@@@ adjust bench timings

[mLib] / test / tvec-core.c

/* -*-c-*-
 *
 * Main test vector driver
 *
 * (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 <string.h>

#include "alloc.h"
#include "bench.h"
#include "tvec.h"

/*----- Output ------------------------------------------------------------*/

int tvec_error(struct tvec_state *tv, const char *msg, ...)
{
  va_list ap;

  va_start(ap, msg); tvec_error_v(tv, msg, &ap); va_end(ap);
  tv->f |= TVSF_ERROR; return (-1);
}
int tvec_error_v(struct tvec_state *tv, const char *msg, va_list *ap)
  { tv->output->ops->error(tv->output, msg, ap); return (-1); }

void tvec_notice(struct tvec_state *tv, const char *msg, ...)
{
  va_list ap;
  va_start(ap, msg); tvec_notice_v(tv, msg, &ap); va_end(ap);
}
void tvec_notice_v(struct tvec_state *tv, const char *msg, va_list *ap)
  { tv->output->ops->notice(tv->output, msg, ap); }

int tvec_syntax(struct tvec_state *tv, int ch, const char *expect, ...)
{
  va_list ap;

  va_start(ap, expect); tvec_syntax_v(tv, ch, expect, &ap); va_end(ap);
  return (-1);
}
int tvec_syntax_v(struct tvec_state *tv, int ch,
		   const char *expect, va_list *ap)
{
  dstr d = DSTR_INIT;
  char found[8];

  switch (ch) {
    case EOF: strcpy(found, "<eof>"); break;
    case '\n': strcpy(found, "<eol>"); ungetc(ch, tv->fp); break;
    default:
      if (isprint(ch)) sprintf(found, "`%c'", ch);
      else sprintf(found, "<#x%02x>", ch);
      break;
  }
  dstr_vputf(&d, expect, ap);
  tvec_error(tv, "syntax error: expected %s but found %s", expect, found);
  return (-1);
}

void tvec_skipgroup(struct tvec_state *tv, const char *excuse, ...)
{
  va_list ap;
  va_start(ap, excuse); tvec_skipgroup_v(tv, excuse, &ap); va_end(ap);
}
void tvec_skipgroup_v(struct tvec_state *tv, const char *excuse, va_list *ap)
{
  tv->f |= TVSF_SKIP; tv->grps[TVOUT_SKIP]++;
  tv->output->ops->skipgroup(tv->output, excuse, ap);
}

static void set_outcome(struct tvec_state *tv, unsigned out)
{
  tv->f &= ~(TVSF_ACTIVE | TVSF_OUTMASK);
  tv->f |= out << TVSF_OUTSHIFT;
}

void tvec_skip(struct tvec_state *tv, const char *excuse, ...)
{
  va_list ap;
  va_start(ap, excuse); tvec_skip_v(tv, excuse, &ap); va_end(ap);
}
void tvec_skip_v(struct tvec_state *tv, const char *excuse, va_list *ap)
{
  assert(tv->f&TVSF_ACTIVE);
  set_outcome(tv, TVOUT_SKIP);
  tv->output->ops->skip(tv->output, excuse, ap);
}

void tvec_fail(struct tvec_state *tv, const char *detail, ...)
{
  va_list ap;
  va_start(ap, detail); tvec_fail_v(tv, detail, &ap); va_end(ap);
}
void tvec_fail_v(struct tvec_state *tv, const char *detail, va_list *ap)
{
  assert((tv->f&TVSF_ACTIVE) ||
	 (tv->f&TVSF_OUTMASK) == (TVOUT_LOSE << TVSF_OUTSHIFT));
  set_outcome(tv, TVOUT_LOSE); tv->output->ops->fail(tv->output, detail, ap);
}

void tvec_mismatch(struct tvec_state *tv)
  { tv->output->ops->mismatch(tv->output); }

