stris.1: makes consistent with other docs

CONTRIBUTING

@@ -1,29 +1,26 @@
 Make sure to read our code of conduct in the CONDUCT file.
 
-
-Copyright Information
-=====================
-
-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:
+When contributing a pull request to the main branch, please sign your commits
+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:
 
  * 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
-copyright notice.
+2023. Please use the en dash (“–”) to separate the years in the copyright
+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,10 +92,6 @@ notice:
  *     USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-
-Style
-=====
-
 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
@@ -111,13 +104,8 @@ style guide for the usage text’s output format [0].
 If committing a new utility, please include tests and documentation (see
 tests/ and docs/) for the new tool.
 
-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.
-
-Format commit messages following these guidelines:
+If committing a new source file, format the commit message following these
+guidelines:
 
 $ git commit -m 'tool(1): add feature x'
 
@@ -143,13 +131,7 @@ $ git commit -m 'tool(1): fix #42 & add feature x'
 
 Commit messages should be written in the present tense.
 
-
-References
-==========
-
 [0] <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
 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>
@@ -19,12 +19,12 @@ PREFIX ?= /usr/local
 # for conditionally compiling OS features
 OS != uname
 OS_INCLUDE != test -e include/$(OS).mk && printf 'include/$(OS).mk\n' \
-	|| printf '/dev/null\n'
+	|| include/None.mk
 
 # normalized prefix
-PREFIX_N != realpath $(PREFIX)
+PREFIX_N != dirname $(PREFIX)/.
 MANDIR != test $(PREFIX_N) = / && printf '/usr/share/man\n' \
-	|| printf '$(PREFIX_N)/man\n'
+	|| printf '/share/man\n'
 SYSEXITS != printf '\043include <sysexits.h>\n' | cpp -M - | tr ' ' '\n' \
 	| sed -n 's/sysexits\.h//p' || printf 'include\n'
 
@@ -42,7 +42,7 @@ BIN = build/bin
 default: all test
 
 .PHONY: all
-all: dj false fileis fop hru intcmp mm npc peek rpn str strcmp swab true
+all: dj false fop hru intcmp mm npc rpn scrut strcmp stris swab true
 
 # keep build/include until bindgen(1) has stdin support
 # https://github.com/rust-lang/rust-bindgen/issues/2703
@@ -54,20 +54,15 @@ clean:
 	rm -rf build dist
 
 dist: all docs
-	mkdir -p $(DESTDIR)/$(PREFIX_N)/bin $(DESTDIR)/$(MANDIR)/man1
-	cp build/bin/* $(DESTDIR)/$(PREFIX_N)/bin
-	cp build/docs/*.1 $(DESTDIR)/$(MANDIR)/man1
+	mkdir -p $(DESTDIR)/$(PREFIX)/bin $(DESTDIR)/$(PREFIX)/$(MANDIR)/man1
+	cp build/bin/* $(DESTDIR)/$(PREFIX)/bin
+	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)
+include tests/tests.mk
 
 .PHONY: test
 test: all $(TESTS) /tmp/getopt
@@ -100,7 +95,7 @@ build/o/libstrerror.rlib: build src/libstrerror.rs
 		src/libstrerror.rs
 
 build/o/libsysexits.rlib: build/include/sysexits.h
-	bindgen --fit-macro-constant-types --default-macro-constant-type unsigned --use-core --formatter=none \
+	bindgen --default-macro-constant-type signed --use-core --formatter=none \
 		build/include/sysexits.h | $(RUSTC) $(RUSTFLAGS) --crate-type lib -o $@ -
 
 # bandage solution until bindgen(1) gets stdin support
@@ -117,11 +112,6 @@ 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) $(RUSTLIBS) -o $@ src/fileis.rs
-
 .PHONY: fop
 fop: build/bin/fop
 build/bin/fop: src/fop.rs build rustlibs
@@ -147,20 +137,20 @@ 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
 
-.PHONY: str
-str: build/bin/str
-build/bin/str: src/str.c build
-	$(CC) $(CFLAGS) -o $@ src/str.c
+.PHONY: scrut
+scrut: build/bin/scrut
+build/bin/scrut: src/scrut.c build
+	$(CC) $(CFLAGS) -o $@ src/scrut.c
+
+.PHONY: stris
+stris: build/bin/stris
+build/bin/stris: src/stris.rs build rustlibs
+	$(RUSTC) $(RUSTFLAGS) -o $@ src/stris.rs
 
 .PHONY: strcmp
 strcmp: build/bin/strcmp

README

@@ -1,28 +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
-be simpler, easier, and more powerful. These tools are the result of careful
-examination of the current state common Unix utilities, POSIX-compliant and
-otherwise, following frustrations with design decisions and implementation
-details. They represent a vision of accomplishing everyday use cases with tools
-that follow the Unix philosophy of “do one thing and do it well” without
-clinging to the past.
+The Bonsai harakit utilities are a replacement for standard POSIX utilities
+which aim to fill its niche while expanding on their capabilities. These new
+tools are the result of the careful examination of the current state of POSIX
+and Unix utilies. The Unix Philosophy of “do one thing and do it well” are their
+core but they avoid clinging to the past.
 
-The intent of Harakit is not to conform to or extend POSIX, like the GNU or BSD
-utilities do, but to invent new utilities to perform the same tasks in more
-intuitive ways. GNU and BSD extensions are convenient but often unhealthy,
-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.
+The era of the original Unix tools has been long and fruitful, but they have
+their flaws. This project originated from frustrations with the way certain
+tools work and how other projects that extend POSIX don’t make anything better.
+
+This project will not follow in the footsteps of GNU; extensions of POSIX will
+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
@@ -47,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>
@@ -76,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>

STYLE

@@ -1,51 +1,11 @@
-“Everyone knows that debugging is twice as hard as writing a program in the
-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
 consistent with the style of the rest of the Bonsai Computer System.
 
+0. Braces are mandatory for all control flow.
 
-Use
-===
+1. Nested indentation should be kept to a minimum.
 
- 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:
+2. Empty lines should be placed between different kinds of statements:
 
 	int t;
 
@@ -65,57 +25,56 @@ Use
 
 	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].
+3. Each block of code should be indented once more than the keyword which
+initiated the block:
 
- 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:
+	switch (c) {
+		case 'e': mode |= EQUAL;   break;
+		case 'g': mode |= GREATER; break;
+		case 'l': mode |= LESS;    break;
+		default:  return usage(s);
+	}
+
+4. In C, spaces should be placed in control flow statements after the keyword
+and before the opening brace:
+
+	for (i = 2; i < argc; ++i) {
+
+5. If a function, a C control flow statement, or a Rust macro has arguments that
+cause the statement to be broken into multiple lines, this should be done by
+placing the arguments on a new line inside the parentheses: 
 
 	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:
+6. If Rust function arguments or fields are on their own lines, they should
+always have a trailing comma:
 
 	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:
+7. If text is on the same line as a brace, spaces should be placed after an
+opening curly brace and before a closing one:
+
+	use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
+
+8. If a control flow statement is short enough to be easily understood in a
+glance, it may be placed on a single line:
+
+	if !(argc < 0) { usage(program_name); }
+
+9. In C, note everything you use from a library in a comment subsequent to its
+#include statement:
+
+	#include <unistd.h> /* close(2), getopt(3), lseek(2), read(2), write(2),
+                         * optarg, optind, STDIN_FILENO, STDOUT_FILENO */
+
+10. In Rust, place extern statements after use statements that include standard
+library crates. Group alike statements:
 
 	use std::fs::Path;
 
