@@@ so much mess

[mLib] / test / tvec-types.c

/* -*-c-*-
 *
 * Types for the test-vector framework
 *
 * (c) 2023 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * mLib is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with mLib.  If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */

/*----- Header files ------------------------------------------------------*/

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

#include "buf.h"
#include "codec.h"
#  include "base32.h"
#  include "base64.h"
#  include "hex.h"
#include "dstr.h"
#include "tvec.h"

/*----- Preliminary utilities ---------------------------------------------*/

#ifdef isnan
#  define NANP(x) isnan(x)
#else
#  define NANP(x) (!((x) == (x)))
#endif

#ifdef isinf
#  define INFP(x) isinf(x)
#else
#  define INFP(x) ((x) > DBL_MAX || (x) < DBL_MIN)
#endif

static int signed_to_buf(buf *b, long i)
{
  kludge64 k;
  unsigned long u;

  u = i;
  if (i >= 0) ASSIGN64(k, u);
  else { ASSIGN64(k, ~u); CPL64(k, k); }
  return (buf_putk64l(b, k));
}

static int signed_from_buf(buf *b, long *i_out)
{
  kludge64 k, lmax, not_lmin;

  ASSIGN64(lmax, LONG_MAX); ASSIGN64(not_lmin, ~(unsigned long)LONG_MIN);
  if (buf_getk64l(b, &k)) return (-1);
  if (CMP64(k, <=, lmax)) *i_out = (long)GET64(unsigned long, k);
  else {
    CPL64(k, k);
    if (CMP64(k, <=, not_lmin)) *i_out = -(long)GET64(unsigned long, k) - 1;
    else return (-1);
  }
  return (0);
}

static int unsigned_to_buf(buf *b, unsigned long u)
  { kludge64 k; ASSIGN64(k, u); return (buf_putk64l(b, k)); }

static int unsigned_from_buf(buf *b, unsigned long *u_out)
{
  kludge64 k, ulmax;

  ASSIGN64(ulmax, ULONG_MAX);
  if (buf_getk64l(b, &k)) return (-1);
  if (CMP64(k, >, ulmax)) return (-1);
  *u_out = GET64(unsigned long, k); return (0);
}

static int hex_width(unsigned long u)
{
  int wd;
  unsigned long t;

  for (t = u >> 4, wd = 4; t >>= wd, wd *= 2, t; );
  return (wd/4);
}

static int check_signed_range(long i,
			      const struct tvec_irange *ir,
			      struct tvec_state *tv)
{
  if (ir && (ir->min > i || i > ir->max)) {
    tvec_error(tv, "integer %ld out of range (must be in [%ld .. %ld])",
	       i, ir->min, ir->max);
    return (-1);
  }
  return (0);
}

static int check_unsigned_range(unsigned long u,
				const struct tvec_urange *ur,
				struct tvec_state *tv)
{
  if (ur && (ur->min > u || u > ur->max)) {
    tvec_error(tv, "integer %lu out of range (must be in [%lu .. %lu])",
	       u, ur->min, ur->max);
    return (-1);
  }
  return (0);
}

static int parse_signed(long *i_out, const char *p,
			const struct tvec_irange *ir,
			struct tvec_state *tv)
{
  char *q; const char *pp;
  int olderr;
  long i;

  olderr = errno; errno = 0;
  pp = p; if (*pp == '-' || *pp == '+') pp++;
  if (!ISDIGIT(*pp))
    return (tvec_syntax(tv, *pp ? *pp : fgetc(tv->fp), "signed integer"));
  i = strtol(p, &q, 0);
  if (*q && !ISSPACE(*q)) return (tvec_syntax(tv, *q, "end-of-line"));
  if (errno)
    return (tvec_error(tv, "invalid integer `%s': %s", p, strerror(errno)));
  if (check_signed_range(i, ir, tv)) return (-1);
  errno = olderr; *i_out = i;
  return (0);
}

static int parse_unsigned(unsigned long *u_out, const char *p,
			  const struct tvec_urange *ur,
			  struct tvec_state *tv)
{
  char *q;
  int olderr;
  unsigned long u;

  olderr = errno; errno = 0;
  if (!ISDIGIT(*p)) return (tvec_syntax(tv, *p, "unsigned integer"));
  u = strtoul(p, &q, 0);
  if (*q && !ISSPACE(*q)) return (tvec_syntax(tv, *q, "end-of-line"));
  if (errno)
    return (tvec_error(tv, "invalid integer `%s': %s", p, strerror(errno)));
  if (check_unsigned_range(u, ur, tv)) return (-1);
  errno = olderr; *u_out = u;
  return (0);
}

static void format_floating(const struct gprintf_ops *gops, void *go,
			    double x)
{
  int prec;

  if (NANP(x))
    gprintf(gops, go, "#nan");
  else if (INFP(x))
    gprintf(gops, go, x > 0 ? "#+inf" : "#-inf");
  else {
    /* Ugh.  C doesn't provide any function for just printing a
     * floating-point number /correctly/, i.e., so that you can read the
     * result back and recover the number you first thought of.  There are
     * complicated algorithms published for doing this, but I really don't
     * want to get into that here.  So we have this.
     *
     * The sign doesn't cause significant difficulty so we're going to ignore
     * it for now.  So suppose we're given a number %$x = f b^e$%, in
     * base-%$b$% format, so %$f b^n$% and %$e$% are integers, with
     * %$0 \le f < 1$%.  We're going to convert it into the nearest integer
     * of the form %$X = F B^E$%, with similar conditions, only with the
     * additional requirement that %$X$% is normalized, i.e., that %$X = 0$%
     * or %$F \ge B^{-N}$%.
     *
     * We're rounding to the nearest such %$X$%.  If there is to be ambiguity
     * in the conversion, then some %$x = f b^e$% and the next smallest
     * representable number %$x' = x + b^{e-n}$% must both map to the same
     * %$X$%, which means both %$x$% and %$x'$% must be nearer to %$X$% than
     * any other number representable in the target system.  The nest larger
     * number is %$X' = X + B^{E-N}$%; the next smaller number will normally
     * be %$W = X - B^{E-N}$%, but if %$F = 1/B$ then the next smaller number
     * is actually %$X - B^{E-N-1}$%.  We ignore this latter possibility in
     * the pursuit of a conservative estimate (though actually it doesn't
     * matter).
     *
     * If both %$x$% and %$x'$% map to %$X$% then we must have
     * %$L = X - B^{E-N}/2 \le x$% and %$x + b^{e-n} \le R = X + B^{E-N}/2$%;
     * so firstly %$f b^e = x \ge L = W + B^{E-N}/2 > W = (F - B^{-N}) B^E$%,
     * and secondly %$b^{e-n} \le B^{E-N}$%.  Since these inequalities are in
     * opposite senses, we can divide, giving
     *
     *	       %$f b^e/b^{e-n} > (F - B^{-N}) B^E/B^{E-N}$% ,
     *
     * whence
     *
     *	       %$f b^n > (F - B^{-N}) B^N = F B^N - 1$% .
     *
     * Now %$f \le 1 - b^{-n}$%, and %$F \ge B^{-1}$%, so, for this to be
     * possible, it must be the case that
     *
     *	       %$(1 - b^{-n}) b^n = b^n - 1 > B^{N-1} - 1$% .
     *
     * Then rearrange and take logarithms, obtaining
     *
     *	       %$(N - 1) \log B < n \log b$% ,
     *
     * and so
     *
     *	       %$N < n \log b/\log B + 1$% .
     *
     * Recall that this is a necessary condition for a collision to occur; we
     * are therefore safe whenever
     *
     *	       %$N \ge n \log b/\log B + 1$% ;
     *
     * so, taking ceilings,
     *
     *	       %$N \ge \lceil n \log b/\log B \rceil + 1$% .
     *
     * So that's why we have this.
     *
     * I'm going to assume that @n = DBL_MANT_DIG@ is sufficiently small that
     * we can calculate this without ending up on the wrong side of an
     * integer boundary.
     *
     * In C11, we have @DBL_DECIMAL_DIG@, which should be the same value only
     * as a constant.  Except that modern compilers are more than clever
     * enough to work out that this is a constant anyway.
     *
     * This is sometimes an overestimate: we'll print out meaningless digits
     * that don't represent anything we actually know about the number in
     * question.  To fix that, we'd need a complicated algorithm like Steele
     * and White's Dragon4, Gay's @dtoa@, or Burger and Dybvig's algorithm
     * (note that Loitsch's Grisu2 is conservative, and Grisu3 hands off to
     * something else in difficult situations).
     */

    prec = ceil(DBL_MANT_DIG*log(FLT_RADIX)/log(10)) + 1;
    gprintf(gops, go, "%.*g", prec, x);
  }
}

