1 /*******************************************************************************
2 * Adobe Font Metric (AFM) file parsing finctions for Wine PostScript driver.
3 * See http://partners.adobe.com/asn/developer/pdfs/tn/5004.AFM_Spec.pdf.
5 * Copyright 2001 Ian Pilcher
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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.
36 #include <limits.h> /* INT_MIN */
39 #include <float.h> /* FLT_MAX */
46 #include "wine/debug.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
50 /*******************************************************************************
53 * Reads a line from a text file into the buffer and trims trailing whitespace.
54 * Can handle DOS and Unix text files, including weird DOS EOF. Returns FALSE
55 * for unexpected I/O errors; otherwise returns TRUE and sets *p_result to
56 * either the number of characters in the returned string or one of the
59 * 0: Blank (or all whitespace) line. This is just a special case
60 * of the normal behavior.
62 * EOF: End of file has been reached.
64 * INT_MIN: Buffer overflow. Returned string is truncated (duh!) and
65 * trailing whitespace is *not* trimmed. Remaining text in
66 * line is discarded. (I.e. the file pointer is positioned at
67 * the beginning of the next line.)
70 static BOOL ReadLine(FILE *file, CHAR buffer[], INT bufsize, INT *p_result)
75 if (fgets(buffer, bufsize, file) == NULL)
77 if (feof(file) == 0) /* EOF or error? */
79 ERR("%s\n", strerror(errno));
87 cp = strchr(buffer, '\n');
92 if (i == bufsize - 1) /* max possible; was line truncated? */
95 i = fgetc(file); /* find the newline or EOF */
96 while (i != '\n' && i != EOF);
100 if (feof(file) == 0) /* EOF or error? */
102 ERR("%s\n", strerror(errno));
106 WARN("No newline at EOF\n");
112 else /* no newline and not truncated */
114 if (strcmp(buffer, "\x1a") == 0) /* test for DOS EOF */
120 WARN("No newline at EOF\n");
121 cp = buffer + i; /* points to \0 where \n should have been */
127 *cp = '\0'; /* trim trailing whitespace */
129 break; /* don't underflow buffer */
132 while (isspace(*cp));
134 *p_result = strlen(buffer);
138 /*******************************************************************************
141 * Finds a line in the file that begins with the given string. Returns FALSE
142 * for unexpected I/O errors; returns an empty (zero character) string if the
143 * requested line is not found.
145 * NOTE: The file pointer *MUST* be positioned at the beginning of a line when
146 * this function is called. Otherwise, an infinite loop can result.
149 static BOOL FindLine(FILE *file, CHAR buffer[], INT bufsize, LPCSTR key)
151 INT len = strlen(key);
152 LONG start = ftell(file);
159 ok = ReadLine(file, buffer, bufsize, &result);
163 if (result > 0 && strncmp(buffer, key, len) == 0)
170 else if (result == INT_MIN)
172 WARN("Line beginning '%32s...' is too long; ignoring\n", buffer);
175 while (ftell(file) != start);
177 WARN("Couldn't find line '%s...' in AFM file\n", key);
182 /*******************************************************************************
185 * Utility function to convert double to float while checking for overflow.
186 * Will also catch strtod overflows, since HUGE_VAL > FLT_MAX (at least on
190 inline static BOOL DoubleToFloat(float *p_f, double d)
192 if (d > (double)FLT_MAX || d < -(double)FLT_MAX)
199 /*******************************************************************************
202 * Utility function to add or subtract 0.5 before converting to integer type.
205 inline static float Round(float f)
207 return (f >= 0.0) ? (f + 0.5) : (f - 0.5);
210 /*******************************************************************************
213 * Finds and parses a line of the form '<key> <value>', where value is a
214 * number. Sets *p_found to FALSE if a corresponding line cannot be found, or
215 * it cannot be parsed; also sets *p_ret to 0.0, so calling functions can just
216 * skip the check of *p_found if the item is not required.
219 static BOOL ReadFloat(FILE *file, CHAR buffer[], INT bufsize, LPCSTR key,
220 FLOAT *p_ret, BOOL *p_found)
225 if (FindLine(file, buffer, bufsize, key) == FALSE)
228 if (buffer[0] == '\0') /* line not found */
235 cp = buffer + strlen(key); /* first char after key */
237 d = strtod(cp, &end_ptr);
239 if (end_ptr == cp || errno != 0 || DoubleToFloat(p_ret, d) == FALSE)
241 WARN("Error parsing line '%s'\n", buffer);
251 /*******************************************************************************
254 * See description of ReadFloat.
257 static BOOL ReadInt(FILE *file, CHAR buffer[], INT bufsize, LPCSTR key,
258 INT *p_ret, BOOL *p_found)
263 retval = ReadFloat(file, buffer, bufsize, key, &f, p_found);
264 if (retval == FALSE || *p_found == FALSE)
272 if (f > (FLOAT)INT_MAX || f < (FLOAT)INT_MIN)
274 WARN("Error parsing line '%s'\n", buffer);
284 /*******************************************************************************
287 * Returns FALSE on I/O error or memory allocation failure; sets *p_str to NULL
288 * if line cannot be found or can't be parsed.
291 static BOOL ReadString(FILE *file, CHAR buffer[], INT bufsize, LPCSTR key,
296 if (FindLine(file, buffer, bufsize, key) == FALSE)
299 if (buffer[0] == '\0')
305 cp = buffer + strlen(key); /* first char after key */
312 while (isspace(*cp)) /* find first non-whitespace char */
315 *p_str = HeapAlloc(PSDRV_Heap, 0, strlen(cp) + 1);
323 /*******************************************************************************
326 * Similar to ReadFloat above.
329 static BOOL ReadBBox(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
335 if (FindLine(file, buffer, bufsize, "FontBBox") == FALSE)
338 if (buffer[0] == '\0')
346 cp = buffer + sizeof("FontBBox");
347 d = strtod(cp, &end_ptr);
348 if (end_ptr == cp || errno != 0 ||
349 DoubleToFloat(&(afm->FontBBox.llx), d) == FALSE)
353 d = strtod(cp, &end_ptr);
354 if (end_ptr == cp || errno != 0 ||
355 DoubleToFloat(&(afm->FontBBox.lly), d) == FALSE)
359 d = strtod(cp, &end_ptr);
360 if (end_ptr == cp || errno != 0
361 || DoubleToFloat(&(afm->FontBBox.urx), d) == FALSE)
365 d = strtod(cp, &end_ptr);
366 if (end_ptr == cp || errno != 0
367 || DoubleToFloat(&(afm->FontBBox.ury), d) == FALSE)
374 WARN("Error parsing line '%s'\n", buffer);
379 /*******************************************************************************
382 * Finds and parses the 'Weight' line of an AFM file. Only tries to determine
383 * if a font is bold (FW_BOLD) or not (FW_NORMAL) -- ignoring all those cute
384 * little FW_* typedefs in the Win32 doc. AFAICT, this is what the Windows
385 * PostScript driver does.
388 static const struct { LPCSTR keyword; INT weight; } afm_weights[] =
390 { "REGULAR", FW_NORMAL },
391 { "ROMAN", FW_NORMAL },
393 { "BOOK", FW_NORMAL },
394 { "MEDIUM", FW_NORMAL },
395 { "LIGHT", FW_NORMAL },
396 { "BLACK", FW_BOLD },
397 { "HEAVY", FW_BOLD },
399 { "ULTRA", FW_BOLD },
400 { "SUPER" , FW_BOLD },
404 static BOOL ReadWeight(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
411 if (ReadString(file, buffer, bufsize, "Weight", &sz) == FALSE)
420 for (cp = sz; *cp != '\0'; ++cp)
423 for (i = 0; afm_weights[i].keyword != NULL; ++i)
425 if (strstr(sz, afm_weights[i].keyword) != NULL)
427 afm->Weight = afm_weights[i].weight;
429 HeapFree(PSDRV_Heap, 0, sz);
434 WARN("Unknown weight '%s'; treating as Roman\n", sz);
436 afm->Weight = FW_NORMAL;
438 HeapFree(PSDRV_Heap, 0, sz);
442 /*******************************************************************************
446 static BOOL ReadFixedPitch(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
451 if (ReadString(file, buffer, bufsize, "IsFixedPitch", &sz) == FALSE)
460 if (strcasecmp(sz, "false") == 0)
462 afm->IsFixedPitch = FALSE;
464 HeapFree(PSDRV_Heap, 0, sz);
468 if (strcasecmp(sz, "true") == 0)
470 afm->IsFixedPitch = TRUE;
472 HeapFree(PSDRV_Heap, 0, sz);
476 WARN("Can't parse line '%s'\n", buffer);
479 HeapFree(PSDRV_Heap, 0, sz);
483 /*******************************************************************************
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
491 static BOOL ReadFontMetrics(FILE *file, CHAR buffer[], INT bufsize, AFM **p_afm)
496 *p_afm = afm = HeapAlloc(PSDRV_Heap, 0, sizeof(*afm));
500 retval = ReadWeight(file, buffer, bufsize, afm, &found);
501 if (retval == FALSE || found == FALSE)
504 retval = ReadFloat(file, buffer, bufsize, "ItalicAngle",
505 &(afm->ItalicAngle), &found);
506 if (retval == FALSE || found == FALSE)
509 retval = ReadFixedPitch(file, buffer, bufsize, afm, &found);
510 if (retval == FALSE || found == FALSE)
513 retval = ReadBBox(file, buffer, bufsize, afm, &found);
514 if (retval == FALSE || found == FALSE)
517 retval = ReadFloat(file, buffer, bufsize, "UnderlinePosition",
518 &(afm->UnderlinePosition), &found);
519 if (retval == FALSE || found == FALSE)
522 retval = ReadFloat(file, buffer, bufsize, "UnderlineThickness",
523 &(afm->UnderlineThickness), &found);
524 if (retval == FALSE || found == FALSE)
527 retval = ReadFloat(file, buffer, bufsize, "Ascender", /* optional */
528 &(afm->Ascender), &found);
532 retval = ReadFloat(file, buffer, bufsize, "Descender", /* optional */
533 &(afm->Descender), &found);
537 afm->WinMetrics.usUnitsPerEm = 1000;
538 afm->WinMetrics.sTypoAscender = (SHORT)Round(afm->Ascender);
539 afm->WinMetrics.sTypoDescender = (SHORT)Round(afm->Descender);
541 if (afm->WinMetrics.sTypoAscender == 0)
542 afm->WinMetrics.sTypoAscender = (SHORT)Round(afm->FontBBox.ury);
544 if (afm->WinMetrics.sTypoDescender == 0)
545 afm->WinMetrics.sTypoDescender = (SHORT)Round(afm->FontBBox.lly);
547 afm->WinMetrics.sTypoLineGap = 1200 -
548 (afm->WinMetrics.sTypoAscender - afm->WinMetrics.sTypoDescender);
549 if (afm->WinMetrics.sTypoLineGap < 0)
550 afm->WinMetrics.sTypoLineGap = 0;
554 cleanup_afm: /* handle fatal or non-fatal errors */
555 HeapFree(PSDRV_Heap, 0, afm);
560 /*******************************************************************************
563 * Fatal error: return FALSE (none defined)
565 * Non-fatal error: leave metrics->C set to INT_MAX
568 static BOOL ParseC(LPSTR sz, OLD_AFMMETRICS *metrics)
583 l = strtol(cp, &end_ptr, base);
584 if (end_ptr == cp || errno != 0 || l > INT_MAX || l < INT_MIN)
586 WARN("Error parsing character code '%s'\n", sz);
594 /*******************************************************************************
597 * Fatal error: return FALSE (none defined)
599 * Non-fatal error: leave metrics->WX set to FLT_MAX
602 static BOOL ParseW(LPSTR sz, OLD_AFMMETRICS *metrics)
623 d = strtod(cp, &end_ptr);
624 if (end_ptr == cp || errno != 0 ||
625 DoubleToFloat(&(metrics->WX), d) == FALSE)
631 /* Make sure that Y component of vector is zero */
633 d = strtod(cp, &end_ptr); /* errno == 0 */
634 if (end_ptr == cp || errno != 0 || d != 0.0)
636 metrics->WX = FLT_MAX;
643 WARN("Error parsing character width '%s'\n", sz);
647 /*******************************************************************************
651 * Fatal error: return FALSE (none defined)
653 * Non-fatal error: leave metrics->B.ury set to FLT_MAX
656 static BOOL ParseB(LPSTR sz, OLD_AFMMETRICS *metrics)
664 d = strtod(cp, &end_ptr);
665 if (end_ptr == cp || errno != 0 ||
666 DoubleToFloat(&(metrics->B.llx), d) == FALSE)
670 d = strtod(cp, &end_ptr);
671 if (end_ptr == cp || errno != 0 ||
672 DoubleToFloat(&(metrics->B.lly), d) == FALSE)
676 d = strtod(cp, &end_ptr);
677 if (end_ptr == cp || errno != 0 ||
678 DoubleToFloat(&(metrics->B.urx), d) == FALSE)
682 d = strtod(cp, &end_ptr);
683 if (end_ptr == cp || errno != 0 ||
684 DoubleToFloat(&(metrics->B.ury), d) == FALSE)
690 WARN("Error parsing glyph bounding box '%s'\n", sz);
694 /*******************************************************************************
697 * Fatal error: return FALSE (PSDRV_GlyphName failure)
699 * Non-fatal error: leave metrics-> set to NULL
702 static BOOL ParseN(LPSTR sz, OLD_AFMMETRICS *metrics)
704 CHAR save, *cp, *end_ptr;
713 while (*end_ptr != '\0' && !isspace(*end_ptr))
718 WARN("Error parsing glyph name '%s'\n", sz);
725 metrics->N = PSDRV_GlyphName(cp);
726 if (metrics->N == NULL)
733 /*******************************************************************************
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.
740 static const OLD_AFMMETRICS badmetrics =
746 { FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX }, /* B */
750 static BOOL ParseCharMetrics(LPSTR buffer, INT len, OLD_AFMMETRICS *metrics)
754 *metrics = badmetrics;
763 case 'C': if (ParseC(cp, metrics) == FALSE)
767 case 'W': if (ParseW(cp, metrics) == FALSE)
771 case 'N': if (ParseN(cp, metrics) == FALSE)
775 case 'B': if (ParseB(cp, metrics) == FALSE)
780 cp = strchr(cp, ';');
783 WARN("No terminating semicolon\n");
790 if (metrics->C == INT_MAX || metrics->WX == FLT_MAX || metrics->N == NULL ||
791 metrics->B.ury == FLT_MAX)
793 *metrics = badmetrics;
800 /*******************************************************************************
803 * Checks whether Unicode value is part of Microsoft code page 1252
806 static const LONG ansiChars[21] =
808 0x0152, 0x0153, 0x0160, 0x0161, 0x0178, 0x017d, 0x017e, 0x0192, 0x02c6,
809 0x02c9, 0x02dc, 0x03bc, 0x2013, 0x2014, 0x2026, 0x2030, 0x2039, 0x203a,
810 0x20ac, 0x2122, 0x2219
813 static int cmpUV(const void *a, const void *b)
815 return (int)(*((const LONG *)a) - *((const LONG *)b));
818 inline static BOOL IsWinANSI(LONG uv)
820 if ((0x0020 <= uv && uv <= 0x007e) || (0x00a0 <= uv && uv <= 0x00ff) ||
821 (0x2018 <= uv && uv <= 0x201a) || (0x201c <= uv && uv <= 0x201e) ||
822 (0x2020 <= uv && uv <= 0x2022))
825 if (bsearch(&uv, ansiChars, 21, sizeof(INT), cmpUV) != NULL)
831 /*******************************************************************************
834 * Determines Unicode value (UV) for each glyph, based on font encoding.
836 * FontSpecific: Usable encodings (0x20 - 0xff) are mapped into the
837 * Unicode private use range U+F020 - U+F0FF.
839 * other: UV determined by glyph name, based on Adobe Glyph List.
841 * Also does some font metric calculations that require UVs to be known.
844 static int UnicodeGlyphByNameIndex(const void *a, const void *b)
846 return ((const UNICODEGLYPH *)a)->name->index -
847 ((const UNICODEGLYPH *)b)->name->index;
850 static VOID Unicodify(AFM *afm, OLD_AFMMETRICS *metrics)
854 if (strcmp(afm->EncodingScheme, "FontSpecific") == 0)
856 for (i = 0; i < afm->NumofMetrics; ++i)
858 if (metrics[i].C >= 0x20 && metrics[i].C <= 0xff)
860 metrics[i].UV = ((LONG)(metrics[i].C)) | 0xf000L;
864 TRACE("Unencoded glyph '%s'\n", metrics[i].N->sz);
869 afm->WinMetrics.sAscender = (SHORT)Round(afm->FontBBox.ury);
870 afm->WinMetrics.sDescender = (SHORT)Round(afm->FontBBox.lly);
872 else /* non-FontSpecific encoding */
874 UNICODEGLYPH ug, *p_ug;
876 PSDRV_IndexGlyphList(); /* for fast searching of glyph names */
878 afm->WinMetrics.sAscender = afm->WinMetrics.sDescender = 0;
880 for (i = 0; i < afm->NumofMetrics; ++i)
882 ug.name = metrics[i].N;
883 p_ug = bsearch(&ug, PSDRV_AGLbyName, PSDRV_AGLbyNameSize,
884 sizeof(ug), UnicodeGlyphByNameIndex);
887 TRACE("Glyph '%s' not in Adobe Glyph List\n", ug.name->sz);
892 metrics[i].UV = p_ug->UV;
894 if (IsWinANSI(p_ug->UV))
896 SHORT ury = (SHORT)Round(metrics[i].B.ury);
897 SHORT lly = (SHORT)Round(metrics[i].B.lly);
899 if (ury > afm->WinMetrics.sAscender)
900 afm->WinMetrics.sAscender = ury;
901 if (lly < afm->WinMetrics.sDescender)
902 afm->WinMetrics.sDescender = lly;
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);
913 afm->WinMetrics.sLineGap =
914 1150 - (afm->WinMetrics.sAscender - afm->WinMetrics.sDescender);
915 if (afm->WinMetrics.sLineGap < 0)
916 afm->WinMetrics.sLineGap = 0;
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;
924 /*******************************************************************************
927 * Reads metrics for all glyphs. *p_metrics will be NULL on non-fatal error.
930 static int OldAFMMetricsByUV(const void *a, const void *b)
932 return ((const OLD_AFMMETRICS *)a)->UV - ((const OLD_AFMMETRICS *)b)->UV;
935 static BOOL ReadCharMetrics(FILE *file, CHAR buffer[], INT bufsize, AFM *afm,
936 AFMMETRICS **p_metrics)
939 OLD_AFMMETRICS *old_metrics, *encoded_metrics;
943 retval = ReadInt(file, buffer, bufsize, "StartCharMetrics",
944 &(afm->NumofMetrics), &found);
945 if (retval == FALSE || found == FALSE)
951 old_metrics = HeapAlloc(PSDRV_Heap, 0,
952 afm->NumofMetrics * sizeof(*old_metrics));
953 if (old_metrics == NULL)
956 for (i = 0; i < afm->NumofMetrics; ++i)
958 retval = ReadLine(file, buffer, bufsize, &len);
960 goto cleanup_old_metrics;
964 retval = ParseCharMetrics(buffer, len, old_metrics + i);
965 if (retval == FALSE || old_metrics[i].C == INT_MAX)
966 goto cleanup_old_metrics;
976 case INT_MIN: WARN("Ignoring long line '%32s...'\n", buffer);
977 goto cleanup_old_metrics; /* retval == TRUE */
979 case EOF: WARN("Unexpected EOF\n");
980 goto cleanup_old_metrics; /* retval == TRUE */
984 Unicodify(afm, old_metrics); /* wait until glyph names have been read */
986 qsort(old_metrics, afm->NumofMetrics, sizeof(*old_metrics),
989 for (i = 0; old_metrics[i].UV == -1; ++i); /* count unencoded glyphs */
991 afm->NumofMetrics -= i;
992 encoded_metrics = old_metrics + i;
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 */
999 for (i = 0; i < afm->NumofMetrics; ++i, ++metrics, ++encoded_metrics)
1001 metrics->C = encoded_metrics->C;
1002 metrics->UV = encoded_metrics->UV;
1003 metrics->WX = encoded_metrics->WX;
1004 metrics->N = encoded_metrics->N;
1007 HeapFree(PSDRV_Heap, 0, old_metrics);
1009 afm->WinMetrics.sAvgCharWidth = PSDRV_CalcAvgCharWidth(afm);
1013 cleanup_old_metrics: /* handle fatal or non-fatal errors */
1014 HeapFree(PSDRV_Heap, 0, old_metrics);
1019 /*******************************************************************************
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).
1026 static BOOL BuildAFM(FILE *file)
1028 CHAR buffer[258]; /* allow for <cr>, <lf>, and <nul> */
1030 AFMMETRICS *metrics;
1031 LPSTR font_name, full_name, family_name, encoding_scheme;
1034 retval = ReadFontMetrics(file, buffer, sizeof(buffer), &afm);
1035 if (retval == FALSE || afm == NULL)
1038 retval = ReadString(file, buffer, sizeof(buffer), "FontName", &font_name);
1039 if (retval == FALSE || font_name == NULL)
1042 retval = ReadString(file, buffer, sizeof(buffer), "FullName", &full_name);
1043 if (retval == FALSE || full_name == NULL)
1044 goto cleanup_font_name;
1046 retval = ReadString(file, buffer, sizeof(buffer), "FamilyName",
1048 if (retval == FALSE || family_name == NULL)
1049 goto cleanup_full_name;
1051 retval = ReadString(file, buffer, sizeof(buffer), "EncodingScheme",
1053 if (retval == FALSE || encoding_scheme == NULL)
1054 goto cleanup_family_name;
1056 afm->FontName = font_name;
1057 afm->FullName = full_name;
1058 afm->FamilyName = family_name;
1059 afm->EncodingScheme = encoding_scheme;
1061 retval = ReadCharMetrics(file, buffer, sizeof(buffer), afm, &metrics);
1062 if (retval == FALSE || metrics == FALSE)
1063 goto cleanup_encoding_scheme;
1065 retval = PSDRV_AddAFMtoList(&PSDRV_AFMFontList, afm, &added);
1066 if (retval == FALSE || added == FALSE)
1067 goto cleanup_encoding_scheme;
1071 /* clean up after fatal or non-fatal errors */
1073 cleanup_encoding_scheme:
1074 HeapFree(PSDRV_Heap, 0, encoding_scheme);
1075 cleanup_family_name:
1076 HeapFree(PSDRV_Heap, 0, family_name);
1078 HeapFree(PSDRV_Heap, 0, full_name);
1080 HeapFree(PSDRV_Heap, 0, font_name);
1082 HeapFree(PSDRV_Heap, 0, afm);
1087 /*******************************************************************************
1090 * Reads font metrics from Type 1 AFM file. Only returns FALSE for
1091 * unexpected errors (memory allocation or I/O).
1094 static BOOL ReadAFMFile(LPCSTR filename)
1099 TRACE("%s\n", filename);
1101 f = fopen(filename, "r");
1104 WARN("%s: %s\n", filename, strerror(errno));
1108 retval = BuildAFM(f);
1114 /*******************************************************************************
1117 * Reads all Type 1 AFM files in a directory.
1120 static BOOL ReadAFMDir(LPCSTR dirname)
1122 struct dirent *dent;
1126 dir = opendir(dirname);
1129 WARN("%s: %s\n", dirname, strerror(errno));
1133 while ((dent = readdir(dir)) != NULL)
1135 CHAR *file_extension = strchr(dent->d_name, '.');
1138 if (file_extension == NULL || strcasecmp(file_extension, ".afm") != 0)
1141 fn_len = snprintf(filename, 256, "%s/%s", dirname, dent->d_name);
1142 if (fn_len < 0 || fn_len > sizeof(filename) - 1)
1144 WARN("Path '%s/%s' is too long\n", dirname, dent->d_name);
1148 if (ReadAFMFile(filename) == FALSE)
1159 /*******************************************************************************
1160 * PSDRV_GetType1Metrics
1162 * Reads font metrics from Type 1 AFM font files in directories listed in the
1163 * [afmdirs] section of the Wine configuration file.
1165 * If this function fails (returns FALSE), the dirver will fail to initialize
1166 * and the driver heap will be destroyed, so it's not necessary to HeapFree
1167 * everything in that event.
1170 BOOL PSDRV_GetType1Metrics(void)
1172 CHAR name_buf[256], value_buf[256];
1175 DWORD type, name_len, value_len;
1177 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
1178 "Software\\Wine\\Wine\\Config\\afmdirs",
1179 0, KEY_READ, &hkey) != ERROR_SUCCESS)
1182 name_len = sizeof(name_buf);
1183 value_len = sizeof(value_buf);
1185 while (RegEnumValueA(hkey, i++, name_buf, &name_len, NULL, &type, value_buf,
1186 &value_len) == ERROR_SUCCESS)
1188 value_buf[sizeof(value_buf) - 1] = '\0';
1190 if (ReadAFMDir(value_buf) == FALSE)
1196 /* initialize lengths for new iteration */
1198 name_len = sizeof(name_buf);
1199 value_len = sizeof(value_buf);