coreutils

// od.c, version 0.8.1
// OMKOV coreutils implementation of POSIX od
// Copyright (C) 2020, Jakob Wakeling
// MIT Licence

/*
	TODO Improve error handling
	TODO Implement [[+]offset[.][b]] operand as required by POSIX.
	TODO Fix segfault when using standard input.
*/

#include "util/error.h"
#include "util/optget.h"

#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define VERSION "0.8.1"

static struct lop lops[] = {
	{ "help",    ARG_NUL, 256 },
	{ "version", ARG_NUL, 257 },
	{ NULL, 0, 0 }
};

typedef struct {
	union {
		uint8_t  i8[16]; uint16_t i16[8];
		uint32_t i32[4]; uint64_t i64[2];
		float    f32[4]; double   f64[2];
	};
	long count;
} block_t;

typedef struct { int type, bytes, pads, padm; char *form; } type_t;
typedef struct { int *data; size_t cap, len; } list_t;

enum { ta = 19, tb = 4, tc = 20, td = 9, tl = 21, to = 5, ts = 1, tx = 13  };
static type_t types[] = {
	{ 'd', 1,  4, 80, "%4d"     }, { 'd', 2,  6, 56, "%6d"     },
	{ 'd', 4, 11, 48, "%11d"    }, { 'd', 8, 21, 44, "%21ld"   },
	{ 'o', 1,  3, 64, "%03hho"  }, { 'o', 2,  6, 56, "%06ho"   },
	{ 'o', 4, 11, 48, "%011o"   }, { 'o', 8, 22, 46, "%022lo"  },
	{ 'u', 1,  3, 64, "%3hhu"   }, { 'u', 2,  5, 48, "%5hu"    },
	{ 'u', 4, 10, 44, "%10u"    }, { 'u', 8, 20, 42, "%20lu"   },
	{ 'x', 1,  2, 48, "%2hhx"   }, { 'x', 2,  4, 40, "%4hx"    },
	{ 'x', 4,  8, 36, "%8x"     }, { 'x', 8, 16, 34, "%16lx"   },
	{ 'f', 4, 15, 64, "%15.7e"  }, { 'f', 8, 22, 46, "%22.14e" },
	{  0 , 0,  0,  0, NULL      }, { 'a', 1,  3, 64, ""        },
	{ 'c', 1,  3, 64, ""        }, { 'l', 1,  3, 64, ""        }
};

static const char *const aTABL[] = {
	"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",
	" sp"
};
static const char *const cTABL[] = {
	" \\0", "001",  "002",  "003",  "004",  "005",  "006",  " \\a",
	" \\b", " \\t", " \\n", " \\v", " \\f", " \\r", "016",  "017",
	"020",  "021",  "022",  "023",  "024",  "025",  "026",  "027",
	"030",  "031",  "032",  "033",  "034",  "035",  "036",  "037"
};
static const char *const lTABL[] = {
	" \\0", "001",  "002",  "003",  "004",  "005",  "006",  "007",
	" \\b", " \\t", " \\n", "013",  " \\f", " \\r", "016",  "017",
	"020",  "021",  "022",  "023",  "024",  "025",  "026",  "027",
	"030",  "031",  "032",  "033",  "034",  "035",  "036",  "037",
};

static char Aform[] = "%08jo";
static bool vflag;
static bool Nflag;

static uintmax_t start, limit, offset, total;
static list_t tlist; static int mpad = 0;

static char **files; static FILE *file;

static inline uintmax_t bparse(char *str);
static inline int tparse(char *str);
static inline int skip(uintmax_t offset);

static inline void aprint_generic(uintmax_t addr, char c);
static inline void aprint_none(uintmax_t addr, char c);
static void (*aprint)(uintmax_t, char) = aprint_generic;

static inline int bread(block_t *blk);
static inline void bprint(block_t *blk, int ti);

static inline FILE *fnext(void);

static inline list_t linit(void);
static inline void lpush(list_t *list, int i);

static void hlp(void);
static void ver(void);