static int eqish_floating_p(double x, double y,
			    const struct tvec_floatinfo *fi)
{
  double xx, yy, t;

  if (NANP(x)) return (NANP(y)); else if (NANP(y)) return (0);
  if (INFP(x)) return (x == y); else if (INFP(y)) return (0);

  switch (fi ? fi->f&TVFF_EQMASK : TVFF_EXACT) {
    case TVFF_EXACT:
      return (x == y);
    case TVFF_ABSDELTA:
      t = x - y; if (t < 0) t = -t; return (t < fi->delta);
    case TVFF_RELDELTA:
      xx = x >= 0 ? x : -x; yy = y >= 0 ? y : -y;
      if (xx < yy) { t = x; x = y; y = t; }
      return (1.0 - y/x < fi->delta);
    default:
      abort();
  }
}

static int parse_floating(double *x_out, const char *p,
			  const struct tvec_floatinfo *fi,
			  struct tvec_state *tv)
{
  const char *pp; char *q;
  dstr d = DSTR_INIT;
  double x;
  int olderr, rc;

  if (STRCMP(p, ==, "#nan")) {
#ifdef NAN
    x = NAN; rc = 0;
#else
    tvec_error(tv, "NaN not supported on this system");
    rc = -1; goto end;
#endif
  } else if (STRCMP(p, ==, "#inf") ||
	     STRCMP(p, ==, "#+inf") ||
	     STRCMP(p, ==, "+#inf")) {
#ifdef NAN
    x = INFINITY; rc = 0;
#else
    tvec_error(tv, "infinity not supported on this system");
    rc = -1; goto end;
#endif
  } else if (STRCMP(p, ==, "#-inf") ||
	     STRCMP(p, ==, "-#inf")) {
#ifdef NAN
    x = -INFINITY; rc = 0;
#else
    tvec_error(tv, "infinity not supported on this system");
    rc = -1; goto end;
#endif
  } else {
    pp = p;
    if (*pp == '+' || *pp == '-') pp++;
    if (*pp == '.') pp++;
    if (!ISDIGIT(*pp)) {
      tvec_syntax(tv, *pp ? *pp : fgetc(tv->fp), "floating-point number");
      rc = -1; goto end;
    }
    olderr = errno; errno = 0;
    x = strtod(p, &q);
    if (*q) {
      tvec_syntax(tv, *q, "end-of-line");
      rc = -1; goto end;
    }
    if (errno && (errno != ERANGE || (x > 0 ? -x : x) == HUGE_VAL)) {
      tvec_error(tv, "invalid floating-point number `%s': %s",
		 p, strerror(errno));
      rc = -1; goto end;
    }
    errno = olderr;
  }

  if (NANP(x) && fi && !(fi->f&TVFF_NANOK)) {
    tvec_error(tv, "#nan not allowed here");
    rc = -1; goto end;
  }
  if (fi && ((!(fi->f&TVFF_NOMIN) && x < fi->min) ||
	     (!(fi->f&TVFF_NOMAX) && x > fi->max))) {
    dstr_puts(&d, "floating-point number ");
    format_floating(&dstr_printops, &d, x);
    dstr_puts(&d, " out of range (must be in ");
    if (fi->f&TVFF_NOMIN)
      dstr_puts(&d, "(#-inf");
    else
      { dstr_putc(&d, '['); format_floating(&dstr_printops, &d, fi->min); }
    dstr_puts(&d, " .. ");
    if (fi->f&TVFF_NOMAX)
      dstr_puts(&d, "#+inf)");
    else
      { format_floating(&dstr_printops, &d, fi->max); dstr_putc(&d, ']'); }
    dstr_putc(&d, ')'); dstr_putz(&d);
    tvec_error(tv, "%s", d.buf); rc = -1; goto end;
  }

  *x_out = x; rc = 0;
end:
  dstr_destroy(&d);
  return (rc);
}

static int convert_hex(char ch, int *v_out)
{
  if ('0' <= ch && ch <= '9') { *v_out = ch - '0'; return (0); }
  else if ('a' <= ch && ch <= 'f') { *v_out = ch - 'a' + 10; return (0); }
  else if ('A' <= ch && ch <= 'F') { *v_out = ch - 'A' + 10; return (0); }
  else return (-1);
}

static int read_escape(int *ch_out, struct tvec_state *tv)
{
  int ch, i, esc;
  unsigned f = 0;
#define f_brace 1u

  ch = getc(tv->fp);
  switch (ch) {
    case EOF: case '\n': tvec_syntax(tv, ch, "string escape");
    case '\'': *ch_out = '\''; break;
    case '\\': *ch_out = '\\'; break;
    case '"': *ch_out = '"'; break;
    case 'a': *ch_out = '\a'; break;
    case 'b': *ch_out = '\b'; break;
    case 'e': *ch_out = '\x1b'; break;
    case 'f': *ch_out = '\f'; break;
    case 'n': *ch_out = '\n'; break;
    case 'r': *ch_out = '\r'; break;
    case 't': *ch_out = '\t'; break;
    case 'v': *ch_out = '\v'; break;

    case 'x':
      ch = getc(tv->fp);
      if (ch == '{') { f |= f_brace; ch = getc(tv->fp); }
      else f &= ~f_brace;
      if (convert_hex(ch, &esc))
	return (tvec_syntax(tv, ch, "hex digit"));
      for (;;) {
	ch = getc(tv->fp); if (convert_hex(ch, &i)) break;
	esc = 8*esc + i;
	if (esc > UCHAR_MAX)
	  return (tvec_error(tv,
			     "character code %d out of range", esc));
      }
      if (!(f&f_brace)) ungetc(ch, tv->fp);
      else if (ch != '}') return (tvec_syntax(tv, ch, "`}'"));
      *ch_out = esc;
      break;

    default:
      if ('0' <= ch && ch < '8') {
	i = 1; esc = ch - '0';
	for (;;) {
	  ch = getc(tv->fp);
	  if ('0' > ch || ch >= '8') { ungetc(ch, tv->fp); break; }
	  esc = 8*esc + ch - '0';
	  i++; if (i >= 3) break;
	}
	if (esc > UCHAR_MAX)
	  return (tvec_error(tv,
			     "character code %d out of range", esc));
	*ch_out = esc;
      } else
	return (tvec_syntax(tv, ch, "string escape"));
  }

  return (0);

#undef f_brace
}