void tvec_write(struct tvec_state *tv, const char *p, ...)
{
  va_list ap;
  va_start(ap, p); tvec_write_v(tv, p, &ap); va_end(ap);
}
void tvec_write_v(struct tvec_state *tv, const char *p, va_list *ap)
{
  dstr d = DSTR_INIT;

  dstr_vputf(&d, p, ap); tv->output->ops->write(tv->output, d.buf, d.len);
  DDESTROY(&d);
}

/*----- Serialization and deserialization ---------------------------------*/

int tvec_serialize(const struct tvec_reg *rv,
		   const struct tvec_regdef *regs,
		   unsigned nr, size_t regsz,
		   void **p_out, size_t *sz_out)
{
  void *p = 0; buf b;
  unsigned char *bitmap;
  size_t i, nbits, bitsz, sz;
  const struct tvec_regdef *rd;
  const struct tvec_reg *r;
  int rc;

  for (rd = regs, nbits = 0, sz = 0; rd->name; rd++, nbits++) {
    if (rd->i >= nr) continue;
    r = TVEC_GREG(rv, rd->i, regsz); if (!(r->f&TVRF_LIVE)) continue;
    sz += rd->ty->measure(&r->v, rd);
  }
  bitsz = (nbits + 7)/8; sz += bitsz;

  p = xmalloc(sz); buf_init(&b, p, sz);
  bitmap = buf_get(&b, bitsz); assert(bitmap); memset(bitmap, 0, bitsz);
  for (rd = regs, i = 0; rd->name; rd++, i++) {
    if (rd->i >= nr) continue;
    r = TVEC_GREG(rv, rd->i, regsz); if (!(r->f&TVRF_LIVE)) continue;
    bitmap[rd->i/8] |= 1 << rd->i%8;
    if (rd->ty->tobuf(&b, &r->v, rd)) { rc = -1; goto end; }
  }

  if (BBAD(&b)) { rc = -1; goto end; }
  *p_out = p; *sz_out = BLEN(&b); p = 0; rc = 0;
end:
  xfree(p);
  return (rc);
}

int tvec_deserialize(struct tvec_reg *rv,
		     const struct tvec_regdef *regs,
		     unsigned nr, size_t regsz,
		     const void *p, size_t sz)
{
  buf b;
  const unsigned char *bitmap;
  size_t i, nbits, bitsz;
  const struct tvec_regdef *rd;
  struct tvec_reg *r;
  int rc;

  for (rd = regs, nbits = 0; rd->name; rd++, nbits++);
  bitsz = (nbits + 7)/8; sz += bitsz;

  buf_init(&b, (/*unconst*/ void *)p, sz);
  bitmap = buf_get(&b, bitsz); if (!bitmap) { rc = -1; goto end; }
  for (rd = regs, i = 0; rd->name; rd++, i++) {
    if (rd->i >= nr) continue;
    if (!(bitmap[rd->i/8]&(1 << rd->i%8))) continue;
    r = TVEC_GREG(rv, rd->i, regsz);
    if (rd->ty->frombuf(&b, &r->v, rd)) { rc = -1; goto end; }
    r->f |= TVRF_LIVE;
  }

  if (BBAD(&b)) { rc = -1; goto end; }
  rc = 0;
end:
  return (rc);
}

/*----- Main machinery ----------------------------------------------------*/

void tvec_skipspc(struct tvec_state *tv)
{
  int ch;

  for (;;) {
    ch = getc(tv->fp);
    if (ch == EOF) break;
    else if (ch == '\n' || !isspace(ch)) { ungetc(ch, tv->fp); break; }
  }
}

int tvec_flushtoeol(struct tvec_state *tv, unsigned f)
{
  int ch, rc = 0;

  for (;;) {
    ch = getc(tv->fp);
    switch (ch) {
      case '\n': tv->lno++; return (rc);
      case EOF: return (rc);
      case ';': f |= TVFF_ALLOWANY; break;
      default:
	if (!(f&TVFF_ALLOWANY) && !isspace(ch)) {
	  tvec_syntax(tv, ch, "end-of-line");
	  rc = -1; f |= TVFF_ALLOWANY;
	}
	break;
    }
  }
}

