Merge branch 'swab' (closes #22)

Makefile

@@ -14,11 +14,10 @@
 PREFIX=/usr/local
 
 CC=cc
-MAKE=make
 RUSTC=rustc
 
 .PHONY: all
-all: dj false fop hru intcmp rpn scrut str strcmp true
+all: dj false fop hru intcmp rpn scrut str strcmp swab true
 
 build:
 	# keep build/include until bindgen(1) has stdin support
@@ -43,7 +42,6 @@ install: dist
 test: build
 	tests/posix-compat.sh
 	$(RUSTC) --test src/getopt-rs/lib.rs -o build/test/getopt
-	$(MAKE) -f Testfile
 
 build/o/libsysexits.rlib: build
 	# bandage solution until bindgen(1) gets stdin support
@@ -110,6 +108,13 @@ strcmp: build/bin/strcmp
 build/bin/strcmp: src/strcmp.c build
 	$(CC) $(CFLAGS) -o $@ src/strcmp.c
 
+.PHONY: swab
+swab: build/bin/swab
+build/bin/swab: src/swab.rs build build/o/libsysexits.rlib
+	$(RUSTC) $(RUSTFLAGS) --extern getopt=build/o/libgetopt.rlib \
+		--extern sysexits=build/o/libsysexits.rlib \
+		-o $@ src/swab.rs
+
 .PHONY: true
 true: build/bin/true
 build/bin/true: src/true.c build

Testfile

@@ -1,78 +0,0 @@
-#!/usr/bin/env make
-# 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.
-
-BIN = build/bin
-MAKE = make -B
-
-DEFENDANTS = dj false intcmp strcmp true
-.PHONY: all $(DEFENDANTS)
-all: $(DEFENDANTS)
-
-$(BIN)/dj:
-	$(MAKE) dj
-
-$(BIN)/false:
-	$(MAKE) false
-
-$(BIN)/intcmp:
-	$(MAKE) intcmp
-
-$(BIN)/strcmp:
-	$(MAKE) strcmp
-
-$(BIN)/true:
-	$(MAKE) true
-
-dj: $(BIN)/dj $(BIN)/strcmp
-	sh -c "! $(BIN)/dj -h"
-	# This test is theoretically Linux-dependent; write(2) should return -1 on
-	# error.
-	# Right now dj(1) interprets the return value of write(2) as the amount of
-	# bytes written. This can decrement the stored quantity of bytes written,
-	# which is an int, so doesn't underflow but goes negative. dj(1) tries to
-	# again to write(2) if an error occurs in which no bytes are written, so in
-	# total two write(2)s are attempted and so the written byte quantity is -2.
-	# This is a bug and will change, but for now is at least documented.
-	sh -ec "\
-		$(BIN)/dj -Hi /dev/zero -o /dev/full \
-		| xargs -I out $(BIN)/strcmp '1+0 > 0+0; 1024 > -2' out"
-	# Read nothing from /dev/null, write nothing to /dev/null.
-	sh -ec "\
-		$(BIN)/dj -Hi /dev/null -o /dev/null \
-		| xargs -I out $(BIN)/strcmp '0+0 > 0+0; 0 > 0' out"
-
-false: $(BIN)/false
-	sh -c "! $(BIN)/false"
-	sh -c "! $(BIN)/false -h"
-
-intcmp: $(BIN)/intcmp
-	$(BIN)/intcmp -e   3 3 3
-	$(BIN)/intcmp -g   3 2 1
-	$(BIN)/intcmp -l   1 2 3
-	$(BIN)/intcmp -ge  3 3 1
-	$(BIN)/intcmp -le  1 3 3
-	$(BIN)/intcmp -gl  1 2 3
-	$(BIN)/intcmp -egl 3 1 1 2
-	sh -c "! $(BIN)/intcmp -e   1 2 3"
-	sh -c "! $(BIN)/intcmp -g   1 3 3"
-	sh -c "! $(BIN)/intcmp -l   3 3 1"
-	sh -c "! $(BIN)/intcmp -ge  1 2 3"
-	sh -c "! $(BIN)/intcmp -le  3 2 1"
-	sh -c "! $(BIN)/intcmp -gl  3 3 3"
-	sh -c "! $(BIN)/intcmp -egl foo"
-
-strcmp: $(BIN)/strcmp
-	$(BIN)/strcmp equals equals
-	sh -c "! $(BIN)/strcmp inequals equals"
-	$(BIN)/strcmp - -
-	sh -c "! $(BIN)/strcmp -h"
-	sh -c "! $(BIN)/strcmp nocmp"
-
-true:
-	$(BIN)/true
-	$(BIN)/true -h

docs/swab.1

@@ -0,0 +1,71 @@
+.\" Copyright (c) 2024 DTB <trinity@trinity.moe>
+.\"
+.\" 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 swab 1
+
+.SH NAME
+
+swab \(en swap bytes
+
+.SH SYNOPSIS
+
+swab
+.RB ( -f )
+.RB ( -w
+.R [
+.B word size
+.R ])
+
+.SH USAGE
+
+Swab swaps the latter and former halves of a block of bytes.
+
+.SH EXAMPLES
+
+The following sh(1p) line:
+
+.R printf 'hello world!\n' | swab
+
+Produces the following output:
+
+.R ehll oowlr!d
+
+.SH OPTIONS
+
+The
+.B -f
+option ignores system call interruptions.
+.PP
+The
+.B -w
+option configures the word size; that is, the size in bytes of the block size
+on which to operate. By default the word size is 2. The word size must be
+cleanly divisible by 2, otherwise the block of bytes being processed can't be
+halved.
+
+.SH DIAGNOSTICS
+
+If an error is encountered in input, output, or invocation, a diagnostic
+message will be written to standard error and swab will exit with the
+appropriate status from sysexits.h(3).
+
+.SH RATIONALE
+
+Swab was modeled after the
+.R conv=swab
+functionality specified in the POSIX dd utility but additionally allows the
+word size to be configured.
+.PP
+Swab is useful for fixing the endianness of binary files produced on other
+machines.
+
+.SH COPYRIGHT
+
+Copyright (c) 2024 DTB. License AGPLv3+: GNU AGPL version 3 or later
+<https://gnu.org/licenses/agpl.html>.
+
+.SH SEE ALSO
+
+dd(1p)

src/swab.rs

@@ -0,0 +1,90 @@
+/*
+ * 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,
+	io::{ stdin, stdout, Error, ErrorKind, Read, Write },
+	process::ExitCode,
+	vec::Vec
+};
+
+extern crate getopt;
+use getopt::{ Opt, Parser };
+
+extern crate sysexits;
+use sysexits::{ EX_OK, EX_OSERR, EX_USAGE };
+
+fn oserr(s: &str, e: Error) -> ExitCode {
+	eprintln!("{}: {}", s, e);
+	ExitCode::from(EX_OSERR as u8)
+}
+
+fn usage(s: &str) -> ExitCode {
+	eprintln!("Usage: {} (-f) (-w [wordsize])", s);
+	ExitCode::from(EX_USAGE as u8)
+}
+
+fn main() -> ExitCode {
+	let argv = args().collect::<Vec<String>>();
+	let mut buf: Vec<u8> = Vec::new();
+	let mut input = stdin();
+	let mut output = stdout().lock();
+
+	let mut opts = Parser::new(&argv, "fw:");
+	let mut force = false;
+	let mut wordsize: usize = 2;
+
+	loop {
+		match opts.next() {
+			None => break,
+			Some(opt) =>
+				match opt {
+					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]); }
+				}
+		}
+	}
+
+	buf.resize(wordsize, 0);
+
+	loop {
+		match input.read(&mut buf) {
+			Ok(0) => break ExitCode::from(EX_OK as u8),
+			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 oserr(&argv[0], e)
+				}
+			},
+			Ok(v) => {
+				if let Err(e) = output.write(&buf[..v]) {
+					break oserr(&argv[0], e)
+				}
+			},
+			Err(e) if e.kind() == ErrorKind::Interrupted && force => continue,
+			Err(e) => break oserr(&argv[0], e)
+		}
+	}
+}