aboutsummaryrefslogtreecommitdiff
path: root/src/commands/od.js
diff options
context:
space:
mode:
Diffstat (limited to 'src/commands/od.js')
-rw-r--r--src/commands/od.js717
1 files changed, 717 insertions, 0 deletions
diff --git a/src/commands/od.js b/src/commands/od.js
new file mode 100644
index 0000000..310244d
--- /dev/null
+++ b/src/commands/od.js
@@ -0,0 +1,717 @@
+#!/usr/bin/env bun
+
+import { closeSync, openSync, readSync } from "node:fs";
+import { open, stat } from "node:fs/promises";
+import { concatBytes, isWriteError, localeQuotedDiagnostic, localeQuotedEscapedDiagnostic, normalizeLongOptionByPrefix, parseGNUSize, parseOptions, readAll, readFdChunkViews, systemErrorMessage } from "../shared/common.js";
+import { UsageError, stderr, stdout } from "../shared/diagnostics.js";
+import { defineCommand, runAsMain } from "../shared/command.js";
+
+export const OD_LONG_OPTIONS = ["address-radix", "endian", "format", "output-duplicates", "read-bytes", "skip-bytes", "strings", "traditional", "width", "help", "version"];
+
+export function odMetaOption(args) {
+ const longValueOptions = new Set(["address-radix", "endian", "format", "read-bytes", "skip-bytes"]);
+ const longOptionalValueOptions = new Set(["strings", "width"]);
+ const shortValueOptions = new Set(["A", "j", "N", "S", "t"]);
+ const shortOptionalValueOptions = new Set(["w"]);
+ const shortKnownOptions = new Set(["A", "j", "N", "S", "t", "w", "a", "b", "c", "d", "f", "i", "l", "o", "s", "x", "v"]);
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i];
+ if (arg === "--") return null;
+ if (arg.startsWith("--")) {
+ const option = normalizeOdLongOption(arg);
+ const [name, inlineValue] = option.slice(2).split(/=(.*)/s, 2);
+ if (!OD_LONG_OPTIONS.includes(name)) return null;
+ if ((option === "--help" || option === "--version") && inlineValue == null) return option;
+ const value = inlineValue ?? (longValueOptions.has(name) ? args[i + 1] : undefined);
+ if (name === "endian" && value !== undefined) validateOdEndian(value);
+ if (name === "read-bytes" && value !== undefined) parseOdSize(value, "--read-bytes");
+ if (name === "skip-bytes" && value !== undefined) parseOdSize(value, "--skip-bytes");
+ if (name === "strings" && inlineValue != null) parseOdStringLength(inlineValue, "--strings");
+ if (name === "width" && inlineValue != null) parseOdWidth(inlineValue, "--width");
+ if (inlineValue == null && longValueOptions.has(name)) i++;
+ else if (inlineValue == null && longOptionalValueOptions.has(name)) continue;
+ else if (inlineValue != null && !longValueOptions.has(name) && !longOptionalValueOptions.has(name)) return null;
+ continue;
+ }
+ if (!arg.startsWith("-") || arg === "-") continue;
+ for (let j = 1; j < arg.length; j++) {
+ const ch = arg[j];
+ if (!shortKnownOptions.has(ch)) return null;
+ if (shortValueOptions.has(ch)) {
+ const inlineValue = arg.slice(j + 1);
+ const value = inlineValue === "" ? args[i + 1] : inlineValue;
+ validateOdMetaShortValue(ch, value);
+ if (inlineValue === "") i++;
+ break;
+ }
+ if (shortOptionalValueOptions.has(ch)) {
+ const inlineValue = arg.slice(j + 1);
+ if (inlineValue !== "") parseOdWidth(inlineValue, "-w");
+ break;
+ }
+ }
+ }
+ return null;
+}
+
+export function validateOdMetaShortValue(ch, value) {
+ if (value === undefined) return;
+ if (ch === "j") parseOdSize(value, "-j");
+ else if (ch === "N") parseOdSize(value, "-N");
+ else if (ch === "S") parseOdStringLength(value, "-S");
+}
+
+export function readStdinBytesLimit(limit) {
+ const chunks = [];
+ const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, Math.max(0, limit)));
+ let total = 0;
+ while (total < limit) {
+ const n = readSync(0, buffer, 0, Math.min(buffer.length, limit - total), null);
+ if (n === 0) break;
+ chunks.push(Buffer.from(buffer.subarray(0, n)));
+ total += n;
+ }
+ const out = new Uint8Array(total);
+ let offset = 0;
+ for (const chunk of chunks) {
+ out.set(chunk, offset);
+ offset += chunk.length;
+ }
+ return out;
+}
+
+export async function odCmd(args) {
+ args = normalizeOdLongOptions(args);
+ const { opts, operands } = parseOptions(args, { short: { A: "value", j: "value", N: "value", S: "value", t: "value", w: "optional-value", a: false, b: false, c: false, d: false, f: false, i: false, l: false, o: false, s: false, x: false, v: false }, long: { "address-radix": "value", "skip-bytes": "value", strings: "optional-value", format: "value", "read-bytes": "value", width: "optional-value", "output-duplicates": false, endian: "value", traditional: false, help: false, version: false } });
+ const explicitFormats = odFormatsFromArgs(args).filter((format) => format !== "");
+ const rawFormats = explicitFormats.length ? explicitFormats : [odFormat(opts)];
+ const radix = normalizeOdAddressRadix(opts.A ?? opts["address-radix"] ?? "o");
+ validateOdEndian(opts.endian);
+ for (const format of rawFormats) validateOdFormat(format);
+ const formats = rawFormats.flatMap(odFormatSpecs);
+ const oldStyleOffset = odCanUseOldStyleOffset(args);
+ const traditional = parseOdTraditionalOperands(operands, opts.traditional, oldStyleOffset);
+ const inputFiles = traditional.files.length ? traditional.files : ["-"];
+ const chunks = [];
+ let failed = false;
+ let hasNonRegularInput = false;
+ const skip = traditional.skip ?? opts.j ?? opts["skip-bytes"];
+ const limit = opts.N ?? opts["read-bytes"];
+ const skipOption = opts.j != null ? "-j" : opts["skip-bytes"] != null ? "--skip-bytes" : "-j";
+ const limitOption = opts.N != null ? "-N" : "--read-bytes";
+ const start = skip == null ? 0 : parseOdSize(skip, skipOption);
+ const limitSize = limit == null ? null : parseOdSize(limit, limitOption);
+ const readLimit = limitSize == null ? null : start + limitSize;
+ if (skip == null && limit == null && traditional.label == null
+ && opts.S == null && opts.strings == null && inputFiles.length === 1
+ && (opts.v || opts["output-duplicates"])) {
+ const lineWidth = resolveOdLineWidth(opts, formats);
+ return streamOdFile(inputFiles[0], formats, opts, lineWidth, radix);
+ }
+ for (const file of inputFiles) {
+ try {
+ if (file !== "-") {
+ const s = await stat(file);
+ if (s.isDirectory()) throw Object.assign(new Error("Is a directory"), { code: "EISDIR" });
+ if (!s.isFile()) hasNonRegularInput = true;
+ }
+ chunks.push(readLimit == null ? await readAll(file) : await readAllLimit(file, readLimit));
+ } catch (error) {
+ stderr(`od: ${odDiagnosticFile(file)}: ${systemErrorMessage(error)}\n`);
+ failed = true;
+ }
+ }
+ if (failed && chunks.length === 0) return 1;
+ const raw = concatBytes(chunks);
+ if (skip != null && start > raw.length && !hasNonRegularInput) {
+ stderr("od: cannot skip past end of combined input\n");
+ return 1;
+ }
+ const data = raw.slice(start, limit == null ? undefined : start + limitSize);
+ const labelDelta = traditional.label == null ? null : parseGNUSize(traditional.label) - start;
+ if (opts.S != null || opts.strings != null) {
+ const stringsOption = opts.S != null ? "-S" : "--strings";
+ stdout(formatOdStrings(data, parseOdStringLength(opts.S ?? (opts.strings === true ? 3 : opts.strings ?? 3), stringsOption), start, radix, limit != null));
+ return failed ? 1 : 0;
+ }
+ const format = formats[0];
+ const lineWidth = resolveOdLineWidth(opts, formats);
+ let out = "";
+ let previousBodyKey = null;
+ let duplicatesSuppressed = false;
+ for (let offset = 0; offset < data.length; offset += lineWidth) {
+ const chunk = data.slice(offset, offset + lineWidth);
+ const address = formatOdAddress(start + offset, radix, labelDelta);
+ const bodyLines = odRenderedBodyLines(chunk, formats, opts.endian, lineWidth);
+ const bodyKey = bodyLines.join("\n");
+ if (!(opts.v || opts["output-duplicates"]) && previousBodyKey === bodyKey) {
+ if (!duplicatesSuppressed) out += "*\n";
+ duplicatesSuppressed = true;
+ continue;
+ }
+ previousBodyKey = bodyKey;
+ duplicatesSuppressed = false;
+ out += formatOdChunkOutput(address, bodyLines, formats);
+ }
+ const finalAddress = formatOdAddress(start + data.length, radix, labelDelta);
+ if (finalAddress) out += `${finalAddress}\n`;
+ stdout(out);
+ return failed ? 1 : 0;
+}
+
+export function resolveOdLineWidth(opts, formats) {
+ const width = opts.w ?? opts.width;
+ const widthOption = opts.w != null ? "-w" : "--width";
+ let lineWidth = width === true ? 32 : width == null ? 16 : parseOdWidth(width, widthOption);
+ const formatSize = Math.max(...formats.map(odFormatSize));
+ if (lineWidth % formatSize !== 0) {
+ stderr(`od: warning: invalid width ${lineWidth}; using ${formatSize} instead\n`);
+ lineWidth = formatSize;
+ }
+ return lineWidth;
+}
+
+export function formatOdChunkOutput(address, bodyLines, formats) {
+ if (formats.length === 1) return `${address} ${bodyLines[0]}\n`;
+ const bodyWidth = Math.max(...bodyLines.map((line) => line.length));
+ const firstPrefix = address ? `${address} ` : " ";
+ const nextPrefix = address ? " ".repeat(address.length + 1) : " ";
+ let out = "";
+ for (let i = 0; i < bodyLines.length; i++) {
+ const line = normalizeOdFormat(formats[i]).showChars ? bodyLines[i].padEnd(bodyWidth) : bodyLines[i];
+ out += `${i === 0 ? firstPrefix : nextPrefix}${line}\n`;
+ }
+ return out;
+}
+
+export function streamOdFile(file, formats, opts, lineWidth, radix) {
+ let fd;
+ let offset = 0;
+ let carry = Buffer.alloc(0);
+ try {
+ fd = file === "-" ? 0 : openSync(file, "r");
+ readFdChunkViews(fd, (chunk) => {
+ const bytes = carry.length ? Buffer.concat([carry, chunk]) : chunk;
+ let index = 0;
+ while (index + lineWidth <= bytes.length) {
+ const part = bytes.subarray(index, index + lineWidth);
+ const address = formatOdAddress(offset, radix, null);
+ stdout(formatOdChunkOutput(address, odRenderedBodyLines(part, formats, opts.endian, lineWidth), formats));
+ offset += part.length;
+ index += lineWidth;
+ }
+ carry = Buffer.from(bytes.subarray(index));
+ });
+ if (carry.length) {
+ const address = formatOdAddress(offset, radix, null);
+ stdout(formatOdChunkOutput(address, odRenderedBodyLines(carry, formats, opts.endian, lineWidth), formats));
+ offset += carry.length;
+ }
+ const finalAddress = formatOdAddress(offset, radix, null);
+ if (finalAddress) stdout(`${finalAddress}\n`);
+ return 0;
+ } catch (error) {
+ if (isWriteError(error)) throw error;
+ stderr(`od: ${odDiagnosticFile(file)}: ${systemErrorMessage(error)}\n`);
+ return 1;
+ } finally {
+ if (fd != null && fd !== 0) closeSync(fd);
+ }
+}
+
+export function odRenderedBodyLines(chunk, formats, endian, lineWidth) {
+ if (formats.length === 1) return [formatOdLine(chunk, formats[0], endian, lineWidth)];
+ return formats.map((fmt) => formatOdLine(chunk, fmt, endian, lineWidth, true, formats));
+}
+
+export function normalizeOdAddressRadix(radix) {
+ const text = String(radix);
+ if (/^[doxn]/.test(text)) return text[0];
+ throw new UsageError(`invalid output address radix '${text[0] ?? "\0"}'; it must be one character from [doxn]`);
+}
+
+export function normalizeOdLongOptions(args) {
+ return args.map((arg) => normalizeOdLongOption(arg));
+}
+
+export function normalizeOdLongOption(arg) {
+ if (!arg.startsWith("--") || arg === "--") return arg;
+ return normalizeLongOptionByPrefix(arg, OD_LONG_OPTIONS);
+}
+
+export function validateOdEndian(endian) {
+ if (endian == null || endian === "little" || endian === "big") return;
+ const kind = endian === "" ? "ambiguous" : "invalid";
+ throw new UsageError(`${kind} argument ${localeQuotedEscapedDiagnostic(endian)} for ${localeQuotedDiagnostic("--endian")}\nValid arguments are:\n - ${localeQuotedDiagnostic("little")}\n - ${localeQuotedDiagnostic("big")}`, true);
+}
+
+export async function readAllLimit(path, limit) {
+ if (limit <= 0) return new Uint8Array();
+ if (path === "-") return readStdinBytesLimit(limit);
+ const handle = await open(path, "r");
+ try {
+ const bytes = Buffer.allocUnsafe(limit);
+ let offset = 0;
+ while (offset < limit) {
+ const { bytesRead } = await handle.read(bytes, offset, limit - offset, null);
+ if (bytesRead === 0) break;
+ offset += bytesRead;
+ }
+ return bytes.subarray(0, offset);
+ } finally {
+ await handle.close();
+ }
+}
+
+export function parseOdSize(value, option) {
+ const text = String(value);
+ if (text === "") throw new UsageError(`invalid ${option} argument ''`);
+ try {
+ const size = parseOdByteCount(text.replace(/^\+/, ""));
+ return size > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(size);
+ } catch (error) {
+ if (error instanceof UsageError && error.message === "too large") throw new UsageError(`${option} argument '${text}' too large`);
+ if (text.startsWith("-")) throw new UsageError(`invalid ${option} argument '${text}'`);
+ throw new UsageError(`invalid suffix in ${option} argument '${text}'`);
+ }
+}
+
+export function parseOdByteCount(text) {
+ const match = String(text).match(/^(\d+)([A-Za-z]*)$/);
+ if (!match) throw new UsageError("invalid suffix");
+ const scales = {
+ "": 1n, b: 512n,
+ K: 1024n, k: 1024n, KiB: 1024n, kiB: 1024n,
+ M: 1024n ** 2n, m: 1024n ** 2n, MiB: 1024n ** 2n, miB: 1024n ** 2n,
+ G: 1024n ** 3n, g: 1024n ** 3n, GiB: 1024n ** 3n, giB: 1024n ** 3n,
+ T: 1024n ** 4n, t: 1024n ** 4n, TiB: 1024n ** 4n, tiB: 1024n ** 4n,
+ P: 1024n ** 5n, PiB: 1024n ** 5n,
+ E: 1024n ** 6n, EiB: 1024n ** 6n,
+ Z: 1024n ** 7n, ZiB: 1024n ** 7n,
+ Y: 1024n ** 8n, YiB: 1024n ** 8n,
+ R: 1024n ** 9n, RiB: 1024n ** 9n,
+ Q: 1024n ** 10n, QiB: 1024n ** 10n,
+ KB: 1000n, kB: 1000n, MB: 1000n ** 2n, mB: 1000n ** 2n,
+ GB: 1000n ** 3n, gB: 1000n ** 3n, TB: 1000n ** 4n, tB: 1000n ** 4n,
+ PB: 1000n ** 5n, EB: 1000n ** 6n, ZB: 1000n ** 7n, YB: 1000n ** 8n,
+ RB: 1000n ** 9n, QB: 1000n ** 10n,
+ };
+ const scale = scales[match[2]];
+ if (!scale) throw new UsageError("invalid suffix");
+ const amount = BigInt(match[1]) * scale;
+ if (amount > 9223372036854775807n) throw new UsageError("too large");
+ return amount;
+}
+
+export function parseOdWidth(value, option) {
+ const text = String(value);
+ let size;
+ try {
+ size = parseGNUSize(text.replace(/^\+/, ""));
+ } catch {
+ if (text.startsWith("-") || !/^\+?\d/.test(text)) throw new UsageError(`invalid ${option} argument '${text}'`);
+ throw new UsageError(`invalid suffix in ${option} argument '${text}'`);
+ }
+ if (size <= 0) throw new UsageError(`invalid ${option} argument '${text}'`);
+ return size;
+}
+
+export function parseOdStringLength(value, option = "-S") {
+ const text = String(value);
+ if (text === "") throw new UsageError(`invalid ${option} argument ''`);
+ try {
+ const parsed = parseOdByteCount(/^\D+$/.test(text) ? `1${text}` : text);
+ return parsed > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(parsed);
+ } catch (error) {
+ if (error instanceof UsageError && error.message === "too large") throw new UsageError(`${option} argument '${text}' too large`);
+ if (text.startsWith("-") || /^[A-Za-z]$/.test(text)) throw new UsageError(`invalid ${option} argument '${text}'`);
+ throw new UsageError(`invalid suffix in ${option} argument '${text}'`);
+ }
+}
+
+export function odFormatsFromArgs(args) {
+ const formats = [];
+ const traditionalFormats = { a: "a", b: "o1", c: "c", d: "u2", f: "fF", i: "dI", l: "dL", o: "o2", s: "d2", x: "x2" };
+ for (let i = 0; i < args.length; i++) {
+ const arg = normalizeOdLongOption(String(args[i]));
+ if (arg === "--") break;
+ if (arg === "-t" || arg === "--format") {
+ if (i + 1 < args.length) formats.push(String(args[++i]));
+ } else if (arg.startsWith("-t") && arg.length > 2) {
+ formats.push(arg.slice(2));
+ } else if (arg.startsWith("--format=")) {
+ formats.push(arg.slice("--format=".length));
+ } else if (/^-[^-]/.test(arg)) {
+ for (let j = 1; j < arg.length; j++) {
+ const ch = arg[j];
+ if (traditionalFormats[ch]) formats.push(traditionalFormats[ch]);
+ else if (ch === "t") {
+ if (j + 1 < arg.length) formats.push(arg.slice(j + 1));
+ else if (i + 1 < args.length) formats.push(String(args[++i]));
+ break;
+ } else if ("AjNSw".includes(ch)) {
+ break;
+ }
+ }
+ }
+ }
+ return formats;
+}
+
+export function odFormatSpecs(format) {
+ const text = String(format);
+ const specs = [];
+ let i = 0;
+ while (i < text.length) {
+ const start = i;
+ const kind = text[i++];
+ if (!isOdFormatStart(kind)) throw new UsageError(`invalid character '${kind ?? ""}' in type string ${localeQuotedEscapedDiagnostic(format)}`);
+ if (kind === "f") {
+ if ("FDLHB".includes(text[i] ?? "")) i++;
+ else while (/\d/.test(text[i] ?? "")) i++;
+ } else if ("doux".includes(kind)) {
+ if ("CSIL".includes(text[i] ?? "")) i++;
+ else while (/\d/.test(text[i] ?? "")) i++;
+ }
+ if (text[i] === "z") i++;
+ specs.push(text.slice(start, i));
+ }
+ return specs;
+}
+
+export function isOdFormatStart(ch) {
+ return ch != null && "acfdoux".includes(ch);
+}
+
+export function odCanUseOldStyleOffset(args) {
+ return args.every((arg) => arg === "--" || !String(arg).startsWith("-"));
+}
+
+export function parseOdTraditionalOperands(operands, traditional = false, oldStyleOffset = false) {
+ const files = [...operands];
+ if (!files.length) return { files, skip: null, label: null };
+ let label = null;
+ const rejectTraditionalExtraFile = () => {
+ if (traditional && files.length > 1) {
+ throw new UsageError(`extra operand ${localeQuotedEscapedDiagnostic(files[1])}\nod: compatibility mode supports at most one file`, true);
+ }
+ };
+ if (traditional && files.length >= 2) {
+ const parsedLabel = parseOdTraditionalOffset(files.at(-1));
+ const parsedSkip = parseOdTraditionalOffset(files.at(-2));
+ if (parsedLabel && parsedSkip) {
+ files.pop();
+ files.pop();
+ rejectTraditionalExtraFile();
+ return { files, skip: parsedSkip, label: parsedLabel };
+ }
+ }
+ const last = files.at(-1);
+ const parsed = parseOdTraditionalOffset(last);
+ if (!parsed || (!traditional && (!oldStyleOffset || !String(last).startsWith("+")))) {
+ rejectTraditionalExtraFile();
+ return { files, skip: null, label };
+ }
+ files.pop();
+ rejectTraditionalExtraFile();
+ return { files, skip: parsed, label };
+}
+
+export function parseOdTraditionalOffset(value) {
+ const text = String(value);
+ const match = text.match(/^\+?((?:0x[0-9a-fA-F]+)|(?:\d+))(\.)?([bB])?$/);
+ if (!match) {
+ if (/^(?:\+?[0-9]{100,}\.?|\+?0x[0-9a-fA-F]{100,})$/.test(text)) throw new UsageError(`${text}: Numerical result out of range`);
+ return null;
+ }
+ const digits = match[1];
+ if (digits.replace(/^0x/i, "").length > 60) throw new UsageError(`${text}: Numerical result out of range`);
+ const base = /^0x/i.test(digits) ? 16 : match[2] === "." ? 10 : 8;
+ if (base === 8 && /[89]/.test(digits)) return null;
+ let n = Number.parseInt(digits.replace(/^0x/i, ""), base);
+ if (match[3]?.toLowerCase() === "b") n *= 512;
+ if (!Number.isSafeInteger(n)) throw new UsageError(`${text}: Numerical result out of range`);
+ return String(n);
+}
+
+export function odDiagnosticFile(file) {
+ return /\s/.test(String(file)) ? `'${String(file).replace(/'/g, "'\\''")}'` : file;
+}
+
+export function odFormat(opts) {
+ if (opts.a) return "a";
+ if (opts.b) return "o1";
+ if (opts.c) return "c";
+ if (opts.d) return "u2";
+ if (opts.f) return "fF";
+ if (opts.i) return "dI";
+ if (opts.l) return "dL";
+ if (opts.o) return "o2";
+ if (opts.s) return "d2";
+ if (opts.x) return "x2";
+ if (opts.t != null && opts.t !== "") return opts.t;
+ if (opts.format != null && opts.format !== "") return opts.format;
+ return "o2";
+}
+
+export function formatOffset(offset, radix) {
+ if (radix === "n") return "";
+ if (radix === "d") return String(offset).padStart(7, "0");
+ if (radix === "x") return offset.toString(16).padStart(6, "0");
+ return offset.toString(8).padStart(7, "0");
+}
+
+export function formatOdAddress(offset, radix, labelDelta = null) {
+ const address = formatOffset(offset, radix);
+ if (labelDelta == null) return address;
+ const label = formatOffset(offset + (radix === "n" ? 0 : labelDelta), radix === "n" ? "o" : radix);
+ return address ? `${address} (${label})` : `(${label})`;
+}
+
+export function formatOdLine(chunk, format, endian = "little", lineWidth = null, multiFormat = false, groupFormats = [format]) {
+ const normalized = normalizeOdFormat(format);
+ const body = formatOdChunk(chunk, normalized.format, endian, multiFormat, groupFormats);
+ if (!normalized.showChars) return body;
+ const paddedBody = lineWidth == null ? body : body.padEnd(odFullLineBodyWidth(normalized.format, lineWidth, multiFormat, groupFormats));
+ return `${paddedBody} ${formatOdAscii(chunk)}`;
+}
+
+export function normalizeOdFormat(format) {
+ const text = String(format);
+ return { format: text.endsWith("z") ? text.slice(0, -1) : text, showChars: text.endsWith("z") };
+}
+
+export function validateOdFormat(format) {
+ const text = String(format);
+ let i = 0;
+ while (i < text.length) {
+ const start = i;
+ const kind = text[i++];
+ if (!isOdFormatStart(kind)) throw new UsageError(`invalid character '${kind ?? ""}' in type string ${localeQuotedEscapedDiagnostic(format)}`);
+ if (kind === "f") {
+ if ("FDLHB".includes(text[i] ?? "")) i++;
+ else while (/\d/.test(text[i] ?? "")) i++;
+ } else if ("doux".includes(kind)) {
+ if ("CSIL".includes(text[i] ?? "")) i++;
+ else while (/\d/.test(text[i] ?? "")) i++;
+ }
+ if (text[i] === "z") i++;
+ validateOdFormatSpec(text.slice(start, i), format);
+ }
+}
+
+export function validateOdFormatSpec(spec, originalFormat = spec) {
+ const text = normalizeOdFormat(spec).format;
+ if (text === "a" || text === "c") return;
+ if ((text.startsWith("a") || text.startsWith("c")) && text.length > 1) throw new UsageError(`invalid character '${text[1]}' in type string ${localeQuotedEscapedDiagnostic(originalFormat)}`);
+ if (text === "f" || text === "fF" || text === "fD" || text === "fL" || text === "fH" || text === "fB" || /^f\d+$/.test(text)) {
+ const floatSize = text.match(/^f(\d+)$/);
+ if (floatSize && ![2, 4, 8, 16].includes(Number(floatSize[1]))) {
+ throw new UsageError(`invalid type string ${localeQuotedEscapedDiagnostic(originalFormat)};\nthis system doesn't provide a ${floatSize[1]}-byte floating point type`);
+ }
+ odFormatSize(text);
+ return;
+ }
+ const kind = text[0] ?? "";
+ if (!"doux".includes(kind)) throw new UsageError(`invalid character '${kind}' in type string ${localeQuotedEscapedDiagnostic(originalFormat)}`);
+ const suffix = text.slice(1);
+ if (suffix === "" || ["C", "S", "I", "L"].includes(suffix)) return;
+ if (/^\d+$/.test(suffix)) {
+ const size = Number(suffix);
+ if (![1, 2, 4, 8].includes(size)) throw new UsageError(`invalid type string ${localeQuotedEscapedDiagnostic(originalFormat)};\nthis system doesn't provide a ${suffix}-byte integral type`);
+ return;
+ }
+ throw new UsageError(`invalid character '${suffix[0]}' in type string ${localeQuotedEscapedDiagnostic(originalFormat)}`);
+}
+
+export function formatOdChunk(chunk, format, endian = "little", multiFormat = false, groupFormats = [format]) {
+ format = normalizeOdFormat(format).format;
+ const size = odFormatSize(format);
+ const parts = [];
+ for (let i = 0; i < chunk.length; i += size) {
+ const bytes = chunk.slice(i, i + size);
+ if (format === "c" || format === "a") {
+ parts.push(formatOdChar(bytes[0], format === "a"));
+ } else if (format.startsWith("f")) {
+ parts.push(formatOdFloat(bytes, format, endian));
+ } else {
+ const value = [...bytes].reduce((sum, byte, idx) => sum + BigInt(byte) * (1n << BigInt(8 * (endian === "big" ? bytes.length - idx - 1 : idx))), 0n);
+ if (format.startsWith("x")) {
+ const text = value.toString(16).padStart(size * 2, "0");
+ parts.push(multiFormat ? text.padStart(odMultiFormatFieldWidth(format, size, groupFormats)) : text.padStart(odFieldWidth(format, size), "0"));
+ }
+ else if (format.startsWith("u")) parts.push(value.toString().padStart(multiFormat ? odMultiFormatFieldWidth(format, size, groupFormats) : odFieldWidth(format, size)));
+ else if (format.startsWith("d")) parts.push(signExtendBigInt(value, size).toString().padStart(multiFormat ? odMultiFormatFieldWidth(format, size, groupFormats) : odFieldWidth(format, size)));
+ else {
+ const text = value.toString(8).padStart(odFieldWidth(format, size), "0");
+ parts.push(multiFormat ? text.padStart(odMultiFormatFieldWidth(format, size, groupFormats)) : text);
+ }
+ }
+ }
+ return parts.join(" ");
+}
+
+export function odFullLineBodyWidth(format, lineWidth, multiFormat = false, groupFormats = [format]) {
+ const size = odFormatSize(format);
+ const fields = Math.floor(lineWidth / size);
+ if (fields <= 0) return 0;
+ const fieldWidth = format === "a" || format === "c" ? 3 : odMultiFormatFieldWidth(format, size, groupFormats, multiFormat);
+ return fields * fieldWidth + Math.max(0, fields - 1);
+}
+
+export function formatOdFloat(bytes, format, endian = "little") {
+ const size = odFormatSize(format);
+ const buffer = new Uint8Array(size);
+ buffer.set(bytes.slice(0, size));
+ if (size === 16) return odFloat128Placeholder(buffer, endian).padStart(24);
+ const view = new DataView(buffer.buffer);
+ const littleEndian = endian !== "big";
+ const value = format === "fB"
+ ? odBfloat16Value(view.getUint16(0, littleEndian))
+ : size === 2
+ ? odFloat16Value(view.getUint16(0, littleEndian))
+ : size === 4
+ ? view.getFloat32(0, littleEndian)
+ : view.getFloat64(0, littleEndian);
+ return formatOdFloatValue(value, size, format);
+}
+
+export function odFloat16Value(bits) {
+ const sign = bits & 0x8000 ? -1 : 1;
+ const exponent = (bits >> 10) & 0x1f;
+ const fraction = bits & 0x03ff;
+ if (exponent === 0x1f) return fraction ? NaN : sign * Infinity;
+ if (exponent === 0) return sign * 2 ** -14 * (fraction / 2 ** 10);
+ return sign * 2 ** (exponent - 15) * (1 + fraction / 2 ** 10);
+}
+
+export function odBfloat16Value(bits) {
+ const buffer = new ArrayBuffer(4);
+ const view = new DataView(buffer);
+ view.setUint32(0, bits << 16, false);
+ return view.getFloat32(0, false);
+}
+
+export function formatOdFloatValue(value, size, format = "") {
+ const width = size === 2 || size === 4 ? 15 : 24;
+ if (!Number.isFinite(value)) return String(value).padStart(width);
+ const text = Number.isInteger(value)
+ ? String(value)
+ : size === 2
+ ? trimOdFloatText(value.toPrecision(8))
+ : size === 4
+ ? trimOdFloatText(value.toPrecision(format === "fB" ? 8 : 7))
+ : trimOdFloatText(value.toPrecision(16));
+ return text.padStart(width);
+}
+
+export function trimOdFloatText(text) {
+ return text.replace(/(\.\d*?[1-9])0+(e[+-]?\d+)$/iu, "$1$2").replace(/\.0+(e[+-]?\d+)$/iu, "$1").replace(/(\.\d*?[1-9])0+$/u, "$1").replace(/\.0+$/u, "");
+}
+
+export function odFloat128Placeholder(bytes, endian = "little") {
+ const ordered = endian === "big" ? [...bytes] : [...bytes].reverse();
+ const value = ordered.reduce((sum, byte) => (sum << 8n) + BigInt(byte), 0n);
+ return value.toString();
+}
+
+export function formatOdAscii(chunk) {
+ let out = ">";
+ for (const byte of chunk) out += byte >= 32 && byte < 127 ? String.fromCharCode(byte) : ".";
+ return `${out}<`;
+}
+
+export function formatOdStrings(data, minLength, start, radix, allowFinalUnterminated = false) {
+ if (!Number.isFinite(minLength) || minLength < 0) throw new UsageError(`invalid suffix in -S argument '${minLength}'`);
+ let out = "";
+ let runStart = -1;
+ for (let i = 0; i <= data.length; i++) {
+ const byte = i < data.length ? data[i] : 0;
+ const printable = i < data.length && byte >= 32 && byte < 127;
+ if (printable) {
+ if (runStart === -1) runStart = i;
+ continue;
+ }
+ if (runStart !== -1) {
+ const length = i - runStart;
+ if (((i < data.length && byte === 0) || (i === data.length && allowFinalUnterminated)) && length >= minLength) {
+ const address = formatOffset(start + runStart, radix);
+ const text = new TextDecoder().decode(data.slice(runStart, i));
+ out += `${address}${address ? " " : ""}${text}\n`;
+ }
+ runStart = -1;
+ } else if (i < data.length && byte === 0 && minLength === 0) {
+ const address = formatOffset(start + i, radix);
+ out += `${address}${address ? " " : ""}\n`;
+ }
+ }
+ return out;
+}
+
+export function odFormatSize(format) {
+ format = normalizeOdFormat(format).format;
+ if (format === "a" || format === "c") return 1;
+ if (format === "fH" || format === "fB") return 2;
+ const floatSize = String(format).match(/^f(\d+)$/);
+ if (floatSize) {
+ const size = Number(floatSize[1]);
+ if (![2, 4, 8, 16].includes(size)) throw new UsageError(`this system doesn't provide a ${size}-byte floating point type`);
+ return size;
+ }
+ if (format === "fF") return 4;
+ if (format === "fD" || format === "fL" || format === "f") return 8;
+ const match = String(format).match(/[doux](\d+|C|S|I|L)?/);
+ const value = match?.[1];
+ if (value === "C") return 1;
+ if (value === "S") return 2;
+ if (value === "I") return 4;
+ if (value === "L") return 8;
+ return Number(value ?? (format === "c" || format === "a" ? 1 : 4));
+}
+
+export function odFieldWidth(format, size, multiFormat = false) {
+ if (format.startsWith("x")) return multiFormat && size === 1 ? 3 : size * 2;
+ if (format.startsWith("o")) return Math.ceil(size * 8 / 3);
+ if (format.startsWith("u")) return ({ 1: 3, 2: 5, 4: 10, 8: 20 })[size] ?? String(2n ** BigInt(size * 8) - 1n).length;
+ if (format.startsWith("d")) return ({ 1: 4, 2: 6, 4: 11, 8: 20 })[size] ?? String(2n ** BigInt(size * 8 - 1)).length + 1;
+ return size;
+}
+
+export function odMultiFormatFieldWidth(format, size, groupFormats, multiFormat = true) {
+ if (!multiFormat) return odFieldWidth(format, size, multiFormat);
+ const normalizedGroup = groupFormats.map((groupFormat) => normalizeOdFormat(groupFormat).format);
+ const unitSize = Math.min(...normalizedGroup.map(odFormatSize));
+ const unitWidth = Math.max(...normalizedGroup
+ .filter((groupFormat) => odFormatSize(groupFormat) === unitSize)
+ .map((groupFormat) => groupFormat === "a" || groupFormat === "c" ? 3 : odFieldWidth(groupFormat, unitSize, true)));
+ const unitCount = size % unitSize === 0 ? size / unitSize : 1;
+ const alignedWidth = unitCount * unitWidth + Math.max(0, unitCount - 1);
+ return Math.max(odFieldWidth(format, size, true), alignedWidth);
+}
+
+export function formatOdChar(byte, named = false) {
+ const asciiNames = ["nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", "bs", "ht", "nl", "vt", "ff", "cr", "so", "si", "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", "can", "em", "sub", "esc", "fs", "gs", "rs", "us"];
+ if (named) {
+ const ascii = byte & 0x7f;
+ if (ascii < asciiNames.length) return asciiNames[ascii].padStart(3);
+ if (ascii === 32) return " sp";
+ if (ascii === 127) return "del";
+ return String.fromCharCode(ascii).padStart(3);
+ }
+ const escapes = { 0: "\\0", 7: "\\a", 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r" };
+ if (escapes[byte]) return escapes[byte].padStart(3);
+ if (byte >= 32 && byte < 127) return String.fromCharCode(byte).padStart(3);
+ return byte.toString(8).padStart(3, "0");
+}
+
+export function signExtendBigInt(value, size) {
+ const bits = BigInt(size * 8);
+ const sign = 1n << (bits - 1n);
+ const mod = 1n << bits;
+ return value >= sign ? value - mod : value;
+}
+
+const singleCall = defineCommand("od", odCmd, odMetaOption);
+export default singleCall;
+
+if (import.meta.main) await runAsMain(singleCall);