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 #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 /* An auxiliary macro to parse properties, to be used in conditionals. */ 173 /* It behaves like `strncmp' but also tests the following character */ 174 /* whether it is a whitespace or NULL. */ 175 /* `property' is a constant string of length `n' to compare with. */ 176 #define _bdf_strncmp( name, property, n ) \ 177 ( ft_strncmp( name, property, n ) || \ 178 !( name[n] == ' ' || \ 179 name[n] == '\0' || \ 180 name[n] == '\n' || \ 181 name[n] == '\r' || \ 182 name[n] == '\t' ) ) 183 184 /* Auto correction messages. */ 185 #define ACMSG1 "FONT_ASCENT property missing. " \ 186 "Added `FONT_ASCENT %hd'.\n" 187 #define ACMSG2 "FONT_DESCENT property missing. " \ 188 "Added `FONT_DESCENT %hd'.\n" 189 #define ACMSG3 "Font width != actual width. Old: %hd New: %hd.\n" 190 #define ACMSG4 "Font left bearing != actual left bearing. " \ 191 "Old: %hd New: %hd.\n" 192 #define ACMSG5 "Font ascent != actual ascent. Old: %hd New: %hd.\n" 193 #define ACMSG6 "Font descent != actual descent. Old: %hd New: %hd.\n" 194 #define ACMSG7 "Font height != actual height. Old: %hd New: %hd.\n" 195 #define ACMSG8 "Glyph scalable width (SWIDTH) adjustments made.\n" 196 #define ACMSG9 "SWIDTH field missing at line %ld. Set automatically.\n" 197 #define ACMSG10 "DWIDTH field missing at line %ld. Set to glyph width.\n" 198 #define ACMSG11 "SIZE bits per pixel field adjusted to %hd.\n" 199 #define ACMSG12 "Duplicate encoding %ld (%s) changed to unencoded.\n" 200 #define ACMSG13 "Glyph %ld extra rows removed.\n" 201 #define ACMSG14 "Glyph %ld extra columns removed.\n" 202 #define ACMSG15 "Incorrect glyph count: %ld indicated but %ld found.\n" 203 #define ACMSG16 "Glyph %ld missing columns padded with zero bits.\n" 204 #define ACMSG17 "Adjusting number of glyphs to %ld.\n" 205 206 /* Error messages. */ 207 #define ERRMSG1 "[line %ld] Missing `%s' line.\n" 208 #define ERRMSG2 "[line %ld] Font header corrupted or missing fields.\n" 209 #define ERRMSG3 "[line %ld] Font glyphs corrupted or missing fields.\n" 210 #define ERRMSG4 "[line %ld] BBX too big.\n" 211 #define ERRMSG5 "[line %ld] `%s' value too big.\n" 212 #define ERRMSG6 "[line %ld] Input line too long.\n" 213 #define ERRMSG7 "[line %ld] Font name too long.\n" 214 #define ERRMSG8 "[line %ld] Invalid `%s' value.\n" 215 #define ERRMSG9 "[line %ld] Invalid keyword.\n" 216 217 /* Debug messages. */ 218 #define DBGMSG1 " [%6ld] %s" /* no \n */ 219 #define DBGMSG2 " (0x%lX)\n" 220 221 222 /*************************************************************************/ 223 /* */ 224 /* Utility types and functions. */ 225 /* */ 226 /*************************************************************************/ 227 228 229 /* Function type for parsing lines of a BDF font. */ 230 231 typedef FT_Error 232 (*_bdf_line_func_t)( char* line, 233 unsigned long linelen, 234 unsigned long lineno, 235 void* call_data, 236 void* client_data ); 237 238 239 /* List structure for splitting lines into fields. */ 240 241 typedef struct _bdf_list_t_ 242 { 243 char** field; 244 unsigned long size; 245 unsigned long used; 246 FT_Memory memory; 247 248 } _bdf_list_t; 249 250 251 /* Structure used while loading BDF fonts. */ 252 253 typedef struct _bdf_parse_t_ 254 { 255 unsigned long flags; 256 unsigned long cnt; 257 unsigned long row; 258 259 short minlb; 260 short maxlb; 261 short maxrb; 262 short maxas; 263 short maxds; 264 265 short rbearing; 266 267 char* glyph_name; 268 long glyph_enc; 269 270 bdf_font_t* font; 271 bdf_options_t* opts; 272 273 unsigned long have[34816]; /* must be in sync with `nmod' and `umod' */ 274 /* arrays from `bdf_font_t' structure */ 275 _bdf_list_t list; 276 277 FT_Memory memory; 278 unsigned long size; /* the stream size */ 279 280 } _bdf_parse_t; 281 282 283 #define setsbit( m, cc ) \ 284 ( m[(FT_Byte)(cc) >> 3] |= (FT_Byte)( 1 << ( (cc) & 7 ) ) ) 285 #define sbitset( m, cc ) \ 286 ( m[(FT_Byte)(cc) >> 3] & ( 1 << ( (cc) & 7 ) ) ) 287 288 289 static void 290 _bdf_list_init( _bdf_list_t* list, 291 FT_Memory memory ) 292 { 293 FT_ZERO( list ); 294 list->memory = memory; 295 } 296 297 298 static void 299 _bdf_list_done( _bdf_list_t* list ) 300 { 301 FT_Memory memory = list->memory; 302 303 304 if ( memory ) 305 { 306 FT_FREE( list->field ); 307 FT_ZERO( list ); 308 } 309 } 310 311 312 static FT_Error 313 _bdf_list_ensure( _bdf_list_t* list, 314 unsigned long num_items ) /* same as _bdf_list_t.used */ 315 { 316 FT_Error error = FT_Err_Ok; 317 318 319 if ( num_items > list->size ) 320 { 321 unsigned long oldsize = list->size; /* same as _bdf_list_t.size */ 322 unsigned long newsize = oldsize + ( oldsize >> 1 ) + 5; 323 unsigned long bigsize = (unsigned long)( FT_INT_MAX / sizeof ( char* ) ); 324 FT_Memory memory = list->memory; 325 326 327 if ( oldsize == bigsize ) 328 { 329 error = FT_THROW( Out_Of_Memory ); 330 goto Exit; 331 } 332 else if ( newsize < oldsize || newsize > bigsize ) 333 newsize = bigsize; 334 335 if ( FT_RENEW_ARRAY( list->field, oldsize, newsize ) ) 336 goto Exit; 337 338 list->size = newsize; 339 } 340 341 Exit: 342 return error; 343 } 344 345 346 static void 347 _bdf_list_shift( _bdf_list_t* list, 348 unsigned long n ) 349 { 350 unsigned long i, u; 351 352 353 if ( list == 0 || list->used == 0 || n == 0 ) 354 return; 355 356 if ( n >= list->used ) 357 { 358 list->used = 0; 359 return; 360 } 361 362 for ( u = n, i = 0; u < list->used; i++, u++ ) 363 list->field[i] = list->field[u]; 364 list->used -= n; 365 } 366 367 368 /* An empty string for empty fields. */ 369 370 static const char empty[1] = { 0 }; /* XXX eliminate this */ 371 372 373 static char * 374 _bdf_list_join( _bdf_list_t* list, 375 int c, 376 unsigned long *alen ) 377 { 378 unsigned long i, j; 379 char* dp; 380 381 382 *alen = 0; 383 384 if ( list == 0 || list->used == 0 ) 385 return 0; 386 387 dp = list->field[0]; 388 for ( i = j = 0; i < list->used; i++ ) 389 { 390 char* fp = list->field[i]; 391 392 393 while ( *fp ) 394 dp[j++] = *fp++; 395 396 if ( i + 1 < list->used ) 397 dp[j++] = (char)c; 398 } 399 if ( dp != empty ) 400 dp[j] = 0; 401 402 *alen = j; 403 return dp; 404 } 405 406 407 /* The code below ensures that we have at least 4 + 1 `field' */ 408 /* elements in `list' (which are possibly NULL) so that we */ 409 /* don't have to check the number of fields in most cases. */ 410 411 static FT_Error 412 _bdf_list_split( _bdf_list_t* list, 413 char* separators, 414 char* line, 415 unsigned long linelen ) 416 { 417 unsigned long final_empty; 418 int mult; 419 char *sp, *ep, *end; 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 == 0 || *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 ) ? 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] = 0; 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 == 0 ) 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_NEW_ARRAY( 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 ) /* last line in file doesn't end in \r or \n */ 588 break; /* ignore it then exit */ 589 590 if ( start == 0 ) 591 { 592 /* this line is definitely too long; try resizing the input */ 593 /* buffer a bit to handle it. */ 594 FT_ULong new_size; 595 596 597 if ( buf_size >= 65536UL ) /* limit ourselves to 64KByte */ 598 { 599 FT_ERROR(( "_bdf_readstream: " ERRMSG6, lineno )); 600 error = FT_THROW( Invalid_Argument ); 601 goto Exit; 602 } 603 604 new_size = buf_size * 2; 605 if ( FT_RENEW_ARRAY( buf, buf_size, new_size ) ) 606 goto Exit; 607 608 cursor = (ptrdiff_t)buf_size; 609 buf_size = new_size; 610 } 611 else 612 { 613 bytes = avail - start; 614 615 FT_MEM_MOVE( buf, buf + start, bytes ); 616 617 cursor = bytes; 618 avail -= bytes; 619 start = 0; 620 } 621 refill = 1; 622 continue; 623 } 624 625 /* Temporarily NUL-terminate the line. */ 626 hold = buf[end]; 627 buf[end] = 0; 628 629 /* XXX: Use encoding independent value for 0x1A */ 630 if ( buf[start] != '#' && buf[start] != 0x1A && end > start ) 631 { 632 error = (*cb)( buf + start, (unsigned long)( end - start ), lineno, 633 (void*)&cb, client_data ); 634 /* Redo if we have encountered CHARS without properties. */ 635 if ( error == -1 ) 636 error = (*cb)( buf + start, (unsigned long)( end - start ), lineno, 637 (void*)&cb, client_data ); 638 if ( error ) 639 break; 640 } 641 642 lineno += 1; 643 buf[end] = (char)hold; 644 start = end + 1; 645 646 if ( hold == '\n' ) 647 to_skip = '\r'; 648 else if ( hold == '\r' ) 649 to_skip = '\n'; 650 else 651 to_skip = NO_SKIP; 652 } 653 654 *lno = lineno; 655 656 Exit: 657 FT_FREE( buf ); 658 return error; 659 } 660 661 662 /* XXX: make this work with EBCDIC also */ 663 664 static const unsigned char a2i[128] = 665 { 666 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 667 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 668 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 669 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 670 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 671 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 672 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 673 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 674 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 675 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 676 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 677 }; 678 679 static const unsigned char ddigits[32] = 680 { 681 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03, 682 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 683 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 684 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 685 }; 686 687 static const unsigned char hdigits[32] = 688 { 689 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03, 690 0x7E, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 691 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 692 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 693 }; 694 695 696 /* Routine to convert a decimal ASCII string to an unsigned long integer. */ 697 static unsigned long 698 _bdf_atoul( char* s ) 699 { 700 unsigned long v; 701 702 703 if ( s == 0 || *s == 0 ) 704 return 0; 705 706 for ( v = 0; sbitset( ddigits, *s ); s++ ) 707 { 708 if ( v < ( FT_ULONG_MAX - 9 ) / 10 ) 709 v = v * 10 + a2i[(int)*s]; 710 else 711 { 712 v = FT_ULONG_MAX; 713 break; 714 } 715 } 716 717 return v; 718 } 719 720 721 /* Routine to convert a decimal ASCII string to a signed long integer. */ 722 static long 723 _bdf_atol( char* s ) 724 { 725 long v, neg; 726 727 728 if ( s == 0 || *s == 0 ) 729 return 0; 730 731 /* Check for a minus sign. */ 732 neg = 0; 733 if ( *s == '-' ) 734 { 735 s++; 736 neg = 1; 737 } 738 739 for ( v = 0; sbitset( ddigits, *s ); s++ ) 740 { 741 if ( v < ( FT_LONG_MAX - 9 ) / 10 ) 742 v = v * 10 + a2i[(int)*s]; 743 else 744 { 745 v = FT_LONG_MAX; 746 break; 747 } 748 } 749 750 return ( !neg ) ? v : -v; 751 } 752 753 754 /* Routine to convert a decimal ASCII string to an unsigned short integer. */ 755 static unsigned short 756 _bdf_atous( char* s ) 757 { 758 unsigned short v; 759 760 761 if ( s == 0 || *s == 0 ) 762 return 0; 763 764 for ( v = 0; sbitset( ddigits, *s ); s++ ) 765 { 766 if ( v < ( FT_USHORT_MAX - 9 ) / 10 ) 767 v = (unsigned short)( v * 10 + a2i[(int)*s] ); 768 else 769 { 770 v = FT_USHORT_MAX; 771 break; 772 } 773 } 774 775 return v; 776 } 777 778 779 /* Routine to convert a decimal ASCII string to a signed short integer. */ 780 static short 781 _bdf_atos( char* s ) 782 { 783 short v, neg; 784 785 786 if ( s == 0 || *s == 0 ) 787 return 0; 788 789 /* Check for a minus. */ 790 neg = 0; 791 if ( *s == '-' ) 792 { 793 s++; 794 neg = 1; 795 } 796 797 for ( v = 0; sbitset( ddigits, *s ); s++ ) 798 { 799 if ( v < ( SHRT_MAX - 9 ) / 10 ) 800 v = (short)( v * 10 + a2i[(int)*s] ); 801 else 802 { 803 v = SHRT_MAX; 804 break; 805 } 806 } 807 808 return (short)( ( !neg ) ? v : -v ); 809 } 810 811 812 /* Routine to compare two glyphs by encoding so they can be sorted. */ 813 static int 814 by_encoding( const void* a, 815 const void* b ) 816 { 817 bdf_glyph_t *c1, *c2; 818 819 820 c1 = (bdf_glyph_t *)a; 821 c2 = (bdf_glyph_t *)b; 822 823 if ( c1->encoding < c2->encoding ) 824 return -1; 825 826 if ( c1->encoding > c2->encoding ) 827 return 1; 828 829 return 0; 830 } 831 832 833 static FT_Error 834 bdf_create_property( char* name, 835 int format, 836 bdf_font_t* font ) 837 { 838 size_t n; 839 bdf_property_t* p; 840 FT_Memory memory = font->memory; 841 FT_Error error = FT_Err_Ok; 842 843 844 /* First check whether the property has */ 845 /* already been added or not. If it has, then */ 846 /* simply ignore it. */ 847 if ( ft_hash_str_lookup( name, &(font->proptbl) ) ) 848 goto Exit; 849 850 if ( FT_RENEW_ARRAY( font->user_props, 851 font->nuser_props, 852 font->nuser_props + 1 ) ) 853 goto Exit; 854 855 p = font->user_props + font->nuser_props; 856 FT_ZERO( p ); 857 858 n = ft_strlen( name ) + 1; 859 if ( n > FT_ULONG_MAX ) 860 return FT_THROW( Invalid_Argument ); 861 862 if ( FT_NEW_ARRAY( p->name, n ) ) 863 goto Exit; 864 865 FT_MEM_COPY( (char *)p->name, name, n ); 866 867 p->format = format; 868 p->builtin = 0; 869 870 n = _num_bdf_properties + font->nuser_props; 871 872 error = ft_hash_str_insert( p->name, n, &(font->proptbl), memory ); 873 if ( error ) 874 goto Exit; 875 876 font->nuser_props++; 877 878 Exit: 879 return error; 880 } 881 882 883 FT_LOCAL_DEF( bdf_property_t* ) 884 bdf_get_property( char* name, 885 bdf_font_t* font ) 886 { 887 size_t* propid; 888 889 890 if ( name == 0 || *name == 0 ) 891 return 0; 892 893 if ( ( propid = ft_hash_str_lookup( name, &(font->proptbl) ) ) == NULL ) 894 return 0; 895 896 if ( *propid >= _num_bdf_properties ) 897 return font->user_props + ( *propid - _num_bdf_properties ); 898 899 return (bdf_property_t*)_bdf_properties + *propid; 900 } 901 902 903 /*************************************************************************/ 904 /* */ 905 /* BDF font file parsing flags and functions. */ 906 /* */ 907 /*************************************************************************/ 908 909 910 /* Parse flags. */ 911 912 #define BDF_START_ 0x0001U 913 #define BDF_FONT_NAME_ 0x0002U 914 #define BDF_SIZE_ 0x0004U 915 #define BDF_FONT_BBX_ 0x0008U 916 #define BDF_PROPS_ 0x0010U 917 #define BDF_GLYPHS_ 0x0020U 918 #define BDF_GLYPH_ 0x0040U 919 #define BDF_ENCODING_ 0x0080U 920 #define BDF_SWIDTH_ 0x0100U 921 #define BDF_DWIDTH_ 0x0200U 922 #define BDF_BBX_ 0x0400U 923 #define BDF_BITMAP_ 0x0800U 924 925 #define BDF_SWIDTH_ADJ_ 0x1000U 926 927 #define BDF_GLYPH_BITS_ ( BDF_GLYPH_ | \ 928 BDF_ENCODING_ | \ 929 BDF_SWIDTH_ | \ 930 BDF_DWIDTH_ | \ 931 BDF_BBX_ | \ 932 BDF_BITMAP_ ) 933 934 #define BDF_GLYPH_WIDTH_CHECK_ 0x40000000UL 935 #define BDF_GLYPH_HEIGHT_CHECK_ 0x80000000UL 936 937 938 static FT_Error 939 _bdf_add_comment( bdf_font_t* font, 940 char* comment, 941 unsigned long len ) 942 { 943 char* cp; 944 FT_Memory memory = font->memory; 945 FT_Error error = FT_Err_Ok; 946 947 948 if ( FT_RENEW_ARRAY( font->comments, 949 font->comments_len, 950 font->comments_len + len + 1 ) ) 951 goto Exit; 952 953 cp = font->comments + font->comments_len; 954 955 FT_MEM_COPY( cp, comment, len ); 956 cp[len] = '\n'; 957 958 font->comments_len += len + 1; 959 960 Exit: 961 return error; 962 } 963 964 965 /* Set the spacing from the font name if it exists, or set it to the */ 966 /* default specified in the options. */ 967 static FT_Error 968 _bdf_set_default_spacing( bdf_font_t* font, 969 bdf_options_t* opts, 970 unsigned long lineno ) 971 { 972 size_t len; 973 char name[256]; 974 _bdf_list_t list; 975 FT_Memory memory; 976 FT_Error error = FT_Err_Ok; 977 978 FT_UNUSED( lineno ); /* only used in debug mode */ 979 980 981 if ( font == 0 || font->name == 0 || font->name[0] == 0 ) 982 { 983 error = FT_THROW( Invalid_Argument ); 984 goto Exit; 985 } 986 987 memory = font->memory; 988 989 _bdf_list_init( &list, memory ); 990 991 font->spacing = opts->font_spacing; 992 993 len = ft_strlen( font->name ) + 1; 994 /* Limit ourselves to 256 characters in the font name. */ 995 if ( len >= 256 ) 996 { 997 FT_ERROR(( "_bdf_set_default_spacing: " ERRMSG7, lineno )); 998 error = FT_THROW( Invalid_Argument ); 999 goto Exit; 1000 } 1001 1002 FT_MEM_COPY( name, font->name, len ); 1003 1004 error = _bdf_list_split( &list, (char *)"-", name, (unsigned long)len ); 1005 if ( error ) 1006 goto Fail; 1007 1008 if ( list.used == 15 ) 1009 { 1010 switch ( list.field[11][0] ) 1011 { 1012 case 'C': 1013 case 'c': 1014 font->spacing = BDF_CHARCELL; 1015 break; 1016 case 'M': 1017 case 'm': 1018 font->spacing = BDF_MONOWIDTH; 1019 break; 1020 case 'P': 1021 case 'p': 1022 font->spacing = BDF_PROPORTIONAL; 1023 break; 1024 } 1025 } 1026 1027 Fail: 1028 _bdf_list_done( &list ); 1029 1030 Exit: 1031 return error; 1032 } 1033 1034 1035 /* Determine whether the property is an atom or not. If it is, then */ 1036 /* clean it up so the double quotes are removed if they exist. */ 1037 static int 1038 _bdf_is_atom( char* line, 1039 unsigned long linelen, 1040 char** name, 1041 char** value, 1042 bdf_font_t* font ) 1043 { 1044 int hold; 1045 char *sp, *ep; 1046 bdf_property_t* p; 1047 1048 1049 *name = sp = ep = line; 1050 1051 while ( *ep && *ep != ' ' && *ep != '\t' ) 1052 ep++; 1053 1054 hold = -1; 1055 if ( *ep ) 1056 { 1057 hold = *ep; 1058 *ep = 0; 1059 } 1060 1061 p = bdf_get_property( sp, font ); 1062 1063 /* Restore the character that was saved before any return can happen. */ 1064 if ( hold != -1 ) 1065 *ep = (char)hold; 1066 1067 /* If the property exists and is not an atom, just return here. */ 1068 if ( p && p->format != BDF_ATOM ) 1069 return 0; 1070 1071 /* The property is an atom. Trim all leading and trailing whitespace */ 1072 /* and double quotes for the atom value. */ 1073 sp = ep; 1074 ep = line + linelen; 1075 1076 /* Trim the leading whitespace if it exists. */ 1077 if ( *sp ) 1078 *sp++ = 0; 1079 while ( *sp && 1080 ( *sp == ' ' || *sp == '\t' ) ) 1081 sp++; 1082 1083 /* Trim the leading double quote if it exists. */ 1084 if ( *sp == '"' ) 1085 sp++; 1086 *value = sp; 1087 1088 /* Trim the trailing whitespace if it exists. */ 1089 while ( ep > sp && 1090 ( *( ep - 1 ) == ' ' || *( ep - 1 ) == '\t' ) ) 1091 *--ep = 0; 1092 1093 /* Trim the trailing double quote if it exists. */ 1094 if ( ep > sp && *( ep - 1 ) == '"' ) 1095 *--ep = 0; 1096 1097 return 1; 1098 } 1099 1100 1101 static FT_Error 1102 _bdf_add_property( bdf_font_t* font, 1103 char* name, 1104 char* value, 1105 unsigned long lineno ) 1106 { 1107 size_t* propid; 1108 bdf_property_t *prop, *fp; 1109 FT_Memory memory = font->memory; 1110 FT_Error error = FT_Err_Ok; 1111 1112 FT_UNUSED( lineno ); /* only used in debug mode */ 1113 1114 1115 /* First, check whether the property already exists in the font. */ 1116 if ( ( propid = ft_hash_str_lookup( name, 1117 (FT_Hash)font->internal ) ) != NULL ) 1118 { 1119 /* The property already exists in the font, so simply replace */ 1120 /* the value of the property with the current value. */ 1121 fp = font->props + *propid; 1122 1123 switch ( fp->format ) 1124 { 1125 case BDF_ATOM: 1126 /* Delete the current atom if it exists. */ 1127 FT_FREE( fp->value.atom ); 1128 1129 if ( value && value[0] != 0 ) 1130 { 1131 if ( FT_STRDUP( fp->value.atom, value ) ) 1132 goto Exit; 1133 } 1134 break; 1135 1136 case BDF_INTEGER: 1137 fp->value.l = _bdf_atol( value ); 1138 break; 1139 1140 case BDF_CARDINAL: 1141 fp->value.ul = _bdf_atoul( value ); 1142 break; 1143 1144 default: 1145 ; 1146 } 1147 1148 goto Exit; 1149 } 1150 1151 /* See whether this property type exists yet or not. */ 1152 /* If not, create it. */ 1153 propid = ft_hash_str_lookup( name, &(font->proptbl) ); 1154 if ( !propid ) 1155 { 1156 error = bdf_create_property( name, BDF_ATOM, font ); 1157 if ( error ) 1158 goto Exit; 1159 propid = ft_hash_str_lookup( name, &(font->proptbl) ); 1160 } 1161 1162 /* Allocate another property if this is overflowing. */ 1163 if ( font->props_used == font->props_size ) 1164 { 1165 if ( font->props_size == 0 ) 1166 { 1167 if ( FT_NEW_ARRAY( font->props, 1 ) ) 1168 goto Exit; 1169 } 1170 else 1171 { 1172 if ( FT_RENEW_ARRAY( font->props, 1173 font->props_size, 1174 font->props_size + 1 ) ) 1175 goto Exit; 1176 } 1177 1178 fp = font->props + font->props_size; 1179 FT_ZERO( fp ); 1180 font->props_size++; 1181 } 1182 1183 if ( *propid >= _num_bdf_properties ) 1184 prop = font->user_props + ( *propid - _num_bdf_properties ); 1185 else 1186 prop = (bdf_property_t*)_bdf_properties + *propid; 1187 1188 fp = font->props + font->props_used; 1189 1190 fp->name = prop->name; 1191 fp->format = prop->format; 1192 fp->builtin = prop->builtin; 1193 1194 switch ( prop->format ) 1195 { 1196 case BDF_ATOM: 1197 fp->value.atom = 0; 1198 if ( value != 0 && value[0] ) 1199 { 1200 if ( FT_STRDUP( fp->value.atom, value ) ) 1201 goto Exit; 1202 } 1203 break; 1204 1205 case BDF_INTEGER: 1206 fp->value.l = _bdf_atol( value ); 1207 break; 1208 1209 case BDF_CARDINAL: 1210 fp->value.ul = _bdf_atoul( value ); 1211 break; 1212 } 1213 1214 /* If the property happens to be a comment, then it doesn't need */ 1215 /* to be added to the internal hash table. */ 1216 if ( _bdf_strncmp( name, "COMMENT", 7 ) != 0 ) 1217 { 1218 /* Add the property to the font property table. */ 1219 error = ft_hash_str_insert( fp->name, 1220 font->props_used, 1221 (FT_Hash)font->internal, 1222 memory ); 1223 if ( error ) 1224 goto Exit; 1225 } 1226 1227 font->props_used++; 1228 1229 /* Some special cases need to be handled here. The DEFAULT_CHAR */ 1230 /* property needs to be located if it exists in the property list, the */ 1231 /* FONT_ASCENT and FONT_DESCENT need to be assigned if they are */ 1232 /* present, and the SPACING property should override the default */ 1233 /* spacing. */ 1234 if ( _bdf_strncmp( name, "DEFAULT_CHAR", 12 ) == 0 ) 1235 font->default_char = fp->value.l; 1236 else if ( _bdf_strncmp( name, "FONT_ASCENT", 11 ) == 0 ) 1237 font->font_ascent = fp->value.l; 1238 else if ( _bdf_strncmp( name, "FONT_DESCENT", 12 ) == 0 ) 1239 font->font_descent = fp->value.l; 1240 else if ( _bdf_strncmp( name, "SPACING", 7 ) == 0 ) 1241 { 1242 if ( !fp->value.atom ) 1243 { 1244 FT_ERROR(( "_bdf_add_property: " ERRMSG8, lineno, "SPACING" )); 1245 error = FT_THROW( Invalid_File_Format ); 1246 goto Exit; 1247 } 1248 1249 if ( fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P' ) 1250 font->spacing = BDF_PROPORTIONAL; 1251 else if ( fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M' ) 1252 font->spacing = BDF_MONOWIDTH; 1253 else if ( fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C' ) 1254 font->spacing = BDF_CHARCELL; 1255 } 1256 1257 Exit: 1258 return error; 1259 } 1260 1261 1262 static const unsigned char nibble_mask[8] = 1263 { 1264 0xFF, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE 1265 }; 1266 1267 1268 /* Actually parse the glyph info and bitmaps. */ 1269 static FT_Error 1270 _bdf_parse_glyphs( char* line, 1271 unsigned long linelen, 1272 unsigned long lineno, 1273 void* call_data, 1274 void* client_data ) 1275 { 1276 int c, mask_index; 1277 char* s; 1278 unsigned char* bp; 1279 unsigned long i, slen, nibbles; 1280 1281 _bdf_parse_t* p; 1282 bdf_glyph_t* glyph; 1283 bdf_font_t* font; 1284 1285 FT_Memory memory; 1286 FT_Error error = FT_Err_Ok; 1287 1288 FT_UNUSED( call_data ); 1289 FT_UNUSED( lineno ); /* only used in debug mode */ 1290 1291 1292 p = (_bdf_parse_t *)client_data; 1293 1294 font = p->font; 1295 memory = font->memory; 1296 1297 /* Check for a comment. */ 1298 if ( _bdf_strncmp( line, "COMMENT", 7 ) == 0 ) 1299 { 1300 linelen -= 7; 1301 1302 s = line + 7; 1303 if ( *s != 0 ) 1304 { 1305 s++; 1306 linelen--; 1307 } 1308 error = _bdf_add_comment( p->font, s, linelen ); 1309 goto Exit; 1310 } 1311 1312 /* The very first thing expected is the number of glyphs. */ 1313 if ( !( p->flags & BDF_GLYPHS_ ) ) 1314 { 1315 if ( _bdf_strncmp( line, "CHARS", 5 ) != 0 ) 1316 { 1317 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "CHARS" )); 1318 error = FT_THROW( Missing_Chars_Field ); 1319 goto Exit; 1320 } 1321 1322 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 1323 if ( error ) 1324 goto Exit; 1325 p->cnt = font->glyphs_size = _bdf_atoul( p->list.field[1] ); 1326 1327 /* We need at least 20 bytes per glyph. */ 1328 if ( p->cnt > p->size / 20 ) 1329 { 1330 p->cnt = font->glyphs_size = p->size / 20; 1331 FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG17, p->cnt )); 1332 } 1333 1334 /* Make sure the number of glyphs is non-zero. */ 1335 if ( p->cnt == 0 ) 1336 font->glyphs_size = 64; 1337 1338 /* Limit ourselves to 1,114,112 glyphs in the font (this is the */ 1339 /* number of code points available in Unicode). */ 1340 if ( p->cnt >= 0x110000UL ) 1341 { 1342 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG5, lineno, "CHARS" )); 1343 error = FT_THROW( Invalid_Argument ); 1344 goto Exit; 1345 } 1346 1347 if ( FT_NEW_ARRAY( font->glyphs, font->glyphs_size ) ) 1348 goto Exit; 1349 1350 p->flags |= BDF_GLYPHS_; 1351 1352 goto Exit; 1353 } 1354 1355 /* Check for the ENDFONT field. */ 1356 if ( _bdf_strncmp( line, "ENDFONT", 7 ) == 0 ) 1357 { 1358 if ( p->flags & BDF_GLYPH_BITS_ ) 1359 { 1360 /* Missing ENDCHAR field. */ 1361 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "ENDCHAR" )); 1362 error = FT_THROW( Corrupted_Font_Glyphs ); 1363 goto Exit; 1364 } 1365 1366 /* Sort the glyphs by encoding. */ 1367 ft_qsort( (char *)font->glyphs, 1368 font->glyphs_used, 1369 sizeof ( bdf_glyph_t ), 1370 by_encoding ); 1371 1372 p->flags &= ~BDF_START_; 1373 1374 goto Exit; 1375 } 1376 1377 /* Check for the ENDCHAR field. */ 1378 if ( _bdf_strncmp( line, "ENDCHAR", 7 ) == 0 ) 1379 { 1380 p->glyph_enc = 0; 1381 p->flags &= ~BDF_GLYPH_BITS_; 1382 1383 goto Exit; 1384 } 1385 1386 /* Check whether a glyph is being scanned but should be */ 1387 /* ignored because it is an unencoded glyph. */ 1388 if ( ( p->flags & BDF_GLYPH_ ) && 1389 p->glyph_enc == -1 && 1390 p->opts->keep_unencoded == 0 ) 1391 goto Exit; 1392 1393 /* Check for the STARTCHAR field. */ 1394 if ( _bdf_strncmp( line, "STARTCHAR", 9 ) == 0 ) 1395 { 1396 if ( p->flags & BDF_GLYPH_BITS_ ) 1397 { 1398 /* Missing ENDCHAR field. */ 1399 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "ENDCHAR" )); 1400 error = FT_THROW( Missing_Startchar_Field ); 1401 goto Exit; 1402 } 1403 1404 /* Set the character name in the parse info first until the */ 1405 /* encoding can be checked for an unencoded character. */ 1406 FT_FREE( p->glyph_name ); 1407 1408 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 1409 if ( error ) 1410 goto Exit; 1411 1412 _bdf_list_shift( &p->list, 1 ); 1413 1414 s = _bdf_list_join( &p->list, ' ', &slen ); 1415 1416 if ( !s ) 1417 { 1418 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG8, lineno, "STARTCHAR" )); 1419 error = FT_THROW( Invalid_File_Format ); 1420 goto Exit; 1421 } 1422 1423 if ( FT_NEW_ARRAY( p->glyph_name, slen + 1 ) ) 1424 goto Exit; 1425 1426 FT_MEM_COPY( p->glyph_name, s, slen + 1 ); 1427 1428 p->flags |= BDF_GLYPH_; 1429 1430 FT_TRACE4(( DBGMSG1, lineno, s )); 1431 1432 goto Exit; 1433 } 1434 1435 /* Check for the ENCODING field. */ 1436 if ( _bdf_strncmp( line, "ENCODING", 8 ) == 0 ) 1437 { 1438 if ( !( p->flags & BDF_GLYPH_ ) ) 1439 { 1440 /* Missing STARTCHAR field. */ 1441 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "STARTCHAR" )); 1442 error = FT_THROW( Missing_Startchar_Field ); 1443 goto Exit; 1444 } 1445 1446 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 1447 if ( error ) 1448 goto Exit; 1449 1450 p->glyph_enc = _bdf_atol( p->list.field[1] ); 1451 1452 /* Normalize negative encoding values. The specification only */ 1453 /* allows -1, but we can be more generous here. */ 1454 if ( p->glyph_enc < -1 ) 1455 p->glyph_enc = -1; 1456 1457 /* Check for alternative encoding format. */ 1458 if ( p->glyph_enc == -1 && p->list.used > 2 ) 1459 p->glyph_enc = _bdf_atol( p->list.field[2] ); 1460 1461 if ( p->glyph_enc < -1 ) 1462 p->glyph_enc = -1; 1463 1464 FT_TRACE4(( DBGMSG2, p->glyph_enc )); 1465 1466 /* Check that the encoding is in the Unicode range because */ 1467 /* otherwise p->have (a bitmap with static size) overflows. */ 1468 if ( p->glyph_enc > 0 && 1469 (size_t)p->glyph_enc >= sizeof ( p->have ) / 1470 sizeof ( unsigned long ) * 32 ) 1471 { 1472 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG5, lineno, "ENCODING" )); 1473 error = FT_THROW( Invalid_File_Format ); 1474 goto Exit; 1475 } 1476 1477 /* Check whether this encoding has already been encountered. */ 1478 /* If it has then change it to unencoded so it gets added if */ 1479 /* indicated. */ 1480 if ( p->glyph_enc >= 0 ) 1481 { 1482 if ( _bdf_glyph_modified( p->have, p->glyph_enc ) ) 1483 { 1484 /* Emit a message saying a glyph has been moved to the */ 1485 /* unencoded area. */ 1486 FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG12, 1487 p->glyph_enc, p->glyph_name )); 1488 p->glyph_enc = -1; 1489 font->modified = 1; 1490 } 1491 else 1492 _bdf_set_glyph_modified( p->have, p->glyph_enc ); 1493 } 1494 1495 if ( p->glyph_enc >= 0 ) 1496 { 1497 /* Make sure there are enough glyphs allocated in case the */ 1498 /* number of characters happen to be wrong. */ 1499 if ( font->glyphs_used == font->glyphs_size ) 1500 { 1501 if ( FT_RENEW_ARRAY( font->glyphs, 1502 font->glyphs_size, 1503 font->glyphs_size + 64 ) ) 1504 goto Exit; 1505 1506 font->glyphs_size += 64; 1507 } 1508 1509 glyph = font->glyphs + font->glyphs_used++; 1510 glyph->name = p->glyph_name; 1511 glyph->encoding = p->glyph_enc; 1512 1513 /* Reset the initial glyph info. */ 1514 p->glyph_name = NULL; 1515 } 1516 else 1517 { 1518 /* Unencoded glyph. Check whether it should */ 1519 /* be added or not. */ 1520 if ( p->opts->keep_unencoded != 0 ) 1521 { 1522 /* Allocate the next unencoded glyph. */ 1523 if ( font->unencoded_used == font->unencoded_size ) 1524 { 1525 if ( FT_RENEW_ARRAY( font->unencoded , 1526 font->unencoded_size, 1527 font->unencoded_size + 4 ) ) 1528 goto Exit; 1529 1530 font->unencoded_size += 4; 1531 } 1532 1533 glyph = font->unencoded + font->unencoded_used; 1534 glyph->name = p->glyph_name; 1535 glyph->encoding = (long)font->unencoded_used++; 1536 1537 /* Reset the initial glyph info. */ 1538 p->glyph_name = NULL; 1539 } 1540 else 1541 { 1542 /* Free up the glyph name if the unencoded shouldn't be */ 1543 /* kept. */ 1544 FT_FREE( p->glyph_name ); 1545 } 1546 1547 p->glyph_name = NULL; 1548 } 1549 1550 /* Clear the flags that might be added when width and height are */ 1551 /* checked for consistency. */ 1552 p->flags &= ~( BDF_GLYPH_WIDTH_CHECK_ | BDF_GLYPH_HEIGHT_CHECK_ ); 1553 1554 p->flags |= BDF_ENCODING_; 1555 1556 goto Exit; 1557 } 1558 1559 /* Point at the glyph being constructed. */ 1560 if ( p->glyph_enc == -1 ) 1561 glyph = font->unencoded + ( font->unencoded_used - 1 ); 1562 else 1563 glyph = font->glyphs + ( font->glyphs_used - 1 ); 1564 1565 /* Check whether a bitmap is being constructed. */ 1566 if ( p->flags & BDF_BITMAP_ ) 1567 { 1568 /* If there are more rows than are specified in the glyph metrics, */ 1569 /* ignore the remaining lines. */ 1570 if ( p->row >= (unsigned long)glyph->bbx.height ) 1571 { 1572 if ( !( p->flags & BDF_GLYPH_HEIGHT_CHECK_ ) ) 1573 { 1574 FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG13, glyph->encoding )); 1575 p->flags |= BDF_GLYPH_HEIGHT_CHECK_; 1576 font->modified = 1; 1577 } 1578 1579 goto Exit; 1580 } 1581 1582 /* Only collect the number of nibbles indicated by the glyph */ 1583 /* metrics. If there are more columns, they are simply ignored. */ 1584 nibbles = glyph->bpr << 1; 1585 bp = glyph->bitmap + p->row * glyph->bpr; 1586 1587 for ( i = 0; i < nibbles; i++ ) 1588 { 1589 c = line[i]; 1590 if ( !sbitset( hdigits, c ) ) 1591 break; 1592 *bp = (FT_Byte)( ( *bp << 4 ) + a2i[c] ); 1593 if ( i + 1 < nibbles && ( i & 1 ) ) 1594 *++bp = 0; 1595 } 1596 1597 /* If any line has not enough columns, */ 1598 /* indicate they have been padded with zero bits. */ 1599 if ( i < nibbles && 1600 !( p->flags & BDF_GLYPH_WIDTH_CHECK_ ) ) 1601 { 1602 FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG16, glyph->encoding )); 1603 p->flags |= BDF_GLYPH_WIDTH_CHECK_; 1604 font->modified = 1; 1605 } 1606 1607 /* Remove possible garbage at the right. */ 1608 mask_index = ( glyph->bbx.width * p->font->bpp ) & 7; 1609 if ( glyph->bbx.width ) 1610 *bp &= nibble_mask[mask_index]; 1611 1612 /* If any line has extra columns, indicate they have been removed. */ 1613 if ( i == nibbles && 1614 sbitset( hdigits, line[nibbles] ) && 1615 !( p->flags & BDF_GLYPH_WIDTH_CHECK_ ) ) 1616 { 1617 FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG14, glyph->encoding )); 1618 p->flags |= BDF_GLYPH_WIDTH_CHECK_; 1619 font->modified = 1; 1620 } 1621 1622 p->row++; 1623 goto Exit; 1624 } 1625 1626 /* Expect the SWIDTH (scalable width) field next. */ 1627 if ( _bdf_strncmp( line, "SWIDTH", 6 ) == 0 ) 1628 { 1629 if ( !( p->flags & BDF_ENCODING_ ) ) 1630 goto Missing_Encoding; 1631 1632 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 1633 if ( error ) 1634 goto Exit; 1635 1636 glyph->swidth = (unsigned short)_bdf_atoul( p->list.field[1] ); 1637 p->flags |= BDF_SWIDTH_; 1638 1639 goto Exit; 1640 } 1641 1642 /* Expect the DWIDTH (scalable width) field next. */ 1643 if ( _bdf_strncmp( line, "DWIDTH", 6 ) == 0 ) 1644 { 1645 if ( !( p->flags & BDF_ENCODING_ ) ) 1646 goto Missing_Encoding; 1647 1648 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 1649 if ( error ) 1650 goto Exit; 1651 1652 glyph->dwidth = (unsigned short)_bdf_atoul( p->list.field[1] ); 1653 1654 if ( !( p->flags & BDF_SWIDTH_ ) ) 1655 { 1656 /* Missing SWIDTH field. Emit an auto correction message and set */ 1657 /* the scalable width from the device width. */ 1658 FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG9, lineno )); 1659 1660 glyph->swidth = (unsigned short)FT_MulDiv( 1661 glyph->dwidth, 72000L, 1662 (FT_Long)( font->point_size * 1663 font->resolution_x ) ); 1664 } 1665 1666 p->flags |= BDF_DWIDTH_; 1667 goto Exit; 1668 } 1669 1670 /* Expect the BBX field next. */ 1671 if ( _bdf_strncmp( line, "BBX", 3 ) == 0 ) 1672 { 1673 if ( !( p->flags & BDF_ENCODING_ ) ) 1674 goto Missing_Encoding; 1675 1676 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 1677 if ( error ) 1678 goto Exit; 1679 1680 glyph->bbx.width = _bdf_atous( p->list.field[1] ); 1681 glyph->bbx.height = _bdf_atous( p->list.field[2] ); 1682 glyph->bbx.x_offset = _bdf_atos( p->list.field[3] ); 1683 glyph->bbx.y_offset = _bdf_atos( p->list.field[4] ); 1684 1685 /* Generate the ascent and descent of the character. */ 1686 glyph->bbx.ascent = (short)( glyph->bbx.height + glyph->bbx.y_offset ); 1687 glyph->bbx.descent = (short)( -glyph->bbx.y_offset ); 1688 1689 /* Determine the overall font bounding box as the characters are */ 1690 /* loaded so corrections can be done later if indicated. */ 1691 p->maxas = (short)FT_MAX( glyph->bbx.ascent, p->maxas ); 1692 p->maxds = (short)FT_MAX( glyph->bbx.descent, p->maxds ); 1693 1694 p->rbearing = (short)( glyph->bbx.width + glyph->bbx.x_offset ); 1695 1696 p->maxrb = (short)FT_MAX( p->rbearing, p->maxrb ); 1697 p->minlb = (short)FT_MIN( glyph->bbx.x_offset, p->minlb ); 1698 p->maxlb = (short)FT_MAX( glyph->bbx.x_offset, p->maxlb ); 1699 1700 if ( !( p->flags & BDF_DWIDTH_ ) ) 1701 { 1702 /* Missing DWIDTH field. Emit an auto correction message and set */ 1703 /* the device width to the glyph width. */ 1704 FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG10, lineno )); 1705 glyph->dwidth = glyph->bbx.width; 1706 } 1707 1708 /* If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH */ 1709 /* value if necessary. */ 1710 if ( p->opts->correct_metrics != 0 ) 1711 { 1712 /* Determine the point size of the glyph. */ 1713 unsigned short sw = (unsigned short)FT_MulDiv( 1714 glyph->dwidth, 72000L, 1715 (FT_Long)( font->point_size * 1716 font->resolution_x ) ); 1717 1718 1719 if ( sw != glyph->swidth ) 1720 { 1721 glyph->swidth = sw; 1722 1723 if ( p->glyph_enc == -1 ) 1724 _bdf_set_glyph_modified( font->umod, 1725 font->unencoded_used - 1 ); 1726 else 1727 _bdf_set_glyph_modified( font->nmod, glyph->encoding ); 1728 1729 p->flags |= BDF_SWIDTH_ADJ_; 1730 font->modified = 1; 1731 } 1732 } 1733 1734 p->flags |= BDF_BBX_; 1735 goto Exit; 1736 } 1737 1738 /* And finally, gather up the bitmap. */ 1739 if ( _bdf_strncmp( line, "BITMAP", 6 ) == 0 ) 1740 { 1741 unsigned long bitmap_size; 1742 1743 1744 if ( !( p->flags & BDF_BBX_ ) ) 1745 { 1746 /* Missing BBX field. */ 1747 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "BBX" )); 1748 error = FT_THROW( Missing_Bbx_Field ); 1749 goto Exit; 1750 } 1751 1752 /* Allocate enough space for the bitmap. */ 1753 glyph->bpr = ( glyph->bbx.width * p->font->bpp + 7 ) >> 3; 1754 1755 bitmap_size = glyph->bpr * glyph->bbx.height; 1756 if ( glyph->bpr > 0xFFFFU || bitmap_size > 0xFFFFU ) 1757 { 1758 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG4, lineno )); 1759 error = FT_THROW( Bbx_Too_Big ); 1760 goto Exit; 1761 } 1762 else 1763 glyph->bytes = (unsigned short)bitmap_size; 1764 1765 if ( FT_NEW_ARRAY( glyph->bitmap, glyph->bytes ) ) 1766 goto Exit; 1767 1768 p->row = 0; 1769 p->flags |= BDF_BITMAP_; 1770 1771 goto Exit; 1772 } 1773 1774 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG9, lineno )); 1775 error = FT_THROW( Invalid_File_Format ); 1776 goto Exit; 1777 1778 Missing_Encoding: 1779 /* Missing ENCODING field. */ 1780 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "ENCODING" )); 1781 error = FT_THROW( Missing_Encoding_Field ); 1782 1783 Exit: 1784 if ( error && ( p->flags & BDF_GLYPH_ ) ) 1785 FT_FREE( p->glyph_name ); 1786 1787 return error; 1788 } 1789 1790 1791 /* Load the font properties. */ 1792 static FT_Error 1793 _bdf_parse_properties( char* line, 1794 unsigned long linelen, 1795 unsigned long lineno, 1796 void* call_data, 1797 void* client_data ) 1798 { 1799 unsigned long vlen; 1800 _bdf_line_func_t* next; 1801 _bdf_parse_t* p; 1802 char* name; 1803 char* value; 1804 char nbuf[128]; 1805 FT_Error error = FT_Err_Ok; 1806 1807 FT_UNUSED( lineno ); 1808 1809 1810 next = (_bdf_line_func_t *)call_data; 1811 p = (_bdf_parse_t *) client_data; 1812 1813 /* Check for the end of the properties. */ 1814 if ( _bdf_strncmp( line, "ENDPROPERTIES", 13 ) == 0 ) 1815 { 1816 /* If the FONT_ASCENT or FONT_DESCENT properties have not been */ 1817 /* encountered yet, then make sure they are added as properties and */ 1818 /* make sure they are set from the font bounding box info. */ 1819 /* */ 1820 /* This is *always* done regardless of the options, because X11 */ 1821 /* requires these two fields to compile fonts. */ 1822 if ( bdf_get_font_property( p->font, "FONT_ASCENT" ) == 0 ) 1823 { 1824 p->font->font_ascent = p->font->bbx.ascent; 1825 ft_sprintf( nbuf, "%hd", p->font->bbx.ascent ); 1826 error = _bdf_add_property( p->font, (char *)"FONT_ASCENT", 1827 nbuf, lineno ); 1828 if ( error ) 1829 goto Exit; 1830 1831 FT_TRACE2(( "_bdf_parse_properties: " ACMSG1, p->font->bbx.ascent )); 1832 p->font->modified = 1; 1833 } 1834 1835 if ( bdf_get_font_property( p->font, "FONT_DESCENT" ) == 0 ) 1836 { 1837 p->font->font_descent = p->font->bbx.descent; 1838 ft_sprintf( nbuf, "%hd", p->font->bbx.descent ); 1839 error = _bdf_add_property( p->font, (char *)"FONT_DESCENT", 1840 nbuf, lineno ); 1841 if ( error ) 1842 goto Exit; 1843 1844 FT_TRACE2(( "_bdf_parse_properties: " ACMSG2, p->font->bbx.descent )); 1845 p->font->modified = 1; 1846 } 1847 1848 p->flags &= ~BDF_PROPS_; 1849 *next = _bdf_parse_glyphs; 1850 1851 goto Exit; 1852 } 1853 1854 /* Ignore the _XFREE86_GLYPH_RANGES properties. */ 1855 if ( _bdf_strncmp( line, "_XFREE86_GLYPH_RANGES", 21 ) == 0 ) 1856 goto Exit; 1857 1858 /* Handle COMMENT fields and properties in a special way to preserve */ 1859 /* the spacing. */ 1860 if ( _bdf_strncmp( line, "COMMENT", 7 ) == 0 ) 1861 { 1862 name = value = line; 1863 value += 7; 1864 if ( *value ) 1865 *value++ = 0; 1866 error = _bdf_add_property( p->font, name, value, lineno ); 1867 if ( error ) 1868 goto Exit; 1869 } 1870 else if ( _bdf_is_atom( line, linelen, &name, &value, p->font ) ) 1871 { 1872 error = _bdf_add_property( p->font, name, value, lineno ); 1873 if ( error ) 1874 goto Exit; 1875 } 1876 else 1877 { 1878 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 1879 if ( error ) 1880 goto Exit; 1881 name = p->list.field[0]; 1882 1883 _bdf_list_shift( &p->list, 1 ); 1884 value = _bdf_list_join( &p->list, ' ', &vlen ); 1885 1886 error = _bdf_add_property( p->font, name, value, lineno ); 1887 if ( error ) 1888 goto Exit; 1889 } 1890 1891 Exit: 1892 return error; 1893 } 1894 1895 1896 /* Load the font header. */ 1897 static FT_Error 1898 _bdf_parse_start( char* line, 1899 unsigned long linelen, 1900 unsigned long lineno, 1901 void* call_data, 1902 void* client_data ) 1903 { 1904 unsigned long slen; 1905 _bdf_line_func_t* next; 1906 _bdf_parse_t* p; 1907 bdf_font_t* font; 1908 char *s; 1909 1910 FT_Memory memory = NULL; 1911 FT_Error error = FT_Err_Ok; 1912 1913 FT_UNUSED( lineno ); /* only used in debug mode */ 1914 1915 1916 next = (_bdf_line_func_t *)call_data; 1917 p = (_bdf_parse_t *) client_data; 1918 1919 if ( p->font ) 1920 memory = p->font->memory; 1921 1922 /* Check for a comment. This is done to handle those fonts that have */ 1923 /* comments before the STARTFONT line for some reason. */ 1924 if ( _bdf_strncmp( line, "COMMENT", 7 ) == 0 ) 1925 { 1926 if ( p->opts->keep_comments != 0 && p->font != 0 ) 1927 { 1928 linelen -= 7; 1929 1930 s = line + 7; 1931 if ( *s != 0 ) 1932 { 1933 s++; 1934 linelen--; 1935 } 1936 1937 error = _bdf_add_comment( p->font, s, linelen ); 1938 if ( error ) 1939 goto Exit; 1940 /* here font is not defined! */ 1941 } 1942 1943 goto Exit; 1944 } 1945 1946 if ( !( p->flags & BDF_START_ ) ) 1947 { 1948 memory = p->memory; 1949 1950 if ( _bdf_strncmp( line, "STARTFONT", 9 ) != 0 ) 1951 { 1952 /* we don't emit an error message since this code gets */ 1953 /* explicitly caught one level higher */ 1954 error = FT_THROW( Missing_Startfont_Field ); 1955 goto Exit; 1956 } 1957 1958 p->flags = BDF_START_; 1959 font = p->font = 0; 1960 1961 if ( FT_NEW( font ) ) 1962 goto Exit; 1963 p->font = font; 1964 1965 font->memory = p->memory; 1966 p->memory = 0; 1967 1968 { /* setup */ 1969 size_t i; 1970 bdf_property_t* prop; 1971 1972 1973 error = ft_hash_str_init( &(font->proptbl), memory ); 1974 if ( error ) 1975 goto Exit; 1976 for ( i = 0, prop = (bdf_property_t*)_bdf_properties; 1977 i < _num_bdf_properties; i++, prop++ ) 1978 { 1979 error = ft_hash_str_insert( prop->name, i, 1980 &(font->proptbl), memory ); 1981 if ( error ) 1982 goto Exit; 1983 } 1984 } 1985 1986 if ( FT_ALLOC( p->font->internal, sizeof ( FT_HashRec ) ) ) 1987 goto Exit; 1988 error = ft_hash_str_init( (FT_Hash)p->font->internal, memory ); 1989 if ( error ) 1990 goto Exit; 1991 p->font->spacing = p->opts->font_spacing; 1992 p->font->default_char = -1; 1993 1994 goto Exit; 1995 } 1996 1997 /* Check for the start of the properties. */ 1998 if ( _bdf_strncmp( line, "STARTPROPERTIES", 15 ) == 0 ) 1999 { 2000 if ( !( p->flags & BDF_FONT_BBX_ ) ) 2001 { 2002 /* Missing the FONTBOUNDINGBOX field. */ 2003 FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "FONTBOUNDINGBOX" )); 2004 error = FT_THROW( Missing_Fontboundingbox_Field ); 2005 goto Exit; 2006 } 2007 2008 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 2009 if ( error ) 2010 goto Exit; 2011 2012 /* at this point, `p->font' can't be NULL */ 2013 p->cnt = p->font->props_size = _bdf_atoul( p->list.field[1] ); 2014 /* We need at least 4 bytes per property. */ 2015 if ( p->cnt > p->size / 4 ) 2016 { 2017 p->font->props_size = 0; 2018 2019 FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG5, lineno, "STARTPROPERTIES" )); 2020 error = FT_THROW( Invalid_Argument ); 2021 goto Exit; 2022 } 2023 2024 if ( FT_NEW_ARRAY( p->font->props, p->cnt ) ) 2025 { 2026 p->font->props_size = 0; 2027 goto Exit; 2028 } 2029 2030 p->flags |= BDF_PROPS_; 2031 *next = _bdf_parse_properties; 2032 2033 goto Exit; 2034 } 2035 2036 /* Check for the FONTBOUNDINGBOX field. */ 2037 if ( _bdf_strncmp( line, "FONTBOUNDINGBOX", 15 ) == 0 ) 2038 { 2039 if ( !( p->flags & BDF_SIZE_ ) ) 2040 { 2041 /* Missing the SIZE field. */ 2042 FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "SIZE" )); 2043 error = FT_THROW( Missing_Size_Field ); 2044 goto Exit; 2045 } 2046 2047 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 2048 if ( error ) 2049 goto Exit; 2050 2051 p->font->bbx.width = _bdf_atous( p->list.field[1] ); 2052 p->font->bbx.height = _bdf_atous( p->list.field[2] ); 2053 2054 p->font->bbx.x_offset = _bdf_atos( p->list.field[3] ); 2055 p->font->bbx.y_offset = _bdf_atos( p->list.field[4] ); 2056 2057 p->font->bbx.ascent = (short)( p->font->bbx.height + 2058 p->font->bbx.y_offset ); 2059 2060 p->font->bbx.descent = (short)( -p->font->bbx.y_offset ); 2061 2062 p->flags |= BDF_FONT_BBX_; 2063 2064 goto Exit; 2065 } 2066 2067 /* The next thing to check for is the FONT field. */ 2068 if ( _bdf_strncmp( line, "FONT", 4 ) == 0 ) 2069 { 2070 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 2071 if ( error ) 2072 goto Exit; 2073 _bdf_list_shift( &p->list, 1 ); 2074 2075 s = _bdf_list_join( &p->list, ' ', &slen ); 2076 2077 if ( !s ) 2078 { 2079 FT_ERROR(( "_bdf_parse_start: " ERRMSG8, lineno, "FONT" )); 2080 error = FT_THROW( Invalid_File_Format ); 2081 goto Exit; 2082 } 2083 2084 /* Allowing multiple `FONT' lines (which is invalid) doesn't hurt... */ 2085 FT_FREE( p->font->name ); 2086 2087 if ( FT_NEW_ARRAY( p->font->name, slen + 1 ) ) 2088 goto Exit; 2089 FT_MEM_COPY( p->font->name, s, slen + 1 ); 2090 2091 /* If the font name is an XLFD name, set the spacing to the one in */ 2092 /* the font name. If there is no spacing fall back on the default. */ 2093 error = _bdf_set_default_spacing( p->font, p->opts, lineno ); 2094 if ( error ) 2095 goto Exit; 2096 2097 p->flags |= BDF_FONT_NAME_; 2098 2099 goto Exit; 2100 } 2101 2102 /* Check for the SIZE field. */ 2103 if ( _bdf_strncmp( line, "SIZE", 4 ) == 0 ) 2104 { 2105 if ( !( p->flags & BDF_FONT_NAME_ ) ) 2106 { 2107 /* Missing the FONT field. */ 2108 FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "FONT" )); 2109 error = FT_THROW( Missing_Font_Field ); 2110 goto Exit; 2111 } 2112 2113 error = _bdf_list_split( &p->list, (char *)" +", line, linelen ); 2114 if ( error ) 2115 goto Exit; 2116 2117 p->font->point_size = _bdf_atoul( p->list.field[1] ); 2118 p->font->resolution_x = _bdf_atoul( p->list.field[2] ); 2119 p->font->resolution_y = _bdf_atoul( p->list.field[3] ); 2120 2121 /* Check for the bits per pixel field. */ 2122 if ( p->list.used == 5 ) 2123 { 2124 unsigned short bpp; 2125 2126 2127 bpp = (unsigned short)_bdf_atos( p->list.field[4] ); 2128 2129 /* Only values 1, 2, 4, 8 are allowed for greymap fonts. */ 2130 if ( bpp > 4 ) 2131 p->font->bpp = 8; 2132 else if ( bpp > 2 ) 2133 p->font->bpp = 4; 2134 else if ( bpp > 1 ) 2135 p->font->bpp = 2; 2136 else 2137 p->font->bpp = 1; 2138 2139 if ( p->font->bpp != bpp ) 2140 FT_TRACE2(( "_bdf_parse_start: " ACMSG11, p->font->bpp )); 2141 } 2142 else 2143 p->font->bpp = 1; 2144 2145 p->flags |= BDF_SIZE_; 2146 2147 goto Exit; 2148 } 2149 2150 /* Check for the CHARS field -- font properties are optional */ 2151 if ( _bdf_strncmp( line, "CHARS", 5 ) == 0 ) 2152 { 2153 char nbuf[128]; 2154 2155 2156 if ( !( p->flags & BDF_FONT_BBX_ ) ) 2157 { 2158 /* Missing the FONTBOUNDINGBOX field. */ 2159 FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "FONTBOUNDINGBOX" )); 2160 error = FT_THROW( Missing_Fontboundingbox_Field ); 2161 goto Exit; 2162 } 2163 2164 /* Add the two standard X11 properties which are required */ 2165 /* for compiling fonts. */ 2166 p->font->font_ascent = p->font->bbx.ascent; 2167 ft_sprintf( nbuf, "%hd", p->font->bbx.ascent ); 2168 error = _bdf_add_property( p->font, (char *)"FONT_ASCENT", 2169 nbuf, lineno ); 2170 if ( error ) 2171 goto Exit; 2172 FT_TRACE2(( "_bdf_parse_properties: " ACMSG1, p->font->bbx.ascent )); 2173 2174 p->font->font_descent = p->font->bbx.descent; 2175 ft_sprintf( nbuf, "%hd", p->font->bbx.descent ); 2176 error = _bdf_add_property( p->font, (char *)"FONT_DESCENT", 2177 nbuf, lineno ); 2178 if ( error ) 2179 goto Exit; 2180 FT_TRACE2(( "_bdf_parse_properties: " ACMSG2, p->font->bbx.descent )); 2181 2182 p->font->modified = 1; 2183 2184 *next = _bdf_parse_glyphs; 2185 2186 /* A special return value. */ 2187 error = -1; 2188 goto Exit; 2189 } 2190 2191 FT_ERROR(( "_bdf_parse_start: " ERRMSG9, lineno )); 2192 error = FT_THROW( Invalid_File_Format ); 2193 2194 Exit: 2195 return error; 2196 } 2197 2198 2199 /*************************************************************************/ 2200 /* */ 2201 /* API. */ 2202 /* */ 2203 /*************************************************************************/ 2204 2205 2206 FT_LOCAL_DEF( FT_Error ) 2207 bdf_load_font( FT_Stream stream, 2208 FT_Memory extmemory, 2209 bdf_options_t* opts, 2210 bdf_font_t* *font ) 2211 { 2212 unsigned long lineno = 0; /* make compiler happy */ 2213 _bdf_parse_t *p = NULL; 2214 2215 FT_Memory memory = extmemory; /* needed for FT_NEW */ 2216 FT_Error error = FT_Err_Ok; 2217 2218 2219 if ( FT_NEW( p ) ) 2220 goto Exit; 2221 2222 memory = NULL; 2223 p->opts = (bdf_options_t*)( ( opts != 0 ) ? opts : &_bdf_opts ); 2224 p->minlb = 32767; 2225 p->size = stream->size; 2226 p->memory = extmemory; /* only during font creation */ 2227 2228 _bdf_list_init( &p->list, extmemory ); 2229 2230 error = _bdf_readstream( stream, _bdf_parse_start, 2231 (void *)p, &lineno ); 2232 if ( error ) 2233 goto Fail; 2234 2235 if ( p->font != 0 ) 2236 { 2237 /* If the font is not proportional, set the font's monowidth */ 2238 /* field to the width of the font bounding box. */ 2239 2240 if ( p->font->spacing != BDF_PROPORTIONAL ) 2241 p->font->monowidth = p->font->bbx.width; 2242 2243 /* If the number of glyphs loaded is not that of the original count, */ 2244 /* indicate the difference. */ 2245 if ( p->cnt != p->font->glyphs_used + p->font->unencoded_used ) 2246 { 2247 FT_TRACE2(( "bdf_load_font: " ACMSG15, p->cnt, 2248 p->font->glyphs_used + p->font->unencoded_used )); 2249 p->font->modified = 1; 2250 } 2251 2252 /* Once the font has been loaded, adjust the overall font metrics if */ 2253 /* necessary. */ 2254 if ( p->opts->correct_metrics != 0 && 2255 ( p->font->glyphs_used > 0 || p->font->unencoded_used > 0 ) ) 2256 { 2257 if ( p->maxrb - p->minlb != p->font->bbx.width ) 2258 { 2259 FT_TRACE2(( "bdf_load_font: " ACMSG3, 2260 p->font->bbx.width, p->maxrb - p->minlb )); 2261 p->font->bbx.width = (unsigned short)( p->maxrb - p->minlb ); 2262 p->font->modified = 1; 2263 } 2264 2265 if ( p->font->bbx.x_offset != p->minlb ) 2266 { 2267 FT_TRACE2(( "bdf_load_font: " ACMSG4, 2268 p->font->bbx.x_offset, p->minlb )); 2269 p->font->bbx.x_offset = p->minlb; 2270 p->font->modified = 1; 2271 } 2272 2273 if ( p->font->bbx.ascent != p->maxas ) 2274 { 2275 FT_TRACE2(( "bdf_load_font: " ACMSG5, 2276 p->font->bbx.ascent, p->maxas )); 2277 p->font->bbx.ascent = p->maxas; 2278 p->font->modified = 1; 2279 } 2280 2281 if ( p->font->bbx.descent != p->maxds ) 2282 { 2283 FT_TRACE2(( "bdf_load_font: " ACMSG6, 2284 p->font->bbx.descent, p->maxds )); 2285 p->font->bbx.descent = p->maxds; 2286 p->font->bbx.y_offset = (short)( -p->maxds ); 2287 p->font->modified = 1; 2288 } 2289 2290 if ( p->maxas + p->maxds != p->font->bbx.height ) 2291 { 2292 FT_TRACE2(( "bdf_load_font: " ACMSG7, 2293 p->font->bbx.height, p->maxas + p->maxds )); 2294 p->font->bbx.height = (unsigned short)( p->maxas + p->maxds ); 2295 } 2296 2297 if ( p->flags & BDF_SWIDTH_ADJ_ ) 2298 FT_TRACE2(( "bdf_load_font: " ACMSG8 )); 2299 } 2300 } 2301 2302 if ( p->flags & BDF_START_ ) 2303 { 2304 /* The ENDFONT field was never reached or did not exist. */ 2305 if ( !( p->flags & BDF_GLYPHS_ ) ) 2306 { 2307 /* Error happened while parsing header. */ 2308 FT_ERROR(( "bdf_load_font: " ERRMSG2, lineno )); 2309 error = FT_THROW( Corrupted_Font_Header ); 2310 goto Fail; 2311 } 2312 else 2313 { 2314 /* Error happened when parsing glyphs. */ 2315 FT_ERROR(( "bdf_load_font: " ERRMSG3, lineno )); 2316 error = FT_THROW( Corrupted_Font_Glyphs ); 2317 goto Fail; 2318 } 2319 } 2320 2321 if ( p->font != 0 ) 2322 { 2323 /* Make sure the comments are NULL terminated if they exist. */ 2324 memory = p->font->memory; 2325 2326 if ( p->font->comments_len > 0 ) 2327 { 2328 if ( FT_RENEW_ARRAY( p->font->comments, 2329 p->font->comments_len, 2330 p->font->comments_len + 1 ) ) 2331 goto Fail; 2332 2333 p->font->comments[p->font->comments_len] = 0; 2334 } 2335 } 2336 else if ( !error ) 2337 error = FT_THROW( Invalid_File_Format ); 2338 2339 *font = p->font; 2340 2341 Exit: 2342 if ( p ) 2343 { 2344 _bdf_list_done( &p->list ); 2345 2346 memory = extmemory; 2347 2348 FT_FREE( p->glyph_name ); 2349 FT_FREE( p ); 2350 } 2351 2352 return error; 2353 2354 Fail: 2355 bdf_free_font( p->font ); 2356 2357 memory = extmemory; 2358 2359 FT_FREE( p->font ); 2360 2361 goto Exit; 2362 } 2363 2364 2365 FT_LOCAL_DEF( void ) 2366 bdf_free_font( bdf_font_t* font ) 2367 { 2368 bdf_property_t* prop; 2369 unsigned long i; 2370 bdf_glyph_t* glyphs; 2371 FT_Memory memory; 2372 2373 2374 if ( font == 0 ) 2375 return; 2376 2377 memory = font->memory; 2378 2379 FT_FREE( font->name ); 2380 2381 /* Free up the internal hash table of property names. */ 2382 if ( font->internal ) 2383 { 2384 ft_hash_str_free( (FT_Hash)font->internal, memory ); 2385 FT_FREE( font->internal ); 2386 } 2387 2388 /* Free up the comment info. */ 2389 FT_FREE( font->comments ); 2390 2391 /* Free up the properties. */ 2392 for ( i = 0; i < font->props_size; i++ ) 2393 { 2394 if ( font->props[i].format == BDF_ATOM ) 2395 FT_FREE( font->props[i].value.atom ); 2396 } 2397 2398 FT_FREE( font->props ); 2399 2400 /* Free up the character info. */ 2401 for ( i = 0, glyphs = font->glyphs; 2402 i < font->glyphs_used; i++, glyphs++ ) 2403 { 2404 FT_FREE( glyphs->name ); 2405 FT_FREE( glyphs->bitmap ); 2406 } 2407 2408 for ( i = 0, glyphs = font->unencoded; i < font->unencoded_used; 2409 i++, glyphs++ ) 2410 { 2411 FT_FREE( glyphs->name ); 2412 FT_FREE( glyphs->bitmap ); 2413 } 2414 2415 FT_FREE( font->glyphs ); 2416 FT_FREE( font->unencoded ); 2417 2418 /* Free up the overflow storage if it was used. */ 2419 for ( i = 0, glyphs = font->overflow.glyphs; 2420 i < font->overflow.glyphs_used; i++, glyphs++ ) 2421 { 2422 FT_FREE( glyphs->name ); 2423 FT_FREE( glyphs->bitmap ); 2424 } 2425 2426 FT_FREE( font->overflow.glyphs ); 2427 2428 /* bdf_cleanup */ 2429 ft_hash_str_free( &(font->proptbl), memory ); 2430 2431 /* Free up the user defined properties. */ 2432 for ( prop = font->user_props, i = 0; 2433 i < font->nuser_props; i++, prop++ ) 2434 { 2435 FT_FREE( prop->name ); 2436 if ( prop->format == BDF_ATOM ) 2437 FT_FREE( prop->value.atom ); 2438 } 2439 2440 FT_FREE( font->user_props ); 2441 2442 /* FREE( font ); */ /* XXX Fixme */ 2443 } 2444 2445 2446 FT_LOCAL_DEF( bdf_property_t * ) 2447 bdf_get_font_property( bdf_font_t* font, 2448 const char* name ) 2449 { 2450 size_t* propid; 2451 2452 2453 if ( font == 0 || font->props_size == 0 || name == 0 || *name == 0 ) 2454 return 0; 2455 2456 propid = ft_hash_str_lookup( name, (FT_Hash)font->internal ); 2457 2458 return propid ? ( font->props + *propid ) : 0; 2459 } 2460 2461 2462 /* END */ 2463
