src/utils/tfmtodit/tfmtodit.cpp - master - niceSOFT/groff

src/utils/tfmtodit/tfmtodit.cpp
954 строки22 KB
G. Branden Robinson
[tfmtodit]: Be more fastidious with heap memory.
29 май 2026, 07:56
29 май 2026, 07:56dd08f60
/* Copyright 1989 Free Software Foundation, Inc.

Written by James Clark (jjc@jclark.com)

This file is part of groff, the GNU roff typesetting system.

groff is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation, either version 3 of the License, or
(at your option) any later version.

groff 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 General Public License
for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>. */

/* I have tried to incorporate the changes needed for TeX 3.0 tfm files,
but I haven't tested them. */

/* Groff requires more font metric information than TeX.  The reason
for this is that TeX has separate Math Italic fonts, whereas groff
uses normal italic fonts for math.  The two additional pieces of
information required by groff correspond to the two arguments to the
math_fit() macro in the Metafont programs for the CM fonts. In the
case of a font for which math_fitting is false, these two arguments
are normally ignored by Metafont. We need to get hold of these two
parameters and put them in the groff font file.

We do this by loading this definition after cmbase when creating
cm.base.

def ignore_math_fit(expr left_adjustment,right_adjustment) =
 special "adjustment";
 numspecial left_adjustment*16/designsize;
 numspecial right_adjustment*16/designsize;
 enddef;

This puts the two arguments to the math_fit macro into the gf file.
(They will appear in the gf file immediately before the character to
which they apply.)  We then create a gf file using this cm.base.  Then
we run tfmtodit and specify this gf file with the -g option.

This need only be done for a font for which math_fitting is false;
When it's true, the left_correction and subscript_correction should
both be zero. */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <assert.h>
#include <errno.h>
#include <math.h> // atan2(), M_PI
#include <stdcountof.h>
#include <stdlib.h> // exit(), EXIT_FAILURE, EXIT_SUCCESS, strtol()
#include <string.h> // memcmp(), strcmp(), strdup(), strerror(),
		    // strlen(), strrchr(), strtok()

#include <getopt.h> // getopt_long()

#include <new> // std::bad_alloc

// needed for DIR_SEPS, FOPEN_RB
#include "posix.h"
#include "nonposix.h"

#include "lib.h"

#include "errarg.h"
#include "error.h"
#include "cset.h"

extern "C" const char *Version_string;

/* Values in the tfm file should be multiplied by this. */

#define MULTIPLIER 1

struct char_info_word {
  unsigned char width_index;
  unsigned char height_index;
  unsigned char depth_index;
  unsigned char italic_index;
  unsigned char tag;
  unsigned char remainder;
};

struct lig_kern_command {
  unsigned char skip_byte;
  unsigned char next_char;
  unsigned char op_byte;
  unsigned char remainder;
};

class tfm {
  int bc;
  int ec;
  int nw;
  int nh;
  int nd;
  int ni;
  int nl;
  int nk;
  int np;
  int cs;
  int ds;
  char_info_word *char_info;
  int *width;
  int *height;
  int *depth;
  int *italic;
  lig_kern_command *lig_kern;
  int *kern;
  int *param;
public:
  tfm();
  ~tfm();
  bool load(const char *);
  bool contains(int);
  int get_width(int);
  int get_height(int);
  int get_depth(int);
  int get_italic(int);
  bool get_param(int, int *);
  int get_checksum();
  int get_design_size();
  bool get_lig(unsigned char, unsigned char, unsigned char *);
  friend class kern_iterator;
};

class kern_iterator {
  tfm *t;
  int c;
  int i;
public:
  kern_iterator(tfm *);
  bool next(unsigned char *c1, unsigned char *c2, int *k);
};


kern_iterator::kern_iterator(tfm *p)
: t(p), c(t->bc), i(-1)
{
}

