Makefile: build/include/sysexits.h depends on include/sysexits.h.template

CONTRIBUTING

@@ -1,29 +1,26 @@
 Make sure to read our code of conduct in the CONDUCT file.
 
-
+When contributing a pull request to the main branch, please sign your commits
-Copyright Information
+with a PGP key and add your name and the year to the bottom of the list of
-=====================
+copyright holders for the file. For example, an existing copyright header might
-
+read:
-When editing a file, create a copyright statement correlated to your
-identity so that it is easier to keep track of who has touched what file.
-Pseudonymous contributions are welcome (and encouraged). Place new copyright
-information below existing copyright information. If there is an existing
-copyright statement:
 
  * Copyright (c) 2022–2023 Emma Tebibyte <emma@tebibyte.media>
 
-you would add your name below it like this:
+You would add your name below it like this:
 
  * Copyright (c) 2022–2023 Emma Tebibyte <emma@tebibyte.media>
  * Copyright (c) 20XX Your Name <your e-mail address or website>
 
+We accept contributions from people using aliases.
+
 Only list years in which you modified the source file. For example:
 
  * Copyright (c) 2020–2021, 2023 Your Name <your-address@example.com>
 
 This header shows that “Your Name” worked on this source file in 2020, 2021, and
-2023. Please use the en dash (“–”, U+2013) to separate consecutive years in the
+2023. Please use the en dash (“–”) to separate the years in the copyright
-copyright notice.
+notice.
 
 If you are contributing a new file, please prepend the following license header
 text to it, replacing the proper text on the copyright line:
@@ -95,263 +92,19 @@ notice:
  *     USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+Make sure lines never exceed 80 columns in width when using four-character
+indentation steps. This helps contributors with smaller screens, those using
+side-by-side editor windows or panes, and those who have no text wrapping in
+their editor or terminal.
 
-Style
+For usage text and help messages, do not implement a -h option. Instead, print
-=====
+usage information when any erroneous option is specified. Follow the NetBSD
+style guide for the usage text’s output format [1].
 
-“Everyone knows that debugging is twice as hard as writing a program in the
+[1] <http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/share/misc/style>
-first place. So if you’re as clever as you can be when you write it, how
-will you ever debug it?”
-	– Brian Kernighan, The Elements of Programming Style
 