int tvec_nexttoken(struct tvec_state *tv)
{
  enum { TAIL, NEWLINE, INDENT, COMMENT };
  int ch;
  unsigned s = TAIL;

  for (;;) {
    ch = getc(tv->fp);
    switch (ch) {
      case EOF:
	return (-1);

      case ';':
	s = COMMENT;
	break;

      case '\n':
	if (s == NEWLINE || s == INDENT) { ungetc(ch, tv->fp); return (-1); }
	else { tv->lno++; s = NEWLINE; }
	break;

      default:
	if (isspace(ch))
	  { if (s == NEWLINE) s = INDENT; }
	else if (s != COMMENT) {
	  ungetc(ch, tv->fp);
	  if (s == NEWLINE) return (-1);
	  else return (0);
	}
	break;
    }
  }
}

int tvec_readword(struct tvec_state *tv, dstr *d, const char *delims,
		  const char *expect, ...)
{
  va_list ap;
  int rc;

  va_start(ap, expect);
  rc = tvec_readword_v(tv, d, delims, expect, &ap);
  va_end(ap);
  return (rc);
}
int tvec_readword_v(struct tvec_state *tv, dstr *d, const char *delims,
		    const char *expect, va_list *ap)
{
  int ch;

  ch = getc(tv->fp);
  if (ch == '\n' || ch == EOF || ch == ';' ||
      (delims && strchr(delims, ch))) {
    if (expect) return (tvec_syntax(tv, ch, expect, ap));
    else { ungetc(ch, tv->fp); return (-1); }
  }
  if (d->len) DPUTC(d, ' ');
  do {
    DPUTC(d, ch);
    ch = getc(tv->fp);
  } while (ch != EOF && !isspace(ch) && (!delims || !strchr(delims, ch)));
  DPUTZ(d); if (ch != EOF) ungetc(ch, tv->fp);
  return (0);
}

static void init_registers(struct tvec_state *tv)
{
  const struct tvec_regdef *rd;
  struct tvec_reg *r;

  for (rd = tv->test->regs; rd->name; rd++) {
    assert(rd->i < tv->nreg); r = TVEC_REG(tv, in, rd->i);
    rd->ty->init(&r->v, rd); r->f = 0;
    if (rd->i < tv->nrout)
      { r = TVEC_REG(tv, out, rd->i); rd->ty->init(&r->v, rd); r->f = 0; }
  }
  tv->expst = '.';
}

static void release_registers(struct tvec_state *tv)
{
  const struct tvec_regdef *rd;
  struct tvec_reg *r;

  for (rd = tv->test->regs; rd->name; rd++) {
    assert(rd->i < tv->nreg); r = TVEC_REG(tv, in, rd->i);
    rd->ty->release(&r->v, rd); r->f = 0;
    if (rd->i < tv->nrout)
      { r = TVEC_REG(tv, out, rd->i); rd->ty->release(&r->v, rd); r->f = 0; }
  }
}

void tvec_check(struct tvec_state *tv, const char *detail, ...)
{
  va_list ap;
  va_start(ap, detail); tvec_check_v(tv, detail, &ap); va_end(ap);
}
void tvec_check_v(struct tvec_state *tv, const char *detail, va_list *ap)
{
  const struct tvec_regdef *rd;
  const struct tvec_reg *rin, *rout;
  unsigned f = 0;
#define f_mismatch 1u

  if (tv->expst != tv->st) f |= f_mismatch;
  for (rd = tv->test->regs; rd->name; rd++) {
    if (rd->i >= tv->nrout) continue;
    rin = TVEC_REG(tv, in, rd->i); rout = TVEC_REG(tv, out, rd->i);
    if (!rin->f&TVRF_LIVE) continue;
    if (!rd->ty->eq(&rin->v, &rout->v, rd)) f |= f_mismatch;
  }
  if (!(f&f_mismatch)) return;

  tvec_fail_v(tv, detail, ap);
  tvec_mismatch(tv);

#undef f_mismatch
}

