src/utils/tfmtodit/tfmtodit.cc

   1 // -*- C++ -*-
   2 /* Copyright (C) 1989-1992, 2000, 2001 Free Software Foundation, Inc.
   3      Written by James Clark (jjc@jclark.com)
   4
   5 This file is part of groff.
   6
   7 groff is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 groff is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License along
  18 with groff; see the file COPYING.  If not, write to the Free Software
  19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
  20
  21 /* I have tried to incorporate the changes needed for TeX 3.0 tfm files,
  22 but I haven't tested them. */
  23
  24 /* Groff requires more font metric information than TeX.  The reason
  25 for this is that TeX has separate Math Italic fonts, whereas groff
  26 uses normal italic fonts for math.  The two additional pieces of
  27 information required by groff correspond to the two arguments to the
  28 math_fit() macro in the Metafont programs for the CM fonts. In the
  29 case of a font for which math_fitting is false, these two arguments
  30 are normally ignored by Metafont. We need to get hold of these two
  31 parameters and put them in the groff font file.
  32
  33 We do this by loading this definition after cmbase when creating cm.base.
  34
  35 def ignore_math_fit(expr left_adjustment,right_adjustment) =
  36  special "adjustment";
  37  numspecial left_adjustment*16/designsize;
  38  numspecial right_adjustment*16/designsize;
  39  enddef;
  40
  41 This puts the two arguments to the math_fit macro into the gf file.
  42 (They will appear in the gf file immediately before the character to
  43 which they apply.)  We then create a gf file using this cm.base.  Then
  44 we run tfmtodit and specify this gf file with the -g option.
  45
  46 This need only be done for a font for which math_fitting is false;
  47 When it's true, the left_correction and subscript_correction should
  48 both be zero. */
  49
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <math.h>
  53 #include <string.h>
  54 #include <errno.h>
  55 #include "lib.h"
  56 #include "errarg.h"
  57 #include "error.h"
  58 #include "assert.h"
  59 #include "cset.h"
  60 #include "nonposix.h"
  61
  62 extern "C" const char *Version_string;
  63
  64 /* Values in the tfm file should be multiplied by this. */
  65
  66 #define MULTIPLIER 1
  67
  68 struct char_info_word {
  69   unsigned char width_index;
  70   char height_index;
  71   char depth_index;
  72   char italic_index;
  73   char tag;
  74   unsigned char remainder;
  75 };
  76
  77 struct lig_kern_command {
  78   unsigned char skip_byte;
  79   unsigned char next_char;
  80   unsigned char op_byte;
  81   unsigned char remainder;
  82 };
  83
  84 class tfm {
  85   int bc;
  86   int ec;
  87   int nw;
  88   int nh;
  89   int nd;
  90   int ni;
  91   int nl;
  92   int nk;
  93   int np;
  94   int cs;
  95   int ds;
  96   char_info_word *char_info;
  97   int *width;
  98   int *height;
  99   int *depth;
 100   int *italic;
 101   lig_kern_command *lig_kern;
 102   int *kern;
 103   int *param;
 104 public:
 105   tfm();
 106   ~tfm();
 107   int load(const char *);
 108   int contains(int);
 109   int get_width(int);
 110   int get_height(int);
 111   int get_depth(int);
 112   int get_italic(int);
 113   int get_param(int, int *);
 114   int get_checksum();
 115   int get_design_size();
 116   int get_lig(unsigned char, unsigned char, unsigned char *);
 117   friend class kern_iterator;
 118 };
 119
 120 class kern_iterator {
 121   tfm *t;
 122   int c;
 123   int i;
 124 public:
 125   kern_iterator(tfm *);
 126   int next(unsigned char *c1, unsigned char *c2, int *k);
 127 };
 128
 129
 130 kern_iterator::kern_iterator(tfm *p)
 131 : t(p), c(t->bc), i(-1)
 132 {
 133 }
 134
 135 int kern_iterator::next(unsigned char *c1, unsigned char *c2, int *k)
 136 {
 137   for (; c <= t->ec; c++)
 138     if (t->char_info[c - t->bc].tag == 1) {
 139       if (i < 0) {
 140         i = t->char_info[c - t->bc].remainder;
 141         if (t->lig_kern[i].skip_byte > 128)
 142           i = (256*t->lig_kern[i].op_byte
 143                    + t->lig_kern[i].remainder);
 144       }
 145       for (;;) {
 146         int skip = t->lig_kern[i].skip_byte;
 147         if (skip <= 128 && t->lig_kern[i].op_byte >= 128) {
 148           *c1 = c;
 149           *c2 = t->lig_kern[i].next_char;
 150           *k = t->kern[256*(t->lig_kern[i].op_byte - 128)
 151                        + t->lig_kern[i].remainder];
 152           if (skip == 128) {
 153             c++;
 154             i = -1;
 155           }
 156           else
 157             i += skip + 1;
 158           return 1;
 159         }
 160         if (skip >= 128)
 161           break;
 162         i += skip + 1;
 163       }
 164       i = -1;
 165     }
 166   return 0;
 167 }
 168
 169 tfm::tfm()
 170 : char_info(0), width(0), height(0), depth(0), italic(0), lig_kern(0),
 171   kern(0), param(0)
 172 {
 173 }
 174
 175 int tfm::get_lig(unsigned char c1, unsigned char c2, unsigned char *cp)
 176 {
 177   if (contains(c1) && char_info[c1 - bc].tag == 1) {
 178     int i = char_info[c1 - bc].remainder;
 179     if (lig_kern[i].skip_byte > 128)
 180       i = 256*lig_kern[i].op_byte + lig_kern[i].remainder;
 181     for (;;) {
 182       int skip = lig_kern[i].skip_byte;
 183       if (skip > 128)
 184         break;
 185       // We are only interested in normal ligatures, for which
 186       // op_byte == 0.
 187       if (lig_kern[i].op_byte == 0
 188           && lig_kern[i].next_char == c2) {
 189         *cp = lig_kern[i].remainder;
 190         return 1;
 191       }
 192       if (skip == 128)
 193         break;
 194       i += skip + 1;
 195     }
 196   }
 197   return 0;
 198 }
 199
 200 int tfm::contains(int i)
 201 {
 202   return i >= bc && i <= ec && char_info[i - bc].width_index != 0;
 203 }
 204
 205 int tfm::get_width(int i)
 206 {
 207   return width[char_info[i - bc].width_index];
 208 }
 209
 210 int tfm::get_height(int i)
 211 {
 212   return height[char_info[i - bc].height_index];
 213 }
 214
 215 int tfm::get_depth(int i)
 216 {
 217   return depth[char_info[i - bc].depth_index];
 218 }
 219
 220 int tfm::get_italic(int i)
 221 {
 222   return italic[char_info[i - bc].italic_index];
 223 }
 224
 225 int tfm::get_param(int i, int *p)
 226 {
 227   if (i <= 0 || i > np)
 228     return 0;
 229   else {
 230     *p = param[i - 1];
 231     return 1;
 232   }
 233 }
 234
 235 int tfm::get_checksum()
 236 {
 237   return cs;
 238 }
 239
 240 int tfm::get_design_size()
 241 {
 242   return ds;
 243 }
 244
 245 tfm::~tfm()
 246 {
 247   a_delete char_info;
 248   a_delete width;
 249   a_delete height;
 250   a_delete depth;
 251   a_delete italic;
 252   a_delete lig_kern;
 253   a_delete kern;
 254   a_delete param;
 255 }
 256
 257 int read2(unsigned char *&s)
 258 {
 259   int n;
 260   n = *s++ << 8;
 261   n |= *s++;
 262   return n;
 263 }
 264
 265 int read4(unsigned char *&s)
 266 {
 267   int n;
 268   n = *s++ << 24;
 269   n |= *s++ << 16;
 270   n |= *s++ << 8;
 271   n |= *s++;
 272   return n;
 273 }
 274
 275
 276 int tfm::load(const char *file)
 277 {
 278   errno = 0;
 279   FILE *fp = fopen(file, FOPEN_RB);
 280   if (!fp) {
 281     error("can't open `%1': %2", file, strerror(errno));
 282     return 0;
 283   }
 284   int c1 = getc(fp);
 285   int c2 = getc(fp);
 286   if (c1 == EOF || c2 == EOF) {
 287     fclose(fp);
 288     error("unexpected end of file on `%1'", file);
 289     return 0;
 290   }
 291   int lf = (c1 << 8) + c2;
 292   int toread = lf*4 - 2;
 293   unsigned char *buf = new unsigned char[toread];
 294   if (fread(buf, 1, toread, fp) != (size_t)toread) {
 295     if (feof(fp))
 296       error("unexpected end of file on `%1'", file);
 297     else
 298       error("error on file `%1'", file);
 299     a_delete buf;
 300     fclose(fp);
 301     return 0;
 302   }
 303   fclose(fp);
 304   if (lf < 6) {
 305     error("bad tfm file `%1': impossibly short", file);
 306     a_delete buf;
 307     return 0;
 308   }
 309   unsigned char *ptr = buf;
 310   int lh = read2(ptr);
 311   bc = read2(ptr);
 312   ec = read2(ptr);
 313   nw = read2(ptr);
 314   nh = read2(ptr);
 315   nd = read2(ptr);
 316   ni = read2(ptr);
 317   nl = read2(ptr);
 318   nk = read2(ptr);
 319   int ne = read2(ptr);
 320   np = read2(ptr);
 321   if (6 + lh + (ec - bc + 1) + nw + nh + nd + ni + nl + nk + ne + np != lf) {
 322     error("bad tfm file `%1': lengths do not sum", file);
 323     a_delete buf;
 324     return 0;
 325   }
 326   if (lh < 2) {
 327     error("bad tfm file `%1': header too short", file);
 328     a_delete buf;
 329     return 0;
 330   }
 331   char_info = new char_info_word[ec - bc + 1];
 332   width = new int[nw];
 333   height = new int[nh];
 334   depth = new int[nd];
 335   italic = new int[ni];
 336   lig_kern = new lig_kern_command[nl];
 337   kern = new int[nk];
 338   param = new int[np];
 339   int i;
 340   cs = read4(ptr);
 341   ds = read4(ptr);
 342   ptr += (lh-2)*4;
 343   for (i = 0; i < ec - bc + 1; i++) {
 344     char_info[i].width_index = *ptr++;
 345     unsigned char tem = *ptr++;
 346     char_info[i].depth_index = tem & 0xf;
 347     char_info[i].height_index = tem >> 4;
 348     tem = *ptr++;
 349     char_info[i].italic_index = tem >> 2;
 350     char_info[i].tag = tem & 3;
 351     char_info[i].remainder = *ptr++;
 352   }
 353   for (i = 0; i < nw; i++)
 354     width[i] = read4(ptr);
 355   for (i = 0; i < nh; i++)
 356     height[i] = read4(ptr);
 357   for (i = 0; i < nd; i++)
 358     depth[i] = read4(ptr);
 359   for (i = 0; i < ni; i++)
 360     italic[i] = read4(ptr);
 361   for (i = 0; i < nl; i++) {
 362     lig_kern[i].skip_byte = *ptr++;
 363     lig_kern[i].next_char = *ptr++;
 364     lig_kern[i].op_byte = *ptr++;
 365     lig_kern[i].remainder = *ptr++;
 366   }
 367   for (i = 0; i < nk; i++)
 368     kern[i] = read4(ptr);
 369   ptr += ne*4;
 370   for (i = 0; i < np; i++)
 371     param[i] = read4(ptr);
 372   assert(ptr == buf + lf*4 - 2);
 373   a_delete buf;
 374   return 1;
 375 }
 376
 377 class gf {
 378   int left[256];
 379   int right[256];
 380   static int sread4(int *p, FILE *fp);
 381   static int uread3(int *p, FILE *fp);
 382   static int uread2(int *p, FILE *fp);
 383   static int skip(int n, FILE *fp);
 384 public:
 385   gf();
 386   int load(const char *file);
 387   int get_left_adjustment(int i) { return left[i]; }
 388   int get_right_adjustment(int i) { return right[i]; }
 389 };
 390
 391 gf::gf()
 392 {
 393   for (int i = 0; i < 256; i++)
 394     left[i] = right[i] = 0;
 395 }
 396
 397 int gf::load(const char *file)
 398 {
 399   enum {
 400     paint_0 = 0,
 401     paint1 = 64,
 402     boc = 67,
 403     boc1 = 68,
 404     eoc = 69,
 405     skip0 = 70,
 406     skip1 = 71,
 407     new_row_0 = 74,
 408     xxx1 = 239,
 409     yyy = 243,
 410     no_op = 244,
 411     pre = 247,
 412     post = 248
 413   };
 414   int got_an_adjustment = 0;
 415   int pending_adjustment = 0;
 416   int left_adj, right_adj;
 417   const int gf_id_byte = 131;
 418   errno = 0;
 419   FILE *fp = fopen(file, FOPEN_RB);
 420   if (!fp) {
 421     error("can't open `%1': %2", file, strerror(errno));
 422     return 0;
 423   }
 424   if (getc(fp) != pre || getc(fp) != gf_id_byte) {
 425     error("bad gf file");
 426     return 0;
 427   }
 428   int n = getc(fp);
 429   if (n == EOF)
 430     goto eof;
 431   if (!skip(n, fp))
 432     goto eof;
 433   for (;;) {
 434     int op = getc(fp);
 435     if (op == EOF)
 436       goto eof;
 437     if (op == post)
 438       break;
 439     if ((op >= paint_0 && op <= paint_0 + 63)
 440         || (op >= new_row_0 && op <= new_row_0 + 164))
 441       continue;
 442     switch (op) {
 443     case no_op:
 444     case eoc:
 445     case skip0:
 446       break;
 447     case paint1:
 448     case skip1:
 449       if (!skip(1, fp))
 450         goto eof;
 451       break;
 452     case paint1 + 1:
 453     case skip1 + 1:
 454       if (!skip(2, fp))
 455         goto eof;
 456       break;
 457     case paint1 + 2:
 458     case skip1 + 2:
 459       if (!skip(3, fp))
 460         goto eof;
 461       break;
 462     case boc:
 463       {
 464         int code;
 465         if (!sread4(&code, fp))
 466           goto eof;
 467         if (pending_adjustment) {
 468           pending_adjustment = 0;
 469           left[code & 0377] = left_adj;
 470           right[code & 0377] = right_adj;
 471         }
 472         if (!skip(20, fp))
 473           goto eof;
 474         break;
 475       }
 476     case boc1:
 477       {
 478         int code = getc(fp);
 479         if (code == EOF)
 480           goto eof;
 481         if (pending_adjustment) {
 482           pending_adjustment = 0;
 483           left[code] = left_adj;
 484           right[code] = right_adj;
 485         }
 486         if (!skip(4, fp))
 487           goto eof;
 488         break;
 489       }
 490     case xxx1:
 491       {
 492         int len = getc(fp);
 493         if (len == EOF)
 494           goto eof;
 495         char buf[256];
 496         if (fread(buf, 1, len, fp) != (size_t)len)
 497           goto eof;
 498         if (len == 10 /* strlen("adjustment") */
 499             && memcmp(buf, "adjustment", len) == 0) {
 500           int c = getc(fp);
 501           if (c != yyy) {
 502             if (c != EOF)
 503               ungetc(c, fp);
 504             break;
 505           }
 506           if (!sread4(&left_adj, fp))
 507             goto eof;
 508           c = getc(fp);
 509           if (c != yyy) {
 510             if (c != EOF)
 511               ungetc(c, fp);
 512             break;
 513           }
 514           if (!sread4(&right_adj, fp))
 515             goto eof;
 516           got_an_adjustment = 1;
 517           pending_adjustment = 1;
 518         }
 519         break;
 520       }
 521     case xxx1 + 1:
 522       if (!uread2(&n, fp) || !skip(n, fp))
 523         goto eof;
 524       break;
 525     case xxx1 + 2:
 526       if (!uread3(&n, fp) || !skip(n, fp))
 527         goto eof;
 528       break;
 529     case xxx1 + 3:
 530       if (!sread4(&n, fp) || !skip(n, fp))
 531         goto eof;
 532       break;
 533     case yyy:
 534       if (!skip(4, fp))
 535         goto eof;
 536       break;
 537     default:
 538       fatal("unrecognized opcode `%1'", op);
 539       break;
 540     }
 541   }
 542   if (!got_an_adjustment)
 543     warning("no adjustment specials found in gf file");
 544   return 1;
 545  eof:
 546   error("unexpected end of file");
 547   return 0;
 548 }
 549
 550 int gf::sread4(int *p, FILE *fp)
 551 {
 552   *p = getc(fp);
 553   if (*p >= 128)
 554     *p -= 256;
 555   *p <<= 8;
 556   *p |= getc(fp);
 557   *p <<= 8;
 558   *p |= getc(fp);
 559   *p <<= 8;
 560   *p |= getc(fp);
 561   return !ferror(fp) && !feof(fp);
 562 }
 563
 564 int gf::uread3(int *p, FILE *fp)
 565 {
 566   *p = getc(fp);
 567   *p <<= 8;
 568   *p |= getc(fp);
 569   *p <<= 8;
 570   *p |= getc(fp);
 571   return !ferror(fp) && !feof(fp);
 572 }
 573
 574 int gf::uread2(int *p, FILE *fp)
 575 {
 576   *p = getc(fp);
 577   *p <<= 8;
 578   *p |= getc(fp);
 579   return !ferror(fp) && !feof(fp);
 580 }
 581
 582 int gf::skip(int n, FILE *fp)
 583 {
 584   while (--n >= 0)
 585     if (getc(fp) == EOF)
 586       return 0;
 587   return 1;
 588 }
 589
 590
 591 struct char_list {
 592   char *ch;
 593   char_list *next;
 594   char_list(const char *, char_list * = 0);
 595 };
 596
 597 char_list::char_list(const char *s, char_list *p) : ch(strsave(s)), next(p)
 598 {
 599 }
 600
 601
 602 int read_map(const char *file, char_list **table)
 603 {
 604   errno = 0;
 605   FILE *fp = fopen(file, "r");
 606   if (!fp) {
 607     error("can't open `%1': %2", file, strerror(errno));
 608     return 0;
 609   }
 610   for (int i = 0; i < 256; i++)
 611     table[i] = 0;
 612   char buf[512];
 613   int lineno = 0;
 614   while (fgets(buf, int(sizeof(buf)), fp)) {
 615     lineno++;
 616     char *ptr = buf;
 617     while (csspace(*ptr))
 618       ptr++;
 619     if (*ptr == '\0' || *ptr == '#')
 620       continue;
 621     ptr = strtok(ptr, " \n\t");
 622     if (!ptr)
 623       continue;
 624     int n;
 625     if (sscanf(ptr, "%d", &n) != 1) {
 626       error("%1:%2: bad map file", file, lineno);
 627       fclose(fp);
 628       return 0;
 629     }
 630     if (n < 0 || n > 255) {
 631       error("%1:%2: code out of range", file, lineno);
 632       fclose(fp);
 633       return 0;
 634     }
 635     ptr = strtok(0, " \n\t");
 636     if (!ptr) {
 637       error("%1:%2: missing names", file, lineno);
 638       fclose(fp);
 639       return 0;
 640     }
 641     for (; ptr; ptr = strtok(0, " \n\t"))
 642       table[n] = new char_list(ptr, table[n]);
 643   }
 644   fclose(fp);
 645   return 1;
 646 }
 647
 648
 649 /* Every character that can participate in a ligature appears in the
 650 lig_chars table. `ch' gives the full-name of the character, `name'
 651 gives the groff name of the character, `i' gives its index in
 652 the encoding, which is filled in later  (-1 if it does not appear). */
 653
 654 struct {
 655   const char *ch;
 656   int i;
 657 } lig_chars[] = {
 658   { "f", -1 },
 659   { "i", -1 },
 660   { "l", -1 },
 661   { "ff", -1 },
 662   { "fi", -1 },
 663   { "fl", -1 },
 664   { "Fi", -1 },
 665   { "Fl", -1 },
 666 };
 667
 668 // Indices into lig_chars[].
 669
 670 enum { CH_f, CH_i, CH_l, CH_ff, CH_fi, CH_fl, CH_ffi, CH_ffl };
 671
 672 // Each possible ligature appears in this table.
 673
 674 struct {
 675   unsigned char c1, c2, res;
 676   const char *ch;
 677 } lig_table[] = {
 678   { CH_f, CH_f, CH_ff, "ff" },
 679   { CH_f, CH_i, CH_fi, "fi" },
 680   { CH_f, CH_l, CH_fl, "fl" },
 681   { CH_ff, CH_i, CH_ffi, "ffi" },
 682   { CH_ff, CH_l, CH_ffl, "ffl" },
 683   };
 684
 685 static void usage(FILE *stream);
 686
 687 int main(int argc, char **argv)
 688 {
 689   program_name = argv[0];
 690   int special_flag = 0;
 691   int skewchar = -1;
 692   int opt;
 693   const char *gf_file = 0;
 694   static const struct option long_options[] = {
 695     { "help", no_argument, 0, CHAR_MAX + 1 },
 696     { "version", no_argument, 0, 'v' },
 697     { NULL, 0, 0, 0 }
 698   };
 699   while ((opt = getopt_long(argc, argv, "svg:k:", long_options, NULL)) != EOF)
 700     switch (opt) {
 701     case 'g':
 702       gf_file = optarg;
 703       break;
 704     case 's':
 705       special_flag = 1;
 706       break;
 707     case 'k':
 708       {
 709         char *ptr;
 710         long n = strtol(optarg, &ptr, 0);
 711         if ((n == 0 && ptr == optarg)
 712             || *ptr != '\0'
 713             || n < 0
 714             || n > UCHAR_MAX)
 715           error("invalid skewchar");
 716         else
 717           skewchar = (int)n;
 718         break;
 719       }
 720     case 'v':
 721       {
 722         printf("GNU tfmtodit (groff) version %s\n", Version_string);
 723         exit(0);
 724         break;
 725       }
 726     case CHAR_MAX + 1: // --help
 727       usage(stdout);
 728       exit(0);
 729       break;
 730     case '?':
 731       usage(stderr);
 732       exit(1);
 733       break;
 734     case EOF:
 735       assert(0);
 736     }
 737   if (argc - optind != 3) {
 738     usage(stderr);
 739     exit(1);
 740   }
 741   gf g;
 742   if (gf_file) {
 743     if (!g.load(gf_file))
 744       return 1;
 745   }
 746   const char *tfm_file = argv[optind];
 747   const char *map_file = argv[optind + 1];
 748   const char *font_file = argv[optind + 2];
 749   tfm t;
 750   if (!t.load(tfm_file))
 751     return 1;
 752   char_list *table[256];
 753   if (!read_map(map_file, table))
 754     return 1;
 755   errno = 0;
 756   if (!freopen(font_file, "w", stdout)) {
 757     error("can't open `%1' for writing: %2", font_file, strerror(errno));
 758     return 1;
 759   }
 760   printf("name %s\n", font_file);
 761   if (special_flag)
 762     fputs("special\n", stdout);
 763   char *internal_name = strsave(argv[optind]);
 764   int len = strlen(internal_name);
 765   if (len > 4 && strcmp(internal_name + len - 4, ".tfm") == 0)
 766     internal_name[len - 4] = '\0';
 767   // DIR_SEPS[] are possible directory separator characters, see nonposix.h.
 768   // We want the rightmost separator of all possible ones.
 769   // Example: d:/foo\\bar.
 770   const char *s = strrchr(internal_name, DIR_SEPS[0]), *s1;
 771   const char *sep = &DIR_SEPS[1];
 772   while (*sep)
 773     {
 774       s1 = strrchr(internal_name, *sep);
 775       if (s1 && (!s || s1 > s))
 776         s = s1;
 777       sep++;
 778     }
 779   printf("internalname %s\n", s ? s + 1 : internal_name);
 780   int n;
 781   if (t.get_param(2, &n)) {
 782     if (n > 0)
 783       printf("spacewidth %d\n", n*MULTIPLIER);
 784   }
 785   if (t.get_param(1, &n) && n != 0)
 786     printf("slant %f\n", atan2(n/double(1<<20), 1.0)*180.0/PI);
 787   int xheight;
 788   if (!t.get_param(5, &xheight))
 789     xheight = 0;
 790   unsigned int i;
 791   // Print the list of ligatures.
 792   // First find the indices of each character that can participate in
 793   // a ligature.
 794   for (i = 0; i < 256; i++)
 795     for (unsigned int j = 0; j < sizeof(lig_chars)/sizeof(lig_chars[0]); j++)
 796       for (char_list *p = table[i]; p; p = p->next)
 797         if (strcmp(lig_chars[j].ch, p->ch) == 0)
 798           lig_chars[j].i = i;
 799   // For each possible ligature, if its participants all exist,
 800   // and it appears as a ligature in the tfm file, include in
 801   // the list of ligatures.
 802   int started = 0;
 803   for (i = 0; i < sizeof(lig_table)/sizeof(lig_table[0]); i++) {
 804     int i1 = lig_chars[lig_table[i].c1].i;
 805     int i2 = lig_chars[lig_table[i].c2].i;
 806     int r = lig_chars[lig_table[i].res].i;
 807     if (i1 >= 0 && i2 >= 0 && r >= 0) {
 808       unsigned char c;
 809       if (t.get_lig(i1, i2, &c) && c == r) {
 810         if (!started) {
 811           started = 1;
 812           fputs("ligatures", stdout);
 813         }
 814         printf(" %s", lig_table[i].ch);
 815       }
 816     }
 817   }
 818   if (started)
 819     fputs(" 0\n", stdout);
 820   printf("checksum %d\n", t.get_checksum());
 821   printf("designsize %d\n", t.get_design_size());
 822   // Now print out the kerning information.
 823   int had_kern = 0;
 824   kern_iterator iter(&t);
 825   unsigned char c1, c2;
 826   int k;
 827   while (iter.next(&c1, &c2, &k))
 828     if (c2 != skewchar) {
 829       k *= MULTIPLIER;
 830       char_list *q = table[c2];
 831       for (char_list *p1 = table[c1]; p1; p1 = p1->next)
 832         for (char_list *p2 = q; p2; p2 = p2->next) {
 833           if (!had_kern) {
 834             printf("kernpairs\n");
 835             had_kern = 1;
 836           }
 837           printf("%s %s %d\n", p1->ch, p2->ch, k);
 838         }
 839     }
 840   printf("charset\n");
 841   char_list unnamed("---");
 842   for (i = 0; i < 256; i++)
 843     if (t.contains(i)) {
 844       char_list *p = table[i] ? table[i] : &unnamed;
 845       int m[6];
 846       m[0] = t.get_width(i);
 847       m[1] = t.get_height(i);
 848       m[2] = t.get_depth(i);
 849       m[3] = t.get_italic(i);
 850       m[4] = g.get_left_adjustment(i);
 851       m[5] = g.get_right_adjustment(i);
 852       printf("%s\t%d", p->ch, m[0]*MULTIPLIER);
 853       int j;
 854       for (j = int(sizeof(m)/sizeof(m[0])) - 1; j > 0; j--)
 855         if (m[j] != 0)
 856           break;
 857       for (k = 1; k <= j; k++)
 858         printf(",%d", m[k]*MULTIPLIER);
 859       int type = 0;
 860       if (m[2] > 0)
 861         type = 1;
 862       if (m[1] > xheight)
 863         type += 2;
 864       printf("\t%d\t%04o\n", type, i);
 865       for (p = p->next; p; p = p->next)
 866         printf("%s\t\"\n", p->ch);
 867     }
 868   return 0;
 869 }
 870
 871 static void usage(FILE *stream)
 872 {
 873   fprintf(stream, "usage: %s [-sv] [-g gf_file] [-k skewchar] tfm_file map_file font\n",
 874           program_name);
 875 }