bool kern_iterator::next(unsigned char *c1, unsigned char *c2, int *k)
{
  for (; c <= t->ec; c++)
    if (t->char_info[c - t->bc].tag == 1) {
      if (i < 0) {
	i = t->char_info[c - t->bc].remainder;
	if (t->lig_kern[i].skip_byte > 128)
	  i = ((256 * t->lig_kern[i].op_byte)
	       + t->lig_kern[i].remainder);
      }
      for (;;) {
	int skip = t->lig_kern[i].skip_byte;
	if (skip <= 128 && t->lig_kern[i].op_byte >= 128) {
	  *c1 = c;
	  *c2 = t->lig_kern[i].next_char;
	  *k = t->kern[(256 * (t->lig_kern[i].op_byte - 128))
		       + t->lig_kern[i].remainder];
	  if (skip == 128) {
	    c++;
	    i = -1;
	  }
	  else
	    i += skip + 1;
	  return true;
	}
	if (skip >= 128)
	  break;
	i += skip + 1;
      }
      i = -1;
    }
  return false;
}

tfm::tfm()
: char_info(0 /* nullptr */), width(0 /* nullptr */),
  height(0 /* nullptr */), depth(0 /* nullptr */),
  italic(0 /* nullptr */), lig_kern(0 /* nullptr */),
  kern(0 /* nullptr */), param(0 /* nullptr */)
{
}

bool tfm::get_lig(unsigned char c1, unsigned char c2, unsigned char *cp)
{
  if (contains(c1) && char_info[c1 - bc].tag == 1) {
    int i = char_info[c1 - bc].remainder;
    if (lig_kern[i].skip_byte > 128)
      i = (256 * lig_kern[i].op_byte) + lig_kern[i].remainder;
    for (;;) {
      int skip = lig_kern[i].skip_byte;
      if (skip > 128)
	break;
      // We are only interested in normal ligatures, for which
      // op_byte == 0.
      if (lig_kern[i].op_byte == 0
	  && lig_kern[i].next_char == c2) {
	*cp = lig_kern[i].remainder;
	return true;
      }
      if (skip == 128)
	break;
      i += skip + 1;
    }
  }
  return false;
}

bool tfm::contains(int i)
{
  return (i >= bc) && (i <= ec) && (char_info[i - bc].width_index != 0);
}

int tfm::get_width(int i)
{
  return width[char_info[i - bc].width_index];
}

int tfm::get_height(int i)
{
  return height[char_info[i - bc].height_index];
}

int tfm::get_depth(int i)
{
  return depth[char_info[i - bc].depth_index];
}

int tfm::get_italic(int i)
{
  return italic[char_info[i - bc].italic_index];
}

bool tfm::get_param(int i, int *p)
{
  if ((i <= 0) || (i > np))
    return false;
  else {
    *p = param[i - 1];
    return true;
  }
}

int tfm::get_checksum()
{
  return cs;
}

int tfm::get_design_size()
{
  return ds;
}

tfm::~tfm()
{
  delete[] char_info;
  delete[] width;
  delete[] height;
  delete[] depth;
  delete[] italic;
  delete[] lig_kern;
  delete[] kern;
  delete[] param;
}

static int read2(unsigned char *&s)
{
  int n;
  n = *s++ << 8;
  n |= *s++;
  return n;
}

static int read4(unsigned char *&s)
{
  int n;
  n = *s++ << 24;
  n |= *s++ << 16;
  n |= *s++ << 8;
  n |= *s++;
  return n;
}