int tvec_runtest(struct tvec_state *tv)
{
  tv->test->fn(tv->in, tv->out, (/*unconst*/ void *)tv->test->arg.p);
  tvec_check(tv, 0); return (0);
}

static void begin_test(struct tvec_state *tv)
{
  tv->f |= TVSF_ACTIVE; tv->f &= ~TVSF_OUTMASK; tv->st = '.';
  tv->output->ops->btest(tv->output);
}

void tvec_endtest(struct tvec_state *tv)
{
  unsigned out;

  if (tv->f&TVSF_ACTIVE) out = TVOUT_WIN;
  else out = (tv->f&TVSF_OUTMASK) >> TVSF_OUTSHIFT;
  assert(out < TVOUT_LIMIT); tv->curr[out]++;
  tv->output->ops->etest(tv->output, out);
  tv->f &= ~TVSF_OPEN;
}

static void check(struct tvec_state *tv)
{
  const struct tvec_regdef *rd;

  if (!(tv->f&TVSF_OPEN)) return;

  for (rd = tv->test->regs; rd->name; rd++) {
    if (TVEC_REG(tv, in, rd->i)->f&TVRF_LIVE)
      { if (rd->i < tv->nrout) TVEC_REG(tv, out, rd->i)->f |= TVRF_LIVE; }
    else if (!(rd->f&TVRF_OPT)) {
      tvec_error(tv, "required register `%s' not set in test `%s'",
		 rd->name, tv->test->name);
      goto end;
    }
  }

  if (!(tv->f&TVSF_SKIP))
    { begin_test(tv); tv->test->run(tv); tvec_endtest(tv); }

end:
  tv->f &= ~TVSF_OPEN; release_registers(tv); init_registers(tv);
}

static void begin_test_group(struct tvec_state *tv)
{
  unsigned i;

  tv->output->ops->bgroup(tv->output);
  tv->f &= ~TVSF_SKIP;
  init_registers(tv);
  for (i = 0; i < TVOUT_LIMIT; i++) tv->curr[i] = 0;
  if (tv->test->preflight) tv->test->preflight(tv);
}

void tvec_reportgroup(struct tvec_state *tv)
{
  unsigned i, out, nrun;

  for (i = 0, nrun = 0; i < TVOUT_LIMIT; i++)
    { nrun += tv->curr[i]; tv->all[i] += tv->curr[i]; }

  if (tv->curr[TVOUT_SKIP] == nrun)
    { out = TVOUT_SKIP; tvec_skipgroup(tv, nrun ? 0 : "no tests to run"); }
  else {
    if (tv->curr[TVOUT_LOSE]) out = TVOUT_LOSE;
    else out = TVOUT_WIN;
    tv->grps[out]++; tv->output->ops->egroup(tv->output, out);
  }
}

static void end_test_group(struct tvec_state *tv)
{
  if (!tv->test) return;
  if (tv->f&TVSF_OPEN) check(tv);
  if (!(tv->f&TVSF_SKIP)) tvec_reportgroup(tv);
  release_registers(tv); tv->test = 0;
}