-The following guidelines are conducive to clear and readable code that is
+If committing a new source file, format the commit message following these
-consistent with the style of the rest of the Bonsai Computer System.
+guidelines:
-
-Use:
-
- 0. A single line for control flow statements short enough to be easily
- understood at a glance:
-
-	if !(argc < 0) { usage(program_name); }
-
- This applies to C switch statements and cases and Rust match statements, as
- well:
-
-	switch (value) { /* aligning stuff to make it easier to read is fine */
-		case possibility: variable = foo;  break;
-		default:          variable = NULL; break;
-	}
-
- 1. Switch cases in C and match arms in Rust should start another level of
- indentation:
-
-	switch (value) {
-		case possibility:
-			statement;
-			break;
-		default:
-			statement;
-			break;
-	}
-
-	match result {
-		Ok(n) => variable = n,
-		Err(e) => error = e,
-	}
-
- 2. Braces in control flow where their inclusion is left optional in C:
-
-	if (condition) { statement; }
-
- 3. Empty lines between different kinds of statements:
-
-	int t;
-
-	assert(io->bufuse > 0);
-	assert(io->bufuse <= io->bs);
-
-	if ((t = write(io->fd, io->buf, io->bufuse)) < 0) {
-		io->error = errno;
-		t = 0;
-	} else if (t > 0) {
-		memmove(io->buf, &(io->buf)[t], (io->bufuse -= t));
-	}
-
-	io->bytes += t;
-	io->prec  += (t > 0 && io->bufuse > 0);
-	io->rec   += (t > 0 && io->bufuse == 0);
-
-	return io;
-
- 4. Compiler options that yield the most useful warnings, such as -Wpedantic in
- a lot of C compilers. Fix the warnings, too [0].
-
- 5. One more level of indentation and one argument per line when a function
- call or statement header is too long to fit on one line:
-	let usage = format!(
-		"Usage: {} [-d delimiter] index command [args...]",
-		argv[0],
-	);
-
- 6. One more level of indentation than the keyword that initiated a multi-line
- block.
-
-	if (condition) {
-		statement;
-		statement;
-	}
-
- 7. The return value of all non-void functions, or explicitly ignore them (like
- casting to void in C) [0]:
-
-	if ((a = malloc(sizeof char)) == NULL) {          /* handle this error */
-		(void)fprintf(stderr, "oh noes!");   /* explicitly ignore this one */
-		return EX_OSERR;       /* ...because the program is exiting anyway */
-	}
-
- 8. The smallest possible scope for data [0].
-
- 9. Comments noting all the symbols and macros used from a C header file, next
- to its include macro:
-
-	#include <unistd.h> /* close(2), getopt(3), lseek(2), read(2), write(2),
-	(space-aligned)      * optarg, optind, STDIN_FILENO, STDOUT_FILENO */
-
- 10. Spaces in control flow statements, after the keyword and before the
- opening brace:
-
-	for (i = 2; i < argc; ++i) {
-
-
- 11. In Rust, a trailing comma on all arguments or fields that are on their own
- lines:
-
-	return Err(EvaluationError {
-		message: format!("{}: Invalid token", i),
-		code: EX_DATAERR,
-	})
-
- 12. In Rust, place extern statements after use statements that include standard
- library crates. Group like statements:
-
-	use std::fs::Path;
-
-	extern crate strerror;
-	extern crate sysexits;
-
-	use strerror::StrError;
-	use sysexits::{ EX_OSERR, EX_USAGE };
-
- 13. If text is on the same line as a brace, spaces after an opening brace and
- before a closing one:
-
-	use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
-
- 14. Alphabetic sorting, where applicable:
-
-	use std::io::{ BufWriter, Read, Write, stderr, stdin, stdout }
-
- 15. In Rust, use the to_owned() method on string types (str, OsStr, CStr, etc.)
- and the to_string() method on other types.
-
-
-Avoid:
-
- 16. Unbounded loops [0].
-
- 17. Function pointers [0].
-
- 18. Heap memory allocation [0].
-
- 19. Using too much nested logic (within reason).
-
- 20. Too many levels of dereferences [0]:
-
-	/* do not do this */
-	for (size_t i = 0; i < sizeof a / sizeof *a; ++i) {
-		if (a[i].id == MATCH) { a[i].val = 0; }
-	}
-
-	/* do this */
-	for (struct MadeUp *s = &a[0]; *s != NULL; s = &s[1]) {
-		if (s->id == MATCH) { s->val = 0; }
-	}
-
- 21. Using C preprocessor macros; the fewer, the better [0].
-
- 22. The exit(3p) and std::process::exit() functions; returning from the main
- function skips a system call.
-
-
-Do not use:
-
- 23. More than the length of one printed page for a function [0].
-
- 24. Recursion, as it’s complex and can unexpectedly overflow the stack [0].
-
- 25. Any functionality not in the POSIX C specification and language features not
- in C99.
-
- 26. Do-while loops, as they’re unique to C and confusing for casual programmers.
-
- 27. Labels and goto statements; use sensible flow control [0].
-
- 28. Pointer arithmetic, as it tends to be confusing and unnecessary; use
- index-reference patterns like &p[1] instead of p + 1. &p[n] is the address at
- p + sizeof p * n, not p + n, like pointer arithmetic suggests.
-
- 29. C struct bitfields in unions, to access certain bits of bigger data types,
- as it’s poorly defined in the C standards; use bit arithmetic.
-
- 30. C trigraphs.
-
- 31. Inclusions in C header files, to prevent multiple file inclusions.
-
- 32. C preprocessor variables to prevent multiple inclusions of the same file,
- such as:
-
-	#ifdef _FILE
-	#define _FILE
-	/* file body */
-	#endif /* ifdef _FILE */
-
- Instead, take the time to ensure other files aren’t including any files twice.
-
- 33. The gets(3p) function from <stdio.h>, as it’s impossible to prevent buffer
- overflows when it's used; use fgets(3p) from <stdio.h>.
-
- 34. The scanf(3p) function from <stdio.h> [1].
-
- 35. Any functionality not described in the latest POSIX make(1) specification.
-
- 36. Macros which panic on failure in Rust (such as the print!() and println!()
- macros). Use a function and handle any errors. However, do use the eprintln!()
- macro for error messages. Handling an error for writing an error message is
- redundant.
-
- 37. A -h option for help text. Instead, print usage information when any
- erroneous option is specified. See the Usage Text section below.
-
- 38. Lines which exceed 80 columns in width when using four-column indentation
- steps. This helps contributors with smaller screens, those using side-by-side
- editor windows or panes, and those who have no text wrapping in their editor or
- terminal.
-
-
-Usage Text
-==========
-
-This section is adapted from the NetBSD style guide [2].
-
-When programs are invoked incorrectly and in the synopsis of manual pages, uasge
-text should be provided to the user. The following is the format used by this
-project for this purpose:
-
-All optional arguments are to be placed in square brackets (U+005B, U+005D).
-Mutually exclusive arguments can be separated by a vertical line (U+007C).
-Groups of arguments should be specified in alphabetical order in most cases. The
-order of arguments and an example of these rules follows:
-
- 0. Options with no option arguments.
- 1. Options with option arguments. Arguments should be specified inside the same
- square brackets as the options.
- 3. Non-option arguments.
-
-	"usage: f [-aDde] [-b b_arg] [-m m_arg] req1 req2 [opt1 [opt2]]\n"
-	"usage: f [-a | -b] [-c [-de] [-n number]]\n"
-
-
-Committing
-==========
-
-When contributing to Bonsai, please sign your commit with a PGP key and create
-the commit with an identity which can be easily contacted.
-
-If committing a new utility, please include tests and documentation (see
-tests/ and docs/) for the new tool.
-
-
-Format commit messages following these guidelines:
 
 $ git commit -m 'tool(1): add feature x'
 
@@ -377,20 +130,6 @@ $ git commit -m 'tool(1): fix #42 & add feature x'
 
 Commit messages should be written in the present tense.
 
-
-References
-==========
-
-[0] <https://web.eecs.umich.edu/~imarkov/10rules.pdf>
-[1] <http://sekrit.de/webdocs/c/beginners-guide-away-from-scanf.html>
-[2] <http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/share/misc/style>
-
-
 --
-
+This work © 2023–2024 by Emma Tebibyte is licensed under CC BY-SA 4.0. To view a
-Copyright © 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+copy of this license, visit <http://creativecommons.org/licenses/by-sa/4.0/>
-Copyright © 2024 DTB <trinity@trinity.moe>
-Copyright © Wikipedia contributors
-
-This work is licensed under CC BY-SA 4.0. To view a copy of this license, visit
-<http://creativecommons.org/licenses/by-sa/4.0/>.

Makefile

@@ -1,4 +1,4 @@
-# Copyright (c) 2023–2025 Emma Tebibyte <emma@tebibyte.media>
+# Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
 # Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
 # Copyright (c) 2023 Sasha Koshka <sashakoshka@tebibyte.media>
 # Copyright (c) 2024 Aaditya Aryal <aryalaadi123@gmail.com>
@@ -16,36 +16,19 @@
 DESTDIR ?= dist
 PREFIX ?= /usr/local
 
-# for conditionally compiling OS features
+MANDIR != [ $(PREFIX) = / ] && printf '/usr/share/man\n' \
-OS != uname
+	|| printf '/share/man\n'
-OS_INCLUDE != test -e include/$(OS).mk && printf 'include/$(OS).mk\n' \
-	|| printf '/dev/null\n'
-
-# normalized prefix
-PREFIX_N != realpath $(PREFIX)
-MANDIR != test $(PREFIX_N) = / && printf '/usr/share/man\n' \
-	|| printf '$(PREFIX_N)/man\n'
-SYSEXITS != printf '\043include <sysexits.h>\n' | cpp -M - | tr ' ' '\n' \
-	| sed -n 's/sysexits\.h//p' || printf 'include\n'
 
 CC ?= cc
 RUSTC ?= rustc
-RUSTFLAGS += --extern getopt=build/o/libgetopt.rlib \
+RUSTLIBS = --extern getopt=build/o/libgetopt.rlib \
-	--extern strerror=build/o/libstrerror.rlib \
+	--extern sysexits=build/o/libsysexits.rlib \
-	--extern sysexits=build/o/libsysexits.rlib
+	--extern strerror=build/o/libstrerror.rlib
-CFLAGS += -I$(SYSEXITS)
+CFLAGS += -Ibuild/include
-
-# testing requires the absolute path to the bin directory set
-BIN = build/bin
-
-.PHONY: default
-default: all test
 
 .PHONY: all
-all: dj false fileis fop hru intcmp mm npc peek rpn str strcmp swab true
+all: docs dj false fop hru intcmp mm npc rpn scrut str strcmp swab true
 
-# keep build/include until bindgen(1) has stdin support
-# https://github.com/rust-lang/rust-bindgen/issues/2703
 build:
 	mkdir -p build/bin build/docs build/include build/lib build/o build/test
 
@@ -53,29 +36,19 @@ build:
 clean:
 	rm -rf build dist
 
-dist: all docs
+dist: all
-	mkdir -p $(DESTDIR)/$(PREFIX_N)/bin $(DESTDIR)/$(MANDIR)/man1
+	mkdir -p $(DESTDIR)/$(PREFIX)/bin $(DESTDIR)/$(PREFIX)/share/man/man1
-	cp build/bin/* $(DESTDIR)/$(PREFIX_N)/bin
+	cp build/bin/* $(DESTDIR)/$(PREFIX)/bin
-	cp build/docs/*.1 $(DESTDIR)/$(MANDIR)/man1
+	cp build/docs/*.1 $(DESTDIR)/$(PREFIX)/$(MANDIR)/man1
 
 .PHONY: install
 install: dist
 	cp -r $(DESTDIR)/* /
 
-TESTFILES != for file in tests/*.mk; do printf '%s ' "$$file"; done
-
-TESTS != printf '%s\n' "$(TESTFILES)" | xargs -n1 basename \
-	| sed 's/\.mk/_tests/g'
-
-include $(TESTFILES)
-
 .PHONY: test
-test: all $(TESTS) /tmp/getopt
+test: build
-	@echo $(TESTS)
+	tests/posix-compat.sh
-	/tmp/getopt
+	$(RUSTC) --test src/getopt-rs/lib.rs -o build/test/getopt
-
-/tmp/getopt: src/libgetopt.rs
-	$(RUSTC) --test -o /tmp/getopt src/libgetopt.rs
 
 .PHONY: docs
 docs: docs/ build
@@ -84,28 +57,28 @@ docs: docs/ build
 		"s/X\.X\.X/$$(git describe --tags --long | cut -d'-' -f1)/g")"; \
 		sed "s/$$original/$$title/g" <"$$file" >"build/$$file"; done
 
-# include OS feature libraries for compilation
-include $(OS_INCLUDE)
-
 .PHONY: rustlibs
-rustlibs: build/o/libgetopt.rlib build/o/libstrerror.rlib \
+rustlibs: build/o/libsysexits.rlib build/o/libgetopt.rlib \
-	 build/o/libsysexits.rlib $(OSLIB)
+	build/o/libstrerror.rlib
 
-build/o/libgetopt.rlib: build src/libgetopt.rs
+build/include/sysexits.h: build include/sysexits.h.template
+	cpp -dM -include sysexits.h /dev/null \
+			| grep '^.define EX_' >$@ \
+		|| cpp -dM -include stdlib.h include/sysexits.h.template \
+			| grep -e '^.define EX_' -e '^.define EXIT_' >$@
+
+build/o/libgetopt.rlib: build src/getopt-rs/lib.rs
 	$(RUSTC) $(RUSTFLAGS) --crate-type=lib --crate-name=getopt \
-		-o $@ src/libgetopt.rs
+		-o $@ src/getopt-rs/lib.rs
 
-build/o/libstrerror.rlib: build src/libstrerror.rs
+build/o/libstrerror.rlib: build src/strerror.rs
 	$(RUSTC) $(RUSTFLAGS) --crate-type=lib -o $@ \
-		src/libstrerror.rs
+		src/strerror.rs
 
-build/o/libsysexits.rlib: build/include/sysexits.h
+build/o/libsysexits.rlib: build build/include/sysexits.h
-	bindgen --fit-macro-constant-types --default-macro-constant-type unsigned --use-core --formatter=none \
+	<build/include/sysexits.h \
-		build/include/sysexits.h | $(RUSTC) $(RUSTFLAGS) --crate-type lib -o $@ -
+		awk '{ print "pub const " $$2 ": i32 = " $$3 ";"; }' \
-
+		| $(RUSTC) $(RUSTFLAGS) --crate-type lib -o $@ -
-# bandage solution until bindgen(1) gets stdin support
-build/include/sysexits.h: build $(SYSEXITS)sysexits.h
-	printf '\043define EXIT_FAILURE 1\n' | cat - $(SYSEXITS)sysexits.h > $@
 
 .PHONY: dj
 dj: build/bin/dj
@@ -117,45 +90,40 @@ false: build/bin/false
 build/bin/false: src/false.c build
 	$(CC) $(CFLAGS) -o $@ src/false.c
 
-.PHONY: fileis
-fileis: build/bin/fileis
-build/bin/fileis: src/fileis.rs build rustlibs
-	$(RUSTC) $(RUSTFLAGS) -o $@ src/fileis.rs
-
 .PHONY: fop
 fop: build/bin/fop
 build/bin/fop: src/fop.rs build rustlibs
-	$(RUSTC) $(RUSTFLAGS) -o $@ src/fop.rs
+	$(RUSTC) $(RUSTFLAGS) $(RUSTLIBS) -o $@ src/fop.rs
 
 .PHONY: hru
 hru: build/bin/hru
 build/bin/hru: src/hru.rs build rustlibs 
-	$(RUSTC) $(RUSTFLAGS) -o $@ src/hru.rs
+	$(RUSTC) $(RUSTFLAGS) $(RUSTLIBS) -o $@ src/hru.rs
 
 .PHONY: intcmp
 intcmp: build/bin/intcmp
-build/bin/intcmp: src/intcmp.rs build rustlibs
+build/bin/intcmp: src/intcmp.c build
-	$(RUSTC) $(RUSTFLAGS) -o $@ src/intcmp.rs
+	$(CC) $(CFLAGS) -o $@ src/intcmp.c
 
 .PHONY: mm
 mm: build/bin/mm
-build/bin/mm: src/mm.rs build rustlibs 
+build/bin/mm: src/mm.c build
-	$(RUSTC) $(RUSTFLAGS) -o $@ src/mm.rs
+	$(CC) $(CFLAGS) -o $@ src/mm.c
 
 .PHONY: npc
 npc: build/bin/npc
 build/bin/npc: src/npc.c build
 	$(CC) $(CFLAGS) -o $@ src/npc.c
 
-.PHONY: peek
-peek: build/bin/peek
-build/bin/peek: src/peek.c build
-	$(CC) $(CFLAGS) -o $@ src/peek.c
-
 .PHONY: rpn
 rpn: build/bin/rpn
 build/bin/rpn: src/rpn.rs build rustlibs
-	$(RUSTC) $(RUSTFLAGS) -o $@ src/rpn.rs
+	$(RUSTC) $(RUSTFLAGS) $(RUSTLIBS) -o $@ src/rpn.rs
+
+.PHONY: scrut
+scrut: build/bin/scrut
+build/bin/scrut: src/scrut.c build
+	$(CC) $(CFLAGS) -o $@ src/scrut.c
 
 .PHONY: str
 str: build/bin/str
@@ -170,7 +138,7 @@ build/bin/strcmp: src/strcmp.c build
 .PHONY: swab
 swab: build/bin/swab
 build/bin/swab: src/swab.rs build rustlibs
-	$(RUSTC) $(RUSTFLAGS) -o $@ src/swab.rs
+	$(RUSTC) $(RUSTFLAGS) $(RUSTLIBS) -o $@ src/swab.rs
 
 .PHONY: true
 true: build/bin/true

README

@@ -1,29 +1,24 @@
 “Seek not to walk the path of the masters; seek what they sought.”
 – Matsuo Basho
 
-Bonsai’s Harakit is an alternative to the standard POSIX utilities that aims to
+The Bonsai harakit utilities are a replacement for standard POSIX utilities
-be simpler, easier, and more powerful. These tools are the result of careful
+which aim to fill its niche while expanding on their capabilities. These new
-examination of the current state common Unix utilities, POSIX-compliant and
+tools are the result of the careful examination of the current state of POSIX
-otherwise, following frustrations with design decisions and implementation
+and Unix utilies. The Unix Philosophy of “do one thing and do it well” are their
-details. They represent a vision of accomplishing everyday use cases with tools
+core but they avoid clinging to the past.
-that follow the Unix philosophy of “do one thing and do it well” without
-clinging to the past.
 
-The intent of Harakit is not to conform to or extend POSIX, like the GNU or BSD
+The era of the original Unix tools has been long and fruitful, but they have
-utilities do, but to invent new utilities to perform the same tasks in more
+their flaws. This project originated from frustrations with the way certain
-intuitive ways. GNU and BSD extensions are convenient but often unhealthy,
+tools work and how other projects that extend POSIX don’t make anything better.
-forgetting the purposes of the tools they extend, or building into existing
-utilities features that would be more useful as their own tools to be used
-anywhere. Other utility sets aim to provide a number of fully-featured
-programs to be used individually, Harakit utilities are meant to be easily
-composable and work together in pipelines.
 
-See docs/ for more on the specific utilities currently implemented and see
+This project will not follow in the footsteps of GNU; extensions of POSIX will
-CONTRIBUTING for guidelines for contributions.
+not be found here. GNU extensions are a gateway to the misuse of the shell. The
+harakit utilities will intentionally discourage use of the shell for purposes
+beyond its scope.
 
+See docs/ for more on the specific utilities currently implemented.
 
 Building
-========
 
 Harakit utilities require a POSIX-compliant environment to compile, including a
 C compiler and preprocessor (cc(1) and cpp(1) by default), an edition 2023 Rust
@@ -48,22 +43,7 @@ To remove all build and distributable files:
 
 $ make clean
 
-
-Contributing
-============
-
-See the CONTRIBUTING file for contribution guidelines.
-
-
-Community
-=========
-
-xmpp://bonsai@covenant.murderu.us
-irc://feeling.murderu.us/#bonsai
-
-
 Read More
-=========
 
 An Introduction to the Unix Shell
 <https://porkmail.org/era/unix/shell>
@@ -77,10 +57,6 @@ Master Foo Discourses on the Unix-Nature
 Shell Programming!
 <https://tldp.org/LDP/abs/html/why-shell.html>
 
-UNIX Style, or cat -v Considered Harmful
-<http://harmful.cat-v.org/cat-v/>
-
-
 --
 Copyright © 2023–2024 Emma Tebibyte <emma@tebibyte.media>
 Copyright © 2024 DTB <trinity@trinity.moe>

docs/dj.1

@@ -4,24 +4,32 @@
 .\" This work is licensed under CC BY-SA 4.0. To see a copy of this license,
 .\" visit <http://creativecommons.org/licenses/by-sa/4.0/>.
 .\"
-.TH DJ 1 2024-07-14 "Harakit X.X.X"
+.TH DJ 1 2024-06-17 "Harakit X.X.X"
 .SH NAME
 dj \(en disk jockey
 .\"
 .SH SYNOPSIS
 
 dj
-.RB [ -Hn ]
+.RB ( -AdHnq )
-.RB [ -a\ byte ]
+.RB ( -a
-.RB [ -c\ count ]
+.RB [ byte ])
+.RB ( -c
+.RB [ count ])
 
-.RB [ -i\ file ]
+.RB ( -i
-.RB [ -b\ block_size ]
+[\fBinput file\fP])
-.RB [ -s\ offset ]
+.RB ( -b
+[\fBinput block size\fP])
+.RB ( -s
+[\fBinput offset\fP])
 
-.RB [ -o\ file ]
+.RB ( -o
-.RB [ -B\ block_size ]
+[\fBoutput file\fP])
-.RB [ -S\ offset ]
+.RB ( -B
+[\fBoutput block size\fP])
+.RB ( -S
+[\fBoutput offset\fP])
 .\"
 .SH DESCRIPTION
 
@@ -34,109 +42,68 @@ respectively. This language is inherited from the
 .BR dd (1p)
 utility and used here to decrease ambiguity.
 
-The offset used when skipping or seeking refers to how many bytes are skipped
+When seeking or skipping to a byte, writing or reading starts at the byte
-or sought. Running
+immediately subsequent to the specified byte.
-.BR dj (1)
-with a skip offset of 1 skips one byte into the input and reads from the second
-byte onwards. A programmer may think of a file as a zero-indexed array of
-bytes; in this analogy, the offset given is the index of the byte at which to
-start reading or writing.
 .\"
 .SH OPTIONS
 
-.IP \fB-i\fP\ \fIfile\fP
+.IP \fB-i\fP
 Takes a file path as an argument and opens it for use as an input.
-.IP \fB-b\fP\ \fIblock_size\fP
+.IP \fB-b\fP
 Takes a numeric argument as the size in bytes of the input buffer, the default
 being 1024.
 .IP \fB-s\fP
-Takes a numeric argument as the index of the byte at which reading will
+Takes a numeric argument as the number of bytes to skip into the input
-commence; \(lqskips\(rq that number of bytes. If the standard input is used,
+before starting to read. If the standard input is used, bytes read to this point
-bytes read to this point are discarded.
+are discarded.
 .IP \fB-o\fP
 Takes a file path as an argument and opens it for use as an output.
-.IP \fB-B\fP\ \fIblock_size\fP
+.IP \fB-B\fP
-Takes a numeric argument as the size in bytes of the output buffer, the default
+Does the same as
-being 1024. Note that this option only affects the size of output writes and not
+.B -b
-the amount of output data itself. See the CAVEATS section.
+but for the output buffer.
 .IP \fB-S\fP
-Takes a numeric argument as the index of the byte at which writing will
+Seeks a number of bytes through the output before starting to write from
-commence; \(lqseeks\(rq that number of bytes. If the standard output is used,
+the input. If the output is a stream, null characters are printed.
-null characters are printed.
 .IP \fB-a\fP
 Accepts a single literal byte with which the input buffer is padded in the event
-of an incomplete read from the input file. If the option argument is empty, the
+of an incomplete read from the input file.
-null byte is used.
+.IP \fB-A\fP
+Specifying this option pads the input buffer with null bytes in the event of an
+incomplete read. This is equivalent to specifying
+.B -a
+with a null byte instead of a character.
 .IP \fB-c\fP
-Specifies a number of blocks to read. The default is 0, in which case the input
+Specifies a number of reads to make. The default is 0, in which case the
-is read until a partial or empty read is made.
+input is read until a partial or empty read is made.
+.IP \fB-d\fP
+Prints invocation information before program execution as described in the
+DIAGNOSTICS section. Each invocation increments the debug level of the
+program.
 .IP \fB-H\fP
-Prints diagnostic messages in a human-readable manner as described in the
+Prints diagnostics messages in a human-readable manner as described in the
 DIAGNOSTICS section.
 .IP \fB-n\fP
 Retries failed reads once before exiting.
+.IP \fB-q\fP
+Suppresses error messages which print when a read or write is partial or
+empty. Each invocation decrements the debug level of the program.
 .\"
 .SH STANDARD INPUT
 
 The standard input shall be used as an input if no inputs are specified or if
-input file is \(lq-\(rq.
+one or more of the input files is \(lq-\(rq.
 .\"
 .SH STANDARD OUTPUT
 The standard output shall be used as an output if no inputs are specified or if
-the output file is \(lq-\(rq.
+one or more of the input files is \(lq-\(rq.
-.\"
-.SH EXAMPLES
-
-The following
-.BR sh (1p)
-line:
-
-.RS
-printf 'Hello, world!\(rsn' | dj -c 1 -b 7 -s 7 2>/dev/null
-.RE
-
-Produces the following output:
-
-.RS
-world!
-.RE
-
-The following
-.BR sh (1p)
-lines run sequentially:
-
-.RS
-tr '\(rs0' 0    </dev/zero | dj -c 1 -b 6 -o hello.txt
-
-tr '\(rs0' H    </dev/zero | dj -c 1 -b 1 -o hello.txt
-
-tr '\(rs0' e    </dev/zero | dj -c 1 -b 1 -o hello.txt -S 1
-
-tr '\(rs0' l    </dev/zero | dj -c 1 -b 2 -o hello.txt -S 2
-
-tr '\(rs0' o    </dev/zero | dj -c 1 -b 1 -o hello.txt -S 4
-
-tr '\(rs0' '\(rsn' </dev/zero | dj -c 1 -b 1 -o hello.txt -S 5
-
-dj -i hello.txt
-.RE
-
-Produce the following output:
-
-.RS
-Hello
-.RE
-
-It may be particularly illuminating to print the contents of the example
-.B hello.txt
-after each
-.BR dj (1)
-invocation.
 .\"
 .SH DIAGNOSTICS
 
-On a partial or empty read, a diagnostic message is printed. Then, the program
+On a partial or empty read, unless the
-exits unless the
+.B -q
+option is specified, a diagnostic message is printed. Then, the program exits
+unless the
 .B -n
 option is specified.
 
@@ -161,6 +128,20 @@ option may be specified. In this event, the following format is used instead:
 {ASCII line feed}
 .RE
 
+If the
+.B -d
+option is specified, debug information will be printed at the beginning of
+execution. This output contains information regarding how the program was
+invoked. The following example is the result of running the program with
+.B -d
+as the only argument:
+
+.RS
+argv0=dj
+in=<stdin>      ibs=1024        skip=0  align=ff       count=0
+out=<stdout>    obs=1024        seek=0  debug= 3       noerror=0
+.RE
+
 In non-recoverable errors that don\(cqt pertain to the read-write cycle, a
 diagnostic message is printed and the program exits with the appropriate
 .BR sysexits.h (3)
@@ -175,39 +156,23 @@ is specified along with the
 option and a count, actual byte output is the product of the count and the input
 block size and therefore may be lower than expected. If the
 .B -a
-option is specified, this could make written data nonsensical.
+or
+.B -A
+options are specified, this could make written data nonsensical.
 .\"
 .SH CAVEATS
 
 Existing files are not truncated on ouput and are instead overwritten.
 
-Option variants that have lowercase and uppercase forms could be confused for
+Many lowercase options have capitalized variants and vice-versa which can be
-each other. The former affects input and the latter affects output.
+confusing. Capitalized options tend to affect output or are more intense
-
+versions of lowercase options.
-The
-.B -B
-option could be mistaken for the count in bytes of data written to the output.
-This conception is intuitive but incorrect, as the
-.B -c
-option controls the number of blocks to read and the
-.B -b
-option sets the size of the blocks. The
-.B -B
-option is similar to the latter but sets the size of blocks to be written,
-regardless of the amount of data that will actually be written. In practice,
-this means the input buffer should be very large to make use of modern hardware
-input and output speeds.
-
-The skipped or sought bytes while processing irregular files, such as streams,
-are reported in the diagnostic output, because they were actually read or
-written. This is as opposed to bytes skipped while processing regular files,
-which are not reported.
 .\"
 .SH RATIONALE
 
 This program was based on the
 .BR dd (1p)
-utility as specified in \*(Px. While character conversion may have been the
+utility as specified in POSIX. While character conversion may have been the
 original intent of
 .BR dd (1p),
 it is irrelevant to its modern use. Because of this, this program eschews
@@ -222,5 +187,3 @@ Copyright \(co 2023 DTB. License AGPLv3+: GNU AGPL version 3 or later
 .\"
 .SH SEE ALSO
 .BR dd (1p)
-.BR lseek (3p)
-.BR mm (1)

docs/false.1

@@ -15,7 +15,7 @@ always be returned.
 .\"
 .SH RATIONALE
 
-In \*(Px.1-2024,
+In POSIX.1-2017,
 .BR false (1p)
 exists for the construction of control flow and loops based on a failure. This
 implementation functions as described in that standard.

docs/fop.1

@@ -22,7 +22,7 @@ Performs operations on specified fields in data read from the standard input.
 .\"
 .SH OPTIONS
 
-.IP \fB-d\fP\ \fIdelimiter\fP
+.IP \fB-d\fP
 Sets a delimiter by which the input data will be split into fields. The default
 is an ASCII record separator.
 .\"

docs/intcmp.1

@@ -11,7 +11,9 @@ intcmp \(en compare integers
 .SH SYNOPSIS
 
 intcmp
-.RB [ -egl ]\ integer\ integer...
+.RB ( -egl )
+.RB [ integer ]
+.RB [ integer... ]
 .SH DESCRIPTION
 Compare integers to each other.
 .\"
@@ -75,7 +77,7 @@ this is elegant but unintuitive.
 .\"
 .SH RATIONALE
 
-The traditional tool for integer comparisons in \*(Px and other Unix shells has
+The traditional tool for integer comparisons in POSIX and other Unix shells has
 been
 .BR test (1).
 This tool also handles string comparisons and file scrutiny. These parts of its

docs/mm.1

@@ -3,16 +3,18 @@
 .\" This work is licensed under CC BY-SA 4.0. To see a copy of this license,
 .\" visit <http://creativecommons.org/licenses/by-sa/4.0/>.
 .\"
-.TH MM 1 2024-07-14 "Harakit X.X.X"
+.TH MM 1 2024-06-17 "Harakit X.X.X"
 .SH NAME
 mm \(en middleman
 .\"
 .SH SYNOPSIS
 
 mm
-.RB [ -aetu ]
+.RB ( -aenu )
-.RB [ -i\ input ]
+.RB ( -i
-.RB [ -o\ output ]
+.RB [ input ])
+.RB ( -o
+.RB [ output ])
 .\"
 .SH DESCRIPTION
 
@@ -21,25 +23,19 @@ Catenate input files and write them to the start of each output file or stream.
 .SH OPTIONS
 
 .IP \fB-a\fP
-Opens outputs for appending rather than updating.
+Opens subsequent outputs for appending rather than updating.
 .IP \fB-e\fP
 Use the standard error as an output.
-.IP \fB-t\fP
+.IP \fB-i\fP
-Causes outputs to be overwritten instead of being truncated.
+Opens a path as an input. If one or more of the input files is \(lq-\(rq or if
+no inputs are specified, the standard input shall be used.
+.IP \fB-o\fP
+Opens a path as an output. If one or more of the output files is \(lq-\(rq or if
+no outputs are specified, the standard output shall be used.
 .IP \fB-u\fP
 Ensures neither input or output will be buffered.
-.IP \fB-i\fP\ \fIinput\fP
+.IP \fB-n\fP
-Opens a path as an input. If one or more of the input files is \(lq-\(rq or if
+Causes SIGINT signals to be ignored.
-no inputs are specified, the standard input shall be used. If specified as the
-last option and if there are trailing arguments to the program, they shall be
-appended to the list of files to use as inputs.
-.IP \fB-o\fP\ \fIoutput\fP
-Opens a path as an output. If one or more of the output files is \(lq-\(rq or if
-no outputs are specified and the
-.B -e
-option is not specified, the standard output shall be used. If specified as the
-last option and if there are trailing arguments to the program, they shall be
-appended to the list of files to use as outputs.
 .\"
 .SH DIAGNOSTICS
 
@@ -51,13 +47,17 @@ exits with the appropriate
 .BR sysexits.h (3)
 status.
 .\"
+.SH CAVEATS
+
+Existing files are not truncated on ouput and are instead overwritten.
+.\"
 .SH RATIONALE
 
 The
 .BR cat (1p)
 and
 .BR tee (1p)
-programs specified in \*(Px together provide similar functionality. The
+programs specified in POSIX together provide similar functionality. The
 separation of the two sets of functionality into separate APIs seemed
 unncessary.
 .\"

docs/npc.1

@@ -11,7 +11,7 @@ npc \(en show non-printing characters
 .SH SYNOPSIS
 
 npc
-.RB [ -et ]
+.RB ( -et )
 .\"
 .SH DESCRIPTION
 
@@ -45,7 +45,7 @@ The program operates in single-byte chunks regardless of intended encoding.
 .\"
 .SH RATIONALE
 
-\*(Px currently lacks a way to display non-printing characters in the terminal
+POSIX currently lacks a way to display non-printing characters in the terminal
 using a standard tool. A popular extension to
 .BR cat (1p),
 the

docs/peek.1

@@ -1,111 +0,0 @@
-.\" Copyright (c) 2023-2024 DTB <trinity@trinity.moe>
-.\" Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-.\"
-.\" This work is licensed under CC BY-SA 4.0. To see a copy of this license,
-.\" visit <http://creativecommons.org/licenses/by-sa/4.0/>.
-.\"
-.TH PEEK 1 2024-08-14 "Harakit X.X.X"
-.SH NAME
-peek \(en read from the standard input, furtively
-.\"
-.SH SYNOPSIS
-
-peek
-.RB [ -i ]
-.\"
-.SH DESCRIPTION
-
-Read input from the standard input with terminal echo disabled.
-.\"
-.SH OPTIONS
-
-.IP \fB-i\fP
-Allows input to come from sources other than terminals (pipes).
-.\"
-.SH DIAGNOSTICS
-
-In the event of an error, a debug message will be printed and the program will
-exit with the appropriate
-.BR sysexits.h (3)
-error code.
-
-In order to ensure the user\(cqs terminal is still usable after premature
-termination, the program attempts to handle the SIGINT signal; if it cannot,
-an error message is printed and execution continues. If the program is
-interrupted, it exits unsuccessfully without an error message.
-.\"
-.SH RATIONALE
-
-This tool was originally written to accept passwords in shell scripts as an
-extremely simple alternative to the GNU Privacy Guard project\(cqs
-.BR pinentry (1)
-utility.
-
-Accepting input without showing what is being typed is useful when keying in
-secrets in public settings or in places where surveillance cameras are
-installed.
-.\"
-.SH CAVEATS
-
-This program does nothing to prevent others from seeing the key presses input to
-a keyboard. It also does not protect against the sound of typing being analyzed
-to determine what was input without needing to see screen or keyboard.
-
-Accepting secrets in shell scripts is probably not advisable.
-
-On systems that support it, the
-.BR ioctl (2)
-command TIOCSTI can be used to insert characters into the standard input. This
-doesn't allow snooping but can be used for general mischief.
-.\"
-.SH EXAMPLES
-
-This is an
-.BR sh (1p)
-command line that hashes a given password. It uses
-.BR head (1p)
-to only accept one line of input,
-.BR xargs (1p)
-and
-.BR printf (1p)
-to strip the trailing newline,
-.BR htpasswd (1) 
-from Apache\(cqs utilities to hash the input with the bcrypt algorithm, and
-.BR cut (1p)
-to print only the resulting hash:
-
-.RS
-$ peek | head -n 1 | xargs printf '%s' | htpasswd -nBi _ | cut -d : -f 2
-.RE
-
-This is an
-.BR sh (1p)
-command line that allows a user to write blindly into a text file but displaying
-only written lines. Some writers have the habit of prematurely revising their 
-work and use tools with functionality similar to this to prevent it. 
-It uses
-.BR mm (1)
-to pipe the output of the program to both the standard error and the regular
-file writing.txt:
-
-.RS
-$ echo Input ^D to quit. && peek | mm -eo - >writing.txt
-.RE
-.\"
-.SH AUTHOR
-
-Written by DTB
-.MT trinity@trinity.moe
-.ME .
-.\"
-.SH COPYRIGHT
-
-Copyright \(co 2023-2024 DTB. License AGPLv3+: GNU AGPL version 3 or later
-<https://gnu.org/licenses/gpl.html>.
-.\"
-.SH SEE ALSO
-.BR ioctl (2),
-.BR ioctl_tty (2),
-.BR read (1p),
-.BR sh (1p),
-.BR stty (1p)

docs/rpn.1

@@ -58,7 +58,7 @@ hardware of any given machine.
 
 An infix notation calculation utility,
 .BR bc (1p),
-is included in the \*(Px standard, but does not accept expressions as arguments;
+is included in the POSIX standard, but does not accept expressions as arguments;
 in scripts, any predefined, non-interactive input must be piped into the
 program. A
 .BR dc (1)

docs/scrut.1

@@ -1,17 +1,17 @@
 .\" Copyright (c) 2024 DTB <trinity@trinity.moe>
-.\" Copyright (c) 2024–2025 Emma Tebibyte <emma@tebibyte.media>
+.\" Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
 .\"
 .\" This work is licensed under CC BY-SA 4.0. To see a copy of this license,
 .\" visit <http://creativecommons.org/licenses/by-sa/4.0/>.
 .\"
-.TH FILEIS 1 2025-02-24 "Harakit X.X.X"
+.TH SCRUT 1 2024-06-06 "Harakit X.X.X"
 .SH NAME
-fileis \(en scrutinize file properties
+scrut \(en scrutinize file properties
 .SH SYNOPSIS
 
-fileis
+scrut
-.RB [ -LSbcdefgkprsuwx ]
+.RB ( -LSbcdefgkprsuwx )
-.B file...
+.RB [ file... ]
 .\"
 .SH DESCRIPTION
 
@@ -82,6 +82,5 @@ Copyright \(co 2024 DTB. License AGPLv3+: GNU AGPL version 3 or later
 .\"
 .SH SEE ALSO
 .BR access (3p),
-.BR chown (1p),
 .BR lstat (3p),
 .BR test (1p)

docs/str.1

@@ -11,7 +11,8 @@ str \(en test string arguments
 .SH SYNOPSIS
 
 str
-.B type string...
+.RB [ type ]
+.RB [ string... ]
 .\"
 .SH DESCRIPTION
 

docs/strcmp.1

@@ -4,14 +4,15 @@
 .\" This work is licensed under CC BY-SA 4.0. To see a copy of this license,
 .\" visit <http://creativecommons.org/licenses/by-sa/4.0/>.
 .\"
-.TH STRCMP 1 2024-07-15 "Harakit X.X.X"
+.TH STRCMP 1 2024-06-17 "Harakit X.X.X"
 .SH NAME
 strcmp \(en compare strings
 .\"
 .SH SYNOPSIS
 
 strcmp
-.B string string...
+.RM [ string ]
+.RB [ strings... ]
 .\"
 .SH DESCRIPTION
 
@@ -20,15 +21,15 @@ Check whether string arguments are the same.
 .SH DIAGNOSTICS
 
 The program will exit successfully if the strings are identical. Otherwise, it
-will exit with an error code less than 128 if a string passed has a lesser byte
+will exit with an error code of 1 if a string passed has a lesser byte value
-value than one of the prior strings:
+than one of the prior strings:
 
 .RS
 strcmp b a
 .RE
 
-or with an error code greater than 128 if it has a greater byte value than one
+or with an error code of 255 if it has a greater byte value than one of the
-of the prior strings:
+prior strings:
 
 .RS
 strcmp a b
@@ -47,13 +48,13 @@ visual similarity and not byte similarity.
 .\"
 .SH RATIONALE
 
-The traditional tool for string comparisons in \*(Px and other Unix shells has
+The traditional tool for string comparisons in POSIX and other Unix shells has
 been
 .BR test (1).
 This tool also handles integer comparisons and file scrutiny. These parts of its
 functionality have been broken out into multiple utilities.
 
-This program\(cqs functionality may be performed on a \*(Px-compliant system
+This program\(cqs functionality may be performed on a POSIX-compliant system
 with
 .BR test (1p).
 .\"

docs/swab.1

@@ -11,7 +11,11 @@ swab \(en swap bytes
 .SH SYNOPSIS
 
 swab
-.RB [ -w\ word_size ]
+.RB ( -f )
+.RB ( -w
+.R [
+.B word size
+.R ])
 .\"
 .SH DESCRIPTION
 
@@ -19,10 +23,13 @@ Swap the latter and former halves of a block of bytes.
 .\"
 .SH OPTIONS
 
-.IP \fB-w\fP\ \fIword_size\fP
+.IP \fB-f\fP
-Configures the word size; that is, the size in bytes of the block size on which
+Ignore SIGINT signal.
-to operate. The default word size is 2. The word size must be cleanly divisible
+.IP \fB-w\fP
-by 2, otherwise the block of bytes being processed can\(cqt be halved.
+Configures the word size; that is, the size in bytes of the block size
+on which to operate. The default word size is 2. The word size must be
+cleanly divisible by 2, otherwise the block of bytes being processed can\(cqt be
+halved.
 .\"
 .SH EXAMPLES
 
@@ -33,7 +40,6 @@ line:
 .RS
 printf 'hello world!\(rsn' | swab
 .RE
-.\" If you change this, make sure to change it in tests/bonsai/swab.mk too.
 
 Produces the following output:
 

docs/true.1

@@ -15,7 +15,7 @@ always be returned.
 .\"
 .SH RATIONALE
 
-In \fI\*(Px.1-2024\fP,
+In \fIPOSIX.1-2017\fP,
 .BR true (1p)
 exists for the construction of control flow and loops based on a success. This
 implementation functions as described in that standard.

include/FreeBSD.mk

@@ -1,6 +0,0 @@
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.

include/OpenBSD.mk

@@ -1,13 +0,0 @@
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-OSLIB = build/o/libopenbsd.rlib
-RUSTFLAGS += --extern openbsd=$(OSLIB)
-
-$(OSLIB): src/libopenbsd.rs
-	$(RUSTC) $(RUSTFLAGS) --crate-type=lib --crate-name=openbsd \
-		-o $@ src/libopenbsd.rs

src/dj.c

@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2024 DTB <trinity@trinity.moe>
- * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  *
  * This program is free software: you can redistribute it and/or modify it under
@@ -17,422 +16,437 @@
  * along with this program. If not, see https://www.gnu.org/licenses/.
  */
 
-#include <assert.h> /* assert(3) */
+#include <ctype.h> /* isupper(3), tolower(3) */
 #include <errno.h> /* errno */
 #include <fcntl.h> /* open(2) */
-#include <stdbool.h> /* bool */
 #include <stdio.h> /* fprintf(3), stderr */
-#include <stdlib.h> /* malloc(3), strtol(3), size_t */
+#include <stdlib.h> /* free(3), malloc(3), strtol(3), size_t */
 #include <string.h> /* memcpy(3), memmove(3), memset(3) */
-#include <sysexits.h> /* EX_OK, EX_OSERR, EX_USAGE */
+#include <sysexits.h> /* EX_OK, EX_USAGE */
 #include <unistd.h> /* close(2), getopt(3), lseek(2), read(2), write(2),
-                     * pledge(2), unveil(2), optarg, optind, STDIN_FILENO,
+                     * optarg, optind, STDIN_FILENO, STDOUT_FILENO */
-					 * STDOUT_FILENO */
+extern int errno;
-#include <sys/stat.h> /* S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR */
-
-char *program_name = "dj";
 
 /* dj uses two structures that respectively correspond to the reading and
  * writing ends of its jockeyed "pipe". User-configurable members are noted
  * with their relevant options. */
-struct Io {
+struct Io{
-	char *buf;      /* buffer */
+	int bs;			/* buffer size (-bB) */
-	char *fn;       /* file name (-io) */
-	size_t bs;    	/* buffer size (-bB) */
 	size_t bufuse;	/* buffer usage */
-	size_t bytes; 	/* bytes processed */
+	char *buf;		/* buffer */
-	size_t prec;  	/* partial records processed */
+	int bytes;		/* bytes processed */
-	size_t rec;   	/* records processed */
+	int fd;			/* file descriptor */
-	long seek;  	/* remaining bytes to seek/skip (-sS) */
+	int fl;			/* file opening flags */
-	int error;  	/* errno */
+	char *fn;		/* file name (may be stdin_name or stdout_name) (-io) */
-	int fd;         /* file descriptor */
+	int prec;		/* partial records processed */
-	int fl;         /* file opening flags */
+	int rec;		/* records processed */
-};
+	long seek;		/* bytes to seek/skip (will be 0 after skippage) (-sS) */
+} ep[2]; /* "engineered pipe"; also "extended play", for the deejay */
 
+/* Additionally, the following global variables are used to store user options.
+ */
+
+/* (-a)  */ static int align; /* Only the lower 8b are used but align is
+                               * negative if no alignment is being done. */
+
+/* (-c)  */ static int count; /* 0 if dj(1) runs until no more reads are
+                               * possible. */
+
+/* ASCII field separator delimited statistics */
+            static char *fmt_asv   = "%d\037%d\036%d\037%d\035%d\036%d\034";
+/* human-readable statistics */
+            static char *fmt_human = "%d+%d > %d+%d; %d > %d\n";
+/* pointer to chosen formatting */
+/* (-H)  */ static char *fmt_output; /* fmt_asv (default) or fmt_human (-H) */
+
+/* (-dq) */ static char debug;       /*
+ *  -d  increments             dj -qq | 0 - no diagnostic output whatsoever
+ *   -q decrements             dj -q  | 1 - typical output without
+ *                                    |     notifications on partial reads or
+ *                                    |     writes
+ *                             dj     | 2 - typical output (default)
+ *                             dj -d  | 3 - verbose status messages */
+
+/* (-n)  */ static char noerror;     /* 0 - exits on partial reads or writes
+                                      *     (default)
+                                      * 1 - retries on partial reads/writes
+                                      *     (-n) */
+
+/* Non-configurable defaults. */
+#define bs_default 1024 /* GNU dd(1) default; twice POSIX but a neat 2^10 */
+static char *program_name = "<no argv[0]>";
 static char *stdin_name = "<stdin>";
 static char *stdout_name = "<stdout>";
+static int read_flags = O_RDONLY; /* These flags are consistent with Busybox */
+static int write_flags = O_WRONLY | O_CREAT; /* dd(1). */
 
-static int creat_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH
+/* Macro to set defaults for user-configurable options. */
-	| S_IWOTH; /* Consistent with touch(1p). */
+#define setdefaults do{ \
-static int read_flags = O_RDONLY; /* Consistent with Busybox dd(1). */
+	align = -1; \
-static int write_flags = O_WRONLY | O_CREAT;
+	count = 0; \
+	debug = 2; \
+	fmt_output = fmt_asv; \
+	noerror = 0; \
+	ep[0].fl = read_flags; \
+	Io_setdefaults(&ep[0]); \
+	ep[1].fl = write_flags; \
+	Io_setdefaults(&ep[1]); }while(0)
 
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 
-/* Macro to check if fd is stdin or stdout */
+/* Macro to check if fd is a std* file, e.g. stdin. */
-#define fdisstd(fd) ((fd) == STDIN_FILENO || (fd) == STDOUT_FILENO)
+#define fdisstd(fd) \
+		((fd) == STDIN_FILENO \
+		|| (fd) == STDOUT_FILENO \
+		|| (fd) == STDERR_FILENO)
 
