@@@ tty commentary

[mLib] / ui / tty.c

/* -*-c-*-
 *
 * Terminal handling
 *
 * (c) 2024 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 "config.h"

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>

#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <sys/select.h>

#ifdef HAVE_TERMCAP
#  include <termcap.h>
#endif

#ifdef HAVE_TERMINFO
#  include <curses.h>
#  include <term.h>
#  undef erase
#  undef inch
#  undef move
#endif

#ifdef HAVE_UNIBILIUM
#  include <unibilium.h>
#endif

#include "alloc.h"
#include "gprintf.h"
#include "macros.h"
#include "str.h"
#include "tty.h"

/*----- Miscellaneous preliminaries ---------------------------------------*/

/* Buffer size parameters. */
#define BUFSZ 4096                      /* size of a buffer */
#define THRESH (BUFSZ/2)                /* threshold for buffering */

/* Incorporate the published control-block structure into our more elaborate
 * object model.
 */
#define TTY_BASEPFX struct tty tty
#define TTY_BASEUSFX struct tty tty

struct tty_ops {
  void (*release)(struct tty */*tty*/);
        /* Free any resources held by the backend. */

  /* The following operations handle the correspondingly named interface
   * functions.
   */
  int (*setattr)(struct tty */*tty*/,
                 const struct gprintf_ops */*gops*/, void */*go*/,
                 const struct tty_attr */*a*/);
  int (*setmodes)(struct tty */*tty*/,
                  const struct gprintf_ops */*gops*/, void */*go*/,
                  uint32 /*modes_bic*/, uint32 /*modes_xor*/);
  int (*move)(struct tty */*tty*/,
              const struct gprintf_ops */*gops*/, void */*go*/,
              unsigned /*orig*/, int /*y*/, int /*x*/);
  int (*repeat)(struct tty */*tty*/,
                const struct gprintf_ops */*gops*/, void */*go*/,
                int /*ch*/, unsigned /*n*/);
  int (*erase)(struct tty */*tty*/,
               const struct gprintf_ops */*gops*/, void */*go*/,
               unsigned /*f*/);
  int (*erch)(struct tty */*tty*/,
              const struct gprintf_ops */*gops*/, void */*go*/,
              unsigned /*n*/);
  int (*ins)(struct tty */*tty*/,
             const struct gprintf_ops */*gops*/, void */*go*/,
             unsigned /*f*/, unsigned /*n*/);
  int (*inch)(struct tty */*tty*/,
              const struct gprintf_ops */*gops*/, void */*go*/,
              int /*ch*/);
  int (*del)(struct tty */*tty*/,
             const struct gprintf_ops */*gops*/, void */*go*/,
             unsigned /*f*/, unsigned /*n*/);
};
#define TTY_BASEOPSPFX struct tty_ops tty
#define TTY_BASEOPSUXFX struct tty_ops tty

/*----- Common support machinery ------------------------------------------*/

/* --- @CHECK@ --- *
 *
 * Arguments@   @expr@ = expression to evaluate
 *
 * Use:         Evaluate @expr@.  If the result is (strictly) negative, then
 *              set @rc = -1@ and transfer control to the label @end@.
 */

#define CHECK(expr) do { if ((expr) < 0) { rc = -1; goto end; } } while (0)

/* --- @debug@ --- *
 *
 * Arguments:   @const char *fmt@ = format control string
 *              @...@ = format arguemnts
 *
 * Returns:     ---
 *
 * Use:         Maybe report a debugging message to standard error.
 */

static PRINTF_LIKE(1, 2) void debug(const char *fmt, ...)
{
  const char *p;
  va_list ap;

  p = getenv("MLIB_TTY_DEBUG");
  if (p && *p != 'n' && *p != '0') {
    va_start(ap, fmt);
    fputs("mLib TTY: ", stderr);
    vfprintf(stderr, fmt, ap);
    fputc('\n', stderr);
    va_end(ap);
  }
}

/* --- @common_init@ --- *
 *
 * Arguments:   @struct tty *tty@ = pointer to terminal control block
 *              @FILE *fp@ = output file stream
 *              @speed_t *ospeed_out@ = where to put encoded output rate, or
 *                      null
 *
 * Returns:     ---
 *
 * Use:         Perform general initialization on the terminal control
 *              block.
 *
 *              Specifically, this fills in the @fpout@, @baud@, @ht@, and
 *              @wd@ slots.  The width and height come from the kernel, or,
 *              failing that, the environment.
 *
 *              For `termcap''s benefit, store the system-encoded output baud
 *              rate in @*ospeed_out@, if it can be found.
 */

static void common_init(struct tty *tty, FILE *fp, speed_t *ospeed_out)
{
  static const struct baudtab { speed_t code; unsigned baud; } baudtab[] = {
  /*
     ;;; The baud-rate table is very boring to type.  To make life less
     ;;; awful, put the rates in this list and evaluate the code to get Emacs
     ;;; to regenerate it.

     (let ((bauds '(50 75 110 134 150 200 300 600 1200 1800 2400 4800 9600
                    19200 38400 57600 115200 230400 460800 500000 576000
                    921600 1000000 1152000 1500000 2000000 2500000 3000000
                    3500000 4000000)))
       (save-excursion
         (goto-char (point-min))
         (search-forward (concat "***" "BEGIN baudlist" "***"))
         (beginning-of-line 2)
         (delete-region (point)
                        (progn
                          (search-forward "***END***")
                          (beginning-of-line)
                          (point)))
         (dolist (baud (sort (copy-list bauds) #'<))
           (insert (format "#ifdef B%d\n    { B%d, %d },\n#endif\n"
                           baud baud baud)))))
  */
    /***BEGIN baudlist***/
#ifdef B50
    { B50, 50 },
#endif
#ifdef B75
    { B75, 75 },
#endif
#ifdef B110
    { B110, 110 },
#endif
#ifdef B134
    { B134, 134 },
#endif
#ifdef B150
    { B150, 150 },
#endif
#ifdef B200
    { B200, 200 },
#endif
#ifdef B300
    { B300, 300 },
#endif
#ifdef B600
    { B600, 600 },
#endif
#ifdef B1200
    { B1200, 1200 },
#endif
#ifdef B1800
    { B1800, 1800 },
#endif
#ifdef B2400
    { B2400, 2400 },
#endif
#ifdef B4800
    { B4800, 4800 },
#endif
#ifdef B9600
    { B9600, 9600 },
#endif
#ifdef B19200
    { B19200, 19200 },
#endif
#ifdef B38400
    { B38400, 38400 },
#endif
#ifdef B57600
    { B57600, 57600 },
#endif
#ifdef B115200
    { B115200, 115200 },
#endif
#ifdef B230400
    { B230400, 230400 },
#endif
#ifdef B460800
    { B460800, 460800 },
#endif
#ifdef B500000
    { B500000, 500000 },
#endif
#ifdef B576000
    { B576000, 576000 },
#endif
#ifdef B921600
    { B921600, 921600 },
#endif
#ifdef B1000000
    { B1000000, 1000000 },
#endif
#ifdef B1152000
    { B1152000, 1152000 },
#endif
#ifdef B1500000
    { B1500000, 1500000 },
#endif
#ifdef B2000000
    { B2000000, 2000000 },
#endif
#ifdef B2500000
    { B2500000, 2500000 },
#endif
#ifdef B3000000
    { B3000000, 3000000 },
#endif
#ifdef B3500000
    { B3500000, 3500000 },
#endif
#ifdef B4000000
    { B4000000, 4000000 },
#endif
    /***END***/
    { 0, 0 }
  };

  const struct baudtab *b;
  const char *p; int n;
  struct termios c;
  speed_t code;

  /* Save the output stream. */
  tty->fpout = fp;

  /* Determine the output baud rate.  Unhelpfully, the kernel provides a
   * weird code, so we have to convert it into an actual rate in bits per
   * second.
   */
  tty->baud = 0; tty->wd = tty->ht = 0;
  if (fp && !tcgetattr(fileno(fp), &c)) {
    code = cfgetospeed(&c); if (ospeed_out) *ospeed_out = code;
    for (b = baudtab; b->baud; b++)
      if (b->code == code) { tty->baud = b->baud; break; }
    tty_resized(tty);
  }

  /* If the kernel didn't tell us the terminal dimensions, try to read them
   * from the environment.
   */
  if (!tty->wd)
    { p = getenv("COLUMNS"); if (p) { n = atoi(p); if (n) tty->wd = n; } }
  if (!tty->ht)
    { p = getenv("LINES");   if (p) { n = atoi(p); if (n) tty->ht = n; } }
}

/* --- @env_colour_caps@ --- *
 *
 * Arguments:   @unsigned *caps_inout@ = attribute capabilities to update
 *              @unsigned f@ = flags
 *
 * Returns:     ---
 *
 * Use:         Check the %|FORCE_COLOR|% environment variable and update the
 *              capabilities as required.
 *
 *              The %|FORCE_COLOR|% variable originates with the Node
 *              community, with two objectives: (a) to convey policy
 *              regarding whether to produce coloured output, and (b) to
 *              describe the colour capabilities of the terminal, because the
 *              traditional mechanisms are deemed inadequate.
 *
 *              The following values have defined meanings.
 *
 *                * Unset or empty: no effect.
 *
 *                * %|0|%: monochrome; don't produce colour.
 *
 *                * %|1|%: 16 colours; 1-bit-per-channel colours are
 *                  available, with an additional common brightness bit.
 *
 *                * %|2|%: 256 colours; the `xterm' 256-bit palette is
 *                  available, consisting of the 1-bit-per-channel colours
 *                  with common brightness bit, a 6 × 6 × 6 colour cube, and
 *                  a 24-level greyscale ramp.
 *
 *                * %|3|%: full 24-bit colour.
 *
 *                * Anything else: a request to use colour if available.
 *                  This is ignored here, in the expectation that it will be
 *                  given effect elsewhere, e.g., by @ttycolour_enablep@.
 *
 *              If @ECCF_SET@ is set, then set or clear capabilities as
 *              required.  Otherwise, clear capability bits which are denied
 *              by the variable setting, but no bits will be set.  (This
 *              latter is necessary for backends which use terminal
 *              databases, since they can't be expected to make up the
 *              necessary control sequences for themselves.)
 */

#define ECCF_SET 1u
static void env_colour_caps(unsigned *caps_inout, unsigned f)
{
  const char *p;
  unsigned caps = *caps_inout, mask;

  p = getenv("FORCE_COLOR"); if (!p) return;
  switch (*p) {
    case '0':
      mask = 0;
      break;
    case '1':
      mask = TTACF_FG | TTACF_BG | TTACF_1BPC | TTACF_1BPCBR;
      break;
    case '2':
      mask = TTACF_FG | TTACF_BG |
             TTACF_1BPC | TTACF_1BPCBR | TTACF_6LPC | TTACF_24LGS;
      break;
    case '3':
      mask = TTACF_FG | TTACF_BG |
             TTACF_1BPC | TTACF_1BPCBR | TTACF_8BPC;
      break;
    default:
      return;
  }
  if (!(f&ECCF_SET)) caps &= mask;
  else caps = (caps&~(TTACF_CSPCMASK | TTACF_FG | TTACF_BG)) | mask;

  *caps_inout = caps;
}

/* --- @clamp_colours@ --- *
 *
 * Arguments:   @uint32 *space_out, *colour_out@ = selected space and colour
 *              @uint32 space, colour@ = requested space and colour
 *              @uint32 acaps@ = terminal's attribute capability mask
 *
 * Returns:     ---
 *
 * Use:         Select the best approximation to the requested colour which
 *              can be accommodated by the terminal.
 */

/* #define DEBUG_CLAMP */

static void clamp_colours(uint32 *space_out, uint32 *colour_out,
                          uint32 space, uint32 colour, uint32 acaps)
{
  unsigned r, g, b, rr, gg, bb, y, t, u;
  uint32 best_colour = 0, best_space; int best_error;

#ifdef DEBUG_CLAMP
#  define D(x) x
#else
#  define D(x)
#endif

  /* Check the colour space.  If it's one that the terminal can handle, then
   * return the colour unchanged.  Otherwise, extract the channel components
   * for the next step.
   */
  switch (space) {

    case TTCSPC_NONE:
      /* No colour wanted at all.  There's nothing to do here. */

      *space_out = TTCSPC_NONE; *colour_out = 0;
      return;

    case TTCSPC_1BPC:
      /* One-bit-per-channel colour.
       *
       * There's no standardized mapping for these; indeed, they're commonly
       * configurable by users.  Since there are also `bright' versions of
       * each, it's probably not right to just map zero to zero and one to
       * full-scale.
       */

      if (colour >= 8) goto inval;
      if (acaps&(TTACF_1BPC | TTACF_1BPCBR))
        { *space_out = TTCSPC_1BPC; *colour_out = colour; return; }

#define C1BPC_FULL 0xcc
#define C1BPC_CVT(col, bit)                                             \
        (C1BPC_FULL&((((col)&(1 << (bit))) << (8 - (bit))) - 1))
      r = C1BPC_CVT(colour, 0);
      g = C1BPC_CVT(colour, 1);
      b = C1BPC_CVT(colour, 2);
      break;

    case TTCSPC_1BPCBR:
      /* One-bit-per-channel colour, with global brightness.  Again, there's
       * no standardized mapping.  Apply a boost across all three channels.
       */

      if (colour >= 16) goto inval;
      if (!(colour&TT1BPC_BRI) && (acaps&(TTACF_1BPC | TTACF_1BPCBR)))
        { *space_out = TTCSPC_1BPC; *colour_out = colour; return; }
      else if (acaps&TTACF_1BPCBR)
        { *space_out = TTCSPC_1BPCBR; *colour_out = colour; return; }

#define C1BPC_BRIGHT 0x33
      r = C1BPC_CVT(colour, 0) + C1BPC_BRIGHT;
      g = C1BPC_CVT(colour, 1) + C1BPC_BRIGHT;
      b = C1BPC_CVT(colour, 2) + C1BPC_BRIGHT;
#undef C1BPC_CVT
      break;

    case TTCSPC_4LPC:
      /* Four-levels-per-channel colour.  These are part of an `indexed'
       * colour space which is theoretically controlled by applications but
       * (a) that's rare, and (b) worrying about that won't do us any good.
       *
       * Each channel has four levels, but they're not assigned linearly.
       */

      if (colour >= 64) goto inval;
      if (acaps&TTACF_4LPC)
        { *space_out = TTCSPC_4LPC; *colour_out = colour; return; }

#define C4LPC_L0 0
#define C4LPC_L1 139
#define C4LPC_L2 205
#define C4LPC_L3 255
#define C4LPC_CVT(ch) (t = (ch), t == 0 ? C4LPC_L0 :                    \
                                 t == 1 ? C4LPC_L1 :                    \
                                 t == 2 ? C4LPC_L2 :                    \
                                          C4LPC_L3)
      r = C4LPC_CVT(TTCOL_2BR(colour));
      g = C4LPC_CVT(TTCOL_2BG(colour));
      b = C4LPC_CVT(TTCOL_2BB(colour));
#undef C4LPC_CVT
      break;

    case TTCSPC_8LGS:
      /* Eight-levels greyscale.  Again, these are part of an `indexed'
       * colour space which is under application control, and, again, the
       * levels aren't linear, but they're not far off linear.
       */
      if (colour >= 8) goto inval;
      if (acaps&TTACF_8LGS)
        { *space_out = TTCSPC_8LGS; *colour_out = colour; return; }

      r = g = b = 255*(colour ? colour + 3 : 2)/11;
      break;

    case TTCSPC_6LPC:
      /* Six-levels-per-channel colour.  Again, `indexed' colour space under
       * application control.  This time the mapping is essentially liner.
       */

      if (colour >= 216) goto inval;
      if (acaps&TTACF_6LPC)
        { *space_out = TTCSPC_6LPC; *colour_out = colour; return; }

#define C6LPC_CVT(ch) (t = (ch), t ? (40*t + 55) : 0)
      r = C6LPC_CVT(TTCOL_6LR(colour));
      g = C6LPC_CVT(TTCOL_6LG(colour));
      b = C6LPC_CVT(TTCOL_6LB(colour));
#undef C6LPC_CVT
      break;

    case TTCSPC_24LGS:
      /* Twenty-four-levels greyscale.  Same story. */

      if (colour >= 24) goto inval;
      if (acaps&TTACF_24LGS)
        { *space_out = TTCSPC_24LGS; *colour_out = colour; return; }

      r = g = b = 10*colour + 8;
      break;

    case TTCSPC_8BPC:
      /* Eight-bits-per-channel colour.  No conversion to apply here. */

      if (colour >= 0x01000000) goto inval;
      if (acaps&TTACF_8BPC)
        { *space_out = TTCSPC_8BPC; *colour_out = colour; return; }

      r = TTCOL_8BR(colour); g = TTCOL_8BG(colour); b = TTCOL_8BB(colour);
      break;

    default:
      /* Anything else. */

      goto inval;
  }

  /* We didn't get an exact match, so we'll have to make do with what we've
   * got.
   */
  best_error = -1; best_space = TTCSPC_NONE; best_colour = 0;
  D( fprintf(stderr, "\n;; APPROX space %u, colour 0x%lx = %u/%u/%u\n",
             space, (unsigned long)colour, r, g, b); )

  /* Approximate colour weightings for human colour vision. */
#define RWT 2
#define GWT 4
#define BWT 1
#define TOTWT (RWT + GWT + BWT)

  /* Determine the optimal grey approximation for this colour. */
  y = (RWT*r + GWT*g + BWT*b + TOTWT/2)/TOTWT;