@@ -125,129 +84,40 @@ Use
 	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:
+11. Do not use do while loops in C.
 
-	use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
+12. Adhere to the following rules from the paper The Power of 10: Rules for
+Developing Safety-Critical Code [0]:
+	1. Avoid complex flow constructs, such as goto and recursion.
+	2. All loops must have fixed bounds. This prevents runaway code.
+	3. Avoid heap memory allocation.
+	4. Restrict functions to the length of a single printed page.
 
- 14. Alphabetic sorting, where applicable:
+	6. Restrict the scope of data to the smallest possible.
+	7. Check the return value of all non-void functions, or cast to void to
+	indicate the return value is useless (such as in the case of using
+	fprintf(3p)	to print to the standard error).
+	8. Use the preprocessor sparingly.
+	9. Limit pointer use to a single dereference, and do not use function
+	pointers.
+	10. Compile with all possible warnings active; all warnings should then be
+	addressed before release of the software (for C compilers, compile with
+	-Wpedantic).
 
-	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.
-
-
-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"
+13. Remember this quote from The Elements of Programming Style by Brian
+Kernighan:
+	Everyone knows that debugging is twice as hard as writing a program in the
+	first place. So if you're as clever as you can be when you write it, how
+	will you ever debug it?
 
 
 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>
 
 --
 Copyright © 2024 Emma Tebibyte <emma@tebibyte.media>
-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

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/scrut.1

@@ -1,15 +1,15 @@
 .\" 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 ]
 .B file...
 .\"
@@ -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