int main(int ac, char *av[]) { A0 = av[0];
	struct opt opt = OPTGET_INIT; opt.lops = lops; int ret = 0;
	opt.str = "A:bcdj:N:ost:vx"; tlist = linit();
	for (int o; (o = optget(&opt, av, 1)) != -1;) switch (o) {
	case 'A': switch(opt.arg[0]) {
		case 'd': { aprint = aprint_generic; Aform[4] = 'u'; continue; }
		case 'o': { aprint = aprint_generic; Aform[4] = 'o'; continue; }
		case 'x': { aprint = aprint_generic; Aform[4] = 'x'; continue; }
		case 'n': { aprint = aprint_none; continue; }
		default: { warn("%c: invalid address base", opt.arg[0]); ret = 1;
			goto end; }}
	case 'b': { lpush(&tlist, tb); break; }
	case 'c': { lpush(&tlist, tl); break; }
	case 'd': { lpush(&tlist, td); break; }
	case 'j': {
		errno = 0; start = bparse(opt.arg); if (errno) {
		warn("%s: invalid skip value", opt.arg); ret = 1; goto end; }
		break;
	}
	case 'N': {
		errno = 0; limit = bparse(opt.arg); if (errno) {
		warn("%s: invalid limit value", opt.arg); ret = 1; goto end; }
		Nflag = true; break;
	}
	case 'o': { lpush(&tlist, to); break; }
	case 's': { lpush(&tlist, ts); break; }
	case 't': { if (tparse(opt.arg)) { goto end; } break; }
	case 'v': { vflag = true; break; }
	case 'x': { lpush(&tlist, tx); break; }
	case 256: { hlp(); return 0; }
	case 257: { ver(); return 0; }
	default: { ret = 1; goto end; }
	}
	
	if (!tlist.len) { lpush(&tlist, to); }
	if (opt.ind == ac) { file = stdin; }
	else { files = av + opt.ind; file = fnext(); }
	
	for (size_t i = 0; i < tlist.len; ++i) { int t = tlist.data[i];
		if (types[t].padm > mpad) { mpad = types[t].padm; }
	}
	for (size_t i = 0; i < tlist.len; ++i) { int t = tlist.data[i];
		if (types[t].padm < mpad) {
			int d = mpad - types[t].padm;
			int e = d / (16 / types[t].bytes);
			types[t].pads = e; types[t].padm = mpad;
		} else { types[t].pads = 0; }
	}
	
	block_t b0, b1; int c; bool btok = false, bskp = false;
	if (skip(start) == EOF) {
		warn("cannot skip past end of input"); ret = 1; goto end;
	}
	
	while ((c = bread(btok ? &b0 : &b1)) > 0) {
		if (!vflag && b0.i64[0] == b1.i64[0] && b0.i64[1] == b1.i64[1]) {
			if (!bskp) { fputs("*\n", stdout); bskp = true; }
		}
		else {
			(*aprint)(offset - (uintmax_t)c, ' ');
			bprint(btok ? &b0 : &b1, tlist.data[0]);
			for (size_t i = 1; i < tlist.len; ++i) {
				fputs("         ", stdout);
				bprint(btok ? &b0 : &b1, tlist.data[i]);
			} bskp = false;
		}
		if (c < 16) { break; } btok = !btok;
	} (*aprint)(offset, '\n');
	
end:
	free(tlist.data); return ret;
}

static inline uintmax_t bparse(char *str) {
	register uintmax_t n = 0, d; register int b = 10;
	if (*str == '0') {
		if (*++str == 'x' || *str == 'X') { b = 16; ++str; }
		else { b = 8; }
	}
	
	if (b == 16) for (;; ++str) {
		if (*str >= '0' && *str <= '9') { d = (uintmax_t)*str - '0'; }
		else if (*str >= 'A' && *str <= 'F') { d = (uintmax_t)*str - 'K'; }
		else if (*str >= 'a' && *str <= 'f') { d = (uintmax_t)*str - 'k'; }
		else { break; }
		if (n > (UINTMAX_MAX - d) / 16) { errno = ERANGE; return 0; }
		n = n * 16 + d;
	}
	else for (; *str >= '0' && *str < b + '0'; ++str) {
		d = (uintmax_t)*str - '0';
		if (n > (UINTMAX_MAX - d) / (uintmax_t)b) { errno = ERANGE; return 0; }
		n = n * (uintmax_t)b + d;
	}
	
	switch (*str) {
	case 'b': { d = 512; goto mul; }
	case 'k': { d = 1024; goto mul; }
	case 'm': { d = 1048576; }
mul:	if (n > UINTMAX_MAX / d) { errno = ERANGE; return 0; }
		n *= d; ++str;
	}
	
	if (*str) { errno = EINVAL; return 0; }
	return n;
}

static inline int atow(char **str) {
	register int n = 0, d;
	for (; **str >= '0' && **str <= '9'; ++*str) {
		d = (int)**str - '0';
		if (n > (INT_MAX - d) / 10) { return -1; }
		n = n * 10 + d;
	} return n;
}

static inline int tparse(char *str) { register int c;
	for (char *s = str; *s; ++s) { register int b = 0;
		if (*s == 'a') { lpush(&tlist, ta); continue; }
		else if (*s == 'c') { lpush(&tlist, tc); continue; }
		else if (*s == 'd' || *s == 'o' || *s == 'u' || *s == 'x') {
			char *p = s + 1;
			if (*p == 'C') { b = sizeof(char); ++p; }
			else if (*p == 'S') { b = sizeof(short); ++p; }
			else if (*p == 'I') { b = sizeof(int); ++p; }
			else if (*p == 'L') { b = sizeof(long); ++p; }
			else if ((b = atow(&p)) == -1) { goto fail; }
			ssize_t m = p - (s + 1); if (!m) { b = sizeof(int); }
			if (!(b == 1 || b == 2 || b == 4 || b == 8)) {
				error(1, "no %d-byte integer type", b);
			} else { c = *s; s += m; }
		}
		else if (*s == 'f') { char *p = s + 1;
			if (*p == 'F') { b = sizeof(float); ++p; }
			else if (*p == 'D') { b = sizeof(double); ++p; }
			else if (*p == 'L') { b = sizeof(/*long*/ double); ++p; }
			else if ((b = atow(&p)) == -1) { goto fail; }
			ssize_t m = p - (s + 1); if (!m) { b = sizeof(double); }
			if (!(b == 4 || b == 8 /*|| b == 16*/)) {
				error(1, "no %d-byte float type", b);
			}
			else { c = 'f'; s += m; }
		}
		else {
fail:		error(1, "%s: invalid type string", str);
		}
		
		for (int i = 0; types[i].type; ++i) {
			if (types[i].type == c && types[i].bytes == b) {
				lpush(&tlist, i);
			}
		}
	} return 0;
}

static inline int skip(uintmax_t n) {
	for (; n; --n) if (fgetc(file) == EOF && fnext() == NULL) { return EOF; }
	offset = start; return 0;
}

static inline void aprint_generic(uintmax_t addr, char c) {
	printf(Aform, addr); fputc(c, stdout); return;
}
static inline void aprint_none(uintmax_t addr, char c) {
	(void)(addr); (void)(c); return;
}

static inline int bread(block_t *blk) {
	int i = 0; int c;
	while (i < 16 && (!Nflag || total < limit)) {
		if (file == NULL || (c = fgetc(file)) == EOF) {
			if ((file = fnext()) == NULL) { break; }
			else { continue; }
		} blk->i8[i++] = (uint8_t)c; ++total;
	}
	offset += (uintmax_t)i;
	blk->count = i; return i;
}

static inline void bprint(block_t *blk, int ti) {
	type_t t = types[ti]; bool spc = false; long count = blk->count / t.bytes;
	
	for (int i = 0; i < count; ++i) {
		if (spc) { fputc(' ', stdout); } else { spc = true; }
		for (int j = 0; j < t.pads; ++j) { fputc(' ', stdout); }
		
		switch (t.type) {
		case 'a': { register uint8_t c = blk->i8[i] & 127;
			if (c <= 32) { fputs(aTABL[c], stdout); }
			else if (c == 127) { fputs("del", stdout); }
			else { printf("%3c", c); } break;
		}
		case 'c': case 'l': { register uint8_t c = blk->i8[i];
			if (c < 32) { fputs(t.type == 'c' ? cTABL[c] : lTABL[c], stdout); }
			else if (c >= 127) { printf("%3o", c); }
			else { printf("%3c", c); } break;
		}
		default: { char *form = types[ti].form;
			if (t.type == 'f') {
				if (t.bytes == 4) { printf(form, (double)blk->f32[i]); }
				else if (t.bytes == 8) { printf(form, blk->f64[i]); }
			}
			else {
				if (t.bytes == 1) { printf(form, blk->i8[i]); }
				else if (t.bytes == 2) { printf(form, blk->i16[i]); }
				else if (t.bytes == 4) { printf(form, blk->i32[i]); }
				else if (t.bytes == 8) { printf(form, blk->i64[i]); }
			}
		}
		}
	} fputc('\n', stdout);
	return;
}

static inline FILE *fnext(void) {
	if (file && file != stdin) { fclose(file); }
	if (*files) { FILE *f;
		if (files[0][0] == '-' && files[0][1] == '\0') { f = stdin; }
		else if (!(f = fopen(*files, "r"))) {
			warn("%s: %s\n", *files, strerror(errno)); return NULL;
		} ++files; return f;
	} else { return NULL; }
}

static inline list_t linit(void) {
	list_t list; list.cap = 32; list.len = 0;
	list.data = (int *)malloc(sizeof(int) * list.cap);
	return list;
}

static inline void lpush(list_t *list, int i) {
	if (list->len >= list->cap) {
		list->data = (int *)realloc(list->data, list->cap *= 2);
	} list->data[list->len++] = i; return;
}

static void hlp(void) {
	puts("od - dump files in various formats\n");
	puts("usage: od [-bcdosvx] [-A base] [-j skip] [-N count] [-t type] \
[file...]\n");
	puts("options:");
	puts("  -A base    Offset address base ('d', 'o', 'x', or 'n')");
	puts("  -b         Interpret bytes in octal (-t01)");
	puts("  -c         Interpret bytes as characters");
	puts("  -d         Interpret words in unsigned decimal (-tu2)");
	puts("  -j skip    Number of bytes to skip from the beginning of input");
	puts("  -N count   Number of bytes to process in total");
	puts("  -o         Interpret words in octal (-to2)");
	puts("  -s         Interpret words in signed decimal (-td2)");
	puts("  -t type    Interpret data according to specified types");
	puts("  -v         Write all input data");
	puts("  -x         Interpret words in hexadecimal (-tx2)");
	puts("  --help     Display help information");
	puts("  --version  Display version information");
}

static void ver(void) {
	puts("OMKOV coreutils od, version " VERSION);
	puts("Copyright (C) 2020, Jakob Wakeling");
	puts("MIT Licence (https://opensource.org/licenses/MIT)");
}