#pragma prototyped

static const char usage[] =

"formats on the standard output. The standard input is read if \b-\b or "

"no files are specified. Each output line contains the file offset of "

"the data in the leftmost column, followed by one or more columns in the "

"specified format. If more than one format is specified then the "

"subsequent lines are listed with the offset column blank. Second and "

"subsequent occurrences of a repeated output line are replaced by a "

"single line with `*' in the first data column.]"

"characters in the LC_CTYPE locale category. The three types differ only "

"in the C style escape sequences recognized; \b--format=C\b explicitly "

"allows future extensions. The backslash character is written as `\\' "

"and NUL is written as `\\0'. Other non-printable characters are written "

"as one three-digit octal number for each byte in the character. "

"Printable multi-byte characters are written in the area corresponding "

"to the first byte of the character; the two-character sequence `**' is "

"written in the area corresponding to each remaining byte in the "

"character; the remaining bytes for \b-p\b are written as ` '. If "

"\b--skip\b or \b--count\b position the file into the middle of a "

"multibyte character then the entire multibyte character is silently "

"treated as non-character bytes.]"

"\b--format\b) then the last file argument is interpreted as an offset "

"expression if it matches the extended regular expression "

"\b+?[0-9]]+\\.?[bkm]]?(ll|LL)?\b . In this case the first \aoffset\a "

"bytes of the file are skipped. The optional \bb\b means bytes, \bk\b "

"means Kb, and \bm\b means Mb. \bll\b and \bLL\b are ignored for "

"compatibility with some systems.]"

"{"

"[+d?decimal]"

"[+o?octal]"

"[+x?hexadecimal]"

"[+n?none - do not print offset]"

"}"

"inclusive or of:]#[op]"

"{"

"[+01?swap 8-bit bytes]"

"[+02?swap 16-bit words]"

"[+04?swap 32-bit longs]"

"[+0?swap for big endian testing]"

"}"

"formatting.]#[bytes]"

"\acodeset\a to the native codeset. The codesets are:]:[codeset]"

"{\fcodesets\f} [p:printable?Output the printable bytes (after \b--map\b "

"if specified), in the last data column. Non-printable byte values are "

"printed as `.'.]"

"bytes.]#? [length:=3]"

"count or size code may follow all but the \ba\b, \bc\b, \bC\b, \bm\b "

"and \bO\b formats.]:[format[size]]:=o2]"

"{\ftypes\f}"

"{"

"[+b\an\a?Allocate a fixed input buffer of size \an\a.]"

"[+m\an\a?Set the mapped input buffer size to \an\a.]"

"[+n?Turn off the \bSF_SHARE\b input buffer flag.]"

"}"

"\aper-line\a must be a multiple of the least common multiple of the "

"sizes of the format types.]#[per-line]"

;

#include <cmd.h>

#include <sig.h>

#include <swap.h>

#include <ccode.h>

#include <ctype.h>

#include <iconv.h>

#include <vmalloc.h>

#include <ast_float.h>

#if _hdr_wctype

#include <wchar.h>

#include <wctype.h>

#else

#define iswprint(w) isprint(w)

#endif

#define NEW (1<<0)

#define OLD (1<<1)

#define BASE_WIDTH 7

#define LINE_LENGTH 78

#define WIDTHINDEX(n) (((n)>1)+((n)>2)+((n)>4)+((n)>8))

#ifdef _ast_int8_t

#define QUAL "ll"

#else

#define QUAL "l"

#endif

#if _typ_long_double

#define double_max long double

#else

#define double_max double

#endif

struct State_s; typedef struct State_s State_t;

struct Format_s; typedef struct Format_s Format_t;

typedef void (*Format_f)(State_t*, Format_t*, Sfio_t*, unsigned char*);

typedef union Mem_u

{

char m_char[sizeof(intmax_t) + sizeof(double_max)];

float m_float;

double m_double;

#if _typ_long_double

long double m_long_double;

#endif

} Mem_t;

typedef struct Size_s

{

char* desc;

int name;

int map;

int dflt;

const char* qual;

int size;

int prefix;

int digits;

int exponent;

} Size_t;

typedef struct Type_s

{

char* desc;

char name;

char mb;

const char* fill;

Format_f fun;

const Size_t* size;

char width[5];

} Type_t;

struct Format_s