bool tfm::load(const char *file)
{
  errno = 0;
  FILE *fp = fopen(file, FOPEN_RB);
  if (0 /* nullptr */ == fp) {
    error("cannot open '%1': %2", file, strerror(errno));
    return false;
  }
  int c1 = getc(fp);
  int c2 = getc(fp);
  if ((c1 == EOF) || (c2 == EOF)) {
    fclose(fp);
    error("unexpected end of file on '%1'", file);
    return false;
  }
  int lf = (c1 << 8) + c2;
  int toread = (lf * 4) - 2;
  unsigned char *buf = 0 /* nullptr */;
  try {
    buf = new unsigned char[toread];
  }
  catch (const std::bad_alloc &e) {
    fatal("cannot allocate %1 bytes for storage of contents of TFM file"
	  " '%2'", toread, file);
  }
  if (fread(buf, 1, toread, fp) != (size_t)toread) {
    if (feof(fp))
      error("unexpected end of file on '%1'", file);
    else
      error("error on file '%1'", file);
    delete[] buf;
    fclose(fp);
    return false;
  }
  fclose(fp);
  if (lf < 6) {
    error("invalid TFM file '%1': impossibly short", file);
    delete[] buf;
    return false;
  }
  unsigned char *ptr = buf;
  int lh = read2(ptr);
  bc = read2(ptr);
  ec = read2(ptr);
  nw = read2(ptr);
  nh = read2(ptr);
  nd = read2(ptr);
  ni = read2(ptr);
  nl = read2(ptr);
  nk = read2(ptr);
  int ne = read2(ptr);
  np = read2(ptr);
  if ((6 + lh + (ec - bc + 1) + nw + nh + nd + ni + nl + nk + ne + np)
      != lf) {
    error("invalid TFM file '%1': lengths do not sum", file);
    delete[] buf;
    return false;
  }
  if (lh < 2) {
    error("invalid TFM file '%1': header too short", file);
    delete[] buf;
    return false;
  }
  // These are pretty meager allocations, so try/catch them all at once.
  size_t amount = ((ec - bc + 1) * sizeof(char_info_word)
		  + (nw * sizeof(int))
		  + (nh * sizeof(int))
		  + (nd * sizeof(int))
		  + (ni * sizeof(int))
		  + (nl * sizeof(lig_kern_command))
		  + (nk * sizeof(int))
		  + (np * sizeof(int)));
  try {
    char_info = new char_info_word[ec - bc + 1];
    width = new int[nw];
    height = new int[nh];
    depth = new int[nd];
    italic = new int[ni];
    lig_kern = new lig_kern_command[nl];
    kern = new int[nk];
    param = new int[np];
  }
  catch (const std::bad_alloc &e) {
    fatal("cannot allocate %1 bytes for storage of font metrics in file"
	  " '%2'", amount, file);
  }
  cs = read4(ptr);
  ds = read4(ptr);
  ptr += (lh - 2) * 4;
  int i;
  for (i = 0; (i < (ec - bc + 1)); i++) {
    char_info[i].width_index = *ptr++;
    unsigned char tem = *ptr++;
    char_info[i].depth_index = tem & 0xf;
    char_info[i].height_index = tem >> 4;
    tem = *ptr++;
    char_info[i].italic_index = tem >> 2;
    char_info[i].tag = tem & 3;
    char_info[i].remainder = *ptr++;
  }
  for (i = 0; i < nw; i++)
    width[i] = read4(ptr);
  for (i = 0; i < nh; i++)
    height[i] = read4(ptr);
  for (i = 0; i < nd; i++)
    depth[i] = read4(ptr);
  for (i = 0; i < ni; i++)
    italic[i] = read4(ptr);
  for (i = 0; i < nl; i++) {
    lig_kern[i].skip_byte = *ptr++;
    lig_kern[i].next_char = *ptr++;
    lig_kern[i].op_byte = *ptr++;
    lig_kern[i].remainder = *ptr++;
  }
  for (i = 0; i < nk; i++)
    kern[i] = read4(ptr);
  ptr += (ne * 4);
  for (i = 0; i < np; i++)
    param[i] = read4(ptr);
  assert(ptr == (buf + (lf * 4) - 2));
  delete[] buf;
  return true;
}

class gf {
  int left[256];
  int right[256];
  static int sread4(int *p, FILE *fp);
  static int uread3(int *p, FILE *fp);
  static int uread2(int *p, FILE *fp);
  static bool skip(int n, FILE *fp);
public:
  gf();
  bool load(const char *file);
  int get_left_adjustment(int i) { return left[i]; }
  int get_right_adjustment(int i) { return right[i]; }
};

