1/***************************************************************************/ 2/* */ 3/* afmparse.c */ 4/* */ 5/* AFM parser (body). */ 6/* */ 7/* Copyright 2006, 2007, 2008, 2009, 2010 by */ 8/* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9/* */ 10/* This file is part of the FreeType project, and may only be used, */ 11/* modified, and distributed under the terms of the FreeType project */ 12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13/* this file you indicate that you have read the license and */ 14/* understand and accept it fully. */ 15/* */ 16/***************************************************************************/ 17 18#include <ft2build.h> 19#include FT_FREETYPE_H 20#include FT_INTERNAL_POSTSCRIPT_AUX_H 21 22#include "afmparse.h" 23#include "psconv.h" 24 25#include "psauxerr.h" 26 27 28/***************************************************************************/ 29/* */ 30/* AFM_Stream */ 31/* */ 32/* The use of AFM_Stream is largely inspired by parseAFM.[ch] from t1lib. */ 33/* */ 34/* */ 35 36 enum 37 { 38 AFM_STREAM_STATUS_NORMAL, 39 AFM_STREAM_STATUS_EOC, 40 AFM_STREAM_STATUS_EOL, 41 AFM_STREAM_STATUS_EOF 42 }; 43 44 45 typedef struct AFM_StreamRec_ 46 { 47 FT_Byte* cursor; 48 FT_Byte* base; 49 FT_Byte* limit; 50 51 FT_Int status; 52 53 } AFM_StreamRec; 54 55 56#ifndef EOF 57#define EOF -1 58#endif 59 60 61 /* this works because empty lines are ignored */ 62#define AFM_IS_NEWLINE( ch ) ( (ch) == '\r' || (ch) == '\n' ) 63 64#define AFM_IS_EOF( ch ) ( (ch) == EOF || (ch) == '\x1a' ) 65#define AFM_IS_SPACE( ch ) ( (ch) == ' ' || (ch) == '\t' ) 66 67 /* column separator; there is no `column' in the spec actually */ 68#define AFM_IS_SEP( ch ) ( (ch) == ';' ) 69 70#define AFM_GETC() \ 71 ( ( (stream)->cursor < (stream)->limit ) ? *(stream)->cursor++ \ 72 : EOF ) 73 74#define AFM_STREAM_KEY_BEGIN( stream ) \ 75 (char*)( (stream)->cursor - 1 ) 76 77#define AFM_STREAM_KEY_LEN( stream, key ) \ 78 ( (char*)(stream)->cursor - key - 1 ) 79 80#define AFM_STATUS_EOC( stream ) \ 81 ( (stream)->status >= AFM_STREAM_STATUS_EOC ) 82 83#define AFM_STATUS_EOL( stream ) \ 84 ( (stream)->status >= AFM_STREAM_STATUS_EOL ) 85 86#define AFM_STATUS_EOF( stream ) \ 87 ( (stream)->status >= AFM_STREAM_STATUS_EOF ) 88 89 90 static int 91 afm_stream_skip_spaces( AFM_Stream stream ) 92 { 93 int ch = 0; /* make stupid compiler happy */ 94 95 96 if ( AFM_STATUS_EOC( stream ) ) 97 return ';'; 98 99 while ( 1 ) 100 { 101 ch = AFM_GETC(); 102 if ( !AFM_IS_SPACE( ch ) ) 103 break; 104 } 105 106 if ( AFM_IS_NEWLINE( ch ) ) 107 stream->status = AFM_STREAM_STATUS_EOL; 108 else if ( AFM_IS_SEP( ch ) ) 109 stream->status = AFM_STREAM_STATUS_EOC; 110 else if ( AFM_IS_EOF( ch ) ) 111 stream->status = AFM_STREAM_STATUS_EOF; 112 113 return ch; 114 } 115 116 117 /* read a key or value in current column */ 118 static char* 119 afm_stream_read_one( AFM_Stream stream ) 120 { 121 char* str; 122 int ch; 123 124 125 afm_stream_skip_spaces( stream ); 126 if ( AFM_STATUS_EOC( stream ) ) 127 return NULL; 128 129 str = AFM_STREAM_KEY_BEGIN( stream ); 130 131 while ( 1 ) 132 { 133 ch = AFM_GETC(); 134 if ( AFM_IS_SPACE( ch ) ) 135 break; 136 else if ( AFM_IS_NEWLINE( ch ) ) 137 { 138 stream->status = AFM_STREAM_STATUS_EOL; 139 break; 140 } 141 else if ( AFM_IS_SEP( ch ) ) 142 { 143 stream->status = AFM_STREAM_STATUS_EOC; 144 break; 145 } 146 else if ( AFM_IS_EOF( ch ) ) 147 { 148 stream->status = AFM_STREAM_STATUS_EOF; 149 break; 150 } 151 } 152 153 return str; 154 } 155 156 157 /* read a string (i.e., read to EOL) */ 158 static char* 159 afm_stream_read_string( AFM_Stream stream ) 160 { 161 char* str; 162 int ch; 163 164 165 afm_stream_skip_spaces( stream ); 166 if ( AFM_STATUS_EOL( stream ) ) 167 return NULL; 168 169 str = AFM_STREAM_KEY_BEGIN( stream ); 170 171 /* scan to eol */ 172 while ( 1 ) 173 { 174 ch = AFM_GETC(); 175 if ( AFM_IS_NEWLINE( ch ) ) 176 { 177 stream->status = AFM_STREAM_STATUS_EOL; 178 break; 179 } 180 else if ( AFM_IS_EOF( ch ) ) 181 { 182 stream->status = AFM_STREAM_STATUS_EOF; 183 break; 184 } 185 } 186 187 return str; 188 } 189 190 191 /*************************************************************************/ 192 /* */ 193 /* AFM_Parser */ 194 /* */ 195 /* */ 196 197 /* all keys defined in Ch. 7-10 of 5004.AFM_Spec.pdf */ 198 typedef enum AFM_Token_ 199 { 200 AFM_TOKEN_ASCENDER, 201 AFM_TOKEN_AXISLABEL, 202 AFM_TOKEN_AXISTYPE, 203 AFM_TOKEN_B, 204 AFM_TOKEN_BLENDAXISTYPES, 205 AFM_TOKEN_BLENDDESIGNMAP, 206 AFM_TOKEN_BLENDDESIGNPOSITIONS, 207 AFM_TOKEN_C, 208 AFM_TOKEN_CC, 209 AFM_TOKEN_CH, 210 AFM_TOKEN_CAPHEIGHT, 211 AFM_TOKEN_CHARWIDTH, 212 AFM_TOKEN_CHARACTERSET, 213 AFM_TOKEN_CHARACTERS, 214 AFM_TOKEN_DESCENDER, 215 AFM_TOKEN_ENCODINGSCHEME, 216 AFM_TOKEN_ENDAXIS, 217 AFM_TOKEN_ENDCHARMETRICS, 218 AFM_TOKEN_ENDCOMPOSITES, 219 AFM_TOKEN_ENDDIRECTION, 220 AFM_TOKEN_ENDFONTMETRICS, 221 AFM_TOKEN_ENDKERNDATA, 222 AFM_TOKEN_ENDKERNPAIRS, 223 AFM_TOKEN_ENDTRACKKERN, 224 AFM_TOKEN_ESCCHAR, 225 AFM_TOKEN_FAMILYNAME, 226 AFM_TOKEN_FONTBBOX, 227 AFM_TOKEN_FONTNAME, 228 AFM_TOKEN_FULLNAME, 229 AFM_TOKEN_ISBASEFONT, 230 AFM_TOKEN_ISCIDFONT, 231 AFM_TOKEN_ISFIXEDPITCH, 232 AFM_TOKEN_ISFIXEDV, 233 AFM_TOKEN_ITALICANGLE, 234 AFM_TOKEN_KP, 235 AFM_TOKEN_KPH, 236 AFM_TOKEN_KPX, 237 AFM_TOKEN_KPY, 238 AFM_TOKEN_L, 239 AFM_TOKEN_MAPPINGSCHEME, 240 AFM_TOKEN_METRICSSETS, 241 AFM_TOKEN_N, 242 AFM_TOKEN_NOTICE, 243 AFM_TOKEN_PCC, 244 AFM_TOKEN_STARTAXIS, 245 AFM_TOKEN_STARTCHARMETRICS, 246 AFM_TOKEN_STARTCOMPOSITES, 247 AFM_TOKEN_STARTDIRECTION, 248 AFM_TOKEN_STARTFONTMETRICS, 249 AFM_TOKEN_STARTKERNDATA, 250 AFM_TOKEN_STARTKERNPAIRS, 251 AFM_TOKEN_STARTKERNPAIRS0, 252 AFM_TOKEN_STARTKERNPAIRS1, 253 AFM_TOKEN_STARTTRACKKERN, 254 AFM_TOKEN_STDHW, 255 AFM_TOKEN_STDVW, 256 AFM_TOKEN_TRACKKERN, 257 AFM_TOKEN_UNDERLINEPOSITION, 258 AFM_TOKEN_UNDERLINETHICKNESS, 259 AFM_TOKEN_VV, 260 AFM_TOKEN_VVECTOR, 261 AFM_TOKEN_VERSION, 262 AFM_TOKEN_W, 263 AFM_TOKEN_W0, 264 AFM_TOKEN_W0X, 265 AFM_TOKEN_W0Y, 266 AFM_TOKEN_W1, 267 AFM_TOKEN_W1X, 268 AFM_TOKEN_W1Y, 269 AFM_TOKEN_WX, 270 AFM_TOKEN_WY, 271 AFM_TOKEN_WEIGHT, 272 AFM_TOKEN_WEIGHTVECTOR, 273 AFM_TOKEN_XHEIGHT, 274 N_AFM_TOKENS, 275 AFM_TOKEN_UNKNOWN 276 277 } AFM_Token; 278 279 280 static const char* const afm_key_table[N_AFM_TOKENS] = 281 { 282 "Ascender", 283 "AxisLabel", 284 "AxisType", 285 "B", 286 "BlendAxisTypes", 287 "BlendDesignMap", 288 "BlendDesignPositions", 289 "C", 290 "CC", 291 "CH", 292 "CapHeight", 293 "CharWidth", 294 "CharacterSet", 295 "Characters", 296 "Descender", 297 "EncodingScheme", 298 "EndAxis", 299 "EndCharMetrics", 300 "EndComposites", 301 "EndDirection", 302 "EndFontMetrics", 303 "EndKernData", 304 "EndKernPairs", 305 "EndTrackKern", 306 "EscChar", 307 "FamilyName", 308 "FontBBox", 309 "FontName", 310 "FullName", 311 "IsBaseFont", 312 "IsCIDFont", 313 "IsFixedPitch", 314 "IsFixedV", 315 "ItalicAngle", 316 "KP", 317 "KPH", 318 "KPX", 319 "KPY", 320 "L", 321 "MappingScheme", 322 "MetricsSets", 323 "N", 324 "Notice", 325 "PCC", 326 "StartAxis", 327 "StartCharMetrics", 328 "StartComposites", 329 "StartDirection", 330 "StartFontMetrics", 331 "StartKernData", 332 "StartKernPairs", 333 "StartKernPairs0", 334 "StartKernPairs1", 335 "StartTrackKern", 336 "StdHW", 337 "StdVW", 338 "TrackKern", 339 "UnderlinePosition", 340 "UnderlineThickness", 341 "VV", 342 "VVector", 343 "Version", 344 "W", 345 "W0", 346 "W0X", 347 "W0Y", 348 "W1", 349 "W1X", 350 "W1Y", 351 "WX", 352 "WY", 353 "Weight", 354 "WeightVector", 355 "XHeight" 356 }; 357 358 359 /* 360 * `afm_parser_read_vals' and `afm_parser_next_key' provide 361 * high-level operations to an AFM_Stream. The rest of the 362 * parser functions should use them without accessing the 363 * AFM_Stream directly. 364 */ 365 366 FT_LOCAL_DEF( FT_Int ) 367 afm_parser_read_vals( AFM_Parser parser, 368 AFM_Value vals, 369 FT_UInt n ) 370 { 371 AFM_Stream stream = parser->stream; 372 char* str; 373 FT_UInt i; 374 375 376 if ( n > AFM_MAX_ARGUMENTS ) 377 return 0; 378 379 for ( i = 0; i < n; i++ ) 380 { 381 FT_Offset len; 382 AFM_Value val = vals + i; 383 384 385 if ( val->type == AFM_VALUE_TYPE_STRING ) 386 str = afm_stream_read_string( stream ); 387 else 388 str = afm_stream_read_one( stream ); 389 390 if ( !str ) 391 break; 392 393 len = AFM_STREAM_KEY_LEN( stream, str ); 394 395 switch ( val->type ) 396 { 397 case AFM_VALUE_TYPE_STRING: 398 case AFM_VALUE_TYPE_NAME: 399 { 400 FT_Memory memory = parser->memory; 401 FT_Error error; 402 403 404 if ( !FT_QALLOC( val->u.s, len + 1 ) ) 405 { 406 ft_memcpy( val->u.s, str, len ); 407 val->u.s[len] = '\0'; 408 } 409 } 410 break; 411 412 case AFM_VALUE_TYPE_FIXED: 413 val->u.f = PS_Conv_ToFixed( (FT_Byte**)(void*)&str, 414 (FT_Byte*)str + len, 0 ); 415 break; 416 417 case AFM_VALUE_TYPE_INTEGER: 418 val->u.i = PS_Conv_ToInt( (FT_Byte**)(void*)&str, 419 (FT_Byte*)str + len ); 420 break; 421 422 case AFM_VALUE_TYPE_BOOL: 423 val->u.b = FT_BOOL( len == 4 && 424 !ft_strncmp( str, "true", 4 ) ); 425 break; 426 427 case AFM_VALUE_TYPE_INDEX: 428 if ( parser->get_index ) 429 val->u.i = parser->get_index( str, len, parser->user_data ); 430 else 431 val->u.i = 0; 432 break; 433 } 434 } 435 436 return i; 437 } 438 439 440 FT_LOCAL_DEF( char* ) 441 afm_parser_next_key( AFM_Parser parser, 442 FT_Bool line, 443 FT_Offset* len ) 444 { 445 AFM_Stream stream = parser->stream; 446 char* key = 0; /* make stupid compiler happy */ 447 448 449 if ( line ) 450 { 451 while ( 1 ) 452 { 453 /* skip current line */ 454 if ( !AFM_STATUS_EOL( stream ) ) 455 afm_stream_read_string( stream ); 456 457 stream->status = AFM_STREAM_STATUS_NORMAL; 458 key = afm_stream_read_one( stream ); 459 460 /* skip empty line */ 461 if ( !key && 462 !AFM_STATUS_EOF( stream ) && 463 AFM_STATUS_EOL( stream ) ) 464 continue; 465 466 break; 467 } 468 } 469 else 470 { 471 while ( 1 ) 472 { 473 /* skip current column */ 474 while ( !AFM_STATUS_EOC( stream ) ) 475 afm_stream_read_one( stream ); 476 477 stream->status = AFM_STREAM_STATUS_NORMAL; 478 key = afm_stream_read_one( stream ); 479 480 /* skip empty column */ 481 if ( !key && 482 !AFM_STATUS_EOF( stream ) && 483 AFM_STATUS_EOC( stream ) ) 484 continue; 485 486 break; 487 } 488 } 489 490 if ( len ) 491 *len = ( key ) ? (FT_Offset)AFM_STREAM_KEY_LEN( stream, key ) 492 : 0; 493 494 return key; 495 } 496 497 498 static AFM_Token 499 afm_tokenize( const char* key, 500 FT_Offset len ) 501 { 502 int n; 503 504 505 for ( n = 0; n < N_AFM_TOKENS; n++ ) 506 { 507 if ( *( afm_key_table[n] ) == *key ) 508 { 509 for ( ; n < N_AFM_TOKENS; n++ ) 510 { 511 if ( *( afm_key_table[n] ) != *key ) 512 return AFM_TOKEN_UNKNOWN; 513 514 if ( ft_strncmp( afm_key_table[n], key, len ) == 0 ) 515 return (AFM_Token) n; 516 } 517 } 518 } 519 520 return AFM_TOKEN_UNKNOWN; 521 } 522 523 524 FT_LOCAL_DEF( FT_Error ) 525 afm_parser_init( AFM_Parser parser, 526 FT_Memory memory, 527 FT_Byte* base, 528 FT_Byte* limit ) 529 { 530 AFM_Stream stream = NULL; 531 FT_Error error; 532 533 534 if ( FT_NEW( stream ) ) 535 return error; 536 537 stream->cursor = stream->base = base; 538 stream->limit = limit; 539 540 /* don't skip the first line during the first call */ 541 stream->status = AFM_STREAM_STATUS_EOL; 542 543 parser->memory = memory; 544 parser->stream = stream; 545 parser->FontInfo = NULL; 546 parser->get_index = NULL; 547 548 return PSaux_Err_Ok; 549 } 550 551 552 FT_LOCAL( void ) 553 afm_parser_done( AFM_Parser parser ) 554 { 555 FT_Memory memory = parser->memory; 556 557 558 FT_FREE( parser->stream ); 559 } 560 561 562 FT_LOCAL_DEF( FT_Error ) 563 afm_parser_read_int( AFM_Parser parser, 564 FT_Int* aint ) 565 { 566 AFM_ValueRec val; 567 568 569 val.type = AFM_VALUE_TYPE_INTEGER; 570 571 if ( afm_parser_read_vals( parser, &val, 1 ) == 1 ) 572 { 573 *aint = val.u.i; 574 575 return PSaux_Err_Ok; 576 } 577 else 578 return PSaux_Err_Syntax_Error; 579 } 580 581 582 static FT_Error 583 afm_parse_track_kern( AFM_Parser parser ) 584 { 585 AFM_FontInfo fi = parser->FontInfo; 586 AFM_TrackKern tk; 587 char* key; 588 FT_Offset len; 589 int n = -1; 590 591 592 if ( afm_parser_read_int( parser, &fi->NumTrackKern ) ) 593 goto Fail; 594 595 if ( fi->NumTrackKern ) 596 { 597 FT_Memory memory = parser->memory; 598 FT_Error error; 599 600 601 if ( FT_QNEW_ARRAY( fi->TrackKerns, fi->NumTrackKern ) ) 602 return error; 603 } 604 605 while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 ) 606 { 607 AFM_ValueRec shared_vals[5]; 608 609 610 switch ( afm_tokenize( key, len ) ) 611 { 612 case AFM_TOKEN_TRACKKERN: 613 n++; 614 615 if ( n >= fi->NumTrackKern ) 616 goto Fail; 617 618 tk = fi->TrackKerns + n; 619 620 shared_vals[0].type = AFM_VALUE_TYPE_INTEGER; 621 shared_vals[1].type = AFM_VALUE_TYPE_FIXED; 622 shared_vals[2].type = AFM_VALUE_TYPE_FIXED; 623 shared_vals[3].type = AFM_VALUE_TYPE_FIXED; 624 shared_vals[4].type = AFM_VALUE_TYPE_FIXED; 625 if ( afm_parser_read_vals( parser, shared_vals, 5 ) != 5 ) 626 goto Fail; 627 628 tk->degree = shared_vals[0].u.i; 629 tk->min_ptsize = shared_vals[1].u.f; 630 tk->min_kern = shared_vals[2].u.f; 631 tk->max_ptsize = shared_vals[3].u.f; 632 tk->max_kern = shared_vals[4].u.f; 633 634 /* is this correct? */ 635 if ( tk->degree < 0 && tk->min_kern > 0 ) 636 tk->min_kern = -tk->min_kern; 637 break; 638 639 case AFM_TOKEN_ENDTRACKKERN: 640 case AFM_TOKEN_ENDKERNDATA: 641 case AFM_TOKEN_ENDFONTMETRICS: 642 fi->NumTrackKern = n + 1; 643 return PSaux_Err_Ok; 644 645 case AFM_TOKEN_UNKNOWN: 646 break; 647 648 default: 649 goto Fail; 650 } 651 } 652 653 Fail: 654 return PSaux_Err_Syntax_Error; 655 } 656 657 658#undef KERN_INDEX 659#define KERN_INDEX( g1, g2 ) ( ( (FT_ULong)g1 << 16 ) | g2 ) 660 661 662 /* compare two kerning pairs */ 663 FT_CALLBACK_DEF( int ) 664 afm_compare_kern_pairs( const void* a, 665 const void* b ) 666 { 667 AFM_KernPair kp1 = (AFM_KernPair)a; 668 AFM_KernPair kp2 = (AFM_KernPair)b; 669 670 FT_ULong index1 = KERN_INDEX( kp1->index1, kp1->index2 ); 671 FT_ULong index2 = KERN_INDEX( kp2->index1, kp2->index2 ); 672 673 674 if ( index1 > index2 ) 675 return 1; 676 else if ( index1 < index2 ) 677 return -1; 678 else 679 return 0; 680 } 681 682 683 static FT_Error 684 afm_parse_kern_pairs( AFM_Parser parser ) 685 { 686 AFM_FontInfo fi = parser->FontInfo; 687 AFM_KernPair kp; 688 char* key; 689 FT_Offset len; 690 int n = -1; 691 692 693 if ( afm_parser_read_int( parser, &fi->NumKernPair ) ) 694 goto Fail; 695 696 if ( fi->NumKernPair ) 697 { 698 FT_Memory memory = parser->memory; 699 FT_Error error; 700 701 702 if ( FT_QNEW_ARRAY( fi->KernPairs, fi->NumKernPair ) ) 703 return error; 704 } 705 706 while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 ) 707 { 708 AFM_Token token = afm_tokenize( key, len ); 709 710 711 switch ( token ) 712 { 713 case AFM_TOKEN_KP: 714 case AFM_TOKEN_KPX: 715 case AFM_TOKEN_KPY: 716 { 717 FT_Int r; 718 AFM_ValueRec shared_vals[4]; 719 720 721 n++; 722 723 if ( n >= fi->NumKernPair ) 724 goto Fail; 725 726 kp = fi->KernPairs + n; 727 728 shared_vals[0].type = AFM_VALUE_TYPE_INDEX; 729 shared_vals[1].type = AFM_VALUE_TYPE_INDEX; 730 shared_vals[2].type = AFM_VALUE_TYPE_INTEGER; 731 shared_vals[3].type = AFM_VALUE_TYPE_INTEGER; 732 r = afm_parser_read_vals( parser, shared_vals, 4 ); 733 if ( r < 3 ) 734 goto Fail; 735 736 kp->index1 = shared_vals[0].u.i; 737 kp->index2 = shared_vals[1].u.i; 738 if ( token == AFM_TOKEN_KPY ) 739 { 740 kp->x = 0; 741 kp->y = shared_vals[2].u.i; 742 } 743 else 744 { 745 kp->x = shared_vals[2].u.i; 746 kp->y = ( token == AFM_TOKEN_KP && r == 4 ) 747 ? shared_vals[3].u.i : 0; 748 } 749 } 750 break; 751 752 case AFM_TOKEN_ENDKERNPAIRS: 753 case AFM_TOKEN_ENDKERNDATA: 754 case AFM_TOKEN_ENDFONTMETRICS: 755 fi->NumKernPair = n + 1; 756 ft_qsort( fi->KernPairs, fi->NumKernPair, 757 sizeof( AFM_KernPairRec ), 758 afm_compare_kern_pairs ); 759 return PSaux_Err_Ok; 760 761 case AFM_TOKEN_UNKNOWN: 762 break; 763 764 default: 765 goto Fail; 766 } 767 } 768 769 Fail: 770 return PSaux_Err_Syntax_Error; 771 } 772 773 774 static FT_Error 775 afm_parse_kern_data( AFM_Parser parser ) 776 { 777 FT_Error error; 778 char* key; 779 FT_Offset len; 780 781 782 while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 ) 783 { 784 switch ( afm_tokenize( key, len ) ) 785 { 786 case AFM_TOKEN_STARTTRACKKERN: 787 error = afm_parse_track_kern( parser ); 788 if ( error ) 789 return error; 790 break; 791 792 case AFM_TOKEN_STARTKERNPAIRS: 793 case AFM_TOKEN_STARTKERNPAIRS0: 794 error = afm_parse_kern_pairs( parser ); 795 if ( error ) 796 return error; 797 break; 798 799 case AFM_TOKEN_ENDKERNDATA: 800 case AFM_TOKEN_ENDFONTMETRICS: 801 return PSaux_Err_Ok; 802 803 case AFM_TOKEN_UNKNOWN: 804 break; 805 806 default: 807 goto Fail; 808 } 809 } 810 811 Fail: 812 return PSaux_Err_Syntax_Error; 813 } 814 815 816 static FT_Error 817 afm_parser_skip_section( AFM_Parser parser, 818 FT_UInt n, 819 AFM_Token end_section ) 820 { 821 char* key; 822 FT_Offset len; 823 824 825 while ( n-- > 0 ) 826 { 827 key = afm_parser_next_key( parser, 1, NULL ); 828 if ( !key ) 829 goto Fail; 830 } 831 832 while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 ) 833 { 834 AFM_Token token = afm_tokenize( key, len ); 835 836 837 if ( token == end_section || token == AFM_TOKEN_ENDFONTMETRICS ) 838 return PSaux_Err_Ok; 839 } 840 841 Fail: 842 return PSaux_Err_Syntax_Error; 843 } 844 845 846 FT_LOCAL_DEF( FT_Error ) 847 afm_parser_parse( AFM_Parser parser ) 848 { 849 FT_Memory memory = parser->memory; 850 AFM_FontInfo fi = parser->FontInfo; 851 FT_Error error = PSaux_Err_Syntax_Error; 852 char* key; 853 FT_Offset len; 854 FT_Int metrics_sets = 0; 855 856 857 if ( !fi ) 858 return PSaux_Err_Invalid_Argument; 859 860 key = afm_parser_next_key( parser, 1, &len ); 861 if ( !key || len != 16 || 862 ft_strncmp( key, "StartFontMetrics", 16 ) != 0 ) 863 return PSaux_Err_Unknown_File_Format; 864 865 while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 ) 866 { 867 AFM_ValueRec shared_vals[4]; 868 869 870 switch ( afm_tokenize( key, len ) ) 871 { 872 case AFM_TOKEN_METRICSSETS: 873 if ( afm_parser_read_int( parser, &metrics_sets ) ) 874 goto Fail; 875 876 if ( metrics_sets != 0 && metrics_sets != 2 ) 877 { 878 error = PSaux_Err_Unimplemented_Feature; 879 880 goto Fail; 881 } 882 break; 883 884 case AFM_TOKEN_ISCIDFONT: 885 shared_vals[0].type = AFM_VALUE_TYPE_BOOL; 886 if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 ) 887 goto Fail; 888 889 fi->IsCIDFont = shared_vals[0].u.b; 890 break; 891 892 case AFM_TOKEN_FONTBBOX: 893 shared_vals[0].type = AFM_VALUE_TYPE_FIXED; 894 shared_vals[1].type = AFM_VALUE_TYPE_FIXED; 895 shared_vals[2].type = AFM_VALUE_TYPE_FIXED; 896 shared_vals[3].type = AFM_VALUE_TYPE_FIXED; 897 if ( afm_parser_read_vals( parser, shared_vals, 4 ) != 4 ) 898 goto Fail; 899 900 fi->FontBBox.xMin = shared_vals[0].u.f; 901 fi->FontBBox.yMin = shared_vals[1].u.f; 902 fi->FontBBox.xMax = shared_vals[2].u.f; 903 fi->FontBBox.yMax = shared_vals[3].u.f; 904 break; 905 906 case AFM_TOKEN_ASCENDER: 907 shared_vals[0].type = AFM_VALUE_TYPE_FIXED; 908 if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 ) 909 goto Fail; 910 911 fi->Ascender = shared_vals[0].u.f; 912 break; 913 914 case AFM_TOKEN_DESCENDER: 915 shared_vals[0].type = AFM_VALUE_TYPE_FIXED; 916 if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 ) 917 goto Fail; 918 919 fi->Descender = shared_vals[0].u.f; 920 break; 921 922 case AFM_TOKEN_STARTCHARMETRICS: 923 { 924 FT_Int n = 0; 925 926 927 if ( afm_parser_read_int( parser, &n ) ) 928 goto Fail; 929 930 error = afm_parser_skip_section( parser, n, 931 AFM_TOKEN_ENDCHARMETRICS ); 932 if ( error ) 933 return error; 934 } 935 break; 936 937 case AFM_TOKEN_STARTKERNDATA: 938 error = afm_parse_kern_data( parser ); 939 if ( error ) 940 goto Fail; 941 /* fall through since we only support kern data */ 942 943 case AFM_TOKEN_ENDFONTMETRICS: 944 return PSaux_Err_Ok; 945 946 default: 947 break; 948 } 949 } 950 951 Fail: 952 FT_FREE( fi->TrackKerns ); 953 fi->NumTrackKern = 0; 954 955 FT_FREE( fi->KernPairs ); 956 fi->NumKernPair = 0; 957 958 fi->IsCIDFont = 0; 959 960 return error; 961 } 962 963 964/* END */ 965