#define TRY_APPROX(rr, gg, bb, spc, clr) do {                           \
  /* If the approximation (RR, GG, BB) is closer to the current best    \
   * then accept SPC and CLR as the new best space/colour option.       \
   */                                                                   \
                                                                        \
  int _r_err = (rr) - r, _g_err = (gg) - g, _b_err = (bb) - b;          \
  int _err;                                                             \
                                                                        \
  if (_r_err < 0) _r_err = -_r_err;                                     \
  if (_g_err < 0) _g_err = -_g_err;                                     \
  if (_b_err < 0) _b_err = -_b_err;                                     \
                                                                        \
  _err = RWT*_r_err + GWT*_g_err + BWT*_b_err;                          \
  D( fprintf(stderr,                                                    \
             ";;   candidate space %u, colour 0x%lx = %u/%u/%u; "       \
                  "error = %d\n",                                       \
             (spc), (unsigned long)(clr), (rr), (gg), (bb), _err); )    \
  if (best_error < 0 || _err < best_error) {                            \
    best_error = _err; best_space = (spc); best_colour = (clr);         \
    D( fprintf(stderr, ";;\tNEW BEST APPROXIMATION\n"); )               \
  }                                                                     \
} while (0)

  if (!(acaps&(TTACF_4LPC | TTACF_6LPC | TTACF_8BPC))) {
    /* The one-bit-per-channel colours are very variable, but there's little
     * choice, so we'll have to try.  We assume the same mapping as on the
     * way in.
     */

    if (acaps&(TTACF_1BPC | TTACF_1BPCBR)) {
      /* One-bit-per-channel colour. */

#define C1BPC_APPROX(cc, c, bit) do {                                   \
      if ((c) <= C1BPC_FULL/2) (cc) = 0;                                \
      else { (cc) = C1BPC_FULL; t |= (bit); }                           \
} while (0)
      t = 0;
      C1BPC_APPROX(rr, r, TT1BPC_RED);
      C1BPC_APPROX(gg, g, TT1BPC_GRN);
      C1BPC_APPROX(bb, b, TT1BPC_BLU);
#undef C1BPC_APPROX
      TRY_APPROX(rr, gg, bb, TTCSPC_1BPC, t);
    }

    if (acaps&TTACF_1BPCBR) {
      /* One-bit-per-channel colour, with global brightness. */

#define C1BPCBR_APPROX(cc, c, bit) do {                                 \
      if ((c) <= C1BPC_FULL/2 + C1BPC_BRIGHT) (cc) = C1BPC_BRIGHT;      \
      else { (cc) = 255; t |= (bit); }                                  \
} while (0)
      t = TT1BPC_BRI;
      C1BPCBR_APPROX(rr, r, TT1BPC_RED);
      C1BPCBR_APPROX(gg, g, TT1BPC_GRN);
      C1BPCBR_APPROX(bb, b, TT1BPC_BLU);
#undef C1BPCBR_APPROX
      TRY_APPROX(rr, gg, bb, TTCSPC_1BPCBR, t);
    }
  }

  if (acaps&TTACF_4LPC) {
    /* Four-levels-per-channel colour. */

#define C4LPC_APPROX(cc, c, sh) do {                                    \
    unsigned _c = (c);                                                  \
                                                                        \
    if (_c > (C4LPC_L2 + C4LPC_L3)/2)                                   \
      { (cc) = C4LPC_L3; t |= 3 << (sh); }                              \
    else if (_c > (C4LPC_L1 + C4LPC_L2)/2)                              \
      { (cc) = C4LPC_L2; t |= 2 << (sh); }                              \
    else if (_c > (C4LPC_L0 + C4LPC_L1)/2)                              \
      { (cc) = C4LPC_L1; t |= 1 << (sh); }                              \
    else                                                                \
      (cc) = C4LPC_L0;                                                  \
} while (0)
    t = 0;
    C4LPC_APPROX(rr, r, 4);
    C4LPC_APPROX(gg, g, 2);
    C4LPC_APPROX(bb, b, 0);
#undef C4LPC_APPROX
    TRY_APPROX(rr, gg, bb, TTCSPC_4LPC, t);
  }

  if (acaps&TTACF_8LGS) {
    /* Eight-levels greyscale. */

    u = (11*y)/255;
    if (u <= 2) { u = 2; t = 0; }
    else if (u == 3) { u = 4; t = 1; }
    else if (u == 11) { u = 10; t = 7; }
    else t = u - 3;
    u = (255*u)/11; TRY_APPROX(u, u, u, TTCSPC_8LGS, t);
  }

  if (acaps&TTACF_6LPC) {
    /* Six-levels-per-channel colour. */

#define C6LPC_APPROX(cc, c, f) do {                                     \
    unsigned _c = (c);                                                  \
                                                                        \
    if (_c < 36) (cc) = 0;                                              \
    else { u = (_c - 36)/40; t += (f)*u; (cc) = 40*u + 55; }            \
} while (0)
    t = 0;
    C6LPC_APPROX(rr, r, 36);
    C6LPC_APPROX(gg, g,  6);
    C6LPC_APPROX(bb, b,  1);
#undef C6LPC_APPROX
    TRY_APPROX(rr, gg, bb, TTCSPC_6LPC, t);
  }

  if (acaps&TTACF_24LGS) {
    /* Twenty-four-levels greyscale. */

    if (y < 3) { t = 0; u = 8; }
    else if (y >= 243) { t = 23; u = 238; }
    else { t = (y - 3)/10; u = 10*t + 8; }
    TRY_APPROX(u, u, u, TTCSPC_24LGS, t);
  }

  if (acaps&TTACF_8BPC) {
    /* Eight-bits-per-channel colour. */

    if (best_error) {
      D( fprintf(stderr, ";;   accept exact 8bpc colour\n"); )
      best_error = 0; best_space = TTCSPC_8BPC;
      best_colour = TTCOL_MK8B(r, g, b);
    }
  }

  /* Done. */
  *space_out = best_space; *colour_out = best_colour;
  return;

inval:
  /* Invalid colour selection.  Ignore this. */
  *space_out = TTCSPC_NONE; *colour_out = 0;

#undef C1BPC_FULL
#undef C1BPC_BRIGHT

#undef C4LPC_L0
#undef C4LPC_L1
#undef C4LPC_L2
#undef C4LPC_L3

#undef TRY_APPROX
#undef TRY_RGB
#undef TRY_GREY

#undef RWT
#undef GWT
#undef BWT
#undef TOTWT

#undef SET_RANGE
#undef CHECK_RANGE

#undef D
}

/* --- @clamp_attr@ --- *
 *
 * Arguments:   @struct tty_attr *a_out@ = selected attributes
 *              @const struct tty_attr *a@ = requested attributes
 *              @uint32 acaps@ = terminal's attribute capability mask
 *
 * Returns:     ---
 *
 * Use:         Select the closest approximation to the requested attributes
 *              which can be accommodated by the terminal.
 */

static void clamp_attr(struct tty_attr *a_out,
                       const struct tty_attr *a, uint32 acaps)
{
  uint32 ff = 0, f = a ? a->f : 0, t;

  /* Line attributes. */
  t = (f&TTAF_LNMASK) >> TTAF_LNSHIFT;
  switch (t) {
    case TTLN_NONE:
      break;
    case TTLN_ULINE:
      if (!acaps&TTACF_ULINE) t = TTLN_NONE;
      break;
    case TTLN_UULINE:
      if (acaps&TTACF_UULINE) ;
      else if (acaps&TTACF_ULINE) t = TTLN_ULINE;
      else t = TTLN_NONE;
      break;
    default:
      t = TTLN_NONE;
  }
  ff |= t << TTAF_LNSHIFT;

  /* Text weight. */
  t = (f&TTAF_WTMASK) >> TTAF_WTSHIFT;
  switch (t) {
    case TTWT_MED: break;
    case TTWT_BOLD: if (!(acaps&TTACF_BOLD)) t = TTWT_MED; break;
    case TTWT_DIM: if (!(acaps&TTACF_DIM)) t = TTWT_MED; break;
    default: t = TTWT_MED; break;
  }
  ff |= t << TTAF_WTSHIFT;

  /* Other text attributes. */
  if (acaps&TTACF_STRIKE) ff |= f&TTAF_STRIKE;
  if (acaps&TTACF_ITAL) ff |= f&TTAF_ITAL;
  if (acaps&TTACF_INVV) ff |= f&TTAF_INVV;

  /* Foreground and background colours. */
  if (!(acaps&TTACF_FG))
    a_out->fg = 0;
  else {
    clamp_colours(&t, &a_out->fg,
                  (f&TTAF_FGSPCMASK) >> TTAF_FGSPCSHIFT, a ? a->fg : 0,
                  acaps);
    ff |= t << TTAF_FGSPCSHIFT;
  }
  if (!(acaps&TTACF_BG))
    a_out->bg = 0;
  else {
    clamp_colours(&t, &a_out->bg,
                  (f&TTAF_BGSPCMASK) >> TTAF_BGSPCSHIFT, a ? a->bg : 0,
                  acaps);
    ff |= t << TTAF_BGSPCSHIFT;
  }

  /* All done. */
  a_out->f = ff; a_out->_res0 = 0;
}

/* --- @stupid_repeat@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @int ch@ = character to write
 *              @unsigned n@ = number of copies
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Write @n@ copies of the character @ch@ to the terminal, the
 *              hard way.  This function tries to be reasonably efficient, by
 *              transmitting buffers rather than exercising the output
 *              machinery for each individual character.
 */

static int stupid_repeat(struct tty *tty,
                         const struct gprintf_ops *gops, void *go,
                         int ch, unsigned n)
{
  char buf[4096];
  unsigned nn;
  int rc;

  if (n < sizeof(buf))
    { memset(buf, ch, n); CHECK(gops->putm(go, buf, n)); }
  else {
    memset(buf, ch, sizeof(buf));
    nn = sizeof(buf);
    for (;;) {
      CHECK(gops->putm(go, buf, nn));
      n -= nn; if (!n) break;
      if (n < nn) nn = n;
    }
  }
  rc = 0;
end:
  return (rc);
}

/*----- Common machinery for %|termcap|% and %|terminfo|% -----------------*/

#if defined(HAVE_TERMINFO) ||                                           \
    defined(HAVE_TERMCAP) ||                                            \
    defined(HAVE_UNIBILIUM)

#if defined(HAVE_TERMINFO) || defined(HAVE_TERMCAP)

/* Global state.
 *
 * The `termcap' and `terminfo' functions call a user-provided function to
 * actually send control codes to the terminal.  The bad news is that
 * `termcap' doesn't provide any way to pass information to the output
 * function beyond the character to be sent, and `terminfo' doesn't fix this
 * mistake.  So we must save the necessary context as global variables.  For
 * good measure, at least some implementations ignore errors from the output
 * function, so we must keep track of them ourselves.  More global variables.
 *
 * It's worse.  Both libraries maintain significant global state of their
 * own.  And, at least with the `ncurses' implementation, the two share the
 * same global state.  The only thing to do is maintain a big interlock to
 * make sure that only one is active at a time.
 */
static const struct gprintf_ops *global_gops; /* output operations ... */
static void *global_gout;               /* and context, for @caps_putch */
static char global_buf[BUFSZ];          /* a big output buffer */
static size_t global_len;               /* length of buffer used */
static int global_err;                  /* error latch, zero if all ok */
static struct tty *global_lock = 0;     /* interlock for global state */

/* --- @caps_claim@ --- *
 *
 * Arguments:   ---
 *
 * Returns:     Zero on success, %$-1$% if already claimed.
 *
 * Use:         Return %$-1$% if the interlock is already held.  This is a
 *              function to call near the beginning of initializing a new
 *              control block, before the common global state gets
 *              clobbered.  If initialization is successful, the caller is
 *              expected to actually store the control block pointer in
 *              @global_lock@ themselves.
 */

static int caps_claim(void)
{
  if (global_lock)
    { debug("termcap/terminfo terminal already open"); return (-1); }
  else
    return (0);
}

/* --- @caps_release@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer for current lock
 *                      holder
 *
 * Returns:     ---
 *
 * Use:         Release the lock.
 */

static void caps_release(struct tty *tty)
  { assert(global_lock == tty); global_lock = 0; }

/* --- @caps_prepout@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer (ignored)
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *
 * Returns:     ---
 *
 * Use:         Prepare output to the given destination.  Check that the
 *              output buffer is initially empty (i.e., that it was properly
 *              flushed last time), and make a note of the output
 *              destination.
 */

static void caps_prepout(struct tty *tty,
                         const struct gprintf_ops *gops, void *go)
  { assert(!global_len); global_gops = gops; global_gout = go; }

/* --- @caps_putch@ --- *
 *
 * Arguments:   @int ch@ = character to write
 *
 * Returns:     Nonnegative on success, negative on failure.  (But @tputs@
 *              ignores this.)
 *
 * Use:         Output the character @ch@.
 */

static int caps_putch(int ch)
{
  size_t n;

  /* By policy, we flush the buffer as soon as it becomes full, so there
   * should always be space for at least one byte.
   */
  n = global_len; assert(n < BUFSZ);
  global_buf[n++] = ch;

  /* If the buffer is now full, then flush it. */
  if (n >= BUFSZ) {
    if (global_gops->putm(global_gout, global_buf, n)) global_err = -1;
    n = 0;
  }

  /* Done. */
  global_len = n; return (0);
}

/* --- @caps_flush@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer (ignored)
 *
 * Returns:     Zero for success, %$-1$% if error pending.
 *
 * Use:         Flush the output buffer to the backend.  If an error is
 *              pending, clear it and return failure.
 */

static int caps_flush(struct tty *tty)
{
  int rc = global_err;

  if (global_len) {
    if (global_gops->putm(global_gout, global_buf, global_len)) rc = -1;
    global_len = 0;
  }
  global_err = 0; return (rc);
}

#endif

/* The list of interesting capabilities.
 *
 * We never actually need all of these: some are only needed if others are
 * unavailable.  But the list isn't too huge, so we'll live with it.
 *
 * The main thing is that each capability has three different names: the
 * `full' name (corresponding to a `terminfo' variable name), the `terminfo'
 * capability name, as used in terminal descriptions, and the two-character
 * `termcap' name.  Unibilium uses the long names, but to reduce typing, the
 * `unibi_' prefix is omitted here.  (Annoyingly, in `ncurses', at least, the
 * `variable' names are `secretly' macros referencing a current state, and
 * premature expansion causes misery, so I've left the leading underscores in
 * place as a countermeasure.)  Internally, we use the short `terminfo'
 * names, since they generally express the most useful information in the
 * smallest space.
 */

#define BASICCAPS(_bool, _int, _str)                                    \
  _str(_repeat_char, rep, rp)                                           \
  _str(_pad_char, pad, pc) _int(_padding_baud_rate, pb, pb)             \
  _bool(_no_pad_char, npc, NP) _bool(_xon_xoff, xon, xo)                \
  _bool(_move_insert_mode, mir, mi) _bool(_move_standout_mode, msgr, ms)

#define ATTRCAPS(_bool, _int, _str)                                     \
  _str(_exit_attribute_mode, sgr0, me)                                  \
  _str(_enter_underline_mode, smul, us)                                 \
    _str(_exit_underline_mode, rmul, ue)                                \
  _str(_enter_italics_mode, sitm, ZH) _str(_exit_italics_mode, ritm, ZR) \
  _str(_enter_bold_mode, bold, md) _str(_enter_dim_mode, dim, mh)       \
  _str(_enter_reverse_mode, rev, mr)                                    \
  COLOURCAPS(_bool, _int, _str)

#define COLOURCAPS(_bool, _int, _str)                                   \
  _str(_set_a_foreground, setaf, AF) _str(_set_a_background, setab, AB) \
  _str(_orig_pair, op, op) _int(_max_colors, colors, Co)

#define MODECAPS(_bool, _int, _str)                                     \
  _str(_carriage_return, cr, cr) _str(_newline, nel, nw)                \
  _str(_enter_am_mode, smam, SA) _str(_exit_am_mode, rmam, RA)          \
  _str(_enter_ca_mode, smcup, ti) _str(_exit_ca_mode, rmcup, te)        \
  _str(_cursor_normal, cnorm, vs) _str(_cursor_invisible, civis, vi)    \
  _str(_enter_insert_mode, smir, im) _str(_exit_insert_mode, rmir, ei)  \
  _str(_enter_delete_mode, smdc, dm) _str(_exit_delete_mode, rmdc, ed)

#define MOVECAPS(_bool, _int, _str)                                     \
  _str(_cursor_home, home, ho)                                          \
  _str(_cursor_address, cup, cm)                                        \
  _str(_row_address, vpa, cv) _str(_column_address, hpa, ch)            \
  _str(_cursor_left, cub1, le) _str(_parm_left_cursor, cub, LE)         \
  _str(_cursor_right, cuf1, nd) _str(_parm_right_cursor, cuf, RI)       \
  _str(_cursor_up, cuu1, up) _str(_parm_up_cursor, cuu, UP)             \
  _str(_cursor_down, cud1, do) _str(_parm_down_cursor, cud, DO)

#define SCROLLCAPS(_bool, _int, _str)                                   \
  _str(_change_scroll_region, csr, cs)                                  \
  _str(_scroll_forward, ind, sf) _str(_parm_index, indn, SF)            \
  _str(_scroll_reverse, ri, sr) _str(_parm_rindex, rin, SR)

#define ERASECAPS(_bool, _int, _str)                                    \
  _str(_erase_chars, ech, ec)                                           \
  _str(_clr_bol, el1, cb) _str(_clr_eol, el, ce)                        \
  _str(_clr_eos, ed, cd) _str(_clear_screen, clear, cl)

#define INSDELCAPS(_bool, _int, _str)                                   \
  _str(_insert_character, ich1, ic) _str(_parm_ich, ich, IC)            \
  _str(_insert_padding, ip, ip)                                         \
  _str(_insert_line, il1, al) _str(_parm_insert_line, il, AL)           \
  _str(_delete_character, dch1, dc) _str(_parm_dch, dch, DC)            \
  _str(_delete_line, dl1, dl) _str(_parm_delete_line, dl, DL)

#define STORECAPS(_bool, _int, _str)                                    \
  BASICCAPS(_bool, _int, _str)                                          \
  ATTRCAPS(_bool, _int, _str)                                           \
  MODECAPS(_bool, _int, _str)                                           \
  MOVECAPS(_bool, _int, _str)                                           \
  SCROLLCAPS(_bool, _int, _str)                                         \
  ERASECAPS(_bool, _int, _str)                                          \
  INSDELCAPS(_bool, _int, _str)

#ifdef HAVE_UNIBILIUM
#  define UNIBI_(x) unibi##x
#else
#  define UNIBI_(x) 0
#endif

#define CAPREF(var, info, cap) UNIBI_(var), #info, #cap
  /* Expand a capability triple into a group of three usable C arguments.  If
   * Unibilium isn't available, then we can use nonsense for its cap index.
   */

/* Some other capabilities which we want to refer to during initialization,
 * but don't need to keep around.
 */
#define CAP_XMC CAPREF(_magic_cookie_glitch, xmc, sg)
#define CAP_BCE CAPREF(_back_color_erase, bce, ut)
#define CAP_XHPA CAPREF(_row_addr_glitch, xvpa, YD)
#define CAP_XVPA CAPREF(_col_addr_glitch, xhpa, YA)
#define CAP_AM CAPREF(_auto_right_margin, am, am)
#define CAP_XENL CAPREF(_eat_newline_glitch, xenl, xn)
#define CAP_HT CAPREF(_lines, lines, li)
#define CAP_WD CAPREF(_columns, cols, co)

/* Additional operations required of terminal backends which make use of the
 * common capability machinery.
 */
struct tty_capopslots {

