dlls/wineps.drv/type1afm.c

   1 /*******************************************************************************
   2  *  Adobe Font Metric (AFM) file parsing functions for Wine PostScript driver.
   3  *  See http://partners.adobe.com/asn/developer/pdfs/tn/5004.AFM_Spec.pdf.
   4  *
   5  *  Copyright 2001  Ian Pilcher
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  *  NOTE:  Many of the functions in this file can return either fatal errors
  22  *      (memory allocation failure) or non-fatal errors (unusable AFM file).
  23  *      Fatal errors are indicated by returning FALSE; see individual function
  24  *      descriptions for how they indicate non-fatal errors.
  25  *
  26  */
  27
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include <errno.h>
  33 #include <io.h>
  34 #include <ctype.h>
  35 #include <limits.h>         /* INT_MIN */
  36 #include <float.h>          /* FLT_MAX */
  37
  38 #include "windef.h"
  39 #include "winbase.h"
  40 #include "winerror.h"
  41 #include "winreg.h"
  42 #include "winnls.h"
  43 #include "winternl.h"
  44 #include "psdrv.h"
  45 #include "wine/debug.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  48
  49 /*******************************************************************************
  50  *  ReadLine
  51  *
  52  *  Reads a line from a text file into the buffer and trims trailing whitespace.
  53  *  Can handle DOS and Unix text files, including weird DOS EOF.  Returns FALSE
  54  *  for unexpected I/O errors; otherwise returns TRUE and sets *p_result to
  55  *  either the number of characters in the returned string or one of the
  56  *  following:
  57  *
  58  *      0:          Blank (or all whitespace) line.  This is just a special case
  59  *                  of the normal behavior.
  60  *
  61  *      EOF:        End of file has been reached.
  62  *
  63  *      INT_MIN:    Buffer overflow.  Returned string is truncated (duh!) and
  64  *                  trailing whitespace is *not* trimmed.  Remaining text in
  65  *                  line is discarded.  (I.e. the file pointer is positioned at
  66  *                  the beginning of the next line.)
  67  *
  68  */
  69 static BOOL ReadLine(FILE *file, CHAR buffer[], INT bufsize, INT *p_result)
  70 {
  71      CHAR   *cp;
  72      INT    i;
  73
  74      if (fgets(buffer, bufsize, file) == NULL)
  75      {
  76         if (feof(file) == 0)                            /* EOF or error? */
  77         {
  78             ERR("%s\n", strerror(errno));
  79             return FALSE;
  80         }
  81
  82         *p_result = EOF;
  83         return TRUE;
  84     }
  85
  86     cp = strchr(buffer, '\n');
  87     if (cp == NULL)
  88     {
  89         i = strlen(buffer);
  90
  91         if (i == bufsize - 1)       /* max possible; was line truncated? */
  92         {
  93             do
  94                 i = fgetc(file);                /* find the newline or EOF */
  95             while (i != '\n' && i != EOF);
  96
  97             if (i == EOF)
  98             {
  99                 if (feof(file) == 0)                    /* EOF or error? */
 100                 {
 101                     ERR("%s\n", strerror(errno));
 102                     return FALSE;
 103                 }
 104
 105                 WARN("No newline at EOF\n");
 106             }
 107
 108             *p_result = INT_MIN;
 109             return TRUE;
 110         }
 111         else                            /* no newline and not truncated */
 112         {
 113             if (strcmp(buffer, "\x1a") == 0)        /* test for DOS EOF */
 114             {
 115                 *p_result = EOF;
 116                 return TRUE;
 117             }
 118
 119             WARN("No newline at EOF\n");
 120             cp = buffer + i;    /* points to \0 where \n should have been */
 121         }
 122     }
 123
 124     do
 125     {
 126         *cp = '\0';                             /* trim trailing whitespace */
 127         if (cp == buffer)
 128             break;                              /* don't underflow buffer */
 129         --cp;
 130     }
 131     while (isspace(*cp));
 132
 133     *p_result = strlen(buffer);
 134     return TRUE;
 135 }
 136
 137 /*******************************************************************************
 138  *  FindLine
 139  *
 140  *  Finds a line in the file that begins with the given string.  Returns FALSE
 141  *  for unexpected I/O errors; returns an empty (zero character) string if the
 142  *  requested line is not found.
 143  *
 144  *  NOTE:  The file pointer *MUST* be positioned at the beginning of a line when
 145  *      this function is called.  Otherwise, an infinite loop can result.
 146  *
 147  */
 148 static BOOL FindLine(FILE *file, CHAR buffer[], INT bufsize, LPCSTR key)
 149 {
 150     INT     len = strlen(key);
 151     LONG    start = ftell(file);
 152
 153     do
 154     {
 155         INT     result;
 156         BOOL    ok;
 157
 158         ok = ReadLine(file, buffer, bufsize, &result);
 159         if (ok == FALSE)
 160             return FALSE;
 161
 162         if (result > 0 && strncmp(buffer, key, len) == 0)
 163             return TRUE;
 164
 165         if (result == EOF)
 166         {
 167             rewind(file);
 168         }
 169         else if (result == INT_MIN)
 170         {
 171             WARN("Line beginning '%32s...' is too long; ignoring\n", buffer);
 172         }
 173     }
 174     while (ftell(file) != start);
 175
 176     WARN("Couldn't find line '%s...' in AFM file\n", key);
 177     buffer[0] = '\0';
 178     return TRUE;
 179 }
 180
 181 /*******************************************************************************
 182  *  DoubleToFloat
 183  *
 184  *  Utility function to convert double to float while checking for overflow.
 185  *  Will also catch strtod overflows, since HUGE_VAL > FLT_MAX (at least on
 186  *  Linux x86/gcc).
 187  *
 188  */
 189 static inline BOOL DoubleToFloat(float *p_f, double d)
 190 {
 191     if (d > (double)FLT_MAX || d < -(double)FLT_MAX)
 192         return FALSE;
 193
 194     *p_f = (float)d;
 195     return TRUE;
 196 }
 197
 198 /*******************************************************************************
 199  *  Round
 200  *
 201  *  Utility function to add or subtract 0.5 before converting to integer type.
 202  *
 203  */
 204 static inline float Round(float f)
 205 {
 206     return (f >= 0.0) ? (f + 0.5) : (f - 0.5);
 207 }
 208
 209 /*******************************************************************************
 210  *  ReadFloat
 211  *
 212  *  Finds and parses a line of the form '<key> <value>', where value is a
 213  *  number.  Sets *p_found to FALSE if a corresponding line cannot be found, or
 214  *  it cannot be parsed; also sets *p_ret to 0.0, so calling functions can just
 215  *  skip the check of *p_found if the item is not required.
 216  *
 217  */
 218 static BOOL ReadFloat(FILE *file, CHAR buffer[], INT bufsize, LPCSTR key,
 219         FLOAT *p_ret, BOOL *p_found)
 220 {
 221     CHAR    *cp, *end_ptr;
 222     double  d;
 223
 224     if (FindLine(file, buffer, bufsize, key) == FALSE)
 225         return FALSE;
 226
 227     if (buffer[0] == '\0')          /* line not found */
 228     {
 229         *p_found = FALSE;
 230         *p_ret = 0.0;
 231         return TRUE;
 232     }
 233
 234     cp = buffer + strlen(key);                      /* first char after key */
 235     errno = 0;
 236     d = strtod(cp, &end_ptr);
 237
 238     if (end_ptr == cp || errno != 0 || DoubleToFloat(p_ret, d) == FALSE)
 239     {
 240         WARN("Error parsing line '%s'\n", buffer);
 241         *p_found = FALSE;
 242         *p_ret = 0.0;
 243         return TRUE;
 244     }
 245
 246     *p_found = TRUE;
 247     return TRUE;
 248 }
 249
 250 /*******************************************************************************
 251  *  ReadInt
 252  *
 253  *  See description of ReadFloat.
 254  *
 255  */
 256 static BOOL ReadInt(FILE *file, CHAR buffer[], INT bufsize, LPCSTR key,
 257         INT *p_ret, BOOL *p_found)
 258 {
 259     BOOL    retval;
 260     FLOAT   f;
 261
 262     retval = ReadFloat(file, buffer, bufsize, key, &f, p_found);
 263     if (retval == FALSE || *p_found == FALSE)
 264     {
 265         *p_ret = 0;
 266         return retval;
 267     }
 268
 269     f = Round(f);
 270
 271     if (f > (FLOAT)INT_MAX || f < (FLOAT)INT_MIN)
 272     {
 273         WARN("Error parsing line '%s'\n", buffer);
 274         *p_ret = 0;
 275         *p_found = FALSE;
 276         return TRUE;
 277     }
 278
 279     *p_ret = (INT)f;
 280     return TRUE;
 281 }
 282
 283 /*******************************************************************************
 284  *  ReadString
 285  *
 286  *  Returns FALSE on I/O error or memory allocation failure; sets *p_str to NULL
 287  *  if line cannot be found or can't be parsed.
 288  *
 289  */
 290 static BOOL ReadString(FILE *file, CHAR buffer[], INT bufsize, LPCSTR key,
 291         LPSTR *p_str)
 292 {
 293     CHAR    *cp;
 294
 295     if (FindLine(file, buffer, bufsize, key) == FALSE)
 296         return FALSE;
 297
 298     if (buffer[0] == '\0')
 299     {
 300         *p_str = NULL;
 301         return TRUE;
 302     }
 303
 304     cp = buffer + strlen(key);                      /* first char after key */
 305     if (*cp == '\0')
 306     {
 307         *p_str = NULL;
 308         return TRUE;
 309     }
 310
 311     while (isspace(*cp))                /* find first non-whitespace char */
 312         ++cp;
 313
 314     *p_str = HeapAlloc(PSDRV_Heap, 0, strlen(cp) + 1);
 315     if (*p_str == NULL)
 316         return FALSE;
 317
 318     strcpy(*p_str, cp);
 319     return TRUE;
 320 }
 321
 322 /*******************************************************************************
 323  *  ReadBBox
 324  *
 325  *  Similar to ReadFloat above.
 326  *
 327  */
 328 static BOOL ReadBBox(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
 329         BOOL *p_found)
 330 {
 331     CHAR    *cp, *end_ptr;
 332     double  d;
 333
 334     if (FindLine(file, buffer, bufsize, "FontBBox") == FALSE)
 335         return FALSE;
 336
 337     if (buffer[0] == '\0')
 338     {
 339         *p_found = FALSE;
 340         return TRUE;
 341     }
 342
 343     errno = 0;
 344
 345     cp = buffer + sizeof("FontBBox");
 346     d = strtod(cp, &end_ptr);
 347     if (end_ptr == cp || errno != 0 ||
 348             DoubleToFloat(&(afm->FontBBox.llx), d) == FALSE)
 349         goto parse_error;
 350
 351     cp = end_ptr;
 352     d = strtod(cp, &end_ptr);
 353     if (end_ptr == cp || errno != 0 ||
 354             DoubleToFloat(&(afm->FontBBox.lly), d) == FALSE)
 355         goto parse_error;
 356
 357     cp = end_ptr;
 358     d = strtod(cp, &end_ptr);
 359     if (end_ptr == cp || errno != 0
 360             || DoubleToFloat(&(afm->FontBBox.urx), d) == FALSE)
 361         goto parse_error;
 362
 363     cp = end_ptr;
 364     d = strtod(cp, &end_ptr);
 365     if (end_ptr == cp || errno != 0
 366             || DoubleToFloat(&(afm->FontBBox.ury), d) == FALSE)
 367         goto parse_error;
 368
 369     *p_found = TRUE;
 370     return TRUE;
 371
 372     parse_error:
 373         WARN("Error parsing line '%s'\n", buffer);
 374         *p_found = FALSE;
 375         return TRUE;
 376 }
 377
 378 /*******************************************************************************
 379  *  ReadWeight
 380  *
 381  *  Finds and parses the 'Weight' line of an AFM file.  Only tries to determine
 382  *  if a font is bold (FW_BOLD) or not (FW_NORMAL) -- ignoring all those cute
 383  *  little FW_* typedefs in the Win32 doc.  AFAICT, this is what the Windows
 384  *  PostScript driver does.
 385  *
 386  */
 387 static const struct { LPCSTR keyword; INT weight; } afm_weights[] =
 388 {
 389     { "REGULAR",        FW_NORMAL },
 390     { "NORMAL",         FW_NORMAL },
 391     { "ROMAN",          FW_NORMAL },
 392     { "BOLD",           FW_BOLD },
 393     { "BOOK",           FW_NORMAL },
 394     { "MEDIUM",         FW_NORMAL },
 395     { "LIGHT",          FW_NORMAL },
 396     { "BLACK",          FW_BOLD },
 397     { "HEAVY",          FW_BOLD },
 398     { "DEMI",           FW_BOLD },
 399     { "ULTRA",          FW_BOLD },
 400     { "SUPER" ,         FW_BOLD },
 401     { NULL,             0 }
 402 };
 403
 404 static BOOL ReadWeight(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
 405         BOOL *p_found)
 406 {
 407     LPSTR   sz;
 408     CHAR    *cp;
 409     INT     i;
 410
 411     if (ReadString(file, buffer, bufsize, "Weight", &sz) == FALSE)
 412         return FALSE;
 413
 414     if (sz == NULL)
 415     {
 416         *p_found = FALSE;
 417         return TRUE;
 418     }
 419
 420     for (cp = sz; *cp != '\0'; ++cp)
 421         *cp = toupper(*cp);
 422
 423     for (i = 0; afm_weights[i].keyword != NULL; ++i)
 424     {
 425         if (strstr(sz, afm_weights[i].keyword) != NULL)
 426         {
 427             afm->Weight = afm_weights[i].weight;
 428             *p_found = TRUE;
 429             HeapFree(PSDRV_Heap, 0, sz);
 430             return TRUE;
 431         }
 432     }
 433
 434     WARN("Unknown weight '%s'; treating as Roman\n", sz);
 435
 436     afm->Weight = FW_NORMAL;
 437     *p_found = TRUE;
 438     HeapFree(PSDRV_Heap, 0, sz);
 439     return TRUE;
 440 }
 441
 442 /*******************************************************************************
 443  *  ReadFixedPitch
 444  *
 445  */
 446 static BOOL ReadFixedPitch(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
 447         BOOL *p_found)
 448 {
 449     LPSTR   sz;
 450
 451     if (ReadString(file, buffer, bufsize, "IsFixedPitch", &sz) == FALSE)
 452         return FALSE;
 453
 454     if (sz == NULL)
 455     {
 456         *p_found = FALSE;
 457         return TRUE;
 458     }
 459
 460     if (stricmp(sz, "false") == 0)
 461     {
 462         afm->IsFixedPitch = FALSE;
 463         *p_found = TRUE;
 464         HeapFree(PSDRV_Heap, 0, sz);
 465         return TRUE;
 466     }
 467
 468     if (stricmp(sz, "true") == 0)
 469     {
 470         afm->IsFixedPitch = TRUE;
 471         *p_found = TRUE;
 472         HeapFree(PSDRV_Heap, 0, sz);
 473         return TRUE;
 474     }
 475
 476     WARN("Can't parse line '%s'\n", buffer);
 477
 478     *p_found = FALSE;
 479     HeapFree(PSDRV_Heap, 0, sz);
 480     return TRUE;
 481 }
 482
 483 /*******************************************************************************
 484  *  ReadFontMetrics
 485  *
 486  *  Allocates space for the AFM on the driver heap and reads basic font metrics.
 487  *  Returns FALSE for memory allocation failure; sets *p_afm to NULL if AFM file
 488  *  is unusable.
 489  *
 490  */
 491 static BOOL ReadFontMetrics(FILE *file, CHAR buffer[], INT bufsize, AFM **p_afm)
 492 {
 493     AFM     *afm;
 494     BOOL    retval, found;
 495
 496     *p_afm = afm = HeapAlloc(PSDRV_Heap, 0, sizeof(*afm));
 497     if (afm == NULL)
 498         return FALSE;
 499
 500     retval = ReadWeight(file, buffer, bufsize, afm, &found);
 501     if (retval == FALSE || found == FALSE)
 502         goto cleanup_afm;
 503
 504     retval = ReadFloat(file, buffer, bufsize, "ItalicAngle",
 505             &(afm->ItalicAngle), &found);
 506     if (retval == FALSE || found == FALSE)
 507         goto cleanup_afm;
 508
 509     retval = ReadFixedPitch(file, buffer, bufsize, afm, &found);
 510     if (retval == FALSE || found == FALSE)
 511         goto cleanup_afm;
 512
 513     retval = ReadBBox(file, buffer, bufsize, afm, &found);
 514     if (retval == FALSE || found == FALSE)
 515         goto cleanup_afm;
 516
 517     retval = ReadFloat(file, buffer, bufsize, "UnderlinePosition",
 518             &(afm->UnderlinePosition), &found);
 519     if (retval == FALSE || found == FALSE)
 520         goto cleanup_afm;
 521
 522     retval = ReadFloat(file, buffer, bufsize, "UnderlineThickness",
 523             &(afm->UnderlineThickness), &found);
 524     if (retval == FALSE || found == FALSE)
 525         goto cleanup_afm;
 526
 527     retval = ReadFloat(file, buffer, bufsize, "Ascender",       /* optional */
 528             &(afm->Ascender), &found);
 529     if (retval == FALSE)
 530         goto cleanup_afm;
 531
 532     retval = ReadFloat(file, buffer, bufsize, "Descender",      /* optional */
 533             &(afm->Descender), &found);
 534     if (retval == FALSE)
 535         goto cleanup_afm;
 536
 537     afm->WinMetrics.usUnitsPerEm = 1000;
 538     afm->WinMetrics.sTypoAscender = (SHORT)Round(afm->Ascender);
 539     afm->WinMetrics.sTypoDescender = (SHORT)Round(afm->Descender);
 540
 541     if (afm->WinMetrics.sTypoAscender == 0)
 542         afm->WinMetrics.sTypoAscender = (SHORT)Round(afm->FontBBox.ury);
 543
 544     if (afm->WinMetrics.sTypoDescender == 0)
 545         afm->WinMetrics.sTypoDescender = (SHORT)Round(afm->FontBBox.lly);
 546
 547     afm->WinMetrics.sTypoLineGap = 1200 -
 548             (afm->WinMetrics.sTypoAscender - afm->WinMetrics.sTypoDescender);
 549     if (afm->WinMetrics.sTypoLineGap < 0)
 550         afm->WinMetrics.sTypoLineGap = 0;
 551
 552     return TRUE;
 553
 554     cleanup_afm:                        /* handle fatal or non-fatal errors */
 555         HeapFree(PSDRV_Heap, 0, afm);
 556         *p_afm = NULL;
 557         return retval;
 558 }
 559
 560 /*******************************************************************************
 561  *  ParseC
 562  *
 563  *  Fatal error:        return FALSE (none defined)
 564  *
 565  *  Non-fatal error:    leave metrics->C set to INT_MAX
 566  *
 567  */
 568 static BOOL ParseC(LPSTR sz, OLD_AFMMETRICS *metrics)
 569 {
 570     int     base = 10;
 571     long    l;
 572     CHAR    *cp, *end_ptr;
 573
 574     cp = sz + 1;
 575
 576     if (*cp == 'H')
 577     {
 578         base = 16;
 579         ++cp;
 580     }
 581
 582     errno = 0;
 583     l = strtol(cp, &end_ptr, base);
 584     if (end_ptr == cp || errno != 0 || l > INT_MAX || l < INT_MIN)
 585     {
 586         WARN("Error parsing character code '%s'\n", sz);
 587         return TRUE;
 588     }
 589
 590     metrics->C = (INT)l;
 591     return TRUE;
 592 }
 593
 594 /*******************************************************************************
 595  *  ParseW
 596  *
 597  *  Fatal error:        return FALSE (none defined)
 598  *
 599  *  Non-fatal error:    leave metrics->WX set to FLT_MAX
 600  *
 601  */
 602 static BOOL ParseW(LPSTR sz, OLD_AFMMETRICS *metrics)
 603 {
 604     CHAR    *cp, *end_ptr;
 605     BOOL    vector = TRUE;
 606     double  d;
 607
 608     cp = sz + 1;
 609
 610     if (*cp == '0')
 611         ++cp;
 612
 613     if (*cp == 'X')
 614     {
 615         vector = FALSE;
 616         ++cp;
 617     }
 618
 619     if (!isspace(*cp))
 620         goto parse_error;
 621
 622     errno = 0;
 623     d = strtod(cp, &end_ptr);
 624     if (end_ptr == cp || errno != 0 ||
 625             DoubleToFloat(&(metrics->WX), d) == FALSE)
 626         goto parse_error;
 627
 628     if (vector == FALSE)
 629         return TRUE;
 630
 631     /*  Make sure that Y component of vector is zero */
 632
 633     d = strtod(cp, &end_ptr);                               /* errno == 0 */
 634     if (end_ptr == cp || errno != 0 || d != 0.0)
 635     {
 636         metrics->WX = FLT_MAX;
 637         goto parse_error;
 638     }
 639
 640     return TRUE;
 641
 642     parse_error:
 643         WARN("Error parsing character width '%s'\n", sz);
 644         return TRUE;
 645 }
 646
 647 /*******************************************************************************
 648  *
 649  *  ParseB
 650  *
 651  *  Fatal error:        return FALSE (none defined)
 652  *
 653  *  Non-fatal error:    leave metrics->B.ury set to FLT_MAX
 654  *
 655  */
 656 static BOOL ParseB(LPSTR sz, OLD_AFMMETRICS *metrics)
 657 {
 658     CHAR    *cp, *end_ptr;
 659     double  d;
 660
 661     errno = 0;
 662
 663     cp = sz + 1;
 664     d = strtod(cp, &end_ptr);
 665     if (end_ptr == cp || errno != 0 ||
 666             DoubleToFloat(&(metrics->B.llx), d) == FALSE)
 667         goto parse_error;
 668
 669     cp = end_ptr;
 670     d = strtod(cp, &end_ptr);
 671     if (end_ptr == cp || errno != 0 ||
 672             DoubleToFloat(&(metrics->B.lly), d) == FALSE)
 673         goto parse_error;
 674
 675     cp = end_ptr;
 676     d = strtod(cp, &end_ptr);
 677     if (end_ptr == cp || errno != 0 ||
 678             DoubleToFloat(&(metrics->B.urx), d) == FALSE)
 679         goto parse_error;
 680
 681     cp = end_ptr;
 682     d = strtod(cp, &end_ptr);
 683     if (end_ptr == cp || errno != 0 ||
 684             DoubleToFloat(&(metrics->B.ury), d) == FALSE)
 685         goto parse_error;
 686
 687     return TRUE;
 688
 689     parse_error:
 690         WARN("Error parsing glyph bounding box '%s'\n", sz);
 691         return TRUE;
 692 }
 693
 694 /*******************************************************************************
 695  *  ParseN
 696  *
 697  *  Fatal error:        return FALSE (PSDRV_GlyphName failure)
 698  *
 699  *  Non-fatal error:    leave metrics-> set to NULL
 700  *
 701  */
 702 static BOOL ParseN(LPSTR sz, OLD_AFMMETRICS *metrics)
 703 {
 704     CHAR    save, *cp, *end_ptr;
 705
 706     cp = sz + 1;
 707
 708     while (isspace(*cp))
 709         ++cp;
 710
 711     end_ptr = cp;
 712
 713     while (*end_ptr != '\0' && !isspace(*end_ptr))
 714         ++end_ptr;
 715
 716     if (end_ptr == cp)
 717     {
 718         WARN("Error parsing glyph name '%s'\n", sz);
 719         return TRUE;
 720     }
 721
 722     save = *end_ptr;
 723     *end_ptr = '\0';
 724
 725     metrics->N = PSDRV_GlyphName(cp);
 726     if (metrics->N == NULL)
 727         return FALSE;
 728
 729     *end_ptr = save;
 730     return TRUE;
 731 }
 732
 733 /*******************************************************************************
 734  *  ParseCharMetrics
 735  *
 736  *  Parses the metrics line for a single glyph in an AFM file.  Returns FALSE on
 737  *  fatal error; sets *metrics to 'badmetrics' on non-fatal error.
 738  *
 739  */
 740 static const OLD_AFMMETRICS badmetrics =
 741 {
 742     INT_MAX,                                        /* C */
 743     INT_MAX,                                        /* UV */
 744     FLT_MAX,                                        /* WX */
 745     NULL,                                           /* N */
 746     { FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX },         /* B */
 747     NULL                                            /* L */
 748 };
 749
 750 static BOOL ParseCharMetrics(LPSTR buffer, INT len, OLD_AFMMETRICS *metrics)
 751 {
 752     CHAR    *cp = buffer;
 753
 754     *metrics = badmetrics;
 755
 756     while (*cp != '\0')
 757     {
 758         while (isspace(*cp))
 759             ++cp;
 760
 761         switch(*cp)
 762         {
 763             case 'C':   if (ParseC(cp, metrics) == FALSE)
 764                             return FALSE;
 765                         break;
 766
 767             case 'W':   if (ParseW(cp, metrics) == FALSE)
 768                             return FALSE;
 769                         break;
 770
 771             case 'N':   if (ParseN(cp, metrics) == FALSE)
 772                             return FALSE;
 773                         break;
 774
 775             case 'B':   if (ParseB(cp, metrics) == FALSE)
 776                             return FALSE;
 777                         break;
 778         }
 779
 780         cp = strchr(cp, ';');
 781         if (cp == NULL)
 782         {
 783             WARN("No terminating semicolon\n");
 784             break;
 785         }
 786
 787         ++cp;
 788     }
 789
 790     if (metrics->C == INT_MAX || metrics->WX == FLT_MAX || metrics->N == NULL ||
 791             metrics->B.ury == FLT_MAX)
 792     {
 793         *metrics = badmetrics;
 794         return TRUE;
 795     }
 796
 797     return TRUE;
 798 }
 799
 800 /*******************************************************************************
 801  *  IsWinANSI
 802  *
 803  *  Checks whether Unicode value is part of Microsoft code page 1252
 804  *
 805  */
 806 static const LONG ansiChars[21] =
 807 {
 808     0x0152, 0x0153, 0x0160, 0x0161, 0x0178, 0x017d, 0x017e, 0x0192, 0x02c6,
 809     0x02c9, 0x02dc, 0x03bc, 0x2013, 0x2014, 0x2026, 0x2030, 0x2039, 0x203a,
 810     0x20ac, 0x2122, 0x2219
 811 };
 812
 813 static int __cdecl cmpUV(const void *a, const void *b)
 814 {
 815     return (int)(*((const LONG *)a) - *((const LONG *)b));
 816 }
 817
 818 static inline BOOL IsWinANSI(LONG uv)
 819 {
 820     if ((0x0020 <= uv && uv <= 0x007e) || (0x00a0 <= uv && uv <= 0x00ff) ||
 821             (0x2018 <= uv && uv <= 0x201a) || (0x201c <= uv && uv <= 0x201e) ||
 822             (0x2020 <= uv && uv <= 0x2022))
 823         return TRUE;
 824
 825     if (bsearch(&uv, ansiChars, 21, sizeof(INT), cmpUV) != NULL)
 826         return TRUE;
 827
 828     return FALSE;
 829 }
 830
 831 /*******************************************************************************
 832  *  Unicodify
 833  *
 834  *  Determines Unicode value (UV) for each glyph, based on font encoding.
 835  *
 836  *      FontSpecific:   Usable encodings (0x20 - 0xff) are mapped into the
 837  *                      Unicode private use range U+F020 - U+F0FF.
 838  *
 839  *      other:          UV determined by glyph name, based on Adobe Glyph List.
 840  *
 841  *  Also does some font metric calculations that require UVs to be known.
 842  *
 843  */
 844 static int __cdecl UnicodeGlyphByNameIndex(const void *a, const void *b)
 845 {
 846     return ((const UNICODEGLYPH *)a)->name->index -
 847             ((const UNICODEGLYPH *)b)->name->index;
 848 }
 849
 850 static VOID Unicodify(AFM *afm, OLD_AFMMETRICS *metrics)
 851 {
 852     INT     i;
 853
 854     if (strcmp(afm->EncodingScheme, "FontSpecific") == 0)
 855     {
 856         for (i = 0; i < afm->NumofMetrics; ++i)
 857         {
 858             if (metrics[i].C >= 0x20 && metrics[i].C <= 0xff)
 859             {
 860                 metrics[i].UV = metrics[i].C | 0xf000L;
 861             }
 862             else
 863             {
 864                 TRACE("Unencoded glyph '%s'\n", metrics[i].N->sz);
 865                 metrics[i].UV = -1L;
 866             }
 867         }
 868
 869         afm->WinMetrics.sAscender = (SHORT)Round(afm->FontBBox.ury);
 870         afm->WinMetrics.sDescender = (SHORT)Round(afm->FontBBox.lly);
 871     }
 872     else                                        /* non-FontSpecific encoding */
 873     {
 874         UNICODEGLYPH    ug, *p_ug;
 875
 876         PSDRV_IndexGlyphList();         /* for fast searching of glyph names */
 877
 878         afm->WinMetrics.sAscender = afm->WinMetrics.sDescender = 0;
 879
 880         for (i = 0; i < afm->NumofMetrics; ++i)
 881         {
 882             ug.name = metrics[i].N;
 883             p_ug = bsearch(&ug, PSDRV_AGLbyName, PSDRV_AGLbyNameSize,
 884                     sizeof(ug), UnicodeGlyphByNameIndex);
 885             if (p_ug == NULL)
 886             {
 887                 TRACE("Glyph '%s' not in Adobe Glyph List\n", ug.name->sz);
 888                 metrics[i].UV = -1L;
 889             }
 890             else
 891             {
 892                 metrics[i].UV = p_ug->UV;
 893
 894                 if (IsWinANSI(p_ug->UV))
 895                 {
 896                     SHORT   ury = (SHORT)Round(metrics[i].B.ury);
 897                     SHORT   lly = (SHORT)Round(metrics[i].B.lly);
 898
 899                     if (ury > afm->WinMetrics.sAscender)
 900                         afm->WinMetrics.sAscender = ury;
 901                     if (lly < afm->WinMetrics.sDescender)
 902                         afm->WinMetrics.sDescender = lly;
 903                 }
 904             }
 905         }
 906
 907         if (afm->WinMetrics.sAscender == 0)
 908             afm->WinMetrics.sAscender = (SHORT)Round(afm->FontBBox.ury);
 909         if (afm->WinMetrics.sDescender == 0)
 910             afm->WinMetrics.sDescender = (SHORT)Round(afm->FontBBox.lly);
 911     }
 912
 913     afm->WinMetrics.sLineGap =
 914             1150 - (afm->WinMetrics.sAscender - afm->WinMetrics.sDescender);
 915     if (afm->WinMetrics.sLineGap < 0)
 916         afm->WinMetrics.sLineGap = 0;
 917
 918     afm->WinMetrics.usWinAscent = (afm->WinMetrics.sAscender > 0) ?
 919             afm->WinMetrics.sAscender : 0;
 920     afm->WinMetrics.usWinDescent = (afm->WinMetrics.sDescender < 0) ?
 921             -(afm->WinMetrics.sDescender) : 0;
 922 }
 923
 924 /*******************************************************************************
 925  *  ReadCharMetrics
 926  *
 927  *  Reads metrics for all glyphs.  *p_metrics will be NULL on non-fatal error.
 928  *
 929  */
 930 static int __cdecl OldAFMMetricsByUV(const void *a, const void *b)
 931 {
 932     return ((const OLD_AFMMETRICS *)a)->UV - ((const OLD_AFMMETRICS *)b)->UV;
 933 }
 934
 935 static BOOL ReadCharMetrics(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
 936         AFMMETRICS **p_metrics)
 937 {
 938     BOOL            retval, found;
 939     OLD_AFMMETRICS  *old_metrics, *encoded_metrics;
 940     AFMMETRICS      *metrics;
 941     INT             i, len;
 942
 943     retval = ReadInt(file, buffer, bufsize, "StartCharMetrics",
 944             &(afm->NumofMetrics), &found);
 945     if (retval == FALSE || found == FALSE)
 946     {
 947         *p_metrics = NULL;
 948         return retval;
 949     }
 950
 951     old_metrics = HeapAlloc(PSDRV_Heap, 0,
 952             afm->NumofMetrics * sizeof(*old_metrics));
 953     if (old_metrics == NULL)
 954         return FALSE;
 955
 956     for (i = 0; i < afm->NumofMetrics; ++i)
 957     {
 958         retval = ReadLine(file, buffer, bufsize, &len);
 959         if (retval == FALSE)
 960             goto cleanup_old_metrics;
 961
 962         if(len > 0)
 963         {
 964             retval = ParseCharMetrics(buffer, len, old_metrics + i);
 965             if (retval == FALSE || old_metrics[i].C == INT_MAX)
 966                 goto cleanup_old_metrics;
 967
 968             continue;
 969         }
 970
 971         switch (len)
 972         {
 973             case 0:         --i;
 974                             continue;
 975
 976             case INT_MIN:   WARN("Ignoring long line '%32s...'\n", buffer);
 977                             goto cleanup_old_metrics;       /* retval == TRUE */
 978
 979             case EOF:       WARN("Unexpected EOF\n");
 980                             goto cleanup_old_metrics;       /* retval == TRUE */
 981         }
 982     }
 983
 984     Unicodify(afm, old_metrics);    /* wait until glyph names have been read */
 985
 986     qsort(old_metrics, afm->NumofMetrics, sizeof(*old_metrics),
 987             OldAFMMetricsByUV);
 988
 989     for (i = 0; old_metrics[i].UV == -1; ++i);      /* count unencoded glyphs */
 990
 991     afm->NumofMetrics -= i;
 992     encoded_metrics = old_metrics + i;
 993
 994     afm->Metrics = *p_metrics = metrics = HeapAlloc(PSDRV_Heap, 0,
 995             afm->NumofMetrics * sizeof(*metrics));
 996     if (afm->Metrics == NULL)
 997         goto cleanup_old_metrics;                           /* retval == TRUE */
 998
 999     for (i = 0; i < afm->NumofMetrics; ++i, ++metrics, ++encoded_metrics)
1000     {
1001         metrics->C = encoded_metrics->C;
1002         metrics->UV = encoded_metrics->UV;
1003         metrics->WX = encoded_metrics->WX;
1004         metrics->N = encoded_metrics->N;
1005     }
1006
1007     HeapFree(PSDRV_Heap, 0, old_metrics);
1008
1009     afm->WinMetrics.sAvgCharWidth = PSDRV_CalcAvgCharWidth(afm);
1010
1011     return TRUE;
1012
1013     cleanup_old_metrics:                /* handle fatal or non-fatal errors */
1014         HeapFree(PSDRV_Heap, 0, old_metrics);
1015         *p_metrics = NULL;
1016         return retval;
1017 }
1018
1019 /*******************************************************************************
1020  *  BuildAFM
1021  *
1022  *  Builds the AFM for a PostScript font and adds it to the driver font list.
1023  *  Returns FALSE only on an unexpected error (memory allocation or I/O error).
1024  *
1025  */
1026 static BOOL BuildAFM(FILE *file)
1027 {
1028     CHAR        buffer[258];            /* allow for <cr>, <lf>, and <nul> */
1029     AFM         *afm;
1030     AFMMETRICS  *metrics;
1031     LPSTR       font_name, full_name, family_name, encoding_scheme;
1032     BOOL        retval, added;
1033
1034     retval = ReadFontMetrics(file, buffer, sizeof(buffer), &afm);
1035     if (retval == FALSE || afm == NULL)
1036         return retval;
1037
1038     retval = ReadString(file, buffer, sizeof(buffer), "FontName", &font_name);
1039     if (retval == FALSE || font_name == NULL)
1040         goto cleanup_afm;
1041
1042     retval = ReadString(file, buffer, sizeof(buffer), "FullName", &full_name);
1043     if (retval == FALSE || full_name == NULL)
1044         goto cleanup_font_name;
1045
1046     retval = ReadString(file, buffer, sizeof(buffer), "FamilyName",
1047             &family_name);
1048     if (retval == FALSE || family_name == NULL)
1049         goto cleanup_full_name;
1050
1051     retval = ReadString(file, buffer, sizeof(buffer), "EncodingScheme",
1052             &encoding_scheme);
1053     if (retval == FALSE || encoding_scheme == NULL)
1054         goto cleanup_family_name;
1055
1056     afm->FontName = font_name;
1057     afm->FullName = full_name;
1058     afm->FamilyName = family_name;
1059     afm->EncodingScheme = encoding_scheme;
1060
1061     retval = ReadCharMetrics(file, buffer, sizeof(buffer), afm, &metrics);
1062     if (retval == FALSE || metrics == FALSE)
1063         goto cleanup_encoding_scheme;
1064
1065     retval = PSDRV_AddAFMtoList(&PSDRV_AFMFontList, afm, &added);
1066     if (retval == FALSE || added == FALSE)
1067         goto cleanup_encoding_scheme;
1068
1069     return TRUE;
1070
1071     /* clean up after fatal or non-fatal errors */
1072
1073     cleanup_encoding_scheme:
1074         HeapFree(PSDRV_Heap, 0, encoding_scheme);
1075     cleanup_family_name:
1076         HeapFree(PSDRV_Heap, 0, family_name);
1077     cleanup_full_name:
1078         HeapFree(PSDRV_Heap, 0, full_name);
1079     cleanup_font_name:
1080         HeapFree(PSDRV_Heap, 0, font_name);
1081     cleanup_afm:
1082         HeapFree(PSDRV_Heap, 0, afm);
1083
1084     return retval;
1085 }
1086
1087 /*******************************************************************************
1088  *  ReadAFMFile
1089  *
1090  *  Reads font metrics from Type 1 AFM file.  Only returns FALSE for
1091  *  unexpected errors (memory allocation or I/O).
1092  *
1093  */
1094 static BOOL ReadAFMFile(LPCWSTR filename)
1095 {
1096     FILE    *f;
1097     BOOL    retval;
1098
1099     TRACE("%s\n", debugstr_w(filename));
1100
1101     f = _wfopen(filename, L"r");
1102     if (f == NULL)
1103     {
1104         WARN("%s: %s\n", debugstr_w(filename), strerror(errno));
1105         return TRUE;
1106     }
1107
1108     retval = BuildAFM(f);
1109
1110     fclose(f);
1111     return retval;
1112 }
1113
1114 /*******************************************************************************
1115  *  ReadAFMDir
1116  *
1117  *  Reads all Type 1 AFM files in a directory.
1118  *
1119  */
1120 static BOOL ReadAFMDir(LPCSTR dirname)
1121 {
1122     WCHAR *path = wine_get_dos_file_name( dirname );
1123     struct _wfinddata_t data;
1124     intptr_t handle;
1125     WCHAR *p, *filename;
1126     BOOL ret = TRUE;
1127
1128     if (!path) return TRUE;
1129     if (!(filename = HeapAlloc( GetProcessHeap(), 0, lstrlenW(path) + 256 )))
1130     {
1131         HeapFree( GetProcessHeap(), 0, path );
1132         return FALSE;
1133     }
1134     lstrcpyW( filename, path );
1135     HeapFree( GetProcessHeap(), 0, path );
1136     p = filename + lstrlenW(filename);
1137     *p++ = '\\';
1138     lstrcpyW( p, L"*" );
1139
1140     handle = _wfindfirst( filename, &data );
1141     if (handle != -1)
1142     {
1143         do
1144         {
1145             WCHAR *ext = wcschr( data.name, '.' );
1146             if (!ext || wcsicmp(ext, L".afm")) continue;
1147             lstrcpyW( p, data.name );
1148             if (!(ret = ReadAFMFile( filename ))) break;
1149         } while (!_wfindnext( handle, &data ));
1150     }
1151     _findclose( handle );
1152
1153     HeapFree( GetProcessHeap(), 0, filename );
1154     return ret;
1155 }
1156
1157 /*******************************************************************************
1158  *  PSDRV_GetType1Metrics
1159  *
1160  *  Reads font metrics from Type 1 AFM font files in directories listed in the
1161  *  HKEY_CURRENT_USER\\Software\\Wine\\Fonts\\AFMPath registry string.
1162  *
1163  *  If this function fails (returns FALSE), the driver will fail to initialize
1164  *  and the driver heap will be destroyed, so it's not necessary to HeapFree
1165  *  everything in that event.
1166  *
1167  */
1168 BOOL PSDRV_GetType1Metrics(void)
1169 {
1170     HKEY hkey;
1171     DWORD len;
1172     LPWSTR valueW;
1173     LPSTR valueA, ptr;
1174
1175     /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
1176     if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) != ERROR_SUCCESS)
1177         return TRUE;
1178
1179     if (RegQueryValueExW( hkey, L"AFMPath", NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
1180     {
1181         len += sizeof(WCHAR);
1182         valueW = HeapAlloc( PSDRV_Heap, 0, len );
1183         if (RegQueryValueExW( hkey, L"AFMPath", NULL, NULL, (BYTE *)valueW, &len ) == ERROR_SUCCESS)
1184         {
1185             len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
1186             valueA = HeapAlloc( PSDRV_Heap, 0, len );
1187             WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
1188             TRACE( "got AFM font path %s\n", debugstr_a(valueA) );
1189             ptr = valueA;
1190             while (ptr)
1191             {
1192                 LPSTR next = strchr( ptr, ':' );
1193                 if (next) *next++ = 0;
1194                 if (!ReadAFMDir( ptr ))
1195                 {
1196                     RegCloseKey(hkey);
1197                     return FALSE;
1198                 }
1199                 ptr = next;
1200             }
1201             HeapFree( PSDRV_Heap, 0, valueA );
1202         }
1203         HeapFree( PSDRV_Heap, 0, valueW );
1204     }
1205
1206     RegCloseKey(hkey);
1207     return TRUE;
1208 }