{

struct Format_s*next;

const Type_t* type;

Format_f fun;

char form[16];

struct

{

int external;

int internal;

} size;

int fp;

int width;

int us;

int per;

};

struct State_s

{

int addr;

char base[8];

int block;

struct

{

char* base;

size_t size;

int noshare;

} buffer;

size_t count;

struct

{

char buf[1024];

char* data;

int mark;

size_t size;

} dup;

unsigned char* eob;

char* file;

Format_t* form;

Format_t* last;

unsigned char* map;

int mb;

int mbmax;

int mbp;

intmax_t offset;

struct

{

char* data;

size_t size;

} peek;

int printable;

int size;

size_t skip;

char* span;

int spansize;

int strings;

int style;

int swap;

size_t total;

int verbose;

int width;

Vmalloc_t* vm;

};

static const Size_t csize[] =

{

"char", 'C', 0, 1, 0, 1,0,0,0,

0

};

static const Size_t isize[] =

{

"char", 'C', 0, 0, 0, 1,0,0,0,

"short", 'S', 0, 0, 0, sizeof(short),0,0,0,

"int", 'I', 0, 1, 0, sizeof(int),0,0,0,

"long", 'L', 0, 0, "l", sizeof(long),0,0,0,

"long long", 'D', 0, 0,

#ifdef _ast_int8_t

"ll", sizeof(int64_t),0,0,0,

#else

0, sizeof(long),0,0,0,

#endif

0

};

static const Size_t fsize[] =

{

"float", 'F', 'e', 0, 0, sizeof(float),3,FLT_DIG,FLT_MAX_10_EXP,

"double", 'D', 'e', 1, 0, sizeof(double),3,DBL_DIG,DBL_MAX_10_EXP,

"long double", 'L', 'e', 0,

#if _typ_long_double

"L", sizeof(long double),3,LDBL_DIG,LDBL_MAX_10_EXP,

#else

0, sizeof(double),3,DBL_DIG,DBL_MAX_10_EXP,

#endif

0

};

static const Size_t asize[] =

{

"float", 'F', 'a', 0, 0, sizeof(float),5,FLT_DIG,FLT_MAX_EXP,

"double", 'D', 'a', 1, 0, sizeof(double),5,DBL_DIG,DBL_MAX_EXP,

"long double", 'L', 'a', 0,

#if _typ_long_double

"L", sizeof(long double),5,LDBL_DIG,LDBL_MAX_EXP,

#else

0, sizeof(double),5,DBL_DIG,DBL_MAX_EXP,

#endif

0

};

static void

aform(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

register int c = *u;

static const char anames[] =

"nulsohstxetxeotenqackbel bs ht nl vt ff cr so si"

"dledc1dc2dc3dc4naksynetbcan emsubesc fs gs rs us"

" sp ! \" # $ % & ' ( ) * + , - . /"

" 0 1 2 3 4 5 6 7 8 9 : ; < = > ?"

" @ A B C D E F G H I J K L M N O"

" P Q R S T U V W X Y Z [ \\ ] ^ _"

" ` a b c d e f g h i j k l m n o"

" p q r s t u v w x y z { | } ~del";

c = 3 * (c & 0177);

sfputc(op, anames[c]);

sfputc(op, anames[c+1]);

sfputc(op, anames[c+2]);

}

static void

bform(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, "%08..2u", *u);

}

static void