  /* Retrieving capabilities. */
  int (*boolcap)(struct tty */*tty*/,
                 int /*uix*/, const char */*info*/, const char */*cap*/);
  int (*intcap)(struct tty */*tty*/,
                int /*uix*/, const char */*info*/, const char */*cap*/);
  const char *(*strcap)(struct tty */*tty*/,
                        int /*uix*/, const char */*info*/,
                        const char */*cap*/);

  /* Preparing and completing output. */
  void (*prepout)(struct tty */*tty*/,
                  const struct gprintf_ops */*gops*/, void */*go*/);
  int (*flush)(struct tty */*tty*/);

  /* Writing capabilities with various kinds of arguments. */
  int (*put0)(struct tty */*tty*/, unsigned /*npad*/, const char */*cap*/);
  int (*put1i)(struct tty */*tty*/,
               unsigned /*npad*/, const char */*cap*/, int /*i0*/);
  int (*put2i)(struct tty */*tty*/,
               unsigned /*npad*/,
               const char */*cap*/, int /*i0*/, int /*i1*/);

  /* Determine the cost of a capability. */
  size_t (*cost)(struct tty */*tty*/,
                 unsigned /*npad*/, const char */*cap*/, int /*i0*/);
};
#define TTY_CAPOPSPFX TTY_BASEOPSPFX; struct tty_capopslots cap
struct tty_capops { TTY_CAPOPSPFX; };
#define TTY_CAPOPSUSFX struct tty_capops cap; TTY_BASEOPSUXFX
union tty_capopsu { TTY_CAPOPSUSFX; };

/* An extension of the control block to track the above capabilities. */
struct tty_capslots {
#define DEF_BOOLCAP(uix, info, cap) unsigned info : 1;
#define DEF_INTCAP(uix, info, cap) int info;
#define DEF_STRCAP(uix, info, cap) const char *info;
  STORECAPS(DEF_BOOLCAP, DEF_INTCAP, DEF_STRCAP)
#undef DEF_BOOLCAP
#undef DEF_INTCAP
#undef DEF_STRCAP
#define LEN_BOOLCAP(uix, info, cap)
#define LEN_INTCAP(uix, info, cap)
#define LEN_STRCAP(uix, info, cap) unsigned info##_cost;
    ATTRCAPS(LEN_BOOLCAP, LEN_INTCAP, LEN_STRCAP)
#undef LEN_BOOLCAP
#undef LEN_INTCAP
#undef LEN_STRCAP
};
#define TTY_CAPSPFX                                                     \
  struct tty tty;                                                       \
  struct tty_capslots cap
struct tty_caps { TTY_CAPSPFX; };
#define TTY_CAPSUSFX                                                    \
  struct tty_caps cap;                                                  \
  struct tty tty
union tty_capsu { TTY_CAPSUSFX; };

/* ---- @init_caps@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *
 * Returns:     ---
 *
 * Use:         Populate the capabilities in the terminal control block, and
 *              advertise the results to the public part.  Set @ht@ and @wd@
 *              from the terminal description if they've not been set
 *              already.
 */

static void init_caps(struct tty_caps *t)
{
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int wd, ht;

  t->tty.acaps = t->tty.ocaps = 0;
  t->tty.st.modes = 0; t->tty.st.attr.f = 0;
  t->tty.st.attr.fg = t->tty.st.attr.bg = 0;

  /* Inhale all of the interesting terminal capabilities. */
#define GETBOOL(var, info, cap_)                                        \
    t->cap.info = ops->cap.boolcap(&t->tty, CAPREF(var, info, cap_));
#define GETINT(var, info, cap_)                                         \
    t->cap.info = ops->cap.intcap(&t->tty, CAPREF(var, info, cap_));
#define GETSTR(var, info, cap_)                                         \
    t->cap.info = ops->cap.strcap(&t->tty, CAPREF(var, info, cap_));
  STORECAPS(GETBOOL, GETINT, GETSTR)
#undef GETBOOL
#undef GETINT
#undef GETSTR

#define COST_BOOLCAP(uix, info, cap_)
#define COST_INTCAP(uix, info, cap_)
#define COST_STRCAP(uix, info, cap_)                                    \
    t->cap.info##_cost =                                                \
      ops->cap.cost(&t->tty, 1, t->cap.info, t->cap.colors - 1);
  ATTRCAPS(COST_BOOLCAP, COST_INTCAP, COST_STRCAP)
#undef COST_BOOLCAP
#undef COST_INTCAP
#undef COST_STRCAP

#define CLEAR_BOOL(uix, info, cap_) t->cap.info = 0;
#define CLEAR_INT(uix, info, cap_) t->cap.info = 0;
#define CLEAR_STR(uix, info, cap_) t->cap.info = 0;
#define CLEARCAPS(caplist)                                              \
    do { caplist(CLEAR_BOOL, CLEAR_INT, CLEAR_STR) } while (0)

  /* Basic capabilities. */
  if (!t->cap.cr) t->cap.cr = "\r";
  if (!t->cap.nel) t->cap.nel = "\r\n";

  /* Attribute capabilities. */
  if (ops->cap.intcap(&t->tty, CAP_XMC) > 0)
    CLEARCAPS(ATTRCAPS);
  else {
    if (t->cap.smul && (t->cap.rmul || t->cap.sgr0))
      t->tty.acaps |= TTACF_ULINE;
    if (t->cap.bold && t->cap.sgr0)
      t->tty.acaps |= TTACF_BOLD;
    if (t->cap.dim && t->cap.sgr0)
      t->tty.acaps |= TTACF_DIM;
    if (t->cap.sitm && (t->cap.ritm || t->cap.sgr0))
      t->tty.acaps |= TTACF_ITAL;
    if (t->cap.rev && t->cap.sgr0)
      t->tty.acaps |= TTACF_INVV;

    if ((t->cap.setaf || t->cap.setab) && (t->cap.op || t->cap.sgr0)) {
      if (t->cap.setaf) t->tty.acaps |= TTACF_FG;
      if (t->cap.setab) t->tty.acaps |= TTACF_BG;
      t->tty.acaps |= TTACF_1BPC;
      if (t->cap.colors >= 16777216)
        t->tty.acaps |= TTACF_1BPC | TTACF_8BPC;
      else if (t->cap.colors >= 256)
        t->tty.acaps |= TTACF_1BPCBR | TTACF_6LPC | TTACF_24LGS;
      else if (t->cap.colors == 88)
        t->tty.acaps |= TTACF_1BPCBR | TTACF_4LPC | TTACF_8LGS;
      else if (t->cap.colors >= 16)
        t->tty.acaps |= TTACF_1BPCBR;
      if (ops->cap.boolcap(&t->tty, CAP_BCE)) t->tty.ocaps |= TTCF_BGER;
      env_colour_caps(&t->tty.acaps, 0);
    }
  }

  /* Motion capabilities. */
  if (ops->cap.boolcap(&t->tty, CAP_XHPA)) t->cap.hpa = 0;
  if (ops->cap.boolcap(&t->tty, CAP_XVPA)) t->cap.vpa = 0;
  if (!t->cap.cub1) t->cap.cub1 = "\b";
  if ((t->cap.cuf || t->cap.cuf1) &&
      (t->cap.cuu || t->cap.cuu1) &&
      (t->cap.cud || t->cap.cud1)) {
    t->tty.ocaps |= TTCF_RELMV;
    if (t->cap.vpa) t->tty.ocaps |= TTCF_ABSMV | TTCF_MIXMV;
    else if (t->cap.home) t->tty.ocaps |= TTCF_ABSMV;
  } else if (t->cap.cup ||
             (t->cap.hpa && t->cap.vpa) ||
             (t->cap.home && (t->cap.cuf || t->cap.cuf1)))
    t->tty.ocaps |= TTCF_ABSMV;

  /* Mode capabilities. */
  if (t->cap.smam && t->cap.rmam) t->tty.ocaps |= TTMF_AUTOM;
  if (t->cap.smcup && t->cap.rmcup) t->tty.ocaps |= TTMF_FSCRN;
  if (t->cap.smir && t->cap.rmir) t->tty.ocaps |= TTMF_INS;
  if (t->cap.smdc && t->cap.rmdc) t->tty.ocaps |= TTMF_DEL;
  if (t->cap.cnorm && t->cap.civis)
    { t->tty.ocaps |= TTMF_CVIS; t->tty.st.modes |= TTMF_CVIS; }
  if (ops->cap.boolcap(&t->tty, CAP_AM)) {
    t->tty.st.modes |= TTMF_AUTOM;
    if (ops->cap.boolcap(&t->tty, CAP_XENL)) t->tty.ocaps |= TTCF_MMARG;
  }

  /* Erasure. */
  if (t->cap.ech) t->tty.ocaps |= TTCF_ERCH;
  if (t->cap.el1) t->tty.ocaps |= TTCF_ERBOL;
  if (t->cap.el) t->tty.ocaps |= TTCF_EREOL;
  if (t->cap.ed) t->tty.ocaps |= TTCF_EREOD;
  if (t->cap.clear || (t->cap.ed && t->cap.home)) t->tty.ocaps |= TTCF_ERDSP;

  /* Insertion and deletion. */
  if (t->cap.ich || t->cap.ich1) t->tty.ocaps |= TTCF_INSCH;
  if (t->cap.il || t->cap.il1) t->tty.ocaps |= TTCF_INSLN;
  if (t->cap.dch || t->cap.dch1) t->tty.ocaps |= TTCF_DELCH;
  if (t->cap.dl || t->cap.dl1) t->tty.ocaps |= TTCF_DELLN;

  /* Geometry. */
  if (!t->tty.wd)
    { wd = ops->cap.intcap(&t->tty, CAP_WD); if (wd > 0) t->tty.wd = wd; }
  if (!t->tty.ht)
    { ht = ops->cap.intcap(&t->tty, CAP_HT); if (ht > 0) t->tty.ht = ht; }

#undef CLEAR_BOOL
#undef CLEAR_INT
#undef CLEAR_STR
#undef CLEARCAPS
}

/* --- @caps_padchars@ --- *
 *
 * Arguments:   @struct tty *tty@ = extended control block pointer
 *              @unsigned delay@ = tenths of milliseconds required
 *              @unsigned f@ = flags
 *
 * Returns:     The number of padding characters to send.
 *
 * Use:         Determine the number of padding characters to send to achieve
 *              a delay of a given duration.  If @CPF_FORCE@ is set, then
 *              ignore the @pb@ and @xon@ capabilities.
 */

#define CPF_FORCE 1u
static size_t caps_padchars(struct tty *tty, unsigned delay, unsigned f)
{
  struct tty_caps *t = (struct tty_caps *)tty;

  if (!(f&CPF_FORCE) && (t->tty.baud < t->cap.pb || t->cap.xon)) {
    /* We're not forced to pad, and the baud rate is sufficiently low or we
     * have flow control, then there's nothing to do.
     */

    return (0);
  } else {
    /* We're transmitting at R b/s, and we want to send N B of data so that
     * this takes D/10000 s.  We're likely sending either seven bits with
     * parity or eight bits without, plus one stop bit, per character, so we
     * must send 9 N b, which will take 9 N/R s = D/10000 s.  Rearranging
     * gives
     *
     *         N = R D/90000 ,
     *
     * and we should round upwards.
     */

    return ((unsigned long)t->tty.baud*delay + 89999/90000);
  }
}

#if defined(HAVE_TERMCAP) || defined(HAVE_TERMINFO)

/* --- @caps_cost@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @unsigned npad@ = number of lines affected
 *              @const char *ctrl@ = formatted control string
 *
 * Returns:     A linear `cost' for sending the capability.
 *
 * Use:         Determines the cost for a `termcap' or `terminfo' capability
 *              by parsing a @tputs@-format string.
 */

static unsigned scan_delay(const char **p_inout, unsigned npad)
{
  const char *p = *p_inout;
  unsigned t, f;

#define f_padmul 1u

  f = 0; t = 0;
  while (ISDIGIT(*p)) t = 10*t + (*p++ - '0');
  t *= 10;
  if (*p == '.') {
    p++;
    if (ISDIGIT(*p)) {
      t += *p++ - '0';
      while (ISDIGIT(*p)) p++;
    }
  }
  for (;;)
    switch (*p) {
      case '*': p++; f |= f_padmul; break;
      case '/': p++; break;
      default: goto done;
    }
done:
  if (f&f_padmul) t *= npad;
  *p_inout = p; return (npad);

#undef f_padmul
}

static size_t caps_cost(struct tty *tty, unsigned npad, const char *ctrl)
{
  size_t n;
  unsigned t;
  const char *p;

  p = ctrl;
  if (ISDIGIT(*p)) {
    /* The string starts with a number, so it's a `termcap'-style string with
     * a leading millisecond count.
     */

    t = scan_delay(&p, npad);
    n = strlen(p);
  } else {
    /* No initial number.  Search for `terminfo'-style %|$<NNN.N[*|/]|%
     * droppings.
     */

    n = 0; t = 0;
    while (*p)
      if (*p != '$' || p[1] != '<' || (!ISDIGIT(p[2] && p[2] != '>')))
        { n++; p++; }
      else {
        p += 2; t += scan_delay(&p, npad);
        if (*p == '>') p++;
      }
  }

  /* All done. */
  return (n + caps_padchars(tty, t, CPF_FORCE));
}

#endif

/* Macros for formatting capabilities.  The @...V@ macros evaluate the cap
 * name, while the unmarked macros interpret it as a slot name.
 */
#define PUT0V(npad, cap_)                                               \
  CHECK(ops->cap.put0(&t->tty, (npad), (cap_)))
#define PUT1IV(npad, cap_, i0)                                          \
  CHECK(ops->cap.put1i(&t->tty, (npad), (cap_), (i0)))
#define PUT2IV(npad, cap_, i0, i1)                                      \
  CHECK(ops->cap.put2i(&t->tty, (npad), (cap_), (i0), (i1)))

#define PUT0(npad, name) PUT0V(npad, t->cap.name)
#define PUT1I(npad, name, i0) PUT1IV(npad, t->cap.name, i0)
#define PUT2I(npad, name, i0, i1) PUT2IV(npad, t->cap.name, i0, i1)

/* --- @caps_iterate@ --- *
 *
 * Arguments:   @struct tty_caps *t@ = extended control block pointer
 *              @const char *cap1, *capn@ = capability strings for single and
 *                      multiple operations
 *              @unsigned f@ = flags
 *              @unsigned npad@ = number of lines affected
 *              @unsigned n@ = number of operations to do
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Sends control codes to do some operation @n@ times.
 *
 *              The capability string @cap1@ should do the operation once,
 *              while @capn@ should do it some number of times as requested
 *              by an argument.  The single-operation cap is likely better
 *              for a single use.  Either or both capabilities might be
 *              missing.
 */

#define CIF_PADMUL 1u
static int caps_iterate(struct tty_caps *t,
                        const char *cap1, const char *capn,
                        unsigned f, unsigned npad, unsigned n)
{
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  unsigned max, nn;
  int rc;

  if (cap1 && (n == 1 || !capn))
    while (n--) PUT0V(npad, cap1);
  else {
    max = npad && (f&CIF_PADMUL) ? INT_MAX/npad : INT_MAX;
    while (n) {
      nn = n; if (nn > max) nn = max;
      PUT1IV(npad, capn, nn);
      n -= nn;
    }
  }
  rc = 0;
end:
  return (rc);
}

/* --- @caps_setcolour@ --- *
 *
 * Arguments:   @struct tty_caps *t@ = extended control block pointer
 *              @const char *cap@ = capability string to apply (typically
 *                      %|setaf|% or %|setab|%)
 *              @uint32 spc, clr@ = the colour space and number
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Emit the correct control string to set the foreground or
 *              background colour as indicated.
 */

static int caps_setcolour(struct tty_caps *t,
                          const char *cap, uint32 spc, uint32 clr)
{
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int rc;

  switch (spc) {
    case TTCSPC_1BPC: case TTCSPC_1BPCBR: PUT1IV(0, cap, clr);       break;
    case TTCSPC_4LPC: case TTCSPC_6LPC:   PUT1IV(0, cap, clr +  16); break;
    case TTCSPC_8LGS:                     PUT1IV(0, cap, clr +  80); break;
    case TTCSPC_24LGS:                    PUT1IV(0, cap, clr + 232); break;

    case TTCSPC_8BPC:
      /* There's an unfortunate ambiguity in the %|setaf|% conventions.  The
       * first eight colours should be dark shades of blue, but in fact
       * they're interpreted as the one-bit-per-channel basic colours by
       * common `terminfo' settings.  Notice and kludge by adding a little
       * red.  This will tinge the colour magenta, but all such colours are
       * so dark as to be effectively black anyway, so I doubt that this will
       * be noticeable.
       */
      if (spc == TTCSPC_8BPC && clr < 8) clr += 65536;
      PUT1IV(0, cap, clr); break;

    /* case TTCSPC_NONE: */
    default: rc = -1; goto end;
  }
  rc = 0;
end:
  return (rc);
}

/* --- @caps_setattr_internal@ --- *
 *
 * Arguments:   @struct tty_caps *t@ = extended control block pointer
 *              @const struct tty_attr *a@ = attribute to set, already
 *                      clamped
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Internal version of @caps_setattr@.  Assumes that @prepout@
 *              has already been called, and that @flush@ will be called
 *              later.
 *
 *              This is split out from @caps_setattr@ because it's used
 *              (e.g., by @caps_move@) to restore the capabilities after
 *              moving the cursor on a terminal which doesn't advertise
 *              %|msgr|%.
 */