gf::gf()
{
  for (int i = 0; i < 256; i++)
    left[i] = right[i] = 0;
}

bool gf::load(const char *file)
{
  enum {
    paint_0 = 0,
    paint1 = 64,
    boc = 67,
    boc1 = 68,
    eoc = 69,
    skip0 = 70,
    skip1 = 71,
    new_row_0 = 74,
    xxx1 = 239,
    yyy = 243,
    no_op = 244,
    pre = 247,
    post = 248
  };
  bool got_an_adjustment = false;
  bool is_adjustment_pending = false;
  int left_adj = 0, right_adj = 0;	// pacify compiler
  const int gf_id_byte = 131;
  errno = 0;
  FILE *fp = fopen(file, FOPEN_RB);
  if (0 /* nullptr */ == fp) {
    error("cannot open '%1': %2", file, strerror(errno));
    return false;
  }
  if (getc(fp) != pre || getc(fp) != gf_id_byte) {
    error("invalid gf file");
    return false;
  }
  int n = getc(fp);
  if (n == EOF)
    goto eof;
  if (!skip(n, fp))
    goto eof;
  for (;;) {
    int op = getc(fp);
    if (op == EOF)
      goto eof;
    if (op == post)
      break;
    if (((op >= paint_0) && (op <= (paint_0 + 63)))
	|| ((op >= new_row_0) && (op <= (new_row_0 + 164))))
      continue;
    switch (op) {
    case no_op:
    case eoc:
    case skip0:
      break;
    case paint1:
    case skip1:
      if (!skip(1, fp))
	goto eof;
      break;
    case paint1 + 1:
    case skip1 + 1:
      if (!skip(2, fp))
	goto eof;
      break;
    case paint1 + 2:
    case skip1 + 2:
      if (!skip(3, fp))
	goto eof;
      break;
    case boc:
      {
	int code;
	if (!sread4(&code, fp))
	  goto eof;
	if (is_adjustment_pending) {
	  is_adjustment_pending = false;
	  left[code & 0377] = left_adj;
	  right[code & 0377] = right_adj;
	}
	if (!skip(20, fp))
	  goto eof;
	break;
      }
    case boc1:
      {
	int code = getc(fp);
	if (code == EOF)
	  goto eof;
	if (is_adjustment_pending) {
	  is_adjustment_pending = false;
	  left[code] = left_adj;
	  right[code] = right_adj;
	}
	if (!skip(4, fp))
	  goto eof;
	break;
      }
    case xxx1:
      {
	int len = getc(fp);
	if (len == EOF)
	  goto eof;
	char buf[256];
	if (fread(buf, 1, len, fp) != (size_t)len)
	  goto eof;
	if (len == 10 /* strlen("adjustment") */
	    && memcmp(buf, "adjustment", len) == 0) {
	  int c = getc(fp);
	  if (c != yyy) {
	    if (c != EOF)
	      ungetc(c, fp);
	    break;
	  }
	  if (!sread4(&left_adj, fp))
	    goto eof;
	  c = getc(fp);
	  if (c != yyy) {
	    if (c != EOF)
	      ungetc(c, fp);
	    break;
	  }
	  if (!sread4(&right_adj, fp))
	    goto eof;
	  got_an_adjustment = true;
	  is_adjustment_pending = true;
	}
	break;
      }
    case xxx1 + 1:
      if (!uread2(&n, fp) || !skip(n, fp))
	goto eof;
      break;
    case xxx1 + 2:
      if (!uread3(&n, fp) || !skip(n, fp))
	goto eof;
      break;
    case xxx1 + 3:
      if (!sread4(&n, fp) || !skip(n, fp))
	goto eof;
      break;
    case yyy:
      if (!skip(4, fp))
	goto eof;
      break;
    default:
      fatal("unrecognized opcode '%1'", op);
      break;
    }
  }
  if (!got_an_adjustment)
    warning("no adjustment specials found in gf file");
  return true;
 eof:
  error("unexpected end of file");
  return false;
}