static int read_quoted_string(dstr *d, int quote, struct tvec_state *tv)
{
  int ch;

  for (;;) {
    ch = getc(tv->fp);
    switch (ch) {
      case EOF: case '\n':
	return (tvec_syntax(tv, ch, "`%c'", quote));
      case '\\':
	if (quote == '\'') goto ordinary;
	ch = getc(tv->fp); if (ch == '\n') { tv->lno++; break; }
	ungetc(ch, tv->fp); if (read_escape(&ch, tv)) return (-1);
	goto ordinary;
      default:
	if (ch == quote) goto end;
      ordinary:
	DPUTC(d, ch);
	break;
    }
  }

end:
  DPUTZ(d);
  return (0);
}

#define FCF_BRACE 1u
static void format_charesc(int ch, unsigned f,
			   const struct gprintf_ops *gops, void *go)
{
  switch (ch) {
    case '\a': gprintf(gops, go, "\\a"); break;
    case '\b': gprintf(gops, go, "\\b"); break;
    case '\x1b': gprintf(gops, go, "\\e"); break;
    case '\f': gprintf(gops, go, "\\f"); break;
    case '\r': gprintf(gops, go, "\\r"); break;
    case '\n': gprintf(gops, go, "\\n"); break;
    case '\t': gprintf(gops, go, "\\t"); break;
    case '\v': gprintf(gops, go, "\\v"); break;
    case '\'': gprintf(gops, go, "\\'"); break;
    case '"': gprintf(gops, go, "\\\""); break;
    default:
      if (f&FCF_BRACE)
	gprintf(gops, go, "\\x{%0*x}", hex_width(UCHAR_MAX), ch);
      else
	gprintf(gops, go, "\\x%0*x", hex_width(UCHAR_MAX), ch);
      break;
  }
}

static void format_char(int ch, const struct gprintf_ops *gops, void *go)
{
  if (ch == EOF)
    gprintf(gops, go, "#eof");
  else if (isprint(ch) && ch != '\'')
    gprintf(gops, go, "'%c'", ch);
  else {
    gprintf(gops, go, "'");
    format_charesc(ch, 0, gops, go);
    gprintf(gops, go, "'");
  }
}

enum { TVCODE_BARE, TVCODE_HEX, TVCODE_BASE64, TVCODE_BASE32 };

static int collect_bare(dstr *d, struct tvec_state *tv)
{
  size_t pos = d->len;
  enum { WORD, SPACE, ESCAPE }; unsigned s = WORD;
  int ch, rc;

  for (;;) {
    ch = getc(tv->fp);
    switch (ch) {
      case EOF:
	tvec_syntax(tv, ch, "bareword");
	rc = -1; goto end;
      case '\n':
	if (s == ESCAPE) { tv->lno++; goto addch; }
	if (s == WORD) pos = d->len;
	ungetc(ch, tv->fp); if (tvec_nexttoken(tv)) { rc = -1; goto end; }
	DPUTC(d, ' '); s = SPACE;
	break;
      case '"': case '\'': case '!':
	if (s == SPACE) { ungetc(ch, tv->fp); goto done; }
	goto addch;
      case '\\':
	s = ESCAPE;
	break;
      default:
	if (s != ESCAPE && isspace(ch)) {
	  if (s == WORD) pos = d->len;
	  DPUTC(d, ch); s = SPACE;
	  break;
	}
      addch:
	DPUTC(d, ch); s = WORD;
    }
  }

done:
  if (s == SPACE) d->len = pos;
  DPUTZ(d); rc = 0;
end:
  return (rc);
}

static void set_up_encoding(const codec_class **ccl_out, unsigned *f_out,
			    unsigned code)
{
  switch (code) {
    case TVCODE_BARE:
      *ccl_out = 0; *f_out = 0;
      break;
    case TVCODE_HEX:
      *ccl_out = &hex_class; *f_out = CDCF_IGNCASE;
      break;
    case TVCODE_BASE32:
      *ccl_out = &base32_class; *f_out = CDCF_IGNCASE | CDCF_IGNEQPAD;
      break;
    case TVCODE_BASE64:
      *ccl_out = &base64_class; *f_out = CDCF_IGNEQPAD;
      break;
    default:
      abort();
  }
}

static int read_compound_string(void **p_inout, size_t *sz_inout,
				unsigned code, struct tvec_state *tv)
{
  const codec_class *ccl; unsigned f;
  codec *cdc;
  dstr d = DSTR_INIT, w = DSTR_INIT;
  char *p;
  int ch, err, rc;

  set_up_encoding(&ccl, &f, code);
  if (tvec_nexttoken(tv)) tvec_syntax(tv, fgetc(tv->fp), "string");
  do {
    ch = getc(tv->fp);
    if (ch == '"' || ch == '\'')
      { if (read_quoted_string(&d, ch, tv)) { rc = -1; goto end; } }
    else if (ch == '!') {
      ungetc(ch, tv->fp);
      DRESET(&w); tvec_readword(tv, &w, ";", "`!'-keyword");
      if (STRCMP(w.buf, ==, "!bare")) code = TVCODE_BARE;
      else if (STRCMP(w.buf, ==, "!hex")) code = TVCODE_HEX;
      else if (STRCMP(w.buf, ==, "!base32")) code = TVCODE_BASE32;
      else if (STRCMP(w.buf, ==, "!base64")) code = TVCODE_BASE64;
      else {
	tvec_error(tv, "unknown string keyword `%s'", w.buf);
	rc = -1; goto end;
      }
      set_up_encoding(&ccl, &f, code);
    } else if (ccl) {
      ungetc(ch, tv->fp);
      DRESET(&w);
      if (tvec_readword(tv, &w, ";", "%s-encoded fragment", ccl->name))
	{ rc = -1; goto end; }
      cdc = ccl->decoder(f);
      err = cdc->ops->code(cdc, w.buf, w.len, &d);
      if (!err) err = cdc->ops->code(cdc, 0, 0, &d);
      if (err) {
	tvec_error(tv, "invalid %s fragment `%s': %s",
		   ccl->name, w.buf, codec_strerror(err));
	rc = -1; goto end;
      }
      cdc->ops->destroy(cdc);
    } else switch (code) {
      case TVCODE_BARE:
	ungetc(ch, tv->fp);
	if (collect_bare(&d, tv)) goto done;
	break;
      default:
	abort();
    }
  } while (!tvec_nexttoken(tv));

done:
  if (*sz_inout <= d.len)
    { xfree(*p_inout); *p_inout = xmalloc(d.len + 1); }
  p = *p_inout; memcpy(p, d.buf, d.len); p[d.len] = 0; *sz_inout = d.len;
  rc = 0;
end:
  dstr_destroy(&d); dstr_destroy(&w);
  return (rc);
}

/*----- Skeleton ----------------------------------------------------------*/
/*
static void init_...(union tvec_regval *rv, const struct tvec_regdef *rd)
static void release_...(union tvec_regval *rv, const struct tvec_regdef *rd)
static int eq_...(const union tvec_regval *rv0, const union tvec_regval *rv1,
		  const struct tvec_regdef *rd)
static int tobuf_...(buf *b, const union tvec_regval *rv,
		     const struct tvec_regdef *rd)
static int frombuf_...(buf *b, union tvec_regval *rv,
		       const struct tvec_regdef *rd)
static int parse_...(union tvec_regval *rv, const struct tvec_regdef *rd,
		     struct tvec_state *tv)
static void dump_...(const union tvec_regval *rv,
		     const struct tvec_regdef *rd,
		     struct tvec_state *tv, unsigned style)

const struct tvec_regty tvty_... = {
  init_..., release_..., eq_...,
  tobuf_..., frombuf_...,
  parse_..., dump_...
};
*/
/*----- Signed and unsigned integer types ---------------------------------*/