cform(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

unsigned char* v;

char* s;

wchar_t w;

int i;

int j;

char buf[2];

if (state->mb)

{

state->mb--;

sfputc(op, ' ');

sfputc(op, '*');

sfputc(op, '*');

return;

}

switch (*u)

{

case 0:

sfputc(op, ' ');

sfputc(op, '\\');

sfputc(op, '0');

return;

case '\\':

sfputc(op, ' ');

sfputc(op, ' ');

sfputc(op, '\\');

return;

}

buf[0] = *(v = u);

if ((w = mbnchar(u, state->eob - u)) > 0 && (i = u - v) > 1 && !iswprint(w))

{

state->mb = i - 1;

for (j = 3 - mbwidth(w); j > 0; j--)

sfputc(op, ' ');

while (i--)

sfputc(op, *v++);

return;

}

buf[1] = 0;

s = fmtesc(buf);

/*

if (*s != '\\')

{

sfputc(op, ' ');

sfputc(op, ' ');

sfputc(op, *s);

return;

}

switch (*(s + 1))

{

case 'a':

case 'b':

case 'f':

case 'n':

case 'r':

case 't':

case 'v':

sfputc(op, ' ');

sfputc(op, '\\');

sfputc(op, *(s + 1));

return;

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

sfputc(op, *++s);

sfputc(op, *++s);

sfputc(op, *++s);

return;

}

sfprintf(op, "%03o", *v);

}

static void

Cform(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

unsigned char* v;

char* s;

wchar_t w;

int i;

int j;

char buf[2];

if (state->mb)

{

state->mb--;

sfputc(op, ' ');

sfputc(op, '*');

sfputc(op, '*');

return;

}

switch (*u)

{

case 0:

sfputc(op, ' ');

sfputc(op, '\\');

sfputc(op, '0');

return;

case '\\':

sfputc(op, ' ');

sfputc(op, ' ');

sfputc(op, '\\');

return;

}

buf[0] = *(v = u);

if ((w = mbnchar(u, state->eob - u)) > 0 && (i = u - v) > 1 && !iswprint(w))

{

state->mb = i - 1;

for (j = 3 - mbwidth(w); j > 0; j--)

sfputc(op, ' ');

while (i--)

sfputc(op, *v++);

return;

}

buf[1] = 0;

s = fmtesc(buf);

if (*s != '\\')

{

sfputc(op, ' ');

sfputc(op, ' ');

sfputc(op, *s);

return;

}

if (isdigit(*(s + 1)))

{

sfputc(op, *++s);

sfputc(op, *++s);

sfputc(op, *++s);

return;

}

sfputc(op, ' ');

sfputc(op, '\\');

sfputc(op, *(s + 1));

}

static void

mform(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

register char* s;

char buf[2];

switch (buf[0] = ccmapchr(state->map, *u))

{

case 0:

sfputc(op, '0');

sfputc(op, '0');

return;

case '\\':

sfputc(op, ' ');

sfputc(op, '\\');

return;

}

buf[1] = 0;

s = fmtesc(buf);

if (*s != '\\')

{

sfputc(op, ' ');

sfputc(op, *s);

return;

}

if (isdigit(*(s + 1)))

sfprintf(op, "%02lx", strtol(s + 1, NiL, 8));

else

{

sfputc(op, '\\');

sfputc(op, *(s + 1));

}

}

static void

Oform(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

unsigned char* v;

char* s;

wchar_t w;

int i;

int j;

char buf[2];

if (state->mb)

{

state->mb--;

sfputc(op, ' ');

sfputc(op, '*');

sfputc(op, '*');

return;

}

switch (*u)

{

case 0:

sfputc(op, ' ');

sfputc(op, '\\');

sfputc(op, '0');

return;

case '\\':

sfputc(op, ' ');

sfputc(op, ' ');

sfputc(op, '\\');

return;

}

buf[0] = *(v = u);

if ((w = mbnchar(u, state->eob - u)) > 0 && (i = u - v) > 1 && !iswprint(w))

{

state->mb = i - 1;

for (j = 3 - mbwidth(w); j > 0; j--)

sfputc(op, ' ');

while (i--)

sfputc(op, *v++);

return;

}

buf[1] = 0;

s = fmtesc(buf);

/*

if (*s != '\\')

{

sfputc(op, ' ');

sfputc(op, ' ');

sfputc(op, *s);

return;

}

switch (*(s + 1))

{

case 'b':

case 'f':

case 'n':

case 'r':

case 't':

sfputc(op, ' ');

sfputc(op, '\\');

sfputc(op, *(s + 1));

return;

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

sfputc(op, *++s);

sfputc(op, *++s);

sfputc(op, *++s);

return;

}

sfprintf(op, "%03o", *v);

}

static const Type_t type[] =

{

{

"ISO/IEC 646:1991 named characters",

'a', 0, 0, aform, csize, 3, 0, 0, 0, 0

},

{

"hexadecimal floating point",

'A', 0, 0, 0, asize, 0, 0, 0, 0, 0

},

{

"binary character",

'b', 0, 0, bform, csize, 8, 0, 0, 0, 0

},

{

"locale character or backslash escape (\\a \\b \\f \\n \\r \\t \\v)",

'c', 0, 0, cform, csize, 3, 0, 0, 0, 0

},

{

"locale character or backslash escape (current and future escapes)",

'C', 0, 0, Cform, csize, 3, 0, 0, 0, 0

},

{

"signed decimal",

'd', 0, 0, 0, isize, 4, 6, 11, 21, 31

},

{

"floating point",

'f', 0, 0, 0, fsize, 0, 0, 0, 0, 0

},

{

"\b--map\b mapped character or hexadecimal value if not printable",

'm', 0, 0, mform, csize, 2, 0, 0, 0, 0

},

{

"octal",

'o', 0, "0", 0, isize, 3, 6, 11, 22, 33

},

{

"locale character or backslash escape (\\b \\f \\n \\r \\t)",

'O', 0, 0, Oform, csize, 3, 0, 0, 0, 0

},

{

"unsigned decimal",

'u', 0, 0, 0, isize, 3, 5, 10, 20, 30

},

{

"hexadecimal",

'x', 0, "0", 0, isize, 2, 4, 8, 16, 32

},

{

"printable bytes",

'z', 0, 0, 0, 0, 1, 0, 0, 0, 0

},

};

static void

form_int8(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, fp->form, *u);

}

static void

form_int16(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, fp->form, (int16_t)swapget(state->swap, u, fp->size.external));

}

static void

form_int32(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, fp->form, (int32_t)swapget(state->swap, u, fp->size.external));

}

static void

form_intmax(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, fp->form, (intmax_t)swapget(state->swap, u, fp->size.external));

}

static void

form_uint8(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, fp->form, *u);

}

static void

form_uint16(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, fp->form, (uint16_t)swapget(state->swap, u, fp->size.external));

}

static void

form_uint32(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, fp->form, (uint32_t)swapget(state->swap, u, fp->size.external));

}

static void

form_uintmax(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

sfprintf(op, fp->form, (uintmax_t)swapget(state->swap, u, fp->size.external));

}

static void

form_float(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

Mem_t mem;

swapmem(state->swap ^ int_swap, u, mem.m_char, fp->size.internal);

sfprintf(op, fp->form, mem.m_float);

}

static void

form_double(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

Mem_t mem;

swapmem(state->swap ^ int_swap, u, mem.m_char, fp->size.internal);

sfprintf(op, fp->form, mem.m_double);

}

#if _typ_long_double

static void

form_long_double(State_t* state, Format_t* fp, Sfio_t* op, unsigned char* u)

{

Mem_t mem;

swapmem(state->swap ^ int_swap, u, mem.m_char, fp->size.internal);

sfprintf(op, fp->form, mem.m_long_double);

}

#endif

static void

format(State_t* state, register char* t)

{

register int c;

register const Type_t* tp;

register const Size_t* zp;

register Format_t* fp;

const Size_t* xp;

uintmax_t m;

int prec;

int base;

int n;

int i;

char* e;

char* s;

char dig[256];

while (c = *t++)

{

if (isspace(c) || c == ',')

continue;

tp = type;

while (c != tp->name)

if (++tp >= &type[elementsof(type)])

{

error(2, "%c: invalid type name", c);

return;

}

if (!(zp = tp->size) && !tp->fun)

{

switch (tp->width[0])

{

case 1:

state->printable = 1;

break;

}

continue;

}

xp = 0;

if (isdigit(*t))

{

c = 0;

n = (int)strton(t, &e, NiL, 1);

t = e;

}

else

{

c = isupper(*t) ? *t++ : 0;

n = 0;

}

for (;;)

{

if (!zp->name)

{

if (c)

{

error(2, "%c: invalid size for type %c", c, tp->name);

return;

}

if (!(zp = xp) || zp->exponent)

{

error(2, "%d: invalid size for type %c", n, tp->name);

return;

}

break;

}

if (n)

{

if (n == zp->size)

break;

zp++;

if (n > (zp-1)->size && n < zp->size)

xp = zp;

}

else if (c == zp->name)

{

if (c != *t)

break;

t++;

zp++;

if (zp->name)

break;

}

else if (!c && !n && zp->dflt)

break;

else

zp++;

}

if (tp->mb && (i = mbmax()) > 1)

state->mbmax = i;

i = zp - tp->size;

if (!(fp = vmnewof(state->vm, 0, Format_t, 1, 0)))

{

error(ERROR_system(1), "out of space");

return;

}

if (state->last)

state->last = state->last->next = fp;

else

state->form = state->last = fp;

fp->type = tp;

fp->us = tp->name != 'd';

fp->size.internal = zp->size;

fp->size.external = n ? n : zp->size;

if (state->size < fp->size.external)

state->size = fp->size.external;

if (zp->exponent)

{

if (zp->map == 'a')

{

for (m = 0, i = zp->digits; i-- > 0; m = m * 10 + 9);

prec = sfsprintf(dig, sizeof(dig), "%I*x", sizeof(m), m);

}

else

prec = zp->digits;

base = sfsprintf(dig, sizeof(dig), "%u", zp->exponent);

fp->width = zp->prefix + prec + base + 2;

}

else

{

fp->width = tp->width[i = WIDTHINDEX(fp->size.internal)];

if (n > 1 && (n & (n - 1)))

{

c = (1 << i) - n;

n = (1 << i) - (1 << (i - 1));

fp->width -= ((fp->width - tp->width[i - 1] + n - 1) / n) * c;

}

prec = 0;

base = 0;

}

if (!(fp->fun = tp->fun))

{

e = fp->form;

*e++ = '%';

if (s = (char*)tp->fill)

while (*e = *s++)

e++;

e += sfsprintf(e, sizeof(fp->form) - (e - fp->form), "%d", fp->width);

if (prec)

e += sfsprintf(e, sizeof(fp->form) - (e - fp->form), ".%d", prec);

if (base)

e += sfsprintf(e, sizeof(fp->form) - (e - fp->form), "%s.%d", prec ? "" : ".", base);

if (s = (char*)zp->qual)

while (*e = *s++)

e++;

*e = zp->map ? zp->map : tp->name;

if (zp->exponent)

{

#if _typ_long_double

if (fp->size.internal == sizeof(long double))

fp->fun = form_long_double;

else

#endif

if (fp->size.internal == sizeof(double))

fp->fun = form_double;

else

fp->fun = form_float;

}

else if (fp->us)

switch (fp->size.internal)

{

case 1:

fp->fun = form_uint8;

break;

case 2:

fp->fun = form_uint16;

break;

case 4:

fp->fun = form_uint32;

break;

default:

fp->fun = form_uintmax;

break;

}

else

switch (fp->size.internal)

{

case 1:

fp->fun = form_int8;

break;

case 2:

fp->fun = form_int16;

break;

case 4:

fp->fun = form_int32;

break;

default:

fp->fun = form_intmax;

break;

}

}

}

}

static Sfio_t*

init(State_t* state, char*** p)

{

Sfio_t* ip;

intmax_t offset;

for (;;)

{

if (**p)

state->file = *((*p)++);

else if (state->file)

return 0;

if (!state->file || streq(state->file, "-"))

{

state->file = "/dev/stdin";

ip = sfstdin;

}

else if (!(ip = sfopen(NiL, state->file, "r")))

{

error(ERROR_system(0), "%s: cannot open", state->file);

error_info.errors = 1;

continue;

}

if (state->buffer.noshare)

sfset(ip, SF_SHARE, 0);

if (state->buffer.size)

sfsetbuf(ip, state->buffer.base, state->buffer.size);

if (state->skip)

{

if ((offset = sfseek(ip, (off_t)0, SEEK_END)) > 0)

{

if (offset <= state->skip)

{

state->skip -= offset;

state->offset += offset;

goto next;

}

if (sfseek(ip, state->skip, SEEK_SET) != state->skip)

{

error(ERROR_system(2), "%s: seek error", state->file);

goto next;

}

state->offset += state->skip;

state->skip = 0;

}

else

{

for (;;)

{

if (!(state->peek.data = sfreserve(ip, SF_UNBOUND, 0)))

{

if (sfvalue(ip))

error(ERROR_system(2), "%s: read error", state->file);

goto next;

}

state->peek.size = sfvalue(ip);

if (state->peek.size < state->skip)

state->skip -= state->peek.size;

else

{

state->peek.data += state->skip;

state->peek.size -= state->skip;

state->skip = 0;

break;

}

}

}

}

break;

next:

if (ip != sfstdin)

sfclose(ip);

}

return ip;

}

static int

block(State_t* state, Sfio_t* op, char* bp, char* ep, intmax_t base)

{

register Format_t* fp;

register unsigned char* u;

register ssize_t z;

unsigned long n;

if (!state->verbose)

{

if (state->dup.size == (n = ep - bp) && !memcmp(state->dup.data, bp, n))

{

if (!state->dup.mark)

{

state->dup.mark = 1;

sfprintf(op, "*\n");

}

return 0;

}

state->dup.mark = 0;

}

for (fp = state->form; fp; fp = fp->next)

{

if (*state->base)

{

if (fp == state->form)

sfprintf(op, state->base, base);

else

sfprintf(op, "%-*.*s ", BASE_WIDTH, BASE_WIDTH, "");

}

u = (unsigned char*)bp;

for (;;)

{

z = fp->per - fp->width;

while (z-- > 0)

sfputc(op, ' ');

(*fp->fun)(state, fp, op, u);

if ((u += fp->size.external) < (unsigned char*)ep)

sfputc(op, ' ');

else

{

if (state->printable && fp == state->form)

{

register int c;

unsigned char* v;

wchar_t w;

if (c = (state->block - (ep - bp)) / state->size * (state->width + 1))

sfprintf(op, "%*s", c, "");

sfputc(op, ' ');

if (state->mbmax)

for (u = (unsigned char*)bp; u < (unsigned char*)ep; u++)

{

if (state->mbp)

{

state->mbp--;

sfputc(op, '.');

}

else if ((v = u) && (w = mbnchar(v, state->eob - u)) > 0 && (c = v - u) > 1 && !iswprint(w))

{

sfwrite(op, u, c);

state->mbp = c - 1;

}

else

{

if ((c = ccmapchr(state->map, *u)) < 040 || c >= 0177)

c = '.';

sfputc(op, c);

}

}

else

for (u = (unsigned char*)bp; u < (unsigned char*)ep;)

{

if ((c = ccmapchr(state->map, *u++)) < 040 || c >= 0177)

c = '.';

sfputc(op, c);

}

}

sfputc(op, '\n');

break;

}

}

if (sferror(op))

return -1;

}

return 0;

}

static int

od(State_t* state, char** files)

{

register char* s;

register char* e;

register char* x;

register char* span = 0;

register int c;

Sfio_t* ip;

size_t n;

size_t m;

ssize_t r;

if (!(ip = init(state, &files)))

return 0;

for (;;)

{

if (s = state->peek.data)

{

state->peek.data = 0;

n = state->peek.size;

}

else

for (;;)

{

s = sfreserve(ip, SF_UNBOUND, 0);

n = sfvalue(ip);

if (s)

break;

if (n)

error(ERROR_system(2), "%s: read error", state->file);

if (ip != sfstdin)

sfclose(ip);

if (!(ip = init(state, &files)))

{

s = 0;

n = 0;

break;

}

}

state->eob = (unsigned char*)s + n;

if (state->count)

{

if (state->total >= state->count)

{

s = 0;

n = 0;

}

else if ((state->total += n) > state->count)

n -= state->total - state->count;

}

if (span)

{

respan:

if (s)

{

m = state->spansize - (span - state->span);

if (m > n)

{

memcpy(span, s, n);

span += n;

continue;

}

memcpy(span, s, m);

span += m;

s += m;

n -= m;

}

if (m = (span - state->span) % state->size)

{

m = state->size - m;

while (m--)

*span++ = 0;

}

state->eob = (unsigned char*)span;

if ((m = span - state->span) > state->block)

m = state->block;

if (block(state, sfstdout, state->span, state->span + m, state->offset))

goto bad;

state->offset += m;

if (!state->verbose)

memcpy(state->dup.data = state->dup.buf, state->span, state->dup.size = m);

if ((r = (span - state->span) - m) > 0)

{

span = state->span;

x = state->span + m;

while (r--)

*span++ = *x++;

goto respan;

}

span = 0;

if (s && !n)

continue;

}

if (!s)

break;

x = s + n;

if (state->strings)

{

state->offset += n;

n = 0;

for (;;)

{

if (s >= x || (c = *s++) == 0 || c == '\n' || !isprint(c))

{

if (n >= state->strings)

{

if (*state->base && sfprintf(sfstdout, state->base, state->offset - (x - s) - n - 1) < 0)

break;

if (sfprintf(sfstdout, "%.*s\n", n, s - n - 1) < 0)

break;

}

if (s >= x)

break;

n = 0;

}

else

n++;

}

}

else

{

e = s + (n / state->block) * state->block;

if (state->mbmax)

e -= state->block + state->mbmax;

if (s < e)

{

do

{

if (block(state, sfstdout, s, s + state->block, state->offset))

goto bad;

state->offset += state->block;

state->dup.data = s;

state->dup.size = state->block;

} while ((s += state->block) < e);

if (!state->verbose)

{

memcpy(state->dup.buf, state->dup.data, state->dup.size = state->block);

state->dup.data = state->dup.buf;

}

}

if (n = x - s)

{

memcpy(state->span, s, n);

span = state->span + n;

}

}

}

return 0;

bad:

if (ip != sfstdin)

sfclose(ip);

return -1;

}

static int

optsize(Sfio_t* sp, const Size_t* zp)

{

register int n;

for (n = 0; zp->name; zp++)

if (zp->qual && (*zp->qual != zp->name || *(zp->qual + 1)))

n += sfprintf(sp, "[%c|%s?sizeof(%s)]", zp->name, zp->qual, zp->desc);

else

n += sfprintf(sp, "[%c?sizeof(%s)]", zp->name, zp->desc);

return n;

}

static int

optinfo(Opt_t* op, Sfio_t* sp, const char* s, Optdisc_t* dp)

{

register iconv_list_t* ic;

register int i;

register int n;

n = 0;

switch (*s)

{

case 'c':

for (ic = iconv_list(NiL); ic; ic = iconv_list(ic))

if (ic->ccode >= 0)

n += sfprintf(sp, "[%c:%s?%s]", ic->match[ic->match[0] == '('], ic->name, ic->desc);

break;

case 't':

for (i = 0; i < elementsof(type); i++)

n += sfprintf(sp, "[%c?%s]", type[i].name, type[i].desc);

n += sfprintf(sp, "[+----- sizes -----?]");

n += optsize(sp, isize);

n += optsize(sp, fsize);

break;

}

return n;

}

b_od(int argc, char** argv, Shbltin_t* context)

{

register int n;

register char* s;

register Format_t* fp;

char* e;

int per;

char buf[4];

Optdisc_t optdisc;

State_t state;

cmdinit(argc, argv, context, ERROR_CATALOG, 0);

memset(&state, 0, sizeof(state));

if (!(state.vm = vmopen(Vmdcheap, Vmlast, 0)))

{

error(ERROR_SYSTEM|2, "out of space");

return 1;

}

optinit(&optdisc, optinfo);

per = 0;

state.map = ccmap(CC_ASCII, CC_ASCII);

state.swap = int_swap;

for (;;)

{

switch (optget(argv, usage))

{

case 'A':

*state.base = *opt_info.arg;

state.style |= NEW;

continue;

case 'B':

if (opt_info.num <= 0)

state.swap = -opt_info.num;

else

state.swap ^= opt_info.num;

continue;

case 'j':

if (*opt_info.option == '+')

{

opt_info.index--;

break;

}

state.skip = opt_info.num;

state.style |= NEW;

continue;

case 'm':

if ((n = ccmapid(opt_info.arg)) < 0)

error(2, "%s: unknown character code set", opt_info.arg);

else

state.map = ccmap(n, CC_NATIVE);

continue;

case 'N':

state.count = opt_info.num;

state.style |= NEW;

continue;

case 'p':

state.printable = 1;

continue;

case 't':

format(&state, opt_info.arg);

state.style |= NEW;

continue;

case 'T':

s = opt_info.arg;

switch (*s)

{

case 'b':

case 'm':

n = *s++;

state.buffer.size = strton(s, &e, NiL, 1);

if (n == 'b' && !(state.buffer.base = vmnewof(state.vm, 0, char, state.buffer.size, 0)))

{

error(ERROR_SYSTEM|2, "out of space");

goto done;

}

if (*e)

error(2, "%s: invalid characters after test", e);

break;

case 'n':

state.buffer.noshare = 1;

break;

default:

error(2, "%s: unknown test", s);

break;

}

continue;

case 'v':

state.verbose = 1;

state.style |= NEW;

continue;

case 'w':

per = opt_info.num;

continue;

case 'z':

state.strings = opt_info.num;

continue;

case 'a':

case 'b':

case 'c':

case 'C':

case 'd':

case 'D':

case 'f':

case 'F':

case 'h':

case 'i':

case 'l':

case 'o':

case 'O':

case 's':

case 'S':

case 'u':

case 'U':

case 'x':

case 'X':

s = buf;

switch (n = opt_info.option[1])

{

case 'b':

*s++ = 'o';

*s++ = 'C';

break;

case 'c':

case 'C':

*s++ = 'O';

break;

case 'D':

n = 'U';

break;

case 'd':

n = 'u';

break;

case 'h':

n = 'x';

break;

case 'i':

case 's':

n = 'd';

break;

case 'l':

case 'S':

n = 'D';

break;

}

if (s == buf)

{

if (isupper(n))

switch (*s++ = tolower(n))

{

case 'f':

*s++ = 'D';

break;

default:

*s++ = 'L';

break;

}

else

switch (*s++ = n)

{

case 'd':

case 'o':

case 's':

case 'u':

case 'x':

/* pronounce that! */

*s++ = 'S';

break;

case 'f':

*s++ = 'F';

break;

}

}