int gf::sread4(int *p, FILE *fp)
{
  *p = getc(fp);
  if (*p >= 128)
    *p -= 256;
  *p <<= 8;
  *p |= getc(fp);
  *p <<= 8;
  *p |= getc(fp);
  *p <<= 8;
  *p |= getc(fp);
  return !ferror(fp) && !feof(fp);
}

int gf::uread3(int *p, FILE *fp)
{
  *p = getc(fp);
  *p <<= 8;
  *p |= getc(fp);
  *p <<= 8;
  *p |= getc(fp);
  return !ferror(fp) && !feof(fp);
}

int gf::uread2(int *p, FILE *fp)
{
  *p = getc(fp);
  *p <<= 8;
  *p |= getc(fp);
  return !ferror(fp) && !feof(fp);
}

bool gf::skip(int n, FILE *fp)
{
  while (--n >= 0)
    if (getc(fp) == EOF)
      return false;
  return true;
}


// TODO: Migrate to an STL container.
struct char_list {
  char *ch;
  char_list *next;
  char_list(const char *, char_list * = 0);
  ~char_list();
};

char_list::char_list(const char *s, char_list *p) : ch(strdup(s)),
		     next(p)
{
}

char_list::~char_list()
{
  free(ch);
}


static bool read_map(const char *file, char_list **table)
{
  errno = 0;
  FILE *fp = fopen(file, "r");
  if (0 /* nullptr */ == fp) {
    error("cannot open '%1': %2", file, strerror(errno));
    return false;
  }
  for (int i = 0; i < 256; i++)
    table[i] = 0;
  char buf[512];
  int lineno = 0;
  while (fgets(buf, int(sizeof(buf)), fp)) {
    lineno++;
    char *ptr = buf;
    while (csspace(*ptr))
      ptr++;
    if (*ptr == '\0' || *ptr == '#')
      continue;
    ptr = strtok(ptr, " \n\t");
    if (0 /* nullptr */ == ptr)
      continue;
    int n;
    if (sscanf(ptr, "%d", &n) != 1) {
      error("%1:%2: invalid map file", file, lineno);
      fclose(fp);
      return false;
    }
    if (n < 0 || n > 255) {
      error("%1:%2: code %3 out of range", file, lineno, n);
      fclose(fp);
      return false;
    }
    ptr = strtok(0 /* nullptr */, " \n\t");
    if (0 /* nullptr */ == ptr) {
      error("%1:%2: missing names", file, lineno);
      fclose(fp);
      return false;
    }
    for (;
	 ptr != 0 /* nullptr */;
	 ptr = strtok(0 /* nullptr */, " \n\t"))
      table[n] = new char_list(ptr, table[n]);
  }
  fclose(fp);
  return true;
}


/* Every character that can participate in a ligature appears in the
lig_chars table. 'ch' gives the full-name of the character, 'name'
gives the groff name of the character, 'i' gives its index in
the encoding, which is filled in later  (-1 if it does not appear). */

struct S {
  const char *ch;
  int i;
} lig_chars[] = {
  { "f", -1 },
  { "i", -1 },
  { "l", -1 },
  { "ff", -1 },
  { "fi", -1 },
  { "fl", -1 },
  { "Fi", -1 },
  { "Fl", -1 },
};

// Indices into lig_chars[].

enum { CH_f, CH_i, CH_l, CH_ff, CH_fi, CH_fl, CH_ffi, CH_ffl };

// Each possible ligature appears in this table.

struct S2 {
  unsigned char c1, c2, res;
  const char *ch;
} lig_table[] = {
  { CH_f, CH_f, CH_ff, "ff" },
  { CH_f, CH_i, CH_fi, "fi" },
  { CH_f, CH_l, CH_fl, "fl" },
  { CH_ff, CH_i, CH_ffi, "ffi" },
  { CH_ff, CH_l, CH_ffl, "ffl" },
  };