static void init_int(union tvec_regval *rv, const struct tvec_regdef *rd)
  { rv->i = 0; }

static void init_uint(union tvec_regval *rv, const struct tvec_regdef *rd)
  { rv->u = 0; }

static void release_int(union tvec_regval *rv, const struct tvec_regdef *rd)
  { ; }

static int eq_int(const union tvec_regval *rv0, const union tvec_regval *rv1,
		  const struct tvec_regdef *rd)
  { return (rv0->i == rv1->i); }

static int eq_uint(const union tvec_regval *rv0,
		   const union tvec_regval *rv1,
		   const struct tvec_regdef *rd)
  { return (rv0->u == rv1->u); }

static int tobuf_int(buf *b, const union tvec_regval *rv,
		     const struct tvec_regdef *rd)
  { return (signed_to_buf(b, rv->i)); }

static int tobuf_uint(buf *b, const union tvec_regval *rv,
		       const struct tvec_regdef *rd)
  { return (unsigned_to_buf(b, rv->u)); }

static int frombuf_int(buf *b, union tvec_regval *rv,
		       const struct tvec_regdef *rd)
  { return (signed_from_buf(b, &rv->i)); }

static int frombuf_uint(buf *b, union tvec_regval *rv,
			const struct tvec_regdef *rd)
  { return (unsigned_from_buf(b, &rv->u)); }

static int parse_int(union tvec_regval *rv, const struct tvec_regdef *rd,
		     struct tvec_state *tv)
{
  dstr d = DSTR_INIT;
  int rc;

  if (tvec_readword(tv, &d, ";", "signed integer"))
    { rc = -1; goto end; }
  if (parse_signed(&rv->i, d.buf, rd->arg.p, tv))
    { rc = -1; goto end; }
  if (tvec_flushtoeol(tv, 0))
    { rc = -1; goto end; }
  rc = 0;
end:
  dstr_destroy(&d);
  return (rc);
}

static int parse_uint(union tvec_regval *rv, const struct tvec_regdef *rd,
		      struct tvec_state *tv)
{
  dstr d = DSTR_INIT;
  int rc;

  if (tvec_readword(tv, &d, ";", "unsigned integer"))
    { rc = -1; goto end; }
  if (parse_unsigned(&rv->u, d.buf, rd->arg.p, tv))
    { rc = -1; goto end; }
  if (tvec_flushtoeol(tv, 0))
    { rc = -1; goto end; }
  rc = 0;
end:
  dstr_destroy(&d);
  return (rc);
}

static void dump_int(const union tvec_regval *rv,
		     const struct tvec_regdef *rd,
		     unsigned style,
		     const struct gprintf_ops *gops, void *go)
{
  unsigned long u;

  gprintf(gops, go, "%ld", rv->i);
  if (!(style&TVSF_COMPACT)) {
    if (rv->i >= 0) u = rv->i;
    else u = -(unsigned long)rv->i;
    gprintf(gops, go, " ; = %s0x%0*lx",
	    rv->i < 0 ? "-" : "", hex_width(u), u);
    if (rv->i == EOF || (0 <= rv->i && rv->i < UCHAR_MAX))
      { gprintf(gops, go, " = "); format_char(rv->i, gops, go); }
  }
}

static void dump_uint(const union tvec_regval *rv,
		      const struct tvec_regdef *rd,
		      unsigned style,
		      const struct gprintf_ops *gops, void *go)
{
  gprintf(gops, go, "%lu", rv->u);
  if (!(style&TVSF_COMPACT)) {
    gprintf(gops, go, " ; = 0x%0*lx", hex_width(rv->u), rv->u);
    if (rv->u < UCHAR_MAX)
      { gprintf(gops, go, " = "); format_char(rv->u, gops, go); }
  }
}

const struct tvec_regty tvty_int = {
  init_int, release_int, eq_int,
  tobuf_int, frombuf_int,
  parse_int, dump_int
};

const struct tvec_irange
  tvrange_schar = { SCHAR_MIN, SCHAR_MAX },
  tvrange_short = { SHRT_MIN, SHRT_MAX },
  tvrange_int = { INT_MIN, INT_MAX },
  tvrange_long = { LONG_MIN, LONG_MAX },
  tvrange_sbyte = { -128, 127 },
  tvrange_i16 = { -32768, +32767 },
  tvrange_i32 = { -2147483648, 2147483647 };

const struct tvec_regty tvty_uint = {
  init_uint, release_int, eq_uint,
  tobuf_uint, frombuf_uint,
  parse_uint, dump_uint
};

const struct tvec_urange
  tvrange_uchar = { 0, UCHAR_MAX },
  tvrange_ushort = { 0, USHRT_MAX },
  tvrange_uint = { 0, UINT_MAX },
  tvrange_ulong = { 0, ULONG_MAX },
  tvrange_size = { 0, (size_t)-1 },
  tvrange_byte = { 0, 255 },
  tvrange_u16 = { 0, 65535 },
  tvrange_u32 = { 0, 4294967296 };

int tvec_claimeq_int(struct tvec_state *tv, long i0, long i1,
		     const char *file, unsigned lno, const char *expr)
{
  tv->in[0].v.i = i0; tv->out[0].v.i = i1;
  return (tvec_claimeq(tv, &tvty_int, 0, file, lno, expr));
}

int tvec_claimeq_uint(struct tvec_state *tv,
		      unsigned long u0, unsigned long u1,
		      const char *file, unsigned lno, const char *expr)
{
  tv->in[0].v.u = u0; tv->out[0].v.u = u1;
  return (tvec_claimeq(tv, &tvty_uint, 0, file, lno, expr));
}

/*----- Main code ---------------------------------------------------------*/

static void init_float(union tvec_regval *rv, const struct tvec_regdef *rd)
  { rv->f = 0.0; }
static void release_float(union tvec_regval *rv,
			  const struct tvec_regdef *rd)
  { ; }

static int eq_float(const union tvec_regval *rv0,
		    const union tvec_regval *rv1,
		    const struct tvec_regdef *rd)
  { return (eqish_floating_p(rv0->f, rv1->f, rd->arg.p)); }

static int tobuf_float(buf *b, const union tvec_regval *rv,
		     const struct tvec_regdef *rd)
  { return (buf_putf64l(b, rv->f)); }
static int frombuf_float(buf *b, union tvec_regval *rv,
		       const struct tvec_regdef *rd)
  { return (buf_getf64l(b, &rv->f)); }

static int parse_float(union tvec_regval *rv, const struct tvec_regdef *rd,
		       struct tvec_state *tv)
{
  dstr d = DSTR_INIT;
  int rc;

  if (tvec_readword(tv, &d, ";", "floating-point number"))
    { rc = -1; goto end; }
  if (parse_floating(&rv->f, d.buf, rd->arg.p, tv))
    { rc = -1; goto end; }
  if (tvec_flushtoeol(tv, 0))
    { rc = -1; goto end; }
  rc = 0;
end:
  dstr_destroy(&d);
  return (rc);
}

static void dump_float(const union tvec_regval *rv,
		       const struct tvec_regdef *rd,
		       unsigned style,
		       const struct gprintf_ops *gops, void *go)
  { format_floating(gops, go, rv->f); }

const struct tvec_regty tvty_float = {
  init_float, release_float, eq_float,
  tobuf_float, frombuf_float,
  parse_float, dump_float
};