*s = 0;

format(&state, buf);

state.style |= OLD;

continue;

case ':':

error(2, "%s", opt_info.arg);

continue;

case '?':

error(ERROR_usage(2), "%s", opt_info.arg);

continue;

}

break;

}

argv += opt_info.index;

if (error_info.errors)

error(ERROR_usage(2), "%s", optusage(NiL));

switch (n = *state.base)

{

case 'n':

*state.base = 0;

break;

case 0:

n = 'o';

/*FALLTHROUGH*/

case 'o':

state.addr = 8;

goto base;

case 'd':

state.addr = 10;

goto base;

case 'x':

state.addr = 16;

/*FALLTHROUGH*/

base:

sfsprintf(state.base, sizeof(state.base), "%%0%d%s%c ", BASE_WIDTH, QUAL, n);

break;

default:

error(2, "%c: invalid addr-base type", n);

break;

}

if (!state.form)

format(&state, "oS");

else if (state.strings)

error(2, "--strings must be the only format type");

if (error_info.errors)

goto done;

for (fp = state.form; fp; fp = fp->next)

if ((n = (state.size / fp->size.external) * (fp->width + 1) - 1) > state.width)

state.width = n;

for (fp = state.form; fp; fp = fp->next)

fp->per = state.width * fp->size.external / state.size;