static void usage(FILE *stream)
{
  fprintf(stream,
"usage: %s [-s] [-g gf-file] [-k skew-char] tfm-file map-file font\n"
"usage: %s {-v | --version}\n"
"usage: %s --help\n",
	  program_name, program_name, program_name);
  if (stdout == stream)
    fputs("\n"
"Create a font description file for use with groff(1)'s 'dvi' output\n"
"device.  See the tfmtodit(1) manual page.\n",
	  stream);
}

int main(int argc, char **argv)
{
  program_name = argv[0];
  bool is_font_special = false;
  int skewchar = -1;
  int opt;
  const char *gf_file = 0;
  static const struct option long_options[] = {
    { "help", no_argument, 0 /* nullptr */, CHAR_MAX + 1 },
    { "version", no_argument, 0 /* nullptr */, 'v' },
    { 0 /* nullptr */, 0, 0 /* nullptr */, 0 }
  };
  while ((opt = getopt_long(argc, argv, ":svg:k:", long_options,
			    0 /* nullptr */))
	 != EOF)
    switch (opt) {
    case 'g':
      gf_file = optarg;
      break;
    case 's':
      is_font_special = true;
      break;
    case 'k':
      {
	char *ptr;
	long n = strtol(optarg, &ptr, 0);
	if (ptr == optarg || *ptr != '\0' || n < 0 || n > UCHAR_MAX)
	  error("invalid skew character position '%1'", optarg);
	else
	  skewchar = (int)n;
	break;
      }
    case 'v':
      {
	printf("GNU tfmtodit (groff) version %s\n", Version_string);
	exit(EXIT_SUCCESS);
	break;
      }
    case CHAR_MAX + 1: // --help
      usage(stdout);
      exit(EXIT_SUCCESS);
      break;
    case '?':
      if (optopt != 0)
	error("unrecognized command-line option '%1'", char(optopt));
      else
	error("unrecognized command-line option '%1'",
	      argv[(optind - 1)]);
      usage(stderr);
      exit(2);
    case ':':
      error("command-line option '%1' requires an argument",
           char(optopt));
      usage(stderr);
      exit(2);
      break;
      break;
    default:
      assert(0 == "EOF encountered in option processing");
    }
  if (argc - optind != 3) {
    error("insufficient arguments");
    usage(stderr);
    exit(2);
  }
  gf g;
  if (gf_file) {
    if (!g.load(gf_file))
      exit(EXIT_FAILURE);
  }
  const char *tfm_file = argv[optind];
  const char *map_file = argv[optind + 1];
  const char *font_file = argv[optind + 2];
  tfm t;
  if (!t.load(tfm_file))
    exit(EXIT_FAILURE);
  char_list *table[256];
  if (!read_map(map_file, table))
    exit(EXIT_FAILURE);
  errno = 0;
  if (!freopen(font_file, "w", stdout))
    fatal("cannot open '%1' for writing: %2", font_file,
	  strerror(errno));
  printf("name %s\n", font_file);
  if (is_font_special)
    fputs("special\n", stdout);
  size_t amount = strlen(argv[optind]);
  char *internal_name = strdup(argv[optind]);
  if (0 /* nullptr */ == internal_name)
    fatal("cannot allocate %1 bytes to copy tfm-file operand", amount);
  size_t len = strlen(internal_name);
  if ((len > 4) && (strcmp(internal_name + len - 4, ".tfm") == 0))
    internal_name[len - 4] = '\0';
  // DIR_SEPS[] are possible directory separator characters, see
  // nonposix.h.  We want the rightmost separator of all possible ones.
  // Example: d:/foo\\bar.
  const char *s = strrchr(internal_name, DIR_SEPS[0]), *s1;
  const char *sep = &DIR_SEPS[1];
  while (*sep)
    {
      s1 = strrchr(internal_name, *sep);
      if (s1 && (!s || s1 > s))
	s = s1;
      sep++;
    }
  printf("internalname %s\n", s ? (s + 1) : internal_name);
  free(internal_name);
  int n;
  if (t.get_param(2, &n)) {
    if (n > 0)
      printf("spacewidth %d\n", n * MULTIPLIER);
  }
  if (t.get_param(1, &n) && (n != 0))
    printf("slant %f\n",
	   atan2(n / double(1 << 20), 1.0) * 180.0 / M_PI);
  int xheight;
  if (!t.get_param(5, &xheight))
    xheight = 0;
  unsigned int i;
  // Print the list of ligatures.
  // First find the indices of each character that can participate in
  // a ligature.
  size_t lig_char_entries = countof(lig_chars);
  size_t lig_table_entries = countof(lig_table);
  for (i = 0; i < 256; i++)
    for (unsigned int j = 0; j < lig_char_entries; j++)
      for (char_list *p = table[i]; p; p = p->next)
	if (strcmp(lig_chars[j].ch, p->ch) == 0)
	  lig_chars[j].i = i;
  // For each possible ligature, if its participants all exist,
  // and it appears as a ligature in the tfm file, include in
  // the list of ligatures.
  int started = 0;
  for (i = 0; i < lig_table_entries; i++) {
    int i1 = lig_chars[lig_table[i].c1].i;
    int i2 = lig_chars[lig_table[i].c2].i;
    int r = lig_chars[lig_table[i].res].i;
    if (i1 >= 0 && i2 >= 0 && r >= 0) {
      unsigned char c;
      if (t.get_lig(i1, i2, &c) && c == r) {
	if (!started) {
	  started = 1;
	  fputs("ligatures", stdout);
	}
	printf(" %s", lig_table[i].ch);
      }
    }
  }
  if (started)
    fputs(" 0\n", stdout);
  printf("checksum %d\n", t.get_checksum());
  printf("designsize %d\n", t.get_design_size());
  // Now print out the kerning information.
  int had_kern = 0;
  kern_iterator iter(&t);
  unsigned char c1, c2;
  int k;
  while (iter.next(&c1, &c2, &k))
    if (c2 != skewchar) {
      k *= MULTIPLIER;
      char_list *q = table[c2];
      for (char_list *p1 = table[c1];
	   p1 != 0 /* nullptr */;
	   p1 = p1->next)
	for (char_list *p2 = q; p2 != 0 /* nullptr */; p2 = p2->next) {
	  if (!had_kern) {
	    printf("kernpairs\n");
	    had_kern = 1;
	  }
	  printf("%s %s %d\n", p1->ch, p2->ch, k);
	}
    }
  printf("charset\n");
  char_list unnamed("---");
  for (i = 0; i < 256; i++)
    if (t.contains(i)) {
      char_list *p = table[i] ? table[i] : &unnamed;
      int m[6];
      m[0] = t.get_width(i);
      m[1] = t.get_height(i);
      m[2] = t.get_depth(i);
      m[3] = t.get_italic(i);
      m[4] = g.get_left_adjustment(i);
      m[5] = g.get_right_adjustment(i);
      printf("%s\t%d", p->ch, m[0]*MULTIPLIER);
      int j;
      for (j = int(countof(m)) - 1; j > 0; j--)
	if (m[j] != 0)
	  break;
      for (k = 1; k <= j; k++)
	printf(",%d", m[k]*MULTIPLIER);
      int type = 0;
      if (m[2] > 0)
	type = 1;
      if (m[1] > xheight)
	type += 2;
      printf("\t%d\t%04o\n", type, i);
      for (p = p->next; p != 0 /* nullptr */; p = p->next)
	printf("%s\t\"\n", p->ch);
    }
  exit(EXIT_SUCCESS);
}

// Local Variables:
// fill-column: 72
// mode: C++
// End:
// vim: set cindent noexpandtab shiftwidth=2 textwidth=72: