sbase

od.c (6365B)

---

 /* See LICENSE file for copyright and license details. */
 #include <ctype.h>
 #include <fcntl.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "queue.h"
 #include "util.h"
 
 struct type {
 	unsigned char     format;
 	unsigned int      len;
 	TAILQ_ENTRY(type) entry;
 };
 
 static TAILQ_HEAD(head, type) head = TAILQ_HEAD_INITIALIZER(head);
 static unsigned char addr_format = 'o';
 static off_t skip = 0;
 static off_t max = -1;
 static size_t linelen = 1;
 static int big_endian;
 
 static void
 printaddress(off_t addr)
 {
 	char fmt[] = "%07j#";
 
 	if (addr_format == 'n') {
 		fputc(' ', stdout);
 	} else {
 		fmt[4] = addr_format;
 		printf(fmt, (intmax_t)addr);
 	}
 }
 
 static void
 printchunk(const unsigned char *s, unsigned char format, size_t len)
 {
 	long long res, basefac;
 	size_t i;
 	char fmt[] = " %#*ll#";
 	unsigned char c;
 
 	const char *namedict[] = {
 		"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",
 	};
 	const char *escdict[] = {
 		['\0'] = "\\0", ['\a'] = "\\a",
 		['\b'] = "\\b", ['\t'] = "\\t",
 		['\n'] = "\\n", ['\v'] = "\\v",
 		['\f'] = "\\f", ['\r'] = "\\r",
 	};
 
 	switch (format) {
 	case 'a':
 		c = *s & ~128; /* clear high bit as required by standard */
 		if (c < LEN(namedict) || c == 127) {
 			printf(" %3s", (c == 127) ? "del" : namedict[c]);
 		} else {
 			printf(" %3c", c);
 		}
 		break;
 	case 'c':
 		if (strchr("\a\b\t\n\v\f\r\0", *s)) {
 			printf(" %3s", escdict[*s]);
 		} else if (!isprint(*s)) {
 			printf(" %3o", *s);
 		} else {
 			printf(" %3c", *s);
 		}
 		break;
 	default:
 		if (big_endian) {
 			for (res = 0, basefac = 1, i = len; i; i--) {
 				res += s[i - 1] * basefac;
 				basefac <<= 8;
 			}
 		} else {
 			for (res = 0, basefac = 1, i = 0; i < len; i++) {
 				res += s[i] * basefac;
 				basefac <<= 8;
 			}
 		}
 		fmt[2] = big_endian ? '-' : ' ';
 		fmt[6] = format;
 		printf(fmt, (int)(3 * len + len - 1), res);
 	}
 }
 
 static void
 printline(const unsigned char *line, size_t len, off_t addr)
 {
 	struct type *t = NULL;
 	size_t i;
 	int first = 1;
 	unsigned char *tmp;
 
 	if (TAILQ_EMPTY(&head))
 		goto once;
 	TAILQ_FOREACH(t, &head, entry) {
 once:
 		if (first) {
 			printaddress(addr);
 			first = 0;
 		} else {
 			printf("%*c", (addr_format == 'n') ? 1 : 7, ' ');
 		}
 		for (i = 0; i < len; i += MIN(len - i, t ? t->len : 4)) {
 			if (len - i < (t ? t->len : 4)) {
 				tmp = ecalloc(t ? t->len : 4, 1);
 				memcpy(tmp, line + i, len - i);
 				printchunk(tmp, t ? t->format : 'o',
 				           t ? t->len : 4);
 				free(tmp);
 			} else {
 				printchunk(line + i, t ? t->format : 'o',
 				           t ? t->len : 4);
 			}
 		}
 		fputc('\n', stdout);
 		if (TAILQ_EMPTY(&head) || (!len && !first))
 			break;
 	}
 }
 
 static int
 od(int fd, char *fname, int last)
 {
 	static unsigned char *line;
 	static size_t lineoff;
 	static off_t addr;
 	unsigned char buf[BUFSIZ];
 	size_t i, size = sizeof(buf);
 	ssize_t n;
 
 	while (skip - addr > 0) {
 		n = read(fd, buf, MIN(skip - addr, sizeof(buf)));
 		if (n < 0)
 			weprintf("read %s:", fname);
 		if (n <= 0)
 			return n;
 		addr += n;
 	}
 	if (!line)
 		line = emalloc(linelen);
 
 	for (;;) {
 		if (max >= 0)
 			size = MIN(max - (addr - skip), size);
 		if ((n = read(fd, buf, size)) <= 0)
 			break;
 		for (i = 0; i < n; i++, addr++) {
 			line[lineoff++] = buf[i];
 			if (lineoff == linelen) {
 				printline(line, lineoff, addr - lineoff + 1);
 				lineoff = 0;
 			}
 		}
 	}
 	if (n < 0) {
 		weprintf("read %s:", fname);
 		return n;
 	}
 	if (lineoff && last)
 		printline(line, lineoff, addr - lineoff);
 	if (last)
 		printline((unsigned char *)"", 0, addr);
 	return 0;
 }
 
 static int
 lcm(unsigned int a, unsigned int b)
 {
 	unsigned int c, d, e;
 
 	for (c = a, d = b; c ;) {
 		e = c;
 		c = d % c;
 		d = e;
 	}
 
 	return a / d * b;
 }
 
 static void
 addtype(char format, int len)
 {
 	struct type *t;
 
 	t = emalloc(sizeof(*t));
 	t->format = format;
 	t->len = len;
 	TAILQ_INSERT_TAIL(&head, t, entry);
 }
 
 static void
 usage(void)
 {
 	eprintf("usage: %s [-bdosvx] [-A addressformat] [-E | -e] [-j skip] "
 	        "[-t outputformat] [file ...]\n", argv0);
 }
 
 int
 main(int argc, char *argv[])
 {
 	int fd;
 	struct type *t;
 	int ret = 0, len;
 	char *s;
 
 	big_endian = (*(uint16_t *)"\0\xff" == 0xff);
 
 	ARGBEGIN {
 	case 'A':
 		s = EARGF(usage());
 		if (strlen(s) != 1 || !strchr("doxn", s[0]))
 			usage();
 		addr_format = s[0];
 		break;
 	case 'b':
 		addtype('o', 1);
 		break;
 	case 'd':
 		addtype('u', 2);
 		break;
 	case 'E':
 	case 'e':
 		big_endian = (ARGC() == 'E');
 		break;
 	case 'j':
 		if ((skip = parseoffset(EARGF(usage()))) < 0)
 			usage();
 		break;
 	case 'N':
 		if ((max = parseoffset(EARGF(usage()))) < 0)
 			usage();
 		break;
 	case 'o':
 		addtype('o', 2);
 		break;
 	case 's':
 		addtype('d', 2);
 		break;
 	case 't':
 		s = EARGF(usage());
 		for (; *s; s++) {
 			switch (*s) {
 			case 'a':
 			case 'c':
 				addtype(*s, 1);
 				break;
 			case 'd':
 			case 'o':
 			case 'u':
 			case 'x':
 				/* todo: allow multiple digits */
 				if (*(s+1) > '0' && *(s+1) <= '9') {
 					len = *(s+1) - '0';
 				} else {
 					switch (*(s+1)) {
 					case 'C':
 						len = sizeof(char);
 						break;
 					case 'S':
 						len = sizeof(short);
 						break;
 					case 'I':
 						len = sizeof(int);
 						break;
 					case 'L':
 						len = sizeof(long);
 						break;
 					default:
 						len = sizeof(int);
 					}
 				}
 				addtype(*s++, len);
 				break;
 			default:
 				usage();
 			}
 		}
 		break;
 	case 'v':
 		/* always set - use uniq(1) to handle duplicate lines */
 		break;
 	case 'x':
 		addtype('x', 2);
 		break;
 	default:
 		usage();
 	} ARGEND
 
 	/* line length is lcm of type lengths and >= 16 by doubling */
 	TAILQ_FOREACH(t, &head, entry)
 		linelen = lcm(linelen, t->len);
 	if (TAILQ_EMPTY(&head))
 		linelen = 16;
 	while (linelen < 16)
 		linelen *= 2;
 
 	if (!argc) {
 		if (od(0, "<stdin>", 1) < 0)
 			ret = 1;
 	} else {
 		for (; *argv; argc--, argv++) {
 			if (!strcmp(*argv, "-")) {
 				*argv = "<stdin>";
 				fd = 0;
 			} else if ((fd = open(*argv, O_RDONLY)) < 0) {
 				weprintf("open %s:", *argv);
 				ret = 1;
 				continue;
 			}
 			if (od(fd, *argv, (!*(argv + 1))) < 0)
 				ret = 1;
 			if (fd != 0)
 				close(fd);
 		}
 	}
 
 	ret |= fshut(stdout, "<stdout>") | fshut(stderr, "<stderr>");
 
 	return ret;
 }