static int caps_setattr_internal(struct tty_caps *t,
                                 const struct tty_attr *a)
{
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  uint32 diff, m;
  int rc;
  unsigned c, z;

  /* Work out what, if anything, needs doing. */
  diff = a->f ^ t->tty.st.attr.f;

  /* Form a basic strategy.
   *
   * In the general case, we're applying some attributes (say bold face) and
   * cancelling others (say italics).  We likely have a big club for the
   * latter in the form of the %|sgr0|% capability, which cancels all
   * attributes and is likely fairly cheap.  On the other hand, some -- but,
   * infuriatingly, not all -- attributes have a cap string for cancelling
   * them, which may or may not be present.
   *
   * Hence, if we're holding over a lot of attributes from the previous
   * state, and cancelling just a small number, then it's likely better to
   * just cancel the individual attributes which need it, because otherwise
   * we'd have to reapply all of the ones we didn't actually mean to change.
   *
   * Add up the costs of each approach and use the cheaper one.  Of course,
   * if we're forced into one or the other, then we have no choice.
   *
   * One point worth noting is that we don't make use of the general %|sgr|%
   * capability here.  For one thing, %|sgr|% takes nine arguments -- so it
   * can't be used from `termcap'.  But, more importantly, we don't know, in
   * any particular case, what it does to other attributes.
   */
  if (t->cap.sgr0) {

    /* First, add up the costs of cancelling the individual attributes which
     * are no longer wanted.  If we find that we can't cancel one, then skip
     * ahead.
     */
    c = 0;
#define CLEARP(mask) ((diff&(mask)) && !(a->f&(mask)))
#define ADDCOST(cap_) do {                                              \
    if (t->cap.cap_) c += t->cap.cap_##_cost;                           \
    else goto sgr0;                                                     \
} while (0)
    if (CLEARP(TTAF_LNMASK)) ADDCOST(rmul);
    if (CLEARP(TTAF_WTMASK)) goto sgr0;
    if (diff&~a->f&TTAF_INVV) goto sgr0;
    if (diff&~a->f&TTAF_ITAL) ADDCOST(ritm);
    if (CLEARP(TTAF_FGSPCMASK) || CLEARP(TTAF_BGSPCMASK)) ADDCOST(op);
#undef CLEARP
#undef ADDCOST

    /* Now, add up the costs of reapplying all of the attributes which aren't
     * supposed to change.  (Attributes which are changing don't count here
     * because we'll have to fiddle with them anyway.)
     */
    z = 0;
    if (!(diff&TTAF_LNMASK))
      switch ((a->f&TTAF_LNMASK) >> TTAF_LNSHIFT) {
        case TTLN_ULINE: z += t->cap.smul_cost; break;
      }
    if (!(diff&TTAF_WTMASK))
      switch ((a->f&TTAF_WTMASK) >> TTAF_WTSHIFT) {
        case TTWT_BOLD: z += t->cap.bold_cost; break;
        case TTWT_DIM: z += t->cap.dim_cost; break;
      }
    m = a->f&~diff;
    if (m&TTAF_INVV) z += t->cap.rev_cost;
    if (m&TTAF_ITAL) z += t->cap.sitm_cost;
#define COLOURCOST(G, g, cap_) do {                                     \
    if (!(diff&TTAF_##G##SPCMASK) &&                                    \
        (a->f&TTAF_##G##SPCMASK) && a->g == t->tty.st.attr.g)           \
      z += t->cap.cap_##_cost;                                          \
} while (0)
    COLOURCOST(FG, fg, setaf);
    COLOURCOST(BG, bg, setab);
#undef COLOURCOST

    if (z + t->cap.sgr0_cost < c) {
    sgr0:
      /* We've decided to clear everything and start over. */

      PUT0(0, sgr0); diff = a->f; t->tty.st.attr.fg = t->tty.st.attr.bg = 0;
    }
  }

  /* Line style. */
  if (diff&TTAF_LNMASK)
    switch ((a->f&TTAF_LNMASK) >> TTAF_LNSHIFT) {
      case TTLN_NONE: PUT0(0, rmul); break;
      case TTLN_ULINE: PUT0(0, smul); break;
      /* case TTLN_UULINE: */
      /* case TTLN_STRIKE: */
      default: rc = -1; goto end;
    }

  /* Text weight. */
  if (diff&TTAF_WTMASK)
    switch ((a->f&TTAF_WTMASK) >> TTAF_WTSHIFT) {
      /* case TTWT_MED: */
      case TTWT_BOLD: PUT0(0, bold); break;
      case TTWT_DIM: PUT0(0, dim); break;
      default: rc = -1; goto end;
    }

  /* Other text effects. */
  if (diff&a->f&TTAF_INVV) PUT0(0, rev);
  if (diff&TTAF_ITAL) {
    if (a->f&TTAF_ITAL) PUT0(0, sitm);
    else PUT0(0, ritm);
  }

  /* Colours. */
  if (((diff&TTAF_FGSPCMASK) && !(a->f&TTAF_FGSPCMASK)) ||
      ((diff&TTAF_BGSPCMASK) && !(a->f&TTAF_BGSPCMASK))) {
    /* There's no capability string for resetting just the foreground
     * or background colours to the defaults, so deal with that here.
     */

    PUT0(0, op);
    diff = (diff&~(TTAF_FGSPCMASK | TTAF_BGSPCMASK)) |
           (a->f&(TTAF_FGSPCMASK | TTAF_BGSPCMASK));
  }
  if ((diff&TTAF_FGSPCMASK) || a->fg != t->tty.st.attr.fg)
    CHECK(caps_setcolour(t, t->cap.setaf,
                         (a->f&TTAF_FGSPCMASK) >> TTAF_FGSPCSHIFT, a->fg));
  if ((diff&TTAF_BGSPCMASK) || a->bg != t->tty.st.attr.bg)
    CHECK(caps_setcolour(t, t->cap.setab,
                         (a->f&TTAF_BGSPCMASK) >> TTAF_BGSPCSHIFT, a->bg));

  /* All done. */
  rc = 0;
end:
  t->tty.st.attr = *a; return (rc);

#undef f_clrall
}

/* --- @caps_setattr@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @const struct tty_attr *a@ = attribute to set, already
 *                      clamped
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Arrange to display future characters with the display
 *              attributes indicated by @a@.
 */

static int caps_setattr(struct tty *tty,
                        const struct gprintf_ops *gops, void *go,
                        const struct tty_attr *a)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int rc;

  /* Hand off to @caps_setattr_internal@. */
  ops->cap.prepout(&t->tty, gops, go);
  rc = caps_setattr_internal(t, a);
  if (ops->cap.flush(&t->tty)) rc = -1;
  return (rc);
}

/* --- @caps_setmodes@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @uint32 modes_bic, modes_xor@ = masks to apply to the modes
 *                      settings
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Set the requested terminal modes.
 */

static int caps_setmodes(struct tty *tty,
                         const struct gprintf_ops *gops, void *go,
                         uint32 modes_bic, uint32 modes_xor)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  uint32 modes, diff;
  const char *cap;
  int rc;

  /* Figure out which modes to set. */
  modes = (t->tty.st.modes&~modes_bic) ^ modes_xor;
  diff = modes ^ t->tty.st.modes;

  /* Prepare output. */
  ops->cap.prepout(&t->tty, gops, go);

  /* Automatic margins. */
  if (diff&TTMF_AUTOM) {
    if (modes&TTMF_AUTOM) PUT0(0, smam);
    else PUT0(0, rmam);
  }

  /* Full-screen. */
  if (diff&TTMF_FSCRN) {
    if (modes&TTMF_FSCRN) PUT0(0, smcup);
    else PUT0(0, rmcup);
  }

  /* Cursor visibility. */
  if (diff&TTMF_CVIS) {
    if (modes&TTMF_CVIS) PUT0(0, civis);
    else PUT0(0, cnorm);
  }

  /* Auto-insert. */
  if (diff&TTMF_INS) {
    cap = modes&TTMF_INS ? t->cap.smir : t->cap.rmir;
    if (cap) PUT0V(0, cap);
    else if (!t->cap.ich) { rc = -1; goto end; }
  }

  /* Delete characters. */
  if (diff&TTMF_DEL) {
    cap = modes&TTMF_DEL ? t->cap.smdc : t->cap.rmdc;
    if (cap) PUT0V(0, cap);
    else if (!t->cap.dch && !t->cap.dch1) { rc = -1; goto end; }
  }

  /* Done. */
  rc = 0;
end:
  if (ops->cap.flush(&t->tty)) rc = -1;
  t->tty.st.modes = modes; return (rc);
}

/* --- @caps_move_relative@ --- *
 *
 * Arguments:   @struct tty_caps *t@ = extended control block pointer
 *              @int delta@ = number of places to move
 *              @const char *fw1, *fwn, *rv1, *rvn@ = capability strings for
 *                      to move by a single or multiple places, in the
 *                      forward (positive) or backwards (negative) direction
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Perform a relative motion, making the most of the supplied
 *              capabilities.
 */

static int caps_move_relative(struct tty_caps *t,
                              int delta,
                              const char *fw1, const char *fwn,
                              const char *rv1, const char *rvn)
{
  const char *mv1, *mvn;

  if (!delta) return (0);
  else if (delta > 0) { mv1 = fw1; mvn = fwn; }
  else { mv1 = rv1; mvn = rvn; delta = - delta; }
  return (caps_iterate(t, mv1, mvn, 0, 0, delta));
}

/* --- @caps_move_absx@ --- *
 *
 * Arguments:   @struct tty_caps *t@ = extended control block pointer
 *              @int x@ = column to move the cursor to
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Move the cursor to the given column in the current line.
 *              This is possible even if we have only relative motion
 *              because we can use the carriage return.
 */

static int caps_move_absx(struct tty_caps *t, int x)
{
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int rc;

  if (t->cap.hpa)
    PUT1I(1, hpa, x);
  else {
    PUT0(1, cr);
    CHECK(caps_iterate(t, t->cap.cuf1, t->cap.cuf, 0, 1, x));
  }
  rc = 0;
end:
  return (rc);
}

/* --- @caps_move@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned orig@ = origin
 *              @int y, x@ = new cursor position
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Move the cursor.
 */

static int caps_move(struct tty *tty,
                     const struct gprintf_ops *gops, void *go,
                     unsigned orig, int y, int x)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  struct tty_attr a, aa = TTY_ATTR_INIT;
  int rc;

  /* Check that the arguments are basically sensible. */
  if ((!(orig&TTOF_YCUR) && y < 0) || (!(orig&TTOF_XCUR) && x < 0))
    { rc = -1; goto end; }

  /* Prepare for output. */
  ops->cap.prepout(&t->tty, gops, go);

  /* If it's unsafe to move with insert mode on, then turn it off. */
  if (!t->cap.mir && (t->tty.st.modes&TTMF_INS)) PUT0(0, rmir);

  /* If it's unsafe to move with attributes set then make a copy of them and
   * clear them all.
   */
  a = t->tty.st.attr;
  if (!t->cap.msgr && a.f) {
    if (t->cap.sgr0) PUT0(0, sgr0);
    else CHECK(caps_setattr_internal(t, &aa));
    t->tty.st.attr.f = 0; t->tty.st.attr.fg = t->tty.st.attr.bg = 0;
  }

  /* Main dispatch. */
  switch (orig) {
    case TTORG_HOME:
      /* Fully absolute movement.
       *
       * Moving to the home position is likely easy and fast.  Use general
       * cursor positioning if available.  Otherwise, try to set the vertical
       * and horizontal positions separately.  If all that fails, move to the
       * home position and use relative motion.
       */

      if (t->cap.home && !x && !y)
        PUT0(1, home);
      else if (t->cap.cup)
        PUT2I(1, cup, y, x);
      else if (t->cap.vpa) {
        PUT1I(1, vpa, y);
        CHECK(caps_move_absx(t, x));
      } else if (t->cap.home) {
        PUT0(1, home);
        CHECK(caps_iterate(t, t->cap.cud1, t->cap.cud, 0, 1, y));
        CHECK(caps_iterate(t, t->cap.cuf1, t->cap.cuf, 0, 1, x));
      } else
        { rc = -1; goto end; }
      break;

    case TTORG_CUR:
      /* Fully relative movement.  This is easy. */

      CHECK(caps_move_relative(t, y,
                               t->cap.cud1, t->cap.cud,
                               t->cap.cuu1, t->cap.cuu));
      CHECK(caps_move_relative(t, x,
                               t->cap.cuf1, t->cap.cuf,
                               t->cap.cub1, t->cap.cub));
      break;

    case TTOF_XHOME | TTOF_YCUR:
      /* Absolute horizontal movement, with relative vertical movement.
       *
       * If we want to move to the start of the next line, this is a
       * `newline' operation.  Otherwise, use two separate motions.
       */

      if (x == 0 && y == 1)
        PUT0(1, nel);
      else {
        CHECK(caps_move_relative(t, y,
                                 t->cap.cud1, t->cap.cud,
                                 t->cap.cuu1, t->cap.cuu));
        CHECK(caps_move_absx(t, x));
      }
      break;

    case TTOF_XCUR | TTOF_YHOME:
      /* Relative horizontal movement, with absolute vertical movement.
       *
       * The only thing to try is two separate motions.
       */

      PUT1I(1, vpa, y);
      CHECK(caps_move_relative(t, x,
                               t->cap.cuf1, t->cap.cuf,
                               t->cap.cub1, t->cap.cub));
      break;

    default:
      /* Anything else was an error. */

      rc = -1; goto end;
      break;
  }

  /* If we turned off insert mode, we can turn it back on now. */
  if (!t->cap.mir && (t->tty.st.modes&TTMF_INS)) PUT0(0, smir);

  /* And if we turned off any attributes, we can turn them back on. */
  if (!t->cap.msgr && a.f)
    CHECK(caps_setattr_internal(t, &a));

  /* All done. */
  rc = 0;
end:
  if (ops->cap.flush(&t->tty)) rc = -1;
  return (rc);
}

/* --- @caps_repeat@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @int ch@ = character to write
 *              @unsigned n@ = number of copies
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Write @n@ copies of the character @ch@ to the terminal.
 */

static int caps_repeat(struct tty *tty,
                       const struct gprintf_ops *gops, void *go,
                       int ch, unsigned n)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  unsigned wd, nn;
  int rc;

  /* Prepare for output. */
  ops->cap.prepout(&t->tty, gops, go);

  /* If there isn't a capability for this then do it the stupid way. */
  if (!t->cap.rep)
    CHECK(stupid_repeat(tty, gops, go, ch, n));
  else {
    wd = t->tty.wd;
    while (n) {
      nn = n; if (nn > INT_MAX) nn = INT_MAX;
      PUT2I((nn + wd - 1)/wd, rep, ch, nn);
      n -= nn;
    }
  }

  /* Done. */
  rc = 0;
end:
  if (ops->cap.flush(&t->tty)) rc = -1;
  return (rc);
}

/* --- @caps_erase@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Erase portions of the current line or the whole display.
 */

static int caps_erase(struct tty *tty,
                      const struct gprintf_ops *gops, void *go,
                      unsigned f)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int rc;

  /* Prepare for output. */
  ops->cap.prepout(&t->tty, gops, go);

  if (!(f&TTEF_DSP)) {
    /* Erase line.  This is easy. */

    if (f&TTEF_BEGIN) PUT0(1, el1);
    if (f&TTEF_END) PUT0(1, el);
  } else {
    /* Erase display.  Note that `terminfo' lacks a capability for `erase
     * from start of display'.
     */

    switch (f&(TTEF_BEGIN | TTEF_END)) {
      case 0:
        /* Nothing to do. */

        break;

      case TTEF_BEGIN | TTEF_END:
        /* Erase the whole display.  If we have a `clear', then use it;
         * otherwise, synthesize it from `home' and `erase to end'.
         */

        if (t->cap.clear) PUT0(t->tty.ht, clear);
        else { PUT0(1, home); PUT0(t->tty.ht, ed); }
        break;

      case TTEF_END:
        /* Erase to the end of the display. */

        PUT0(t->tty.ht, ed);
        break;

      default:
        /* Anything else is wrong. */

        rc = -1; goto end;
        break;
    }
  }

  /* Done. */
  rc = 0;
end:
  if (ops->cap.flush(&t->tty)) rc = -1;
  return (rc);
}

/* --- @caps_erch@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned n@ = number of characters to erase
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Erase a number of characters, starting from and including the
 *              current cursor position.
 */

static int caps_erch(struct tty *tty,
                     const struct gprintf_ops *gops, void *go,
                     unsigned n)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int rc;

  /* Prepare for output. */
  ops->cap.prepout(&t->tty, gops, go);

  /* Produce the control sequence. */
  if (n) PUT1I(1, ech, n);

  /* Done. */
  rc = 0;
end:
  if (ops->cap.flush(&t->tty)) rc = -1;
  return (rc);
}

/* --- @caps_ins@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *              @unsigned n@ = number of items to insert
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Insert a number of blank characters or lines.
 */

static int caps_ins(struct tty *tty,
                    const struct gprintf_ops *gops, void *go,
                    unsigned f, unsigned n)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int rc;

  /* Prepare for output. */
  ops->cap.prepout(&t->tty, gops, go);

  /* Produce the control sequence. */
  if (f&TTIDF_LN)
    CHECK(caps_iterate(t, t->cap.il1, t->cap.il, CIF_PADMUL, 1, n));
  else
    CHECK(caps_iterate(t, t->cap.ich1, t->cap.ich, 0, 1, n));

  /* Done. */
  rc = 0;
end:
  if (ops->cap.flush(&t->tty)) rc = -1;
  return (rc);
}

/* --- @caps_inch@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @int ch@ = character to insert
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Insert a single character.
 */

static int caps_inch(struct tty *tty,
                     const struct gprintf_ops *gops, void *go,
                     int ch)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int rc;

  /* Prepare for output. */
  ops->cap.prepout(&t->tty, gops, go);

  /* If the terminal has an insert mode, but it's not turned on, then this
   * isn't going to work.
   */
  if (t->cap.smir ? !(t->tty.st.modes&TTMF_INS) : !t->cap.ich)
    { rc = -1; goto end; }

  /* If there's an insert-one-character sequence, then send that. */
  if (t->cap.ich) PUT0(1, ich);

  /* Put the actual character. */
  CHECK(gops->putch(go, ch));

  /* Some terminals need post-insertion padding, which turns up here. */
  if (t->cap.ip) PUT0(1, ip);

  /* Done. */
  rc = 0;
end:
  if (ops->cap.flush(&t->tty)) rc = -1;
  return (rc);
}

/* --- @caps_del@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *              @unsigned n@ = number of items to delete
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Delete a number of characters or lines.
 */

static int caps_del(struct tty *tty,
                    const struct gprintf_ops *gops, void *go,
                    unsigned f, unsigned n)
{
  struct tty_caps *t = (struct tty_caps *)tty;
  const struct tty_capops *ops = (const struct tty_capops *)t->tty.ops;
  int rc;

  /* Prepare for output. */
  ops->cap.prepout(&t->tty, gops, go);

  /* Send the control sequence. */
  if (n) {
    if (f&TTIDF_LN)
      CHECK(caps_iterate(t, t->cap.dl1, t->cap.dl, CIF_PADMUL, 1, n));
    else
      CHECK(caps_iterate(t, t->cap.dch1, t->cap.dch, 0, 1, n));
  }

  /* Done. */
  rc = 0;
end:
  if (ops->cap.flush(&t->tty)) rc = -1;
  return (rc);
}

#undef PUT0V
#undef PUT1IV
#undef PUT2IV
#undef PUT0
#undef PUT1I
#undef PUT2I

/* The operation functions for terminal backends based on `terminfo'. */
#define TTY_CAPOPS                                                      \
  caps_setattr, caps_setmodes,                                          \
  caps_move, caps_repeat,                                               \
  caps_erase, caps_erch, caps_ins, caps_inch, caps_del

