From 6f5241afb5bd1d6a1a8724bf06cc6f205c279402 Mon Sep 17 00:00:00 2001 From: Soccera1 <129828376+Soccera1@users.noreply.github.com> Date: Sat, 18 Jul 2026 09:27:17 +1000 Subject: Refactor to single call --- src/commands/od.js | 717 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 717 insertions(+) create mode 100644 src/commands/od.js (limited to 'src/commands/od.js') 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); -- cgit v1.3