Makefile

@@ -95,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

src/false.c

@@ -13,7 +13,7 @@
 
 int main(void) {
 #ifdef __OpenBSD__
-	(void)pledge("stdio", "");
+	pledge(NULL, NULL);
 #endif
 	return 1;
 }

src/fop.rs

@@ -18,8 +18,8 @@
 
 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;
@@ -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) {
+fn main() {
-	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 optind = 1;
 
 	#[cfg(target_os="openbsd")] {
-		let promises = Promises::new("exec proc stdio unveil");
+		let promises = Promises::new("stdio proc exec");
 		if let Err(e) = pledge(Some(promises), None) {
-			err(&argv[0], e);
+			eprintln!("{}: {}", argv[0], e.strerror());
-			return ExitCode::from(EX_OSERR);
+			exit(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])); }
+	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);
+		eprintln!("{}: {}", argv[0], e.strerror());
-		exit(EX_IOERR.into());
+		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);
+			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 */
@@ -131,8 +126,8 @@ fn main() -> ExitCode {
 	}
 
 	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 */
@@ -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);
+		eprintln!("{}: {}: {}", argv[0], argv[command_arg], e);
-		exit(EX_IOERR.into());
+		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);
+		eprintln!("{}: {}", argv[0], e.strerror());
-		exit(EX_IOERR.into());
+		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");
+		let promises = Promises::new("stdio");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+		if let Err(e) = pledge(Some(promises), None) {
-			return err(&argv[0], e.strerror(), Some(EX_OSERR));
+			eprintln!("{}: {}", argv[0], e.strerror());
-		}
+			return ExitCode::from(EX_OSERR as u8);
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e.strerror(), Some(EX_OSERR));
 		}
 	}
 
 	let mut buf = String::new();
 
-	if let Err(e) = stdin().read_line(&mut buf) {
+	while let Ok(_) = stdin().read_line(&mut buf) {
-		return err(&argv[0], e.strerror(), Some(EX_IOERR));
+		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() {
+		let (number, prefix) = match convert(n) {
-		Ok(f) => {
+			Ok(x) => x,
-			buf.clear();
+			Err(err) => {
-			f
+				eprintln!("{}: {}", argv[0], err);
-		},
+				return ExitCode::from(EX_SOFTWARE as u8);
-		Err(e) => return err(&argv[0], e.to_string(), Some(EX_DATAERR)),
+			},
-	};
+		};
 
-	let (number, prefix) = convert(n).unwrap_or_else(|e| {
+		let si_prefix = format!("{}B", prefix.1);
-		let _ = err(&argv[0], e.to_string(), None);
-		exit(EX_SOFTWARE.into());
-	});
 
-	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 */
+		stdout().write_all(format!("{} {}\n", out, si_prefix).as_bytes())
-	let rounded = (number * 10.0).round() / 10.0;
+			.unwrap_or_else(|e| {
-	let out = rounded.to_string() + " " + &si_prefix + &'\n'.to_string();
+				eprintln!("{}: {}", argv[0], e.strerror());
-
+				exit(EX_IOERR);
-	if let Err(e) = stdout().write_all(out.as_bytes()) {
+			});
-		return err(&argv[0], e.strerror(), Some(EX_IOERR));
 	}
 
 	ExitCode::SUCCESS

src/intcmp.rs

@@ -26,35 +26,27 @@ 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 {
+fn usage(s: &str) -> ExitCode {
-	eprintln!("{}: {}", argv0, e);
+	eprintln!("Usage: {} [-egl] integer integer...", s);
-	ExitCode::from(code)
+	ExitCode::from(EX_USAGE as u8)
-}
-
-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");
+		let promises = Promises::new("stdio");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+		if let Err(e) = pledge(Some(promises), None) {
-			return err(&argv[0], e.strerror(), EX_OSERR);
+			eprintln!("{}: {}", argv[0], e.strerror());
-		}
+			return ExitCode::from(EX_OSERR as u8);
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e.strerror(), EX_OSERR);
 		}
 	}
 