@@ -1,59 +0,0 @@
-.\" Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
-.\" Copyright (c) 2023–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 STR 1 2024-06-17 "Harakit X.X.X"
-.SH NAME
-str \(en test string arguments
-.\"
-.SH SYNOPSIS
-
-str
-.B type string...
-.\"
-.SH DESCRIPTION
-
-Test the character types of string arguments.
-
-The tests in this program are equivalent to the functions with the same names in
-.BR ctype.h (0p)
-and are the methods by which string arguments are tested.
-.\"
-.SH DIAGNOSTICS
-
-If all tests pass, the program will exit successfully. If any of the tests fail,
-the program will exit unsuccessfully with an error code of 1.
-
-When invoked incorrectly, a debug message will be printed and the program will
-exit with the appropriate
-.BR sysexits.h (3)
-error code.
-.\"
-.SH CAVEATS
-
-None of an empty string\(cqs contents pass any of the tests, so the program will
-exit unsuccessfully if one is specified.
-
-There\(cqs no way of knowing which argument failed the test without re-testing
-arguments individually.
-
-If a character in a string isn\(cqt valid ASCII, the program will exit
-unsuccessfully.
-.\"
-.SH AUTHOR
-
-Written by DTB
-.MT trinity@trinity.moe
-.ME .
-.\"
-.SH COPYRIGHT
-
-Copyright \(co 2023 DTB. License AGPLv3+: GNU AGPL version 3 or later
-<https://gnu.org/licenses/gpl.html>.
-.\"
-.SH SEE ALSO
-.BR ctype (3p),
-.BR strcmp(1),
-.BR ascii(7)

docs/stris.1

@@ -0,0 +1,104 @@
+.\" Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
+.\" Copyright (c) 2023–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 STRIS 1 2024-10-22 "Harakit X.X.X"
+.SH NAME
+stris \(en test the character types of string arguments
+.\"
+.SH SYNOPSIS
+
+stris
+.RB [ -7bcdlu ]
+.RB [ -i\ inclusions ]
+.RB strings...
+.\"
+.SH DESCRIPTION
+
+Test each character in any number of string arguments, ensuring each meets any
+of the parameters specified by program options.
+.\"
+.SH OPTIONS
+
+.IP \fB-7\fP
+Tests if the character encoding is ASCII.
+.IP \fB-b\fP
+Tests if characters are whitespace.
+.IP \fB-c\fP
+Tests if characters are control characters.
+.IP \fB-d\fP
+Tests if characters are numeric.
+.IP \fB-i\fP \fIinclusions...\fP
+In addition to specified options, also permits characters in 
+.IR inclusions .
+.IP \fB-l\fP
+Tests if characters are in lower case.
+.IP \fB-u\fP
+Tests if characters are in upper case.
+.\"
+.SH DIAGNOSTICS
+
+If no test cases pass for a character in
+.IR strings ,
+the program will exit unsuccessfully.
+
+.SH CAVEATS
+
+If no options are specified, the program will exit successfully as long as the
+input
+.I strings
+are legibly encoded.
+
+Neither which test failed nor which of the
+.I strings
+failed a test cannot be known without further invocations of the program.
+
+Characters that can be encoded losslessly into ASCII from UTF-8 but which
+are in an \(lqoverlong encoding\(rq, where the character was encoded with
+unnecessary leading zeroes causing it to span multiple bytes, won\(cqt be
+detected as ASCII.
+.\"
+.SH EXAMPLES
+
+This is an
+.BR sh (1p)
+snippet which tests if an environment variable is an ASCII digit.
+
+.RS
+stris -7 "$v" && stris -d "$v" && echo ASCII digit.
+.RE
+
+This is an
+.BR sh (1p)
+snippet that tests if an environment variable is a hexadecimal number.
+
+.RS
+stris -7 "$v" && stris -di ABCDEFabcdef "$v" && echo Hexadecimal number.
+.RE
+.\"
+.SH AUTHOR
+
+Written by DTB
+.MT trinity@trinity.moe
+.ME .
+.\"
+.SH HISTORY
+
+This program replaces the former str(1) which took the name of a function from
+.BR ctype (3p)
+as its first argument and checked the following strings against it;
+.BR str (1)
+exited unsuccessfully when it encountered any non-ASCII characters and could
+only have one parameter specified.
+.\"
+.SH COPYRIGHT
+
+Copyright \(co 2023\(en2024 DTB. License AGPLv3+: GNU AGPL version 3 or later
+<https://gnu.org/licenses/gpl.html>.
+.\"
+.SH SEE ALSO
+.BR ascii (7),
+.BR ctype (3p),
+.BR strcmp (1)

src/false.c

@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2023–2024 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
@@ -11,9 +10,9 @@
 #	include <unistd.h> /* pledge(2) */
 #endif
 
-int main(void) {
+int main() {
 #ifdef __OpenBSD__
-	(void)pledge("stdio", "");
+	pledge(NULL, NULL);
 #endif
-	return 1;
+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,8 +18,8 @@
 
 use std::{
 	env::args,
-	io::{ Error, Read, Write, stdin, stdout },
-	process::{ Command, ExitCode, Stdio, exit },
+	io::{ Read, stdin, stdout, Write },
+	process::{ Command, exit, Stdio },
 };
 
 extern crate getopt;
@@ -32,36 +32,25 @@ use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
 
 #[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
 #[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
 
-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 {
+fn main() {
 	let argv = args().collect::<Vec<String>>();
 	let mut d = '\u{1E}'.to_string(); /* ASCII record separator */
 	let mut optind = 1;
 
-	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("exec proc stdio unveil");
+	if cfg!(target_os="openbsd") {
+		let promises = Promises::new("stdio proc exec");
 		if let Err(e) = pledge(Some(promises), None) {
-			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);
+			eprintln!("{}: {}", argv[0], e.strerror());
+			exit(EX_OSERR);
 		}
 	}
 
-	if argv.len() == 1 { return ExitCode::from(usage(&argv[0])); }
+	let usage = format!(
+		"Usage: {} [-d delimiter] index command [args...]",
+		argv[0],
+	);
 
 	while let Some(opt) = argv.getopt("d:") {
 		match opt.opt() {
@@ -71,7 +60,8 @@ fn main() -> ExitCode {
 				optind = opt.ind();
 			},
 			_ => {
-				return ExitCode::from(usage(&argv[0]));
+				eprintln!("{}", usage);
+				exit(EX_USAGE);
 			}
 		};
 	}
@@ -79,7 +69,7 @@ fn main() -> ExitCode {
 	/* parse the specified index as a number we can use */
 	let index = argv[optind].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 */
@@ -87,14 +77,15 @@ fn main() -> ExitCode {
 
 	/* argv[0] of the operator command */
 	let operator = argv.get(command_arg).unwrap_or_else(|| {
-		exit(usage(&argv[0]).into());
+		eprintln!("{}", usage);
+		exit(EX_USAGE);
 	});
 
 	/* read entire standard input into memory */
 	let mut buf = String::new();
 	if let Err(e) = stdin().read_to_string(&mut buf) {
-		err(&argv[0], e);
-		exit(EX_IOERR.into());
+		eprintln!("{}: {}", argv[0], e.strerror());
+		exit(EX_IOERR);
 	};
 
 	/* split the buffer by the delimiter (by default, '\u{1E}') */
@@ -114,14 +105,18 @@ fn main() -> ExitCode {
 		.stdout(Stdio::piped()) /* piped stdout to handle output ourselves */
 		.spawn()
 		.unwrap_or_else( |e| {
-			err(&argv[0], e);
-			exit(EX_UNAVAILABLE.into());
+			eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
+			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);
-		exit(EX_DATAERR.into());
+		eprintln!(
+			"{}: {}: 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 */
@@ -131,8 +126,8 @@ fn main() -> ExitCode {
 	}
 
 	let output = spawned.wait_with_output().unwrap_or_else(|e| {
-		err(&argv[0], e);
-		exit(EX_IOERR.into());
+		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
+		exit(EX_IOERR);
 	});
 
 	/* get the output with which the original field will be replaced */
@@ -148,8 +143,8 @@ fn main() -> ExitCode {
 
 	/* convert the output of the program to UTF-8 */
 	let new_field = String::from_utf8(replace).unwrap_or_else(|e| {
-		eprintln!("{}: {}", argv[0], e);
-		exit(EX_IOERR.into());
+		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e);
+		exit(EX_IOERR);
 	});
 
 	/* store the new field in the old fields vector */
@@ -159,9 +154,7 @@ fn main() -> ExitCode {
 	stdout().write_all(
 		fields.join(&d.to_string()).as_bytes()
 	).unwrap_or_else(|e| {
-		err(&argv[0], e);
-		exit(EX_IOERR.into());
+		eprintln!("{}: {}", argv[0], e.strerror());
+		exit(EX_IOERR);
 	});
-
-	ExitCode::SUCCESS
 }

src/hru.rs

@@ -19,7 +19,7 @@
 use std::{
 	cmp::Ordering,
 	env::args,
-	io::{ Write, stdin, stdout },
+	io::{ stdin, stdout, Write },
 	process::{ ExitCode, exit },
 };
 
@@ -31,7 +31,7 @@ use sysexits::{ EX_DATAERR, EX_IOERR, EX_SOFTWARE, EX_USAGE };
 
 #[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
 #[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
 
 /* list of SI prefixes */
 const LIST: [(u32, &str); 10] = [
@@ -47,16 +47,6 @@ const LIST: [(u32, &str); 10] = [
 	(30, "Q"), /* quetta */
 ];
 
-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, "")); 
@@ -91,48 +81,53 @@ 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]); }
+	if let Some(_) = argv.get(1) {
+		eprintln!("Usage: {}", argv[0]);
+		return ExitCode::from(EX_USAGE as u8);
+	}
 
-	#[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));
+	if cfg!(target_os="openbsd") {
+		let promises = Promises::new("stdio");
+		if let Err(e) = pledge(Some(promises), None) {
+			eprintln!("{}: {}", argv[0], e.strerror());
+			return ExitCode::from(EX_OSERR as u8);
 		}
 	}
 
 	let mut buf = String::new();
 
-	if let Err(e) = stdin().read_line(&mut buf) {
-		return err(&argv[0], e.strerror(), Some(EX_IOERR));
-	}
+	while let Ok(_) = stdin().read_line(&mut buf) {
+		if buf.is_empty() { return ExitCode::SUCCESS; }
 
-	if buf.is_empty() { return ExitCode::SUCCESS; }
+		let n: u128 = match buf.trim().parse() {
+			Ok(f) => {
+				buf.clear();
+				f
+			},
+			Err(err) => {
+				eprintln!("{}: {}", argv[0], err);
+				return ExitCode::from(EX_DATAERR as u8);
+			},
+		};
 
-	let n: u128 = match buf.trim().parse() {
-		Ok(f) => {
-			buf.clear();
-			f
-		},
-		Err(e) => return err(&argv[0], e.to_string(), Some(EX_DATAERR)),
-	};
+		let (number, prefix) = match convert(n) {
+			Ok(x) => x,
+			Err(err) => {
+				eprintln!("{}: {}", argv[0], err);
+				return ExitCode::from(EX_SOFTWARE as u8);
+			},
+		};
 
-	let (number, prefix) = convert(n).unwrap_or_else(|e| {
-		let _ = err(&argv[0], e.to_string(), None);
-		exit(EX_SOFTWARE.into());
-	});
+		let si_prefix = format!("{}B", prefix.1);
 
-	let si_prefix = prefix.1.to_owned() + "B";
+		/* round output number to one decimal place */
+		let out = ((number * 10.0).round() / 10.0).to_string();
 
-	/* round output number to one decimal place */
-	let rounded = (number * 10.0).round() / 10.0;
-	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));
+		stdout().write_all(format!("{} {}\n", out, si_prefix).as_bytes())
+			.unwrap_or_else(|e| {
+				eprintln!("{}: {}", argv[0], e.strerror());
+				exit(EX_IOERR);
+			});
 	}
 
 	ExitCode::SUCCESS

src/intcmp.rs

@@ -26,35 +26,28 @@ extern crate getopt;
 extern crate sysexits;
 
 use getopt::GetOpt;
-use sysexits::{ EX_DATAERR, EX_USAGE };
+use sysexits::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 openbsd::{ Promises, pledge };
 #[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 usage(s: &str) -> ExitCode {
+	eprintln!("Usage: {} [-egl] integer integer...", s);
+	ExitCode::from(EX_USAGE as u8)
 }
 
 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);
+	if cfg!(target_os="openbsd") {
+		let promises = Promises::new("stdio");
+		if let Err(e) = pledge(Some(promises), None) {
+			eprintln!("{}: {}", argv[0], e.strerror());
+			return ExitCode::from(EX_OSERR as u8);
 		}
 	}
 
@@ -86,8 +79,8 @@ fn main() -> ExitCode {
 		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);
+				eprintln!("{}: {}: {}", &argv[0], arg, e);
+				return ExitCode::from(EX_USAGE as u8);
 			}
 		}
 

src/libopenbsd.rs

@@ -43,10 +43,6 @@ impl Promises {
 	}
 }
 
-impl Default for Promises {
-	fn default() -> Self { Promises::new("") }
-}
-
 pub fn pledge(
 	promises: Option<Promises>, execpromises: Option<Promises>
 ) -> Result<(), Error> {
@@ -69,12 +65,14 @@ pub fn pledge(
 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 new(permissions: Vec<char>) -> Self {
+		if permissions.is_empty() {
+			return UnveilPerms(CString::new("").unwrap());
+		}
+
+		UnveilPerms(
+			CString::new(permissions.iter().collect::<String>()).unwrap()
+		)
 	}
 }
 
@@ -85,9 +83,9 @@ pub fn unveil(
 	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());
+	let arg2 = permissions
+		.map(|p| p.0.into_raw() as *const c_char)
+		.unwrap_or(null());
 
 	unsafe {
 		match openbsd::unveil(arg1, arg2) {

src/mm.rs

@@ -20,9 +20,9 @@
 use std::{
 	env::args,
 	fs::File,
-	io::{ Error, BufWriter, Read, Write, stderr, stdin, stdout },
+	io::{ stdin, stdout, stderr, BufWriter, Read, Write },
 	os::fd::{ AsRawFd, FromRawFd },
-	process::{ ExitCode, exit},
+	process::{ exit, ExitCode },
 };
 
 extern crate getopt;
@@ -47,23 +47,15 @@ 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<_>>();
+	let usage = format!("Usage: {} [-aetu] [-i input] [-o output]", argv[0]);
 
-	#[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));
+	if cfg!(target_os="openbsd") {
+		let promises = Promises::new("rpath stdio unveil");
+		if let Err(e) = pledge(Some(promises), None) {
+			eprintln!("{}: {}", argv[0], e.strerror());
+			return ExitCode::from(EX_OSERR as u8);
 		}
 	}
 
@@ -84,16 +76,35 @@ fn main() -> ExitCode {
 			Ok("t") => t = false,
 			Ok("i") => { /* add inputs */
 				let input = opt.arg().unwrap();
+
+				if cfg!(target_os="openbsd") {
+					let perms = UnveilPerms::new(vec!['r']);
+					if let Err(e) = unveil(Some(&input), Some(perms)) {
+						eprintln!("{}: {}", argv[0], e.strerror());
+						return ExitCode::from(EX_OSERR as u8);
+					}
+				}
+
 				ins.push(input);
 				mode = Some(In); /* latest argument == -i */
 			},
 			Ok("o") => { /* add output */
-				let output = opt.arg().unwrap();
+				let output = opt.arg().unwrap(); 
+
+				if cfg!(target_os="openbsd") {
+					let perms = UnveilPerms::new(vec!['w', 'c']);
+					if let Err(e) = unveil(Some(&output), Some(perms)) {
+						eprintln!("{}: {}", argv[0], e.strerror());
+						return ExitCode::from(EX_OSERR as u8);
+					}
+				}
+
 				outs.push(output);
 				mode = Some(Out); /* latest argument == -o */
 			},
 			Err(_) | Ok(_) => {
-				return usage(&argv[0]);
+				eprintln!("{}", usage);
+				return ExitCode::from(EX_USAGE as u8);
 			},
 		};
 
@@ -113,30 +124,16 @@ fn main() -> ExitCode {
 		}
 	}
 
-	#[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 cfg!(target_os="openbsd") {
 		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e, Some(EX_OSERR));
+			eprintln!("{}: {}", argv[0], e.strerror());
+			return ExitCode::from(EX_OSERR as u8);
 		}
 	}
 
 	if ins.is_empty() && outs.is_empty() && argv.len() > optind {
-		return usage(&argv[0]);
+		eprintln!("Usage: {}", usage);
+		return ExitCode::from(EX_USAGE as u8);
 	}
 
 	/* use stdin if no inputs are specified */
@@ -156,8 +153,8 @@ fn main() -> ExitCode {
 		match File::open(file) {
 			Ok(f) => f,
 			Err(e) => {
-				let _ = err(&(argv[0].clone() + ": " + file), e, None);
-				exit(EX_IOERR.into());
+				eprintln!("{}: {}: {}", argv[0], file, e.strerror());
+				exit(EX_IOERR);
 			},
 		}
 	}).collect::<Vec<_>>();
@@ -183,8 +180,8 @@ fn main() -> ExitCode {
 		match options {
 			Ok(f) => return f,
 			Err(e) => {
-				let _ = err(&(argv[0].clone() + ": " + file), e, None);
-				exit(EX_IOERR.into());
+				eprintln!("{}: {}: {}", argv[0], file, e.strerror());
+				exit(EX_IOERR);
 			},
 		};
 	}).collect::<Vec<_>>();
@@ -208,19 +205,21 @@ fn main() -> ExitCode {
 	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());
+				eprintln!("{}: {}", argv[0], e.strerror());
+				exit(EX_IOERR);
 			})
 		}) {
 			for out in &mut outputs {
 				if let Err(e) = out.write(&[byte]) {
-					return err(&argv[0], e, Some(EX_IOERR));
+					eprintln!("{}: {}", argv[0], e.strerror());
+					return ExitCode::from(EX_IOERR as u8);
 				}
 
 				if u {
 					/* immediately flush the output for -u */
 					if let Err(e) = out.flush() { 
-						return err(&argv[0], e, Some(EX_IOERR));
+						eprintln!("{}: {}", argv[0], e.strerror());
+						return ExitCode::from(EX_IOERR as u8);
 					}
 				}
 			}

src/npc.c

@@ -20,7 +20,7 @@
 #include <stdio.h> /* fprintf(3), fputs(3), getc(3), perror(3), putc(3), stdin,
                     * stdout, EOF */
 #include <sysexits.h> /* EX_IOERR, EX_OK, EX_OSERR, EX_USAGE */
-#include <unistd.h> /* NULL, getopt(3), pledge(2), unveil(2) */
+#include <unistd.h> /* pledge(2), getopt(3) */
 
 char *program_name = "npc";
 
@@ -44,7 +44,7 @@ int main(int argc, char *argv[]) {
 	char showtab = 0; /* prints tab characters in caret notation */
 
 #ifdef __OpenBSD__
-	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL)) {
+	if (pledge("stdio", NULL) == -1) {
 		perror(argv[0] == NULL ? program_name : argv[0]);
 		return EX_OSERR;
 	}

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,21 +46,21 @@ 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, EX_IOERR };
+use sysexits::EX_DATAERR;
 
 #[cfg(target_os="openbsd")] use sysexits::EX_OSERR;
+#[cfg(target_os="openbsd")] extern crate strerror;
 #[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
+#[cfg(target_os="openbsd")] use strerror::StrError;
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
 
 #[derive(Clone, PartialEq, PartialOrd, Debug)]
 /* enum CalcType is a type containing operations used in the calculator */
@@ -120,46 +120,12 @@ impl Display for CalcType {
 #[derive(Debug, Clone)]
 struct EvaluationError {
 	message: String,
-	code: u8,
+	code: i32,
 }
 
-impl StrError for EvaluationError {
-	fn strerror(&self) -> String {
-		self.message.clone()
-	}
-}
-
-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)
-}
+/* I’m no math nerd but I want the highest possible approximation of 0.9
+ * repeating and it seems this can give it to me */
+const PRECISION_MOD: f64 = 0.9 + f64::EPSILON * 100.0;
 
 fn eval(
 	input: &str,
@@ -179,7 +145,6 @@ fn eval(
 		.rev()
 		.map(|t| CalcType::from(t))
 		.collect();
-
 	let mut ops: VecDeque<CalcType> = VecDeque::new();
 
 	while let Some(n) = toks.pop_back() {
@@ -187,15 +152,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 */
-				return operate(stack, op).map(|s| (s, oper));
+				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,
+					})
+				}
 			},
 		};
 	}
