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