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 static BOOL ReadStringW(FILE *file, CHAR *buffer, int size, const char *key, WCHAR **out)
 323 {
 324     char *outA;
 325     int len;
 326
 327     if (!ReadString(file, buffer, size, key, &outA))
 328         return FALSE;
 329     if (!outA)
 330     {
 331         *out = NULL;
 332         return TRUE;
 333     }
 334
 335     len = MultiByteToWideChar(CP_ACP, 0, outA, -1, NULL, 0);
 336     if (len)
 337         *out = HeapAlloc(PSDRV_Heap, 0, len * sizeof(WCHAR));
 338     if (!len || !*out)
 339     {
 340         HeapFree(PSDRV_Heap, 0, outA);
 341         return FALSE;
 342     }
 343     MultiByteToWideChar(CP_ACP, 0, outA, -1, *out, len);
 344     HeapFree(PSDRV_Heap, 0, outA);
 345     return TRUE;
 346 }
 347
 348 /*******************************************************************************
 349  *  ReadBBox
 350  *
 351  *  Similar to ReadFloat above.
 352  *
 353  */
 354 static BOOL ReadBBox(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
 355         BOOL *p_found)
 356 {
 357     CHAR    *cp, *end_ptr;
 358     double  d;
 359
 360     if (FindLine(file, buffer, bufsize, "FontBBox") == FALSE)
 361         return FALSE;
 362
 363     if (buffer[0] == '\0')
 364     {
 365         *p_found = FALSE;
 366         return TRUE;
 367     }
 368
 369     errno = 0;
 370
 371     cp = buffer + sizeof("FontBBox");
 372     d = strtod(cp, &end_ptr);
 373     if (end_ptr == cp || errno != 0 ||
 374             DoubleToFloat(&(afm->FontBBox.llx), d) == FALSE)
 375         goto parse_error;
 376
 377     cp = end_ptr;
 378     d = strtod(cp, &end_ptr);
 379     if (end_ptr == cp || errno != 0 ||
 380             DoubleToFloat(&(afm->FontBBox.lly), d) == FALSE)
 381         goto parse_error;
 382
 383     cp = end_ptr;
 384     d = strtod(cp, &end_ptr);
 385     if (end_ptr == cp || errno != 0
 386             || DoubleToFloat(&(afm->FontBBox.urx), d) == FALSE)
 387         goto parse_error;
 388
 389     cp = end_ptr;
 390     d = strtod(cp, &end_ptr);
 391     if (end_ptr == cp || errno != 0
 392             || DoubleToFloat(&(afm->FontBBox.ury), d) == FALSE)
 393         goto parse_error;
 394
 395     *p_found = TRUE;
 396     return TRUE;
 397
 398     parse_error:
 399         WARN("Error parsing line '%s'\n", buffer);
 400         *p_found = FALSE;
 401         return TRUE;
 402 }
 403
 404 /*******************************************************************************
 405  *  ReadWeight
 406  *
 407  *  Finds and parses the 'Weight' line of an AFM file.  Only tries to determine
 408  *  if a font is bold (FW_BOLD) or not (FW_NORMAL) -- ignoring all those cute
 409  *  little FW_* typedefs in the Win32 doc.  AFAICT, this is what the Windows
 410  *  PostScript driver does.
 411  *
 412  */
 413 static const struct { LPCSTR keyword; INT weight; } afm_weights[] =
 414 {
 415     { "REGULAR",        FW_NORMAL },
 416     { "NORMAL",         FW_NORMAL },
 417     { "ROMAN",          FW_NORMAL },
 418     { "BOLD",           FW_BOLD },
 419     { "BOOK",           FW_NORMAL },
 420     { "MEDIUM",         FW_NORMAL },
 421     { "LIGHT",          FW_NORMAL },
 422     { "BLACK",          FW_BOLD },
 423     { "HEAVY",          FW_BOLD },
 424     { "DEMI",           FW_BOLD },
 425     { "ULTRA",          FW_BOLD },
 426     { "SUPER" ,         FW_BOLD },
 427     { NULL,             0 }
 428 };
 429
 430 static BOOL ReadWeight(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
 431         BOOL *p_found)
 432 {
 433     LPSTR   sz;
 434     CHAR    *cp;
 435     INT     i;
 436
 437     if (ReadString(file, buffer, bufsize, "Weight", &sz) == FALSE)
 438         return FALSE;
 439
 440     if (sz == NULL)
 441     {
 442         *p_found = FALSE;
 443         return TRUE;
 444     }
 445
 446     for (cp = sz; *cp != '\0'; ++cp)
 447         *cp = toupper(*cp);
 448
 449     for (i = 0; afm_weights[i].keyword != NULL; ++i)
 450     {
 451         if (strstr(sz, afm_weights[i].keyword) != NULL)
 452         {
 453             afm->Weight = afm_weights[i].weight;
 454             *p_found = TRUE;
 455             HeapFree(PSDRV_Heap, 0, sz);
 456             return TRUE;
 457         }
 458     }
 459
 460     WARN("Unknown weight '%s'; treating as Roman\n", sz);
 461
 462     afm->Weight = FW_NORMAL;
 463     *p_found = TRUE;
 464     HeapFree(PSDRV_Heap, 0, sz);
 465     return TRUE;
 466 }
 467
 468 /*******************************************************************************
 469  *  ReadFixedPitch
 470  *
 471  */
 472 static BOOL ReadFixedPitch(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
 473         BOOL *p_found)
 474 {
 475     LPSTR   sz;
 476
 477     if (ReadString(file, buffer, bufsize, "IsFixedPitch", &sz) == FALSE)
 478         return FALSE;
 479
 480     if (sz == NULL)
 481     {
 482         *p_found = FALSE;
 483         return TRUE;
 484     }
 485
 486     if (stricmp(sz, "false") == 0)
 487     {
 488         afm->IsFixedPitch = FALSE;
 489         *p_found = TRUE;
 490         HeapFree(PSDRV_Heap, 0, sz);
 491         return TRUE;
 492     }
 493
 494     if (stricmp(sz, "true") == 0)
 495     {
 496         afm->IsFixedPitch = TRUE;
 497         *p_found = TRUE;
 498         HeapFree(PSDRV_Heap, 0, sz);
 499         return TRUE;
 500     }
 501
 502     WARN("Can't parse line '%s'\n", buffer);
 503
 504     *p_found = FALSE;
 505     HeapFree(PSDRV_Heap, 0, sz);
 506     return TRUE;
 507 }
 508
 509 /*******************************************************************************
 510  *  ReadFontMetrics
 511  *
 512  *  Allocates space for the AFM on the driver heap and reads basic font metrics.
 513  *  Returns FALSE for memory allocation failure; sets *p_afm to NULL if AFM file
 514  *  is unusable.
 515  *
 516  */
 517 static BOOL ReadFontMetrics(FILE *file, CHAR buffer[], INT bufsize, AFM **p_afm)
 518 {
 519     AFM     *afm;
 520     BOOL    retval, found;
 521
 522     *p_afm = afm = HeapAlloc(PSDRV_Heap, 0, sizeof(*afm));
 523     if (afm == NULL)
 524         return FALSE;
 525
 526     retval = ReadWeight(file, buffer, bufsize, afm, &found);
 527     if (retval == FALSE || found == FALSE)
 528         goto cleanup_afm;
 529
 530     retval = ReadFloat(file, buffer, bufsize, "ItalicAngle",
 531             &(afm->ItalicAngle), &found);
 532     if (retval == FALSE || found == FALSE)
 533         goto cleanup_afm;
 534
 535     retval = ReadFixedPitch(file, buffer, bufsize, afm, &found);
 536     if (retval == FALSE || found == FALSE)
 537         goto cleanup_afm;
 538
 539     retval = ReadBBox(file, buffer, bufsize, afm, &found);
 540     if (retval == FALSE || found == FALSE)
 541         goto cleanup_afm;
 542
 543     retval = ReadFloat(file, buffer, bufsize, "UnderlinePosition",
 544             &(afm->UnderlinePosition), &found);
 545     if (retval == FALSE || found == FALSE)
 546         goto cleanup_afm;
 547
 548     retval = ReadFloat(file, buffer, bufsize, "UnderlineThickness",
 549             &(afm->UnderlineThickness), &found);
 550     if (retval == FALSE || found == FALSE)
 551         goto cleanup_afm;
 552
 553     retval = ReadFloat(file, buffer, bufsize, "Ascender",       /* optional */
 554             &(afm->Ascender), &found);
 555     if (retval == FALSE)
 556         goto cleanup_afm;
 557
 558     retval = ReadFloat(file, buffer, bufsize, "Descender",      /* optional */
 559             &(afm->Descender), &found);
 560     if (retval == FALSE)
 561         goto cleanup_afm;
 562
 563     afm->WinMetrics.usUnitsPerEm = 1000;
 564     afm->WinMetrics.sTypoAscender = (SHORT)Round(afm->Ascender);
 565     afm->WinMetrics.sTypoDescender = (SHORT)Round(afm->Descender);
 566
 567     if (afm->WinMetrics.sTypoAscender == 0)
 568         afm->WinMetrics.sTypoAscender = (SHORT)Round(afm->FontBBox.ury);
 569
 570     if (afm->WinMetrics.sTypoDescender == 0)
 571         afm->WinMetrics.sTypoDescender = (SHORT)Round(afm->FontBBox.lly);
 572
 573     afm->WinMetrics.sTypoLineGap = 1200 -
 574             (afm->WinMetrics.sTypoAscender - afm->WinMetrics.sTypoDescender);
 575     if (afm->WinMetrics.sTypoLineGap < 0)
 576         afm->WinMetrics.sTypoLineGap = 0;
 577
 578     return TRUE;
 579
 580     cleanup_afm:                        /* handle fatal or non-fatal errors */
 581         HeapFree(PSDRV_Heap, 0, afm);
 582         *p_afm = NULL;
 583         return retval;
 584 }
 585
 586 /*******************************************************************************
 587  *  ParseC
 588  *
 589  *  Fatal error:        return FALSE (none defined)
 590  *
 591  *  Non-fatal error:    leave metrics->C set to INT_MAX
 592  *
 593  */
 594 static BOOL ParseC(LPSTR sz, OLD_AFMMETRICS *metrics)
 595 {
 596     int     base = 10;
 597     long    l;
 598     CHAR    *cp, *end_ptr;
 599
 600     cp = sz + 1;
 601
 602     if (*cp == 'H')
 603     {
 604         base = 16;
 605         ++cp;
 606     }
 607
 608     errno = 0;
 609     l = strtol(cp, &end_ptr, base);
 610     if (end_ptr == cp || errno != 0 || l > INT_MAX || l < INT_MIN)
 611     {
 612         WARN("Error parsing character code '%s'\n", sz);
 613         return TRUE;
 614     }
 615
 616     metrics->C = (INT)l;
 617     return TRUE;
 618 }
 619
 620 /*******************************************************************************
 621  *  ParseW
 622  *
 623  *  Fatal error:        return FALSE (none defined)
 624  *
 625  *  Non-fatal error:    leave metrics->WX set to FLT_MAX
 626  *
 627  */
 628 static BOOL ParseW(LPSTR sz, OLD_AFMMETRICS *metrics)
 629 {
 630     CHAR    *cp, *end_ptr;
 631     BOOL    vector = TRUE;
 632     double  d;
 633
 634     cp = sz + 1;
 635
 636     if (*cp == '0')
 637         ++cp;
 638
 639     if (*cp == 'X')
 640     {
 641         vector = FALSE;
 642         ++cp;
 643     }
 644
 645     if (!isspace(*cp))
 646         goto parse_error;
 647
 648     errno = 0;
 649     d = strtod(cp, &end_ptr);
 650     if (end_ptr == cp || errno != 0 ||
 651             DoubleToFloat(&(metrics->WX), d) == FALSE)
 652         goto parse_error;
 653
 654     if (vector == FALSE)
 655         return TRUE;
 656
 657     /*  Make sure that Y component of vector is zero */
 658
 659     d = strtod(cp, &end_ptr);                               /* errno == 0 */
 660     if (end_ptr == cp || errno != 0 || d != 0.0)
 661     {
 662         metrics->WX = FLT_MAX;
 663         goto parse_error;
 664     }
 665
 666     return TRUE;
 667
 668     parse_error:
 669         WARN("Error parsing character width '%s'\n", sz);
 670         return TRUE;
 671 }
 672
 673 /*******************************************************************************
 674  *
 675  *  ParseB
 676  *
 677  *  Fatal error:        return FALSE (none defined)
 678  *
 679  *  Non-fatal error:    leave metrics->B.ury set to FLT_MAX
 680  *
 681  */
 682 static BOOL ParseB(LPSTR sz, OLD_AFMMETRICS *metrics)
 683 {
 684     CHAR    *cp, *end_ptr;
 685     double  d;
 686
 687     errno = 0;
 688
 689     cp = sz + 1;
 690     d = strtod(cp, &end_ptr);
 691     if (end_ptr == cp || errno != 0 ||
 692             DoubleToFloat(&(metrics->B.llx), d) == FALSE)
 693         goto parse_error;
 694
 695     cp = end_ptr;
 696     d = strtod(cp, &end_ptr);
 697     if (end_ptr == cp || errno != 0 ||
 698             DoubleToFloat(&(metrics->B.lly), d) == FALSE)
 699         goto parse_error;
 700
 701     cp = end_ptr;
 702     d = strtod(cp, &end_ptr);
 703     if (end_ptr == cp || errno != 0 ||
 704             DoubleToFloat(&(metrics->B.urx), d) == FALSE)
 705         goto parse_error;
 706
 707     cp = end_ptr;
 708     d = strtod(cp, &end_ptr);
 709     if (end_ptr == cp || errno != 0 ||
 710             DoubleToFloat(&(metrics->B.ury), d) == FALSE)
 711         goto parse_error;
 712
 713     return TRUE;
 714
 715     parse_error:
 716         WARN("Error parsing glyph bounding box '%s'\n", sz);
 717         return TRUE;
 718 }
 719
 720 /*******************************************************************************
 721  *  ParseN
 722  *
 723  *  Fatal error:        return FALSE (PSDRV_GlyphName failure)
 724  *
 725  *  Non-fatal error:    leave metrics-> set to NULL
 726  *
 727  */
 728 static BOOL ParseN(LPSTR sz, OLD_AFMMETRICS *metrics)
 729 {
 730     CHAR    save, *cp, *end_ptr;
 731
 732     cp = sz + 1;
 733
 734     while (isspace(*cp))
 735         ++cp;
 736
 737     end_ptr = cp;
 738
 739     while (*end_ptr != '\0' && !isspace(*end_ptr))
 740         ++end_ptr;
 741
 742     if (end_ptr == cp)
 743     {
 744         WARN("Error parsing glyph name '%s'\n", sz);
 745         return TRUE;
 746     }
 747
 748     save = *end_ptr;
 749     *end_ptr = '\0';
 750
 751     metrics->N = PSDRV_GlyphName(cp);
 752     if (metrics->N == NULL)
 753         return FALSE;
 754
 755     *end_ptr = save;
 756     return TRUE;
 757 }
 758
 759 /*******************************************************************************
 760  *  ParseCharMetrics
 761  *
 762  *  Parses the metrics line for a single glyph in an AFM file.  Returns FALSE on
 763  *  fatal error; sets *metrics to 'badmetrics' on non-fatal error.
 764  *
 765  */
 766 static const OLD_AFMMETRICS badmetrics =
 767 {
 768     INT_MAX,                                        /* C */
 769     INT_MAX,                                        /* UV */
 770     FLT_MAX,                                        /* WX */
 771     NULL,                                           /* N */
 772     { FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX },         /* B */
 773     NULL                                            /* L */
 774 };
 775
 776 static BOOL ParseCharMetrics(LPSTR buffer, INT len, OLD_AFMMETRICS *metrics)
 777 {
 778     CHAR    *cp = buffer;
 779
 780     *metrics = badmetrics;
 781
 782     while (*cp != '\0')
 783     {
 784         while (isspace(*cp))
 785             ++cp;
 786
 787         switch(*cp)
 788         {
 789             case 'C':   if (ParseC(cp, metrics) == FALSE)
 790                             return FALSE;
 791                         break;
 792
 793             case 'W':   if (ParseW(cp, metrics) == FALSE)
 794                             return FALSE;
 795                         break;
 796
 797             case 'N':   if (ParseN(cp, metrics) == FALSE)
 798                             return FALSE;
 799                         break;
 800
 801             case 'B':   if (ParseB(cp, metrics) == FALSE)
 802                             return FALSE;
 803                         break;
 804         }
 805
 806         cp = strchr(cp, ';');
 807         if (cp == NULL)
 808         {
 809             WARN("No terminating semicolon\n");
 810             break;
 811         }
 812
 813         ++cp;
 814     }
 815
 816     if (metrics->C == INT_MAX || metrics->WX == FLT_MAX || metrics->N == NULL ||
 817             metrics->B.ury == FLT_MAX)
 818     {
 819         *metrics = badmetrics;
 820         return TRUE;
 821     }
 822
 823     return TRUE;
 824 }
 825
 826 /*******************************************************************************
 827  *  IsWinANSI
 828  *
 829  *  Checks whether Unicode value is part of Microsoft code page 1252
 830  *
 831  */
 832 static const LONG ansiChars[21] =
 833 {
 834     0x0152, 0x0153, 0x0160, 0x0161, 0x0178, 0x017d, 0x017e, 0x0192, 0x02c6,
 835     0x02c9, 0x02dc, 0x03bc, 0x2013, 0x2014, 0x2026, 0x2030, 0x2039, 0x203a,
 836     0x20ac, 0x2122, 0x2219
 837 };
 838
 839 static int __cdecl cmpUV(const void *a, const void *b)
 840 {
 841     return (int)(*((const LONG *)a) - *((const LONG *)b));
 842 }
 843
 844 static inline BOOL IsWinANSI(LONG uv)
 845 {
 846     if ((0x0020 <= uv && uv <= 0x007e) || (0x00a0 <= uv && uv <= 0x00ff) ||
 847             (0x2018 <= uv && uv <= 0x201a) || (0x201c <= uv && uv <= 0x201e) ||
 848             (0x2020 <= uv && uv <= 0x2022))
 849         return TRUE;
 850
 851     if (bsearch(&uv, ansiChars, 21, sizeof(INT), cmpUV) != NULL)
 852         return TRUE;
 853
 854     return FALSE;
 855 }
 856
 857 /*******************************************************************************
 858  *  Unicodify
 859  *
 860  *  Determines Unicode value (UV) for each glyph, based on font encoding.
 861  *
 862  *      FontSpecific:   Usable encodings (0x20 - 0xff) are mapped into the
 863  *                      Unicode private use range U+F020 - U+F0FF.
 864  *
 865  *      other:          UV determined by glyph name, based on Adobe Glyph List.
 866  *
 867  *  Also does some font metric calculations that require UVs to be known.
 868  *
 869  */
 870 static int __cdecl UnicodeGlyphByNameIndex(const void *a, const void *b)
 871 {
 872     return ((const UNICODEGLYPH *)a)->name->index -
 873             ((const UNICODEGLYPH *)b)->name->index;
 874 }
 875
 876 static VOID Unicodify(AFM *afm, OLD_AFMMETRICS *metrics)
 877 {
 878     INT     i;
 879
 880     if (wcscmp(afm->EncodingScheme, L"FontSpecific") == 0)
 881     {
 882         for (i = 0; i < afm->NumofMetrics; ++i)
 883         {
 884             if (metrics[i].C >= 0x20 && metrics[i].C <= 0xff)
 885             {
 886                 metrics[i].UV = metrics[i].C | 0xf000L;
 887             }
 888             else
 889             {
 890                 TRACE("Unencoded glyph '%s'\n", metrics[i].N->sz);
 891                 metrics[i].UV = -1L;
 892             }
 893         }
 894
 895         afm->WinMetrics.sAscender = (SHORT)Round(afm->FontBBox.ury);
 896         afm->WinMetrics.sDescender = (SHORT)Round(afm->FontBBox.lly);
 897     }
 898     else                                        /* non-FontSpecific encoding */
 899     {
 900         UNICODEGLYPH    ug, *p_ug;
 901
 902         PSDRV_IndexGlyphList();         /* for fast searching of glyph names */
 903
 904         afm->WinMetrics.sAscender = afm->WinMetrics.sDescender = 0;
 905
 906         for (i = 0; i < afm->NumofMetrics; ++i)
 907         {
 908             ug.name = metrics[i].N;
 909             p_ug = bsearch(&ug, PSDRV_AGLbyName, PSDRV_AGLbyNameSize,
 910                     sizeof(ug), UnicodeGlyphByNameIndex);
 911             if (p_ug == NULL)
 912             {
 913                 TRACE("Glyph '%s' not in Adobe Glyph List\n", ug.name->sz);
 914                 metrics[i].UV = -1L;
 915             }
 916             else
 917             {
 918                 metrics[i].UV = p_ug->UV;
 919
 920                 if (IsWinANSI(p_ug->UV))
 921                 {
 922                     SHORT   ury = (SHORT)Round(metrics[i].B.ury);
 923                     SHORT   lly = (SHORT)Round(metrics[i].B.lly);
 924
 925                     if (ury > afm->WinMetrics.sAscender)
 926                         afm->WinMetrics.sAscender = ury;
 927                     if (lly < afm->WinMetrics.sDescender)
 928                         afm->WinMetrics.sDescender = lly;
 929                 }
 930             }
 931         }
 932
 933         if (afm->WinMetrics.sAscender == 0)
 934             afm->WinMetrics.sAscender = (SHORT)Round(afm->FontBBox.ury);
 935         if (afm->WinMetrics.sDescender == 0)
 936             afm->WinMetrics.sDescender = (SHORT)Round(afm->FontBBox.lly);
 937     }
 938
 939     afm->WinMetrics.sLineGap =
 940             1150 - (afm->WinMetrics.sAscender - afm->WinMetrics.sDescender);
 941     if (afm->WinMetrics.sLineGap < 0)
 942         afm->WinMetrics.sLineGap = 0;
 943
 944     afm->WinMetrics.usWinAscent = (afm->WinMetrics.sAscender > 0) ?
 945             afm->WinMetrics.sAscender : 0;
 946     afm->WinMetrics.usWinDescent = (afm->WinMetrics.sDescender < 0) ?
 947             -(afm->WinMetrics.sDescender) : 0;
 948 }
 949
 950 /*******************************************************************************
 951  *  ReadCharMetrics
 952  *
 953  *  Reads metrics for all glyphs.  *p_metrics will be NULL on non-fatal error.
 954  *
 955  */
 956 static int __cdecl OldAFMMetricsByUV(const void *a, const void *b)
 957 {
 958     return ((const OLD_AFMMETRICS *)a)->UV - ((const OLD_AFMMETRICS *)b)->UV;
 959 }
 960
 961 static BOOL ReadCharMetrics(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
 962         AFMMETRICS **p_metrics)
 963 {
 964     BOOL            retval, found;
 965     OLD_AFMMETRICS  *old_metrics, *encoded_metrics;
 966     AFMMETRICS      *metrics;
 967     INT             i, len;
 968
 969     retval = ReadInt(file, buffer, bufsize, "StartCharMetrics",
 970             &(afm->NumofMetrics), &found);
 971     if (retval == FALSE || found == FALSE)
 972     {
 973         *p_metrics = NULL;
 974         return retval;
 975     }
 976
 977     old_metrics = HeapAlloc(PSDRV_Heap, 0,
 978             afm->NumofMetrics * sizeof(*old_metrics));
 979     if (old_metrics == NULL)
 980         return FALSE;
 981
 982     for (i = 0; i < afm->NumofMetrics; ++i)
 983     {
 984         retval = ReadLine(file, buffer, bufsize, &len);
 985         if (retval == FALSE)
 986             goto cleanup_old_metrics;
 987
 988         if(len > 0)
 989         {
 990             retval = ParseCharMetrics(buffer, len, old_metrics + i);
 991             if (retval == FALSE || old_metrics[i].C == INT_MAX)
 992                 goto cleanup_old_metrics;
 993
 994             continue;
 995         }
 996
 997         switch (len)
 998         {
 999             case 0:         --i;
1000                             continue;
1001
1002             case INT_MIN:   WARN("Ignoring long line '%32s...'\n", buffer);
1003                             goto cleanup_old_metrics;       /* retval == TRUE */
1004
1005             case EOF:       WARN("Unexpected EOF\n");
1006                             goto cleanup_old_metrics;       /* retval == TRUE */
1007         }
1008     }
1009
1010     Unicodify(afm, old_metrics);    /* wait until glyph names have been read */
1011
1012     qsort(old_metrics, afm->NumofMetrics, sizeof(*old_metrics),
1013             OldAFMMetricsByUV);
1014
1015     for (i = 0; old_metrics[i].UV == -1; ++i);      /* count unencoded glyphs */
1016
1017     afm->NumofMetrics -= i;
1018     encoded_metrics = old_metrics + i;
1019
1020     afm->Metrics = *p_metrics = metrics = HeapAlloc(PSDRV_Heap, 0,
1021             afm->NumofMetrics * sizeof(*metrics));
1022     if (afm->Metrics == NULL)
1023         goto cleanup_old_metrics;                           /* retval == TRUE */
1024
1025     for (i = 0; i < afm->NumofMetrics; ++i, ++metrics, ++encoded_metrics)
1026     {
1027         metrics->C = encoded_metrics->C;
1028         metrics->UV = encoded_metrics->UV;
1029         metrics->WX = encoded_metrics->WX;
1030         metrics->N = encoded_metrics->N;
1031     }
1032
1033     HeapFree(PSDRV_Heap, 0, old_metrics);
1034
1035     afm->WinMetrics.sAvgCharWidth = PSDRV_CalcAvgCharWidth(afm);
1036
1037     return TRUE;
1038
1039     cleanup_old_metrics:                /* handle fatal or non-fatal errors */
1040         HeapFree(PSDRV_Heap, 0, old_metrics);
1041         *p_metrics = NULL;
1042         return retval;
1043 }
1044
1045 /*******************************************************************************
1046  *  BuildAFM
1047  *
1048  *  Builds the AFM for a PostScript font and adds it to the driver font list.
1049  *  Returns FALSE only on an unexpected error (memory allocation or I/O error).
1050  *
1051  */
1052 static BOOL BuildAFM(FILE *file)
1053 {
1054     CHAR        buffer[258];            /* allow for <cr>, <lf>, and <nul> */
1055     AFM         *afm;
1056     AFMMETRICS  *metrics;
1057     WCHAR *full_name, *family_name, *encoding_scheme;
1058     char *font_name;
1059     BOOL retval, added;
1060
1061     retval = ReadFontMetrics(file, buffer, sizeof(buffer), &afm);
1062     if (retval == FALSE || afm == NULL)
1063         return retval;
1064
1065     retval = ReadString(file, buffer, sizeof(buffer), "FontName", &font_name);
1066     if (retval == FALSE || font_name == NULL)
1067         goto cleanup_afm;
1068
1069     retval = ReadStringW(file, buffer, sizeof(buffer), "FullName", &full_name);
1070     if (retval == FALSE || full_name == NULL)
1071         goto cleanup_font_name;
1072
1073     retval = ReadStringW(file, buffer, sizeof(buffer), "FamilyName",
1074             &family_name);
1075     if (retval == FALSE || family_name == NULL)
1076         goto cleanup_full_name;
1077
1078     retval = ReadStringW(file, buffer, sizeof(buffer), "EncodingScheme",
1079             &encoding_scheme);
1080     if (retval == FALSE || encoding_scheme == NULL)
1081         goto cleanup_family_name;
1082
1083     afm->FontName = font_name;
1084     afm->FullName = full_name;
1085     afm->FamilyName = family_name;
1086     afm->EncodingScheme = encoding_scheme;
1087
1088     retval = ReadCharMetrics(file, buffer, sizeof(buffer), afm, &metrics);
1089     if (retval == FALSE || metrics == FALSE)
1090         goto cleanup_encoding_scheme;
1091
1092     retval = PSDRV_AddAFMtoList(&PSDRV_AFMFontList, afm, &added);
1093     if (retval == FALSE || added == FALSE)
1094         goto cleanup_encoding_scheme;
1095
1096     return TRUE;
1097
1098     /* clean up after fatal or non-fatal errors */
1099
1100     cleanup_encoding_scheme:
1101         HeapFree(PSDRV_Heap, 0, encoding_scheme);
1102     cleanup_family_name:
1103         HeapFree(PSDRV_Heap, 0, family_name);
1104     cleanup_full_name:
1105         HeapFree(PSDRV_Heap, 0, full_name);
1106     cleanup_font_name:
1107         HeapFree(PSDRV_Heap, 0, font_name);
1108     cleanup_afm:
1109         HeapFree(PSDRV_Heap, 0, afm);
1110
1111     return retval;
1112 }
1113
1114 /*******************************************************************************
1115  *  ReadAFMFile
1116  *
1117  *  Reads font metrics from Type 1 AFM file.  Only returns FALSE for
1118  *  unexpected errors (memory allocation or I/O).
1119  *
1120  */
1121 static BOOL ReadAFMFile(LPCWSTR filename)
1122 {
1123     FILE    *f;
1124     BOOL    retval;
1125
1126     TRACE("%s\n", debugstr_w(filename));
1127
1128     f = _wfopen(filename, L"r");
1129     if (f == NULL)
1130     {
1131         WARN("%s: %s\n", debugstr_w(filename), strerror(errno));
1132         return TRUE;
1133     }
1134
1135     retval = BuildAFM(f);
1136
1137     fclose(f);
1138     return retval;
1139 }
1140
1141 /*******************************************************************************
1142  *  ReadAFMDir
1143  *
1144  *  Reads all Type 1 AFM files in a directory.
1145  *
1146  */
1147 static BOOL ReadAFMDir(LPCSTR dirname)
1148 {
1149     WCHAR *path = wine_get_dos_file_name( dirname );
1150     struct _wfinddata_t data;
1151     intptr_t handle;
1152     WCHAR *p, *filename;
1153     BOOL ret = TRUE;
1154
1155     if (!path) return TRUE;
1156     if (!(filename = HeapAlloc( GetProcessHeap(), 0, lstrlenW(path) + 256 )))
1157     {
1158         HeapFree( GetProcessHeap(), 0, path );
1159         return FALSE;
1160     }
1161     lstrcpyW( filename, path );
1162     HeapFree( GetProcessHeap(), 0, path );
1163     p = filename + lstrlenW(filename);
1164     *p++ = '\\';
1165     lstrcpyW( p, L"*" );
1166
1167     handle = _wfindfirst( filename, &data );
1168     if (handle != -1)
1169     {
1170         do
1171         {
1172             WCHAR *ext = wcschr( data.name, '.' );
1173             if (!ext || wcsicmp(ext, L".afm")) continue;
1174             lstrcpyW( p, data.name );
1175             if (!(ret = ReadAFMFile( filename ))) break;
1176         } while (!_wfindnext( handle, &data ));
1177     }
1178     _findclose( handle );
1179
1180     HeapFree( GetProcessHeap(), 0, filename );
1181     return ret;
1182 }
1183
1184 /*******************************************************************************
1185  *  PSDRV_GetType1Metrics
1186  *
1187  *  Reads font metrics from Type 1 AFM font files in directories listed in the
1188  *  HKEY_CURRENT_USER\\Software\\Wine\\Fonts\\AFMPath registry string.
1189  *
1190  *  If this function fails (returns FALSE), the driver will fail to initialize
1191  *  and the driver heap will be destroyed, so it's not necessary to HeapFree
1192  *  everything in that event.
1193  *
1194  */
1195 BOOL PSDRV_GetType1Metrics(void)
1196 {
1197     HKEY hkey;
1198     DWORD len;
1199     LPWSTR valueW;
1200     LPSTR valueA, ptr;
1201
1202     /* @@ Wine registry key: HKCU\Software\Wine\Fonts */
1203     if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts", &hkey) != ERROR_SUCCESS)
1204         return TRUE;
1205
1206     if (RegQueryValueExW( hkey, L"AFMPath", NULL, NULL, NULL, &len ) == ERROR_SUCCESS)
1207     {
1208         len += sizeof(WCHAR);
1209         valueW = HeapAlloc( PSDRV_Heap, 0, len );
1210         if (RegQueryValueExW( hkey, L"AFMPath", NULL, NULL, (BYTE *)valueW, &len ) == ERROR_SUCCESS)
1211         {
1212             len = WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, NULL, 0, NULL, NULL );
1213             valueA = HeapAlloc( PSDRV_Heap, 0, len );
1214             WideCharToMultiByte( CP_UNIXCP, 0, valueW, -1, valueA, len, NULL, NULL );
1215             TRACE( "got AFM font path %s\n", debugstr_a(valueA) );
1216             ptr = valueA;
1217             while (ptr)
1218             {
1219                 LPSTR next = strchr( ptr, ':' );
1220                 if (next) *next++ = 0;
1221                 if (!ReadAFMDir( ptr ))
1222                 {
1223                     RegCloseKey(hkey);
1224                     return FALSE;
1225                 }
1226                 ptr = next;
1227             }
1228             HeapFree( PSDRV_Heap, 0, valueA );
1229         }
1230         HeapFree( PSDRV_Heap, 0, valueW );
1231     }
1232
1233     RegCloseKey(hkey);
1234     return TRUE;
1235 }