int tvec_claimeqish_float(struct tvec_state *tv,
			  double f0, double f1, unsigned f, double delta,
			  const char *file, unsigned lno,
			  const char *expr)
{
  struct tvec_floatinfo fi;
  union tvec_misc arg;

  fi.f = f; fi.min = fi.max = 0.0; fi.delta = delta; arg.p = &fi;
  tv->in[0].v.f = f0; tv->in[1].v.f = f1;
  return (tvec_claimeq(tv, &tvty_float, &arg, file, lno, expr));
}
int tvec_claimeq_float(struct tvec_state *tv,
		       double f0, double f1,
		       const char *file, unsigned lno,
		       const char *expr)
{
  return (tvec_claimeqish_float(tv, f0, f1, TVFF_EXACT, 0.0,
				file, lno, expr));
}

/*----- Enumerations ------------------------------------------------------*/

static void init_enum(union tvec_regval *rv, const struct tvec_regdef *rd)
{
  const struct tvec_enuminfo *ei = rd->arg.p;

  switch (ei->mv) {
#define CASE(tag, ty, slot)						\
	case TVMISC_##tag: rv->slot = 0; break;
    TVEC_MISCSLOTS(CASE)
#undef CASE
    default: abort();
  }
}

static int eq_enum(const union tvec_regval *rv0,
		   const union tvec_regval *rv1,
		   const struct tvec_regdef *rd)
{
  const struct tvec_enuminfo *ei = rd->arg.p;
  const struct tvec_fenuminfo *fei;

  switch (ei->mv) {
#define CASE(tag, ty, slot)						\
	case TVMISC_##tag: PREP_##tag return (HANDLE_##tag);
#define PREP_INT
#define HANDLE_INT	rv0->i == rv1->i
#define PREP_UINT
#define HANDLE_UINT	rv0->u == rv1->u
#define PREP_FLT	fei = (const struct tvec_fenuminfo *)ei;
#define HANDLE_FLT	eqish_floating_p(rv0->f, rv1->f, fei->fi)
#define PREP_PTR
#define HANDLE_PTR	rv0->p == rv1->p
    TVEC_MISCSLOTS(CASE)
#undef CASE
#undef PREP_INT
#undef HANDLE_INT
#undef PREP_UINT
#undef HANDLE_UINT
#undef PREP_FLT
#undef HANDLE_FLT
#undef PREP_PTR
#undef HANDLE_PTR
    default: abort();
  }
}

static int tobuf_enum(buf *b, const union tvec_regval *rv,
		      const struct tvec_regdef *rd)
{
  const struct tvec_enuminfo *ei = rd->arg.p;
  const struct tvec_penuminfo *pei;
  const struct tvec_passoc *pa;
  long i;

  switch (ei->mv) {
#define CASE(tag, ty, slot)						\
	case TVMISC_##tag: HANDLE_##tag
#define HANDLE_INT	return (signed_to_buf(b, rv->i));
#define HANDLE_UINT	return (unsigned_to_buf(b, rv->u));
#define HANDLE_FLT	return (buf_putf64l(b, rv->f));
#define HANDLE_PTR							\
	pei = (const struct tvec_penuminfo *)ei;			\
	for (pa = pei->av, i = 0; pa->tag; pa++, i++)			\
	  if (pa->p == rv->p) goto found;				\
	if (!rv->p) i = -1;						\
	else return (-1);						\
      found:								\
	return (signed_to_buf(b, i));
    TVEC_MISCSLOTS(CASE)
#undef CASE
#undef HANDLE_INT
#undef HANDLE_UINT
#undef HANDLE_FLT
#undef HANDLE_PTR
    default: abort();
  }
  return (0);
}

static int frombuf_enum(buf *b, union tvec_regval *rv,
			const struct tvec_regdef *rd)
{
  const struct tvec_enuminfo *ei = rd->arg.p;
  const struct tvec_penuminfo *pei;
  const struct tvec_passoc *pa;
  long i, n;

  switch (ei->mv) {
#define CASE(tag, ty, slot)						\
	case TVMISC_##tag: HANDLE_##tag
#define HANDLE_INT	return (signed_from_buf(b, &rv->i));
#define HANDLE_UINT	return (unsigned_from_buf(b, &rv->u));
#define HANDLE_FLT	return (buf_getf64l(b, &rv->f));
#define HANDLE_PTR							\
	pei = (const struct tvec_penuminfo *)ei;			\
	for (pa = pei->av, n = 0; pa->tag; pa++, n++);			\
	if (signed_from_buf(b, &i)) return (-1);			\
	if (0 <= i && i < n) rv->p = (/*unconst*/ void *)pei->av[i].p;	\
	else if (i == -1) rv->p = 0;					\
	else return (-1);						\
	return (0);
    TVEC_MISCSLOTS(CASE)
#undef CASE
#undef HANDLE_INT
#undef HANDLE_UINT
#undef HANDLE_FLT
#undef HANDLE_PTR
    default: abort();
  }
}

static int parse_enum(union tvec_regval *rv, const struct tvec_regdef *rd,
		      struct tvec_state *tv)
{
  const struct tvec_enuminfo *ei = rd->arg.p;
#define DECLS(tag, ty, slot)						\
	const struct tvec_##slot##enuminfo *slot##ei;			\
	const struct tvec_##slot##assoc *slot##a;
  TVEC_MISCSLOTS(DECLS)
#undef DECLS
  dstr d = DSTR_INIT;
  int rc;