#endif

/*----- Termcap -----------------------------------------------------------*/

#ifdef HAVE_TERMCAP

/* So `termcap' is pretty bad, actually.  It reads the terminal description
 * from a file into a caller-provided buffer without knowing how big the
 * buffer is.  The @tgetstr@ function partially decodes a string capability
 * into another caller-provided buffer with no bounds checking.
 *
 * And then there's the way that pieces of `termcap' communicate with each
 * other through global variables which the caller has to set for it.
 *
 * Finally, while output can be redirected under application control, output
 * is strictly one-character-at-a-time, and there's no way to pass additional
 * context information to the character-output function, so we need yet more
 * global state.
 *
 * I'm not a fan.
 */

/* Additional state required by `termcap'. */
struct tty_termcapslots {
  char capbuf[4096], *capcur;           /* string caps, and cursor */
};
struct tty_termcap { TTY_CAPSPFX; struct tty_termcapslots tc; };
union tty_termcapu { struct tty_termcap tc; TTY_CAPSUSFX; };

/* --- @termcap_boolcap@, @termcap_intcap@, @termcap_strcap@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @int uix, const char *info, const char *cap@ = names for the
 *                      requested capability (as Unibilium index, and
 *                      `terminfo' and `termcap' names
 *
 * Returns:     The requested capability value.  On failure,
 *              @termcap_boolcap@ returns false, @termcap_intcap@ returns
 *              %$-1$%, and @termcap_strcap@ returns a null pointer.
 *
 * Use:         Return a requested boolean, integer, or string capability.
 */

static int termcap_boolcap(struct tty *tty,
                           int uix, const char *info, const char *cap)
{
  int p;

  p = tgetflag(cap); assert(p >= 0);
  return (p);
}

static int termcap_intcap(struct tty *tty,
                          int uix, const char *info, const char *cap)
{
  int n;

  n = tgetnum(cap); assert(n >= -1);
  return (n);
}

static const char *termcap_strcap(struct tty *tty,
                                  int uix, const char *info,
                                  const char *cap)
{
  struct tty_termcap *t = (struct tty_termcap *)tty;
  const char *p;
  size_t n;

  /* Try to detect overruns.  This is gnarly because C and `termcap'.  We're
   * not allowed to compare out-of-bounds pointers.  The best I can manage is
   * to assume that @capcur@ is maintained within @capbuf@, and check that
   * the length of the new capability didn't push us over the limit.  Things
   * are even harder because, e.g., `ncurses' doesn't actually make use of
   * our @capbuf@ at all.
   *
   * (Of course, if it did, it's probably too late to expect anyhing good,
   * but maybe we can apply the emergency brakes before things get too bad.)
   */
  n = t->tc.capcur - t->tc.capbuf;
  p = tgetstr(cap, &t->tc.capcur);
    assert(p != (const char *)-1);
    assert(!p || n + strlen(p) < sizeof(t->tc.capbuf));
  return (p);
}

/* --- @termcap_put0@, @termcap_put1i@, @termcap_put2i@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @unsigned npad@ = number of lines affected, for padding
 *              @const char *cap@ = capability string to write, or null
 *              @int i0, i1@ = integer parameters
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Format a capability string and send it to the terminal.
 */

static int termcap_put0(struct tty *tty,
                        unsigned npad, const char *cap)
{
  if (!cap) return (-1);
  return (tputs(cap, npad, caps_putch));
}

static int termcap_put1i(struct tty *tty,
                         unsigned npad, const char *cap, int i0)
{
  if (!cap) return (-1);
  return (tputs(tgoto(cap, -1, i0), npad, caps_putch) == OK ? 0 : -1);
}

static int termcap_put2i(struct tty *tty,
                         unsigned npad, const char *cap, int i0, int i1)
{
  if (!cap) return (-1);
  return (tputs(tgoto(cap, i1, i0), npad, caps_putch) == OK ? 0 : -1);
}

/* --- @termcap_cost@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @unsigned npad@ = number of lines affected
 *              @const char *cap@ = capability string to measure, or null
 *              @int i0@ = argument
 *
 * Returns:     A linear cost for using the capability.  This is meaningless
 *              if @cap@ is null.
 */

static size_t termcap_cost(struct tty *tty,
                           unsigned npad, const char *cap, int i0)
  { return (cap ? caps_cost(tty, npad, tgoto(cap, 0, i0)) : 0); }

/* The `termcap' operations table. */
static const union tty_capopsu termcap_ops = { {
  { caps_release, TTY_CAPOPS },
  { termcap_boolcap, termcap_intcap, termcap_strcap,
    caps_prepout, caps_flush,
    termcap_put0, termcap_put1i, termcap_put2i,
    termcap_cost }
} };

/* --- @termcap_init@ --- *
 *
 * Arguments:   @FILE *fp@ = the output stream
 *
 * Returns:     A pointer to a fresh terminal control block, or null on
 *              failure.
 *
 * Use:         Initialize a terminal for use through `termcap'.
 */

static struct tty *termcap_init(FILE *fp)
{
  union tty_termcapu *u = 0; struct tty *ret = 0;
  char termbuf[4096];
  const char *term;
  speed_t spd = B0;
  char *t;

  /* The `termcap' library makes use of global state, so we can only have one
   * at a time.  Traditional `termcap' is actually less bad in this sense,
   * but the `ncurses' emulation is tangled up with its `terminfo' machinery,
   * which is backed by a large amount of global state.  So check that there
   * aren't likely to be conflicts.
   */
  if (caps_claim()) goto end;

  /* Get the terminal name and try to find the terminal description. */
  term = getenv("TERM"); if (!term) goto end;
  if (tgetent(termbuf, term) < 1) goto end;

  /* Set up a fresh control block. */
  XNEW(u);
  u->tc.tc.capcur = u->tc.tc.capbuf;
  u->tty.ops = &termcap_ops.tty;
  common_init(&u->tty, fp, &spd);
  init_caps(&u->cap);

  /* Set the `termcap' global variables. */
  t = tgetstr("bc", &u->tc.tc.capcur); BC = t ? t : "\b";
  UP = UNCONST(char, u->cap.cap.cuu1);
  PC = u->cap.cap.pad ? *u->cap.cap.pad : 0;
  ospeed = spd;

  /* All done. */
  ret = &u->tty; u = 0;
end:
  xfree(u); global_lock = ret; return (ret);
}

#endif

/*----- Terminfo ----------------------------------------------------------*/

#ifdef HAVE_TERMINFO

/* So `terminfo' is pretty bad too, actually.  The good news is that
 * `termcap''s potential buffer overruns are gone.  The bad news is that
 * `terminfo' goes all in on global state.  Rather than being put in a
 * caller-provided buffer, the terminal description is read into global
 * state.
 *
 * Annoyingly, `terminfo' adopts the same `tputs' machinery as `termcap', and
 * therefore shares the one-character-at-a-time output and inability to pass
 * contextual information through to the ouptut function.
 *
 * I'm not a fan of `terminfo' either.
 */

/* --- @terminfo_boolcap@, @terminfo_intcap@, @terminfo_strcap@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @int uix, const char *info, const char *cap@ = names for the
 *                      requested capability (as Unibilium index, and
 *                      `terminfo' and `termcap' names
 *
 * Returns:     The requested capability value.  On failure,
 *              @termcap_boolcap@ returns false, @termcap_intcap@ returns
 *              %$-1$%, and @termcap_strcap@ returns a null pointer.
 *
 * Use:         Return a requested boolean, integer, or string capability.
 */

static int terminfo_boolcap(struct tty *tty,
                            int uix, const char *info, const char *cap)
{
  int p;

  p = tigetflag(info); assert(p >= 0);
  return (p);
}

static int terminfo_intcap(struct tty *tty,
                           int uix, const char *info, const char *cap)
{
  int n;

  n = tigetnum(info); assert(n >= -1);
  return (n);
}

static const char *terminfo_strcap(struct tty *tty,
                                   int uix, const char *info,
                                   const char *cap)
{
  const char *p;

  p = tigetstr(info); assert(p != (const char *)-1);
  return (p);
}

/* --- @terminfo_put0@, @terminfo_put1i@, @terminfo_put2i@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @unsigned npad@ = number of lines affected, for padding
 *              @const char *cap@ = capability string to write, or null
 *              @int i0, i1@ = integer parameters
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Format a capability string and send it to the terminal.
 */

static int terminfo_put0(struct tty *tty,
                         unsigned npad, const char *cap)
{
  if (!cap) return (-1);
  return (tputs(cap, npad, caps_putch));
}

static int terminfo_put1i(struct tty *tty,
                          unsigned npad, const char *cap, int i0)
{
  if (!cap) return (-1);
  return (tputs(tparm(cap, i0), npad, caps_putch) == OK ? 0 : -1);
}

static int terminfo_put2i(struct tty *tty,
                          unsigned npad, const char *cap, int i0, int i1)
{
  if (!cap) return (-1);
  return (tputs(tparm(cap, i0, i1), npad, caps_putch) == OK ? 0 : -1);
}

/* --- @terminfo_cost@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @unsigned npad@ = number of lines affected
 *              @const char *cap@ = capability string to measure, or null
 *              @int i0@ = argument
 *
 * Returns:     A linear cost for using the capability.  This is meaningless
 *              if @cap@ is null.
 */

static size_t terminfo_cost(struct tty *tty,
                            unsigned npad, const char *cap, int i0)
  { return (cap ? caps_cost(tty, npad, tparm(cap, i0)) : 0); }

/* The `terminfo' operations table. */
static const union tty_capopsu terminfo_ops = { {
  { caps_release, TTY_CAPOPS },
  { terminfo_boolcap, terminfo_intcap, terminfo_strcap,
    caps_prepout, caps_flush,
    terminfo_put0, terminfo_put1i, terminfo_put2i,
    terminfo_cost }
} };

/* --- @terminfo_init@ --- *
 *
 * Arguments:   @FILE *fp@ = the output stream
 *
 * Returns:     A pointer to a fresh terminal control block, or null on
 *              failure.
 *
 * Use:         Initialize a terminal for use through `terminfo'.
 */

static struct tty *terminfo_init(FILE *fp)
{
  union tty_capsu *u = 0; struct tty *ret = 0;
  int err;

  /* The `termcap' library makes extensive use of global state, so we can
   * only have one at a time.  Check that there aren't likely to be
   * conflicts.
   */
  if (caps_claim()) goto end;

  /* Get the terminal description. */
  if (setupterm(0, fp ? fileno(fp) : -1, &err) != OK || err < 1) goto end;

  /* Set up a fresh control block. */
  XNEW(u);
  u->tty.ops = &terminfo_ops.tty;
  common_init(&u->tty, fp, 0);
  init_caps(&u->cap);

  /* All done. */
  ret = &u->tty; u = 0;
end:
  xfree(u); global_lock = ret; return (ret);
}

#endif

/*----- Unibilium ---------------------------------------------------------*/

#ifdef HAVE_UNIBILIUM

/* Unibilium is a `terminfo' library for the 21st century.  It avoids all of
 * the mistakes of the `termcap' and `terminfo' interfaces.  Honestly, it's a
 * bit too `modern' for my tastes: the type bureaucracy involved with
 * `unibi_var_t' seems unnecessarily heavyweight (but won't actually bother
 * us much here).
 *
 * It's not all sunshine and roses.  The library makes a principled decision
 * to avoid actually messing with terminals directly at all, which seems
 * fair enough -- even laudable, maybe.  But there's also no help provided to
 * generate padding characters, so we have to do that by ourselves, which
 * ends up being perhaps the most complicated part of this whole business.
 *
 * Also, while the caller-provided output functions can at least be passed a
 * context pointer, they can't report errors, which means that we must leave
 * a pending error indication.
 *
 * Oh, and the name is actually really difficult to type.
 */

/* Additional state required for Unibilium. */
struct tty_unibislots {
  unibi_term *ut;                       /* the terminal description */
  unibi_var_t dy[26], st[26];           /* variables used by cap strings */
  const struct gprintf_ops *gops; void *go; /* output destination */
  char buf[BUFSZ]; size_t n;            /* output buffer and length */
  int err;                              /* pending error indication */
};
struct tty_unibilium { TTY_CAPSPFX; struct tty_unibislots u; };
union tty_unibiliumu { struct tty_unibilium u; TTY_CAPSUSFX; };

/* --- @termunibi_release@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *
 * Returns:     ---
 *
 * Use:         Release resources held by the control block.
 */

static void termunibi_release(struct tty *tty)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;

  unibi_destroy(t->u.ut);
}

/* --- @termcap_boolcap@, @termcap_intcap@, @termcap_strcap@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @int uix, const char *info, const char *cap@ = names for the
 *                      requested capability (as Unibilium index, and
 *                      `terminfo' and `termcap' names
 *
 * Returns:     The requested capability value.  On failure,
 *              @termcap_boolcap@ returns false, @termcap_intcap@ returns
 *              %$-1$%, and @termcap_strcap@ returns a null pointer.
 *
 * Use:         Return a requested boolean, integer, or string capability.
 */

static int termunibi_boolcap(struct tty *tty,
                            int uix, const char *info, const char *cap)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;

  return (unibi_get_bool(t->u.ut, uix));
}

static int termunibi_intcap(struct tty *tty,
                           int uix, const char *info, const char *cap)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;

  return (unibi_get_num(t->u.ut, uix));
}

static const char *termunibi_strcap(struct tty *tty,
                                   int uix, const char *info,
                                   const char *cap)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;

  return (unibi_get_str(t->u.ut, uix));
}

/* --- @termunibi_prepout@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer (ignored)
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *
 * Returns:     ---
 *
 * Use:         Prepare output to the given destination.  Check that the
 *              output buffer is initially empty (i.e., that it was properly
 *              flushed last time), and make a note of the output
 *              destination.
 */

static void termunibi_prepout(struct tty *tty,
                              const struct gprintf_ops *gops, void *go)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;

  assert(!t->u.n); t->u.gops = gops; t->u.go = go;
}

/* Context for output operations. */
struct termunibi_outctx {
  struct tty_unibilium *t;              /* control block pointer */
  unsigned npad;                        /* number of lines, for padding */
};

/* --- @termunibi_putm@ --- *
 *
 * Arguments:   @void *ctx@ = output context pointer
 *              @const char *p, size_t sz@ = buffer to write
 *
 * Returns:     ---
 *
 * Use:         Send the material in the buffer to the current output
 *              destination.
 */

static void termunibi_putm(void *ctx, const char *p, size_t sz)
{
  struct termunibi_outctx *out = ctx;
  struct tty_unibilium *t = out->t;
  size_t n;

  /* Find out how much space is left in the buffer.  As for the common
   * `termcap'/`terminfo' machinery above, by policy, we leave the buffer
   * with at least one byte of space.
   */
  n = BUFSZ - t->u.n; assert(n > 0);

  /* Save the output into the buffer. */
  if (sz < n) {
    /* There's enough space in the buffer for everything.  Just store all of
     * it.
     */

    memcpy(t->u.buf + t->u.n, p, sz); t->u.n += sz;
  } else if (sz - n < THRESH) {
    /* We don't really have enough left over to be worth cycling the output
     * machinery again yet.
     */

    memcpy(t->u.buf + t->u.n, p, n); p += n; sz -= n;
    if (t->u.gops->putm(t->u.go, t->u.buf, BUFSZ)) t->u.err = -1;
    memcpy(t->u.buf, p, sz); t->u.n = sz;
  } else {
    /* There's enough that it's worth avoiding the copy.  Flush whatever's in
     * the buffer, and inhale the entire new input in one go, leaving the
     * buffer empty.
     */

    if (t->u.gops->putm(t->u.go, t->u.buf, t->u.n)) t->u.err = -1;
      t->u.n = 0;
    if (t->u.gops->putm(t->u.go, p, sz)) t->u.err = -1;
  }
}

/* --- @termunibi_pad@ --- *
 *
 * Arguments:   @void *ctx@ = control block pointer
 *              @size_t delay@ = tenths of milliseconds to pad
 *              @int mulp@ = nonzero if padding is per line
 *              @int forcep@ = nonzero if padding is unconditional
 *                      (regardless of, e.g., baud rate or flow control)
 *
 * Returns:     ---
 *
 * Use:         Pad for a given duration.
 */

static void termunibi_pad(void *ctx, size_t delay, int mulp, int forcep)
{
  struct termunibi_outctx *out = ctx;
  struct tty_unibilium *t = out->t;
  struct timeval tv;
  unsigned long d;
  int pc;
  size_t sz, n;

  /* Determine the actual delay. */
  if (mulp) d = (unsigned long)delay*out->npad;
  else d = delay;

  /* There's nothing to do unless (a) we're forced, or (b) the baud rate is
   * high enough and flow control isn't advertised.
   */
  if (forcep || (t->tty.baud >= t->cap.pb && !t->cap.xon)) {

    if (t->cap.npc) {
      /* There's no safe pad character to send, so we'll just have to wait
       * for long enough.
       *
       * If output is buffered downstream of us then this isn't going to work
       * correctly.  Honestly, that's a problem for the other output drivers
       * too, and it only comes into clear focus here.
       */

      /* Flush the output. */
      if (t->u.n) {
        if (t->u.gops->putm(t->u.go, t->u.buf, BUFSZ)) t->u.err = -1;
        t->u.n = 0;
      }
      if (t->tty.fpout) fflush(t->tty.fpout);

      /* Do nothing for a little while. */
      tv.tv_sec = d/10000; tv.tv_usec = 100*(d%10000);
      select(0, 0, 0, 0, &tv);
    } else {
      /* There's a pad character, so figure out how many we need and send
       * them.
       */

      /* Determine the number of pad character and the pad value. */
      sz = caps_padchars(&t->tty, d, forcep ? CPF_FORCE : 0);
      pc = t->cap.pad ? *t->cap.pad : 0;

      /* Work out how much buffer space is available.  Again, by policy, the
       * buffer is always left with at least one byte of capacity.
       */
      n = BUFSZ - t->u.n; assert(n);
      if (sz < n) {
        /* The padding will fit in the buffer. */

        memset(t->u.buf + t->u.n, pc, sz); t->u.n += sz;
      } else if (sz - n < BUFSZ) {
        /* There's not enough to fill the buffer a second time.  Do this in
         * two pieces.
         */

        memset(t->u.buf + t->u.n, pc, n); sz -= n;
        if (t->u.gops->putm(t->u.go, t->u.buf, BUFSZ)) t->u.err = -1;
        memset(t->u.buf, pc, sz); t->u.n = sz;
      } else {
        /* We'll fill the whole buffer at least once.  Flush what we have
         * immediately and then do whole buffer-full sends.
         */

        if (t->u.gops->putm(t->u.go, t->u.buf, t->u.n)) t->u.err = -1;
        memset(t->u.buf, pc, BUFSZ);
        while (sz >= BUFSZ) {
          if (t->u.gops->putm(t->u.go, t->u.buf, BUFSZ)) t->u.err = -1;
          sz -= BUFSZ;
        }
        t->u.n = sz;
      }
    }
  }
}