n = LINE_LENGTH - state.printable;

if (*state.base)

n -= (BASE_WIDTH + 1);

if (!(n /= (state.width + state.printable * state.size + 1)))

n = 1;

if (state.addr)

{

while (n > state.addr)

state.addr *= 2;

while (n < state.addr)

state.addr /= 2;

if (state.addr)

n = state.addr;

}

if (per)

n = per;

state.block = n * state.size;

state.spansize = state.block + state.mbmax;

if (!(state.span = vmnewof(state.vm, 0, char, state.spansize, 0)))

{

error(ERROR_SYSTEM|2, "out of space");

goto done;

}

if (!(state.style & NEW) && (s = *argv))

{

e = "?(+)+([0-9])?(.)?([bkm])?(ll|LL)";

if (!*(argv + 1))

{

if (strmatch(s, e) && *s == '+')

argv++;

else s = 0;

}

else if (!*(argv + 2))

{

s = *(argv + 1);

if (strmatch(s, e) && (state.style == OLD || *s == '+'))

*(argv + 1) = 0;

else s = 0;

}

else s = 0;

if (s)

{

state.skip = strtol(s, &e, strchr(s, '.') ? 10 : 8);

if (*e == '.')

e++;

switch (*e)

{

case 'b':

state.skip *= 512;

break;

case 'k':

state.skip *= 1024;

break;

case 'm':

state.skip *= 1024 * 1024;

break;

}

}

}

#ifdef SIGFPE

signal(SIGFPE, SIG_IGN);

#endif

od(&state, argv);

#ifdef SIGFPE

signal(SIGFPE, SIG_DFL);

#endif

if (state.skip)

{

error(2, "cannot skip past available data");

goto done;

}

if (*state.base && !state.strings)

{

*(state.base + strlen(state.base) - 1) = '\n';

sfprintf(sfstdout, state.base, (intmax_t)state.offset);

}

if (sfsync(sfstdout) && !ERROR_PIPE(errno))

error(ERROR_SYSTEM|2, "write error");

done:

vmclose(state.vm);

return error_info.errors != 0;

}