  if (tvec_readword(tv, &d, ";", "enumeration tag or literal integer"))
    { rc = -1; goto end; }
  switch (ei->mv) {

#define CASE(tag_, ty, slot)						\
	case TVMISC_##tag_:						\
	  slot##ei = (const struct tvec_##slot##enuminfo *)ei;		\
	  for (slot##a = slot##ei->av; slot##a->tag; slot##a++)		\
	    if (STRCMP(d.buf, ==, slot##a->tag))			\
	      { rv->slot = FETCH_##tag_; goto done; }			\
	  HANDLE_##tag_ goto done;

#define FETCH_INT (ia->i)
#define HANDLE_INT							\
	if (parse_signed(&rv->i, d.buf, iei->ir, tv))			\
	  { rc = -1; goto end; }

#define FETCH_UINT (ua->u)
#define HANDLE_UINT							\
	if (parse_unsigned(&rv->u, d.buf, uei->ur, tv))			\
	  { rc = -1; goto end; }

#define FETCH_FLT (fa->f)
#define HANDLE_FLT							\
	if (parse_floating(&rv->f, d.buf, fei->fi, tv))			\
	  { rc = -1; goto end; }

#define FETCH_PTR ((/*unconst*/ void *)(pa->p))
#define HANDLE_PTR							\
	if (STRCMP(d.buf, ==, "#nil")) rv->p = 0;			\
	else goto tagonly;

    TVEC_MISCSLOTS(CASE)

#undef CASE
#undef FETCH_INT
#undef HANDLE_INT
#undef FETCH_UINT
#undef HANDLE_UINT
#undef FETCH_FLT
#undef HANDLE_FLT
#undef FETCH_PTR
#undef HANDLE_PTR

    tagonly:
      tvec_error(tv, "unknown `%s' value `%s'", ei->name, d.buf);
      rc = -1; goto end;
  }

done:
  if (tvec_flushtoeol(tv, 0)) { rc = -1; goto end; }
  rc = 0;
end:
  dstr_destroy(&d);
  return (rc);
}

static void dump_enum(const union tvec_regval *rv,
		      const struct tvec_regdef *rd,
		      unsigned style,
		      const struct gprintf_ops *gops, void *go)
{
  const struct tvec_enuminfo *ei = rd->arg.p;
#define DECLS(tag, ty, slot)						\
	const struct tvec_##slot##enuminfo *slot##ei;			\
	const struct tvec_##slot##assoc *slot##a;
  TVEC_MISCSLOTS(DECLS)
#undef DECLS
  const char *tag;
  unsigned long u;
  unsigned f = 0;
#define f_known 1u

  switch (ei->mv) {
#define CASE(tag_, ty, slot)						\
	case TVMISC_##tag_:						\
	  slot##ei = (const struct tvec_##slot##enuminfo *)ei;		\
	  for (slot##a = slot##ei->av; slot##a->tag; slot##a++)		\
	    if (rv->slot == slot##a->slot)				\
	      { tag = slot##a->tag; goto found; }			\
	  break;
    TVEC_MISCSLOTS(CASE)
#undef CASE
    default: abort();
  }
  goto print_raw;

found:
  f |= f_known;
  gprintf(gops, go, "%s", tag);
  if (style&TVSF_COMPACT) return;
  gprintf(gops, go, " ; = ");

print_raw:
  switch (ei->mv) {
#define CASE(tag, ty, slot)						\
	case TVMISC_##tag: HANDLE_##tag break;
#define HANDLE_INT	gprintf(gops, go, "%ld", rv->i);
#define HANDLE_UINT	gprintf(gops, go, "%lu", rv->u);
#define HANDLE_FLT	format_floating(gops, go, rv->f);
#define HANDLE_PTR	if (!rv->p) gprintf(gops, go, "#nil");		\
			else gprintf(gops, go, "#<%s %p>", ei->name, rv->p);
    TVEC_MISCSLOTS(CASE)
#undef CASE
#undef HANDLE_INT
#undef HANDLE_UINT
#undef HANDLE_FLT
#undef HANDLE_PTR
  }

  if (style&TVSF_COMPACT) return;
  switch (ei->mv) {
    case TVMISC_INT:
      if (!(f&f_known)) gprintf(gops, go, " ;");
      if (rv->i >= 0) u = rv->i;
      else u = -(unsigned long)rv->i;
      gprintf(gops, go, " = %s0x%0*lx",
	      rv->i < 0 ? "-" : "", hex_width(u), u);
      if (rv->i == EOF || (0 <= rv->i && rv->i < UCHAR_MAX))
	{ gprintf(gops, go, " = "); format_char(rv->i, gops, go); }
      break;
    case TVMISC_UINT:
      if (!(f&f_known)) gprintf(gops, go, " ;");
      gprintf(gops, go, " = 0x%0*lx", hex_width(rv->u), rv->u);
      if (rv->u < UCHAR_MAX)
	{ gprintf(gops, go, " = "); format_char(rv->u, gops, go); }
      break;
  }
}

const struct tvec_regty tvty_enum = {
  init_enum, release_int, eq_enum,
  tobuf_enum, frombuf_enum,
  parse_enum, dump_enum
};

static const struct tvec_iassoc bool_assoc[] = {
  { "nil",		0 },
  { "false",		0 },
  { "f",		0 },
  { "no",		0 },
  { "n",		0 },
  { "off",		0 },

  { "t",		1 },
  { "true",		1 },
  { "yes",		1 },
  { "y",		1 },
  { "on",		1 },

  { 0,			0 }
};

const struct tvec_ienuminfo tvenum_bool =
  { { "bool", TVMISC_INT }, bool_assoc, &tvrange_int };

#define DEFCLAIM(tag, ty, slot)						\
	int tvec_claimeq_##slot##enum					\
	  (struct tvec_state *tv,					\
	   const struct tvec_##slot##enuminfo *ei, ty e0, ty e1,	\
	   const char *file, unsigned lno, const char *expr)		\
	{								\
	  union tvec_misc arg;						\
									\
	  assert(ei->_ei.mv == TVMISC_##tag);				\
	  arg.p = ei;							\
	  tv->in[0].v.slot = GET_##tag(e0);				\
	  tv->out[0].v.slot = GET_##tag(e1);				\
	  return (tvec_claimeq(tv, &tvty_enum, &arg, file, lno, expr));	\
	}
#define GET_INT(e) (e)
#define GET_UINT(e) (e)
#define GET_FLT(e) (e)
#define GET_PTR(e) ((/*unconst*/ void *)(e))
TVEC_MISCSLOTS(DEFCLAIM)
#undef DEFCLAIM
#undef GET_INT
#undef GET_UINT
#undef GET_FLT
#undef GET_PTR

/*----- Flag types --------------------------------------------------------*/

static int parse_flags(union tvec_regval *rv, const struct tvec_regdef *rd,
		       struct tvec_state *tv)
{
  const struct tvec_flaginfo *fi = rd->arg.p;
  const struct tvec_flag *f;
  unsigned long m = 0, v = 0, t;
  dstr d = DSTR_INIT;
  int ch, rc;

  for (;;) {
    DRESET(&d);
    if (tvec_readword(tv, &d, "|;", "flag name or integer"))
      { rc = -1; goto end; }

    for (f = fi->fv; f->tag; f++)
      if (STRCMP(f->tag, ==, d.buf)) {
	if (m&f->m)
	  { tvec_error(tv, "colliding flag setting"); rc = -1; goto end; }
	else
	  { m |= f->m; v |= f->v; goto next; }
      }

    if (parse_unsigned(&t, d.buf, fi->range, tv))
      { rc = -1; goto end; }
    v |= t;
  next:
    if (tvec_nexttoken(tv)) break;
    ch = getc(tv->fp);
      if (ch != '|') { tvec_syntax(tv, ch, "`|'"); rc = -1; goto end; }
    if (tvec_nexttoken(tv))
      { tvec_syntax(tv, '\n', "flag name or integer"); rc = -1; goto end; }
  }
  rv->u = v;
  rc = 0;
end:
  dstr_destroy(&d);
  return (rc);
}

static void dump_flags(const union tvec_regval *rv,
		       const struct tvec_regdef *rd,
		       unsigned style,
		       const struct gprintf_ops *gops, void *go)
{
  const struct tvec_flaginfo *fi = rd->arg.p;
  const struct tvec_flag *f;
  unsigned long m = ~(unsigned long)0, v = rv->u;
  const char *sep;

  for (f = fi->fv, sep = ""; f->tag; f++)
    if ((m&f->m) && (v&f->m) == f->v) {
      gprintf(gops, go, "%s%s", sep, f->tag); m &= ~f->m;
      sep = style&TVSF_COMPACT ? "|" : " | ";
    }

  if (v&m) gprintf(gops, go, "%s0x%0*lx", sep, hex_width(v), v&m);

  if (!(style&TVSF_COMPACT))
    gprintf(gops, go, " ; = 0x%0*lx", hex_width(rv->u), rv->u);
}

const struct tvec_regty tvty_flags = {
  init_uint, release_int, eq_uint,
  tobuf_uint, frombuf_uint,
  parse_flags, dump_flags
};

int tvec_claimeq_flags(struct tvec_state *tv,
		       const struct tvec_flaginfo *fi,
		       unsigned long f0, unsigned long f1,
		       const char *file, unsigned lno, const char *expr)
{
  union tvec_misc arg;

  arg.p = fi; tv->in[0].v.u = f0; tv->out[0].v.u = f1;
  return (tvec_claimeq(tv, &tvty_flags, &arg, file, lno, expr));
}

/*----- Characters --------------------------------------------------------*/

static int tobuf_char(buf *b, const union tvec_regval *rv,
		     const struct tvec_regdef *rd)
{
  uint32 u;
  if (0 <= rv->i && rv->i <= UCHAR_MAX) u = rv->i;
  else if (rv->i == EOF) u = MASK32;
  else return (-1);
  return (buf_putu32l(b, u));
}

static int frombuf_char(buf *b, union tvec_regval *rv,
		       const struct tvec_regdef *rd)
{
  uint32 u;

  if (buf_getu32l(b, &u)) return (-1);
  if (0 <= u && u <= UCHAR_MAX) rv->i = u;
  else if (u == MASK32) rv->i = EOF;
  else return (-1);
  return (0);
}

static int parse_char(union tvec_regval *rv, const struct tvec_regdef *rd,
		      struct tvec_state *tv)
{
  dstr d = DSTR_INIT;
  int ch, rc;
  unsigned f = 0;
#define f_quote 1u

  ch = getc(tv->fp);
  if (ch == '#') {
    ungetc(ch, tv->fp);
    if (tvec_readword(tv, &d, ";", "character name")) { rc = -1; goto end; }
    if (STRCMP(d.buf, ==, "#eof"))
      rv->i = EOF;
    else {
      rc = tvec_error(tv, "unknown character name `%s'", d.buf);
      goto end;
    }
    rc = 0; goto end;
  }

  if (ch == '\'') { f |= f_quote; ch = getc(tv->fp); }
  switch (ch) {
    case '\'':
      if (!(f&f_quote)) goto plain;
    case EOF: case '\n':
      rc = tvec_syntax(tv, ch, "character"); goto end;
    case '\\':
      if (read_escape(&ch, tv)) return (-1);
    default: plain:
      rv->i = ch; break;
  }
  if (f&f_quote) {
    ch = getc(tv->fp);
    if (ch != '\'') { rc = tvec_syntax(tv, ch, "`''"); goto end; }
  }
  if (tvec_flushtoeol(tv, 0)) { rc = -1; goto end; }
  rc = 0;
end:
  dstr_destroy(&d);
  return (rc);

#undef f_quote
}

static void dump_char(const union tvec_regval *rv,
		      const struct tvec_regdef *rd,
		      unsigned style,
		      const struct gprintf_ops *gops, void *go)
{
  unsigned u;

  if ((style&TVSF_COMPACT) && isprint(rv->i) && rv->i != '\'')
    gprintf(gops, go, "%c", (int)rv->i);
  else
    format_char(rv->i, gops, go);

  if (!(style&TVSF_COMPACT)) {
    u = rv->i < 0 ? -rv->i : rv->i;
    gprintf(gops, go, " ; = %d = %s0x%0*x",
	    (int)rv->i, rv->i < 0 ? "-" : "", hex_width(u), u);
  }
}

const struct tvec_regty tvty_char = {
  init_int, release_int, eq_int,
  tobuf_char, frombuf_char,
  parse_char, dump_char
};

int tvec_claimeq_char(struct tvec_state *tv, int c0, int c1,
		      const char *file, unsigned lno, const char *expr)
{
  tv->in[0].v.i = c0; tv->out[0].v.i = c1;
  return (tvec_claimeq(tv, &tvty_char, 0, file, lno, expr));
}

/*----- Text and byte strings ---------------------------------------------*/

void tvec_allocstring(union tvec_regval *rv, size_t sz)
{
  if (rv->str.sz < sz) { xfree(rv->str.p); rv->str.p = xmalloc(sz); }
  rv->str.sz = sz;
}

void tvec_allocbytes(union tvec_regval *rv, size_t sz)
{
  if (rv->bytes.sz < sz) { xfree(rv->bytes.p); rv->bytes.p = xmalloc(sz); }
  rv->bytes.sz = sz;
}

static void init_string(union tvec_regval *rv, const struct tvec_regdef *rd)
  { rv->str.p = 0; rv->str.sz = 0; }

static void init_bytes(union tvec_regval *rv, const struct tvec_regdef *rd)
  { rv->bytes.p = 0; rv->bytes.sz = 0; }

static void release_string(union tvec_regval *rv,
			  const struct tvec_regdef *rd)
  { xfree(rv->str.p); }

static void release_bytes(union tvec_regval *rv,
			  const struct tvec_regdef *rd)
  { xfree(rv->bytes.p); }

static int eq_string(const union tvec_regval *rv0,
		     const union tvec_regval *rv1,
		     const struct tvec_regdef *rd)
{
  return (rv0->str.sz == rv1->str.sz &&
	  (!rv0->bytes.sz ||
	   MEMCMP(rv0->str.p, ==, rv1->str.p, rv1->str.sz)));
}

static int eq_bytes(const union tvec_regval *rv0,
		    const union tvec_regval *rv1,
		    const struct tvec_regdef *rd)
{
  return (rv0->bytes.sz == rv1->bytes.sz &&
	  (!rv0->bytes.sz ||
	   MEMCMP(rv0->bytes.p, ==, rv1->bytes.p, rv1->bytes.sz)));
}

static int tobuf_string(buf *b, const union tvec_regval *rv,
			const struct tvec_regdef *rd)
  { return (buf_putmem32l(b, rv->str.p, rv->str.sz)); }

static int tobuf_bytes(buf *b, const union tvec_regval *rv,
		       const struct tvec_regdef *rd)
  { return (buf_putmem32l(b, rv->bytes.p, rv->bytes.sz)); }

static int frombuf_string(buf *b, union tvec_regval *rv,
			  const struct tvec_regdef *rd)
{
  const void *p;
  size_t sz;

  p = buf_getmem32l(b, &sz); if (!p) return (-1);
  tvec_allocstring(rv, sz); memcpy(rv->str.p, p, sz);
  return (0);
}

static int frombuf_bytes(buf *b, union tvec_regval *rv,
			 const struct tvec_regdef *rd)
{
  const void *p;
  size_t sz;

  p = buf_getmem32l(b, &sz); if (!p) return (-1);
  tvec_allocbytes(rv, sz); memcpy(rv->bytes.p, p, sz);
  return (0);
}

static int check_string_length(size_t sz, const struct tvec_urange *ur,
			       struct tvec_state *tv)
{
  if (ur && (ur->min > sz || sz > ur->max))
    return (tvec_error(tv,
		       "invalid string length %lu; must be in [%lu..%lu]",
		       (unsigned long)sz, ur->min, ur->max));
  return (0);
}

static int parse_string(union tvec_regval *rv, const struct tvec_regdef *rd,
			struct tvec_state *tv)
{
  void *p = rv->str.p;

  if (read_compound_string(&p, &rv->str.sz, TVCODE_BARE, tv)) return (-1);
  rv->str.p = p;
  if (check_string_length(rv->str.sz, rd->arg.p, tv)) return (-1);
  return (0);
}

static int parse_bytes(union tvec_regval *rv, const struct tvec_regdef *rd,
		       struct tvec_state *tv)
{
  void *p = rv->bytes.p;

  if (read_compound_string(&p, &rv->bytes.sz, TVCODE_HEX, tv)) return (-1);
  rv->bytes.p = p;
  if (check_string_length(rv->bytes.sz, rd->arg.p, tv)) return (-1);
  return (0);
}

static void dump_string(const union tvec_regval *rv,
			const struct tvec_regdef *rd,
			unsigned style,
			const struct gprintf_ops *gops, void *go)
{
  const unsigned char *p, *q, *l;
  unsigned f = 0;
#define f_nonword 1u
#define f_newline 2u

  if (!rv->str.sz) { gprintf(gops, go, "\"\""); return; }

  p = (const unsigned char *)rv->str.p; l = p + rv->str.sz;
  if (*p == '!' || *p == ';' || *p == '"' || *p == '\'') goto quote;
  for (q = p; q < l; q++)
    if (*q == '\n' && q != l - 1) f |= f_newline;
    else if (!*q || !isgraph(*q) || *q == '\\') f |= f_nonword;
  if (f&f_newline) { gprintf(gops, go, "\n\t"); goto quote; }
  else if (f&f_nonword) goto quote;
  gops->putm(go, (const char *)p, rv->str.sz); return;

quote:
  gprintf(gops, go, "\"");
  for (q = p; q < l; q++)
    if (!isprint(*q) || *q == '"') {
      if (p < q) gops->putm(go, (const char *)p, q - p);
      if (*q == '\n' && !(style&TVSF_COMPACT))gprintf(gops, go, "\\n\"\t\"");
      else format_charesc(*q, FCF_BRACE, gops, go);
    }
  if (p < q) gops->putm(go, (const char *)p, q - p);
  gprintf(gops, go, "\"");

#undef f_nonword
#undef f_newline
}

static void dump_bytes(const union tvec_regval *rv,
		       const struct tvec_regdef *rd,
		       unsigned style,
		       const struct gprintf_ops *gops, void *go)
{
  const unsigned char *p = rv->bytes.p, *l = p + rv->bytes.sz;
  size_t off, sz = rv->bytes.sz;
  unsigned i, n;
  int wd;

  if (!sz) {
    gprintf(gops, go, style&TVSF_COMPACT ? "\"\"" : "\"\" ; empty");
    return;
  }

  if (style&TVSF_COMPACT) {
    while (p < l) gprintf(gops, go, "%02x", *p++);
    return;
  }

  if (sz > 16) gprintf(gops, go, "\n\t");

  off = 0; wd = hex_width(sz);
  while (p < l) {
    if (l - p < 16) n = l - p;
    else n = 16;

    for (i = 0; i < 16; i++) {
      if (i < n) gprintf(gops, go, "%02x", p[i]);
      else gprintf(gops, go, "  ");
      if (i%4 == 3) gprintf(gops, go, " ");
    }
    gprintf(gops, go, " ; ");
    if (sz > 16) gprintf(gops, go, "[%0*lx] ", wd, (unsigned long)off);
    for (i = 0; i < n; i++)
      gprintf(gops, go, "%c", isprint(p[i]) ? p[i] : '.');
    p += n; off += n;
    if (p < l) gprintf(gops, go, "\n\t");
  }
}

const struct tvec_regty tvty_string = {
  init_string, release_string, eq_string,
  tobuf_string, frombuf_string,
  parse_string, dump_string
};

const struct tvec_regty tvty_bytes = {
  init_bytes, release_bytes, eq_bytes,
  tobuf_bytes, frombuf_bytes,
  parse_bytes, dump_bytes
};

int tvec_claimeq_string(struct tvec_state *tv,
			const char *p0, size_t sz0,
			const char *p1, size_t sz1,
			const char *file, unsigned lno, const char *expr)
{
  tv->in[0].v.str.p = (/*unconst*/ char *)p0; tv->in[0].v.str.sz = sz0;
  tv->out[0].v.str.p =(/*unconst*/ char *) p1; tv->out[0].v.str.sz = sz1;
  return (tvec_claimeq(tv, &tvty_string, 0, file, lno, expr));
}

int tvec_claimeq_strz(struct tvec_state *tv,
		      const char *p0, const char *p1,
		      const char *file, unsigned lno, const char *expr)
{
  tv->in[0].v.str.p = (/*unconst*/ char *)p0;
    tv->in[0].v.str.sz = strlen(p0);
  tv->out[0].v.str.p = (/*unconst*/ char *)p1;
    tv->out[0].v.str.sz = strlen(p1);
  return (tvec_claimeq(tv, &tvty_string, 0, file, lno, expr));
}

int tvec_claimeq_bytes(struct tvec_state *tv,
		       const void *p0, size_t sz0,
		       const void *p1, size_t sz1,
		       const char *file, unsigned lno, const char *expr)
{
  tv->in[0].v.bytes.p = (/*unconst*/ void *)p0;
    tv->in[0].v.bytes.sz = sz0;
  tv->out[0].v.bytes.p = (/*unconst*/ void *)p1;
    tv->out[0].v.bytes.sz = sz1;
  return (tvec_claimeq(tv, &tvty_bytes, 0, file, lno, expr));
}

/*----- Buffer type -------------------------------------------------------*/

static int eq_buffer(const union tvec_regval *rv0,
		     const union tvec_regval *rv1,
		     const struct tvec_regdef *rd)
  { return (rv0->bytes.sz == rv1->bytes.sz); }

static int tobuf_buffer(buf *b, const union tvec_regval *rv,
			 const struct tvec_regdef *rd)
  { return (unsigned_to_buf(b, rv->bytes.sz)); }

static int frombuf_buffer(buf *b, union tvec_regval *rv,
			  const struct tvec_regdef *rd)
{
  unsigned long u;

  if (unsigned_from_buf(b, &u)) return (-1);
  if (u > (size_t)-1) return (-1);
  tvec_allocbytes(rv, u); memset(rv->bytes.p, '!', u);
  return (0);
}

static const char units[] = "kMGTPEZY";

static int parse_buffer(union tvec_regval *rv,
			const struct tvec_regdef *rd,
			struct tvec_state *tv)
{
  dstr d = DSTR_INIT;
  char *q; const char *unit;
  int olderr;
  size_t pos;
  unsigned long u, t;
  int rc;
  unsigned f = 0;
#define f_range 1u

  if (tvec_readword(tv, &d, ";", "buffer length")) { rc = -1; goto end; }
  olderr = errno; errno = 0;
  u = strtoul(d.buf, &q, 0);
  if (errno) goto bad;
  errno = olderr;
  if (!*q) {
    tvec_skipspc(tv); pos = d.len;
    if (!tvec_readword(tv, &d, ";", 0)) pos++;
    q = d.buf + pos;
  }

  if (u > (size_t)-1) goto rangerr;
  for (t = u, unit = units; *unit; unit++) {
    if (t > (size_t)-1/1024) f |= f_range;
    else t *= 1024;
    if (*q == *unit && (!q[1] || q[1] == 'B')) {
      if (f&f_range) goto rangerr;
      u = t; q += 2; break;
    }
  }
  if (*q && *q != ';') goto bad;
  if (check_string_length(u, rd->arg.p, tv)) { rc = -1; goto end; }

  if (tvec_flushtoeol(tv, 0)) { rc = -1; goto end; }
  tvec_allocbytes(rv, u); memset(rv->bytes.p, '?', u);
  rc = 0;
end:
  DDESTROY(&d); return (rc);

bad:
  tvec_error(tv, "invalid buffer length `%s'", d.buf);
  rc = -1; goto end;

rangerr:
  tvec_error(tv, "buffer length `%s' out of range", d.buf);
  rc = -1; goto end;

#undef f_range
}

static void dump_buffer(const union tvec_regval *rv,
			const struct tvec_regdef *rd,
			unsigned style,
			const struct gprintf_ops *gops, void *go)
{
  const char *unit;
  unsigned long u = rv->bytes.sz;

  if (!u || u%1024)
    gprintf(gops, go, "%lu B", u);
  else {
    for (unit = units, u /= 1024; !(u%1024) && unit[1]; u /= 1024, unit++);
    gprintf(gops, go, "%lu %cB", u, *unit);
  }
}

const struct tvec_regty tvty_buffer = {
  init_bytes, release_bytes, eq_buffer,
  tobuf_buffer, frombuf_buffer,
  parse_buffer, dump_buffer
};

/*----- That's all, folks -------------------------------------------------*/