-/* Completes one Io block read */
+/* Macro to call the cleanup functions that operate on struct io on the
+ * particular io[2] used in main. Error conditions are not checked because this
+ * is only used when the program is about to terminate (hence its name). */
+#define terminate(io) do{ \
+	Io_buffree(&(io)[0]); \
+	Io_buffree(&(io)[1]); \
+	Io_fdclose(&(io)[0]); \
+	Io_fdclose(&(io)[1]); }while(0)
+
+/* Allocates *io's buffer. Returns NULL if unsuccessful. */
+static void *
+Io_bufalloc(struct Io *io){
+
+	return (io->buf = malloc(io->bs * (sizeof *io->buf)));
+}
+
+/* Frees *io's buffer. Returns io. */
 static struct Io *
-Io_read(struct Io *io) {
+Io_buffree(struct Io *io){
-	int t;
 
-	assert(io->bs > 0);
+	free(io->buf);
-	assert(io->bufuse < io->bs);
-
-	if ((t = read(io->fd, &(io->buf)[io->bufuse], io->bs - io->bufuse)) < 0) {
-		io->error = errno;
-		t = 0;
-	}
-
-	io->bufuse += t;
-	io->bytes  += t;
-	io->prec   += (0 < io->bufuse && io->bufuse < io->bs);
-	io->rec    += (io->bufuse == io->bs);
-
-	assert(io->bufuse <= io->bs);
 
 	return io;
 }
 
-/* Completes one Io block write */
+/* Fills the unused portion of io's buffer with padding, updating io->bufuse.
+ * Returns io. */
 static struct Io *
-Io_write(struct Io *io) {
+Io_bufrpad(struct Io *io, int padding){
-	int t;
+	
-
+	memset(io->buf + io->bufuse, padding, io->bs - io->bufuse);
-	assert(io->bufuse > 0);
+	io->bufuse = io->bs;
-	assert(io->bufuse <= io->bs);
-
-	if ((t = write(io->fd, io->buf, io->bufuse)) < 0) {
-		io->error = errno;
-		t = 0;
-	} else if (t > 0) {
-		(void)memmove(io->buf, &(io->buf)[t], (io->bufuse -= t));
-	}
-
-	io->bytes += t;
-	io->prec  += (t > 0 && io->bufuse > 0);
-	io->rec   += (t > 0 && io->bufuse == 0);
 
 	return io;
 }
 
+/* Copies from the buffer in src as much as possible to the free space in the
+ * dest buffer, removing the copied units from src and permuting the remaining
+ * units in the src buffer to the start of the buffer, modifying both the src
+ * and dest bufuse and returning dest. */
+static struct Io*
+Io_bufxapp(struct Io *dest, struct Io *src){
+	int n;
+
+	n = MIN(src->bufuse, dest->bs - dest->bufuse);
+	memcpy(dest->buf + dest->bufuse, src->buf, n);
+	dest->bufuse += n;
+	memmove(src->buf, src->buf + n, src->bs - n);
+	src->bufuse -= n;
+
+	return dest;
+}
+
+/* Copies from the buffer in src to the buffer in dest no more than n units,
+ * removing the copied units from src and permuting the remaining units in the
+ * src buffer to the start of the buffer, modifying both the src and dest
+ * bufuse and returning dest. */
+static struct Io*
+Io_bufxfer(struct Io *dest, struct Io *src, int n){
+
+	memcpy(dest->buf, src->buf, (dest->bufuse = n));
+	memmove(src->buf, src->buf + n, (src->bufuse -= n));
+
+	return dest;
+}
+
+/* Closes io->fn and returns -1 on error, otherwise io->fd. */
 static int
-oserr(char *e, int n) { /* program_name: [failing component:] error */
+Io_fdclose(struct Io *io){
-	(void)fprintf(stderr, "%s: ", program_name);
+
-	if (e != NULL) { (void)fprintf(stderr, "%s: ", e); }
+	return fdisstd(io->fd)
-	(void)fprintf(stderr, "%s\n", strerror(n));
+		? 0
+		: close(io->fd);
+}
+
+/* Opens io->fn and saves the file descriptor into io->fd. Returns io->fd,
+ * which will be -1 if an error occured. */
+static int
+Io_fdopen(struct Io *io, char *fn){
+	int fd;
+	
+	if((fd = open(fn, io->fl,
+					/* these are the flags used by touch(1p) */
+					S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH))
+				!= -1
+			&& Io_fdclose(io) == 0){
+		io->fd = fd;
+		io->fn = fn;
+	}
+
+	return fd;
+}
+
+/* Seeks io->seek bytes through *io's file descriptor, (counter-intuitively)
+ * returning -1 if successful and a sysexits.h exit code if an unrecoverable
+ * error occurred. io->buf will be cleared of useful bytes and io->seek will
+ * be set to zero to indicate the seek occurred. */
+static int
+Io_fdseek(struct Io *io){
+	int (*op)(int, void *, size_t);
+	
+	if(!fdisstd(io->fd) && lseek(io->fd, io->seek, SEEK_SET) != -1)
+		return -1;
+
+	/* repeated code to get the condition out of the loop */
+	if(io->fl == write_flags){
+		memset(io->buf, '\0', io->bs);
+		/* We're going to cheat and use bufuse as the retval for write(2),
+		 * which is fine because it'll be zeroed as this function returns
+		 * anyway. */
+		do{
+			if((io->bufuse = write(io->fd, io->buf, MIN(io->bs, io->seek)))
+					== 0)
+				/* second chance */
+				io->bufuse = write(io->fd, io->buf, MIN(io->bs, io->seek));
+		}while((io->seek -= io->bufuse) > 0 && io->bufuse != 0);
+	}else if(io->fl == read_flags){
+		do{
+			if((io->bufuse = read(io->fd, io->buf, MIN(io->bs, io->seek)))
+					== 0)
+				/* second chance */
+				io->bufuse = read(io->fd, io->buf, MIN(io->bs, io->seek));
+		}while((io->seek -= io->bufuse) > 0 && io->bufuse != 0);
+	}else
+		return EX_SOFTWARE;
+
+	io->bufuse = 0;
+
+	return -1;
+}
+
+/* Reads io->bs bytes from *io's file descriptor into io->buf, storing the
+ * number of read bytes in io->bufuse and updating io->bytes. If io->bufuse is
+ * 0, errno will probably be set. Returns io. */
+static struct Io *
+Io_read(struct Io *io){
+
+	io->bytes += (io->bufuse = read(io->fd, io->buf, io->bs));
+
+	return io;
+}
+
+/* Sets the variables in a struct *io to the defaults. Identifies the read/
+ * write ends of the "pipe" by checking io->fl. Returns io. */
+static struct Io *
+Io_setdefaults(struct Io *io){
+
+	io->bs = bs_default;
+	io->buf = NULL;
+	io->bytes = 0;
+	io->fd = (io->fl == read_flags) ? STDIN_FILENO : STDOUT_FILENO;
+	io->fn = (io->fl == read_flags) ? stdin_name   : stdout_name;
+	io->prec = 0;
+	io->rec = 0;
+	io->seek = 0;
+
+	return io;
+}
+
+/* Writes io->bufuse units from io->buf to io->fd, permuting any unwritten
+ * bytes to the start of io->buf and updating io->bufuse. If io->bufuse doesn't
+ * change, errno will probably be set. Returns io. */
+static struct Io *
+Io_write(struct Io *io){
+	int t;
+
+	if((t = write(io->fd, io->buf, io->bufuse)) > 0)
+		memmove(io->buf, io->buf + t, (io->bufuse -= t));
+	io->bytes += t;
+
+	return io;
+}
+
+/* Prints an error message suitable for the event of an operating system error,
+ * with the error itself to be described in the string s. */
+static int
+oserr(char *s){
+
+	fprintf(stderr, "%s: %s: %s\n", program_name, s, strerror(errno));
 
 	return EX_OSERR;
 }
 
 /* Prints statistics regarding the use of dj, particularly partially and
- * completely read and written records. */
+ * completely read and written records, accessing debug, ep, and fmt_output. */
-static int
+static void
-fprintio(FILE *stream, char *fmt, struct Io io[2]) {
+output(void){
-	return fprintf(
-		stream,
-		fmt,
-		io[0].rec,
-		io[0].prec,
-		io[1].rec,
-		io[1].prec,
-		io[0].bytes,
-		io[1].bytes
-	);
-}
 
-/* To be assigned to main:fmt and used with printio(). */
+	if(debug >= 1)
-static char *fmt_asv =
+		fprintf(stderr, fmt_output,
-	"%d" /* io[0].rec   */ "\037" /* ASCII US */
+			ep[0].rec, ep[0].prec, ep[1].rec, ep[1].prec,
-	"%d" /* io[0].prec  */ "\036" /* ASCII RS */
+			ep[0].bytes, ep[1].bytes);
-	"%d" /* io[1].rec   */ "\037" /* ASCII US */
+
-	"%d" /* io[1].prec  */ "\035" /* ASCII GS */
+	return;
-	"%d" /* io[0].bytes */ "\036" /* ASCII RS */
+}
-	"%d" /* io[1].bytes */ "\034" /* ASCII FS */
-	"\n"
-;
-static char *fmt_human = "%d+%d > %d+%d; %d > %d\n";
 
 /* Parses the string s to an integer, returning either the integer or in the
  * case of an error a negative integer. This is used for argument parsing
  * (e.g. -B [int]) in dj and no negative integer would be valid anyway. */
 static long
-parse(char *s) {
+parse(char *s){
 	long r;
 
 	errno = 0;
 	r = strtol(s, &s, 0);
-	return (*s == '\0' /* no chars left unparsed */ && errno == 0) ? r : -1;
+	return (*s == '\0' /* no chars left unparsed */ && errno == 0)
+		? r
+		: -1;
 }
 
 static int
-usage(char *argv0) {
+usage(void){
-	(void)fprintf(
+
-		stderr,
+	fprintf(stderr, "Usage: %s (-AdfHqQ) (-a [byte]) (-c [count])\n"
-		"Usage: %s [-Hn] [-a byte] [-c count]\n"
+		"\t(-i [input file]) (-b [input block size]) (-s [input offset])\n"
-		"\t[-i file] [-b block_size] [-s offset]\n"
+		"\t(-o [output file]) (-B [output block size]) (-S [output offset])\n",
-		"\t[-o file] [-B block_size] [-S offset]\n",
+		program_name);
-		argv0
-	);
 
 	return EX_USAGE;
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[]){
-   	int align;    /* low 8b used, negative if no alignment is being done */
+	int c;
-	int count;    /* -1 if dj(1) runs until no more reads are possible */
+	int i;
-	char *fmt;    /* set to fmt_asv (default) or fmt_human (-H) */
-	size_t i;     /* side of io (in or out) being modified */
-	bool retry;   /* false if exits on partial reads or writes */
-	struct Io io[2 /* { in, out } */];
 
-#ifdef __OpenBSD__
+	setdefaults;
-	if (pledge("cpath rpath stdio unveil wpath", NULL) == -1) {
-		return oserr(NULL, errno);
-	}
-#endif
-
-	/* Set defaults. */
-	align = -1;
-	count = -1;
-	fmt = fmt_asv;
-	retry = 0;
-	for (i = 0; i < (sizeof io) / (sizeof *io); ++i) {
-		io[i].bs = 1024 /* 1 KiB */; /* GNU dd(1) default; POSIX says 512B */
-		io[i].bufuse = 0;
-		io[i].bytes = 0;
-		io[i].fd = i == 0 ? STDIN_FILENO : STDOUT_FILENO;
-		io[i].fn = i == 0 ? stdin_name   : stdout_name;
-		io[i].fl = i == 0 ? read_flags   : write_flags;
-		io[i].error = 0;
-		io[i].prec = 0;
-		io[i].rec = 0;
-		io[i].seek = 0;
-	}
-
-	if (argc > 0) {
-		int c;
 
+	if(argc > 0){
 		program_name = argv[0];
-		while ((c = getopt(argc, argv, "a:b:B:c:i:hHns:S:o:")) != -1) {
+		while((c = getopt(argc, argv, "a:Ab:B:c:di:hHnqs:S:o:")) != -1)
-			switch (c) {
+			switch(c){
-				case 'i': case 'o': /* input, output */
+			case 'i': case 'o':
-					i = (c == 'o');
+				i = (c == 'o');
-
+				if(optarg[0] == '-' && optarg[1] == '\0'){ /* optarg == "-" */
-					/* optarg == "-" (stdin/stdout) */
+					ep[i].fd = (i == 0) ? STDIN_FILENO : STDOUT_FILENO;
-					if (optarg[0] == '-' && optarg[1] == '\0') { 
+					ep[i].fn = (i == 0) ? stdin_name   : stdout_name;
-						io[i].fd = i == 0 ? STDIN_FILENO : STDOUT_FILENO;
+					break;
-						io[i].fn = i == 0 ? stdin_name   : stdout_name;
+				}else if(Io_fdopen(&ep[i], optarg) != -1)
-						break;
+					break;
-					} else {
+				terminate(ep);
-						int fd;
+				return oserr(optarg);
-
+			case 'A': align = '\0'; break;
-#ifdef __OpenBSD__
+			case 'd': ++debug; break;
-						if (unveil(optarg, i == 0 ? "r" : "wc") == -1) {
+			case 'n': noerror = 1; break;
-							return oserr(NULL, errno);
+			case 'H': fmt_output = fmt_human; break;
-						}
+			case 'q': --debug; break;
-#endif
+			case 'a':
-
+				if(optarg[0] != '\0' && optarg[1] == '\0'){
-						if (
+					align = optarg[0];
-							(fd = open(optarg, io[i].fl, creat_mode)) != -1
-							&& (fdisstd(io[i].fd) || close(io[i].fd) == 0)
-						) {
-							io[i].fd = fd;
-							io[i].fn = optarg;
-							break;
-						}
-					}
-
-					return oserr(optarg, errno);
-					/* UNREACHABLE */
-				case 'n': retry = 1; break; /* retry failed reads once */
-				case 'H': fmt = fmt_human; break; /* human-readable output */
-				case 'a': /* input buffer padding */
-					if (optarg[0] == '\0' || optarg[1] == '\0') {
-						align = optarg[0];
-						break;
-					}
-					/* FALLTHROUGH */
-				case 'c': /* number of reads */
-				case 'b': case 'B': /* input/output block size */
-				case 's': case 'S': /* (s)kip/(S)eek in input/output */
-					if (c == 'c' && (count = parse(optarg)) >= 0) { break; }
-
-					i = (c >= 'A' && c <= 'Z');
-					c |= 0x20; /* 0b 0010 0000 (ASCII) make lowercase */
-
-					if ( /* if -b or -s is parsed out correctly */
-						(c == 'b' && (io[i].bs = parse(optarg)) > 0)
-						|| (c == 's' && (io[i].seek = parse(optarg)) >= 0)
-					) { break; } /* don't error */
-
-					/* FALLTHROUGH */
-				default:
-					return usage(program_name);
-			}
-		}
-	}
-
-#ifdef __OpenBSD__
-	if (unveil(NULL, NULL) == -1) { return oserr(NULL, errno); }
-#endif
-
-	assert(io->fd != STDIN_FILENO  || io->fl == read_flags);
-	assert(io->fd != STDOUT_FILENO || io->fl == write_flags);
-
-	if (argc > optind) { return usage(program_name); }
-
-	for (i = 0; i < (sizeof io) / (sizeof *io); ++i) {
-		/* buffer allocation */
-		if ((io[i].buf = malloc(io[i].bs * (sizeof *(io[i].buf)))) == NULL) {
-			(void)fprintf(
-				stderr, "%s: Failed to allocate %zd bytes\n",
-				program_name, io[i].bs
-			);
-			return EX_OSERR;
-		}
-
-		/* easy seeking */
-		if (!fdisstd(io[i].fd) && lseek(io[i].fd, io[i].seek, SEEK_SET) != -1) {
-			io[i].seek = 0;
-		}
-	}
-
-	assert(io[1].bufuse == 0); /* requirement for hard seeking */
-
-	/* hard seeking; t is io[1].bufuse, before Io_write subtracts from it */
-	for(size_t t; io[1].seek > 0; io[1].seek -= (t - io[1].bufuse)) {
-		(void)memset(
-			io[1].buf, '\0', /* set buf to all nulls */
-			(t = io[1].bufuse = MIN(io[1].bs, io[1].seek)) /* saturate block */
-		);
-
-		if (Io_write(&io[1])->bufuse == t && !retry && io[1].error == 0) {
-			(void)Io_write(&io[1]); /* second chance */
-		}
-
-		if (io[1].error != 0) { return oserr(io[1].fn, io[1].error); }
-
-		if (io[1].bufuse == t) { break; } /* all writes failed! */
-	}
-
-	io[1].bufuse = 0; /* reset after hard seek */
-
-	if (io[1].seek > 0) { /* hard seeking failed */
-		(void)fprintio(stderr, fmt, io);
-		return oserr(io[1].fn, errno);
-	}
-
-	for (	;
-			count == -1 || count > 0;
-			count -= (count != -1) /* decrement if counting */
-	) {
-		assert(io[0].bufuse == 0);
-
-		{ /* read */
-			long skipping;
-			size_t t;
-
-			/* hack to intentionally get a partial read from Io_read */
-			if ((skipping = MIN(io[0].seek, io[0].bs)) > 0) {
-				io[0].bufuse = io[0].bs - (size_t)skipping;
-			}
-
-			t = io[0].bufuse;
-			if (Io_read(&io[0])->bufuse == t && !retry && io[0].error == 0) {
-				(void)Io_read(&io[0]); /* second chance */
-			}
-
-			assert(io[0].bufuse >= t);
-
-			if (io[0].bufuse == t) { break; } /* that's all she wrote */
-
-			if (/* t < io[0].bufuse && */ io[0].bufuse < io[0].bs) {
-				(void)fprintf(stderr, "%s: Partial read:\n\t", program_name);
-				(void)fprintio(stderr, fmt, io);
-
-				if (!retry) { count = 1; }
-
-				if (align >= 0) {
-					/* fill the rest of the ibuf with padding */
-					(void)memset(
-						&(io[0].buf)[io[0].bufuse],
-						align,
-						io[0].bs - io[0].bufuse
-					);
-
-					io->bufuse = io->bs;
-				}
-			}
-
-			if (skipping > 0) {
-				io[0].seek -= skipping;
-				io[0].bufuse = 0;
-				count += (count != -1); /* increment if counting */
-				continue;
-			}
-		}
-
-		assert(io[0].bufuse > 0);
-
-		while (io[0].bufuse > 0) { /* write */
-			if (io[0].bs <= io[1].bs) {
-				int n;
-
-				(void)memcpy( /* saturate obuf */
-					io[1].buf, io[0].buf,
-				   (io[1].bufuse = (n = MIN(io[0].bufuse, io[1].bs)))
-				);
-
-				/* permute the copied units out of ibuf */
-				(void)memmove(io[0].buf, &(io[0].buf)[n], (io[0].bufuse -= n));
-			} else /* if(io[0].bs > io[1].bs) */ {
-				int n;
-
-				/* drain what we can from ibuf */
-				(void)memcpy(
-					&(io[1].buf)[io[1].bufuse], io[0].buf,
-				    (n = MIN(io[0].bufuse, io[1].bs - io[1].bufuse))
-				);
-				io[1].bufuse += n;
-
-				/* permute out the copied units */
-				(void)memmove(io[0].buf, &(io[0].buf)[n], io[0].bs - n);
-				io[0].bufuse -= n;
-
-				if(io[0].bs + io[1].bufuse <= io[1].bs && count != 1) {
-					continue; /* obuf not saturated - we could write more */
-				}
-			}
-
-			{ /* writes actually happen, or die */
-				size_t t;
-
-				t = io[1].bufuse;
-				if (Io_write(&io[1])->bufuse == t
-						&& !retry
-						&& io[1].error == 0) {
-					(void)Io_write(&io[1]); /* second chance */
-				}
-
-				assert(io[1].error == 0 || io[1].bufuse == t);
-				/* if the Io_writes errored, bufuse wouldn't have changed, and
-				 * the error will be reported at the end of the read/write
-				 * loop */
-
-				assert(io[1].bufuse <= t);
-
-				if (io[1].bufuse == t) { /* no more love */
-					count = 1;
 					break;
 				}
+				/* FALLTHROUGH */
+			case 'c': case 'b': case 's': case 'B': case 'S':
+				if(c == 'c' && (count = parse(optarg)) >= 0)
+					break;
+				i = isupper(c);
+				c = tolower(c);
+				if((c == 'b' && (ep[i].bs = parse(optarg)) > 0)
+						|| (c == 's' && (ep[i].seek = parse(optarg)) >= 0))
+					break;
+				/* FALLTHROUGH */
+			default:
+				terminate(ep);
+				return usage();
 			}
-
-			if (0 < io[1].bufuse /* && io[1].bufuse < t */) {
-				(void)fprintf(stderr, "%s: Partial write:\n\t", program_name);
-				(void)fprintio(stderr, fmt, io);
-
-				if(!retry) { count = 1; }
-			}
-		}
 	}
 
-	(void)fprintio(stderr, fmt, io);
+	if(debug >= 3)
+		fprintf(stderr,
+			"argv0=%s\n"
+			"in=%s\tibs=%d\tskip=%ld\talign=%hhx\tcount=%d\n"
+			"out=%s\tobs=%d\tseek=%ld\tdebug=%2d\tnoerror=%d\n",
+			program_name,
+			ep[0].fn, ep[0].bs, ep[0].seek, align, count,
+			ep[1].fn, ep[1].bs, ep[1].seek, debug, noerror);
 
-	for (i = 0; i < (sizeof io) / (sizeof *io); ++i) {
+	if(argc > optind){
-		if (io[i].error) { return oserr(io[i].fn, io[i].error); }
+		terminate(ep);
+		return usage();
 	}
 
+	for(i = 0; i <= 1; ++i){
+		if(Io_bufalloc(&ep[i]) == NULL){
+			fprintf(stderr, "%s: Failed to allocate %d bytes\n",
+				program_name, ep[i].bs);
+			terminate(ep);
+			return EX_OSERR;
+		}else if(ep[i].seek > 0)
+			switch(Io_fdseek(&ep[i])){
+			case EX_OK:
+				output();
+				terminate(ep);
+				return EX_OK;
+			}
+	}
+
+	do{	/* read */
+		Io_read(&ep[0]);
+		if(!noerror && ep[0].bufuse == 0)
+			Io_read(&ep[0]); /* second chance */
+		if(ep[0].bufuse == 0) /* that's all she wrote */
+			break;
+		else if(ep[0].bufuse < ep[0].bs){
+			++ep[0].prec;
+			if(debug >= 2){
+				fprintf(stderr, "%s: Partial read:\n\t", program_name);
+				output();
+			}
+			if(!noerror)
+				count = 1;
+			if(align >= 0)
+				Io_bufrpad(&ep[0], align);
+		}else
+			++ep[0].rec;
+
+		/* write */
+		do{	if(ep[1].bs > ep[0].bs){ /* io[1].bs > io[0].bs */
+				Io_bufxapp(&ep[1], &ep[0]);
+				if(ep[0].bs + ep[1].bufuse <= ep[1].bs && count != 1)
+					continue; /* we could write more */
+			}else
+				Io_bufxfer(&ep[1], &ep[0], MIN(ep[0].bufuse, ep[1].bs));
+
+			c = ep[1].bufuse;
+			Io_write(&ep[1]);
+			if(!noerror && ep[1].bufuse == c)
+				Io_write(&ep[1]); /* second chance */
+			if(c == ep[1].bufuse){ /* no more love */
+				count = 1;
+				break;
+			}else if(c > ep[1].bufuse && ep[1].bufuse > 0){
+				ep[1].prec += 1;
+				if(debug >= 2){
+					fprintf(stderr, "%s: Partial write:\n\t", program_name);
+					output();
+				}
+				if(!noerror)
+					count = 1;
+			}else if(ep[1].bufuse == 0 && c < ep[1].bs)
+				++ep[1].prec;
+			else
+				++ep[1].rec;
+		}while(ep[0].bufuse > 0);
+	}while(count == 0 || --count > 0);
+
+	output();
+	terminate(ep);
+
 	return EX_OK;
 }

src/false.c

@@ -1,19 +1,9 @@
 /*
- * Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
- * Copyright (c) 2024 DTB <trinity@trinity.moe>
  * SPDX-License-Identifier: CC0
  *
  * This work is marked with CC0 1.0. To view a copy of this license, visit
  * <http://creativecommons.org/publicdomain/zero/1.0>.
  */
 
-#ifdef __OpenBSD__
+int main() { return 1; }
-#	include <unistd.h> /* pledge(2) */
-#endif
-
-int main(void) {
-#ifdef __OpenBSD__
-	(void)pledge("stdio", "");
-#endif
-	return 1;
-}

src/fileis.rs

@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 2024 DTB <trinity@trinity.moe>
- * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- * 
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-
-use std::{
-	env::args,
-	fs::metadata,
-	os::unix::fs::{ FileTypeExt, MetadataExt },
-	process::ExitCode,
-};
-
-extern crate getopt;
-extern crate strerror;
-extern crate sysexits;
-
-use getopt::GetOpt;
-use strerror::StrError;
-use sysexits::EX_USAGE;
-
-const OPTS: &str = "bcdefgkprsuwxLS";
-
-fn usage(argv0: &str) -> ExitCode {
-	eprintln!("Usage: {} [-{}] file...", argv0, OPTS);
-	ExitCode::from(EX_USAGE)
-}
-
-fn main() -> ExitCode {
-	let argv = args().collect::<Vec<_>>();
-
-	let mut sel = String::with_capacity(OPTS.len()); // selected options
-	let mut optind: usize = 1; // argv[0]
-
-	while let Some(opt) = argv.getopt(OPTS) {
-		if let Ok(optchr) = opt.opt() { sel.push_str(optchr); }
-		else { return usage(&argv[0]); }
-
-		optind = opt.ind();
-	}
-
-	if optind == argv.len() { return usage(&argv[0]); }
-
-	for arg in argv.iter().skip(optind) {
-		let fmeta = match metadata(arg) {
-			Ok(m) => m,
-			Err(e) => { // no perms or nonexistent
-				eprintln!("{}: {}: {}", argv[0], arg, e.strerror());
-				return ExitCode::FAILURE;
-			},
-		};
-
-		let fmode = fmeta.mode();
-		let ftype = fmeta.file_type();
-
-		for selection in sel.chars() { // run all selected tests
-			match selection {
-				'b' if ftype.is_block_device() => (),
-				'c' if ftype.is_char_device() => (),
-				'e' => (), // exists or metadata would have errored
-				'd' if fmeta.is_dir() => (),
-				'f' if fmeta.is_file() => (),
-				'g' if fmode & 0o2000 /* S_ISGID */ != 0 => (), // setgid
-				'k' if fmode & 0o1000 /* S_ISVTX */ != 0 => (), // setvtx
-				'p' if ftype.is_fifo() => (),
-				'r' if fmode & 0o0400 /* S_IRUSR */ != 0 => (), // read access
-				'u' if fmode & 0o4000 /* S_ISUID */ != 0 => (), // setuid
-				'w' if fmode & 0o0200 /* S_IWUSR */ != 0 => (), // write access
-				'x' if fmode & 0o0100 /* S_IXUSR */ != 0 => (), // exec access
-				'L' if fmeta.is_symlink() => (),
-				'S' if ftype.is_socket() => (),
-				_ => { return ExitCode::FAILURE; }
-			}
-		}
-	}
-
-	ExitCode::SUCCESS
-}

src/fop.rs

@@ -18,150 +18,97 @@
 
 use std::{
 	env::args,
-	io::{ Error, Read, Write, stdin, stdout },
+	io::{ Read, stdin, stdout, Write },
-	process::{ Command, ExitCode, Stdio, exit },
+	process::{ Command, exit, Stdio },
 };
 
 extern crate getopt;
 extern crate strerror;
 extern crate sysexits;
 
-use getopt::GetOpt;
+use getopt::{ Opt, Parser };
 use strerror::StrError;
 use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
 
-#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
+fn main() {
-#[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
-
-fn err(argv0: &String, e: Error) {
-	eprintln!("{}: {}", argv0, e.strerror());
-}
-
-fn usage(argv0: &String) -> u8 {
-	eprintln!("Usage: {} [-d delimiter] index command [args...]", argv0);
-	EX_USAGE
-}
-
-fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
-	let mut d = '\u{1E}'.to_string(); /* ASCII record separator */
+	let mut d = '\u{1E}'.to_string();
-	let mut optind = 1;
+	let mut arg_parser = Parser::new(&argv, "d:");
 
-	#[cfg(target_os="openbsd")] {
+	while let Some(opt) = arg_parser.next() {
-		let promises = Promises::new("exec proc stdio unveil");
+		match opt {
-		if let Err(e) = pledge(Some(promises), None) {
+			Ok(Opt('d', Some(arg))) => d = arg,
-			err(&argv[0], e);
+			_ => {},
-			return ExitCode::from(EX_OSERR);
-		}
-
-		if let Err(e) = unveil(None, None) {
-			err(&argv[0], e);
-			return ExitCode::from(EX_OSERR);
-		}
-	}
-
-	if argv.len() == 1 { return ExitCode::from(usage(&argv[0])); }
-
-	while let Some(opt) = argv.getopt("d:") {
-		match opt.opt() {
-			Ok("d") => {
-				/* delimiter */
-				d = opt.arg().unwrap();
-				optind = opt.ind();
-			},
-			_ => {
-				return ExitCode::from(usage(&argv[0]));
-			}
 		};
 	}
 
-	/* parse the specified index as a number we can use */
+	let index_arg = arg_parser.index();
-	let index = argv[optind].parse::<usize>().unwrap_or_else(|e| {
+	let command_arg = arg_parser.index() + 1;
+
+	argv.get(command_arg).unwrap_or_else(|| {
+		eprintln!("Usage: {} [-d delimiter] index command [args...]", argv[0]);
+		exit(EX_USAGE);
+	});
+
+	let index = argv[index_arg].parse::<usize>().unwrap_or_else(|e| {
 		eprintln!("{}: {}: {}", argv[0], argv[1], e);
-		exit(EX_DATAERR.into());
+		exit(EX_DATAERR);
 	});
 
-	/* index of the argv[0] for the operator command */
-	let command_arg = optind as usize + 1;
-
-	/* argv[0] of the operator command */
-	let operator = argv.get(command_arg).unwrap_or_else(|| {
-		exit(usage(&argv[0]).into());
-	});
-
-	/* read entire standard input into memory */
 	let mut buf = String::new();
-	if let Err(e) = stdin().read_to_string(&mut buf) {
+	let _ = stdin().read_to_string(&mut buf);
-		err(&argv[0], e);
-		exit(EX_IOERR.into());
-	};
-
-	/* split the buffer by the delimiter (by default, '\u{1E}') */
 	let mut fields = buf.split(&d).collect::<Vec<&str>>();
 
-	/* collect arguments for the operator command */
+	let opts = argv
-	let command_args = argv
 		.iter()
 		.clone()
-		.skip(command_arg + 1) /* skip the command name */
+		.skip(command_arg + 1)
 		.collect::<Vec<&String>>();
 
-	/* spawn the command to operate on the field */
+	let mut spawned = Command::new(argv.get(command_arg).unwrap())
-	let mut spawned = Command::new(operator)
+		.args(opts)
-		.args(command_args) /* spawn with the specified arguments */
 		.stdin(Stdio::piped())
-		.stdout(Stdio::piped()) /* piped stdout to handle output ourselves */
+		.stdout(Stdio::piped())
 		.spawn()
 		.unwrap_or_else( |e| {
-			err(&argv[0], e);
+			eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
-			exit(EX_UNAVAILABLE.into());
+			exit(EX_UNAVAILABLE);
 		});
 
-	/* get field we want to pipe into spawned program */
 	let field = fields.get(index).unwrap_or_else(|| {
-		eprintln!("{}: {}: no such index in input", argv[0], index);
+		eprintln!(
-		exit(EX_DATAERR.into());
+			"{}: {}: No such index in input",
+			argv[0],
+			index.to_string(),
+		);
+		exit(EX_DATAERR);
 	});
 
-	/* get the stdin of the newly spawned program and feed it the field val */
 	if let Some(mut child_stdin) = spawned.stdin.take() {
 		let _ = child_stdin.write_all(field.as_bytes());
-		drop(child_stdin); /* stay safe! drop your children! */
+		drop(child_stdin);
 	}
 
 	let output = spawned.wait_with_output().unwrap_or_else(|e| {
-		err(&argv[0], e);
+		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
-		exit(EX_IOERR.into());
+		exit(EX_IOERR);
 	});
 
-	/* get the output with which the original field will be replaced */
 	let mut replace = output.stdout.clone();
 
-	/* pop trailing newline out if the input did not contain it */
+	if replace.pop() != Some(b'\n') { replace = output.stdout; }
-	if fields[index].chars().last() != Some('\n') /* no newline */
-		&& replace.pop() != Some(b'\n') { /* pop last char of replacement */
-		/* restore replacement to original command output if popped char was not
-		 * a newline */
-		replace = output.stdout;
-	}
 
-	/* convert the output of the program to UTF-8 */
 	let new_field = String::from_utf8(replace).unwrap_or_else(|e| {
-		eprintln!("{}: {}", argv[0], e);
+		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e);
-		exit(EX_IOERR.into());
+		exit(EX_IOERR);
 	});
 
-	/* store the new field in the old fields vector */
 	fields[index] = &new_field;
 
-	/* fop it */ 
 	stdout().write_all(
 		fields.join(&d.to_string()).as_bytes()
 	).unwrap_or_else(|e| {
-		err(&argv[0], e);
+		eprintln!("{}: {}", argv[0], e.strerror());
-		exit(EX_IOERR.into());
+		exit(EX_IOERR);
 	});
-
-	ExitCode::SUCCESS
 }

src/getopt-rs/error.rs

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ *
+ * This file incorporates work covered by the following copyright and permission
+ * notice:
+ *     The Clear BSD License
+ *
+ *     Copyright © 2017-2023 David Wildasin
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted (subject to the limitations in the disclaimer
+ *     below) provided that the following conditions are met:
+ *
+ *          * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions, and the following disclaimer.
+ *
+ *          * 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.
+ *
+ *          * Neither the name of the copyright holder nor the names of its
+ *          contributors may be used to endorse or promote products derived from
+ *          this software without specific prior written permission.
+ *
+ *     NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
+ *     BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+ *     HOLDER 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.
+ */
+
+use std::{ error, fmt };
+
+use crate::ErrorKind::{ self, * };
+
+/// A basic error type for [`Parser`](struct.Parser.html)
+#[derive(Debug, Eq, PartialEq)]
+pub struct Error {
+    culprit: char,
+    kind: ErrorKind,
+}
+
+impl Error {
+    /// Creates a new error using a known kind and the character that caused the
+	/// issue.
+    pub fn new(kind: ErrorKind, culprit: char) -> Self {
+        Self { culprit, kind }
+    }
+
+    /// Returns the [`ErrorKind`](enum.ErrorKind.html) for this error.
+    pub fn kind(self) -> ErrorKind {
+        self.kind
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.kind {
+            MissingArgument => write!(
+				f, 
+				"option requires an argument -- {:?}",
+				self.culprit,
+			),
+            UnknownOption => write!(f, "unknown option -- {:?}", self.culprit),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        None
+    }
+}

src/getopt-rs/errorkind.rs

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ *
+ * This file incorporates work covered by the following copyright and permission
+ * notice:
+ *     The Clear BSD License
+ *
+ *     Copyright © 2017-2023 David Wildasin
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted (subject to the limitations in the disclaimer
+ *     below) provided that the following conditions are met:
+ *
+ *          * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions, and the following disclaimer.
+ *
+ *          * 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.
+ *
+ *          * Neither the name of the copyright holder nor the names of its
+ *          contributors may be used to endorse or promote products derived from
+ *          this software without specific prior written permission.
+ *
+ *     NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
+ *     BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+ *     HOLDER 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.
+ */
+
+/// What kinds of errors [`Parser`](struct.Parser.html) can return.
+#[derive(Debug, Eq, PartialEq)]
+pub enum ErrorKind {
+    /// An argument was not found for an option that was expecting one.
+    MissingArgument,
+    /// An unknown option character was encountered.
+    UnknownOption,
+}

src/getopt-rs/lib.rs

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ *
+ * This file incorporates work covered by the following copyright and permission
+ * notice:
+ *     The Clear BSD License
+ *
+ *     Copyright © 2017-2023 David Wildasin
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted (subject to the limitations in the disclaimer
+ *     below) provided that the following conditions are met:
+ *
+ *          * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions, and the following disclaimer.
+ *
+ *          * 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.
+ *
+ *          * Neither the name of the copyright holder nor the names of its
+ *          contributors may be used to endorse or promote products derived from
+ *          this software without specific prior written permission.
+ *
+ *     NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
+ *     BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+ *     HOLDER 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.
+ */
+
+//! # getopt
+//!
+//! `getopt` provides a minimal, (essentially) POSIX-compliant option parser.
+
+pub use crate::{
+	error::Error,
+	errorkind::ErrorKind,
+	opt::Opt,
+	parser::Parser,
+	result::Result
+};
+
+mod error;
+mod errorkind;
+mod opt;
+mod parser;
+mod result;
+#[cfg(test)]
+mod tests;

src/getopt-rs/opt.rs

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ *
+ * This file incorporates work covered by the following copyright and permission
+ * notice:
+ *     The Clear BSD License
+ *
+ *     Copyright © 2017-2023 David Wildasin
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted (subject to the limitations in the disclaimer
+ *     below) provided that the following conditions are met:
+ *
+ *          * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions, and the following disclaimer.
+ *
+ *          * 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.
+ *
+ *          * Neither the name of the copyright holder nor the names of its
+ *          contributors may be used to endorse or promote products derived from
+ *          this software without specific prior written permission.
+ *
+ *     NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
+ *     BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+ *     HOLDER 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.
+ */
+
+use std::fmt;
+
+/// A single option.
+///
+/// For `Opt(x, y)`:
+///   - `x` is the character representing the option.
+///   - `y` is `Some` string, or `None` if no argument was expected.
+///
+/// # Example
+///
+/// ```
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+/// use getopt::Opt;
+///
+/// // args = ["program", "-abc", "foo"];
+/// # let args: Vec<String> = vec!["program", "-abc", "foo"]
+/// #     .into_iter()
+/// #     .map(String::from)
+/// #     .collect();
+/// let optstring = "ab:c";
+/// let mut opts = getopt::Parser::new(&args, optstring);
+///
+/// assert_eq!(Opt('a', None), opts.next().transpose()?.unwrap());
+/// assert_eq!(Opt('b', Some("c".to_string())), opts.next().transpose()?.unwrap());
+/// assert_eq!(None, opts.next().transpose()?);
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Opt(pub char, pub Option<String>);
+
+impl fmt::Display for Opt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Opt({:?}, {:?})", self.0, self.1)
+    }
+}

src/getopt-rs/parser.rs

@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ *
+ * This file incorporates work covered by the following copyright and permission
+ * notice:
+ *     The Clear BSD License
+ *
+ *     Copyright © 2017-2023 David Wildasin
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted (subject to the limitations in the disclaimer
+ *     below) provided that the following conditions are met:
+ *
+ *          * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions, and the following disclaimer.
+ *
+ *          * 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.
+ *
+ *          * Neither the name of the copyright holder nor the names of its
+ *          contributors may be used to endorse or promote products derived from
+ *          this software without specific prior written permission.
+ *
+ *     NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
+ *     BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+ *     HOLDER 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.
+ */
+
+use std::collections::HashMap;
+
+use crate::{ error::Error, errorkind::ErrorKind, opt::Opt, result::Result };
+
+/// The core of the `getopt` crate.
+///
+/// `Parser` is implemented as an iterator over the options present in the given
+/// argument vector.
+///
+/// The method [`next`](#method.next) does the heavy lifting.
+///
+/// # Examples
+///
+/// ## Simplified usage:
+/// ```
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+/// use getopt::Opt;
+///
+/// // args = ["program", "-abc", "foo"];
+/// # let args: Vec<String> = vec!["program", "-abc", "foo"]
+/// #     .into_iter()
+/// #     .map(String::from)
+/// #     .collect();
+/// let mut opts = getopt::Parser::new(&args, "ab:c");
+///
+/// assert_eq!(Some(Opt('a', None)), opts.next().transpose()?);
+/// assert_eq!(1, opts.index());
+/// assert_eq!(Some(Opt('b', Some("c".to_string()))), opts.next().transpose()?);
+/// assert_eq!(2, opts.index());
+/// assert_eq!(None, opts.next());
+/// assert_eq!(2, opts.index());
+/// assert_eq!("foo", args[opts.index()]);
+/// # Ok(())
+/// # }
+/// ```
+///
+/// ## A more idiomatic example:
+/// ```
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+/// use getopt::Opt;
+///
+/// // args = ["program", "-abc", "-d", "foo", "-e", "bar"];
+/// # let mut args: Vec<String> = vec!["program", "-abc", "-d", "foo", "-e", "bar"]
+/// #     .into_iter()
+/// #     .map(String::from)
+/// #     .collect();
+/// let mut opts = getopt::Parser::new(&args, "ab:cd:e");
+///
+/// let mut a_flag = false;
+/// let mut b_flag = String::new();
+/// let mut c_flag = false;
+/// let mut d_flag = String::new();
+/// let mut e_flag = false;
+///
+/// loop {
+///     match opts.next().transpose()? {
+///         None => break,
+///         Some(opt) => match opt {
+///             Opt('a', None) => a_flag = true,
+///             Opt('b', Some(arg)) => b_flag = arg.clone(),
+///             Opt('c', None) => c_flag = true,
+///             Opt('d', Some(arg)) => d_flag = arg.clone(),
+///             Opt('e', None) => e_flag = true,
+///             _ => unreachable!(),
+///         },
+///     }
+/// }
+///
+/// let new_args = args.split_off(opts.index());
+///
+/// assert_eq!(true, a_flag);
+/// assert_eq!("c", b_flag);
+/// assert_eq!(false, c_flag);
+/// assert_eq!("foo", d_flag);
+/// assert_eq!(true, e_flag);
+///
+/// assert_eq!(1, new_args.len());
+/// assert_eq!("bar", new_args.first().unwrap());
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Debug, Eq, PartialEq)]
+pub struct Parser {
+    opts: HashMap<char, bool>,
+    args: Vec<Vec<char>>,
+    index: usize,
+    point: usize,
+}
+
+impl Parser {
+    /// Create a new `Parser`, which will process the arguments in `args`
+	/// according to the options specified in `optstring`.
+    ///
+    /// For compatibility with
+	/// [`std::env::args`](https://doc.rust-lang.org/std/env/fn.args.html),
+    /// valid options are expected to begin at the second element of `args`, and
+	/// `index` is
+    /// initialised to `1`.
+    /// If `args` is structured differently, be sure to call
+	/// [`set_index`](#method.set_index) before the first invocation of
+	/// [`next`](#method.next).
+    ///
+    /// `optstring` is a string of recognised option characters; if a character
+	/// is followed by a colon (`:`), that option takes an argument.
+    ///
+    /// # Note:
+    /// Transforming the OS-specific argument strings into a vector of `String`s
+	/// is the sole responsibility of the calling program, as it involves some
+	/// level of potential information loss (which this crate does not presume
+	/// to handle unilaterally) and error handling (which would complicate the
+	/// interface).
+    pub fn new(args: &[String], optstring: &str) -> Self {
+        let optstring: Vec<char> = optstring.chars().collect();
+        let mut opts = HashMap::new();
+        let mut i = 0;
+        let len = optstring.len();
+
+        while i < len {
+            let j = i + 1;
+
+            if j < len && optstring[j] == ':' {
+                opts.insert(optstring[i], true);
+                i += 1;
+            } else {
+                opts.insert(optstring[i], false);
+            }
+            i += 1;
+        }
+
+        Self {
+            opts,
+            // "explode" the args into a vector of character vectors, to allow
+			// indexing
+            args: args.iter().map(|e| e.chars().collect()).collect(),
+            index: 1,
+            point: 0,
+        }
+    }
+
+    /// Return the current `index` of the parser.
+    ///
+    /// `args[index]` will always point to the the next element of `args`; when
+	/// the parser is
+    /// finished with an element, it will increment `index`.
+    ///
+    /// After the last option has been parsed (and [`next`](#method.next) is
+	/// returning `None`),
+    /// `index` will point to the first non-option argument.
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    // `point` must be reset to 0 whenever `index` is changed
+
+    /// Modify the current `index` of the parser.
+    pub fn set_index(&mut self, value: usize) {
+        self.index = value;
+        self.point = 0;
+    }
+
+    /// Increment the current `index` of the parser.
+    ///
+    /// This use case is common enough to warrant its own optimised method.
+    pub fn incr_index(&mut self) {
+        self.index += 1;
+        self.point = 0;
+    }
+}
+
+impl Iterator for Parser {
+    type Item = Result<Opt>;
+
+    /// Returns the next option, if any.
+    ///
+    /// Returns an [`Error`](struct.Error.html) if an unexpected option is
+	/// encountered or if an
+    /// expected argument is not found.
+    ///
+    /// Parsing stops at the first non-hyphenated argument; or at the first
+	/// argument matching "-";
+    /// or after the first argument matching "--".
+    ///
+    /// When no more options are available, `next` returns `None`.
+    ///
+    /// # Examples
+    ///
+    /// ## "-"
+    /// ```
+    /// use getopt::Parser;
+    ///
+    /// // args = ["program", "-", "-a"];
+    /// # let args: Vec<String> = vec!["program", "-", "-a"]
+    /// #     .into_iter()
+    /// #     .map(String::from)
+    /// #     .collect();
+    /// let mut opts = Parser::new(&args, "a");
+    ///
+    /// assert_eq!(None, opts.next());
+    /// assert_eq!("-", args[opts.index()]);
+    /// ```
+    ///
+    /// ## "--"
+    /// ```
+    /// use getopt::Parser;
+    ///
+    /// // args = ["program", "--", "-a"];
+    /// # let args: Vec<String> = vec!["program", "--", "-a"]
+    /// #     .into_iter()
+    /// #     .map(String::from)
+    /// #     .collect();
+    /// let mut opts = Parser::new(&args, "a");
+    ///
+    /// assert_eq!(None, opts.next());
+    /// assert_eq!("-a", args[opts.index()]);
+    /// ```
+    ///
+    /// ## Unexpected option:
+    /// ```
+    /// use getopt::Parser;
+    ///
+    /// // args = ["program", "-b"];
+    /// # let args: Vec<String> = vec!["program", "-b"]
+    /// #     .into_iter()
+    /// #     .map(String::from)
+    /// #     .collect();
+    /// let mut opts = Parser::new(&args, "a");
+    ///
+    /// assert_eq!(
+    ///     "unknown option -- 'b'".to_string(),
+    ///     opts.next().unwrap().unwrap_err().to_string()
+    /// );
+    /// ```
+    ///
+    /// ## Missing argument:
+    /// ```
+    /// use getopt::Parser;
+    ///
+    /// // args = ["program", "-a"];
+    /// # let args: Vec<String> = vec!["program", "-a"]
+    /// #     .into_iter()
+    /// #     .map(String::from)
+    /// #     .collect();
+    /// let mut opts = Parser::new(&args, "a:");
+    ///
+    /// assert_eq!(
+    ///     "option requires an argument -- 'a'".to_string(),
+    ///     opts.next().unwrap().unwrap_err().to_string()
+    /// );
+    /// ```
+    fn next(&mut self) -> Option<Result<Opt>> {
+        if self.point == 0 {
+            /*
+             * Rationale excerpts below taken verbatim from "The Open Group Base
+			 * Specifications Issue 7, 2018 edition", IEEE Std 1003.1-2017
+			 * (Revision of IEEE Std 1003.1-2008).
+             * Copyright © 2001-2018 IEEE and The Open Group.
+             */
+
+            /*
+             * If, when getopt() is called:
+             *      argv[optind]    is a null pointer
+             *      *argv[optind]   is not the character '-'
+             *      argv[optind]    points to the string "-"
+             * getopt() shall return -1 without changing optind.
+             */
+            if self.index >= self.args.len()
+                || self.args[self.index].is_empty()
+                || self.args[self.index][0] != '-'
+                || self.args[self.index].len() == 1
+            {
+                return None;
+            }
+
+            /*
+             * If:
+             *      argv[optind]    points to the string "--"
+             * getopt() shall return -1 after incrementing index.
+             */
+            if self.args[self.index][1] == '-' && self.args[self.index].len() == 2 {
+                self.incr_index();
+                return None;
+            }
+
+            // move past the starting '-'
+            self.point += 1;
+        }
+
+        let opt = self.args[self.index][self.point];
+        self.point += 1;
+
+        match self.opts.get(&opt) {
+            None => {
+                if self.point >= self.args[self.index].len() {
+                    self.incr_index();
+                }
+                Some(Err(Error::new(ErrorKind::UnknownOption, opt)))
+            }
+            Some(false) => {
+                if self.point >= self.args[self.index].len() {
+                    self.incr_index();
+                }
+
+                Some(Ok(Opt(opt, None)))
+            }
+            Some(true) => {
+                let arg: String = if self.point >= self.args[self.index].len() {
+                    self.incr_index();
+                    if self.index >= self.args.len() {
+                        return Some(Err(Error::new(
+									ErrorKind::MissingArgument,
+									opt,
+								)));
+                    }
+                    self.args[self.index].iter().collect()
+                } else {
+                    self.args[self.index]
+                        .clone()
+                        .split_off(self.point)
+                        .iter()
+                        .collect()
+                };
+
+                self.incr_index();
+
+                Some(Ok(Opt(opt, Some(arg))))
+            }
+        }
+    }
+}

src/getopt-rs/result.rs

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ *
+ * This file incorporates work covered by the following copyright and permission
+ * notice:
+ *     The Clear BSD License
+ *
+ *     Copyright © 2017-2023 David Wildasin
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted (subject to the limitations in the disclaimer
+ *     below) provided that the following conditions are met:
+ *
+ *          * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions, and the following disclaimer.
+ *
+ *          * 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.
+ *
+ *          * Neither the name of the copyright holder nor the names of its
+ *          contributors may be used to endorse or promote products derived from
+ *          this software without specific prior written permission.
+ *
+ *     NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
+ *     BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+ *     HOLDER 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.
+ */
+
+use std::result;
+
+use crate::error::Error;
+
+/// A specialized `Result` type for use with [`Parser`](struct.Parser.html)
+pub type Result<T> = result::Result<T, Error>;

src/getopt-rs/tests.rs

@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ *
+ * This file incorporates work covered by the following copyright and permission
+ * notice:
+ *     The Clear BSD License
+ *
+ *     Copyright © 2017-2023 David Wildasin
+ *     All rights reserved.
+ *
+ *     Redistribution and use in source and binary forms, with or without
+ *     modification, are permitted (subject to the limitations in the disclaimer
+ *     below) provided that the following conditions are met:
+ *
+ *          * Redistributions of source code must retain the above copyright
+ *          notice, this list of conditions, and the following disclaimer.
+ *
+ *          * 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.
+ *
+ *          * Neither the name of the copyright holder nor the names of its
+ *          contributors may be used to endorse or promote products derived from
+ *          this software without specific prior written permission.
+ *
+ *     NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
+ *     BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+ *     HOLDER 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.
+ */
+
+use crate::{Opt, Parser};
+
+macro_rules! basic_test {
+    ($name:ident, $expect:expr, $next:expr, [$($arg:expr),+], $optstr:expr) => (
+        #[test]
+        fn $name() -> Result<(), String> {
+            let expect: Option<Opt> = $expect;
+            let args: Vec<String> = vec![$($arg),+]
+				.into_iter()
+				.map(String::from)
+				.collect();
+            let next: Option<String> = $next;
+            let mut opts = Parser::new(&args, $optstr);
+
+            match opts.next().transpose() {
+                Err(error) => {
+                    return Err(format!("next() returned {:?}", error))
+                },
+                Ok(actual) => if actual != expect {
+                    return Err(
+						format!("expected {:?}; got {:?}", expect, actual)
+					)
+                },
+            };
+
+            match next {
+                None => if opts.index() < args.len() {
+                    return Err(format!(
+							"expected end of args; got {:?}", args[opts.index()]
+					))
+                },
+                Some(n) => if args[opts.index()] != n {
+                    return Err(format!(
+							"next arg: expected {:?}; got {:?}",
+							n,
+							args[opts.index()]
+					))
+                },
+            };
+
+            Ok(())
+        }
+    )
+}
+
+#[rustfmt::skip] basic_test!(
+	blank_arg, None, Some(String::new()), ["x", ""], "a"
+);
+#[rustfmt::skip] basic_test!(
+	double_dash, None, Some("-a".to_string()), ["x", "--", "-a", "foo"], "a"
+);
+#[rustfmt::skip] basic_test!(no_opts_1, None, None, ["x"], "a");
+#[rustfmt::skip] basic_test!(
+	no_opts_2, None, Some("foo".to_string()), ["x", "foo"], "a"
+);
+#[rustfmt::skip] basic_test!(
+	no_opts_3, None, Some("foo".to_string()), ["x", "foo", "-a"], "a"
+);
+#[rustfmt::skip] basic_test!(
+	single_dash, None, Some("-".to_string()), ["x", "-", "-a", "foo"], "a"
+);
+#[rustfmt::skip] basic_test!(
+	single_opt,
+	Some(Opt('a', None)),
+	Some("foo".to_string()),
+	["x", "-a", "foo"],
+	"a"
+);
+#[rustfmt::skip] basic_test!(
+	single_optarg,
+	Some(Opt('a', Some("foo".to_string()))),
+	None,
+	["x", "-a", "foo"],
+	"a:"
+);
+
+macro_rules! error_test {
+    ($name:ident, $expect:expr, [$($arg:expr),+], $optstr:expr) => (
+        #[test]
+        fn $name() -> Result<(), String> {
+            let expect: String = $expect.to_string();
+            let args: Vec<String> = vec![$($arg),+]
+				.into_iter()
+				.map(String::from)
+				.collect();
+            let mut opts = Parser::new(&args, $optstr);
+
+            match opts.next() {
+                None => {
+                    return Err(format!(
+							"unexpected successful response: end of options"
+					))
+                },
+                Some(Err(actual)) => {
+                    let actual = actual.to_string();
+
+                    if actual != expect {
+                        return Err(
+							format!("expected {:?}; got {:?}", expect, actual)
+						);
+                    }
+                },
+                Some(Ok(opt)) => {
+                    return Err(
+						format!("unexpected successful response: {:?}", opt)
+					)
+                },
+            };
+
+            Ok(())
+        }
+    )
+}
+
+#[rustfmt::skip] error_test!(
+	bad_opt,
+	"unknown option -- 'b'",
+	["x", "-b"],
+	"a"
+);
+
+#[rustfmt::skip] error_test!(
+	missing_optarg,
+	"option requires an argument -- 'a'",
+	["x", "-a"],
+	"a:"
+);
+
+#[test]
+fn multiple() -> Result<(), String> {
+    let args: Vec<String> = vec!["x", "-abc", "-d", "foo", "-e", "bar"]
+        .into_iter()
+        .map(String::from)
+        .collect();
+    let optstring = "ab:d:e".to_string();
+    let mut opts = Parser::new(&args, &optstring);
+
+    macro_rules! check_result {
+        ($expect:expr) => {
+            let expect: Option<Opt> = $expect;
+            match opts.next().transpose() {
+                Err(error) => {
+					return Err(format!("next() returned {:?}", error));
+				},
+                Ok(actual) => {
+                    if actual != expect {
+                        return Err(
+							format!("expected {:?}; got {:?}", expect, actual)
+						);
+                    }
+                }
+            };
+        };
+    }
+
+    check_result!(Some(Opt('a', None)));
+    check_result!(Some(Opt('b', Some("c".to_string()))));
+    check_result!(Some(Opt('d', Some("foo".to_string()))));
+    check_result!(Some(Opt('e', None)));
+    check_result!(None);
+
+    Ok(())
+}
+
+#[test]
+fn continue_after_error() {
+    let args: Vec<String> = vec!["x", "-z", "-abc"]
+        .into_iter()
+        .map(String::from)
+        .collect();
+    let optstring = "ab:d:e".to_string();
+    for _opt in Parser::new(&args, &optstring) {
+        // do nothing, should not panic
+    }
+}