int tvec_read(struct tvec_state *tv, const char *infile, FILE *fp)
{
  dstr d = DSTR_INIT;
  const struct tvec_test *test;
  const struct tvec_regdef *rd;
  struct tvec_reg *r;
  int ch;
  int rc = 0;

  tv->infile = infile; tv->lno = 1; tv->fp = fp;

  for (;;) {
    ch = getc(tv->fp);
    switch (ch) {

      case EOF:
	goto end;

      case '[':
	end_test_group(tv);
	tvec_skipspc(tv);
	DRESET(&d); tvec_readword(tv, &d, "];", "group name");
	tvec_skipspc(tv);
	ch = getc(tv->fp); if (ch != ']') tvec_syntax(tv, ch, "`]'");
	for (test = tv->tests; test->name; test++)
	  if (STRCMP(d.buf, ==, test->name)) goto found_test;
	tvec_error(tv, "unknown test group `%s'", d.buf); goto flush_line;
      found_test:
	tvec_flushtoeol(tv, 0);	tv->test = test; begin_test_group(tv);
	break;

      case '\n':
	tv->lno++;
	if (tv->f&TVSF_OPEN) check(tv);
	break;

      default:
	if (isspace(ch)) {
	  tvec_skipspc(tv);
	  ch = getc(tv->fp);
	  if (ch == EOF) goto end;
	  else if (ch == ';') tvec_flushtoeol(tv, TVFF_ALLOWANY);
	  else if (tvec_flushtoeol(tv, 0)) rc = -1;
	  else check(tv);
	} else if (ch == ';')
	  tvec_flushtoeol(tv, TVFF_ALLOWANY);
	else {
	  ungetc(ch, tv->fp);
	  DRESET(&d);
	  if (tvec_readword(tv, &d, "=:;", "register name")) goto flush_line;
	  tvec_skipspc(tv); ch = getc(tv->fp);
	  if (ch != '=' && ch != ':')
	    { tvec_syntax(tv, ch, "`=' or `:'"); goto flush_line; }
	  tvec_skipspc(tv);
	  if (d.buf[0] == '@') {
	    if (STRCMP(d.buf, ==, "@status")) {
	      if (!(tv->f&TVSF_OPEN))
		{ tv->test_lno = tv->lno; tv->f |= TVSF_OPEN; }
	      ch = getc(tv->fp);
	      if (ch == EOF || ch == '\n' || ch == ';')
		{ tvec_syntax(tv, ch, "status character"); goto flush_line; }
	      else if (ch == '\\') {
		ch = getc(tv->fp);
		if (ch == EOF || ch == '\n') {
		  tvec_syntax(tv, ch, "escaped status character");
		  goto flush_line;
		}
	      }
	      tv->expst = ch;
	      tvec_flushtoeol(tv, 0);
	    } else {
	      tvec_error(tv, "unknown special register `%s'", d.buf);
	      goto flush_line;
	    }
	  } else {
	    if (!tv->test)
	      { tvec_error(tv, "no current test"); goto flush_line; }
	    for (rd = tv->test->regs; rd->name; rd++)
	      if (STRCMP(rd->name, ==, d.buf)) goto found_reg;
	    tvec_error(tv, "unknown register `%s' for test `%s'",
		       d.buf, tv->test->name);
	    goto flush_line;
	  found_reg:
	    if (!(tv->f&TVSF_OPEN))
	      { tv->test_lno = tv->lno; tv->f |= TVSF_OPEN; }
	    tvec_skipspc(tv);
	    r = TVEC_REG(tv, in, rd->i);
	    if (r->f&TVRF_LIVE) {
	      tvec_error(tv, "register `%s' already set", rd->name);
	      goto flush_line;
	    }
	    if (rd->ty->parse(&r->v, rd, tv)) goto flush_line;
	    r->f |= TVRF_LIVE;
	  }
	}
	break;
    }
    continue;

  flush_line:
    tvec_flushtoeol(tv, TVFF_ALLOWANY); rc = -1;
  }
  if (ferror(tv->fp))
    { tvec_error(tv, "error reading input: %s", strerror(errno)); rc = -1; }
end:
  end_test_group(tv);
  tv->infile = 0; tv->fp = 0;
  dstr_destroy(&d);
  return (rc);
}

/*----- Benchmarking ------------------------------------------------------*/

struct bench_state *tvec_benchstate;

struct benchrun {
  unsigned long *n;
  tvec_testfn *fn;
  const struct tvec_reg *in; struct tvec_reg *out;
  void *ctx;
};