/* --- @termunibi_flush@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer (ignored)
 *
 * Returns:     Zero for success, %$-1$% if error pending.
 *
 * Use:         Flush the output buffer to the backend.  If an error is
 *              pending, clear it and return failure.
 */

static int termunibi_flush(struct tty *tty)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;
  int rc = t->u.err;

  if (t->u.n) {
    if (t->u.gops->putm(t->u.go, t->u.buf, t->u.n)) rc = -1;
    t->u.n = 0;
  }
  t->u.err = 0; return (rc);
}

/* --- @termunibi_put0@, @termunibi_put1i@, @termunibi_put2i@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @unsigned npad@ = number of lines affected, for padding
 *              @const char *cap@ = capability string to write, or null
 *              @int i0, i1@ = integer parameters
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Format a capability string and send it to the terminal.
 */

static int termunibi_put0(struct tty *tty,
                          unsigned npad, const char *cap)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;
  struct termunibi_outctx out;
  unibi_var_t arg[9];

  if (!cap) return (-1);
  out.t = t; out.npad = npad;
  unibi_format(t->u.dy, t->u.st, cap, arg,
               termunibi_putm, &out,
               termunibi_pad, &out);
  return (0);
}

static int termunibi_put1i(struct tty *tty,
                           unsigned npad, const char *cap, int i0)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;
  struct termunibi_outctx out;
  unibi_var_t arg[9];

  if (!cap) return (-1);
  arg[0] = unibi_var_from_num(i0);
  out.t = t; out.npad = npad;
  unibi_format(t->u.dy, t->u.st, cap, arg,
               termunibi_putm, &out,
               termunibi_pad, &out);
  return (0);
}

static int termunibi_put2i(struct tty *tty,
                           unsigned npad,
                           const char *cap, int i0, int i1)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;
  struct termunibi_outctx out;
  unibi_var_t arg[9];

  if (!cap) return (-1);
  arg[0] = unibi_var_from_num(i0);
  arg[1] = unibi_var_from_num(i1);
  out.t = t; out.npad = npad;
  unibi_format(t->u.dy, t->u.st, cap, arg,
               termunibi_putm, &out,
               termunibi_pad, &out);
  return (0);
}

/* Context for cost counting. */
struct termunibi_costctx {
  struct tty_unibilium *t;              /* terminal control block */
  unsigned npad;                        /* number of lines affected */
  size_t n;                             /* accumulated cost, in chars */
};

/* --- @termunibi_costputm@ --- *
 *
 * Arguments:   @void *ctx@ = output context pointer
 *              @const char *p, size_t sz@ = buffer to write
 *
 * Returns:     ---
 *
 * Use:         Count the number of characters written.
 */

static void termunibi_costputm(void *ctx, const char *p, size_t sz)
  { struct termunibi_costctx *c = ctx; c->n += sz; }

/* --- @termunibi_costpad@ --- *
 *
 * Arguments:   @void *ctx@ = control block pointer
 *              @size_t delay@ = tenths of milliseconds to pad
 *              @int mulp@ = nonzero if padding is per line
 *              @int forcep@ = nonzero if padding is unconditional
 *                      (regardless of, e.g., baud rate or flow control)
 *
 * Returns:     ---
 *
 * Use:         Count the character equivalent of the requested delay.
 */

static void termunibi_costpad(void *ctx, size_t delay, int mulp, int forcep)
{
  struct termunibi_costctx *c = ctx;

  if (mulp) delay *= c->npad;
  c->n += caps_padchars(&c->t->tty, delay, CPF_FORCE);
}

/* --- @termunibi_cost@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @unsigned npad@ = number of lines affected
 *              @const char *cap@ = capability string to measure, or null
 *              @int i0@ = argument
 *
 * Returns:     A linear cost for using the capability.  This is meaningless
 *              if @cap@ is null.
 */

static size_t termunibi_cost(struct tty *tty,
                              unsigned npad, const char *cap, int i0)
{
  struct tty_unibilium *t = (struct tty_unibilium *)tty;
  struct termunibi_costctx c;
  unibi_var_t arg[9];

  if (!cap) return (0);
  arg[0] = unibi_var_from_num(i0);
  c.t = t; c.npad = npad; c.n = 0;
  unibi_format(t->u.dy, t->u.st, cap, arg,
               termunibi_costputm, &c,
               termunibi_costpad, &c);
  return (c.n);
}

/* The `terminfo' operations table. */
static const union tty_capopsu termunibi_ops = { {
  { termunibi_release, TTY_CAPOPS },
  { termunibi_boolcap, termunibi_intcap, termunibi_strcap,
    termunibi_prepout, termunibi_flush,
    termunibi_put0, termunibi_put1i, termunibi_put2i,
    termunibi_cost }
} };

/* --- @termunibi_init@ --- *
 *
 * Arguments:   @FILE *fp@ = the output stream
 *
 * Returns:     A pointer to a fresh terminal control block, or null on
 *              failure.
 *
 * Use:         Initialize a terminal for use through Unibilium.
 */

static struct tty *termunibi_init(FILE *fp)
{
  union tty_unibiliumu *u = 0; struct tty *ret = 0;
  unibi_term *ut = 0;

  /* Collect the terminal description. */
  ut = unibi_from_env(); if (!ut) goto end;

  /* Set up a fresh control block. */
  XNEW(u);
  u->tty.ops = &termunibi_ops.tty;
  u->u.u.ut = ut; ut = 0;
  common_init(&u->tty, fp, 0);
  init_caps(&u->cap);

  /* Initialize the buffer state. */
  u->u.u.n = 0; u->u.u.err = 0;

  /* All done. */
  ret = &u->tty; u = 0;
end:
  xfree(u); if (ut) unibi_destroy(ut);
  return (ret);
}

#endif

/*----- ANSI terminals ----------------------------------------------------*/

/* Here we dispense with external libraries and take a wild guess that the
 * terminal accepts some variant of ANSI control sequences.
 *
 * Here's a quick reference of the control sequences that we use here.
 *
 *   * CUP: \33 [ Y ; X H               `cursor position' [vt100]
 *
 *   * CUU/CUD/CUR/CUL: \33 [ N A/B/C/D `cursor up/down/right/left'
 *
 *   * DCH: \33 [ N P                   `delete character' [vt220]
 *                                              (single char only in vt102?)
 *
 *   * DL: \33 [ N M                    `delete line' [vt220]
 *                                              (single line only in vt102?)
 *
 *   * ECH: \33 [ N X                   `erase characters' [vt220]
 *
 *   * ED: \33 [ P J                    `erase in display'
 *       P = 0                          erase to end-of-screen [vt100]
 *       P = 1                          erase from start-of-screen [vt100]
 *       P = 2                          erase entire screen [vt100]
 *
 *   * EL: \33 [ P K                    `erase in line'
 *       P = 0                          erase to end-of-line [vt100]
 *       P = 1                          erase from start-of-line [vt100]
 *       P = 2                          erase entire line [vt100]
 *
 *   * HPA/VPA: \33 [ I G/d             `horizontal/vertical position
 *                                              absolute' [ecma48-4]
 *
 *   * ICH: \33 [ N @                   `insert character' [vt220]
 *                                              (single char only in vt102?)
 *
 *   * IL: \33 [ N L                    `insert line' [vt220]
 *                                              (single line only in vt102?)
 *
 *   * SGR: \33 [ P ; ... m             `select graphics rendition'
 *       P = 0                          cancel all attributes [vt100]
 *       P = 1                          bold [vt100]
 *       P = 2                          dim [ecma48-4]
 *       P = 3                          italics [ecma48-4]
 *       P = 4                          underline [vt100]
 *       P = 7                          inverse video [vt100]
 *       P = 9                          strikeout [ecma48-4]
 *       P = 21                         double underline [ecma48-4]
 *       P = 22                         cancal bold/dim [vt220]
 *       P = 24                         cancel underline [vt220]
 *       P = 27                         cancel inverse video [vt220]
 *       P = 30 + 4 R + 2 G + B         set 1BPC foreground [ecma48-4]
 *       P = 38 : 2 : ? : R : G : B     set foreground [iso8613-6]
 *       P = 38 : 5 : N                 set foreground [iso8613-6, xterm]
 *       P = 39                         cancel foreground [ecma48-4]
 *       P = 40--49                     as above, for background
 *       P = 90 + 4 R + 2 G + B         set bright 1BPC foreground [xterm]
 *       P = 100 + 4 R + 2 G + B        set bright 1BPC background [xterm]
 *
 *   * SM/RM: \33 [ P ; ... h/l `set/reset modes'
 *       M = 4                          insert [vt220]
 *
 *   * SM, RM: \33 [ ? P ; ... h/l      `set/reset private modes'
 *       M = 7                          auto right margin [vt100]
 *       M = 25                         visible cursor [vt220]
 *       M = 1049                       alternate screen [xterm]
 *
 *   * \33 [ P ; X ; Y t                `window manipulation'
 *       P = 22, X = 0                  save title and icon [xterm]
 *       P = 23, X = 0                  restore title and icon [xterm]
 */

/* Additional state required for ANSI terminals. */
struct tty_ansislots {
  unsigned f;
#define TAF_CNCATTR 1u                  /*   attributes can be cancelled */
#define TAF_EDITN 2u                    /*   insert/delete multiple */
#define TAF_SEMI 4u                     /*   semicolons in CSI 38 m colour */
};
struct tty_ansi { TTY_BASEPFX; struct tty_ansislots ansi; };
union tty_ansiu { struct tty_ansi ansi; TTY_BASEUSFX; };

/* --- @ansi_release@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *
 * Returns:     ---
 *
 * Use:         Release resources held by the control block.  (There's
 *              actually nothing to do here.)
 */

static void ansi_release(struct tty *tty) { ; }

/* Some simple macros we use throughout. */
#define PUTCH(ch) CHECK(gops->putch(go, (ch)))
#define PUTLIT(lit) CHECK(gops->putm(go, (lit), sizeof(lit) - 1))

/* Shared macro for @ansi_setcolour@ and @ansi_setattr@.  The output has the
 * form `ESC [ ... ; ... ; ... m', so there's a semicolon before each
 * parameter other than the first.  The @TAF_SEMI@ flag here keeps track of
 * whether a semicolon is wanted before the next item, and this macro is
 * responsible for writing it when necessary.
 */
#define SEMI do {                                                       \
  if (!(f&TAF_SEMI)) f |= TAF_SEMI;                                     \
  else PUTCH(';');                                                      \
} while (0)

/* --- @ansi_setcolour@ --- *
 *
 * Arguments:   @struct tty_caps *t@ = extended control block pointer
 *              @unsigned *f_inout@ = flags (updated)
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @int norm, br@ = normal and bright base codes -- 30 and 90
 *                      for foreground, or 40 and 100 for background
 *              @uint32 spc, clr@ = the colour space and number
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Emit the correct control string to set the foreground or
 *              background colour as indicated.
 */

static int ansi_setcolour(struct tty_ansi *t, unsigned *f_inout,
                          const struct gprintf_ops *gops, void *go,
                          int norm, int br,
                          uint32 spc, uint32 clr)
{
  unsigned f = *f_inout;
  int rc;

  switch (spc) {
    case TTCSPC_NONE:
      SEMI; CHECK(gprintf(gops, go, "%d", norm + 9));
      break;
    case TTCSPC_1BPC:
      SEMI; CHECK(gprintf(gops, go, "%d", norm + clr));
      break;
    case TTCSPC_1BPCBR:
      SEMI; CHECK(gprintf(gops, go, "%d", br + (clr&~TT1BPC_BRI)));
      break;
    case TTCSPC_4LPC: case TTCSPC_6LPC:
      SEMI;
      if (t->ansi.f&TAF_SEMI)
        CHECK(gprintf(gops, go, "%d;5;%d", norm + 8, clr + 16));
      else
        CHECK(gprintf(gops, go, "%d:5:%d", norm + 8, clr + 16));
      break;
    case TTCSPC_8LGS:
      SEMI;
      if (t->ansi.f&TAF_SEMI)
        CHECK(gprintf(gops, go, "%d;5;%d", norm + 8, clr + 80));
      else
        CHECK(gprintf(gops, go, "%d:5:%d", norm + 8, clr + 80));
      break;
    case TTCSPC_24LGS:
      SEMI;
      if (t->ansi.f&TAF_SEMI)
        CHECK(gprintf(gops, go, "%d;5;%d", norm + 8, clr + 232));
      else
        CHECK(gprintf(gops, go, "%d:5:%d", norm + 8, clr + 232));
      break;
    case TTCSPC_8BPC:
      SEMI;
      if (t->ansi.f&TAF_SEMI)
        CHECK(gprintf(gops, go, "%d;2;%d;%d;%d", norm + 8,
                      TTCOL_8BR(clr), TTCOL_8BG(clr), TTCOL_8BB(clr)));
      else
        CHECK(gprintf(gops, go, "%d:2::%d:%d:%d", norm + 8,
                      TTCOL_8BR(clr), TTCOL_8BG(clr), TTCOL_8BB(clr)));
      break;
    default:
      rc = -1; goto end;
  }

  rc = 0;
end:
  *f_inout = f; return (rc);
}

/* --- @ansi_setattr@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @const struct tty_attr *a@ = attribute to set, already
 *                      clamped
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Arrange to display future characters with the display
 *              attributes indicated by @a@.
 */

