src/groff-font.c

   1 /* PSPP - computes sample statistics.
   2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
   3    Written by Ben Pfaff <blp@gnu.org>.
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18    02110-1301, USA. */
  19
  20 #include <config.h>
  21 #include "font.h"
  22 #include "error.h"
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <stdlib.h>
  26 #include <limits.h>
  27 #include <stdarg.h>
  28 #include "alloc.h"
  29 #include "error.h"
  30 #include "filename.h"
  31 #include "hash.h"
  32 #include "pool.h"
  33 #include "str.h"
  34 #include "version.h"
  35
  36 int font_number_to_index (int);
  37
  38 int space_index;
  39
  40 static int font_msg (int, const char *,...)
  41      PRINTF_FORMAT (2, 3);
  42 static void scan_badchars (char *, int);
  43 static void dup_char_metric (struct font_desc * font, int dest, int src);
  44 static void add_char_metric (struct font_desc * font, struct char_metrics *metrics,
  45                              int code);
  46 static void add_kern (struct font_desc * font, int ch1, int ch2, int adjust);
  47
  48 /* Typical whitespace characters for tokenizing. */
  49 static const char whitespace[] = " \t\n\r\v";
  50
  51 /* Some notes on the groff_font(8) manpage:
  52
  53    DESC file format: A typical PostScript `res' would be 72000, with
  54    `hor' and `vert' set to 1 to indicate that all those positions are
  55    valid.  `sizescale' of 1000 would indicate that a scaled point is
  56    1/1000 of a point (which is 1/72000 of an inch, the same as the
  57    number of machine units per inch indicated on `res').  `unitwidth'
  58    of 1000 would indicate that font files are set up for fonts with
  59    point size of 1000 scaled points, which would equal 1/72 inch or 1
  60    point (this would tell Groff's postprocessor that it needs to scale
  61    the font 12 times larger to get a 12-point font). */
  62
  63 /* Reads a Groff font description file and converts it to a usable
  64    binary format in memory.  Installs the binary format in the global
  65    font table.  See groff_font(8) for a description of the font
  66    description format supported.  Returns nonzero on success. */
  67 struct font_desc *
  68 groff_read_font (const char *fn)
  69 {
  70   struct char_metrics *metrics;
  71
  72   /* Pool created for font, font being created, font file. */
  73   struct pool *font_pool = NULL;
  74   struct font_desc *font = NULL;
  75   FILE *f = NULL;
  76
  77   /* Current line, size of line buffer, length of line. */
  78   char *line = NULL;
  79   size_t size;
  80   int len;
  81
  82   /* Tokenization saved pointer. */
  83   char *sp;
  84
  85   /* First token on line. */
  86   char *key;
  87
  88   /* 0=kernpairs section, 1=charset section. */
  89   int charset = 0;
  90
  91   /* Index for previous line. */
  92   int prev_index = -1;
  93
  94   /* Current location in file, used for error reporting. */
  95   struct file_locator where;
  96
  97 #ifdef unix
  98   fn = fn_tilde_expand (fn);
  99 #endif
 100
 101   msg (VM (1), _("%s: Opening Groff font file..."), fn);
 102
 103   where.filename = fn;
 104   where.line_number = 1;
 105   err_push_file_locator (&where);
 106
 107   f = fopen (fn, "r");
 108   if (!f)
 109     goto file_lossage;
 110
 111   font_pool = pool_create ();
 112   font = pool_alloc (font_pool, sizeof *font);
 113   font->owner = font_pool;
 114   font->name = NULL;
 115   font->internal_name = NULL;
 116   font->encoding = NULL;
 117   font->space_width = 0;
 118   font->slant = 0.0;
 119   font->ligatures = 0;
 120   font->special = 0;
 121   font->deref = NULL;
 122   font->deref_size = 0;
 123   font->metric = NULL;
 124   font->metric_size = 0;
 125   font->metric_used = 0;
 126   font->kern = NULL;
 127   font->kern_size = 8;
 128   font->kern_used = 0;
 129   font->kern_max_used = 0;
 130
 131   /* Parses first section of font file. */
 132   for (;;)
 133     {
 134       /* Location of '#' in line. */
 135       char *p;
 136
 137       len = getline (&line, &size, f);
 138       if (len == -1)
 139         break;
 140
 141       scan_badchars (line, len);
 142       p = strchr (line, '#');
 143       if (p)
 144         *p = '\0';              /* Reject comments. */
 145
 146       key = strtok_r (line, whitespace, &sp);
 147       if (!key)
 148         goto next_iteration;
 149
 150       if (!strcmp (key, "internalname"))
 151         {
 152           font->internal_name = strtok_r (NULL, whitespace, &sp);
 153           if (font->internal_name == NULL)
 154             {
 155               font_msg (SE, _("Missing font name."));
 156               goto lose;
 157             }
 158           font->internal_name = pool_strdup (font_pool, font->internal_name);
 159         }
 160       else if (!strcmp (key, "encoding"))
 161         {
 162           font->encoding = strtok_r (NULL, whitespace, &sp);
 163           if (font->encoding == NULL)
 164             {
 165               font_msg (SE, _("Missing encoding filename."));
 166               goto lose;
 167             }
 168           font->encoding = pool_strdup (font_pool, font->encoding);
 169         }
 170       else if (!strcmp (key, "spacewidth"))
 171         {
 172           char *n = strtok_r (NULL, whitespace, &sp);
 173           char *tail;
 174           if (n)
 175             font->space_width = strtol (n, &tail, 10);
 176           if (n == NULL || tail == n)
 177             {
 178               font_msg (SE, _("Bad spacewidth value."));
 179               goto lose;
 180             }
 181         }
 182       else if (!strcmp (key, "slant"))
 183         {
 184           char *n = strtok_r (NULL, whitespace, &sp);
 185           char *tail;
 186           if (n)
 187             font->slant = strtod (n, &tail);
 188           if (n == NULL || tail == n)
 189             {
 190               font_msg (SE, _("Bad slant value."));
 191               goto lose;
 192             }
 193         }
 194       else if (!strcmp (key, "ligatures"))
 195         {
 196           char *lig;
 197
 198           for (;;)
 199             {
 200               lig = strtok_r (NULL, whitespace, &sp);
 201               if (!lig || !strcmp (lig, "0"))
 202                 break;
 203               else if (!strcmp (lig, "ff"))
 204                 font->ligatures |= LIG_ff;
 205               else if (!strcmp (lig, "ffi"))
 206                 font->ligatures |= LIG_ffi;
 207               else if (!strcmp (lig, "ffl"))
 208                 font->ligatures |= LIG_ffl;
 209               else if (!strcmp (lig, "fi"))
 210                 font->ligatures |= LIG_fi;
 211               else if (!strcmp (lig, "fl"))
 212                 font->ligatures |= LIG_fl;
 213               else
 214                 {
 215                   font_msg (SE, _("Unknown ligature `%s'."), lig);
 216                   goto lose;
 217                 }
 218             }
 219         }
 220       else if (!strcmp (key, "special"))
 221         font->special = 1;
 222       else if (!strcmp (key, "charset") || !strcmp (key, "kernpairs"))
 223         break;
 224
 225       where.line_number++;
 226     }
 227   if (ferror (f))
 228     goto file_lossage;
 229
 230   /* Parses second section of font file (metrics & kerning data). */
 231   do
 232     {
 233       key = strtok_r (line, whitespace, &sp);
 234       if (!key)
 235         goto next_iteration;
 236
 237       if (!strcmp (key, "charset"))
 238         charset = 1;
 239       else if (!strcmp (key, "kernpairs"))
 240         charset = 0;
 241       else if (charset)
 242         {
 243           struct char_metrics *metrics = pool_alloc (font_pool,
 244                                                      sizeof *metrics);
 245           char *m, *type, *code, *tail;
 246
 247           m = strtok_r (NULL, whitespace, &sp);
 248           if (!m)
 249             {
 250               font_msg (SE, _("Unexpected end of line reading character "
 251                               "set."));
 252               goto lose;
 253             }
 254           if (!strcmp (m, "\""))
 255             {
 256               if (!prev_index)
 257                 {
 258                   font_msg (SE, _("Can't use ditto mark for first character."));
 259                   goto lose;
 260                 }
 261               if (!strcmp (key, "---"))
 262                 {
 263                   font_msg (SE, _("Can't ditto into an unnamed character."));
 264                   goto lose;
 265                 }
 266               dup_char_metric (font, font_char_name_to_index (key), prev_index);
 267               where.line_number++;
 268               goto next_iteration;
 269             }
 270
 271           if (m)
 272             {
 273               metrics->code = metrics->width
 274                 = metrics->height = metrics->depth = 0;
 275             }
 276
 277           if (m == NULL || 1 > sscanf (m, "%d,%d,%d", &metrics->width,
 278                                        &metrics->height, &metrics->depth))
 279             {
 280               font_msg (SE, _("Missing metrics for character `%s'."), key);
 281               goto lose;
 282             }
 283
 284           type = strtok_r (NULL, whitespace, &sp);
 285           if (type)
 286             metrics->type = strtol (type, &tail, 10);
 287           if (!type || tail == type)
 288             {
 289               font_msg (SE, _("Missing type for character `%s'."), key);
 290               goto lose;
 291             }
 292
 293           code = strtok_r (NULL, whitespace, &sp);
 294           if (code)
 295             metrics->code = strtol (code, &tail, 0);
 296           if (tail == code)
 297             {
 298               font_msg (SE, _("Missing code for character `%s'."), key);
 299               goto lose;
 300             }
 301
 302           if (strcmp (key, "---"))
 303             prev_index = font_char_name_to_index (key);
 304           else
 305             prev_index = font_number_to_index (metrics->code);
 306           add_char_metric (font, metrics, prev_index);
 307         }
 308       else
 309         {
 310           char *c1 = key;
 311           char *c2 = strtok_r (NULL, whitespace, &sp);
 312           char *n, *tail;
 313           int adjust;
 314
 315           if (c2 == NULL)
 316             {
 317               font_msg (SE, _("Malformed kernpair."));
 318               goto lose;
 319             }
 320
 321           n = strtok_r (NULL, whitespace, &sp);
 322           if (!n)
 323             {
 324               font_msg (SE, _("Unexpected end of line reading kernpairs."));
 325               goto lose;
 326             }
 327           adjust = strtol (n, &tail, 10);
 328           if (tail == n || *tail)
 329             {
 330               font_msg (SE, _("Bad kern value."));
 331               goto lose;
 332             }
 333           add_kern (font, font_char_name_to_index (c1),
 334                     font_char_name_to_index (c2), adjust);
 335         }
 336
 337     next_iteration:
 338       where.line_number++;
 339
 340       len = getline (&line, &size, f);
 341     }
 342   while (len != -1);
 343
 344   if (ferror (f))
 345     goto file_lossage;
 346   if (fclose (f) == EOF)
 347     {
 348       f = NULL;
 349       goto file_lossage;
 350     }
 351   free (line);
 352 #ifdef unix
 353   free ((char *) fn);
 354 #endif
 355
 356   /* Get font ascent and descent. */
 357   metrics = font_get_char_metrics (font, font_char_name_to_index ("d"));
 358   font->ascent = metrics ? metrics->height : 0;
 359   metrics = font_get_char_metrics (font, font_char_name_to_index ("p"));
 360   font->descent = metrics ? metrics->depth : 0;
 361
 362   msg (VM (2), _("Font read successfully with internal name %s."),
 363        font->internal_name == NULL ? "<none>" : font->internal_name);
 364
 365   err_pop_file_locator (&where);
 366
 367   return font;
 368
 369   /* Come here on a file error. */
 370 file_lossage:
 371   msg (ME, "%s: %s", fn, strerror (errno));
 372
 373   /* Come here on any error. */
 374 lose:
 375   if (f != NULL)
 376     fclose (f);
 377   pool_destroy (font_pool);
 378 #ifdef unix
 379   free ((char *) fn);
 380 #endif
 381   err_pop_file_locator (&where);
 382
 383   msg (VM (1), _("Error reading font."));
 384   return NULL;
 385 }
 386
 387 /* Prints a font error on stderr. */
 388 static int
 389 font_msg (int class, const char *format,...)
 390 {
 391   va_list args;
 392
 393   va_start (args, format);
 394   tmsg (class, format, args, _("installation error: Groff font error: "));
 395   va_end (args);
 396
 397   return 0;
 398 }
 399
 400 /* Scans string LINE of length LEN (not incl. null terminator) for bad
 401    characters, converts to spaces; reports warnings on file FN. */
 402 static void
 403 scan_badchars (char *line, int len)
 404 {
 405   unsigned char *cp = line;
 406
 407   /* Same bad characters as Groff. */
 408   static unsigned char badchars[32] =
 409   {
 410     0x01, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 411     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 412     0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
 413     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 414   };
 415
 416   for (; len--; cp++)
 417     if (badchars[*cp >> 3] & (1 << (*cp & 7)))
 418       {
 419         font_msg (SE, _("Bad character \\%3o."), *cp);
 420         *cp = ' ';
 421       }
 422 }
 423 \f
 424 /* Character name hashing. */
 425
 426 /* Associates a character index with a character name. */
 427 struct index_hash
 428   {
 429     char *name;
 430     int index;
 431   };
 432
 433 /* Character index hash table. */
 434 static struct
 435   {
 436     int size;                   /* Size of table (must be power of 2). */
 437     int used;                   /* Number of full entries. */
 438     int next_index;             /* Next index to allocate. */
 439     struct index_hash *tab;     /* Hash table proper. */
 440     struct pool *ar;            /* Pool for names. */
 441   }
 442 hash;
 443
 444 void
 445 groff_init (void)
 446 {
 447   space_index = font_char_name_to_index ("space");
 448 }
 449
 450 void
 451 groff_done (void)
 452 {
 453   free (hash.tab) ;
 454   pool_destroy(hash.ar);
 455 }
 456
 457
 458 /* Searches for NAME in the global character code table, returns the
 459    index if found; otherwise inserts NAME and returns the new
 460    index. */
 461 int
 462 font_char_name_to_index (const char *name)
 463 {
 464   int i;
 465
 466   if (name[0] == ' ')
 467     return space_index;
 468   if (name[0] == '\0' || name[1] == '\0')
 469     return name[0];
 470   if (0 == strncmp (name, "char", 4))
 471     {
 472       char *tail;
 473       int x = strtol (name + 4, &tail, 10);
 474       if (tail != name + 4 && *tail == 0 && x >= 0 && x <= 255)
 475         return x;
 476     }
 477
 478   if (!hash.tab)
 479     {
 480       hash.size = 128;
 481       hash.used = 0;
 482       hash.next_index = 256;
 483       hash.tab = xmalloc (sizeof *hash.tab * hash.size);
 484       hash.ar = pool_create ();
 485       for (i = 0; i < hash.size; i++)
 486         hash.tab[i].name = NULL;
 487     }
 488
 489   for (i = hsh_hash_string (name) & (hash.size - 1); hash.tab[i].name; )
 490     {
 491       if (!strcmp (hash.tab[i].name, name))
 492         return hash.tab[i].index;
 493       if (++i >= hash.size)
 494         i = 0;
 495     }
 496
 497   hash.used++;
 498   if (hash.used >= hash.size / 2)
 499     {
 500       struct index_hash *old_tab = hash.tab;
 501       int old_size = hash.size;
 502       int i, j;
 503
 504       hash.size *= 2;
 505       hash.tab = xmalloc (sizeof *hash.tab * hash.size);
 506       for (i = 0; i < hash.size; i++)
 507         hash.tab[i].name = NULL;
 508       for (i = 0; i < old_size; i++)
 509         if (old_tab[i].name)
 510           {
 511             for (j = hsh_hash_string (old_tab[i].name) & (hash.size - 1);
 512                  hash.tab[j].name;)
 513               if (++j >= hash.size)
 514                 j = 0;
 515             hash.tab[j] = old_tab[i];
 516           }
 517       free (old_tab);
 518     }
 519
 520   hash.tab[i].name = pool_strdup (hash.ar, name);
 521   hash.tab[i].index = hash.next_index;
 522   return hash.next_index++;
 523 }
 524
 525 /* Returns an index for a character that has only a code, not a
 526    name. */
 527 int
 528 font_number_to_index (int x)
 529 {
 530   char name[INT_DIGITS + 2];
 531
 532   /* Note that space is the only character that can't appear in a
 533      character name.  That makes it an excellent choice for a name
 534      that won't conflict. */
 535   sprintf (name, " %d", x);
 536   return font_char_name_to_index (name);
 537 }
 538 \f
 539 /* Font character metric entries. */
 540
 541 /* Ensures room for at least MIN_SIZE metric indexes in deref of
 542    FONT. */
 543 static void
 544 check_deref_space (struct font_desc *font, int min_size)
 545 {
 546   if (min_size >= font->deref_size)
 547     {
 548       int i = font->deref_size;
 549
 550       font->deref_size = min_size + 16;
 551       if (font->deref_size < 256)
 552         font->deref_size = 256;
 553       font->deref = pool_realloc (font->owner, font->deref,
 554                                   sizeof *font->deref * font->deref_size);
 555       for (; i < font->deref_size; i++)
 556         font->deref[i] = -1;
 557     }
 558 }
 559
 560 /* Inserts METRICS for character with code CODE into FONT. */
 561 static void
 562 add_char_metric (struct font_desc *font, struct char_metrics *metrics, int code)
 563 {
 564   check_deref_space (font, code);
 565   if (font->metric_used >= font->metric_size)
 566     {
 567       font->metric_size += 64;
 568       font->metric = pool_realloc (font->owner, font->metric,
 569                                    sizeof *font->metric * font->metric_size);
 570     }
 571   font->metric[font->metric_used] = metrics;
 572   font->deref[code] = font->metric_used++;
 573 }
 574
 575 /* Copies metric in FONT from character with code SRC to character
 576    with code DEST. */
 577 static void
 578 dup_char_metric (struct font_desc *font, int dest, int src)
 579 {
 580   check_deref_space (font, dest);
 581   assert (font->deref[src] != -1);
 582   font->deref[dest] = font->deref[src];
 583 }
 584 \f
 585 /* Kerning. */
 586
 587 /* Returns a hash value for characters with codes CH1 and CH2. */
 588 #define hash_kern(CH1, CH2)                     \
 589         ((unsigned) (((CH1) << 16) ^ (CH2)))
 590
 591 /* Adds an ADJUST-size kern to FONT between characters with codes CH1
 592    and CH2. */
 593 static void
 594 add_kern (struct font_desc *font, int ch1, int ch2, int adjust)
 595 {
 596   int i;
 597
 598   if (font->kern_used >= font->kern_max_used)
 599     {
 600       struct kern_pair *old_kern = font->kern;
 601       int old_kern_size = font->kern_size;
 602       int j;
 603
 604       font->kern_size *= 2;
 605       font->kern_max_used = font->kern_size / 2;
 606       font->kern = pool_malloc (font->owner,
 607                                 sizeof *font->kern * font->kern_size);
 608       for (i = 0; i < font->kern_size; i++)
 609         font->kern[i].ch1 = -1;
 610
 611       if (old_kern)
 612         {
 613           for (i = 0; i < old_kern_size; i++)
 614             {
 615               if (old_kern[i].ch1 == -1)
 616                 continue;
 617
 618               j = (hash_kern (old_kern[i].ch1, old_kern[i].ch2)
 619                    & (font->kern_size - 1));
 620               while (font->kern[j].ch1 != -1)
 621                 if (0 == j--)
 622                   j = font->kern_size - 1;
 623               font->kern[j] = old_kern[i];
 624             }
 625           pool_free (font->owner, old_kern);
 626         }
 627     }
 628
 629   for (i = hash_kern (ch1, ch2) & (font->kern_size - 1);
 630        font->kern[i].ch1 != -1; )
 631     if (0 == i--)
 632       i = font->kern_size - 1;
 633   font->kern[i].ch1 = ch1;
 634   font->kern[i].ch2 = ch2;
 635   font->kern[i].adjust = adjust;
 636   font->kern_used++;
 637 }
 638
 639 /* Finds a font file corresponding to font NAME for device DEV. */
 640 static char *
 641 find_font_file (const char *dev, const char *name)
 642 {
 643   char *basename = xmalloc (3 + strlen (dev) + 1 + strlen (name) + 1);
 644   char *cp;
 645   char *filename;
 646   char *path;
 647
 648   cp = stpcpy (basename, "dev");
 649   cp = stpcpy (cp, dev);
 650   *cp++ = DIR_SEPARATOR;
 651   strcpy (cp, name);
 652
 653   /* Search order:
 654      1. $STAT_GROFF_FONT_PATH
 655      2. $GROFF_FONT_PATH
 656      3. GROFF_FONT_PATH from pref.h
 657      4. config_path
 658    */
 659   if ((path = getenv ("STAT_GROFF_FONT_PATH")) != NULL
 660       && (filename = fn_search_path (basename, path, NULL)) != NULL)
 661     goto win;
 662
 663   if ((path = getenv ("GROFF_FONT_PATH")) != NULL
 664       && (filename = fn_search_path (basename, path, NULL)) != NULL)
 665     goto win;
 666
 667   if ((filename = fn_search_path (basename, groff_font_path, NULL)) != NULL)
 668     goto win;
 669
 670   if ((filename = fn_search_path (basename, config_path, NULL)) != NULL)
 671     goto win;
 672
 673   msg (IE, _("Groff font error: Cannot find \"%s\"."), basename);
 674
 675 win:
 676   free (basename);
 677   return filename;
 678 }
 679
 680 /* Finds a font for device DEV with name NAME, reads it with
 681    groff_read_font(), and returns the resultant font. */
 682 struct font_desc *
 683 groff_find_font (const char *dev, const char *name)
 684 {
 685   char *filename = find_font_file (dev, name);
 686   struct font_desc *fd;
 687
 688   if (!filename)
 689     return NULL;
 690   fd = groff_read_font (filename);
 691   free (filename);
 692   return fd;
 693 }
 694
 695 /* Reads a DESC file for device DEV and sets the appropriate fields in
 696    output driver *DRIVER, which must be previously allocated.  Returns
 697    nonzero on success. */
 698 int
 699 groff_read_DESC (const char *dev_name, struct groff_device_info * dev)
 700 {
 701   char *filename;               /* Full name of DESC file. */
 702   FILE *f;                      /* DESC file. */
 703
 704   char *line = NULL;            /* Current line. */
 705   int line_len;                 /* Number of chars in current line. */
 706   size_t line_size = 0;         /* Number of chars allocated for line. */
 707
 708   char *token;                  /* strtok()'d token inside line. */
 709
 710   unsigned found = 0;           /* Bitmask showing what settings
 711                                    have been encountered. */
 712
 713   int m_sizes = 0;              /* Number of int[2] items that
 714                                    can fit in driver->sizes. */
 715
 716   char *sp;                     /* Tokenization string pointer. */
 717   struct file_locator where;
 718
 719   int i;
 720
 721   dev->horiz = 1;
 722   dev->vert = 1;
 723   dev->size_scale = 1;
 724   dev->n_sizes = 0;
 725   dev->sizes = NULL;
 726   dev->family = NULL;
 727   for (i = 0; i < 4; i++)
 728     dev->font_name[i] = NULL;
 729
 730   filename = find_font_file (dev_name, "DESC");
 731   if (!filename)
 732     return 0;
 733
 734   where.filename = filename;
 735   where.line_number = 0;
 736   err_push_file_locator (&where);
 737
 738   msg (VM (1), _("%s: Opening Groff description file..."), filename);
 739   f = fopen (filename, "r");
 740   if (!f)
 741     goto file_lossage;
 742
 743   while ((line_len = getline (&line, &line_size, f)) != -1)
 744     {
 745       where.line_number++;
 746
 747       token = strtok_r (line, whitespace, &sp);
 748       if (!token)
 749         continue;
 750
 751       if (!strcmp (token, "sizes"))
 752         {
 753           if (found & 0x10000)
 754             font_msg (SW, _("Multiple `sizes' declarations."));
 755           for (;;)
 756             {
 757               char *tail;
 758               int lower, upper;
 759
 760               for (;;)
 761                 {
 762                   token = strtok_r (NULL, whitespace, &sp);
 763                   if (token)
 764                     break;
 765
 766                   where.line_number++;
 767                   if ((line_len = getline (&line, &line_size, f)) != -1)
 768                     {
 769                       if (ferror (f))
 770                         goto file_lossage;
 771                       font_msg (SE, _("Unexpected end of file.  "
 772                                 "Missing 0 terminator to `sizes' command?"));
 773                       goto lossage;
 774                     }
 775                 }
 776
 777               if (!strcmp (token, "0"))
 778                 break;
 779
 780               errno = 0;
 781               if (0 == (lower = strtol (token, &tail, 0)) || errno == ERANGE)
 782                 {
 783                   font_msg (SE, _("Bad argument to `sizes'."));
 784                   goto lossage;
 785                 }
 786               if (*tail == '-')
 787                 {
 788                   if (0 == (upper = strtol (&tail[1], &tail, 0)) || errno == ERANGE)
 789                     {
 790                       font_msg (SE, _("Bad argument to `sizes'."));
 791                       goto lossage;
 792                     }
 793                   if (lower < upper)
 794                     {
 795                       font_msg (SE, _("Bad range in argument to `sizes'."));
 796                       goto lossage;
 797                     }
 798                 }
 799               else
 800                 upper = lower;
 801               if (*tail)
 802                 {
 803                   font_msg (SE, _("Bad argument to `sizes'."));
 804                   goto lossage;
 805                 }
 806
 807               if (dev->n_sizes + 2 >= m_sizes)
 808                 {
 809                   m_sizes += 1;
 810                   dev->sizes = xrealloc (dev->sizes,
 811                                          m_sizes * sizeof *dev->sizes);
 812                 }
 813               dev->sizes[dev->n_sizes++][0] = lower;
 814               dev->sizes[dev->n_sizes][1] = upper;
 815
 816               found |= 0x10000;
 817             }
 818         }
 819       else if (!strcmp (token, "family"))
 820         {
 821           token = strtok_r (NULL, whitespace, &sp);
 822           if (!token)
 823             {
 824               font_msg (SE, _("Family name expected."));
 825               goto lossage;
 826             }
 827           if (found & 0x20000)
 828             {
 829               font_msg (SE, _("This command already specified."));
 830               goto lossage;
 831             }
 832           dev->family = xstrdup (token);
 833         }
 834       else if (!strcmp (token, "charset"))
 835         break;
 836       else
 837         {
 838           static const char *id[]
 839             = {"res", "hor", "vert", "sizescale", "unitwidth", NULL};
 840           const char **cp;
 841           int value;
 842
 843           for (cp = id; *cp; cp++)
 844             if (!strcmp (token, *cp))
 845               break;
 846           if (*cp == NULL)
 847             continue;           /* completely ignore unrecognized lines */
 848           if (found & (1 << (cp - id)))
 849             font_msg (SW, _("%s: Device characteristic already defined."), *cp);
 850
 851           token = strtok_r (NULL, whitespace, &sp);
 852           errno = 0;
 853           if (!token || (value = strtol (token, NULL, 0)) <= 0 || errno == ERANGE)
 854             {
 855               font_msg (SE, _("%s: Invalid numeric format."), *cp);
 856               goto lossage;
 857             }
 858           found |= (1 << (cp - id));
 859           switch (cp - id)
 860             {
 861             case 0:
 862               dev->res = value;
 863               break;
 864             case 1:
 865               dev->horiz = value;
 866               break;
 867             case 2:
 868               dev->vert = value;
 869               break;
 870             case 3:
 871               dev->size_scale = value;
 872               break;
 873             case 4:
 874               dev->unit_width = value;
 875               break;
 876             default:
 877               assert (0);
 878             }
 879         }
 880     }
 881   if (ferror (f))
 882     goto file_lossage;
 883   if ((found & 0x10011) != 0x10011)
 884     {
 885       font_msg (SE, _("Missing `res', `unitwidth', and/or `sizes' line(s)."));
 886       goto lossage;
 887     }
 888
 889   /* Font name = family name + suffix. */
 890   {
 891     static const char *suffix[4] =
 892       {"R", "I", "B", "BI"};    /* match OUTP_F_* */
 893     int len;                    /* length of family name */
 894     int i;
 895
 896     if (!dev->family)
 897       dev->family = xstrdup ("");
 898     len = strlen (dev->family);
 899     for (i = 0; i < 4; i++)
 900       {
 901         char *cp;
 902         dev->font_name[i] = xmalloc (len + strlen (suffix[i]) + 1);
 903         cp = stpcpy (dev->font_name[i], dev->family);
 904         strcpy (cp, suffix[i]);
 905       }
 906   }
 907
 908   dev->sizes[dev->n_sizes][0] = 0;
 909   dev->sizes[dev->n_sizes][1] = 0;
 910
 911   msg (VM (2), _("Description file read successfully."));
 912
 913   err_pop_file_locator (&where);
 914   free (filename);
 915   free (line);
 916   return 1;
 917
 918   /* Come here on a file error. */
 919 file_lossage:
 920   msg (ME, "%s: %s", filename, strerror (errno));
 921
 922   /* Come here on any error. */
 923 lossage:
 924   fclose (f);
 925   free (line);
 926   free (dev->family);
 927   dev->family = NULL;
 928   free (filename);
 929   free (dev->sizes);
 930   dev->sizes = NULL;
 931   dev->n_sizes = 0;
 932 #if 0                           /* at the moment, no errors can come here when dev->font_name[*] are
 933                                    nonzero. */
 934   for (i = 0; i < 4; i++)
 935     {
 936       free (dev->font_name[i]);
 937       dev->font_name[i] = NULL;
 938     }
 939 #endif
 940
 941   err_pop_file_locator (&where);
 942
 943   msg (VM (1), _("Error reading description file."));
 944
 945   return 0;
 946 }
 947
 948 /* Finds character with index CH (as returned by name_to_index() or
 949    number_to_index()) in font FONT and returns the associated metrics.
 950    Nonexistent characters have width 0. */
 951 struct char_metrics *
 952 font_get_char_metrics (const struct font_desc *font, int ch)
 953 {
 954   short index;
 955
 956   if (ch < 0 || ch >= font->deref_size)
 957     return 0;
 958
 959   index = font->deref[ch];
 960   if (index == -1)
 961     return 0;
 962
 963   return font->metric[index];
 964 }
 965
 966 /* Finds kernpair consisting of CH1 and CH2, in that order, in font
 967    FONT and returns the associated kerning adjustment. */
 968 int
 969 font_get_kern_adjust (const struct font_desc *font, int ch1, int ch2)
 970 {
 971   unsigned i;
 972
 973   if (!font->kern)
 974     return 0;
 975   for (i = hash_kern (ch1, ch2) & (font->kern_size - 1);
 976        font->kern[i].ch1 != -1;)
 977     {
 978       if (font->kern[i].ch1 == ch1 && font->kern[i].ch2 == ch2)
 979         return font->kern[i].adjust;
 980       if (0 == i--)
 981         i = font->kern_size - 1;
 982     }
 983   return 0;
 984 }
 985
 986 /* Returns a twelve-point fixed-pitch font that can be used as a
 987    last-resort fallback. */
 988 struct font_desc *
 989 default_font (void)
 990 {
 991   struct pool *font_pool;
 992   static struct font_desc *font;
 993
 994   if (font)
 995     return font;
 996   font_pool = pool_create ();
 997   font = pool_alloc (font_pool, sizeof *font);
 998   font->owner = font_pool;
 999   font->name = NULL;
1000   font->internal_name = pool_strdup (font_pool, _("<<fallback>>"));
1001   font->encoding = pool_strdup (font_pool, "text.enc");
1002   font->space_width = 12000;
1003   font->slant = 0.0;
1004   font->ligatures = 0;
1005   font->special = 0;
1006   font->ascent = 8000;
1007   font->descent = 4000;
1008   font->deref = NULL;
1009   font->deref_size = 0;
1010   font->metric = NULL;
1011   font->metric_size = 0;
1012   font->metric_used = 0;
1013   font->kern = NULL;
1014   font->kern_size = 8;
1015   font->kern_used = 0;
1016   font->kern_max_used = 0;
1017   return font;
1018 }