src/hru.rs

@@ -19,7 +19,7 @@
 use std::{
 	cmp::Ordering,
 	env::args,
-	io::{ Write, stdin, stdout },
+	io::{ stdin, stdout, Write },
 	process::{ ExitCode, exit },
 };
 
@@ -27,61 +27,42 @@ extern crate strerror;
 extern crate sysexits;
 
 use strerror::StrError;
-use sysexits::{ EX_DATAERR, EX_IOERR, EX_SOFTWARE, EX_USAGE };
+use sysexits::{ EX_DATAERR, EX_IOERR, EX_SOFTWARE };
 
-#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
-#[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
-
-/* list of SI prefixes */
 const LIST: [(u32, &str); 10] = [
-	(3, "k"), /* kilo */
+	(3, "k"),
-	(6, "M"), /* mega */
+	(6, "M"),
-	(9, "G"), /* giga */
+	(9, "G"),
-	(12, "T"), /* tera */
+	(12, "T"),
-	(15, "P"), /* peta */
+	(15, "P"),
-	(18, "E"), /* exa */
+	(18, "E"),
-	(21, "Z"), /* zetta */
+	(21, "Z"),
-	(24, "Y"), /* yotta */
+	(24, "Y"),
-	(27, "R"), /* ronna */
+	(27, "R"),
-	(30, "Q"), /* quetta */
+	(30, "Q")
 ];
 
-fn err(argv0: &String, message: String, code: Option<u8>) -> ExitCode {
-	eprintln!("{}: {}", argv0, message);
-	ExitCode::from(code.unwrap_or(1 /* unknown error */))
-}
-
-fn usage(argv0: &String) -> ExitCode {
-	eprintln!("Usage: {}", argv0);
-	ExitCode::from(EX_USAGE)
-}
-
 fn convert(input: u128) -> Result<(f64, (u32, &'static str)), String> {
-	/* preserve decimal places in output by casting to a float */
-	let mut out = (input as f64, (0_u32, "")); 
 
-	if input < 1000 { return Ok(out); } /* too low to convert */
+	let mut out = (input as f64, (0_u32, ""));
+	if input < 1000 { return Ok(out); }
 
 	for (n, p) in LIST {
 		let c = match 10_u128.checked_pow(n) {
 			Some(c) => c,
-			None => { /* too big for the laws of computing :( */
+			None => {
 				return Err(format!("10^{}: Integer overflow", n.to_string()));
 			},
 		};
 
 		match c.cmp(&input) {
-			Ordering::Less => { /* c < input */
+			Ordering::Less => {
-				/* the program will keep assigning out every loop until either
-				 * the list runs out of higher prefix bases or the input is
-				 * greater than the prefix base */
 				out = (input as f64 / c as f64, (n, p));
 			},
-			Ordering::Equal => { /* c == input */
+			Ordering::Equal => {
 				return Ok((input as f64 / c as f64, (n, p)));
 			},
-			Ordering::Greater => {}, /* c > input */
+			Ordering::Greater => {},
 		};
 	}
 
@@ -90,49 +71,38 @@ fn convert(input: u128) -> Result<(f64, (u32, &'static str)), String> {
 
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
-
-	if let Some(_) = argv.get(1) { return usage(&argv[0]); }
-
-	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio unveil");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
-			return err(&argv[0], e.strerror(), Some(EX_OSERR));
-		}
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e.strerror(), Some(EX_OSERR));
-		}
-	}
-
 	let mut buf = String::new();
+	while let Ok(_) = stdin().read_line(&mut buf) {
+		if buf.is_empty() { return ExitCode::SUCCESS; }
 
-	if let Err(e) = stdin().read_line(&mut buf) {
+		let n: u128 = match buf.trim().parse() {
-		return err(&argv[0], e.strerror(), Some(EX_IOERR));
+			Ok(f) => {
-	}
+				buf.clear();
+				f
+			},
+			Err(err) => {
+				eprintln!("{}: {}", argv[0], err);
+				return ExitCode::from(EX_DATAERR as u8);
+			},
+		};
 
-	if buf.is_empty() { return ExitCode::SUCCESS; }
+		let (number, prefix) = match convert(n) {
+			Ok(x) => x,
+			Err(err) => {
+				eprintln!("{}: {}", argv[0], err);
+				return ExitCode::from(EX_SOFTWARE as u8);
+			},
+		};
 
-	let n: u128 = match buf.trim().parse() {
+		let si_prefix = format!("{}B", prefix.1);
-		Ok(f) => {
-			buf.clear();
-			f
-		},
-		Err(e) => return err(&argv[0], e.to_string(), Some(EX_DATAERR)),
-	};
 
-	let (number, prefix) = convert(n).unwrap_or_else(|e| {
+		let out = ((number * 10.0).round() / 10.0).to_string();
-		let _ = err(&argv[0], e.to_string(), None);
-		exit(EX_SOFTWARE.into());
-	});
 
-	let si_prefix = prefix.1.to_owned() + "B";
+		stdout().write_all(format!("{} {}\n", out, si_prefix).as_bytes())
-
+			.unwrap_or_else(|e| {
-	/* round output number to one decimal place */
+				eprintln!("{}: {}", argv[0], e.strerror());
-	let rounded = (number * 10.0).round() / 10.0;
+				exit(EX_IOERR);
-	let out = rounded.to_string() + " " + &si_prefix + &'\n'.to_string();
+			});
-
-	if let Err(e) = stdout().write_all(out.as_bytes()) {
-		return err(&argv[0], e.strerror(), Some(EX_IOERR));
 	}
 
 	ExitCode::SUCCESS

src/intcmp.c

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2023 DTB <trinity@trinity.moe>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+
+#include <errno.h> /* errno */
+#include <stdio.h> /* fprintf(3), stderr */
+#include <stdlib.h> /* strtol(3), size_t, EXIT_FAILURE */
+#include <unistd.h> /* getopt(3), optind */
+#include <sysexits.h>
+
+/* 0b00? */		/*                     Equal | -e  | 0b001 | 1 */
+#define EQUAL	0x01	/*                   Greater | -g  | 0b010 | 2 */
+/* 0b0?0 */		/*          Greater or Equal | -ge | 0b011 | 3 */
+#define GREATER	0x02	/*                      Less | -l  | 0b100 | 4 */
+/* 0b?00 */		/*             Less or Equal | -le | 0b101 | 5 */
+#define LESS	0x04	/* Inequal (Greater or Less) | -gl | 0b110 | 6 */
+
+static char *program_name = "intcmp";
+
+int main(int argc, char *argv[]){
+	int c;
+	size_t i;
+	unsigned char mode;
+	int r; /* reference integer */
+
+	mode = 0;
+
+	if(argc < 3)
+		goto usage;
+
+	while((c = getopt(argc, argv, "egl")) != -1)
+		switch(c){
+		case 'e': mode |= EQUAL;   break;
+		case 'g': mode |= GREATER; break;
+		case 'l': mode |= LESS;	   break;
+		default:  goto usage;
+		}
+
+	if(optind + 2 /* ref cmp */ > argc){
+usage:		fprintf(stderr,
+			"Usage: %s (-eghl) [integer] [integer...]\n",
+			argv[0] == NULL ? program_name : argv[0]);
+		return EX_USAGE;
+	}
+
+	i = optind;
+
+	do{	r = c;
+		c = strtol(argv[i], &argv[i], 10);
+		if(*argv[i] != '\0' || errno != 0){
+			fprintf(stderr, "%s: argument #%d: Invalid integer\n",
+				argv[0], (int)i);
+			return EX_USAGE;
+		}
+
+		if(i == optind)
+			continue;
+
+		/* rule enforcement; if a mode isn't permitted and the numbers
+		 * correspond to it, return 1 */
+		if(		(!(mode & EQUAL) && r == c)
+				|| (!(mode & GREATER) && r > c)
+				|| (!(mode & LESS) && r < c))
+			return 1;
+	}while(++i < argc);
+	
+	return 0;
+}

src/intcmp.rs

@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
- * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- * 
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-
-use std::{
-	env::args,
-	process::ExitCode
-};
-
-extern crate getopt;
-extern crate sysexits;
-
-use getopt::GetOpt;
-use sysexits::{ EX_DATAERR, EX_USAGE };
-
-#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
-#[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] extern crate strerror;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
-#[cfg(target_os="openbsd")] use strerror::StrError;
-
-fn err(argv0: &String, e: String, code: u8) -> ExitCode {
-	eprintln!("{}: {}", argv0, e);
-	ExitCode::from(code)
-}
-
-fn usage(argv0: &String) -> ExitCode {
-	eprintln!("Usage: {} [-egl] integer integer...", argv0);
-	ExitCode::from(EX_USAGE)
-}
-
-fn main() -> ExitCode {
-	let argv = args().collect::<Vec<String>>();
-
-	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio unveil");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
-			return err(&argv[0], e.strerror(), EX_OSERR);
-		}
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e.strerror(), EX_OSERR);
-		}
-	}
-
-	let mut e = false; /* args can be == */
-	let mut g = false; /* args can be > */
-	let mut l = false; /* args can be < */
-	let mut optind = 0;
-
-	if argv.len() < 3 { return usage(&argv[0]); }
-
-	while let Some(opt) = argv.getopt("egl") {
-		match opt.opt() {
-			Ok("e") => e = true,
-			Ok("g") => g = true,
-			Ok("l") => l = true,
-			_ => return usage(&argv[0]),
-		}
-		optind = opt.ind();
-	}
-
-	if !e & !g & !l { return usage(&argv[0]); }
-
-	if argv.len() - optind < 2 /* see usage */ { return usage(&argv[0]); }
-
-	let mut prev: Option<usize> = None; /* no previous operand */
-	let mut currn: usize;
-
-	for arg in argv.iter().skip(optind) { /* iterate operands */
-		match arg.parse::<usize>() { /* parse current operand */
-			Ok(n) => currn = n,
-			Err(e) => {
-				let error = arg.to_owned() + ": " + &e.to_string();
-				return err(&argv[0], error, EX_DATAERR);
-			}
-		}
-
-		if let Some(prevn) = prev { /* if there was a previous opr., test */
-			if (!e && prevn == currn)
-					|| (!g && prevn > currn)
-					|| (!l && prevn < currn)
-				{ return ExitCode::FAILURE; }
-		}
-
-		prev = Some(currn); /* there is a previous operand */
-	}
-
-	ExitCode::SUCCESS
-}

src/libgetopt.rs

@@ -1,202 +0,0 @@
-/*
- * Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- * 
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-
-use std::ffi::{ c_int, c_char, CString, CStr };
-
-/* binding to getopt(3p) */
-extern "C" {
-	static mut optarg: *mut c_char;
-	static mut _opterr: c_int;
-	static mut optind: c_int;
-	static mut optopt: c_int;
-
-	fn getopt(
-		___argc: c_int,
-		___argv: *const *mut c_char,
-		__shortopts: *const c_char,
-	) -> c_int;
-}
-
-#[derive(Clone, Debug)]
-pub enum OptError {
-	MissingArg(String),
-	UnknownOpt(String),
-}
-
-#[derive(Clone, Debug)]
-pub struct Opt {
-	arg: Option<String>, /* option argument */
-	ind: *mut i32, /* option index */
-	opt: Result<String, OptError>, /* option option */
-}
-
-impl Opt {
-	pub fn arg(&self) -> Option<String> { self.arg.clone() }
-
-	/* sets optarg if default is desired */
-	pub fn arg_or(&self, default: impl std::fmt::Display) -> String {
-		default.to_string()
-	}
-
-	/* makes matching the output of this method more bearable */
-	pub fn opt(&self) -> Result<&str, OptError> {
-		self.opt.as_ref().map(|o| o.as_str()).map_err(OptError::clone)
-	}
-
-	/* From getopt(3p):
-	 *
-	 * The variable optind is the index of the next element of the argv[]
-	 * vector to be processed. It shall be initialized to 1 by the system, and
-	 * getopt() shall update it when it finishes with each element of argv[].
-	 * If the application sets optind to zero  before calling getopt(), the
-	 * behavior is unspecified. When an element of argv[] contains multiple
-	 * option characters, it is unspecified how getopt() determines which
-	 * options have already been processed. */
-	pub fn ind(&self) -> usize { unsafe { *self.ind as usize } }
-
-	/* this is patently terrible and is only happening because I’m stubborn */
-	pub fn set_ind(&self, ind: i32) { unsafe { *self.ind = ind; } }
-}
-
-/* function signature */
-pub trait GetOpt {
-	fn getopt(&self, optstring: &str) -> Option<Opt>;
-}
-
-impl GetOpt for Vec<String> {
-    fn getopt(&self, optstring: &str) -> Option<Opt> {
-        let c_strings: Vec<_> = self
-			.iter()
-			.cloned()
-			.map(|x| CString::new(x).unwrap().into_raw())
-			.collect();
-
-		/* god knows what this does */
-		let boxed = Box::into_raw(c_strings.into_boxed_slice());
-		let argv = boxed as *const *mut c_char;
-
-		/* operations are separated out so that everything lives long enough */
-        let opts = CString::new(optstring).unwrap().into_raw();
-        let len = self.len() as c_int;
-
-        unsafe {
-            let ret = match getopt(len, argv, opts) { 
-				/* From getopt(3p):
-				 *
-				 * The getopt() function shall return the next option character
-				 * specified on the command line.
-				 *
-				 * A <colon> (':') shall be returned if getopt() detects a
-				 * missing argument and the first character of optstring was a
-				 * <colon> (':').
-				 *
-				 * A <question-mark> ('?') shall be returned if getopt()
-				 * encounters an option character not in optstring or detects a
-				 * missing argument and the first character of optstring was not
-				 * a <colon> (':').
-				 *
-				 * Otherwise, getopt() shall return -1 when all command line
-				 * options are parsed. */
-				58 => { /* ASCII ':' */
-					Some(Opt {
-						arg: None,
-						ind: std::ptr::addr_of_mut!(optind),
-						/* error containing option */
-						opt: Err(OptError::MissingArg(optopt.to_string())),
-					})
-				},
-				63 => { /* ASCII '?' */
-					Some(Opt {
-						arg: None,
-						ind: std::ptr::addr_of_mut!(optind),
-						/* error containing option */
-						opt: Err(OptError::UnknownOpt(optopt.to_string())),
-					})
-				},
-				/* From getopt(3p):
-				 *
-				 * If, when getopt() is called:
-				 *
-				 * argv[optind]  is a null pointer
-				 * *argv[optind]  is not the character -
-				 * argv[optind]  points to the string "-"
-				 *
-				 * getopt() shall return -1 without changing optind.  If:
-				 *
-				 * argv[optind]   points to the string "--"
-				 *
-				 * getopt() shall return -1 after incrementing optind. */
-                -1 => return None,
-                opt => {
-					let arg: Option<String>;
-
-					if optarg.is_null() { arg = None; }
-					else {
-						arg = Some(CStr::from_ptr(optarg)
-							.to_string_lossy()
-							.into_owned());
-					}
-
-					Some(Opt {
-						arg,
-						ind: std::ptr::addr_of_mut!(optind),
-						/* I didn’t need to cast this before; I rewrote the
-						 * pointer logic and now I do
-						 *
-						 * I don’t know why this is */
-						opt: Ok((opt as u8 as char).to_string()),
-					})
-				},
-            };
-
-			/* delloc argv (something online said I should do this) */
-			let _ = Box::from_raw(boxed);
-			return ret;
-        }
-    }
-}
-
-/* tests (good) */
-#[cfg(test)]
-mod tests {
-	use GetOpt;
-
-	#[test]
-	fn testing() {
-		let argv: Vec<String> = ["test", "-b", "-f", "arg", "-o", "arg"]
-			.iter()
-			.map(|s| s.to_string())
-			.collect();
-
-		while let Some(opt) = argv.getopt(":abf:o:") {
-			match opt.opt() {
-				Ok("a") => assert_eq!(opt.ind(), 1),
-				Ok("b") => assert_eq!(opt.ind(), 2),
-				Ok("f") | Ok("o") => {
-					assert_eq!(opt.arg(), Some("arg".into()));
-				},
-				_ => assert!(false),
-			};
-		}
-
-		if let Some(opt) = argv.getopt("abc:") {
-			opt.clone().set_ind(1);
-			assert_eq!(opt.ind(), 1);
-		}
-	}
-}

src/libopenbsd.rs

@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- * 
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-
-use std::{
-	ffi::{ CString, c_char },
-	io::Error,
-	ptr::null,
-};
-
-mod openbsd {
-	use std::ffi::{ c_char, c_int };
-	extern "C" {
-		pub fn pledge(arg1: *const c_char, arg2: *const c_char) -> c_int;
-
-		pub fn unveil(arg1: *const c_char, arg2: *const c_char) -> c_int;
-
-		pub fn __errno() -> *mut c_int;
-	}
-}
-
-pub struct Promises(*const c_char);
-
-impl Promises {
-	pub fn new(promises: &str) -> Self {
-		let p = CString::new(promises).unwrap();
-
-		Promises(p.into_raw() as *const c_char)
-	}
-}
-
-impl Default for Promises {
-	fn default() -> Self { Promises::new("") }
-}
-
-pub fn pledge(
-	promises: Option<Promises>, execpromises: Option<Promises>
-) -> Result<(), Error> {
-	/* From pledge(2):
-	 *
-	 * Passing NULL to promises or execpromises specifies to not change
-	 * the current value. */
-	let arg1 = promises.unwrap_or(Promises(null())).0;
-	let arg2 = execpromises.unwrap_or(Promises(null())).0;
-
-	unsafe {
-		match openbsd::pledge(arg1, arg2) {
-			-1 => Err(Error::from_raw_os_error(*openbsd::__errno())),
-			0 => Ok(()),
-			_ => panic!(), /* unreachable */
-		}
-	}
-}
-
-pub struct UnveilPerms(CString);
-
-impl UnveilPerms {
-	pub fn new<T: IntoIterator<Item = char>>(permissions: T) -> Self {
-		let perms = CString::new(
-			permissions.into_iter().collect::<String>()
-		).unwrap();
-		
-		UnveilPerms(perms)
-	}
-}
-
-pub fn unveil(
-	path: Option<&str>,
-	permissions: Option<UnveilPerms>,
-) -> Result<(), Error> {
-	let path_c = path.map(CString::new).map(Result::unwrap);
-	let arg1 = path_c.map(|p| p.into_raw() as *const c_char).unwrap_or(null());
-
-	let arg2 = permissions.map(|p| {
-		p.0.into_raw() as *const c_char
-	}).unwrap_or(null());
-
-	unsafe {
-		match openbsd::unveil(arg1, arg2) {
-			-1 => Err(Error::from_raw_os_error(*openbsd::__errno())),
-			0 => Ok(()),
-			_ => panic!(), /* unreachable */
-		}
-	}
-}

src/mm.c

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2024 DTB <trinity@trinity.moe>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+
+#include <errno.h> /* errno */
+#include <signal.h> /* signal(2), SIG_ERR, SIG_IGN, SIGINT */
+#include <stdio.h> /* fclose(3), fopen(3), fprintf(3), getc(3), putc(3),
+                    * setvbuf(3), size_t, _IONBF, NULL */
+#include <stdlib.h> /* free(3), realloc(3) */
+#include <string.h> /* strcmp(3), strerror(3) */
+#include <unistd.h> /* getopt(3) */
+#if !defined EX_IOERR || !defined EX_OK || !defined EX_OSERR \
+		|| !defined EX_USAGE
+#	include <sysexits.h>
+#endif
+extern int errno;
+
+/* This structure is how open files are tracked. */
+struct Files{
+	size_t a;	/* allocation */
+	size_t s;	/* used size */
+	char *mode;	/* file opening mode */
+	char **names;	/* file names */
+	FILE **files;	/* file pointers */
+};
+
+/* How much to grow the allocation when it's saturated. */
+#ifndef ALLOC_INCREMENT
+#	define ALLOC_INCREMENT 1
+#endif
+
+/* How much to grow the allocation at program start. */
+#ifndef ALLOC_INITIAL
+#	define ALLOC_INITIAL 10
+#endif
+
+/* pre-allocated strings */
+static char *program_name = "<no argv[0]>";
+static char *stdin_name = "<stdin>";
+static char *stdout_name = "<stdout>";
+static char *stderr_name = "<stderr>";
+static char *(fmode[]) = { (char []){"rb"}, (char []){"rb+"} };
+static char *wharsh = "wb";
+
+/* Adds the open FILE pointer for the file at the path s to the files struct,
+ * returning the FILE if successful and NULL if not, allocating more memory in
+ * the files buffers as needed. */
+static FILE *
+Files_append(struct Files *files, FILE *file, char *name){
+
+	if(file == NULL || (files->s == files->a
+			&& ((files->files = realloc(files->files,
+					(files->a += (files->a == 0)
+						? ALLOC_INITIAL
+						: ALLOC_INCREMENT)
+					* sizeof *(files->files))) == NULL
+				|| (files->names = realloc(files->names,
+					files->a * sizeof *(files->names))) == NULL)))
+		return NULL;
+
+	files->names[files->s] = name;
+	return files->files[files->s++] = file;
+}
+
+/* Opens the file at the path p and puts it in the files struct, returning NULL
+ * if either the opening or the placement of the open FILE pointer fail. */
+#define Files_open(files, p) \
+	Files_append((files), fopen((p), (files)->mode), (p))
+
+/* Prints a diagnostic message based on errno and returns an exit status
+ * appropriate for an OS error. */
+static int
+oserr(char *s, char *r){
+
+	fprintf(stderr, "%s: %s: %s\n", s, r, strerror(errno));
+
+	return EX_OSERR;
+}
+
+/* Hijacks i and j from main and destructs the files[2] struct used by main by
+ * closing its files and freeing its files and names arrays, returning retval
+ * from main. */
+#define terminate \
+	for(i = 0; i < 2; ++i){ \
+		for(j = 0; j < files[i].s; ++j) \
+			if(files[i].files[j] != stdin \
+					&& files[i].files[j] != stdout \
+					&& files[i].files[j] != stderr) \
+				fclose(files[i].files[j]); \
+		free(files[i].files); \
+		free(files[i].names); \
+	} \
+	return retval
+
+/* Prints a usage text, in which s is the program being run (i.e. argv[0]), and
+ * returns an exit status appropriate for a usage error. */
+int usage(char *s){
+
+	fprintf(stderr, "Usage: %s (-aenu) (-i [input])... (-o [output])...\n", s);
+
+	return EX_USAGE;
+}
+
+int main(int argc, char *argv[]){
+	int c;
+	struct Files files[2]; /* {read, write} */
+	size_t i;
+	size_t j;
+	size_t k; /* loop index but also unbuffer status */
+	int retval;
+
+	/* Initializes the files structs with their default values, standard
+	 * input and standard output. If an input or an output is specified
+	 * these initial values will be overwritten, so to, say, use mm(1)
+	 * equivalently to tee(1p), -o - will need to be specified before
+	 * additional files to ensure standard output is still written. */
+	for(i = 0; i < 2; ++i){
+		files[i].a = 0;
+		files[i].s = 0;
+		files[i].mode = fmode[i];
+		files[i].files = NULL;
+		files[i].names = NULL;
+		Files_append(&files[i], i == 0 ? stdin : stdout,
+			i == 0 ? stdin_name : stdout_name);
+		files[i].s = 0;
+	}
+
+	k = 0;
+
+	if(argc > 0)
+		program_name = argv[0];
+
+	if(argc > 1)
+		while((c = getopt(argc, argv, "aehi:no:u")) != -1)
+			switch(c){
+			case 'a': /* "rb+" -> "ab" */
+				files[1].mode[0] = 'a';
+				files[1].mode[2] = '\0';
+				break;
+			case 'e':
+				if(Files_append(&files[1], stderr, stderr_name) != NULL)
+					break;
+				retval = oserr(argv[0], "-e");
+				terminate;
+			case 'i':
+				if((strcmp(optarg, "-") == 0 && Files_append(&files[0],
+							stdin, stdin_name) != NULL)
+						|| Files_open(&files[0], optarg) != NULL)
+					break;
+				retval = oserr(argv[0], optarg);
+				terminate;
+			case 'o':
+				if((strcmp(optarg, "-") == 0 && Files_append(&files[1],
+							stdout, stdout_name) != NULL)
+						|| Files_open(&files[1], optarg) != NULL)
+					break;
+				/* does not exist, so try to create it */
+				if(errno == ENOENT){
+					files[1].mode = wharsh;
+					if(Files_open(&files[1], optarg) != NULL){
+						files[1].mode = fmode[1];
+						break;
+					}
+				}
+				retval = oserr(argv[0], optarg);
+				terminate;
+			case 'n':
+				if(signal(SIGINT, SIG_IGN) != SIG_ERR)
+					break;
+				retval = oserr(argv[0], "-n");
+				terminate;
+			case 'u':
+				k = 1;
+				break;
+			default:
+				retval = usage(argv[0]);
+				terminate;
+			}
+
+	if(optind != argc){
+		retval = usage(argv[0]);
+		terminate;
+	}
+
+	files[0].s += files[0].s == 0;
+	files[1].s += files[1].s == 0;
+	
+	/* Unbuffer files. */
+	if(k){
+		for(i = 0;
+			i < files[0].s;
+			setvbuf(files[0].files[i++], NULL, _IONBF, 0));
+		for(i = 0;
+			i < files[1].s;
+			setvbuf(files[1].files[i++], NULL, _IONBF, 0));
+	}
+
+	retval = EX_OK;
+
+	/* Actual program loop. */
+	for(i = 0; i < files[0].s; ++i) /* iterate ins */
+		while((c = getc(files[0].files[i])) != EOF) /* iterate chars */
+			for(j = 0; j < files[1].s; ++j) /* iterate outs */
+				if(putc(c, files[1].files[j]) == EOF){
+					/* notebook's full */
+					retval = EX_IOERR;
+					fprintf(stderr, "%s: %s: %s\n",
+						program_name, files[1].names[j], strerror(errno));
+					if(fclose(files[1].files[j]) == EOF)
+						fprintf(stderr, "%s: %s: %s\n",
+							program_name, files[1].names[j], strerror(errno));
+					/* massage out the tense muscle */
+					for(k = j--; k < files[1].s - 1; ++k){
+						files[1].files[k] = files[1].files[k+1];
+						files[1].names[k] = files[1].names[k+1];
+					}
+					if(--files[1].s == 0)
+						terminate;
+				}
+
+	terminate;
+}

src/mm.rs

@@ -1,231 +0,0 @@
-/*
- * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
- * Copyright (c) 2024 DTB <trinity@trinity.moe>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- * 
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-
-use std::{
-	env::args,
-	fs::File,
-	io::{ Error, BufWriter, Read, Write, stderr, stdin, stdout },
-	os::fd::{ AsRawFd, FromRawFd },
-	process::{ ExitCode, exit},
-};
-
-extern crate getopt;
-extern crate strerror;
-extern crate sysexits;
-
-use getopt::GetOpt;
-use strerror::StrError;
-use sysexits::{ EX_IOERR, EX_USAGE };
-
-#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
-#[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")]
-use openbsd::{
-	Promises,
-	UnveilPerms,
-	pledge,
-	unveil,
-};
-
-use ArgMode::*;
-
-enum ArgMode { In, Out }
-
-fn err(argv0: &String, e: Error, code: Option<u8>) -> ExitCode {
-	eprintln!("{}: {}", argv0, e.strerror());
-	ExitCode::from(code.unwrap_or(1 /* unknown error */))
-}
-
-fn usage(argv0: &String) -> ExitCode {
-	eprintln!("Usage: {} [-aetu] [-i input] [-o output]", argv0);
-	ExitCode::from(EX_USAGE)
-}
-
-fn main() -> ExitCode {
-	let argv = args().collect::<Vec<_>>();
-
-	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("cpath rpath stdio unveil wpath");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
-			return err(&argv[0], e, Some(EX_OSERR));
-		}
-	}
-
-	let mut a = false; /* append to the file */
-	let mut e = false; /* use stderr as an output */
-	let mut t = true; /* do not truncate the file before writing */
-	let mut u = false; /* unbuffer i/o */
-	let mut ins = Vec::new(); /* initial input file path vector */
-	let mut outs = Vec::new(); /* initial output file path vector */
-	let mut mode: Option<ArgMode> = None; /* mode set by last-used option */
-	let mut optind = 0;
-
-	while let Some(opt) = argv.getopt("aei:o:tu") {
-		match opt.opt() {
-			Ok("a") => a = true,
-			Ok("e") => e = true, 
-			Ok("u") => u = true,
-			Ok("t") => t = false,
-			Ok("i") => { /* add inputs */
-				let input = opt.arg().unwrap();
-				ins.push(input);
-				mode = Some(In); /* latest argument == -i */
-			},
-			Ok("o") => { /* add output */
-				let output = opt.arg().unwrap();
-				outs.push(output);
-				mode = Some(Out); /* latest argument == -o */
-			},
-			Err(_) | Ok(_) => {
-				return usage(&argv[0]);
-			},
-		};
-
-		optind = opt.ind();
-	}
-
-	let remaining = argv.iter().skip(optind);
-
-	/* check the last flag specified */
-	if let Some(m) = mode {
-		for arg in remaining {
-			/* move the subsequent arguments to the list of inputs or outputs */
-			match m {
-				In => ins.push(arg.to_string()),
-				Out => outs.push(arg.to_string()),
-			};
-		}
-	}
-
-	#[cfg(target_os="openbsd")] {
-		for input in &ins {
-			let perms = UnveilPerms::new(['r']);
-
-			if let Err(e) = unveil(Some(&input), Some(perms)) {
-				return err(&argv[0], e, Some(EX_OSERR));
-			}
-		}
-
-		for output in &outs {
-			let perms = UnveilPerms::new(['c', 'w']);
-
-			if let Err(e) = unveil(Some(&output), Some(perms)) {
-				return err(&argv[0], e, Some(EX_OSERR));
-			}
-		}
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e, Some(EX_OSERR));
-		}
-	}
-
-	if ins.is_empty() && outs.is_empty() && argv.len() > optind {
-		return usage(&argv[0]);
-	}
-
-	/* use stdin if no inputs are specified */
-	if ins.is_empty() { ins.push("-".to_string()); }
-
-	/* use stdout if no outputs are specified */
-	if outs.is_empty() && !e { outs.push("-".to_string()); }
-	
-	/* map all path strings to files */
-	let inputs = ins.iter().map(|file| {
-		/* if a file is “-”, it is stdin */
-		if *file == "-" {
-			/* portable way to access stdin as a file */
-			return unsafe { File::from_raw_fd(stdin().as_raw_fd()) };
-		}
-
-		match File::open(file) {
-			Ok(f) => f,
-			Err(e) => {
-				let _ = err(&(argv[0].clone() + ": " + file), e, None);
-				exit(EX_IOERR.into());
-			},
-		}
-	}).collect::<Vec<_>>();
-
-	/* map all path strings to files */
-	let mut outputs = outs.iter().map(|file| {
-		/* of a file is “-”, it is stdout */
-		if *file == "-" {
-			/* portable way to access stdout as a file */
-			return unsafe { File::from_raw_fd(stdout().as_raw_fd()) }; 
-		}
-
-		let options = File::options()
-			/* don’t truncate if -t is specified, append if -a is specified */
-			.truncate(t)
-			.append(a)
-			/* enable the ability to create and write to files */
-			.create(true)
-			.write(true)
-			/* finally, open the file! */
-			.open(file);
-
-		match options {
-			Ok(f) => return f,
-			Err(e) => {
-				let _ = err(&(argv[0].clone() + ": " + file), e, None);
-				exit(EX_IOERR.into());
-			},
-		};
-	}).collect::<Vec<_>>();
-
-	/* if -e is specified, use stderr */
-	if e {
-		/* portable way to access stderr as a file */
-		outputs.push(unsafe { File::from_raw_fd(stderr().as_raw_fd()) });
-	}
-
-	let mut outputs = outputs.iter().map(|o| {
-		if u {
-			/* unbuffered writing through a buffer of capacity 0 */
-			BufWriter::with_capacity(0, o)
-		} else {
-			/* theoretically buffered writing */
-			BufWriter::new(o)
-		}
-	}).collect::<Vec<_>>();
-
-	for file in inputs {
-		for byte in file.bytes().map(|b| {
-			b.unwrap_or_else(|e| {
-				let _ = err(&argv[0], e, None);
-				exit(EX_IOERR.into());
-			})
-		}) {
-			for out in &mut outputs {
-				if let Err(e) = out.write(&[byte]) {
-					return err(&argv[0], e, Some(EX_IOERR));
-				}
-
-				if u {
-					/* immediately flush the output for -u */
-					if let Err(e) = out.flush() { 
-						return err(&argv[0], e, Some(EX_IOERR));
-					}
-				}
-			}
-		}
-	}
-
-	ExitCode::SUCCESS
-}

src/npc.c

@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2023 DTB <trinity@trinity.moe>
- * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  *
  * This program is free software: you can redistribute it and/or modify it under
@@ -17,72 +16,46 @@
  * along with this program. If not, see https://www.gnu.org/licenses/.
  */
 
-#include <stdio.h> /* fprintf(3), fputs(3), getc(3), perror(3), putc(3), stdin,
+#include <stdio.h> /* fprintf(3), fputs(3), getc(3), putc(3), stdin, stdout,
-                    * stdout, EOF */
+                    * EOF */
-#include <sysexits.h> /* EX_IOERR, EX_OK, EX_OSERR, EX_USAGE */
+#include <stdlib.h> /* EXIT_FAILURE, EXIT_SUCCESS */
-#include <unistd.h> /* NULL, getopt(3), pledge(2), unveil(2) */
+#include <unistd.h> /* getopt(3) */
+#include <sysexits.h>
 
-char *program_name = "npc";
+int main(int argc, char *argv[]){
-
-static int
-ioerr(char *argv0) {
-	perror(argv0);
-
-	return EX_IOERR;
-}
-
-static int
-usage(char *argv0) {
-	(void)fprintf(stderr, "Usage: %s [-et]\n", argv0);
-
-	return EX_USAGE;
-}
-
-int main(int argc, char *argv[]) {
 	int c;
-	char showend = 0; /* print a dollar sign before each newline */
+	char showend;
-	char showtab = 0; /* prints tab characters in caret notation */
+	char showtab;
 
-#ifdef __OpenBSD__
+	showend = 0;
-	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL)) {
+	showtab = 0;
-		perror(argv[0] == NULL ? program_name : argv[0]);
-		return EX_OSERR;
-	}
-#endif
 