@@ -204,46 +190,51 @@ fn eval(
 }
 
 /* Round a float to the given precision level */
-fn round_precise(value: &f64) -> f64 {
-	/* Set floating-point precision for correcting rounding errors based on
-	 * machine epsilon */
-	let precision = (-f64::EPSILON.log10()).floor() as i32;
-	let multiplier = 10_f64.powi(precision);
-
+fn round_precise(value: &f64, precision: usize) -> f64 {
+	let multiplier = 10_f64.powi(precision as i32);
 	(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));
+	if cfg!(target_os="openbsd") {
+		let promises = Promises::new("stdio");
+		if let Err(e) = pledge(Some(promises), None) {
+			eprintln!("{}: {}", argv[0], e.strerror());
+			return ExitCode::from(EX_OSERR as u8);
 		}
 	}
 
 	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() { /* read from stdin */
+		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() {
+						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 { /* read from argv */
 		/* join argv into an owned String joined by spaces minus argv[0] */
 		let input = argv
 			.iter()
@@ -254,44 +245,20 @@ fn main() -> ExitCode {
 
 		match eval(&input, stack) {
 			Ok(s) => {
-				/* we can ignore the return value of unstack() because we are
-				 * not continually evaluating from stdin */
-				if let Err(e) = unstack(s.0.clone(), s.1.clone()) {
-					return err(&argv[0], &e, Some(EX_IOERR));
-				}
+				stack = s.0.clone();
 
-				return ExitCode::SUCCESS;
-			},
-			Err(e) => {
-				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))
-					},
+				let val = match stack.iter().last() {
+					Some(v) => v,
+					None => return ExitCode::SUCCESS,
 				};
+
+				println!("{}", round_precise(val, precision).to_string())
 			},
-			Err(e) => {
-				return err(&argv[0], &e, Some(e.code));
+			Err(err) => {
+				eprintln!("{}: {}", argv[0], err.message);
+				return ExitCode::from(err.code as u8);
 			},
 		};
 	}
-
 	ExitCode::SUCCESS
 }

src/scrut.c

@@ -46,7 +46,7 @@ int main(int argc, char *argv[]) {
 	program_name = argv[0] == NULL ? program_name : argv[0];
 
 #ifdef __OpenBSD__
-	if (pledge("rpath stdio unveil", "") == -1) {
+	if (pledge("rpath stdio unveil", NULL) == -1) {
 		perror(program_name);
 		return EX_OSERR;
 	}
@@ -82,7 +82,7 @@ int main(int argc, char *argv[]) {
 		struct stat buf;
 
 #ifdef __OpenBSD__
-		if (unveil(*argv, "rw") == -1) {
+		if (unveil(*argv, "r") == -1) {
 			perror(program_name);
 			return EX_OSERR;
 		}

src/str.c

@@ -1,96 +0,0 @@
-/*
- * Copyright (c) 2023 DTB <trinity@trinity.moe>
- * Copyright (c) 2023 Marceline Cramer <mars@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 <ctype.h>
-#include <stddef.h> /* NULL */
-#include <stdio.h> /* fprintf(3), perror(3) */
-#include <stdlib.h> /* size_t, EXIT_FAILURE */
-#include <string.h> /* strcmp(3) */
-#include <sysexits.h> /* EX_OSERR, EX_USAGE */
-
-#ifdef __OpenBSD__
-#	include <unistd.h> /* pledge(2), unveil(2) */
-#endif
-
-char *program_name = "str";
-
-static struct {
-	char *name;
-	int (*f)(int);
-} ctypes[] = {
-	{ "isalnum", isalnum },
-	{ "isalpha", isalpha },
-	{ "isblank", isblank },
-	{ "iscntrl", iscntrl },
-	{ "isdigit", isdigit },
-	{ "isxdigit", isxdigit },
-	{ "isgraph", isgraph },
-	{ "islower", islower },
-	{ "isprint", isprint },
-	{ "ispunct", ispunct },
-	{ "isspace", isspace },
-	{ "isupper", isupper },
-	{ NULL, NULL } /* marks end */
-};
-
-static int
-usage(char *argv0) {
-	(void)fprintf(stderr, "Usage: %s type string...\n", argv0);
-
-	return EX_USAGE;
-}
-
-int main(int argc, char *argv[]) {
-	size_t ctype; // selected from ctypes.h; index of ctype
-	int retval; // initially fail but becomes success on the first valid char
-	program_name = argv[0] == NULL ? program_name : argv[0];
-
-#ifdef __OpenBSD__
-	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL) == -1) {
-		perror(program_name);
-		return EX_OSERR;
-	}
-#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

@@ -20,7 +20,7 @@
 #include <sysexits.h> /* EX_OK, EX_OSERR, EX_USAGE */
 
 #ifdef __OpenBSD__
-#	include <unistd.h> /* pledge(2), unveil(2) */
+#	include <unistd.h> /* pledge(2) */
 #endif
 
 char *program_name = "strcmp";
@@ -29,7 +29,7 @@ int main(int argc, char *argv[]) {
 	unsigned int i;
 
 #ifdef __OpenBSD__
-	if (pledge("stdio unveil", "") == -1 || unveil(NULL, NULL) == -1) {
+	if (pledge("stdio", NULL) == -1) {
 		perror(argv[0] == NULL ? program_name : argv[0]);
 
 		return EX_OSERR;

src/stris.rs

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2023–2024 DTB <trinity@trinity.moe>
+ * Copyright (c) 2023 Marceline Cramer <mars@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_USAGE;
+
+struct Reqs {
+	ascii: bool, blank: bool, cntrl: bool, digit: bool, lower: bool,
+	upper: bool, inuse: bool, extra: String
+}
+
+fn usage(s: &str) -> ExitCode {
+	eprintln!("Usage: {} [-7bcdlu] [-i inclusions] [strings...]", s);
+	ExitCode::from(EX_USAGE as u8)
+}
+
+fn main() -> ExitCode {
+	let argv = args().collect::<Vec<String>>();
+	let mut optind = 1;
+	let mut reqs = Reqs {
+		ascii: false, blank: false, cntrl: false, digit: false, lower: false,
+		upper: false, inuse: false, extra: String::default()
+	};
+
+	while let Some(opt) = argv.getopt("7bcdi:lu") {
+		match opt.opt() {
+			Ok("7") => reqs.ascii = true,
+			Ok("b") => reqs.blank = true,
+			Ok("c") => reqs.cntrl = true,
+			Ok("d") => reqs.digit = true,
+			Ok("i") => reqs.extra = opt.arg().unwrap(),
+			Ok("l") => reqs.lower = true,
+			Ok("u") => reqs.upper = true,
+			_ => { return usage(&argv[0]); }
+		}
+		optind = opt.ind();
+		reqs.inuse = true;
+	}
+
+	if argv.len() == optind { return usage(&argv[0]); }
+
+	drop(argv);
+
+	if reqs.inuse {
+		for arg in args().skip(optind) {
+			for c in arg.chars() {
+				if (reqs.ascii && c.is_ascii())
+						|| (reqs.blank && c.is_whitespace())
+						|| (reqs.cntrl && c.is_control())
+						|| (reqs.digit && c.is_numeric())
+						|| (reqs.lower && c.is_lowercase())
+						|| (reqs.upper && c.is_uppercase())
+						|| reqs.extra.contains(c) {
+					continue;
+				} else {
+					return ExitCode::FAILURE;
+				}
+			}
+		}
+	}
+
+	ExitCode::SUCCESS
+}

src/swab.rs

@@ -33,29 +33,31 @@ use sysexits::{ EX_IOERR, EX_OK, EX_OSERR, EX_USAGE };
 use strerror::StrError;
 
 #[cfg(target_os="openbsd")] extern crate openbsd;
-#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge, unveil };
+#[cfg(target_os="openbsd")] use openbsd::{ Promises, pledge };
 
-fn err(argv0: &String, e: Error, code: u8) -> ExitCode {
+
+fn oserr(argv0: &str, e: Error) -> ExitCode {
 	eprintln!("{}: {}", argv0, e.strerror());
-	ExitCode::from(code)
+	ExitCode::from(EX_OSERR as u8)
 }
 
-fn usage(s: &String) -> ExitCode {
+fn ioerr(argv0: &str, e: Error) -> ExitCode {
+	eprintln!("{}: {}", argv0, e.strerror());
+	ExitCode::from(EX_IOERR as u8)
+}
+
+fn usage(s: &str) -> ExitCode {
 	eprintln!("Usage: {} [-w word_size]", s);
-	ExitCode::from(EX_USAGE)
+	ExitCode::from(EX_USAGE as u8)
 }
 
 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, EX_OSERR);
-		}
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e, EX_OSERR);
+	if cfg!(target_os="openbsd") {
+		let promises = Promises::new("stdio");
+		if let Err(e) = pledge(Some(promises), None) {
+			return oserr(&argv[0], e);
 		}
 	}
 
@@ -86,22 +88,22 @@ fn main() -> ExitCode {
 
 	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), // read nothing; bye
 			Ok(v) if v == wordsize => { // read full block; swab
 				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 ioerr(&argv[0], e);
 				}
 
 			},
 			Ok(v) => { // partial read; partially write
 				if let Err(e) = output.write(&buf[..v]) {
-					break err(&argv[0], e, EX_IOERR);
+					break ioerr(&argv[0], e);
 				}
 			},
-			Err(e) => break err(&argv[0], e, EX_OSERR)
+			Err(e) => break oserr(&argv[0], e)
 		}
 	}
 }

src/true.c

@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2023–2024 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
@@ -11,8 +10,8 @@
 #	include <unistd.h> /* pledge(2) */
 #endif
 
-int main(void) {
+int main() {
 #ifdef __OpenBSD__
-	(void)pledge("stdio", "");
+	pledge(NULL, NULL);
 #endif
 }

tests/README

@@ -1,13 +1,24 @@
-Tests
-=====
+The testing suite contains two trees: the Bonsai tree and the POSIX tree:
 
-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.
+.
+├── README
+├── bonsai/
+│   ├── dj.mk
+│   ├── false.mk
+│   ├── fop.mk
+│   └── ...
+├── posix/
+└── tests.mk
 
-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.
+The Bonsai tree tests the functionality of Harakit utilities for regressions and
+other issues relating to compliance to our standards of practice.
+
+The POSIX tests are currently a work-in-progress. Their status in this
+repository is uncertain.
+
+Both sets of tests also 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
@@ -16,10 +27,10 @@ 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
+	$ make -f tests.mk BIN=../build/bin dj_tests
 
 --
-Copyright © 2024–2025 Emma Tebibyte <emma@tebibyte.media>
+Copyright © 2024 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/bonsai/dj.mk

@@ -19,7 +19,7 @@ dj_tests: dj_help dj_full dj_null # dj_skip_stdin
 dj_full: $(BIN)/dj /dev/full
 	case "$$(uname)" in \
 	Linux) \
-		! $(BIN)/dj -Hi /dev/zero -o /dev/full 2>&1 \
+		$(BIN)/dj -Hi /dev/zero -o /dev/full 2>&1 \
 			| tee /dev/stderr \
 			| xargs -I out test '1+0 > 0+0; 1024 > 0' = out \
 		;; \

tests/bonsai/fop.mk

@@ -24,7 +24,6 @@ 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

tests/bonsai/mm.mk

@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
+# Copyright (c) 2024 E$(NAME)a Tebibyte <e$(NAME)a@tebibyte.media>
 # SPDX-License-Identifier: FSFAP
 #
 # Copying and distribution of this file, with or without modification, are
@@ -6,7 +6,7 @@
 # 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
+mm_tests: mm_args mm_help mm_stderr
 
 .PHONY: mm_none
 mm_none: $(BIN)/mm
@@ -25,16 +25,3 @@ mm_help: $(BIN)/mm
 # 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/bonsai/npc.mk

@@ -1,6 +1,6 @@
 #!/bin/sh
 # Copyright (c) 2024 DTB <trinity@trinity.moe>
-# Copyright (c) 2024–2025 Emma Tebibyte <emma@tebibyte.media>
+# Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
 # SPDX-License-Identifier: FSFAP
 #
 # Copying and distribution of this file, with or without modification, are
@@ -26,35 +26,17 @@ npc_args:
 
 .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: npc_ascii_controls npc_ascii_symbols npc_ascii_uppers # \
 #	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" =
+		| xargs -I out test "^@^A^B^C^D^E^F^G^H" = out
 
 	# ASCII 0x0a (otherwise the head|tail sequence won't work) to 0x1f
 	awk 'BEGIN{ for (i = 0; i < 32; ++i) printf("%c", i); print }' \
@@ -63,18 +45,14 @@ npc_ascii_controls:
 		| 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_symbols
+# ASCII 0x1f to 0x3f (^_ and symbols)
+npc_ascii_symbols:
+	# shell quoting olympics
+	awk 'BEGIN{ for (i = 31; i < 64; ++i) printf("%c", i); print }' \
+		| $(BIN)/npc \
+		| sed -e s"/\'/\\\'/g" -e 's/"/\\"/g' \
+		| xargs -I out test "^_ !\"#$$%&'()*+,-./0123456789:;<=>?" = out
 
 .PHONY: npc_ascii_uppers
 # ASCII 0x40 to 0x5f (uppercases)

tests/bonsai/rpn.mk

@@ -6,7 +6,7 @@
 # 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
+rpn_tests: rpn_help rpn_add rpn_sub rpn_mul rpn_div rpn_mod rpn_flr
 
 .PHONY: rpn_help
 rpn_help: $(BIN)/rpn
@@ -30,7 +30,7 @@ rpn_mul: $(BIN)/rpn
 .PHONY: rpn_div
 rpn_div: $(BIN)/rpn
 	test "$$($(BIN)/rpn 12 5 /)" = 2.4
-	test "$$($(BIN)/rpn 3 0 /)" = inf
+	test "$$($(BIN)/rpn 3 0 /)" -eq inf
 
 .PHONY: rpn_mod
 rpn_mod: $(BIN)/rpn
@@ -41,8 +41,3 @@ rpn_mod: $(BIN)/rpn
 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/bonsai/scrut.mk

@@ -8,20 +8,20 @@
 
 .PRAGMA: command_comment
 
-.PHONY: fileis_tests 
-fileis_tests: fileis_help fileis_options
+.PHONY: scrut_tests
+scrut_tests: scrut_help scrut_options
 
-.PHONY: fileis_help
-fileis_help: $(BIN)/fileis
-	! $(BIN)/fileis -h
+.PHONY: scrut_help
+scrut_help: $(BIN)/scrut
+	! $(BIN)/scrut -h
 
-.PHONY: fileis_options
-# fileis tests file attributes, but files of a certain attribute aren't
+.PHONY: scrut_options
+# scrut 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.
+# scrut.
 # opts are space-delimited (for command splitting), sel is not
-fileis_options: $(BIN)/fileis
+scrut_options: $(BIN)/scrut
 	set -e; \
 	opts="b c d e f g k p r s u w x L S"; \
 	sel=; \
@@ -30,12 +30,12 @@ fileis_options: $(BIN)/fileis
 			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" \
+						if ! $(BIN)/scrut -$$opt "$$f"; \
+							then printf "[!!] scrut -%s failed on %s.\n" \
 								$$opt "$$f"; \
 						fi; \
 						sel="$$sel$$opt"; \
-						printf "[OK] Tested fileis -%s using %s\n" \
+						printf "[OK] Tested scrut -%s using %s\n" \
 							$$opt "$$f"; \
 					fi; \
 				fi; \

tests/bonsai/stris.mk

@@ -0,0 +1,25 @@
+# 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: stris_tests
+stris_tests: stris_help stris_7 stris_b
+
+.PHONY: stris_help
+stris_help: $(BIN)/stris
+	! $(BIN)/stris -h
+
+.PHONY: stris_7
+stris_7: $(BIN)/stris
+	$(BIN)/stris   -7 !1Aa' '
+	! $(BIN)/stris -7 今日は
+
+.PHONY: stris_b
+stris_b: $(BIN)/stris
+	$(BIN)/stris   -b "$(printf ' \t\v\r\n')"
+	! $(BIN)/stris -b !1Aa

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/bin/cat

@@ -0,0 +1,22 @@
+#!/bin/sh
+# 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.
+
+# Strictly POSIX-compliant cat(1) implementation. See cat(1p)
+
+for arg in "$@"; do
+	case "$arg" in
+		-u) args="$(printf '%s	%s\n' "$args" "$arg")" ;;
+		*) args="$(printf -- '%s	-i	%s\n' "$args" "$arg")" ;;
+	esac
+done
+
+# See IEEE Std 1003.1-2017 3.282
+# https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_282
+IFS='	'
+
+mm $args

tests/posix/bin/false

@@ -1,20 +1,12 @@
+#!/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.
 
-.PRAGMA: command_comment
+# Strictly POSIX-compliant false(1) implementation. See false(1p)
 
-.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
+false "$@"

tests/posix/bin/true

@@ -0,0 +1,11 @@
+#!/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.
+
+# Strictly POSIX-compliant true(1) implementation. See true(1p)
+true "$@"

tests/posix/posix_env

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+set -ex
+
+PATH="$PWD/bin:$PATH"

tests/tests.mk

@@ -0,0 +1,15 @@
+# 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.
+
+
+#TESTFILES != for file in tests/bonsai/*.mk tests/posix/*.mk; do printf '%s ' "$$file"; done;
+TESTFILES != for file in tests/bonsai/*.mk; do printf '%s ' "$$file"; done;
+
+TESTS != printf '%s\n' "$(TESTFILES)" | xargs -n1 basename \
+	| sed 's/\.mk/_tests/g'
+
+include $(TESTFILES)