static int ansi_setattr(struct tty *tty,
                        const struct gprintf_ops *gops, void *go,
                        const struct tty_attr *a)
{
  struct tty_ansi *t = (struct tty_ansi *)tty;
  uint32 diff, m;
  int rc = 0;
  unsigned z, c, f = 0;

  /* Work out what, if anything, needs doing.  Since we start by writing
   * `ESC [' unconditionally below, if there's actually no work to do at all,
   * we need to stop early.
   */
  diff = a->f ^ t->tty.st.attr.f;
  if (!diff && a->fg == t->tty.st.attr.fg && a->bg == t->tty.st.attr.bg)
    { rc = 0; goto end; }

  /* We're committed.  Write the start of the `SGR' sequence. */
  PUTLIT("\33[");

  /* Form a basic strategy.
   *
   * As for @caps_setattr@ above, we need to decide betwen cancelling
   * individual attributes or resetting the whole lot and reinstating the
   * attributes which were cancelled unnecessarily.
   */

  /* Start by adding up the costs of cancelling individual attributes.
   * Early terminals can't do this, but we'll deal with that problem later.
   */
  c = 0;
#define CLEARP(mask) ((diff&(mask)) && !(a->f&(mask)))
  if (CLEARP(TTAF_LNMASK)) c += 3;
  if (CLEARP(TTAF_WTMASK)) c += 3;
  if (diff&~a->f&TTAF_INVV) c += 3;
  if (diff&~a->f&TTAF_STRIKE) c += 3;
  if (diff&~a->f&TTAF_ITAL) c += 3;
  if (CLEARP(TTAF_FGSPCMASK)) c += 3;
  if (CLEARP(TTAF_BGSPCMASK)) c += 3;
#undef CLEARP

  /* Count up the cost of cancelling everything and then putting back the
   * ones that we actually wanted.
   */
  z = 0;
  if (!(diff&TTAF_LNMASK))
    switch ((a->f&TTAF_LNMASK) >> TTAF_LNSHIFT) {
      case TTLN_ULINE: z += 2; break;
      case TTLN_UULINE: z += 3; break;
    }
  if (!(diff&TTAF_WTMASK))
    switch ((a->f&TTAF_LNMASK) >> TTAF_LNSHIFT) {
      case TTWT_BOLD: z += 2; break;
      case TTWT_DIM: z += 2; break;
    }
  m = a->f&~diff;
  if (m&TTAF_INVV) z += 2;
  if (m&TTAF_STRIKE) z += 2;
  if (m&TTAF_ITAL) z += 2;
#define COLOURCOST(G, g) do {                                           \
  if (!(diff&TTAF_##G##SPCMASK) &&                                      \
      (a->f&TTAF_##G##SPCMASK) && a->g == t->tty.st.attr.g)             \
    switch ((a->f&TTAF_##G##SPCMASK) >> TTAF_##G##SPCSHIFT) {           \
      case TTCSPC_1BPC: case TTCSPC_1BPCBR: z += 3; break;              \
      case TTCSPC_4LPC: case TTCSPC_8LGS: z += 8; break;                \
      case TTCSPC_6LPC: case TTCSPC_24LGS: z += 9; break;               \
      case TTCSPC_8BPC: z += 16; break;                                 \
    }                                                                   \
} while (0)
  COLOURCOST(FG, fg); COLOURCOST(BG, bg);
#undef COLOURCOST

  /* If cancelling everything is cheaper, or we can't cancel individual
   * attributes after all, then reset everything.
   */
  if (z < c || (c && !(t->ansi.f&TAF_CNCATTR)))
    { SEMI; diff = a->f; t->tty.st.attr.fg = t->tty.st.attr.bg = 0; }

  /* Line style. */
  if (diff&TTAF_LNMASK)
    switch ((a->f&TTAF_LNMASK) >> TTAF_LNSHIFT) {
      case TTLN_NONE: SEMI; PUTLIT("24"); break;
      case TTLN_ULINE: SEMI; PUTCH('4'); break;
      case TTLN_UULINE: SEMI; PUTLIT("21"); break;
      default: rc = -1; goto end;
    }

  /* Text weight. */
  if (diff&TTAF_WTMASK)
    switch ((a->f&TTAF_WTMASK) >> TTAF_WTSHIFT) {
      case TTWT_MED: SEMI; PUTLIT("22"); break;
      case TTWT_BOLD: SEMI; PUTCH('1'); break;
      case TTWT_DIM: SEMI; PUTCH('2'); break;
      default: rc = -1; goto end;
    }

  /* Other text effects. */
  if (diff&TTAF_INVV)
    { SEMI; if (a->f&TTAF_INVV) PUTCH('7'); else PUTLIT("27"); }
  if (diff&TTAF_STRIKE)
    { SEMI; if (a->f&TTAF_STRIKE) PUTCH('9'); else PUTLIT("29"); }
  if (diff&TTAF_ITAL)
    { SEMI; if (a->f&TTAF_ITAL) PUTCH('3'); else PUTLIT("23"); }

  /* Colours. */
  if (diff&TTAF_FGSPCMASK || a->fg != tty->st.attr.fg)
    CHECK(ansi_setcolour(t, &f, gops, go, 30, 90,
                         (a->f&TTAF_FGSPCMASK) >> TTAF_FGSPCSHIFT, a->fg));
  if (diff&TTAF_BGSPCMASK || a->bg != tty->st.attr.bg)
    CHECK(ansi_setcolour(t, &f, gops, go, 40, 100,
                         (a->f&TTAF_BGSPCMASK) >> TTAF_BGSPCSHIFT, a->bg));

  /* All done. */
  PUTCH('m'); rc = 0;
end:
  t->tty.st.attr = *a; return (rc);
}

/* --- @ansi_setmodes@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @uint32 modes_bic, modes_xor@ = masks to apply to the modes
 *                      settings
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Set the requested terminal modes.
 */

static int ansi_setmodes(struct tty *tty,
                         const struct gprintf_ops *gops, void *go,
                         uint32 modes_bic, uint32 modes_xor)
{
  uint32 modes, diff;
  int rc;

  /* Figure out which modes to set. */
  modes = (tty->st.modes&~modes_bic) ^ modes_xor;
  diff = modes ^ tty->st.modes;

  /* Auto-margins. */
  if (diff&TTMF_AUTOM) {
    if (modes&TTMF_AUTOM) PUTLIT("\33[?7h");
    else PUTLIT("\33[?7l");
  }

  /* Fullscreen. */
  if (diff&TTMF_FSCRN) {
    if (modes&TTMF_FSCRN) PUTLIT("\33[?1049h\33[22;0;0t");
    else PUTLIT("\33[?1049l\33[23;0;0t");
  }

  /* Visible cursor. */
  if (diff&TTMF_CVIS) {
    if (modes&TTMF_CVIS) PUTLIT("\33[?25h");
    else PUTLIT("\33[?25l");
  }

  /* Insert. */
  if (diff&TTMF_INS) {
    if (modes&TTMF_INS) PUTLIT("\33[4h");
    else PUTLIT("\33[4l");
  }

  /* Done. */
  rc = 0;
end:
  tty->st.modes = modes;
  return (rc);
}

/* --- @ansi_move@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned orig@ = origin
 *              @int y, x@ = new cursor position
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Move the cursor.
 */

static int ansi_move(struct tty *tty,
                     const struct gprintf_ops *gops, void *go,
                     unsigned orig, int y, int x)
{
  static const char bs[4] = { '\b', '\b', '\b', '\b' };
  int rc;

  /* Check that the arguments are basically sensible. */
  if ((!(orig&TTOF_YCUR) && y < 0) || (!(orig&TTOF_XCUR) && x < 0))
    { rc = -1; goto end; }

  if (orig == TTORG_HOME) {
    /* Fully absolute positioning.  We can omit the arguments for the topmost
     * row and/or leftmost column.
     */

    if (!x) {
      if (!y) PUTLIT("\33[H");
      else CHECK(gprintf(gops, go, "\33[%dH", y + 1));
    } else {
      if (!y) CHECK(gprintf(gops, go, "\33[;%dH", x + 1));
      else CHECK(gprintf(gops, go, "\33[%d,%dH", y + 1, x + 1));
    }
  } else if (orig == (TTOF_XHOME | TTOF_YCUR) && x == 0 && y == 1) {
    /* Special case for starting a new line. */

    PUTLIT("\r\n");
  } else {
    /* More complex motion.  Handle the horizontal and vertical motions
     * separately.
     */

    /* First, vertical motion.  This is simpler. */
    if (!(orig&TTOF_YCUR)) CHECK(gprintf(gops, go, "\33[%dd", y + 1));
    else if (y == -1) PUTLIT("\33[A");
    else if (y < 0) CHECK(gprintf(gops, go, "\33[%dA", -y));
    else if (y == +1) PUTLIT("\33[B"); /* not %|^J|%! */
    else if (y > 1) CHECK(gprintf(gops, go, "\33[%dB", y));

    /* Next, horizontal motion. */
    if (!(orig&TTOF_XCUR)) {
      /* Absolute positioning. Use a carriage return if (a) we want the
       * leftmost column anyway, or (b) the terminal can't handle absolute
       * horizontal positioning.
       */

      if (!x)
        PUTCH('\r');
      else if (tty->ocaps&TTCF_MIXMV)
        CHECK(gprintf(gops, go, "\33[%dG", x + 1));
      else
        CHECK(gprintf(gops, go, "\r\33[%dC", x));
    } else {
      /* Relative positioning.  We can go back one space simply using the
       * backspace control sequence.  The `CUB' sequence is at least four
       * characters long.
       */

      if (x == -1) PUTCH('\b');
      else if (-4 <= x && x < -1) CHECK(gops->putm(go, bs, -x));
      else if (x < 0) CHECK(gprintf(gops, go, "\33[%dD", -x));
      else if (x == +1) PUTLIT("\33[C");
      else if (x > 0) CHECK(gprintf(gops, go, "\33[%dC", x));
    }
  }

  /* Done. */
  rc = 0;
end:
  return (rc);
}

/* --- @ansi_erase@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Erase portions of the current line or the whole display.
 */

static int ansi_erase(struct tty *tty,
                      const struct gprintf_ops *gops, void *go,
                      unsigned f)
{
  int rc;

  if (f&TTEF_DSP)
    switch (f&(TTEF_BEGIN | TTEF_END)) {
      case 0: break;
      case TTEF_BEGIN: PUTLIT("\33[1J"); break;
      case TTEF_END: PUTLIT("\33[J"); break;
      case TTEF_BEGIN | TTEF_END: PUTLIT("\33[2J"); break;
    }
  else
    switch (f&(TTEF_BEGIN | TTEF_END)) {
      case 0: break;
      case TTEF_BEGIN: PUTLIT("\33[1K"); break;
      case TTEF_END: PUTLIT("\33[K"); break;
      case TTEF_BEGIN | TTEF_END: PUTLIT("\33[2K"); break;
    }
  rc = 0;
end:
  return (rc);
}

/* --- @ansi_erch@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned n@ = number of characters to erase
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Erase a number of characters, starting from and including the
 *              current cursor position.
 */

static int ansi_erch(struct tty *tty,
                     const struct gprintf_ops *gops, void *go,
                     unsigned n)
{
  int rc;

  if (n == 1) PUTLIT("\33[X");
  else if (n) CHECK(gprintf(gops, go, "\33[%uX", n));
  rc = 0;
end:
  return (rc);
}

/* --- @caps_ins@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *              @unsigned n@ = number of items to insert
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Insert a number of blank characters or lines.
 */

static int ansi_ins(struct tty *tty,
                    const struct gprintf_ops *gops, void *go,
                    unsigned f, unsigned n)
{
  int rc;

  if (f&TTIDF_LN) {
    if (n == 1) PUTLIT("\33[L");
    else if (n) CHECK(gprintf(gops, go, "\33[%uL", n));
  } else {
    if (n == 1) PUTLIT("\33[@");
    else if (n) CHECK(gprintf(gops, go, "\33[%u@", n));
  }
  rc = 0;
end:
  return (rc);
}

/* --- @caps_inch@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @int ch@ = character to insert
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Insert a single character.
 */

static int ansi_inch(struct tty *tty,
                     const struct gprintf_ops *gops, void *go,
                     int ch)
{
  /* There's actually nothing to do here except write the character. */
  if (!(tty->st.modes&TTMF_INS)) return (-1);
  else return (gops->putch(go, ch));
}

/* --- @caps_del@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *              @unsigned n@ = number of items to delete
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Delete a number of characters or lines.
 */

static int ansi_del(struct tty *tty,
                    const struct gprintf_ops *gops, void *go,
                    unsigned f, unsigned n)
{
  int rc;

  if (f&TTIDF_LN) {
    if (n == 1) PUTLIT("\33[M");
    else if (n) CHECK(gprintf(gops, go, "\33[%uM", n));
  } else {
    if (n == 1) PUTLIT("\33[P");
    else if (n) CHECK(gprintf(gops, go, "\33[%uP", n));
  }
  rc = 0;
end:
  return (rc);
}

#undef PUTCH
#undef PUTLIT
#undef SEMI

#undef CHECK

/* The ANSI operations table. */
static const struct tty_ops ansi_ops = {
  ansi_release,
  ansi_setattr, ansi_setmodes,
  ansi_move, stupid_repeat,
  ansi_erase, ansi_erch, ansi_ins, ansi_inch, ansi_del
};

/* --- @termcap_init@ --- *
 *
 * Arguments:   @FILE *fp@ = the output stream
 *
 * Returns:     A pointer to a fresh terminal control block, or null on
 *              failure.
 *
 * Use:         Initialize a terminal for use with ANSI control sequences.
 */

static struct tty *ansi_init(FILE *fp)
{
  /* Useful collections of capabilities. */
#define COLS_NO 0
#define COLS_8 (TTACF_FG | TTACF_BG | TTACF_1BPC)
#define COLS_16 (COLS_8 | TTACF_1BPCBR)
#define COLS_88 (COLS_16 | TTACF_4LPC | TTACF_8LGS)
#define COLS_256 (COLS_16 | TTACF_6LPC | TTACF_24LGS)
#define COLS_16M (COLS_256 | TTACF_8BPC)

#define EDIT_OPS (TTCF_ERCH |                                           \
                  TTCF_DELCH | TTCF_DELLN |                             \
                  TTCF_INSCH | TTCF_INSLN)

  /* Table of user-settable flags. */
  static const struct flagmap {
    const char *name;
    uint32 acaps, ocaps;
    unsigned tf;
  } flagmap[] = {
    { "dim",            TTACF_DIM,      0,              0 },
    { "uuline",         TTACF_UULINE,   0,              0 },
    { "strike",         TTACF_STRIKE,   0,              0 },
    { "ital",           TTACF_ITAL,     0,              0 },
    { "cvis",           0,              TTMF_CVIS,      0 },
    { "fscrn",          0,              TTMF_FSCRN,     0 },
    { "insmode",        0,              TTMF_INS,       0 },
    { "hvpa"    ,       0,              TTCF_MIXMV,     0 },
    { "edit",           0,              EDIT_OPS,       0 },
    { "cncattr",        0,              0,              TAF_CNCATTR },
    { "editn",          0,              0,              TAF_EDITN },
    { "semi",           0,              0,              TAF_SEMI },
    { 0,                0,              0,              0 }
  };

  /* Tables of enumerated setting values. */
  static const struct kw { const char *name; uint32 val; }
    kw_colours[] = {
      { "no",           COLS_NO },
      { "8",            COLS_8 },
      { "16",           COLS_16 },
      { "88",           COLS_88 },
      { "256",          COLS_256 },
      { "16m",          COLS_16M },
      { 0,              0 }
    };

  /* Table of enumerated settings. */
  static const struct enummap {
    const char *name;
    uint32 mask;
    const struct kw *kw;
  } enummap[] = {
    { "colours",        TTACF_CSPCMASK | TTACF_FG | TTACF_BG,
                                                        kw_colours },
    { 0,                0,                              0 }
  };

  /* Table of recognized terminal types. */
  static const struct termmap {
    const char *pat;
    unsigned acaps, ocaps, tf;
  } termmap[] = {

#define VT100_ACAPS (TTACF_ULINE | TTACF_BOLD | TTACF_INVV)
#define VT100_OCAPS (TTMF_AUTOM |                                       \
                     TTCF_RELMV | TTCF_ABSMV |                          \
                     TTCF_MMARG |                                       \
                     TTCF_ERBOL | TTCF_EREOL |                          \
                     TTCF_ERBOD | TTCF_EREOD | TTCF_ERDSP)
#define VT100_TF (0)

#define VT102_ACAPS (VT100_ACAPS)
#define VT102_OCAPS (VT100_OCAPS |                                      \
                     TTMF_INS |                                         \
                     TTCF_INSCH | TTCF_INSLN | TTCF_DELCH | TTCF_DELLN)
#define VT102_TF (VT100_TF)

#define VT220_ACAPS (VT102_ACAPS)
#define VT220_OCAPS (VT102_OCAPS | TTMF_CVIS | TTCF_ERCH)
#define VT220_TF (VT102_TF | TAF_CNCATTR | TAF_EDITN)

#define ECMA48_ACAPS (VT220_ACAPS | TTACF_DIM)
#define ECMA48_OCAPS (VT220_OCAPS | TTCF_MIXMV)
#define ECMA48_TF (VT220_TF)

#define XTERM_ACAPS (ECMA48_ACAPS)
#define XTERM_OCAPS (ECMA48_OCAPS | TTMF_FSCRN)
#define XTERM_TF (ECMA48_TF)

#define STRIKE TTACF_STRIKE
#define ITAL TTACF_ITAL
#define SEMI TAF_SEMI

#define T(pat, base, cols, acaps, ocaps, tf)                            \
  { pat,                                                                \
    base##_ACAPS | COLS_##cols | (acaps),                               \
    base##_OCAPS | (ocaps), base##_TF | (tf) }

    T("color_xterm",    XTERM,  8,      STRIKE | ITAL,  0,      0),

    T("gnome",          XTERM,  16M,    STRIKE | ITAL,  0,      SEMI),
  /*T("gonme-*"         XTERM,  16M,    STRIKE | ITAL,  0,      SEMI),*/

    T("linux",          XTERM,  16,     0,              0,      0),

    T("putty",          XTERM,  16M,    0,              0,      SEMI),

    T("vt100*",         VT100,  NO,     0,              0,      0),
    T("vt102*",         VT102,  NO,     0,              0,      0),
    T("vt[2-5][0-9][0-9]*", VT220, NO,  0,              0,      0),

    T("vte",            XTERM,  16M,    STRIKE | ITAL,  0,      SEMI),
  /*T("vte-*"           XTERM,  16M,    STRIKE | ITAL,  0,      SEMI),*/

    T("win",            XTERM,  16M,    0,              0,      SEMI),

    T("xterm",          XTERM,  16M,    STRIKE | ITAL,  0,      0),
    T("xterm-color",    XTERM,  8,      STRIKE | ITAL,  0,      0),
    T("xterm-16color",  XTERM,  16,     STRIKE | ITAL,  0,      0),
    T("xterm-88color",  XTERM,  88,     STRIKE | ITAL,  0,      SEMI),
    T("xterm-256color", XTERM,  256,    STRIKE | ITAL,  0,      SEMI),
    T("xterm-direct",   XTERM,  16M,    STRIKE | ITAL,  0,      0),
    T("xterm-*",        XTERM,  16M,    STRIKE | ITAL,  0,      0),

  /*T("*-color",        XTERM,  16,     0,              0,      0),*/
  /*T("*-16color",      XTERM,  16,     0,              0,      0),*/
    T("*-88color",      XTERM,  88,     0,              0,      SEMI),
    T("*-256color",     XTERM,  256,    0,              0,      SEMI),
    T("*-direct",       XTERM,  16M,    0,              0,      SEMI),

    T("*",              XTERM,  16,     0,              0,      0),
    { 0,                                0,              0,      0 }

#undef VT100_ACAPS
#undef VT100_OCAPS
#undef VT100_TF

#undef VT102_ACAPS
#undef VT102_OCAPS
#undef VT102_TF

#undef VT220_ACAPS
#undef VT220_OCAPS
#undef VT220_TF

#undef ECMA48_ACAPS
#undef ECMA48_OCAPS
#undef ECMA48_TF

#undef XTERM_ACAPS
#undef XTERM_OCAPS
#undef XTERM_TF

#undef STRIKE
#undef ITAL
#undef SEMI
  };

#undef COLS_NO
#undef COLS_8
#undef COLS_16
#undef COLS_88
#undef COLS_256
#undef COLS_16M

#undef EDIT_OPS

  union tty_ansiu *u = 0; struct tty *ret = 0;
  const char *term, *config, *p, *l;
  const struct kw *kw;
  const struct enummap *em;
  const struct flagmap *fm;
  const struct termmap *tm;
  size_t n, nn;
  unsigned
    acaps = 0, ocaps = 0, tf = 0,
    acapset = 0, ocapset = 0, tfset = 0,
    f = 0;
#define f_sense 1u

  /* Read the environment variables. */
  config = getenv("MLIB_TTY_ANSICONFIG");
  term = getenv("TERM");

  /* We're not going to touch Emacs's `dumb' terminal. */
  if (term && STRCMP(term, ==, "dumb")) goto end;

  /* Scan the user configuration first.  We'll keep track of masks for the
   * capabilities that we've set so that we don't clobber them later.
   */
  if (config) {
    l = config + strlen(config);
    for (;;) {

      /* Skip spaces. */
      for (;;)
        if (config >= l) goto done_config;
        else if (!ISSPACE(*config)) break;
        else config++;

      /* Find the length of the next space-sparated word. */
      for (p = config + 1; p < l && !ISSPACE(*p); p++);

      if (*config == '+' || *config == '-') {
        /* We've found a flag setting. */

        /* Track whether we're supposed to set or clear it. */
        if (*config == '+') f |= f_sense;
        else f &= ~f_sense;
        config++; n = p - config;

        /* Search for the flag name. */
        for (fm = flagmap; fm->name; fm++)
          if (STRNCMP(config, ==, fm->name, n) && !fm->name[n])
            goto found_flag;
        debug("unknown flag `%.*s'", (int)n, config); goto next_config;

      found_flag:
        /* Found it.  Check that we've not already seen this one. */
        if ((acapset&fm->acaps) || (ocapset&fm->ocaps) || (tfset&fm->tf)) {
          debug("duplicate setting for `%s'", fm->name);
          goto next_config;
        }

        /* Apply the setting. */
        if (f&f_sense)
          { acaps |= fm->acaps; ocaps |= fm->ocaps; tf |= fm->tf; }
        acapset |= fm->acaps; ocapset |= fm->ocaps; tfset |= fm->tf;
      } else {
        /* Must be an assignment of an enumerated setting. */

        n = p - config;

        /* Find the `%|=|%' separator. */
        p = memchr(config, '=', n);
        if (!p) {
          debug("missing `=' in setting `%.*s'", (int)n, config);
          goto next_config;
        }

        /* Search for the setting name. */
        nn = p - config;
        for (em = enummap; em->name; em++)
          if (STRNCMP(config, ==, em->name, nn) && !em->name[nn])
            goto found_enum;
        debug("unknown setting `%.*s'", (int)nn, config); goto next_config;

      found_enum:
        /* Found it.  Check that we've not already seen this one. */
        if (acapset&em->mask) {
          debug("duplicate setting for `%s'", em->name);
          goto next_config;
        }

        /* Now search for the value. */
        p++; nn = n - nn - 1;
        for (kw = em->kw; kw->name; kw++)
          if (STRNCMP(p, ==, kw->name, nn) && !kw->name[nn])
            goto found_kw;
        debug("unknown `%s' value `%.*s", em->name, (int)nn, p);
        goto next_config;

      found_kw:
        /* Found that too.  Apply the setting. */
        acaps |= kw->val; acapset |= em->mask;
      }

    next_config:
      /* Move on to the next word. */
      config += n;
    }
  done_config:;
  }

  /* Next, check our built-in table of terminal idiosyncrasies. */
  if (term) {
    for (tm = termmap; tm->pat; tm++)
      if (str_match(tm->pat, term))
        goto found_term;
    assert(0);
  found_term:
    acaps |= tm->acaps&~acapset;
    ocaps |= tm->ocaps&~ocapset;
    tf |= tm->tf&~tfset;
  }

  /* If the user hasn't already set how we handle colour, then check the
   * environment for more general advice.  Unlike `terminfo'-based backends,
   * we can handle colour upgrades as well as downgrades.
   */
  if (!(acapset&TTACF_CSPCMASK)) env_colour_caps(&acaps, ECCF_SET);

  /* If we can handle background colours, then we can erase to background. */
  if (acaps&TTACF_BG) ocaps |= TTCF_BGER;

  /* Set up a fresh control block. */
  XNEW(u);
  u->tty.ops = &ansi_ops;
  u->tty.acaps = acaps;
  u->tty.ocaps = ocaps;
  u->ansi.ansi.f = tf;
  u->tty.wd = 80; u->tty.ht = 25;
  u->tty.st.modes = TTMF_AUTOM | (u->tty.ocaps&TTMF_CVIS);
  u->tty.st.attr.f = 0; u->tty.st.attr.fg = u->tty.st.attr.bg = 0;
  common_init(&u->ansi.tty, fp, 0);

  /* All done. */
  ret = &u->tty; u = 0;
end:
  xfree(u); return (ret);

#undef f_sense
}

/*----- Backend selection -------------------------------------------------*/

/* --- @tty_open@ --- *
 *
 * Arguments:   @FILE *fp@ = stream open on terminal, or null
 *              @unsigned f@ = flags (@TTF_...@)
 *              @const unsigned *backends@ = ordered list of backends to try
 *
 * Returns:     Pointer to terminal control block, or null on error.
 *
 * Use:         Open a terminal and return a @struct tty *@ terminal control
 *              block pointer.
 *
 *              If @fp@ is provided, then it will be used for terminal
 *              output.  If @fp@ is @stdout@, then input (not currently
 *              supported) will come from @stdin@; otherwise, input comes
 *              from @fp@.  If @fp@ is null and @TTF_OPEN@ is set, then
 *              @tty_open@ will attempt to open a terminal for itself: if
 *              @stdin@ is interactive then it used for input; if @stdout@ --
 *              or, failing that, @stderr@ -- is interactive, then it is used
 *              for output; otherwise %|/dev/tty|% is opened and used.  If
 *              @fp@ is null and @TTF_OPEN@ is not set, then a usable
 *              terminal control block is still returned, but output cannot
 *              be sent directly to the terminal -- since there isn't one.
 *
 *              If @TTF_BORROW@ is set, then the stream will not be closed by
 *              @tty_close@.  (This flag is ignored if @fp@ is null.)
 *
 *              If @beckends@ is provided, then it points to a vector of
 *              @TTBK_...@ constants describing the backends to be tried in
 *              order.  The vector is terminated by @TTBK_END@; if this is
 *              found, then a null pointer is returned.
 *
 *              A null control block pointer is valid for all @tty@
 *              functions: most will just immediately report failure, but
 *              there won't be any crashing.
 */

struct tty *tty_open(FILE *fp, unsigned f, const unsigned *backends)
{
  static const struct betab {
    const char *name; unsigned code;
    struct tty *(*init)(FILE */*fp*/);
  } betab[] = {
#ifdef HAVE_UNIBILIUM
    { "unibilium",      TTBK_UNIBI,     termunibi_init },
#endif
#ifdef HAVE_TERMINFO
    { "terminfo",       TTBK_TERMINFO,  terminfo_init },
#endif
#ifdef HAVE_TERMCAP
    { "termcap",        TTBK_TERMCAP,   termcap_init },
#endif
    { "ansi",           TTBK_ANSI,      ansi_init },
    { 0,                0,              0 }
  };

  const struct betab *bt;
  const char *config, *p, *l;
  struct tty *tty = 0;
  FILE *fpin = 0;
  size_t n;

  if (fp || !(f&TTF_OPEN))
    fpin = fp != stdout ? fp : isatty(STDIN_FILENO) ? stdin : 0;
  else {
    if (isatty(STDIN_FILENO)) fpin = stdin;
    else fpin = 0;
    if (isatty(STDOUT_FILENO)) { fp = stdout; f |= TTF_BORROW; }
    else if (isatty(STDERR_FILENO)) { fp = stderr; f |= TTF_BORROW; }
    else {
      fp = fopen("/dev/tty", "r+"); if (!fp) goto end;
      fpin = fp; f &= ~TTF_BORROW;
    }
  }

  config = getenv("MLIB_TTY_BACKENDS");
  if (config) {
    l = config + strlen(config);
    for (;;) {
      for (;;)
        if (config >= l) goto done_config;
        else if (!ISSPACE(*config)) break;
        else config++;

      for (p = config + 1; p < l && !ISSPACE(*p); p++);
      n = p - config;

      for (bt = betab; bt->name; bt++)
        if (STRNCMP(config, ==, bt->name, n) && !bt->name[n])
          goto found_byname;
      debug("unknown backend `%.*s'", (int)n, config); goto next_config;
    found_byname:
      tty = bt->init(fp); if (tty) goto found;
      debug("failed to initialize `%s'", bt->name);
    next_config:
      config += n;
    }
  done_config:;
  } else if (backends)
    while (*backends) {
      for (bt = betab; bt->name; bt++)
        if (*backends == bt->code) goto found_bycode;
      debug("unknown backend code %u", *backends); goto next_code;
    found_bycode:
      tty = bt->init(fp); if (tty) goto found;
      debug("failed to initialize `%s'", bt->name);
    next_code:
      backends++;
    }
  else
    for (bt = betab; bt->name; bt++) {
      tty = bt->init(fp); if (tty) goto found;
      debug("failed to initialize `%s'", bt->name);
    }

  debug("all backends failed"); goto end;
found:
  debug("selected backend `%s'", bt->name);
  tty->fpin = fpin; tty->f = f; fp = 0;
end:
  if (fp && !(f&TTF_BORROW)) fclose(fp);
  return (tty);
}

/* --- @tty_close@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *
 * Returns:     ---
 *
 * Use:         Closes a terminal, releasing the control block and any
 *              resources it held.  In particular, if the terminal was opened
 *              without @TTF_BORROW@, then the output stream is closed.
 */

void tty_close(struct tty *tty)
{
  if (tty) {
    if (tty->fpout && !(tty->f&TTF_BORROW)) fclose(tty->fpout);
    tty->ops->release(tty); xfree(tty);
  }
}

/* --- @tty_resized@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *
 * Returns:     Zero if the size hasn't changed, %$+1$% if the size has
 *              changed, or %$-1$% on error.
 *
 * Use:         Update the terminal width and height.  Call this after
 *              receiving @SIGWINCH@, or otherwise periodically, to avoid
 *              making a mess.
 */

int tty_resized(struct tty *tty)
{
  struct winsize ws;

  if (!tty || !tty->fpout) { errno = ENOTTY; return (-1); }
  else if (ioctl(fileno(tty->fpout), TIOCGWINSZ, &ws)) return (-1);
  else if (tty->wd == ws.ws_col && tty->ht == ws.ws_row) return (0);
  else { tty->wd = ws.ws_col; tty->ht = ws.ws_row; return (1); }
}

/*----- Terminal operations -----------------------------------------------*/

/* --- @tty_setattr@, @tty_setattrg@--- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @const struct tty_attr *a@ = pointer to attributes to set, or
 *                      null
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Set the indicated formatting attributes on following output.
 *              If @a@ is null, then clear all attributes, just as if
 *              @a->f == 0@.
 *
 *              If you only ever request attributes which are advertised in
 *              the terminals capapbility masked, then you'll always get what
 *              you asked for.  Otherwise, the provided attributes will be
 *              `clamped', i.e., modified so as to accommodate the terminal's
 *              shortcomings.  In simple cases, unsupported attributes may
 *              just be dropped; but they can also be substituted, e.g.,
 *              single underlining for double, or approximate colours for
 *              unsupported colours.
 */

int tty_setattr(struct tty *tty, const struct tty_attr *a)
{
  struct tty_attr aa;

  if (!tty || !tty->fpout)
    return (-1);
  else {
    clamp_attr(&aa, a, tty->acaps);
    return (tty->ops->setattr(tty, &file_printops, tty->fpout, &aa));
  }
}

int tty_setattrg(struct tty *tty,
                 const struct gprintf_ops *gops, void *go,
                 const struct tty_attr *a)
{
  struct tty_attr aa;

  if (!tty)
    return (-1);
  else {
    clamp_attr(&aa, a, tty->acaps);
    return (tty->ops->setattr(tty, gops, go, &aa));
  }
}

/* --- @tty_setattrlist@, @tty_setattrlistg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @const struct tty_attrlist *aa@ = pointer to attribute list
 *                      `menu'
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Search the list for an entry matching the terminal's
 *              capabilities, i.e., @tty->acaps&a->cap_mask == a->cap_eq@.
 *              The attributes in the first such entry are set, as if by
 *              @tty_setattr@.
 *
 *              The list is terminated by an entry with @cap_mask == 0@ --
 *              though it will be checked like any other before ending the
 *              search.  In particular, this means that an entry with
 *              @cap_mask == cap_eq == 0@ is a `catch-all', and its
 *              attributes will be set if no earlier matching entry could be
 *              found, while an entry with @cap_mask == 0@ and @cap_eq != 0@
 *              terminates the search without setting any attributes.
 */

int tty_setattrlist(struct tty *tty, const struct tty_attrlist *aa)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty_setattrlistg(tty, &file_printops, tty->fpout, aa));
}

