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