static void benchloop_outer(unsigned long n, void *p)
  { struct benchrun *r = p; while (n--) r->fn(r->in, r->out, r->ctx); }

static void benchloop_inner(unsigned long n, void *p)
  { struct benchrun *r = p; *r->n = n; r->fn(r->in, r->out, r->ctx); }

int tvec_ensurebench(struct tvec_state *tv, struct bench_state **b_out)
{
  const struct tvec_bench *tvb = tv->test->arg.p;
  struct bench_state **bb;
  struct bench_timer *bt;

  if (tvb->b) bb = tvb->b;
  else bb = &tvec_benchstate;

  if (!*bb) {
    bt = bench_createtimer();
    if (!bt) { tvec_skip(tv, "failed to create timer"); return (-1); }
    *bb = xmalloc(sizeof(**bb)); bench_init(*bb, bt);
  } else if (!(*bb)->tm)
    { tvec_skip(tv, "failed to create timer"); return (-1); }

  *b_out = *bb;
  return (0);
}

int tvec_bench(struct tvec_state *tv)
{
  const struct tvec_bench *tvb = tv->test->arg.p;
  struct bench_state *b;
  struct bench_timing tm;
  struct benchrun r;
  bench_fn *loopfn;

  if (tvec_ensurebench(tv, &b)) goto end_0;

  r.in = tv->in; r.out = tv->out; r.fn = tv->test->fn;
  if (tvb->ctxsz) r.ctx = xmalloc(tvb->ctxsz);
  else r.ctx = 0;
  if (tvb->setup && tvb->setup(tv->in, tv->out, &tvb->arg, r.ctx))
    { tvec_skip(tv, "benchmark setup failed"); goto end_1; }

  if (tvb->riter < 0)
    { r.n = 0; loopfn = benchloop_outer; }
  else
    { r.n = &TVEC_REG(tv, in, tvb->riter)->v.u; loopfn = benchloop_inner; }

  tv->output->ops->bbench(tv->output);
  if (bench_measure(&tm, b, loopfn, &r))
    { tv->output->ops->ebench(tv->output, 0); goto end_2; }
  tv->output->ops->ebench(tv->output, &tm);

end_2:
  if (tvb->teardown) tvb->teardown(r.ctx);
end_1:
  if (r.ctx) xfree(r.ctx);
end_0:
  return (0);
}

/*----- Ad-hoc testing ----------------------------------------------------*/

static const struct tvec_regdef no_regs = { 0, 0, 0, 0, { 0 } };

static int fakerun(struct tvec_state *tv)
  { assert(!"fake run function"); }
static void fakefn(const struct tvec_reg *in, struct tvec_reg *out, void *p)
  { assert(!"fake test function"); }

void tvec_adhoc(struct tvec_state *tv, struct tvec_test *t)
{
  t->name = "<unset>"; t->regs = &no_regs;
  t->preflight = 0; t->run = fakerun; t->fn = fakefn; t->arg.p = 0;
  tv->tests = t;
}

void tvec_begingroup(struct tvec_state *tv, const char *name,
		     const char *file, unsigned lno)
{
  struct tvec_test *t = (/*unconst*/ struct tvec_test *)tv->tests;

  t->name = name; tv->test = t;
  tv->infile = file; tv->lno = tv->test_lno = lno;
  begin_test_group(tv);
}

void tvec_endgroup(struct tvec_state *tv)
{
  if (!(tv->f&TVSF_SKIP)) tvec_reportgroup(tv);
  tv->test = 0;
}

void tvec_begintest(struct tvec_state *tv, const char *file, unsigned lno)
{
  tv->infile = file; tv->lno = tv->test_lno = lno;
  begin_test(tv); tv->f |= TVSF_OPEN;
}

struct adhoc_claim {
  unsigned f;
#define ACF_FRESH 1u
  const char *saved_file; unsigned saved_lno;
};

