1 /*
2 * Copyright 2000 Computing Research Labs, New Mexico State University
3 * Copyright 2001-2014
4 * Francesco Zappa Nardelli
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
20 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
21 * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
22 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /**************************************************************************
26 *
27 * This file is based on bdf.c,v 1.22 2000/03/16 20:08:50
28 *
29 * taken from Mark Leisher's xmbdfed package
30 *
31 */
32
33
34
35 #include <freetype/freetype.h>
36 #include <freetype/internal/ftdebug.h>
37 #include <freetype/internal/ftstream.h>
38 #include <freetype/internal/ftobjs.h>
39
40 #include "bdf.h"
41 #include "bdferror.h"
42
43
44 /**************************************************************************
45 *
46 * The macro FT_COMPONENT is used in trace mode. It is an implicit
47 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
48 * messages during execution.
49 */
50 #undef FT_COMPONENT
51 #define FT_COMPONENT bdflib
52
53
54 #define BUFSIZE 128
55
56
57 /**************************************************************************
58 *
59 * Default BDF font options.
60 *
61 */
62
63
64 static const bdf_options_t bdf_opts_ =
65 {
66 1, /* Correct metrics. */
67 1, /* Preserve unencoded glyphs. */
68 0, /* Preserve comments. */
69 BDF_PROPORTIONAL /* Default spacing. */
70 };
71
72
73 /**************************************************************************
74 *
75 * Builtin BDF font properties.
76 *
77 */
78
79 /* List of most properties that might appear in a font. Doesn't include */
80 /* the RAW_* and AXIS_* properties in X11R6 polymorphic fonts. */
81
82 static const bdf_property_t bdf_properties_[] =
83 {
84 { "ADD_STYLE_NAME", BDF_ATOM, 1, { 0 } },
85 { "AVERAGE_WIDTH", BDF_INTEGER, 1, { 0 } },
86 { "AVG_CAPITAL_WIDTH", BDF_INTEGER, 1, { 0 } },
87 { "AVG_LOWERCASE_WIDTH", BDF_INTEGER, 1, { 0 } },
88 { "CAP_HEIGHT", BDF_INTEGER, 1, { 0 } },
89 { "CHARSET_COLLECTIONS", BDF_ATOM, 1, { 0 } },
90 { "CHARSET_ENCODING", BDF_ATOM, 1, { 0 } },
91 { "CHARSET_REGISTRY", BDF_ATOM, 1, { 0 } },
92 { "COMMENT", BDF_ATOM, 1, { 0 } },
93 { "COPYRIGHT", BDF_ATOM, 1, { 0 } },
94 { "DEFAULT_CHAR", BDF_CARDINAL, 1, { 0 } },
95 { "DESTINATION", BDF_CARDINAL, 1, { 0 } },
96 { "DEVICE_FONT_NAME", BDF_ATOM, 1, { 0 } },
97 { "END_SPACE", BDF_INTEGER, 1, { 0 } },
98 { "FACE_NAME", BDF_ATOM, 1, { 0 } },
99 { "FAMILY_NAME", BDF_ATOM, 1, { 0 } },
100 { "FIGURE_WIDTH", BDF_INTEGER, 1, { 0 } },
101 { "FONT", BDF_ATOM, 1, { 0 } },
102 { "FONTNAME_REGISTRY", BDF_ATOM, 1, { 0 } },
103 { "FONT_ASCENT", BDF_INTEGER, 1, { 0 } },
104 { "FONT_DESCENT", BDF_INTEGER, 1, { 0 } },
105 { "FOUNDRY", BDF_ATOM, 1, { 0 } },
106 { "FULL_NAME", BDF_ATOM, 1, { 0 } },
107 { "ITALIC_ANGLE", BDF_INTEGER, 1, { 0 } },
108 { "MAX_SPACE", BDF_INTEGER, 1, { 0 } },
109 { "MIN_SPACE", BDF_INTEGER, 1, { 0 } },
110 { "NORM_SPACE", BDF_INTEGER, 1, { 0 } },
111 { "NOTICE", BDF_ATOM, 1, { 0 } },
112 { "PIXEL_SIZE", BDF_INTEGER, 1, { 0 } },
113 { "POINT_SIZE", BDF_INTEGER, 1, { 0 } },
114 { "QUAD_WIDTH", BDF_INTEGER, 1, { 0 } },
115 { "RAW_ASCENT", BDF_INTEGER, 1, { 0 } },
116 { "RAW_AVERAGE_WIDTH", BDF_INTEGER, 1, { 0 } },
117 { "RAW_AVG_CAPITAL_WIDTH", BDF_INTEGER, 1, { 0 } },
118 { "RAW_AVG_LOWERCASE_WIDTH", BDF_INTEGER, 1, { 0 } },
119 { "RAW_CAP_HEIGHT", BDF_INTEGER, 1, { 0 } },
120 { "RAW_DESCENT", BDF_INTEGER, 1, { 0 } },
121 { "RAW_END_SPACE", BDF_INTEGER, 1, { 0 } },
122 { "RAW_FIGURE_WIDTH", BDF_INTEGER, 1, { 0 } },
123 { "RAW_MAX_SPACE", BDF_INTEGER, 1, { 0 } },
124 { "RAW_MIN_SPACE", BDF_INTEGER, 1, { 0 } },
125 { "RAW_NORM_SPACE", BDF_INTEGER, 1, { 0 } },
126 { "RAW_PIXEL_SIZE", BDF_INTEGER, 1, { 0 } },
127 { "RAW_POINT_SIZE", BDF_INTEGER, 1, { 0 } },
128 { "RAW_PIXELSIZE", BDF_INTEGER, 1, { 0 } },
129 { "RAW_POINTSIZE", BDF_INTEGER, 1, { 0 } },
130 { "RAW_QUAD_WIDTH", BDF_INTEGER, 1, { 0 } },
131 { "RAW_SMALL_CAP_SIZE", BDF_INTEGER, 1, { 0 } },
132 { "RAW_STRIKEOUT_ASCENT", BDF_INTEGER, 1, { 0 } },
133 { "RAW_STRIKEOUT_DESCENT", BDF_INTEGER, 1, { 0 } },
134 { "RAW_SUBSCRIPT_SIZE", BDF_INTEGER, 1, { 0 } },
135 { "RAW_SUBSCRIPT_X", BDF_INTEGER, 1, { 0 } },
136 { "RAW_SUBSCRIPT_Y", BDF_INTEGER, 1, { 0 } },
137 { "RAW_SUPERSCRIPT_SIZE", BDF_INTEGER, 1, { 0 } },
138 { "RAW_SUPERSCRIPT_X", BDF_INTEGER, 1, { 0 } },
139 { "RAW_SUPERSCRIPT_Y", BDF_INTEGER, 1, { 0 } },
140 { "RAW_UNDERLINE_POSITION", BDF_INTEGER, 1, { 0 } },
141 { "RAW_UNDERLINE_THICKNESS", BDF_INTEGER, 1, { 0 } },
142 { "RAW_X_HEIGHT", BDF_INTEGER, 1, { 0 } },
143 { "RELATIVE_SETWIDTH", BDF_CARDINAL, 1, { 0 } },
144 { "RELATIVE_WEIGHT", BDF_CARDINAL, 1, { 0 } },
145 { "RESOLUTION", BDF_INTEGER, 1, { 0 } },
146 { "RESOLUTION_X", BDF_CARDINAL, 1, { 0 } },
147 { "RESOLUTION_Y", BDF_CARDINAL, 1, { 0 } },
148 { "SETWIDTH_NAME", BDF_ATOM, 1, { 0 } },
149 { "SLANT", BDF_ATOM, 1, { 0 } },
150 { "SMALL_CAP_SIZE", BDF_INTEGER, 1, { 0 } },
151 { "SPACING", BDF_ATOM, 1, { 0 } },
152 { "STRIKEOUT_ASCENT", BDF_INTEGER, 1, { 0 } },
153 { "STRIKEOUT_DESCENT", BDF_INTEGER, 1, { 0 } },
154 { "SUBSCRIPT_SIZE", BDF_INTEGER, 1, { 0 } },
155 { "SUBSCRIPT_X", BDF_INTEGER, 1, { 0 } },
156 { "SUBSCRIPT_Y", BDF_INTEGER, 1, { 0 } },
157 { "SUPERSCRIPT_SIZE", BDF_INTEGER, 1, { 0 } },
158 { "SUPERSCRIPT_X", BDF_INTEGER, 1, { 0 } },
159 { "SUPERSCRIPT_Y", BDF_INTEGER, 1, { 0 } },
160 { "UNDERLINE_POSITION", BDF_INTEGER, 1, { 0 } },
161 { "UNDERLINE_THICKNESS", BDF_INTEGER, 1, { 0 } },
162 { "WEIGHT", BDF_CARDINAL, 1, { 0 } },
163 { "WEIGHT_NAME", BDF_ATOM, 1, { 0 } },
164 { "X_HEIGHT", BDF_INTEGER, 1, { 0 } },
165 { "_MULE_BASELINE_OFFSET", BDF_INTEGER, 1, { 0 } },
166 { "_MULE_RELATIVE_COMPOSE", BDF_INTEGER, 1, { 0 } },
167 };
168
169 static const unsigned long
170 num_bdf_properties_ = sizeof ( bdf_properties_ ) /
171 sizeof ( bdf_properties_[0] );
172
173
174 /* An auxiliary macro to parse properties, to be used in conditionals. */
175 /* It behaves like `strncmp' but also tests the following character */
176 /* whether it is a whitespace or null. */
177 /* `property' is a constant string of length `n' to compare with. */
178 #define _bdf_strncmp( name, property, n ) \
179 ( ft_strncmp( name, property, n ) || \
180 !( name[n] == ' ' || \
181 name[n] == '\0' || \
182 name[n] == '\n' || \
183 name[n] == '\r' || \
184 name[n] == '\t' ) )
185
186 /* Auto correction messages. */
187 #define ACMSG1 "FONT_ASCENT property missing. " \
188 "Added `FONT_ASCENT %hd'.\n"
189 #define ACMSG2 "FONT_DESCENT property missing. " \
190 "Added `FONT_DESCENT %hd'.\n"
191 #define ACMSG3 "Font width != actual width. Old: %d New: %d.\n"
192 #define ACMSG4 "Font left bearing != actual left bearing. " \
193 "Old: %hd New: %hd.\n"
194 #define ACMSG5 "Font ascent != actual ascent. Old: %hd New: %hd.\n"
195 #define ACMSG6 "Font descent != actual descent. Old: %d New: %d.\n"
196 #define ACMSG7 "Font height != actual height. Old: %d New: %d.\n"
197 #define ACMSG8 "Glyph scalable width (SWIDTH) adjustments made.\n"
198 #define ACMSG9 "SWIDTH field missing at line %ld. Set automatically.\n"
199 #define ACMSG10 "DWIDTH field missing at line %ld. Set to glyph width.\n"
200 #define ACMSG11 "SIZE bits per pixel field adjusted to %hd.\n"
201 #define ACMSG13 "Glyph %lu extra rows removed.\n"
202 #define ACMSG14 "Glyph %lu extra columns removed.\n"
203 #define ACMSG15 "Incorrect glyph count: %ld indicated but %ld found.\n"
204 #define ACMSG16 "Glyph %lu missing columns padded with zero bits.\n"
205 #define ACMSG17 "Adjusting number of glyphs to %ld.\n"
206
207 /* Error messages. */
208 #define ERRMSG1 "[line %ld] Missing `%s' line.\n"
209 #define ERRMSG2 "[line %ld] Font header corrupted or missing fields.\n"
210 #define ERRMSG3 "[line %ld] Font glyphs corrupted or missing fields.\n"
211 #define ERRMSG4 "[line %ld] BBX too big.\n"
212 #define ERRMSG5 "[line %ld] `%s' value too big.\n"
213 #define ERRMSG6 "[line %ld] Input line too long.\n"
214 #define ERRMSG7 "[line %ld] Font name too long.\n"
215 #define ERRMSG8 "[line %ld] Invalid `%s' value.\n"
216 #define ERRMSG9 "[line %ld] Invalid keyword.\n"
217
218 /* Debug messages. */
219 #define DBGMSG1 " [%6ld] %s" /* no \n */
220 #define DBGMSG2 " (0x%lX)\n"
221
222
223 /**************************************************************************
224 *
225 * Utility types and functions.
226 *
227 */
228
229
230 /* Function type for parsing lines of a BDF font. */
231
232 typedef FT_Error
233 (*bdf_line_func_t_)( char* line,
234 unsigned long linelen,
235 unsigned long lineno,
236 void* call_data,
237 void* client_data );
238
239
240 /* List structure for splitting lines into fields. */
241
242 typedef struct bdf_list_t__
243 {
244 char** field;
245 unsigned long size;
246 unsigned long used;
247 FT_Memory memory;
248
249 } bdf_list_t_;
250
251
252 /* Structure used while loading BDF fonts. */
253
254 typedef struct bdf_parse_t__
255 {
256 unsigned long flags;
257 unsigned long cnt;
258 unsigned long row;
259
260 short minlb;
261 short maxlb;
262 short maxrb;
263 short maxas;
264 short maxds;
265
266 short rbearing;
267
268 char* glyph_name;
269 long glyph_enc;
270
271 bdf_font_t* font;
272 bdf_options_t* opts;
273
274 bdf_list_t_ list;
275
276 FT_Memory memory;
277 unsigned long size; /* the stream size */
278
279 } bdf_parse_t_;
280
281
282 #define setsbit( m, cc ) \
283 ( m[(FT_Byte)(cc) >> 3] |= (FT_Byte)( 1 << ( (cc) & 7 ) ) )
284 #define sbitset( m, cc ) \
285 ( m[(FT_Byte)(cc) >> 3] & ( 1 << ( (cc) & 7 ) ) )
286
287
288 static void
289 bdf_list_init_( bdf_list_t_* list,
290 FT_Memory memory )
291 {
292 FT_ZERO( list );
293 list->memory = memory;
294 }
295
296
297 static void
298 bdf_list_done_( bdf_list_t_* list )
299 {
300 FT_Memory memory = list->memory;
301
302
303 if ( memory )
304 {
305 FT_FREE( list->field );
306 FT_ZERO( list );
307 }
308 }
309
310
311 static FT_Error
312 bdf_list_ensure_( bdf_list_t_* list,
313 unsigned long num_items ) /* same as bdf_list_t_.used */
314 {
315 FT_Error error = FT_Err_Ok;
316
317
318 if ( num_items > list->size )
319 {
320 unsigned long oldsize = list->size; /* same as bdf_list_t_.size */
321 unsigned long newsize = oldsize + ( oldsize >> 1 ) + 5;
322 unsigned long bigsize = (unsigned long)( FT_INT_MAX / sizeof ( char* ) );
323 FT_Memory memory = list->memory;
324
325
326 if ( oldsize == bigsize )
327 {
328 error = FT_THROW( Out_Of_Memory );
329 goto Exit;
330 }
331 else if ( newsize < oldsize || newsize > bigsize )
332 newsize = bigsize;
333
334 if ( FT_QRENEW_ARRAY( list->field, oldsize, newsize ) )
335 goto Exit;
336
337 list->size = newsize;
338 }
339
340 Exit:
341 return error;
342 }
343
344
345 static void
346 bdf_list_shift_( bdf_list_t_* list,
347 unsigned long n )
348 {
349 unsigned long i, u;
350
351
352 if ( list == NULL || list->used == 0 || n == 0 )
353 return;
354
355 if ( n >= list->used )
356 {
357 list->used = 0;
358 return;
359 }
360
361 for ( u = n, i = 0; u < list->used; i++, u++ )
362 list->field[i] = list->field[u];
363 list->used -= n;
364 }
365
366
367 /* An empty string for empty fields. */
368
369 static const char empty[] = ""; /* XXX eliminate this */
370
371
372 static char *
373 bdf_list_join_( bdf_list_t_* list,
374 int c,
375 unsigned long *alen )
376 {
377 unsigned long i, j;
378 char* dp;
379
380
381 *alen = 0;
382
383 if ( list == NULL || list->used == 0 )
384 return NULL;
385
386 dp = list->field[0];
387 for ( i = j = 0; i < list->used; i++ )
388 {
389 char* fp = list->field[i];
390
391
392 while ( *fp )
393 dp[j++] = *fp++;
394
395 if ( i + 1 < list->used )
396 dp[j++] = (char)c;
397 }
398 if ( dp != empty )
399 dp[j] = 0;
400
401 *alen = j;
402 return dp;
403 }
404
405
406 /* The code below ensures that we have at least 4 + 1 `field' */
407 /* elements in `list' (which are possibly NULL) so that we */
408 /* don't have to check the number of fields in most cases. */
409
410 static FT_Error
411 bdf_list_split_( bdf_list_t_* list,
412 const char* separators,
413 char* line,
414 unsigned long linelen )
415 {
416 unsigned long final_empty;
417 int mult;
418 const char *sp, *end;
419 char *ep;
420 char seps[32];
421 FT_Error error = FT_Err_Ok;
422
423
424 /* Initialize the list. */
425 list->used = 0;
426 if ( list->size )
427 {
428 list->field[0] = (char*)empty;
429 list->field[1] = (char*)empty;
430 list->field[2] = (char*)empty;
431 list->field[3] = (char*)empty;
432 list->field[4] = (char*)empty;
433 }
434
435 /* If the line is empty, then simply return. */
436 if ( linelen == 0 || line[0] == 0 )
437 goto Exit;
438
439 /* In the original code, if the `separators' parameter is NULL or */
440 /* empty, the list is split into individual bytes. We don't need */
441 /* this, so an error is signaled. */
442 if ( separators == NULL || *separators == 0 )
443 {
444 error = FT_THROW( Invalid_Argument );
445 goto Exit;
446 }
447
448 /* Prepare the separator bitmap. */
449 FT_MEM_ZERO( seps, 32 );
450
451 /* If the very last character of the separator string is a plus, then */
452 /* set the `mult' flag to indicate that multiple separators should be */
453 /* collapsed into one. */
454 for ( mult = 0, sp = separators; sp && *sp; sp++ )
455 {
456 if ( *sp == '+' && *( sp + 1 ) == 0 )
457 mult = 1;
458 else
459 setsbit( seps, *sp );
460 }
461
462 /* Break the line up into fields. */
463 for ( final_empty = 0, sp = ep = line, end = sp + linelen;
464 sp < end && *sp; )
465 {
466 /* Collect everything that is not a separator. */
467 for ( ; *ep && !sbitset( seps, *ep ); ep++ )
468 ;
469
470 /* Resize the list if necessary. */
471 if ( list->used == list->size )
472 {
473 error = bdf_list_ensure_( list, list->used + 1 );
474 if ( error )
475 goto Exit;
476 }
477
478 /* Assign the field appropriately. */
479 list->field[list->used++] = ( ep > sp ) ? (char*)sp : (char*)empty;
480
481 sp = ep;
482
483 if ( mult )
484 {
485 /* If multiple separators should be collapsed, do it now by */
486 /* setting all the separator characters to 0. */
487 for ( ; *ep && sbitset( seps, *ep ); ep++ )
488 *ep = 0;
489 }
490 else if ( *ep != 0 )
491 /* Don't collapse multiple separators by making them 0, so just */
492 /* make the one encountered 0. */
493 *ep++ = 0;
494
495 final_empty = ( ep > sp && *ep == 0 );
496 sp = ep;
497 }
498
499 /* Finally, NULL-terminate the list. */
500 if ( list->used + final_empty >= list->size )
501 {
502 error = bdf_list_ensure_( list, list->used + final_empty + 1 );
503 if ( error )
504 goto Exit;
505 }
506
507 if ( final_empty )
508 list->field[list->used++] = (char*)empty;
509
510 list->field[list->used] = NULL;
511
512 Exit:
513 return error;
514 }
515
516
517 #define NO_SKIP 256 /* this value cannot be stored in a 'char' */
518
519
520 static FT_Error
521 bdf_readstream_( FT_Stream stream,
522 bdf_line_func_t_ callback,
523 void* client_data,
524 unsigned long *lno )
525 {
526 bdf_line_func_t_ cb;
527 unsigned long lineno, buf_size;
528 int refill, hold, to_skip;
529 ptrdiff_t bytes, start, end, cursor, avail;
530 char* buf = NULL;
531 FT_Memory memory = stream->memory;
532 FT_Error error = FT_Err_Ok;
533
534
535 if ( callback == NULL )
536 {
537 error = FT_THROW( Invalid_Argument );
538 goto Exit;
539 }
540
541 /* initial size and allocation of the input buffer */
542 buf_size = 1024;
543
544 if ( FT_QALLOC( buf, buf_size ) )
545 goto Exit;
546
547 cb = callback;
548 lineno = 1;
549 buf[0] = 0;
550 start = 0;
551 avail = 0;
552 cursor = 0;
553 refill = 1;
554 to_skip = NO_SKIP;
555 bytes = 0; /* make compiler happy */
556
557 for (;;)
558 {
559 if ( refill )
560 {
561 bytes = (ptrdiff_t)FT_Stream_TryRead(
562 stream, (FT_Byte*)buf + cursor,
563 buf_size - (unsigned long)cursor );
564 avail = cursor + bytes;
565 cursor = 0;
566 refill = 0;
567 }
568
569 end = start;
570
571 /* should we skip an optional character like \n or \r? */
572 if ( start < avail && buf[start] == to_skip )
573 {
574 start += 1;
575 to_skip = NO_SKIP;
576 continue;
577 }
578
579 /* try to find the end of the line */
580 while ( end < avail && buf[end] != '\n' && buf[end] != '\r' )
581 end++;
582
583 /* if we hit the end of the buffer, try shifting its content */
584 /* or even resizing it */
585 if ( end >= avail )
586 {
587 if ( bytes == 0 )
588 {
589 /* last line in file doesn't end in \r or \n; */
590 /* ignore it then exit */
591 if ( lineno == 1 )
592 error = FT_THROW( Missing_Startfont_Field );
593 break;
594 }
595
596 if ( start == 0 )
597 {
598 /* this line is definitely too long; try resizing the input */
599 /* buffer a bit to handle it. */
600 FT_ULong new_size;
601
602
603 if ( buf_size >= 65536UL ) /* limit ourselves to 64KByte */
604 {
605 if ( lineno == 1 )
606 error = FT_THROW( Missing_Startfont_Field );
607 else
608 {
609 FT_ERROR(( "bdf_readstream_: " ERRMSG6, lineno ));
610 error = FT_THROW( Invalid_Argument );
611 }
612 goto Exit;
613 }
614
615 new_size = buf_size * 2;
616 if ( FT_QREALLOC( buf, buf_size, new_size ) )
617 goto Exit;
618
619 cursor = avail;
620 buf_size = new_size;
621 }
622 else
623 {
624 bytes = avail - start;
625
626 FT_MEM_MOVE( buf, buf + start, bytes );
627
628 cursor = bytes;
629 start = 0;
630 }
631 refill = 1;
632 continue;
633 }
634
635 /* Temporarily NUL-terminate the line. */
636 hold = buf[end];
637 buf[end] = 0;
638
639 /* XXX: Use encoding independent value for 0x1A */
640 if ( buf[start] != '#' && buf[start] != 0x1A && end > start )
641 {
642 error = (*cb)( buf + start, (unsigned long)( end - start ), lineno,
643 (void*)&cb, client_data );
644 /* Redo if we have encountered CHARS without properties. */
645 if ( error == -1 )
646 error = (*cb)( buf + start, (unsigned long)( end - start ), lineno,
647 (void*)&cb, client_data );
648 if ( error )
649 break;
650 }
651
652 lineno += 1;
653 buf[end] = (char)hold;
654 start = end + 1;
655
656 if ( hold == '\n' )
657 to_skip = '\r';
658 else if ( hold == '\r' )
659 to_skip = '\n';
660 else
661 to_skip = NO_SKIP;
662 }
663
664 *lno = lineno;
665
666 Exit:
667 FT_FREE( buf );
668 return error;
669 }
670
671
672 /* XXX: make this work with EBCDIC also */
673
674 static const unsigned char a2i[128] =
675 {
676 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
677 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
678 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
679 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
680 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00,
681 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00,
682 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
683 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
684 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00,
685 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
686 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
687 };
688
689 static const unsigned char ddigits[32] =
690 {
691 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03,
692 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
693 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
694 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
695 };
696
697 static const unsigned char hdigits[32] =
698 {
699 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03,
700 0x7E, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00,
701 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
702 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
703 };
704
705
706 /* Routine to convert a decimal ASCII string to an unsigned long integer. */
707 static unsigned long
708 bdf_atoul_( const char* s )
709 {
710 unsigned long v;
711
712
713 if ( s == NULL || *s == 0 )
714 return 0;
715
716 for ( v = 0; sbitset( ddigits, *s ); s++ )
717 {
718 if ( v < ( FT_ULONG_MAX - 9 ) / 10 )
719 v = v * 10 + a2i[(int)*s];
720 else
721 {
722 v = FT_ULONG_MAX;
723 break;
724 }
725 }
726
727 return v;
728 }
729
730
731 /* Routine to convert a decimal ASCII string to a signed long integer. */
732 static long
733 bdf_atol_( const char* s )
734 {
735 long v, neg;
736
737
738 if ( s == NULL || *s == 0 )
739 return 0;
740
741 /* Check for a minus sign. */
742 neg = 0;
743 if ( *s == '-' )
744 {
745 s++;
746 neg = 1;
747 }
748
749 for ( v = 0; sbitset( ddigits, *s ); s++ )
750 {
751 if ( v < ( FT_LONG_MAX - 9 ) / 10 )
752 v = v * 10 + a2i[(int)*s];
753 else
754 {
755 v = FT_LONG_MAX;
756 break;
757 }
758 }
759
760 return ( !neg ) ? v : -v;
761 }
762
763
764 /* Routine to convert a decimal ASCII string to an unsigned short integer. */
765 static unsigned short
766 bdf_atous_( const char* s )
767 {
768 unsigned short v;
769
770
771 if ( s == NULL || *s == 0 )
772 return 0;
773
774 for ( v = 0; sbitset( ddigits, *s ); s++ )
775 {
776 if ( v < ( FT_USHORT_MAX - 9 ) / 10 )
777 v = (unsigned short)( v * 10 + a2i[(int)*s] );
778 else
779 {
780 v = FT_USHORT_MAX;
781 break;
782 }
783 }
784
785 return v;
786 }
787
788
789 /* Routine to convert a decimal ASCII string to a signed short integer. */
790 static short
791 bdf_atos_( const char* s )
792 {
793 short v, neg;
794
795
796 if ( s == NULL || *s == 0 )
797 return 0;
798
799 /* Check for a minus. */
800 neg = 0;
801 if ( *s == '-' )
802 {
803 s++;
804 neg = 1;
805 }
806
807 for ( v = 0; sbitset( ddigits, *s ); s++ )
808 {
809 if ( v < ( SHRT_MAX - 9 ) / 10 )
810 v = (short)( v * 10 + a2i[(int)*s] );
811 else
812 {
813 v = SHRT_MAX;
814 break;
815 }
816 }
817
818 return (short)( ( !neg ) ? v : -v );
819 }
820
821
822 /* Routine to compare two glyphs by encoding so they can be sorted. */
823 FT_COMPARE_DEF( int )
824 by_encoding( const void* a,
825 const void* b )
826 {
827 bdf_glyph_t *c1, *c2;
828
829
830 c1 = (bdf_glyph_t *)a;
831 c2 = (bdf_glyph_t *)b;
832
833 if ( c1->encoding < c2->encoding )
834 return -1;
835
836 if ( c1->encoding > c2->encoding )
837 return 1;
838
839 return 0;
840 }
841
842
843 static FT_Error
844 bdf_create_property( const char* name,
845 int format,
846 bdf_font_t* font )
847 {
848 size_t n;
849 bdf_property_t* p;
850 FT_Memory memory = font->memory;
851 FT_Error error = FT_Err_Ok;
852
853
854 /* First check whether the property has */
855 /* already been added or not. If it has, then */
856 /* simply ignore it. */
857 if ( ft_hash_str_lookup( name, &(font->proptbl) ) )
858 goto Exit;
859
860 if ( FT_QRENEW_ARRAY( font->user_props,
861 font->nuser_props,
862 font->nuser_props + 1 ) )
863 goto Exit;
864
865 p = font->user_props + font->nuser_props;
866
867 n = ft_strlen( name ) + 1;
868 if ( n > FT_LONG_MAX )
869 return FT_THROW( Invalid_Argument );
870
871 if ( FT_QALLOC( p->name, n ) )
872 goto Exit;
873
874 FT_MEM_COPY( (char *)p->name, name, n );
875
876 p->format = format;
877 p->builtin = 0;
878 p->value.atom = NULL; /* nothing is ever stored here */
879
880 n = num_bdf_properties_ + font->nuser_props;
881
882 error = ft_hash_str_insert( p->name, n, &(font->proptbl), memory );
883 if ( error )
884 goto Exit;
885
886 font->nuser_props++;
887
888 Exit:
889 return error;
890 }
891
892
893 static bdf_property_t*
894 bdf_get_property( const char* name,
895 bdf_font_t* font )
896 {
897 size_t* propid;
898
899
900 if ( name == NULL || *name == 0 )
901 return NULL;
902
903 if ( ( propid = ft_hash_str_lookup( name, &(font->proptbl) ) ) == NULL )
904 return NULL;
905
906 if ( *propid >= num_bdf_properties_ )
907 return font->user_props + ( *propid - num_bdf_properties_ );
908
909 return (bdf_property_t*)bdf_properties_ + *propid;
910 }
911
912
913 /**************************************************************************
914 *
915 * BDF font file parsing flags and functions.
916 *
917 */
918
919
920 /* Parse flags. */
921
922 #define BDF_START_ 0x0001U
923 #define BDF_FONT_NAME_ 0x0002U
924 #define BDF_SIZE_ 0x0004U
925 #define BDF_FONT_BBX_ 0x0008U
926 #define BDF_PROPS_ 0x0010U
927 #define BDF_GLYPHS_ 0x0020U
928 #define BDF_GLYPH_ 0x0040U
929 #define BDF_ENCODING_ 0x0080U
930 #define BDF_SWIDTH_ 0x0100U
931 #define BDF_DWIDTH_ 0x0200U
932 #define BDF_BBX_ 0x0400U
933 #define BDF_BITMAP_ 0x0800U
934
935 #define BDF_SWIDTH_ADJ_ 0x1000U
936
937 #define BDF_GLYPH_BITS_ ( BDF_GLYPH_ | \
938 BDF_ENCODING_ | \
939 BDF_SWIDTH_ | \
940 BDF_DWIDTH_ | \
941 BDF_BBX_ | \
942 BDF_BITMAP_ )
943
944 #define BDF_GLYPH_WIDTH_CHECK_ 0x40000000UL
945 #define BDF_GLYPH_HEIGHT_CHECK_ 0x80000000UL
946
947
948 static FT_Error
949 bdf_add_comment_( bdf_font_t* font,
950 const char* comment,
951 unsigned long len )
952 {
953 char* cp;
954 FT_Memory memory = font->memory;
955 FT_Error error = FT_Err_Ok;
956
957
958 if ( FT_QRENEW_ARRAY( font->comments,
959 font->comments_len,
960 font->comments_len + len + 1 ) )
961 goto Exit;
962
963 cp = font->comments + font->comments_len;
964
965 FT_MEM_COPY( cp, comment, len );
966 cp[len] = '\0';
967
968 font->comments_len += len + 1;
969
970 Exit:
971 return error;
972 }
973
974
975 /* Set the spacing from the font name if it exists, or set it to the */
976 /* default specified in the options. */
977 static FT_Error
978 bdf_set_default_spacing_( bdf_font_t* font,
979 bdf_options_t* opts,
980 unsigned long lineno )
981 {
982 size_t len;
983 char name[256];
984 bdf_list_t_ list;
985 FT_Memory memory;
986 FT_Error error = FT_Err_Ok;
987
988 FT_UNUSED( lineno ); /* only used in debug mode */
989
990
991 if ( font == NULL || font->name == NULL || font->name[0] == 0 )
992 {
993 error = FT_THROW( Invalid_Argument );
994 goto Exit;
995 }
996
997 memory = font->memory;
998
999 bdf_list_init_( &list, memory );
1000
1001 font->spacing = opts->font_spacing;
1002
1003 len = ft_strlen( font->name ) + 1;
1004 /* Limit ourselves to 256 characters in the font name. */
1005 if ( len >= 256 )
1006 {
1007 FT_ERROR(( "bdf_set_default_spacing_: " ERRMSG7, lineno ));
1008 error = FT_THROW( Invalid_Argument );
1009 goto Exit;
1010 }
1011
1012 FT_MEM_COPY( name, font->name, len );
1013
1014 error = bdf_list_split_( &list, "-", name, (unsigned long)len );
1015 if ( error )
1016 goto Fail;
1017
1018 if ( list.used == 15 )
1019 {
1020 switch ( list.field[11][0] )
1021 {
1022 case 'C':
1023 case 'c':
1024 font->spacing = BDF_CHARCELL;
1025 break;
1026 case 'M':
1027 case 'm':
1028 font->spacing = BDF_MONOWIDTH;
1029 break;
1030 case 'P':
1031 case 'p':
1032 font->spacing = BDF_PROPORTIONAL;
1033 break;
1034 }
1035 }
1036
1037 Fail:
1038 bdf_list_done_( &list );
1039
1040 Exit:
1041 return error;
1042 }
1043
1044
1045 /* Determine whether the property is an atom or not. If it is, then */
1046 /* clean it up so the double quotes are removed if they exist. */
1047 static int
1048 bdf_is_atom_( char* line,
1049 unsigned long linelen,
1050 char** name,
1051 char** value,
1052 bdf_font_t* font )
1053 {
1054 int hold;
1055 char *sp, *ep;
1056 bdf_property_t* p;
1057
1058
1059 sp = ep = line;
1060
1061 while ( *ep && *ep != ' ' && *ep != '\t' )
1062 ep++;
1063
1064 hold = *ep;
1065 *ep = '\0';
1066
1067 p = bdf_get_property( sp, font );
1068
1069 /* If the property exists and is not an atom, just return here. */
1070 if ( p && p->format != BDF_ATOM )
1071 {
1072 *ep = (char)hold; /* Undo NUL-termination. */
1073 return 0;
1074 }
1075
1076 *name = sp;
1077
1078 /* The property is an atom. Trim all leading and trailing whitespace */
1079 /* and double quotes for the atom value. */
1080 sp = ep;
1081 ep = line + linelen;
1082
1083 /* Trim the leading whitespace if it exists. */
1084 if ( sp < ep )
1085 do
1086 sp++;
1087 while ( *sp == ' ' || *sp == '\t' );
1088
1089 /* Trim the leading double quote if it exists. */
1090 if ( *sp == '"' )
1091 sp++;
1092
1093 *value = sp;
1094
1095 /* Trim the trailing whitespace if it exists. */
1096 if ( sp < ep )
1097 do
1098 *ep-- = '\0';
1099 while ( *ep == ' ' || *ep == '\t' );
1100
1101 /* Trim the trailing double quote if it exists. */
1102 if ( *ep == '"' )
1103 *ep = '\0';
1104
1105 return 1;
1106 }
1107
1108
1109 static FT_Error
1110 bdf_add_property_( bdf_font_t* font,
1111 const char* name,
1112 char* value,
1113 unsigned long lineno )
1114 {
1115 size_t* propid;
1116 bdf_property_t *prop, *fp;
1117 FT_Memory memory = font->memory;
1118 FT_Error error = FT_Err_Ok;
1119
1120 FT_UNUSED( lineno ); /* only used in debug mode */
1121
1122
1123 /* First, check whether the property already exists in the font. */
1124 if ( ( propid = ft_hash_str_lookup( name,
1125 (FT_Hash)font->internal ) ) != NULL )
1126 {
1127 /* The property already exists in the font, so simply replace */
1128 /* the value of the property with the current value. */
1129 fp = font->props + *propid;
1130
1131 switch ( fp->format )
1132 {
1133 case BDF_ATOM:
1134 /* Delete the current atom if it exists. */
1135 FT_FREE( fp->value.atom );
1136
1137 if ( value && value[0] != 0 )
1138 {
1139 if ( FT_STRDUP( fp->value.atom, value ) )
1140 goto Exit;
1141 }
1142 break;
1143
1144 case BDF_INTEGER:
1145 fp->value.l = bdf_atol_( value );
1146 break;
1147
1148 case BDF_CARDINAL:
1149 fp->value.ul = bdf_atoul_( value );
1150 break;
1151
1152 default:
1153 ;
1154 }
1155
1156 goto Exit;
1157 }
1158
1159 /* See whether this property type exists yet or not. */
1160 /* If not, create it. */
1161 propid = ft_hash_str_lookup( name, &(font->proptbl) );
1162 if ( !propid )
1163 {
1164 error = bdf_create_property( name, BDF_ATOM, font );
1165 if ( error )
1166 goto Exit;
1167 propid = ft_hash_str_lookup( name, &(font->proptbl) );
1168 }
1169
1170 /* Allocate another property if this is overflowing. */
1171 if ( font->props_used == font->props_size )
1172 {
1173 if ( FT_QRENEW_ARRAY( font->props,
1174 font->props_size,
1175 font->props_size + 1 ) )
1176 goto Exit;
1177
1178 font->props_size++;
1179 }
1180
1181 if ( *propid >= num_bdf_properties_ )
1182 prop = font->user_props + ( *propid - num_bdf_properties_ );
1183 else
1184 prop = (bdf_property_t*)bdf_properties_ + *propid;
1185
1186 fp = font->props + font->props_used;
1187
1188 fp->name = prop->name;
1189 fp->format = prop->format;
1190 fp->builtin = prop->builtin;
1191
1192 switch ( prop->format )
1193 {
1194 case BDF_ATOM:
1195 fp->value.atom = NULL;
1196 if ( value && value[0] )
1197 {
1198 if ( FT_STRDUP( fp->value.atom, value ) )
1199 goto Exit;
1200 }
1201 break;
1202
1203 case BDF_INTEGER:
1204 fp->value.l = bdf_atol_( value );
1205 break;
1206
1207 case BDF_CARDINAL:
1208 fp->value.ul = bdf_atoul_( value );
1209 break;
1210 }
1211
1212 /* If the property happens to be a comment, then it doesn't need */
1213 /* to be added to the internal hash table. */
1214 if ( _bdf_strncmp( name, "COMMENT", 7 ) != 0 )
1215 {
1216 /* Add the property to the font property table. */
1217 error = ft_hash_str_insert( fp->name,
1218 font->props_used,
1219 (FT_Hash)font->internal,
1220 memory );
1221 if ( error )
1222 goto Exit;
1223 }
1224
1225 font->props_used++;
1226
1227 /* Some special cases need to be handled here. The DEFAULT_CHAR */
1228 /* property needs to be located if it exists in the property list, the */
1229 /* FONT_ASCENT and FONT_DESCENT need to be assigned if they are */
1230 /* present, and the SPACING property should override the default */
1231 /* spacing. */
1232 if ( _bdf_strncmp( name, "DEFAULT_CHAR", 12 ) == 0 )
1233 font->default_char = fp->value.ul;
1234 else if ( _bdf_strncmp( name, "FONT_ASCENT", 11 ) == 0 )
1235 font->font_ascent = fp->value.l;
1236 else if ( _bdf_strncmp( name, "FONT_DESCENT", 12 ) == 0 )
1237 font->font_descent = fp->value.l;
1238 else if ( _bdf_strncmp( name, "SPACING", 7 ) == 0 )
1239 {
1240 if ( !fp->value.atom )
1241 {
1242 FT_ERROR(( "bdf_add_property_: " ERRMSG8, lineno, "SPACING" ));
1243 error = FT_THROW( Invalid_File_Format );
1244 goto Exit;
1245 }
1246
1247 if ( fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P' )
1248 font->spacing = BDF_PROPORTIONAL;
1249 else if ( fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M' )
1250 font->spacing = BDF_MONOWIDTH;
1251 else if ( fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C' )
1252 font->spacing = BDF_CHARCELL;
1253 }
1254
1255 Exit:
1256 return error;
1257 }
1258
1259
1260 static const unsigned char nibble_mask[8] =
1261 {
1262 0xFF, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE
1263 };
1264
1265
1266 static FT_Error
1267 bdf_parse_end_( char* line,
1268 unsigned long linelen,
1269 unsigned long lineno,
1270 void* call_data,
1271 void* client_data )
1272 {
1273 /* a no-op; we ignore everything after `ENDFONT' */
1274
1275 FT_UNUSED( line );
1276 FT_UNUSED( linelen );
1277 FT_UNUSED( lineno );
1278 FT_UNUSED( call_data );
1279 FT_UNUSED( client_data );
1280
1281 return FT_Err_Ok;
1282 }
1283
1284
1285 /* Actually parse the glyph info and bitmaps. */
1286 static FT_Error
1287 bdf_parse_glyphs_( char* line,
1288 unsigned long linelen,
1289 unsigned long lineno,
1290 void* call_data,
1291 void* client_data )
1292 {
1293 int c, mask_index;
1294 char* s;
1295 unsigned char* bp;
1296 unsigned long i, slen, nibbles;
1297
1298 bdf_line_func_t_* next;
1299 bdf_parse_t_* p;
1300 bdf_glyph_t* glyph;
1301 bdf_font_t* font;
1302
1303 FT_Memory memory;
1304 FT_Error error = FT_Err_Ok;
1305
1306 FT_UNUSED( lineno ); /* only used in debug mode */
1307
1308
1309 next = (bdf_line_func_t_ *)call_data;
1310 p = (bdf_parse_t_ *) client_data;
1311
1312 font = p->font;
1313 memory = font->memory;
1314
1315 /* Check for a comment. */
1316 if ( _bdf_strncmp( line, "COMMENT", 7 ) == 0 )
1317 {
1318 if ( p->opts->keep_comments )
1319 {
1320 linelen -= 7;
1321
1322 s = line + 7;
1323 if ( *s != 0 )
1324 {
1325 s++;
1326 linelen--;
1327 }
1328 error = bdf_add_comment_( p->font, s, linelen );
1329 }
1330 goto Exit;
1331 }
1332
1333 /* The very first thing expected is the number of glyphs. */
1334 if ( !( p->flags & BDF_GLYPHS_ ) )
1335 {
1336 if ( _bdf_strncmp( line, "CHARS", 5 ) != 0 )
1337 {
1338 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG1, lineno, "CHARS" ));
1339 error = FT_THROW( Missing_Chars_Field );
1340 goto Exit;
1341 }
1342
1343 error = bdf_list_split_( &p->list, " +", line, linelen );
1344 if ( error )
1345 goto Exit;
1346 p->cnt = font->glyphs_size = bdf_atoul_( p->list.field[1] );
1347
1348 /* We need at least 20 bytes per glyph. */
1349 if ( p->cnt > p->size / 20 )
1350 {
1351 p->cnt = font->glyphs_size = p->size / 20;
1352 FT_TRACE2(( "bdf_parse_glyphs_: " ACMSG17, p->cnt ));
1353 }
1354
1355 /* Make sure the number of glyphs is non-zero. */
1356 if ( p->cnt == 0 )
1357 font->glyphs_size = 64;
1358
1359 /* Limit ourselves to 1,114,112 glyphs in the font (this is the */
1360 /* number of code points available in Unicode). */
1361 if ( p->cnt >= 0x110000UL )
1362 {
1363 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG5, lineno, "CHARS" ));
1364 error = FT_THROW( Invalid_Argument );
1365 goto Exit;
1366 }
1367
1368 if ( FT_NEW_ARRAY( font->glyphs, font->glyphs_size ) )
1369 goto Exit;
1370
1371 p->flags |= BDF_GLYPHS_;
1372
1373 goto Exit;
1374 }
1375
1376 /* Check for the ENDFONT field. */
1377 if ( _bdf_strncmp( line, "ENDFONT", 7 ) == 0 )
1378 {
1379 if ( p->flags & BDF_GLYPH_BITS_ )
1380 {
1381 /* Missing ENDCHAR field. */
1382 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG1, lineno, "ENDCHAR" ));
1383 error = FT_THROW( Corrupted_Font_Glyphs );
1384 goto Exit;
1385 }
1386
1387 /* Sort the glyphs by encoding. */
1388 ft_qsort( (char *)font->glyphs,
1389 font->glyphs_used,
1390 sizeof ( bdf_glyph_t ),
1391 by_encoding );
1392
1393 p->flags &= ~BDF_START_;
1394 *next = bdf_parse_end_;
1395
1396 goto Exit;
1397 }
1398
1399 /* Check for the ENDCHAR field. */
1400 if ( _bdf_strncmp( line, "ENDCHAR", 7 ) == 0 )
1401 {
1402 p->glyph_enc = 0;
1403 p->flags &= ~BDF_GLYPH_BITS_;
1404
1405 goto Exit;
1406 }
1407
1408 /* Check whether a glyph is being scanned but should be */
1409 /* ignored because it is an unencoded glyph. */
1410 if ( ( p->flags & BDF_GLYPH_ ) &&
1411 p->glyph_enc == -1 &&
1412 p->opts->keep_unencoded == 0 )
1413 goto Exit;
1414
1415 /* Check for the STARTCHAR field. */
1416 if ( _bdf_strncmp( line, "STARTCHAR", 9 ) == 0 )
1417 {
1418 if ( p->flags & BDF_GLYPH_BITS_ )
1419 {
1420 /* Missing ENDCHAR field. */
1421 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG1, lineno, "ENDCHAR" ));
1422 error = FT_THROW( Missing_Startchar_Field );
1423 goto Exit;
1424 }
1425
1426 /* Set the character name in the parse info first until the */
1427 /* encoding can be checked for an unencoded character. */
1428 FT_FREE( p->glyph_name );
1429
1430 error = bdf_list_split_( &p->list, " +", line, linelen );
1431 if ( error )
1432 goto Exit;
1433
1434 bdf_list_shift_( &p->list, 1 );
1435
1436 s = bdf_list_join_( &p->list, ' ', &slen );
1437
1438 if ( !s )
1439 {
1440 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG8, lineno, "STARTCHAR" ));
1441 error = FT_THROW( Invalid_File_Format );
1442 goto Exit;
1443 }
1444
1445 if ( FT_QALLOC( p->glyph_name, slen + 1 ) )
1446 goto Exit;
1447
1448 FT_MEM_COPY( p->glyph_name, s, slen + 1 );
1449
1450 p->flags |= BDF_GLYPH_;
1451
1452 FT_TRACE4(( DBGMSG1, lineno, s ));
1453
1454 goto Exit;
1455 }
1456
1457 /* Check for the ENCODING field. */
1458 if ( _bdf_strncmp( line, "ENCODING", 8 ) == 0 )
1459 {
1460 if ( !( p->flags & BDF_GLYPH_ ) )
1461 {
1462 /* Missing STARTCHAR field. */
1463 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG1, lineno, "STARTCHAR" ));
1464 error = FT_THROW( Missing_Startchar_Field );
1465 goto Exit;
1466 }
1467
1468 error = bdf_list_split_( &p->list, " +", line, linelen );
1469 if ( error )
1470 goto Exit;
1471
1472 p->glyph_enc = bdf_atol_( p->list.field[1] );
1473
1474 /* Normalize negative encoding values. The specification only */
1475 /* allows -1, but we can be more generous here. */
1476 if ( p->glyph_enc < -1 )
1477 p->glyph_enc = -1;
1478
1479 /* Check for alternative encoding format. */
1480 if ( p->glyph_enc == -1 && p->list.used > 2 )
1481 p->glyph_enc = bdf_atol_( p->list.field[2] );
1482
1483 if ( p->glyph_enc < -1 || p->glyph_enc >= 0x110000L )
1484 p->glyph_enc = -1;
1485
1486 FT_TRACE4(( DBGMSG2, p->glyph_enc ));
1487
1488 if ( p->glyph_enc >= 0 )
1489 {
1490 /* Make sure there are enough glyphs allocated in case the */
1491 /* number of characters happen to be wrong. */
1492 if ( font->glyphs_used == font->glyphs_size )
1493 {
1494 if ( FT_RENEW_ARRAY( font->glyphs,
1495 font->glyphs_size,
1496 font->glyphs_size + 64 ) )
1497 goto Exit;
1498
1499 font->glyphs_size += 64;
1500 }
1501
1502 glyph = font->glyphs + font->glyphs_used++;
1503 glyph->name = p->glyph_name;
1504 glyph->encoding = (unsigned long)p->glyph_enc;
1505
1506 /* Reset the initial glyph info. */
1507 p->glyph_name = NULL;
1508 }
1509 else
1510 {
1511 /* Unencoded glyph. Check whether it should */
1512 /* be added or not. */
1513 if ( p->opts->keep_unencoded )
1514 {
1515 /* Allocate the next unencoded glyph. */
1516 if ( font->unencoded_used == font->unencoded_size )
1517 {
1518 if ( FT_RENEW_ARRAY( font->unencoded ,
1519 font->unencoded_size,
1520 font->unencoded_size + 4 ) )
1521 goto Exit;
1522
1523 font->unencoded_size += 4;
1524 }
1525
1526 glyph = font->unencoded + font->unencoded_used;
1527 glyph->name = p->glyph_name;
1528 glyph->encoding = font->unencoded_used++;
1529
1530 /* Reset the initial glyph info. */
1531 p->glyph_name = NULL;
1532 }
1533 else
1534 {
1535 /* Free up the glyph name if the unencoded shouldn't be */
1536 /* kept. */
1537 FT_FREE( p->glyph_name );
1538 }
1539 }
1540
1541 /* Clear the flags that might be added when width and height are */
1542 /* checked for consistency. */
1543 p->flags &= ~( BDF_GLYPH_WIDTH_CHECK_ | BDF_GLYPH_HEIGHT_CHECK_ );
1544
1545 p->flags |= BDF_ENCODING_;
1546
1547 goto Exit;
1548 }
1549
1550 if ( !( p->flags & BDF_ENCODING_ ) )
1551 goto Missing_Encoding;
1552
1553 /* Point at the glyph being constructed. */
1554 if ( p->glyph_enc == -1 )
1555 glyph = font->unencoded + ( font->unencoded_used - 1 );
1556 else
1557 glyph = font->glyphs + ( font->glyphs_used - 1 );
1558
1559 /* Check whether a bitmap is being constructed. */
1560 if ( p->flags & BDF_BITMAP_ )
1561 {
1562 /* If there are more rows than are specified in the glyph metrics, */
1563 /* ignore the remaining lines. */
1564 if ( p->row >= (unsigned long)glyph->bbx.height )
1565 {
1566 if ( !( p->flags & BDF_GLYPH_HEIGHT_CHECK_ ) )
1567 {
1568 FT_TRACE2(( "bdf_parse_glyphs_: " ACMSG13, glyph->encoding ));
1569 p->flags |= BDF_GLYPH_HEIGHT_CHECK_;
1570 }
1571
1572 goto Exit;
1573 }
1574
1575 /* Only collect the number of nibbles indicated by the glyph */
1576 /* metrics. If there are more columns, they are simply ignored. */
1577 nibbles = glyph->bpr << 1;
1578 bp = glyph->bitmap + p->row * glyph->bpr;
1579
1580 for ( i = 0; i < nibbles; i++ )
1581 {
1582 c = line[i];
1583 if ( !sbitset( hdigits, c ) )
1584 break;
1585 *bp = (FT_Byte)( ( *bp << 4 ) + a2i[c] );
1586 if ( i + 1 < nibbles && ( i & 1 ) )
1587 *++bp = 0;
1588 }
1589
1590 /* If any line has not enough columns, */
1591 /* indicate they have been padded with zero bits. */
1592 if ( i < nibbles &&
1593 !( p->flags & BDF_GLYPH_WIDTH_CHECK_ ) )
1594 {
1595 FT_TRACE2(( "bdf_parse_glyphs_: " ACMSG16, glyph->encoding ));
1596 p->flags |= BDF_GLYPH_WIDTH_CHECK_;
1597 }
1598
1599 /* Remove possible garbage at the right. */
1600 mask_index = ( glyph->bbx.width * p->font->bpp ) & 7;
1601 if ( glyph->bbx.width )
1602 *bp &= nibble_mask[mask_index];
1603
1604 /* If any line has extra columns, indicate they have been removed. */
1605 if ( i == nibbles &&
1606 sbitset( hdigits, line[nibbles] ) &&
1607 !( p->flags & BDF_GLYPH_WIDTH_CHECK_ ) )
1608 {
1609 FT_TRACE2(( "bdf_parse_glyphs_: " ACMSG14, glyph->encoding ));
1610 p->flags |= BDF_GLYPH_WIDTH_CHECK_;
1611 }
1612
1613 p->row++;
1614 goto Exit;
1615 }
1616
1617 /* Expect the SWIDTH (scalable width) field next. */
1618 if ( _bdf_strncmp( line, "SWIDTH", 6 ) == 0 )
1619 {
1620 error = bdf_list_split_( &p->list, " +", line, linelen );
1621 if ( error )
1622 goto Exit;
1623
1624 glyph->swidth = bdf_atous_( p->list.field[1] );
1625 p->flags |= BDF_SWIDTH_;
1626
1627 goto Exit;
1628 }
1629
1630 /* Expect the DWIDTH (device width) field next. */
1631 if ( _bdf_strncmp( line, "DWIDTH", 6 ) == 0 )
1632 {
1633 error = bdf_list_split_( &p->list, " +", line, linelen );
1634 if ( error )
1635 goto Exit;
1636
1637 glyph->dwidth = bdf_atous_( p->list.field[1] );
1638
1639 if ( !( p->flags & BDF_SWIDTH_ ) )
1640 {
1641 /* Missing SWIDTH field. Emit an auto correction message and set */
1642 /* the scalable width from the device width. */
1643 FT_TRACE2(( "bdf_parse_glyphs_: " ACMSG9, lineno ));
1644
1645 glyph->swidth = (unsigned short)FT_MulDiv(
1646 glyph->dwidth, 72000L,
1647 (FT_Long)( font->point_size *
1648 font->resolution_x ) );
1649 }
1650
1651 p->flags |= BDF_DWIDTH_;
1652 goto Exit;
1653 }
1654
1655 /* Expect the BBX field next. */
1656 if ( _bdf_strncmp( line, "BBX", 3 ) == 0 )
1657 {
1658 error = bdf_list_split_( &p->list, " +", line, linelen );
1659 if ( error )
1660 goto Exit;
1661
1662 glyph->bbx.width = bdf_atous_( p->list.field[1] );
1663 glyph->bbx.height = bdf_atous_( p->list.field[2] );
1664 glyph->bbx.x_offset = bdf_atos_( p->list.field[3] );
1665 glyph->bbx.y_offset = bdf_atos_( p->list.field[4] );
1666
1667 /* Generate the ascent and descent of the character. */
1668 glyph->bbx.ascent = (short)( glyph->bbx.height + glyph->bbx.y_offset );
1669 glyph->bbx.descent = (short)( -glyph->bbx.y_offset );
1670
1671 /* Determine the overall font bounding box as the characters are */
1672 /* loaded so corrections can be done later if indicated. */
1673 p->maxas = (short)FT_MAX( glyph->bbx.ascent, p->maxas );
1674 p->maxds = (short)FT_MAX( glyph->bbx.descent, p->maxds );
1675
1676 p->rbearing = (short)( glyph->bbx.width + glyph->bbx.x_offset );
1677
1678 p->maxrb = (short)FT_MAX( p->rbearing, p->maxrb );
1679 p->minlb = (short)FT_MIN( glyph->bbx.x_offset, p->minlb );
1680 p->maxlb = (short)FT_MAX( glyph->bbx.x_offset, p->maxlb );
1681
1682 if ( !( p->flags & BDF_DWIDTH_ ) )
1683 {
1684 /* Missing DWIDTH field. Emit an auto correction message and set */
1685 /* the device width to the glyph width. */
1686 FT_TRACE2(( "bdf_parse_glyphs_: " ACMSG10, lineno ));
1687 glyph->dwidth = glyph->bbx.width;
1688 }
1689
1690 /* If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH */
1691 /* value if necessary. */
1692 if ( p->opts->correct_metrics )
1693 {
1694 /* Determine the point size of the glyph. */
1695 unsigned short sw = (unsigned short)FT_MulDiv(
1696 glyph->dwidth, 72000L,
1697 (FT_Long)( font->point_size *
1698 font->resolution_x ) );
1699
1700
1701 if ( sw != glyph->swidth )
1702 {
1703 glyph->swidth = sw;
1704
1705 p->flags |= BDF_SWIDTH_ADJ_;
1706 }
1707 }
1708
1709 p->flags |= BDF_BBX_;
1710 goto Exit;
1711 }
1712
1713 /* And finally, gather up the bitmap. */
1714 if ( _bdf_strncmp( line, "BITMAP", 6 ) == 0 )
1715 {
1716 unsigned long bitmap_size;
1717
1718
1719 if ( !( p->flags & BDF_BBX_ ) )
1720 {
1721 /* Missing BBX field. */
1722 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG1, lineno, "BBX" ));
1723 error = FT_THROW( Missing_Bbx_Field );
1724 goto Exit;
1725 }
1726
1727 /* Allocate enough space for the bitmap. */
1728 glyph->bpr = ( glyph->bbx.width * p->font->bpp + 7 ) >> 3;
1729
1730 bitmap_size = glyph->bpr * glyph->bbx.height;
1731 if ( glyph->bpr > 0xFFFFU || bitmap_size > 0xFFFFU )
1732 {
1733 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG4, lineno ));
1734 error = FT_THROW( Bbx_Too_Big );
1735 goto Exit;
1736 }
1737 else
1738 glyph->bytes = (unsigned short)bitmap_size;
1739
1740 if ( FT_ALLOC( glyph->bitmap, glyph->bytes ) )
1741 goto Exit;
1742
1743 p->row = 0;
1744 p->flags |= BDF_BITMAP_;
1745
1746 goto Exit;
1747 }
1748
1749 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG9, lineno ));
1750 error = FT_THROW( Invalid_File_Format );
1751 goto Exit;
1752
1753 Missing_Encoding:
1754 /* Missing ENCODING field. */
1755 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG1, lineno, "ENCODING" ));
1756 error = FT_THROW( Missing_Encoding_Field );
1757
1758 Exit:
1759 if ( error && ( p->flags & BDF_GLYPH_ ) )
1760 FT_FREE( p->glyph_name );
1761
1762 return error;
1763 }
1764
1765
1766 /* Load the font properties. */
1767 static FT_Error
1768 bdf_parse_properties_( char* line,
1769 unsigned long linelen,
1770 unsigned long lineno,
1771 void* call_data,
1772 void* client_data )
1773 {
1774 unsigned long vlen;
1775 bdf_line_func_t_* next;
1776 bdf_parse_t_* p;
1777 char* name;
1778 char* value;
1779 char nbuf[BUFSIZE];
1780 FT_Error error = FT_Err_Ok;
1781
1782 FT_UNUSED( lineno );
1783
1784
1785 next = (bdf_line_func_t_ *)call_data;
1786 p = (bdf_parse_t_ *) client_data;
1787
1788 /* Check for the end of the properties. */
1789 if ( _bdf_strncmp( line, "ENDPROPERTIES", 13 ) == 0 )
1790 {
1791 /* If the FONT_ASCENT or FONT_DESCENT properties have not been */
1792 /* encountered yet, then make sure they are added as properties and */
1793 /* make sure they are set from the font bounding box info. */
1794 /* */
1795 /* This is *always* done regardless of the options, because X11 */
1796 /* requires these two fields to compile fonts. */
1797 if ( bdf_get_font_property( p->font, "FONT_ASCENT" ) == 0 )
1798 {
1799 p->font->font_ascent = p->font->bbx.ascent;
1800 ft_snprintf( nbuf, BUFSIZE, "%hd", p->font->bbx.ascent );
1801 error = bdf_add_property_( p->font, "FONT_ASCENT",
1802 nbuf, lineno );
1803 if ( error )
1804 goto Exit;
1805
1806 FT_TRACE2(( "bdf_parse_properties_: " ACMSG1, p->font->bbx.ascent ));
1807 }
1808
1809 if ( bdf_get_font_property( p->font, "FONT_DESCENT" ) == 0 )
1810 {
1811 p->font->font_descent = p->font->bbx.descent;
1812 ft_snprintf( nbuf, BUFSIZE, "%hd", p->font->bbx.descent );
1813 error = bdf_add_property_( p->font, "FONT_DESCENT",
1814 nbuf, lineno );
1815 if ( error )
1816 goto Exit;
1817
1818 FT_TRACE2(( "bdf_parse_properties_: " ACMSG2, p->font->bbx.descent ));
1819 }
1820
1821 p->flags &= ~BDF_PROPS_;
1822 *next = bdf_parse_glyphs_;
1823
1824 goto Exit;
1825 }
1826
1827 /* Ignore the _XFREE86_GLYPH_RANGES properties. */
1828 if ( _bdf_strncmp( line, "_XFREE86_GLYPH_RANGES", 21 ) == 0 )
1829 goto Exit;
1830
1831 /* Handle COMMENT fields and properties in a special way to preserve */
1832 /* the spacing. */
1833 if ( _bdf_strncmp( line, "COMMENT", 7 ) == 0 )
1834 {
1835 name = value = line;
1836 value += 7;
1837 if ( *value )
1838 *value++ = 0;
1839 error = bdf_add_property_( p->font, name, value, lineno );
1840 if ( error )
1841 goto Exit;
1842 }
1843 else if ( bdf_is_atom_( line, linelen, &name, &value, p->font ) )
1844 {
1845 error = bdf_add_property_( p->font, name, value, lineno );
1846 if ( error )
1847 goto Exit;
1848 }
1849 else
1850 {
1851 error = bdf_list_split_( &p->list, " +", line, linelen );
1852 if ( error )
1853 goto Exit;
1854 name = p->list.field[0];
1855
1856 bdf_list_shift_( &p->list, 1 );
1857 value = bdf_list_join_( &p->list, ' ', &vlen );
1858
1859 error = bdf_add_property_( p->font, name, value, lineno );
1860 if ( error )
1861 goto Exit;
1862 }
1863
1864 Exit:
1865 return error;
1866 }
1867
1868
1869 /* Load the font header. */
1870 static FT_Error
1871 bdf_parse_start_( char* line,
1872 unsigned long linelen,
1873 unsigned long lineno,
1874 void* call_data,
1875 void* client_data )
1876 {
1877 unsigned long slen;
1878 bdf_line_func_t_* next;
1879 bdf_parse_t_* p;
1880 bdf_font_t* font;
1881 char *s;
1882
1883 FT_Memory memory = NULL;
1884 FT_Error error = FT_Err_Ok;
1885
1886 FT_UNUSED( lineno ); /* only used in debug mode */
1887
1888
1889 next = (bdf_line_func_t_ *)call_data;
1890 p = (bdf_parse_t_ *) client_data;
1891
1892 if ( p->font )
1893 memory = p->font->memory;
1894
1895 /* Check for a comment. This is done to handle those fonts that have */
1896 /* comments before the STARTFONT line for some reason. */
1897 if ( _bdf_strncmp( line, "COMMENT", 7 ) == 0 )
1898 {
1899 if ( p->opts->keep_comments && p->font )
1900 {
1901 linelen -= 7;
1902
1903 s = line + 7;
1904 if ( *s != 0 )
1905 {
1906 s++;
1907 linelen--;
1908 }
1909 error = bdf_add_comment_( p->font, s, linelen );
1910 }
1911 goto Exit;
1912 }
1913
1914 if ( !( p->flags & BDF_START_ ) )
1915 {
1916 memory = p->memory;
1917
1918 if ( _bdf_strncmp( line, "STARTFONT", 9 ) != 0 )
1919 {
1920 /* we don't emit an error message since this code gets */
1921 /* explicitly caught one level higher */
1922 error = FT_THROW( Missing_Startfont_Field );
1923 goto Exit;
1924 }
1925
1926 p->flags = BDF_START_;
1927 font = p->font = NULL;
1928
1929 if ( FT_NEW( font ) )
1930 goto Exit;
1931 p->font = font;
1932
1933 font->memory = p->memory;
1934
1935 { /* setup */
1936 size_t i;
1937 bdf_property_t* prop;
1938
1939
1940 error = ft_hash_str_init( &(font->proptbl), memory );
1941 if ( error )
1942 goto Exit;
1943 for ( i = 0, prop = (bdf_property_t*)bdf_properties_;
1944 i < num_bdf_properties_; i++, prop++ )
1945 {
1946 error = ft_hash_str_insert( prop->name, i,
1947 &(font->proptbl), memory );
1948 if ( error )
1949 goto Exit;
1950 }
1951 }
1952
1953 if ( FT_QALLOC( p->font->internal, sizeof ( FT_HashRec ) ) )
1954 goto Exit;
1955 error = ft_hash_str_init( (FT_Hash)p->font->internal, memory );
1956 if ( error )
1957 goto Exit;
1958 p->font->spacing = p->opts->font_spacing;
1959 p->font->default_char = ~0UL;
1960
1961 goto Exit;
1962 }
1963
1964 /* Check for the start of the properties. */
1965 if ( _bdf_strncmp( line, "STARTPROPERTIES", 15 ) == 0 )
1966 {
1967 if ( !( p->flags & BDF_FONT_BBX_ ) )
1968 {
1969 /* Missing the FONTBOUNDINGBOX field. */
1970 FT_ERROR(( "bdf_parse_start_: " ERRMSG1, lineno, "FONTBOUNDINGBOX" ));
1971 error = FT_THROW( Missing_Fontboundingbox_Field );
1972 goto Exit;
1973 }
1974
1975 error = bdf_list_split_( &p->list, " +", line, linelen );
1976 if ( error )
1977 goto Exit;
1978
1979 /* at this point, `p->font' can't be NULL */
1980 p->cnt = p->font->props_size = bdf_atoul_( p->list.field[1] );
1981 /* We need at least 4 bytes per property. */
1982 if ( p->cnt > p->size / 4 )
1983 {
1984 p->font->props_size = 0;
1985
1986 FT_ERROR(( "bdf_parse_glyphs_: " ERRMSG5, lineno, "STARTPROPERTIES" ));
1987 error = FT_THROW( Invalid_Argument );
1988 goto Exit;
1989 }
1990
1991 if ( FT_NEW_ARRAY( p->font->props, p->cnt ) )
1992 {
1993 p->font->props_size = 0;
1994 goto Exit;
1995 }
1996
1997 p->flags |= BDF_PROPS_;
1998 *next = bdf_parse_properties_;
1999
2000 goto Exit;
2001 }
2002
2003 /* Check for the FONTBOUNDINGBOX field. */
2004 if ( _bdf_strncmp( line, "FONTBOUNDINGBOX", 15 ) == 0 )
2005 {
2006 if ( !( p->flags & BDF_SIZE_ ) )
2007 {
2008 /* Missing the SIZE field. */
2009 FT_ERROR(( "bdf_parse_start_: " ERRMSG1, lineno, "SIZE" ));
2010 error = FT_THROW( Missing_Size_Field );
2011 goto Exit;
2012 }
2013
2014 error = bdf_list_split_( &p->list, " +", line, linelen );
2015 if ( error )
2016 goto Exit;
2017
2018 p->font->bbx.width = bdf_atous_( p->list.field[1] );
2019 p->font->bbx.height = bdf_atous_( p->list.field[2] );
2020
2021 p->font->bbx.x_offset = bdf_atos_( p->list.field[3] );
2022 p->font->bbx.y_offset = bdf_atos_( p->list.field[4] );
2023
2024 p->font->bbx.ascent = (short)( p->font->bbx.height +
2025 p->font->bbx.y_offset );
2026
2027 p->font->bbx.descent = (short)( -p->font->bbx.y_offset );
2028
2029 p->flags |= BDF_FONT_BBX_;
2030
2031 goto Exit;
2032 }
2033
2034 /* The next thing to check for is the FONT field. */
2035 if ( _bdf_strncmp( line, "FONT", 4 ) == 0 )
2036 {
2037 error = bdf_list_split_( &p->list, " +", line, linelen );
2038 if ( error )
2039 goto Exit;
2040 bdf_list_shift_( &p->list, 1 );
2041
2042 s = bdf_list_join_( &p->list, ' ', &slen );
2043
2044 if ( !s )
2045 {
2046 FT_ERROR(( "bdf_parse_start_: " ERRMSG8, lineno, "FONT" ));
2047 error = FT_THROW( Invalid_File_Format );
2048 goto Exit;
2049 }
2050
2051 /* Allowing multiple `FONT' lines (which is invalid) doesn't hurt... */
2052 FT_FREE( p->font->name );
2053
2054 if ( FT_QALLOC( p->font->name, slen + 1 ) )
2055 goto Exit;
2056 FT_MEM_COPY( p->font->name, s, slen + 1 );
2057
2058 /* If the font name is an XLFD name, set the spacing to the one in */
2059 /* the font name. If there is no spacing fall back on the default. */
2060 error = bdf_set_default_spacing_( p->font, p->opts, lineno );
2061 if ( error )
2062 goto Exit;
2063
2064 p->flags |= BDF_FONT_NAME_;
2065
2066 goto Exit;
2067 }
2068
2069 /* Check for the SIZE field. */
2070 if ( _bdf_strncmp( line, "SIZE", 4 ) == 0 )
2071 {
2072 if ( !( p->flags & BDF_FONT_NAME_ ) )
2073 {
2074 /* Missing the FONT field. */
2075 FT_ERROR(( "bdf_parse_start_: " ERRMSG1, lineno, "FONT" ));
2076 error = FT_THROW( Missing_Font_Field );
2077 goto Exit;
2078 }
2079
2080 error = bdf_list_split_( &p->list, " +", line, linelen );
2081 if ( error )
2082 goto Exit;
2083
2084 p->font->point_size = bdf_atoul_( p->list.field[1] );
2085 p->font->resolution_x = bdf_atoul_( p->list.field[2] );
2086 p->font->resolution_y = bdf_atoul_( p->list.field[3] );
2087
2088 /* Check for the bits per pixel field. */
2089 if ( p->list.used == 5 )
2090 {
2091 unsigned short bpp;
2092
2093
2094 bpp = bdf_atous_( p->list.field[4] );
2095
2096 /* Only values 1, 2, 4, 8 are allowed for greymap fonts. */
2097 if ( bpp > 4 )
2098 p->font->bpp = 8;
2099 else if ( bpp > 2 )
2100 p->font->bpp = 4;
2101 else if ( bpp > 1 )
2102 p->font->bpp = 2;
2103 else
2104 p->font->bpp = 1;
2105
2106 if ( p->font->bpp != bpp )
2107 FT_TRACE2(( "bdf_parse_start_: " ACMSG11, p->font->bpp ));
2108 }
2109 else
2110 p->font->bpp = 1;
2111
2112 p->flags |= BDF_SIZE_;
2113
2114 goto Exit;
2115 }
2116
2117 /* Check for the CHARS field -- font properties are optional */
2118 if ( _bdf_strncmp( line, "CHARS", 5 ) == 0 )
2119 {
2120 char nbuf[BUFSIZE];
2121
2122
2123 if ( !( p->flags & BDF_FONT_BBX_ ) )
2124 {
2125 /* Missing the FONTBOUNDINGBOX field. */
2126 FT_ERROR(( "bdf_parse_start_: " ERRMSG1, lineno, "FONTBOUNDINGBOX" ));
2127 error = FT_THROW( Missing_Fontboundingbox_Field );
2128 goto Exit;
2129 }
2130
2131 /* Add the two standard X11 properties which are required */
2132 /* for compiling fonts. */
2133 p->font->font_ascent = p->font->bbx.ascent;
2134 ft_snprintf( nbuf, BUFSIZE, "%hd", p->font->bbx.ascent );
2135 error = bdf_add_property_( p->font, "FONT_ASCENT",
2136 nbuf, lineno );
2137 if ( error )
2138 goto Exit;
2139 FT_TRACE2(( "bdf_parse_properties_: " ACMSG1, p->font->bbx.ascent ));
2140
2141 p->font->font_descent = p->font->bbx.descent;
2142 ft_snprintf( nbuf, BUFSIZE, "%hd", p->font->bbx.descent );
2143 error = bdf_add_property_( p->font, "FONT_DESCENT",
2144 nbuf, lineno );
2145 if ( error )
2146 goto Exit;
2147 FT_TRACE2(( "bdf_parse_properties_: " ACMSG2, p->font->bbx.descent ));
2148
2149 *next = bdf_parse_glyphs_;
2150
2151 /* A special return value. */
2152 error = -1;
2153 goto Exit;
2154 }
2155
2156 FT_ERROR(( "bdf_parse_start_: " ERRMSG9, lineno ));
2157 error = FT_THROW( Invalid_File_Format );
2158
2159 Exit:
2160 return error;
2161 }
2162
2163
2164 /**************************************************************************
2165 *
2166 * API.
2167 *
2168 */
2169
2170
2171 FT_LOCAL_DEF( FT_Error )
2172 bdf_load_font( FT_Stream stream,
2173 FT_Memory memory,
2174 bdf_options_t* opts,
2175 bdf_font_t* *font )
2176 {
2177 unsigned long lineno = 0; /* make compiler happy */
2178 bdf_parse_t_ *p = NULL;
2179
2180 FT_Error error = FT_Err_Ok;
2181
2182
2183 if ( FT_NEW( p ) )
2184 goto Exit;
2185
2186 p->opts = (bdf_options_t*)( opts ? opts : &bdf_opts_ );
2187 p->minlb = 32767;
2188 p->size = stream->size;
2189 p->memory = memory; /* only during font creation */
2190
2191 bdf_list_init_( &p->list, memory );
2192
2193 error = bdf_readstream_( stream, bdf_parse_start_,
2194 (void *)p, &lineno );
2195 if ( error )
2196 goto Fail;
2197
2198 if ( p->font )
2199 {
2200 /* If the font is not proportional, set the font's monowidth */
2201 /* field to the width of the font bounding box. */
2202
2203 if ( p->font->spacing != BDF_PROPORTIONAL )
2204 p->font->monowidth = p->font->bbx.width;
2205
2206 /* If the number of glyphs loaded is not that of the original count, */
2207 /* indicate the difference. */
2208 if ( p->cnt != p->font->glyphs_used + p->font->unencoded_used )
2209 {
2210 FT_TRACE2(( "bdf_load_font: " ACMSG15, p->cnt,
2211 p->font->glyphs_used + p->font->unencoded_used ));
2212 }
2213
2214 /* Once the font has been loaded, adjust the overall font metrics if */
2215 /* necessary. */
2216 if ( p->opts->correct_metrics != 0 &&
2217 ( p->font->glyphs_used > 0 || p->font->unencoded_used > 0 ) )
2218 {
2219 if ( p->maxrb - p->minlb != p->font->bbx.width )
2220 {
2221 FT_TRACE2(( "bdf_load_font: " ACMSG3,
2222 p->font->bbx.width, p->maxrb - p->minlb ));
2223 p->font->bbx.width = (unsigned short)( p->maxrb - p->minlb );
2224 }
2225
2226 if ( p->font->bbx.x_offset != p->minlb )
2227 {
2228 FT_TRACE2(( "bdf_load_font: " ACMSG4,
2229 p->font->bbx.x_offset, p->minlb ));
2230 p->font->bbx.x_offset = p->minlb;
2231 }
2232
2233 if ( p->font->bbx.ascent != p->maxas )
2234 {
2235 FT_TRACE2(( "bdf_load_font: " ACMSG5,
2236 p->font->bbx.ascent, p->maxas ));
2237 p->font->bbx.ascent = p->maxas;
2238 }
2239
2240 if ( p->font->bbx.descent != p->maxds )
2241 {
2242 FT_TRACE2(( "bdf_load_font: " ACMSG6,
2243 p->font->bbx.descent, p->maxds ));
2244 p->font->bbx.descent = p->maxds;
2245 p->font->bbx.y_offset = (short)( -p->maxds );
2246 }
2247
2248 if ( p->maxas + p->maxds != p->font->bbx.height )
2249 {
2250 FT_TRACE2(( "bdf_load_font: " ACMSG7,
2251 p->font->bbx.height, p->maxas + p->maxds ));
2252 p->font->bbx.height = (unsigned short)( p->maxas + p->maxds );
2253 }
2254
2255 if ( p->flags & BDF_SWIDTH_ADJ_ )
2256 FT_TRACE2(( "bdf_load_font: " ACMSG8 ));
2257 }
2258 }
2259
2260 if ( p->flags & BDF_START_ )
2261 {
2262 /* The ENDFONT field was never reached or did not exist. */
2263 if ( !( p->flags & BDF_GLYPHS_ ) )
2264 {
2265 /* Error happened while parsing header. */
2266 FT_ERROR(( "bdf_load_font: " ERRMSG2, lineno ));
2267 error = FT_THROW( Corrupted_Font_Header );
2268 goto Fail;
2269 }
2270 else
2271 {
2272 /* Error happened when parsing glyphs. */
2273 FT_ERROR(( "bdf_load_font: " ERRMSG3, lineno ));
2274 error = FT_THROW( Corrupted_Font_Glyphs );
2275 goto Fail;
2276 }
2277 }
2278
2279 if ( !p->font && !error )
2280 error = FT_THROW( Invalid_File_Format );
2281
2282 *font = p->font;
2283
2284 Exit:
2285 if ( p )
2286 {
2287 bdf_list_done_( &p->list );
2288
2289 FT_FREE( p->glyph_name );
2290 FT_FREE( p );
2291 }
2292
2293 return error;
2294
2295 Fail:
2296 bdf_free_font( p->font );
2297
2298 FT_FREE( p->font );
2299
2300 goto Exit;
2301 }
2302
2303
2304 FT_LOCAL_DEF( void )
2305 bdf_free_font( bdf_font_t* font )
2306 {
2307 bdf_property_t* prop;
2308 unsigned long i;
2309 bdf_glyph_t* glyphs;
2310 FT_Memory memory;
2311
2312
2313 if ( font == NULL )
2314 return;
2315
2316 memory = font->memory;
2317
2318 FT_FREE( font->name );
2319
2320 /* Free up the internal hash table of property names. */
2321 if ( font->internal )
2322 {
2323 ft_hash_str_free( (FT_Hash)font->internal, memory );
2324 FT_FREE( font->internal );
2325 }
2326
2327 /* Free up the comment info. */
2328 FT_FREE( font->comments );
2329
2330 /* Free up the properties. */
2331 for ( i = 0; i < font->props_size; i++ )
2332 {
2333 if ( font->props[i].format == BDF_ATOM )
2334 FT_FREE( font->props[i].value.atom );
2335 }
2336
2337 FT_FREE( font->props );
2338
2339 /* Free up the character info. */
2340 for ( i = 0, glyphs = font->glyphs;
2341 i < font->glyphs_used; i++, glyphs++ )
2342 {
2343 FT_FREE( glyphs->name );
2344 FT_FREE( glyphs->bitmap );
2345 }
2346
2347 for ( i = 0, glyphs = font->unencoded; i < font->unencoded_used;
2348 i++, glyphs++ )
2349 {
2350 FT_FREE( glyphs->name );
2351 FT_FREE( glyphs->bitmap );
2352 }
2353
2354 FT_FREE( font->glyphs );
2355 FT_FREE( font->unencoded );
2356
2357 /* bdf_cleanup */
2358 ft_hash_str_free( &(font->proptbl), memory );
2359
2360 /* Free up the user defined properties. */
2361 for ( prop = font->user_props, i = 0;
2362 i < font->nuser_props; i++, prop++ )
2363 FT_FREE( prop->name );
2364
2365 FT_FREE( font->user_props );
2366
2367 /* FREE( font ); */ /* XXX Fixme */
2368 }
2369
2370
2371 FT_LOCAL_DEF( bdf_property_t * )
2372 bdf_get_font_property( bdf_font_t* font,
2373 const char* name )
2374 {
2375 size_t* propid;
2376
2377
2378 if ( font == NULL || font->props_size == 0 || name == NULL || *name == 0 )
2379 return 0;
2380
2381 propid = ft_hash_str_lookup( name, (FT_Hash)font->internal );
2382
2383 return propid ? ( font->props + *propid ) : 0;
2384 }
2385
2386
2387 /* END */