@@ -86,8 +78,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();
+				eprintln!("{}: {}: {}", &argv[0], arg, e);
-				return err(&argv[0], error, EX_DATAERR);
+				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 {
+	pub fn new(permissions: Vec<char>) -> Self {
-		let perms = CString::new(
+		if permissions.is_empty() {
-			permissions.into_iter().collect::<String>()
+			return UnveilPerms(CString::new("").unwrap());
-		).unwrap();
+		}
-		
+
-		UnveilPerms(perms)
+		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| {
+	let arg2 = permissions
-		p.0.into_raw() as *const c_char
+		.map(|p| p.0.into_raw() as *const c_char)
-	}).unwrap_or(null());
+		.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())) {
+		if let Err(e) = pledge(Some(promises), None) {
-			return err(&argv[0], e, Some(EX_OSERR));
+			eprintln!("{}: {}", argv[0], e.strerror());
+			return ExitCode::from(EX_OSERR as u8);
 		}
 	}
 
@@ -93,7 +85,8 @@ fn main() -> ExitCode {
 				mode = Some(Out); /* latest argument == -o */
 			},
 			Err(_) | Ok(_) => {
-				return usage(&argv[0]);
+				eprintln!("{}", usage);
+				return ExitCode::from(EX_USAGE as u8);
 			},
 		};
 
@@ -115,28 +108,32 @@ fn main() -> ExitCode {
 
 	#[cfg(target_os="openbsd")] {
 		for input in &ins {
-			let perms = UnveilPerms::new(['r']);
+			let perms = UnveilPerms::new(vec!['r']);
 
 			if let Err(e) = unveil(Some(&input), Some(perms)) {
-				return err(&argv[0], e, Some(EX_OSERR));
+				eprintln!("{}: {}", argv[0], e.strerror());
+				return ExitCode::from(EX_OSERR as u8);
 			}
 		}
 
 		for output in &outs {
-			let perms = UnveilPerms::new(['c', 'w']);
+			let perms = UnveilPerms::new(vec!['c', 'w']);
 
 			if let Err(e) = unveil(Some(&output), Some(perms)) {
-				return err(&argv[0], e, Some(EX_OSERR));
+				eprintln!("{}: {}", argv[0], e.strerror());
+				return ExitCode::from(EX_OSERR as u8);
 			}
 		}
 
 		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);
+				eprintln!("{}: {}: {}", argv[0], file, e.strerror());
-				exit(EX_IOERR.into());
+				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);
+				eprintln!("{}: {}: {}", argv[0], file, e.strerror());
-				exit(EX_IOERR.into());
+				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);
+				eprintln!("{}: {}", argv[0], e.strerror());
-				exit(EX_IOERR.into());
+				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/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;
-use sysexits::{ EX_DATAERR, EX_IOERR };
 
 #[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 {
+/* 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,
@@ -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 */
+				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,
+					})
+				}
 			},
 		};
 	}
@@ -204,46 +190,51 @@ fn eval(
 }
 
 /* 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");
+		let promises = Promises::new("stdio");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+		if let Err(e) = pledge(Some(promises), None) {
-			return err(&argv[0], &e, Some(EX_OSERR));
+			eprintln!("{}: {}", argv[0], e.strerror());
-		}
+			return ExitCode::from(EX_OSERR as u8);
-
-		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() { /* 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
+				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::SUCCESS,
-				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::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

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

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/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");
+		let promises = Promises::new("stdio");
-		if let Err(e) = pledge(Some(promises), Some(Promises::default())) {
+		if let Err(e) = pledge(Some(promises), None) {
-			return err(&argv[0], e, EX_OSERR);
+			return oserr(&argv[0], e);
-		}
-
-		if let Err(e) = unveil(None, None) {
-			return err(&argv[0], e, EX_OSERR);
 		}
 	}
 
@@ -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

@@ -13,6 +13,6 @@
 
 int main(void) {
 #ifdef __OpenBSD__
-	(void)pledge("stdio", "");
+	pledge(NULL, NULL);
 #endif
 }

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

@@ -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 mm_remaining
 
 .PHONY: mm_none
 mm_none: $(BIN)/mm
@@ -32,9 +32,3 @@ 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/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
@@ -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