static void adhoc_claim_setup(struct tvec_state *tv,
			      struct adhoc_claim *ck,
			      const struct tvec_regdef *regs,
			      const char *file, unsigned lno)
{
  struct tvec_test *t = (/*unconst*/ struct tvec_test *)tv->test;

  ck->f = 0;

  if (!(tv->f&TVSF_OPEN))
    { ck->f |= ACF_FRESH; tvec_begintest(tv, file, lno); }

  ck->saved_file = tv->infile; if (file) tv->infile = file;
  ck->saved_lno = tv->test_lno; if (file) tv->test_lno = lno;
  t->regs = regs ? regs : &no_regs;

  tv->st = '.';
}

static void adhoc_claim_teardown(struct tvec_state *tv,
				 struct adhoc_claim *ck)
{
  struct tvec_test *t = (/*unconst*/ struct tvec_test *)tv->test;

  t->regs = &no_regs;
  tv->infile = ck->saved_file; tv->test_lno = ck->saved_lno;

  if (ck->f&ACF_FRESH) tvec_endtest(tv);
}

int tvec_claim(struct tvec_state *tv, int ok,
	       const char *file, unsigned lno, const char *expr, ...)
{
  struct adhoc_claim ck;
  va_list ap;

  adhoc_claim_setup(tv, &ck, 0, file, lno);
  if (!ok)
    { va_start(ap, expr); tvec_fail_v(tv, expr, &ap); va_end(ap); }
  adhoc_claim_teardown(tv, &ck);
  return (ok);
}

int tvec_claimeq(struct tvec_state *tv,
		 const struct tvec_regty *ty, const union tvec_misc *arg,
		 const char *file, unsigned lno, const char *expr)
{
  struct tvec_regdef regs[2];
  struct adhoc_claim ck;
  int ok;

  tv->in[0].f = tv->out[0].f = TVRF_LIVE;

  regs[0].name = "value"; regs[0].i = 0;
  regs[0].ty = ty; regs[0].f = 0;
  if (arg) regs[0].arg = *arg;
  else regs[0].arg.p = 0;

  regs[1].name = 0;

  adhoc_claim_setup(tv, &ck, regs, file, lno);
  ok = ty->eq(&tv->in[0].v, &tv->out[0].v, &regs[0]);
  if (!ok) { tvec_fail(tv, "%s", expr ); tvec_mismatch(tv); }
  adhoc_claim_teardown(tv, &ck);
  return (ok);
}

/*----- Session lifecycle -------------------------------------------------*/

void tvec_begin(struct tvec_state *tv_out,
		const struct tvec_info *info,
		struct tvec_output *o)
{
  unsigned i;

  tv_out->f = 0;

  assert(info->nrout <= info->nreg);
  tv_out->nrout = info->nrout; tv_out->nreg = info->nreg;
  tv_out->regsz = info->regsz;
  tv_out->in = xmalloc(tv_out->nreg*tv_out->regsz);
  tv_out->out = xmalloc(tv_out->nrout*tv_out->regsz);
  for (i = 0; i < tv_out->nreg; i++) {
    TVEC_REG(tv_out, in, i)->f = 0;
    if (i < tv_out->nrout) TVEC_REG(tv_out, out, i)->f = 0;
  }

  for (i = 0; i < TVOUT_LIMIT; i++)
    tv_out->curr[i] = tv_out->all[i] = tv_out->grps[i] = 0;

  tv_out->tests = info->tests; tv_out->test = 0;
  tv_out->infile = 0; tv_out->lno = 0; tv_out->fp = 0;
  o->tv = tv_out; tv_out->output = o;

  tv_out->output->ops->bsession(tv_out->output);
}

int tvec_end(struct tvec_state *tv)
{
  int rc = tv->output->ops->esession(tv->output);

  tv->output->ops->destroy(tv->output);
  xfree(tv->in); xfree(tv->out);
  return (rc);
}

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