int tty_setattrlistg(struct tty *tty,
                     const struct gprintf_ops *gops, void *go,
                     const struct tty_attrlist *aa)
{
  if (!tty) return (-1);
  for (;; aa++)
    if ((tty->acaps&aa->cap_mask) == aa->cap_eq)
      return (tty->ops->setattr(tty, gops, go, &aa->attr));
    else if (!aa->cap_mask)
      return (0);
}

/* --- @tty_setmodes@, @tty_setmodesg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @uint32 modes_bic, modes_xor@ = masks to apply to the modes
 *                      settings
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Adjust the terminal display modes: specifically, the modes
 *              are adjusted to be @(modes&~modes_bic) ^ modes_xor@.
 *              Mode bits which aren't supported by the terminal are
 *              ignored.
 */

int tty_setmodes(struct tty *tty, uint32 modes_bic, uint32 modes_xor)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty->ops->setmodes(tty, &file_printops, tty->fpout,
                                  modes_bic, modes_xor));
}

int tty_setmodesg(struct tty *tty,
                  const struct gprintf_ops *gops, void *go,
                  uint32 modes_bic, uint32 modes_xor)
{
  if (!tty) return (-1);
  else return (tty->ops->setmodes(tty, gops, go, modes_bic, modes_xor));
}

/* --- @tty_move@, @tty_moveg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned orig@ = origin
 *              @int y, x@ = new cursor position
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Move the cursor.  Coordinates are numbered starting with 0.
 *
 *              The @y@ position is interpreted relative to the origin given
 *              by @orig@: if @TTOF_YCUR@ is set, then the motion is relative
 *              to the current cursor row; otherwise, it is relative to
 *              the top `home' row.  Similarly, the @x@ position is
 *              interpreted relative to the current cursor column if
 *              @TTOF_XCUR is set, otherwise relative to the leftmost
 *              column.
 *
 *              Not all terminals are capable of all kinds of motions:
 *              @TTCF_ABSMV@ is set if absolute motion is possible, and
 *              @TTCF_RELMV@ is set if relative motion is possible.  The
 *              @TTCF_MIXMV@ bit indicates that the combination of absolute-y
 *              and relative-x motion is possible; note that the combination
 *              of relative-y and absolute-x is always possible if relative
 *              motion is possible at all.
 *
 *              The above notwithstanding, all terminals are assumed capable
 *              of moving the cursor to the start of either the current line
 *              @tty_move(tty, TTOF_YCUR | TTOF_XHOME, 0, 0)@, or of the next
 *              line @tty_move(tty, TTOF_YCUR | TTOF_XHOME, +1, 0)@.
 */

int tty_move(struct tty *tty, unsigned orig, int y, int x)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty->ops->move(tty, &file_printops, tty->fpout, orig, y, x));
}

int tty_moveg(struct tty *tty,
              const struct gprintf_ops *gops, void *go,
              unsigned orig, int y, int x)
{
  if (!tty) return (-1);
  else return (tty->ops->move(tty, gops, go, orig, y, x));
}

/* --- @tty_repeat@, @tty_repeatg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @int ch@ = character to write
 *              @unsigned n@ = number of copies
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Write @n@ copies of the character @ch@ to the terminal.
 *              (Some terminals have a special control sequence for doing
 *              this.)
 */

int tty_repeat(struct tty *tty, int ch, unsigned n)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty->ops->repeat(tty, &file_printops, tty->fpout, ch, n));
}

int tty_repeatg(struct tty *tty,
                const struct gprintf_ops *gops, void *go,
                int ch, unsigned n)
{
  if (!tty) return (-1);
  else return (tty->ops->repeat(tty, gops, go, ch, n));
}

/* --- @tty_erase@, @tty_eraseg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Erase portions of the current line or the whole display.
 *
 *              If @TTEF_DSP@ is set, then the whole display is affected.  If
 *              @TTEF_BEGIN@ is set, then the display is erased starting from
 *              the top left and ending at and including the cursor
 *              position.  If @TTEF_END@ is set, then the display is erased
 *              starting from and including the cursor position, and ending
 *              at the bottom right.  If both flags are set, then,
 *              additionally, the cursor is moved to its `home' position at
 *              the top left.
 *
 *              If @TTF_DSP@ is not set, then the current line is affected.
 *              If @TTEF_BEGIN@ is set, then the line is erased starting from
 *              the left and ending at and including the cursor position.  If
 *              @TTEF_END@ is set, then the line is erased starting from and
 *              including the cursor position, and ending at the right hand
 *              side.
 *
 *              If the @TTCF_BGER@ capability is set, then the erased
 *              positions take on the current background colour; otherwise,
 *              they have the default background colour.
 */

int tty_erase(struct tty *tty, unsigned f)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty->ops->erase(tty, &file_printops, tty->fpout, f));
}

int tty_eraseg(struct tty *tty,
               const struct gprintf_ops *gops, void *go,
               unsigned f)
{
  if (!tty) return (-1);
  else return (tty->ops->erase(tty, gops, go, f));
}

/* --- @tty_erch@, @tty_erchg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned n@ = number of characters to erase
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Erase a number of characters, starting from and including the
 *              current cursor position.
 *
 *              If the @TTCF_BGER@ capability is set, then the erased
 *              positions take on the current background colour; otherwise,
 *              they have the default background colour.
 */

int tty_erch(struct tty *tty, unsigned n)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty->ops->erch(tty, &file_printops, tty->fpout, n));
}

int tty_erchg(struct tty *tty,
              const struct gprintf_ops *gops, void *go,
              unsigned n)
{
  if (!tty) return (-1);
  else return (tty->ops->erch(tty, gops, go, n));
}

/* --- @tty_ins@, @tty_insg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *              @unsigned n@ = number of items to insert
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Insert a number of blank characters or lines.
 *
 *              If @TTIDF_LN@ is set, then insert @n@ blank lines above the
 *              current line.  The cursor must be at the far left of the
 *              line.
 *
 *              Otherwise, insert @n@ empty character spaces at the cursor
 *              position.
 */

int tty_ins(struct tty *tty, unsigned f, unsigned n)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty->ops->ins(tty, &file_printops, tty->fpout, f, n));
}

int tty_insg(struct tty *tty,
             const struct gprintf_ops *gops, void *go,
             unsigned f, unsigned n)
{
  if (!tty) return (-1);
  else return (tty->ops->ins(tty, gops, go, f, n));
}

/* --- @tty_inch@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @int ch@ = character to insert
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Insert a single character.
 *
 *              If the @TTMF_INS@ mode is advertised, then insert mode must
 *              be set before calling this function.
 */

int tty_inch(struct tty *tty, int ch)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty->ops->inch(tty, &file_printops, tty->fpout, ch));
}

int tty_inchg(struct tty *tty,
              const struct gprintf_ops *gops, void *go,
              int ch)
{
  if (!tty) return (-1);
  else return (tty->ops->inch(tty, gops, go, ch));
}

/* --- @tty_del@, @tty_delg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @unsigned f@ = flags
 *              @unsigned n@ = number of items to delete
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Delete a number of characters or lines.
 *
 *              If @TTIDF_LN@ is set, then delete @n@ blank lines, starting
 *              with the current line line.  The cursor must be at the far
 *              left of the line.
 *
 *              Otherwise, delete @n@ characters at the cursor position.
 */

int tty_del(struct tty *tty, unsigned f, unsigned n)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty->ops->del(tty, &file_printops, tty->fpout, f, n));
}

int tty_delg(struct tty *tty,
             const struct gprintf_ops *gops, void *go,
             unsigned f, unsigned n)
{
  if (!tty) return (-1);
  else return (tty->ops->del(tty, gops, go, f, n));
}

/* --- @tty_restore@, @tty_restoreg@ --- *
 *
 * Arguments:   @struct tty *tty@ = control block pointer
 *              @const struct gprintf_ops *gops, void *go@ = output
 *                      destination
 *              @const struct tty_state *st@ = state to restore
 *
 * Returns:     Zero on success, %$-1$% on error.
 *
 * Use:         Restore the terminal modes and attributes to match a
 *              state previously captured by copying @tty->st@.
 */

int tty_restore(struct tty *tty, const struct tty_state *st)
{
  if (!tty || !tty->fpout) return (-1);
  else return (tty_restoreg(tty, &file_printops, tty->fpout, st));
}

int tty_restoreg(struct tty *tty,
                 const struct gprintf_ops *gops, void *go,
                 const struct tty_state *st)
{
  int rc;

  if (!tty ||
      tty->ops->setmodes(tty, gops, go, MASK32, st->modes) ||
      tty->ops->setattr(tty, gops, go, &st->attr))
    { rc = -1; goto end; }
  rc = 0;
end:
  return (rc);
}

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