-	if (argc > 0) {
+	if(argc > 0)
-		program_name = argv[0];
+		while((c = getopt(argc, argv, "et")) != -1)
-
+			switch(c){
-		while ((c = getopt(argc, argv, "et")) != -1) {
+			case 'e':	showend = 1; break;
-			switch (c){
+			case 't':	showtab = 1; break;
-				case 'e': showend = 1; break;
+			default:	goto usage;
-				case 't': showtab = 1; break;
-				default:  return usage(program_name);
 			}
-		}
+
+	if(argc > optind){
+usage:		fprintf(stderr, "Usage: %s (-eht)\n", argv[0]);
+		return EX_USAGE;
 	}
 
-	if (argc > optind) { return usage(program_name); }
+	while((c = getc(stdin)) != EOF){
-
+		if((c & 0x80) != 0)
-	while ((c = getc(stdin)) != EOF) {
+			fputs("M-", stdout);
-		if ((c & 0x80) != 0 && fputs("M-", stdout) == EOF) {
+		switch(c ^ 0x80 /* 0b 1000 0000 */){
-			return ioerr(argv[0]);
+		case 0x7f:	fputs("^?", stdout);
-		}
-
-		switch (c ^ 0x80 /* 0b 1000 0000 */) {
-			case 0x7f: /* ASCII DEL (127d) */
-				if(fputs("^?", stdout) == EOF) { return ioerr(argv[0]); }
 				break;
-			case '\n':
+		case '\n':	if(showend)
-				if (showend && fputc('$', stdout) == EOF) {
+					putc('$', stdout);
-					return ioerr(argv[0]);
+		default:
-				}
+			if(c >= ' ' || c == '\n' || (!showtab && c == '\t'))
-			default:
+				putc(c, stdout);
-				if (c >= ' ' || c == '\n' || (!showtab && c == '\t')) {
+			else
-					if (fputc(c, stdout) == EOF) { return ioerr(argv[0]); }
+				fprintf(stdout, "^%c", c + '@');
-				} else if (fprintf(stdout, "^%c", c + '@') < 0) {
-					return ioerr(argv[0]);
-				}
 		}
 	}
 

src/peek.c

@@ -1,147 +0,0 @@
-/*
- * Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- * 
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-
-#include <signal.h> /* sigaction(2), signal(2), struct sigaction, SIGINT */
-#include <stdbool.h> /* bool */
-#include <stdio.h> /* fprintf(3), fgetc(3), perror(3), fputc(3), stderr, stdin,
-                    * stdout, EOF, NULL */
-#include <stdlib.h> /* exit(3), EXIT_FAILURE */
-#include <sysexits.h> /* EX_IOERR, EX_OK, EX_USAGE */
-#include <termios.h> /* tcgetattr(3), tcsetattr(3), struct termios, ECHO */
-#include <unistd.h> /* getopt(3), isatty(3), pledge(2), unveil(2),
-                     * STDIN_FILENO */
-
-char *program_name = "peek";
-
-/* Restores terminal echo; otherwise when a user ^Cs the terminal would
- * continue to not display typed text. If sig isn't zero, this will terminate
- * the program. */
-static void
-restore_echo(int sig) {
-	static struct termios t;
-
-	/* Failure isn't reported because this is the termination routine anyway;
-	 * errors will be obvious. */
-	if (tcgetattr(STDIN_FILENO, &t) == 0) {
-		t.c_lflag |= ECHO;
-		(void)tcsetattr(STDIN_FILENO, TCSAFLUSH, &t);
-	}
-
-	if (sig != 0) { exit(EXIT_FAILURE); } /* Terminated by signal. */
-
-	return;
-}
-
-static int
-ioerr(char *argv0) {
-	perror(argv0);
-	restore_echo(0);
-	return EX_IOERR;
-}
-
-static int
-usage(char *argv0) {
-	(void)fprintf(stderr, "Usage: %s [-i]\n", argv0);
-
-	return EX_USAGE;
-}
-
-int main(int argc, char *argv[]){
-	bool is_term; /* Is stdin a terminal? */
-	bool must_be_term = 1; /* Must it be? */
-
-#ifdef __OpenBSD__
-	if (pledge("stdio tty unveil", "") != 0 || unveil(NULL, NULL) != 0) {
-		/* This isn't fatal; these return values could be cast to void just as
-		 * easily. */
-		(void)perror(argv[0] == NULL ? argv[0] : program_name);
-	}
-#endif
-
-	is_term = isatty(STDIN_FILENO);
-
-	if (argc > 0) { /* option parsing */
-		int c;
-
-		program_name = argv[0];
-
-		while ((c = getopt(argc, argv, "i")) != -1) {
-			switch (c) {
-				case 'i':	must_be_term = 0; break;
-				default:	return usage(argv[0]);
-			}
-		}
-
-		if (argc > optind) { return usage(argv[0]); }
-	}
-
-	if (!is_term && must_be_term) {
-		(void)fprintf(
-		    stderr,
-		    "%s: Must be run in a terminal (specify -i to skip this check)\n",
-		    argv[0]
-		);
-		return EX_USAGE;
-	}
-
-	if (is_term) {
-		{ /* Install signal handler */
-			/* There isn't a difference in functionality between the signal(2)
-			 * and sigaction(2) methods. sigaction(2) is vastly preferred for
-			 * portability but some older systems only have signal(2). */
-			/* Errors aren't terminating because the worst that happens is some
-			 * terminal phooeyness if things go awry. */
-#if defined _POSIX_C_SOURCE
-			struct sigaction act = { 0 };
-
-			act.sa_handler = restore_echo;
-			if (sigaction(SIGINT, &act, NULL) != 0) { perror(program_name); }
-#else
-			if (signal(SIGINT, restore_echo) == SIG_ERR) {
-				perror(program_name);
-			}
-#endif
-		}
-
-		{ /* Banish terminal echo */
-			/* This terminates when it fails because it's the whole point of
-			 * the program. */
-			struct termios t;
-
-			if (tcgetattr(STDIN_FILENO, &t) != 0) {
-				return ioerr(program_name);
-			}
-			t.c_lflag ^= ECHO;
-			if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t) != 0) {
-				return ioerr(program_name);
-			}
-		}
-	}
-
-	{ /* Input loop */
-		int c;
-
-		while ((c = fgetc(stdin)) != EOF) {
-			if (fputc(c, stdout) == EOF) { return ioerr(program_name); }
-		}
-	}
-
-	if (is_term) { restore_echo(0); }
-
-	return EX_OK;
-}

src/rpn.rs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024–2025 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  *
  * This program is free software: you can redistribute it and/or modify it under
@@ -46,24 +46,18 @@ use std::{
 	collections::VecDeque,
 	env::args,
 	fmt::{ self, Display, Formatter },
-	io::{ Error, Write, stdin, stdout },
+	io::stdin,
 	process::ExitCode,
 };
 
 use CalcType::*;
 
-extern crate strerror;
 extern crate sysexits;
 
-use strerror::StrError;
+use sysexits::EX_DATAERR;
-use sysexits::{ EX_DATAERR, EX_IOERR };
-
-#[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
-#[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
 
 #[derive(Clone, PartialEq, PartialOrd, Debug)]
-/* enum CalcType is a type containing operations used in the calculator */
+// enum CalcType is a type containing operations used in the calculator
 enum CalcType {
 	Add,
 	Subtract,
@@ -120,46 +114,12 @@ impl Display for CalcType {
 #[derive(Debug, Clone)]
 struct EvaluationError {
 	message: String,
-	code: u8,
+	code: i32,
 }
 
-impl StrError for EvaluationError {
+// I’m no math nerd but I want the highest possible approximation of 0.9
-	fn strerror(&self) -> String {
+// repeating and it seems this can give it to me
-		self.message.clone()
+const PRECISION_MOD: f64 = 0.9 + f64::EPSILON * 100.0;
-	}
-}
-
-fn err<T: StrError>(argv0: &String, e: &T, code: Option<u8>) -> ExitCode {
-	eprintln!("{}: {}", argv0, e.strerror());
-	ExitCode::from(code.unwrap_or(1 /* unknown error */))
-}
-
-fn operate(
-	mut stack: VecDeque<f64>,
-	op: CalcType,
-) -> Result<VecDeque<f64>, EvaluationError> {
-	let vals = (stack.pop_back(), stack.pop_back());
-
-	if let (Some(x), Some(y)) = vals {
-		match op {
-			Add => stack.push_back(y + x),
-			Subtract => stack.push_back(y - x),
-			Multiply => stack.push_back(y * x),
-			Divide => stack.push_back(y / x),
-			Power => stack.push_back(y.powf(x)),
-			Floor => stack.push_back((y / x).floor()),
-			Modulo => stack.push_back(y % x),
-			_ => {},
-		};
-	} else {
-		return Err(EvaluationError {
-			message: format!("{}: unexpected operation", op),
-			code: EX_DATAERR,
-		})
-	}
-
-	Ok(stack)
-}
 
 fn eval(
 	input: &str,
@@ -173,13 +133,12 @@ fn eval(
 		return Ok((stack, oper));
 	}
 
-	/* Split the input into tokens. */
+	// Split the input into tokens.
 	let mut toks: VecDeque<CalcType> = input
 		.split_whitespace()
 		.rev()
 		.map(|t| CalcType::from(t))
 		.collect();
-
 	let mut ops: VecDeque<CalcType> = VecDeque::new();
 
 	while let Some(n) = toks.pop_back() {
@@ -187,15 +146,36 @@ fn eval(
 			Val(v) => stack.push_back(v),
 			Invalid(i) => {
 				return Err(EvaluationError {
-					message: format!("{}: invalid token", i),
+					message: format!("{}: Invalid token", i),
 					code: EX_DATAERR,
 				})
 			},
 			op => {
 				ops.push_back(op.clone());
+				oper = true;
 
-				oper = true; /* this is an operation */
+				let vals = (
-				return operate(stack, op).map(|s| (s, oper));
+					stack.pop_back(),
+					stack.pop_back(),
+				);
+
+				if let (Some(x), Some(y)) = vals {
+					match op {
+						Add => stack.push_back(y + x),
+						Subtract => stack.push_back(y - x),
+						Multiply => stack.push_back(y * x),
+						Divide => stack.push_back(y / x),
+						Power => stack.push_back(y.powf(x)),
+						Floor => stack.push_back((y / x).floor()),
+						Modulo => stack.push_back(y % x),
+						_ => {},
+					};
+				} else {
+					return Err(EvaluationError {
+						message: format!("{}: Unexpected operation", op),
+						code: EX_DATAERR,
+					})
+				}
 			},
 		};
 	}
@@ -203,95 +183,66 @@ fn eval(
 	Ok((stack, oper))
 }
 
-/* Round a float to the given precision level */
+// Round a float to the given precision level
-fn round_precise(value: &f64) -> f64 {
+fn round_precise(value: &f64, precision: usize) -> f64 {
-	/* Set floating-point precision for correcting rounding errors based on
+	let multiplier = 10_f64.powi(precision as i32);
-	 * machine epsilon */
-	let precision = (-f64::EPSILON.log10()).floor() as i32;
-	let multiplier = 10_f64.powi(precision);
-
 	(value * multiplier).round() / multiplier
 }
 
-/* print the stack and let the caller know if evaluation should continue */
-fn unstack(stack: VecDeque<f64>, op: bool) -> Result<bool, Error> {
-	if let Some(val) = stack.iter().last() {
-		if !op { return Ok(true); }
-
-		let out = round_precise(val).to_string() + &'\n'.to_string();
-
-		return stdout().write_all(out.as_bytes()).map(|_| true);
-	} else {
-		return Ok(false);
-	}
-}
-
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
-
-	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio unveil");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
-			return err(&argv[0], &e, Some(EX_OSERR));
-		}
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], &e, Some(EX_OSERR));
-		}
-	}
-
 	let mut stack = VecDeque::new();
 	let mut buf = String::new();
+	// Set floating-point precision for correcting rounding errors based on
+	// machine epsilon
+	let precision = (-f64::EPSILON.log10() * PRECISION_MOD).ceil() as usize;
+	
+	if argv.get(1).is_none() {
+		while let Ok(_) = stdin().read_line(&mut buf) {
+			match eval(&buf.trim(), stack) {
+				Ok(s) => {
+					buf.clear();
+					stack = s.0.clone();
 
-	if argv.get(1).is_some() { /* read expressions from argv */
+					let val = match stack.iter().last() {
-		/* join argv into an owned String joined by spaces minus argv[0] */
+						Some(v) => v,
+						None => break,
+					};
+
+					if s.1 == false { continue; }
+
+					println!("{}", round_precise(val, precision).to_string());
+				},
+				Err(err) => {
+					eprintln!("{}: {}", argv[0], err.message);
+					return ExitCode::from(err.code as u8);
+				},
+			};
+		}
+	} else {
 		let input = argv
 			.iter()
 			.skip(1)
 			.map(|x| x.to_owned())
-			.collect::<Vec<_>>()
+			.collect::<Vec<String>>()
 			.join(" ");
 
 		match eval(&input, stack) {
 			Ok(s) => {
-				/* we can ignore the return value of unstack() because we are
+				stack = s.0.clone();
-				 * not continually evaluating from stdin */
-				if let Err(e) = unstack(s.0.clone(), s.1.clone()) {
-					return err(&argv[0], &e, Some(EX_IOERR));
-				}
 
-				return ExitCode::SUCCESS;
+				let val = match stack.iter().last() {
-			},
+					Some(v) => v,
-			Err(e) => {
+					None => return ExitCode::from(0),
-				return err(&argv[0], &e, Some(e.code));
-			},
-		};
-	}
-
-	/* else, read from stdin */
-	loop { /* take input until EOF */
-		if let Err(e) = stdin().read_line(&mut buf) {
-			return err(&argv[0], &e, Some(EX_IOERR));
-		}
-
-		match eval(&buf.trim(), stack) {
-			Ok(s) => {
-				buf.clear();
-				stack = s.0.clone(); /* out with the old, in with the new */
-
-				match unstack(s.0, s.1) {
-					Ok(b) if b => continue,
-					Ok(_) => break,
-					Err(e) => {
-						return err(&argv[0], &e, Some(EX_IOERR))
-					},
 				};
+
+				println!("{}", round_precise(val, precision).to_string())
 			},
-			Err(e) => {
+			Err(err) => {
-				return err(&argv[0], &e, Some(e.code));
+				eprintln!("{}: {}", argv[0], err.message);
+				return ExitCode::from(err.code as u8);
 			},
 		};
 	}
-
+	ExitCode::from(0)
-	ExitCode::SUCCESS
 }

src/scrut.c

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
+ * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://www.gnu.org/licenses/.
+ */
+
+#include <stdio.h> /* fprintf(3), stderr, NULL */
+#include <stdlib.h> /* EXIT_FAILURE, EXIT_SUCCESS */
+#include <string.h> /* memset(3), strchr(3) */
+#ifndef EX_USAGE
+#	include <sysexits.h>
+#endif
+#include <unistd.h> /* access(3), getopt(3), F_OK, R_OK, W_OK, X_OK */
+#include <sys/stat.h> /* lstat(3), stat struct, S_ISBLK, S_ISCHR, S_ISDIR,
+                       * S_ISFIFO, S_ISGID, S_ISREG, S_ISLNK, S_ISSOCK,
+                       * S_ISUID, S_ISVTX */
+
+static char args[] = "bcdefghkprsuwxLS";
+static char ops[(sizeof args) / (sizeof *args)];
+static char *program_name = "scrut";
+
+int main(int argc, char *argv[]){
+	struct stat buf;
+	int c;
+	size_t i;
+	char *p;
+
+	if(argc < 2)
+		goto usage;
+
+	memset(ops, '\0', sizeof ops);
+	while((c = getopt(argc, argv, args)) != -1)
+		if((p = strchr(args, c)) == NULL)
+			goto usage;
+		else
+			ops[p - args] = c;
+	/* straighten out ops */
+	for(i = 0, p = ops; i < (sizeof ops) / (sizeof *ops); ++i)
+		if(ops[i] != '\0'){
+			*p = ops[i];
+			if(&ops[i] != p++)
+				ops[i] = '\0';
+		}
+
+	if(optind == argc)
+		goto usage;
+
+	argv += optind;
+	do{	if(access(*argv, F_OK) != 0 || lstat(*argv, &buf) == -1)
+			return EXIT_FAILURE; /* doesn't exist or isn't stattable */
+
+		for(i = 0; ops[i] != '\0'; ++i)
+			if(ops[i] == 'e')
+				continue;
+			else if(ops[i] == 'h'){
+usage:				fprintf(stderr, "Usage: %s (-%s) [file...]\n",
+					argv[0] == NULL
+						? program_name
+						: argv[0],
+					args);
+
+				return EX_USAGE;
+			}else if(
+					(ops[i] == 'b'
+						&& !S_ISBLK(buf.st_mode))
+					|| (ops[i] == 'c'
+						&& !S_ISCHR(buf.st_mode))
+					|| (ops[i] == 'd'
+						&& !S_ISDIR(buf.st_mode))
+					|| (ops[i] == 'f'
+						&& !S_ISREG(buf.st_mode))
+					|| (ops[i] == 'g'
+						&& !(buf.st_mode & S_ISGID))
+					|| (ops[i] == 'k'
+						&& !(buf.st_mode & S_ISVTX))
+					|| (ops[i] == 'p'
+						&& !S_ISFIFO(buf.st_mode))
+					|| (ops[i] == 'r'
+						&& access(*argv, R_OK) != 0)
+					|| (ops[i] == 'u'
+						&& !(buf.st_mode & S_ISUID))
+					|| (ops[i] == 'w'
+						&& access(*argv, W_OK) != 0)
+					|| (ops[i] == 'x'
+						&& access(*argv, X_OK) != 0)
+					|| (ops[i] == 'L'
+						&& !S_ISLNK(buf.st_mode))
+					|| (ops[i] == 'S'
+						&& !S_ISSOCK(buf.st_mode)))
+				return EXIT_FAILURE;
+	}while(*++argv != NULL);
+
+	return EXIT_SUCCESS;
+}

src/str.c

@@ -19,21 +19,17 @@
 
 #include <ctype.h>
 #include <stddef.h> /* NULL */
-#include <stdio.h> /* fprintf(3), perror(3) */
+#include <stdio.h> /* fprintf(3) */
-#include <stdlib.h> /* size_t, EXIT_FAILURE */
+#include <stdlib.h> /* EXIT_FAILURE */
 #include <string.h> /* strcmp(3) */
-#include <sysexits.h> /* EX_OSERR, EX_USAGE */
+#include <sysexits.h>
 
-#ifdef __OpenBSD__
+static char *program_name = "str";
-#	include <unistd.h> /* pledge(2), unveil(2) */
-#endif
-
-char *program_name = "str";
 
 static struct {
 	char *name;
 	int (*f)(int);
-} ctypes[] = {
+}ctypes[] = {
 	{ "isalnum", isalnum },
 	{ "isalpha", isalpha },
 	{ "isblank", isblank },
@@ -45,52 +41,35 @@ static struct {
 	{ "isprint", isprint },
 	{ "ispunct", ispunct },
 	{ "isspace", isspace },
-	{ "isupper", isupper },
+	{ "isupper", isupper }
-	{ NULL, NULL } /* marks end */
 };
 
-static int
+int main(int argc, char *argv[]){
-usage(char *argv0) {
+	int ctype;
-	(void)fprintf(stderr, "Usage: %s type string...\n", argv0);
+	int i;
+	int r;
+
+	if(argc >= 3){
+		for(ctype = 0; ctype < (sizeof ctypes) / (sizeof *ctypes);
+				++ctype)
+			if(strcmp(argv[1], ctypes[ctype].name) == 0)
+				goto pass;
+	}
+
+	fprintf(stderr, "Usage: %s [type] [string...]\n",
+		argv[0] == NULL ? program_name : argv[0]);
 
 	return EX_USAGE;
-}
+
-
+pass:	for(argv += 2, r = 1; *argv != NULL; ++argv)
-int main(int argc, char *argv[]) {
+		for(i = 0; argv[0][i] != '\0'; ++i)
-	size_t ctype; // selected from ctypes.h; index of ctype
+			/* First checks if argv[0][i] is valid ASCII; ctypes(3)
-	int retval; // initially fail but becomes success on the first valid char
+			 * don't handle non-ASCII.
-	program_name = argv[0] == NULL ? program_name : argv[0];
+			 * This is bad. */
-
+			if((unsigned char)argv[0][i] < 0x80 && !ctypes[ctype].f(argv[0][i]))
-#ifdef __OpenBSD__
+				return 1;
-	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL) == -1) {
+			else
-		perror(program_name);
+				r = 0;
-		return EX_OSERR;
+
-	}
+	return r;
-#endif
-
-	if (argc < 3) { return usage(program_name); }
-
-	for ( /* iterate ctypes */
-		ctype = 0;
-		ctypes[ctype].f != NULL /* break at the end of ctypes */
-			&& strcmp(argv[1], ctypes[ctype].name) != 0; /* break at match */
-		++ctype
-	);
-
-	if (ctypes[ctype].f == NULL) { return usage(argv[0]); }
-
-	/* iterate args */
-	for (argv += 2, retval = EXIT_FAILURE; *argv != NULL; ++argv) {
-		for (size_t i = 0; argv[0][i] != '\0'; ++i) { /* iterate arg bytes */
-			/* First checks if argv[0][i] is valid ASCII; ctypes(3) don't
-			 * handle non-ASCII. This is bad. */
-			if(
-				(unsigned char)argv[0][i] < 0x80 // argv[0][i] is ASCII,
-					&& !ctypes[ctype].f(argv[0][i]) // so use ctypes(3)
-			) { return EXIT_FAILURE; }
-			else { retval = EXIT_SUCCESS; }
-		}
-	}
-
-	return retval;
 }

src/strcmp.c

@@ -1,62 +1,24 @@
-/*
+#include <stdio.h> /* fprintf(3), stderr */
- * Copyright (c) 2023 DTB <trinity@trinity.moe>
+#include <stdlib.h> /* EXIT_FAILURE */
- * Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+#include <sysexits.h>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Affero General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see https://www.gnu.org/licenses/.
- */
-#include <stdio.h> /* fprintf(3), perror(3), stderr */
-#include <sysexits.h> /* EX_OK, EX_OSERR, EX_USAGE */
 
-#ifdef __OpenBSD__
+static char *program_name = "strcmp";
-#	include <unistd.h> /* pledge(2), unveil(2) */
-#endif
 
-char *program_name = "strcmp";
+int main(int argc, char *argv[]){
-
+	int i;
-int main(int argc, char *argv[]) {
-	unsigned int i;
-
-#ifdef __OpenBSD__
-	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL) == -1) {
-		perror(argv[0] == NULL ? program_name : argv[0]);
-
-		return EX_OSERR;
-	}
-#endif
-
-	if (argc < 3) {
-		(void)fprintf(
-			stderr,
-			"Usage: %s string string...\n",
-			argv[0] == NULL ? program_name : argv[0]
-		);
 
+	if(argc < 3){
+		fprintf(stderr, "Usage: %s [string] [string...]\n",
+			argv[0] == NULL ? program_name : argv[0]);
 		return EX_USAGE;
 	}
 
-	for (; *argv[1] != '\0'; ++argv[1]) {
+	for(; *argv[1] != '\0'; ++argv[1])
-		for (i = 2; i < argc; ++i) {
+		for(i = 2; i < argc; ++i)
-			/* a former string has a greater byte value */
+			if(*argv[i-1] > *argv[i])
-			if (*argv[i-1] > *argv[i]) { 
 				return 1;
-			/* a latter string has a greater byte value */
+			else if(*argv[i-1] < *argv[i]++)
-			} else if (*argv[i-1] < *argv[i]++) {
 				return -1; /* actually 255 */
-			}
-		}
-	}
 
-	return EX_OK;
+	return 0;
 }

src/swab.rs

@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2024 DTB <trinity@trinity.moe>
- * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  *
  * This program is free software: you can redistribute it and/or modify it under
@@ -19,89 +18,73 @@
 
 use std::{
 	env::args,
-	io::{ stdin, stdout, Error, Read, Write },
+	io::{ stdin, stdout, Error, ErrorKind, Read, Write },
 	process::ExitCode,
 	vec::Vec
 };
 
 extern crate getopt;
+use getopt::{ Opt, Parser };
+
 extern crate sysexits;
-extern crate strerror;
+use sysexits::{ EX_OK, EX_OSERR, EX_USAGE };
 
-use getopt::GetOpt;
+fn oserr(s: &str, e: Error) -> ExitCode {
-use sysexits::{ EX_IOERR, EX_OK, EX_OSERR, EX_USAGE };
+	eprintln!("{}: {}", s, e);
-use strerror::StrError;
+	ExitCode::from(EX_OSERR as u8)
-
-#[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
-
-fn err(argv0: &String, e: Error, code: u8) -> ExitCode {
-	eprintln!("{}: {}", argv0, e.strerror());
-	ExitCode::from(code)
 }
 
-fn usage(s: &String) -> ExitCode {
+fn usage(s: &str) -> ExitCode {
-	eprintln!("Usage: {} [-w word_size]", s);
+	eprintln!("Usage: {} (-f) (-w [wordsize])", s);
-	ExitCode::from(EX_USAGE)
+	ExitCode::from(EX_USAGE as u8)
 }
 
 fn main() -> ExitCode {
 	let argv = args().collect::<Vec<String>>();
-	
+	let mut buf: Vec<u8> = Vec::new();
-	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("stdio unveil");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
-			return err(&argv[0], e, EX_OSERR);
-		}
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e, EX_OSERR);
-		}
-	}
-
-	let mut buf: Vec<u8> = Vec::new(); // holds the sequence getting swabbed
 	let mut input = stdin();
 	let mut output = stdout().lock();
-	let mut optind: usize = 1;   // argv[0]
-	let mut wordsize: usize = 2; // default; mimics dd(1p) conv=swab
 
-	while let Some(opt) = argv.getopt("w:") {
+	let mut opts = Parser::new(&argv, "fw:");
-		match opt.opt() {
+	let mut force = false;
-			Ok("w") => {
+	let mut wordsize: usize = 2;
-					match opt.arg().unwrap().parse::<usize>() {
+
-						Ok(w) if w % 2 == 0 => { wordsize = w; },
+	loop {
-						_ => { return usage(&argv[0]); },
+		match opts.next() {
-					}
+			None => break,
-				optind = opt.ind();
+			Some(opt) =>
-			},
+				match opt {
-			_ => { return usage(&argv[0]); }
+					Ok(Opt('f', None)) => force = true,
+					Ok(Opt('w', Some(arg))) => {
+						match arg.parse::<usize>() {
+							Ok(w) if w % 2 == 0 => { wordsize = w; () },
+							_ => { return usage(&argv[0]); },
+						}
+					},
+					_ => { return usage(&argv[0]); }
+				}
 		}
 	}
 
-	if optind < argv.len() {
-		return usage(&argv[0]);
-	}
-
 	buf.resize(wordsize, 0);
 
 	loop {
 		match input.read(&mut buf) {
-			Ok(0) => break ExitCode::from(EX_OK), // read nothing; bye
+			Ok(0) => break ExitCode::from(EX_OK as u8),
-			Ok(v) if v == wordsize => { // read full block; swab
+			Ok(v) if v == wordsize => {
 				let (left, right) = buf.split_at(v/2);
-
 				if let Err(e) = output.write(&right)
 						.and_then(|_| output.write(&left)) {
-					break err(&argv[0], e, EX_IOERR);
+					break oserr(&argv[0], e)
 				}
-
 			},
-			Ok(v) => { // partial read; partially write
+			Ok(v) => {
 				if let Err(e) = output.write(&buf[..v]) {
-					break err(&argv[0], e, EX_IOERR);
+					break oserr(&argv[0], e)
 				}
 			},
-			Err(e) => break err(&argv[0], e, EX_OSERR)
+			Err(e) if e.kind() == ErrorKind::Interrupted && force => continue,
+			Err(e) => break oserr(&argv[0], e)
 		}
 	}
 }

src/true.c

@@ -1,18 +1,9 @@
 /*
- * Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+ * Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
- * Copyright (c) 2024 DTB <trinity@trinity.moe>
  * SPDX-License-Identifier: CC0
  *
  * This work is marked with CC0 1.0. To view a copy of this license, visit
  * <http://creativecommons.org/publicdomain/zero/1.0>.
  */
 
-#ifdef __OpenBSD__
+int main() {}
-#	include <unistd.h> /* pledge(2) */
-#endif
-
-int main(void) {
-#ifdef __OpenBSD__
-	(void)pledge("stdio", "");
-#endif
-}

tests/README

@@ -1,25 +0,0 @@
-Tests
-=====
-
-The Harakit testing suite verifies the functionality of Harakit utilities
-and checks for regressions and other issues relating to compliance to our
-standards of practice.
-
-Tests inherit the environment set by the top-level Makefile, which sets the BIN
-variable to the build/bin directory at the root of the project; therefore, each
-binary is located at $(BIN)/tool for idiomatic access.
-
-Each test contains a set of PHONY targets which are prefixed with the name of
-the tool being tested and an underscore. The first target is tests, which
-depends on all the other targets in the test file. These test files are each
-included in the top Makefile, so they can be called from the root of the
-repository. This also means that BIN can be set manually so that tests can be
-run using make(1) inside of the tests directory:
-
-	$ make -f dj.mk BIN=../build/bin dj_tests
-
---
-Copyright © 2024–2025 Emma Tebibyte <emma@tebibyte.media>
-
-This work is licensed under CC BY-SA 4.0. To view a copy of this license, visit
-<http://creativecommons.org/licenses/by-sa/4.0/>.

tests/dj.mk

@@ -1,48 +0,0 @@
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PRAGMA: command_comment
-
-/dev/full:
-/dev/null:
-
-.PHONY: dj_tests
-dj_tests: dj_help dj_full dj_null # dj_skip_stdin
-
-.PHONY: dj_full
-# Linux has a /dev/full pseudodevice useful for testing errors.
-dj_full: $(BIN)/dj /dev/full
-	case "$$(uname)" in \
-	Linux) \
-		! $(BIN)/dj -Hi /dev/zero -o /dev/full 2>&1 \
-			| tee /dev/stderr \
-			| xargs -I out test '1+0 > 0+0; 1024 > 0' = out \
-		;; \
-	esac
-
-.PHONY: dj_help
-dj_help: $(BIN)/dj
-	! $(BIN)/dj -h
-
-.PHONY: dj_null
-# Read nothing from /dev/null, write nothing to /dev/null.
-dj_null: $(BIN)/dj /dev/null
-	$(BIN)/dj -Hi /dev/null -o /dev/null 2>&1 \
-		| tee /dev/stderr \
-		| xargs -I out test '0+0 > 0+0; 0 > 0' = out
-
-# This test currently fails. This is probably due to dj(1) being stale relative
-# to the main harakit branch. TODO: Reassess once the testing branch is merged.
-# .PHONY: dj_skip_stdin
-# # Test skipping stdin.
-# dj_skip_stdin: $(BIN)/dj
-# 	# Pipe 1024B of '\0' into dj(1); skip the first 24B; expect 1000B written.
-# 	dd count=1 bs=1024 </dev/zero 2>/dev/null \
-# 		| $(BIN)/dj -H -s 24 -o /dev/null 2>&1 \
-# 		| tee /dev/stderr \
-# 		| xargs -I out test '1+0 > 1+0; 1024 > 1000' = out

tests/false.mk

@@ -1,18 +0,0 @@
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PHONY: false_tests
-false_tests: false_test false_help
-
-.PHONY: false
-false_test: $(BIN)/false
-	! $(BIN)/false
-
-.PHONY: false_help
-false_help: $(BIN)/false
-	! $(BIN)/false -h

tests/fileis.mk

@@ -1,46 +0,0 @@
-#!/bin/sh
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PRAGMA: command_comment
-
-.PHONY: fileis_tests 
-fileis_tests: fileis_help fileis_options
-
-.PHONY: fileis_help
-fileis_help: $(BIN)/fileis
-	! $(BIN)/fileis -h
-
-.PHONY: fileis_options
-# fileis tests file attributes, but files of a certain attribute aren't
-# guaranteed to be present on a system. This test checks all of the files in
-# harakit and, if test(1p) says a file matches a certain attribute, then checks
-# fileis.
-# opts are space-delimited (for command splitting), sel is not
-fileis_options: $(BIN)/fileis
-	set -e; \
-	opts="b c d e f g k p r s u w x L S"; \
-	sel=; \
-	find . -name .git -prune -o -print \
-		| while read -r f; do \
-			for opt in $$opts; \
-				do if ! printf "%s\n" $$sel | grep $$opt >/dev/null; then \
-					if test -$$opt "$$f"; then \
-						if ! $(BIN)/fileis -$$opt "$$f"; \
-							then printf "[!!] fileis -%s failed on %s.\n" \
-								$$opt "$$f"; \
-						fi; \
-						sel="$$sel$$opt"; \
-						printf "[OK] Tested fileis -%s using %s\n" \
-							$$opt "$$f"; \
-					fi; \
-				fi; \
-			done; \
-			if printf "%s\n" "$$opts" | sed 's/ //g' | xargs test "$$sel" =; \
-				then break; \
-			fi; \
-		done

tests/fop.mk

@@ -1,32 +0,0 @@
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PHONY: fop_tests
-fop_tests: fop_functionality fop_delimiter fop_help fop_fail
-
-.PHONY: fop_help
-fop_help: $(BIN)/fop
-	! $(BIN)/fop -h
-
-.PHONY: fop_delimiter
-fop_delimiter: $(BIN)/fop
-	test "$$(printf 'test1 test1 test1\n' | $(BIN)/fop -d' ' 2 sed 's/1/4/g')" \
-		= 'test1 test1 test4'
-	test "$$(printf 'meowsetwoofsetribbit\n' \
-		| $(BIN)/fop -d 'set' 1 sed 's/woof/meow/g')" = 'meowsetmeowsetribbit'
-
-.PHONY: fop_fail
-fop_fail: $(BIN)/fop
-	! printf 'test\n' | $(BIN)/fop 1 cat
-	! printf 'test\n' | $(BIN)/fop 'test' cat
-	! printf 'test\n' | $(BIN)/fop -d'test' cat
-	! $(BIN)/fop
-
-.PHONY: fop_functionality
-fop_functionality: $(BIN)/fop
-	test "$$(printf 'test1\036test1\036test1\n' | $(BIN)/fop 1 sed 's/1/4/g')" \
-		= "$$(printf 'test1\036test4\036test1\n')"

tests/hru.mk

@@ -1,32 +0,0 @@
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PHONY: hru_tests
-hru_tests: hru_help hru_functionality hru_negative hru_regressions
-
-.PHONY: hru_help
-hru_help: $(BIN)/hru
-	! $(BIN)/hru -h
-
-.PHONY: hru_functionality
-hru_functionality: $(BIN)/hru
-	test "$$(printf '1234\n' | $(BIN)/hru)" = '1.2 kB'
-	test "$$(printf '0\n' | $(BIN)/hru)" = '0 B'
-
-.PHONY: hru_negative
-hru_negative: $(BIN)/hru
-	! printf '%s\n' '-1' | $(BIN)/hru
-
-.PHONY: hru_regressions
-hru_regressions: $(BIN)/hru
-	n=1; \
-	while true; \
-	do \
-		printf '%s\n' "$$n" | $(BIN)/hru || break; \
-		n="$$(($$n * 10))"; \
-	done; \
-	printf 'Max float: %s\n' "$$n"

tests/intcmp.mk

@@ -1,67 +0,0 @@
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PHONY: intcmp_tests
-intcmp_tests: intcmp_help intcmp_none intcmp_e intcmp_g intcmp_l intcmp_combined
-
-.PHONY: intcmp_help
-intcmp_help: $(BIN)/intcmp
-	! $(BIN)/intcmp -h
-
-# These test that integer comparisons are working as they should. For the sake
-# of readability (to facilitate faster skimming) these recipes follow a
-# columned format:
-#	$binary       -flags d d d d  # op
-# For flag meanings reference intcmp(1) (though they are somewhat self
-# explanatory). d here refers to a decimal number; a mixture of 1s, 2s, and 3s
-# (a particularly lovely number) arranged to demonstrate easily the operation
-# under scrutiny. The commented op is the operation that is true for the given
-# numbers. For example:
-#	$(BIN)/intcmp   -e   3 3 3 3  # ==
-# op here is ==; 3 == 3 == 3 == 3. The flag being used is -e, to test for
-# equality, so this test should succeed.
-#	! $(BIN)/intcmp -l   3 2 1    # >
-# op here is >; 3 > 2 > 1. The flag being used is -l, to test for each integer
-# being less than the next, so intcmp should fail - hence the ! at the start of
-# the invocation. If this test failed, intcmp(1) would be confusing -l for -g,
-# so that would be a good place to start looking for bugs.
-
-.PHONY: intcmp_none
-intcmp_none: $(BIN)/intcmp
-	! $(BIN)/intcmp 1 2
-
-.PHONY: intcmp_e
-intcmp_e: $(BIN)/intcmp
-	$(BIN)/intcmp   -e   3 3 3    # ==
-	! $(BIN)/intcmp -e   1 2 3    # <
-	! $(BIN)/intcmp -e   3 2 1    # >
-
-.PHONY: intcmp_g
-intcmp_g: $(BIN)/intcmp
-	$(BIN)/intcmp   -g   3 2 1    # >
-	! $(BIN)/intcmp -g   3 3 3    # ==
-	! $(BIN)/intcmp -g   1 2 3    # <
-	$(BIN)/intcmp   -ge  3 3 1    # >=
-	! $(BIN)/intcmp -ge  1 2 3    # <
-
-.PHONY: intcmp_l
-intcmp_l: $(BIN)/intcmp
-	$(BIN)/intcmp   -l   1 2 3    # <
-	! $(BIN)/intcmp -l   3 3 3    # ==
-	! $(BIN)/intcmp -l   3 2 1    # >
-	$(BIN)/intcmp   -le  1 3 3    # <=
-	! $(BIN)/intcmp -le  3 2 1    # >
-
-.PHONY: intcmp_combined
-intcmp_combined: $(BIN)/intcmp
-	$(BIN)/intcmp   -gl  1 2 3    # <
-	$(BIN)/intcmp   -gl  3 2 1    # >
-	$(BIN)/intcmp   -gl  1 3 1    # !=
-	! $(BIN)/intcmp -gl  3 3 3    # ==
-	$(BIN)/intcmp   -egl 3 1 1 3  # >, ==, <
-	! $(BIN)/intcmp -egl foo      # huh?

tests/mm.mk

@@ -1,40 +0,0 @@
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PHONY: mm_tests
-mm_tests: mm_args mm_help mm_stderr mm_remaining mm_remaining_options
-
-.PHONY: mm_none
-mm_none: $(BIN)/mm
-	test "$$(printf 'meow\n' | $(BIN)/mm)" = meow
-
-.PHONY: mm_args
-# mm(1) will error if positional arguments are given without -i or -o
-mm_args: $(BIN)/mm
-	! $(BIN)/mm argument
-
-.PHONY: mm_help
-mm_help: $(BIN)/mm
-	! $(BIN)/mm -h
-
-.PHONY: mm_stderr
-# check if stderr is empty upon specifying -e
-mm_stderr: $(BIN)/mm
-	test "$$(printf 'test\n' | $(BIN)/mm -e 2>&1 >/dev/null )" = "test"
-
-.PHONY: mm_remaining
-# check to make sure remaining arguments are used
-mm_remaining: $(BIN)/mm
-	test "$$($(BIN)/mm -i README COPYING)" = "$$(cat README COPYING)"
-	$(BIN)/mm -i README -o /tmp/mm_test0 /tmp/mm_test1
-	diff /tmp/mm_test0 /tmp/mm_test1
-
-.PHONY: mm_remaining_options
-# check to make sure mm -i with trailing arguments interprets -o as one
-mm_remaining_options:
-	! $(BIN)/mm -i README COPYING -o - 2>&1 | cut -d: -f2 \
-		| xargs test " -o" =

tests/npc.mk

@@ -1,94 +0,0 @@
-#!/bin/sh
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# Copyright (c) 2024–2025 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PRAGMA: command_comment
-
-.PHONY: npc_tests
-npc_tests: npc_help npc_args npc_ascii
-
-.PHONY: npc_help
-npc_help: $(BIN)/npc
-	! $(BIN)/npc -h
-
-.PHONY: npc_args
-# arg parsing
-npc_args:
-	$(BIN)/npc -e </dev/null
-	$(BIN)/npc -t </dev/null
-	$(BIN)/npc -et </dev/null
-	! $(BIN)/npc -et 5 </dev/null
-
-.PHONY: npc_ascii
-# Test 0x00 to 0x7f in input; in other words, the full 7b ASCII range.
-npc_ascii: npc_ascii_controls npc_ascii_uppers # npc_ascii_symbols \
-#	npc_ascii_lowers
-
-.PHONY: npc_ascii_controls
-# (control characters)
-npc_ascii_controls:
-	# The following test prints the bytes 0x00 (inclusive) through 0x20
-	# (exclusive) and pipes them through npc(1). npc(1) should then replace all
-	# non-printing, non-space (in the isspace(3p) sense) characters with their
-	# graphical carat-char counterparts (see the npc(1) man page). The head(1p)
-	# invocation then strips off everything past the first line (or past the
-	# first newline byte, 0x0A) and xargs(1p) is used to test(1p) the output
-	# against the known good answer.
-
-	# Immediately before that newline, 0x09 is printed - in ASCII, the
-	# horizontal tab. If xargs' -I option is used, tr(1p) should used to delete
-	# that tab. If the tab is left as part of input, OpenBSD's xargs(1)
-	# implementation has been observed to strip it along with the other
-	# trailing whitespace (the newline), but Busybox's and GNU's xargs(1)
-	# implementations have been observed to leave the tab in. All three
-	# implementations strip off the trailing tab if `-I` is not used. The POSIX
-	# specification for `-I` is ambiguous as to which behavior is correct.
-	# This comment is the result of much bewilderment and debugging.
-
-	# ASCII 0x00 to 0x0a (before the newline, due to xargs(1p) issues)
-	awk 'BEGIN{ for (i = 0; i < 32; ++i) printf("%c", i); }' \
-		| $(BIN)/npc \
-		| head -n 1 \
-		| xargs test "^@^A^B^C^D^E^F^G^H" =
-
-	# ASCII 0x0a (otherwise the head|tail sequence won't work) to 0x1f
-	awk 'BEGIN{ for (i = 0; i < 32; ++i) printf("%c", i); print }' \
-		| $(BIN)/npc \
-		| head -n 2 \
-		| tail -n 1 \
-		| xargs -I out test "^K^L^M^N^O^P^Q^R^S^T^U^V^W^X^Y^Z^[^\^]^^^_"
-
-# This test is broken on Linux and will need closer inspection along with GNU
-# xargs(1).
-# .PHONY: npc_ascii_symbols
-# # ASCII 0x1f to 0x3f (^_ and symbols)
-# npc_ascii_symbols:
-# 	# shell quoting olympics
-# 	c="$(awk 'BEGIN{ for (i = 31; i < 64; ++i) printf("%c", i); print }')"
-# 
-# 	printf '%s\n' "$c" | $(BIN)/npc \
-# 		| sed -e s"/\'/\\\'/g" -e 's/"/\\"/g' \
-# 		| tr -d '\n' \
-# 		| xargs -I out test "^_ !\"#$$%&\'()*+,-./0123456789:;<=>?" = out
-
-.PHONY: npc_ascii_uppers
-# ASCII 0x40 to 0x5f (uppercases)
-npc_ascii_uppers:
-	awk 'BEGIN{ for (i = 64; i < 96; ++i) printf("%c", i); print }' \
-		| $(BIN)/npc \
-		| sed 's/\\/\\\\/' \
-		| xargs -I out test @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_ = out
-
-# This test is broken and will need closer inspection along with the npc(1)
-# source.
-# .PHONY: npc_ascii_lowers
-# # ASCII 0x60 to 0x7f (lowercases)
-# npc_ascii_lowers:
-# 	awk 'BEGIN{ for (i = 96; i < 128; ++i) printf("%c", i); print }' \
-# 		| $(BIN)/npc \
-# 		| xargs -I out test "\`abcdefghijklmnopqrstuvwxyz{|}~^?" = out

tests/peek.mk

@@ -1,24 +0,0 @@
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-# Testing peek is hard as it requires visual confirmation that text isn't being
-# echoed. These tests don't go that far but are a start, and have already
-# caught a bug in -i behavior.
-
-.PHONY: peek_tests
-peek_tests: peek_help peek_stdio
-
-.PHONY: peek_help
-peek_help: $(BIN)/peek
-	! $(BIN)/peek -h
-
-.PHONY: peek_stdio
-# Test peek -i
-peek_stdio: $(BIN)/peek
-	printf 'Test.\n' \
-		| $(BIN)/peek -i \
-		| xargs test 'Test.' =

tests/posix-compat.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+# Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
+# SPDX-License-Identifier: FSFAP
+#
+# Copying and distribution of this file, with or without modification, are
+# permitted in any medium without royalty provided the copyright notice and this
+# notice are preserved.  This file is offered as-is, without any warranty.
+
+set -e
+
+if ! ls Makefile >/dev/null 2>&1
+then
+	printf '%s: Run this script in the root of the project.\n' "$0" 1>&2 
+	exit 1
+fi
+
+printf "Starting POSIX compatibility testing.\n"
+
+for utility in tests/posix/*; do
+	printf '%s: %s: Testing utility.\n' "$0" "$utility"
+	"$utility"
+	printf '\n'
+done

tests/rpn.mk

@@ -1,48 +0,0 @@
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PHONY: rpn_tests
-rpn_tests: rpn_help rpn_add rpn_sub rpn_mul rpn_div rpn_mod rpn_flr rpn_stdin
-
-.PHONY: rpn_help
-rpn_help: $(BIN)/rpn
-	! $(BIN)/rpn -h
-
-.PHONY: rpn_add
-rpn_add: $(BIN)/rpn
-	test "$$($(BIN)/rpn 1 2 +)" -eq 3
-	test "$$($(BIN)/rpn 0.2 0.1 +)" = 0.3
-
-.PHONY: rpn_sub
-rpn_sub: $(BIN)/rpn
-	test "$$($(BIN)/rpn 23 5 -)" -eq 18
-	test "$$($(BIN)/rpn 0.3 0.1 -)" = 0.2
-
-.PHONY: rpn_mul
-rpn_mul: $(BIN)/rpn
-	test "$$($(BIN)/rpn 1.2 3 '*')" = 3.6
-	test "$$($(BIN)/rpn 0 3 '*')" -eq 0
-
-.PHONY: rpn_div
-rpn_div: $(BIN)/rpn
-	test "$$($(BIN)/rpn 12 5 /)" = 2.4
-	test "$$($(BIN)/rpn 3 0 /)" = inf
-
-.PHONY: rpn_mod
-rpn_mod: $(BIN)/rpn
-	test "$$($(BIN)/rpn 12 5 %)" -eq 2
-	test "$$($(BIN)/rpn 9 4 %)" -eq 1
-
-.PHONY: rpn_flr
-rpn_flr: $(BIN)/rpn
-	test "$$($(BIN)/rpn 12 5 //)" -eq 2
-	test "$$($(BIN)/rpn 9 4 //)" -eq 2
-
-# done last because all operations have been tested
-.PHONY: rpn_stdin
-rpn_stdin: $(BIN)/rpn
-	test "$$(printf '1\n2\n+\n3\n-\n' | $(BIN)/rpn | tail -n1)" -eq 0

tests/str.mk

@@ -1,20 +0,0 @@
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PRAGMA: command_comment
-
-.PHONY: str_tests
-str_tests: str_help str_isalpha
-
-.PHONY: str_help
-str_help: $(BIN)/str
-	! $(BIN)/str -h
-
-.PHONY: str_isalpha
-str_isalpha: $(BIN)/str
-	$(BIN)/str   isalpha c
-	! $(BIN)/str isalpha 3

tests/strcmp.mk

@@ -1,31 +0,0 @@
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-NAME = strcmp
-TARGET = $(NAME)_tests
-BINARY = $(BIN)/$(NAME)
-
-.PHONY: strcmp_tests
-strcmp_tests: strcmp_equals strcmp_help strcmp_nocmp strcmp_unequals
-
-.PHONY: strcmp_equals
-strcmp_equals: $(BIN)/strcmp
-	$(BIN)/strcmp equals equals
-	$(BIN)/strcmp - -
-
-.PHONY: strcmp_help
-strcmp_help: $(BIN)/strcmp
-	! $(BIN)/strcmp -h
-
-.PHONY: strcmp_nocmp
-strcmp_nocmp: $(BIN)/strcmp
-	! $(BIN)/strcmp nocmp
-
-.PHONY: strcmp_unequals
-strcmp_unequals: $(BIN)/strcmp
-	! $(BIN)/strcmp unequals equals

tests/swab.mk

@@ -1,22 +0,0 @@
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PRAGMA: command_comment
-
-.PHONY: swab_tests
-swab_tests: swab_help swab_examples
-
-.PHONY: swab_help
-swab_help: $(BIN)/swab
-	! $(BIN)/swab -h
-
-.PHONY: swab_examples
-# These are the examples present in the man page.
-swab_examples: $(BIN)/swab
-	printf 'hello world!\n' \
-		| $(BIN)/swab \
-		| xargs -I out test 'ehll oowlr!d' = out

tests/true.mk

@@ -1,19 +0,0 @@
-#!/bin/sh
-# Copyright (c) 2024 DTB <trinity@trinity.moe>
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
-# SPDX-License-Identifier: FSFAP
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice and this
-# notice are preserved.  This file is offered as-is, without any warranty.
-
-.PHONY: true_tests
-true_tests: true_test
-
-.PHONY: true_help
-true_help: $(BIN)/true
-	$(BIN)/true -h
-
-.PHONY: true_test
-true_test: $(BIN)/true
-	$(BIN)/true