1/***************************************************************************/ 2/* */ 3/* t1decode.c */ 4/* */ 5/* PostScript Type 1 decoding routines (body). */ 6/* */ 7/* Copyright 2000-2013 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 19#include <ft2build.h> 20#include FT_INTERNAL_CALC_H 21#include FT_INTERNAL_DEBUG_H 22#include FT_INTERNAL_POSTSCRIPT_HINTS_H 23#include FT_OUTLINE_H 24 25#include "t1decode.h" 26#include "psobjs.h" 27 28#include "psauxerr.h" 29 30/* ensure proper sign extension */ 31#define Fix2Int( f ) ( (FT_Int)(FT_Short)( (f) >> 16 ) ) 32 33 /*************************************************************************/ 34 /* */ 35 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 36 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 37 /* messages during execution. */ 38 /* */ 39#undef FT_COMPONENT 40#define FT_COMPONENT trace_t1decode 41 42 43 typedef enum T1_Operator_ 44 { 45 op_none = 0, 46 op_endchar, 47 op_hsbw, 48 op_seac, 49 op_sbw, 50 op_closepath, 51 op_hlineto, 52 op_hmoveto, 53 op_hvcurveto, 54 op_rlineto, 55 op_rmoveto, 56 op_rrcurveto, 57 op_vhcurveto, 58 op_vlineto, 59 op_vmoveto, 60 op_dotsection, 61 op_hstem, 62 op_hstem3, 63 op_vstem, 64 op_vstem3, 65 op_div, 66 op_callothersubr, 67 op_callsubr, 68 op_pop, 69 op_return, 70 op_setcurrentpoint, 71 op_unknown15, 72 73 op_max /* never remove this one */ 74 75 } T1_Operator; 76 77 78 static 79 const FT_Int t1_args_count[op_max] = 80 { 81 0, /* none */ 82 0, /* endchar */ 83 2, /* hsbw */ 84 5, /* seac */ 85 4, /* sbw */ 86 0, /* closepath */ 87 1, /* hlineto */ 88 1, /* hmoveto */ 89 4, /* hvcurveto */ 90 2, /* rlineto */ 91 2, /* rmoveto */ 92 6, /* rrcurveto */ 93 4, /* vhcurveto */ 94 1, /* vlineto */ 95 1, /* vmoveto */ 96 0, /* dotsection */ 97 2, /* hstem */ 98 6, /* hstem3 */ 99 2, /* vstem */ 100 6, /* vstem3 */ 101 2, /* div */ 102 -1, /* callothersubr */ 103 1, /* callsubr */ 104 0, /* pop */ 105 0, /* return */ 106 2, /* setcurrentpoint */ 107 2 /* opcode 15 (undocumented and obsolete) */ 108 }; 109 110 111 /*************************************************************************/ 112 /* */ 113 /* <Function> */ 114 /* t1_lookup_glyph_by_stdcharcode */ 115 /* */ 116 /* <Description> */ 117 /* Looks up a given glyph by its StandardEncoding charcode. Used to */ 118 /* implement the SEAC Type 1 operator. */ 119 /* */ 120 /* <Input> */ 121 /* face :: The current face object. */ 122 /* */ 123 /* charcode :: The character code to look for. */ 124 /* */ 125 /* <Return> */ 126 /* A glyph index in the font face. Returns -1 if the corresponding */ 127 /* glyph wasn't found. */ 128 /* */ 129 static FT_Int 130 t1_lookup_glyph_by_stdcharcode( T1_Decoder decoder, 131 FT_Int charcode ) 132 { 133 FT_UInt n; 134 const FT_String* glyph_name; 135 FT_Service_PsCMaps psnames = decoder->psnames; 136 137 138 /* check range of standard char code */ 139 if ( charcode < 0 || charcode > 255 ) 140 return -1; 141 142 glyph_name = psnames->adobe_std_strings( 143 psnames->adobe_std_encoding[charcode]); 144 145 for ( n = 0; n < decoder->num_glyphs; n++ ) 146 { 147 FT_String* name = (FT_String*)decoder->glyph_names[n]; 148 149 150 if ( name && 151 name[0] == glyph_name[0] && 152 ft_strcmp( name, glyph_name ) == 0 ) 153 return n; 154 } 155 156 return -1; 157 } 158 159 160 /*************************************************************************/ 161 /* */ 162 /* <Function> */ 163 /* t1operator_seac */ 164 /* */ 165 /* <Description> */ 166 /* Implements the `seac' Type 1 operator for a Type 1 decoder. */ 167 /* */ 168 /* <Input> */ 169 /* decoder :: The current CID decoder. */ 170 /* */ 171 /* asb :: The accent's side bearing. */ 172 /* */ 173 /* adx :: The horizontal offset of the accent. */ 174 /* */ 175 /* ady :: The vertical offset of the accent. */ 176 /* */ 177 /* bchar :: The base character's StandardEncoding charcode. */ 178 /* */ 179 /* achar :: The accent character's StandardEncoding charcode. */ 180 /* */ 181 /* <Return> */ 182 /* FreeType error code. 0 means success. */ 183 /* */ 184 static FT_Error 185 t1operator_seac( T1_Decoder decoder, 186 FT_Pos asb, 187 FT_Pos adx, 188 FT_Pos ady, 189 FT_Int bchar, 190 FT_Int achar ) 191 { 192 FT_Error error; 193 FT_Int bchar_index, achar_index; 194#if 0 195 FT_Int n_base_points; 196 FT_Outline* base = decoder->builder.base; 197#endif 198 FT_Vector left_bearing, advance; 199 200#ifdef FT_CONFIG_OPTION_INCREMENTAL 201 T1_Face face = (T1_Face)decoder->builder.face; 202#endif 203 204 205 if ( decoder->seac ) 206 { 207 FT_ERROR(( "t1operator_seac: invalid nested seac\n" )); 208 return FT_THROW( Syntax_Error ); 209 } 210 211 if ( decoder->builder.metrics_only ) 212 { 213 FT_ERROR(( "t1operator_seac: unexpected seac\n" )); 214 return FT_THROW( Syntax_Error ); 215 } 216 217 /* seac weirdness */ 218 adx += decoder->builder.left_bearing.x; 219 220 /* `glyph_names' is set to 0 for CID fonts which do not */ 221 /* include an encoding. How can we deal with these? */ 222#ifdef FT_CONFIG_OPTION_INCREMENTAL 223 if ( decoder->glyph_names == 0 && 224 !face->root.internal->incremental_interface ) 225#else 226 if ( decoder->glyph_names == 0 ) 227#endif /* FT_CONFIG_OPTION_INCREMENTAL */ 228 { 229 FT_ERROR(( "t1operator_seac:" 230 " glyph names table not available in this font\n" )); 231 return FT_THROW( Syntax_Error ); 232 } 233 234#ifdef FT_CONFIG_OPTION_INCREMENTAL 235 if ( face->root.internal->incremental_interface ) 236 { 237 /* the caller must handle the font encoding also */ 238 bchar_index = bchar; 239 achar_index = achar; 240 } 241 else 242#endif 243 { 244 bchar_index = t1_lookup_glyph_by_stdcharcode( decoder, bchar ); 245 achar_index = t1_lookup_glyph_by_stdcharcode( decoder, achar ); 246 } 247 248 if ( bchar_index < 0 || achar_index < 0 ) 249 { 250 FT_ERROR(( "t1operator_seac:" 251 " invalid seac character code arguments\n" )); 252 return FT_THROW( Syntax_Error ); 253 } 254 255 /* if we are trying to load a composite glyph, do not load the */ 256 /* accent character and return the array of subglyphs. */ 257 if ( decoder->builder.no_recurse ) 258 { 259 FT_GlyphSlot glyph = (FT_GlyphSlot)decoder->builder.glyph; 260 FT_GlyphLoader loader = glyph->internal->loader; 261 FT_SubGlyph subg; 262 263 264 /* reallocate subglyph array if necessary */ 265 error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 ); 266 if ( error ) 267 goto Exit; 268 269 subg = loader->current.subglyphs; 270 271 /* subglyph 0 = base character */ 272 subg->index = bchar_index; 273 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES | 274 FT_SUBGLYPH_FLAG_USE_MY_METRICS; 275 subg->arg1 = 0; 276 subg->arg2 = 0; 277 subg++; 278 279 /* subglyph 1 = accent character */ 280 subg->index = achar_index; 281 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES; 282 subg->arg1 = (FT_Int)FIXED_TO_INT( adx - asb ); 283 subg->arg2 = (FT_Int)FIXED_TO_INT( ady ); 284 285 /* set up remaining glyph fields */ 286 glyph->num_subglyphs = 2; 287 glyph->subglyphs = loader->base.subglyphs; 288 glyph->format = FT_GLYPH_FORMAT_COMPOSITE; 289 290 loader->current.num_subglyphs = 2; 291 goto Exit; 292 } 293 294 /* First load `bchar' in builder */ 295 /* now load the unscaled outline */ 296 297 FT_GlyphLoader_Prepare( decoder->builder.loader ); /* prepare loader */ 298 299 /* the seac operator must not be nested */ 300 decoder->seac = TRUE; 301 error = t1_decoder_parse_glyph( decoder, bchar_index ); 302 decoder->seac = FALSE; 303 if ( error ) 304 goto Exit; 305 306 /* save the left bearing and width of the base character */ 307 /* as they will be erased by the next load. */ 308 309 left_bearing = decoder->builder.left_bearing; 310 advance = decoder->builder.advance; 311 312 decoder->builder.left_bearing.x = 0; 313 decoder->builder.left_bearing.y = 0; 314 315 decoder->builder.pos_x = adx - asb; 316 decoder->builder.pos_y = ady; 317 318 /* Now load `achar' on top of */ 319 /* the base outline */ 320 321 /* the seac operator must not be nested */ 322 decoder->seac = TRUE; 323 error = t1_decoder_parse_glyph( decoder, achar_index ); 324 decoder->seac = FALSE; 325 if ( error ) 326 goto Exit; 327 328 /* restore the left side bearing and */ 329 /* advance width of the base character */ 330 331 decoder->builder.left_bearing = left_bearing; 332 decoder->builder.advance = advance; 333 334 decoder->builder.pos_x = 0; 335 decoder->builder.pos_y = 0; 336 337 Exit: 338 return error; 339 } 340 341 342 /*************************************************************************/ 343 /* */ 344 /* <Function> */ 345 /* t1_decoder_parse_charstrings */ 346 /* */ 347 /* <Description> */ 348 /* Parses a given Type 1 charstrings program. */ 349 /* */ 350 /* <Input> */ 351 /* decoder :: The current Type 1 decoder. */ 352 /* */ 353 /* charstring_base :: The base address of the charstring stream. */ 354 /* */ 355 /* charstring_len :: The length in bytes of the charstring stream. */ 356 /* */ 357 /* <Return> */ 358 /* FreeType error code. 0 means success. */ 359 /* */ 360 FT_LOCAL_DEF( FT_Error ) 361 t1_decoder_parse_charstrings( T1_Decoder decoder, 362 FT_Byte* charstring_base, 363 FT_UInt charstring_len ) 364 { 365 FT_Error error; 366 T1_Decoder_Zone zone; 367 FT_Byte* ip; 368 FT_Byte* limit; 369 T1_Builder builder = &decoder->builder; 370 FT_Pos x, y, orig_x, orig_y; 371 FT_Int known_othersubr_result_cnt = 0; 372 FT_Int unknown_othersubr_result_cnt = 0; 373 FT_Bool large_int; 374 FT_Fixed seed; 375 376 T1_Hints_Funcs hinter; 377 378#ifdef FT_DEBUG_LEVEL_TRACE 379 FT_Bool bol = TRUE; 380#endif 381 382 383 /* compute random seed from stack address of parameter */ 384 seed = (FT_Fixed)( ( (FT_PtrDist)(char*)&seed ^ 385 (FT_PtrDist)(char*)&decoder ^ 386 (FT_PtrDist)(char*)&charstring_base ) & 387 FT_ULONG_MAX ) ; 388 seed = ( seed ^ ( seed >> 10 ) ^ ( seed >> 20 ) ) & 0xFFFFL; 389 if ( seed == 0 ) 390 seed = 0x7384; 391 392 /* First of all, initialize the decoder */ 393 decoder->top = decoder->stack; 394 decoder->zone = decoder->zones; 395 zone = decoder->zones; 396 397 builder->parse_state = T1_Parse_Start; 398 399 hinter = (T1_Hints_Funcs)builder->hints_funcs; 400 401 /* a font that reads BuildCharArray without setting */ 402 /* its values first is buggy, but ... */ 403 FT_ASSERT( ( decoder->len_buildchar == 0 ) == 404 ( decoder->buildchar == NULL ) ); 405 406 if ( decoder->buildchar && decoder->len_buildchar > 0 ) 407 ft_memset( &decoder->buildchar[0], 408 0, 409 sizeof ( decoder->buildchar[0] ) * decoder->len_buildchar ); 410 411 FT_TRACE4(( "\n" 412 "Start charstring\n" )); 413 414 zone->base = charstring_base; 415 limit = zone->limit = charstring_base + charstring_len; 416 ip = zone->cursor = zone->base; 417 418 error = FT_Err_Ok; 419 420 x = orig_x = builder->pos_x; 421 y = orig_y = builder->pos_y; 422 423 /* begin hints recording session, if any */ 424 if ( hinter ) 425 hinter->open( hinter->hints ); 426 427 large_int = FALSE; 428 429 /* now, execute loop */ 430 while ( ip < limit ) 431 { 432 FT_Long* top = decoder->top; 433 T1_Operator op = op_none; 434 FT_Int32 value = 0; 435 436 437 FT_ASSERT( known_othersubr_result_cnt == 0 || 438 unknown_othersubr_result_cnt == 0 ); 439 440#ifdef FT_DEBUG_LEVEL_TRACE 441 if ( bol ) 442 { 443 FT_TRACE5(( " (%d)", decoder->top - decoder->stack )); 444 bol = FALSE; 445 } 446#endif 447 448 /*********************************************************************/ 449 /* */ 450 /* Decode operator or operand */ 451 /* */ 452 /* */ 453 454 /* first of all, decompress operator or value */ 455 switch ( *ip++ ) 456 { 457 case 1: 458 op = op_hstem; 459 break; 460 461 case 3: 462 op = op_vstem; 463 break; 464 case 4: 465 op = op_vmoveto; 466 break; 467 case 5: 468 op = op_rlineto; 469 break; 470 case 6: 471 op = op_hlineto; 472 break; 473 case 7: 474 op = op_vlineto; 475 break; 476 case 8: 477 op = op_rrcurveto; 478 break; 479 case 9: 480 op = op_closepath; 481 break; 482 case 10: 483 op = op_callsubr; 484 break; 485 case 11: 486 op = op_return; 487 break; 488 489 case 13: 490 op = op_hsbw; 491 break; 492 case 14: 493 op = op_endchar; 494 break; 495 496 case 15: /* undocumented, obsolete operator */ 497 op = op_unknown15; 498 break; 499 500 case 21: 501 op = op_rmoveto; 502 break; 503 case 22: 504 op = op_hmoveto; 505 break; 506 507 case 30: 508 op = op_vhcurveto; 509 break; 510 case 31: 511 op = op_hvcurveto; 512 break; 513 514 case 12: 515 if ( ip > limit ) 516 { 517 FT_ERROR(( "t1_decoder_parse_charstrings:" 518 " invalid escape (12+EOF)\n" )); 519 goto Syntax_Error; 520 } 521 522 switch ( *ip++ ) 523 { 524 case 0: 525 op = op_dotsection; 526 break; 527 case 1: 528 op = op_vstem3; 529 break; 530 case 2: 531 op = op_hstem3; 532 break; 533 case 6: 534 op = op_seac; 535 break; 536 case 7: 537 op = op_sbw; 538 break; 539 case 12: 540 op = op_div; 541 break; 542 case 16: 543 op = op_callothersubr; 544 break; 545 case 17: 546 op = op_pop; 547 break; 548 case 33: 549 op = op_setcurrentpoint; 550 break; 551 552 default: 553 FT_ERROR(( "t1_decoder_parse_charstrings:" 554 " invalid escape (12+%d)\n", 555 ip[-1] )); 556 goto Syntax_Error; 557 } 558 break; 559 560 case 255: /* four bytes integer */ 561 if ( ip + 4 > limit ) 562 { 563 FT_ERROR(( "t1_decoder_parse_charstrings:" 564 " unexpected EOF in integer\n" )); 565 goto Syntax_Error; 566 } 567 568 value = (FT_Int32)( ( (FT_UInt32)ip[0] << 24 ) | 569 ( (FT_UInt32)ip[1] << 16 ) | 570 ( (FT_UInt32)ip[2] << 8 ) | 571 (FT_UInt32)ip[3] ); 572 ip += 4; 573 574 /* According to the specification, values > 32000 or < -32000 must */ 575 /* be followed by a `div' operator to make the result be in the */ 576 /* range [-32000;32000]. We expect that the second argument of */ 577 /* `div' is not a large number. Additionally, we don't handle */ 578 /* stuff like `<large1> <large2> <num> div <num> div' or */ 579 /* <large1> <large2> <num> div div'. This is probably not allowed */ 580 /* anyway. */ 581 if ( value > 32000 || value < -32000 ) 582 { 583 if ( large_int ) 584 { 585 FT_ERROR(( "t1_decoder_parse_charstrings:" 586 " no `div' after large integer\n" )); 587 } 588 else 589 large_int = TRUE; 590 } 591 else 592 { 593 if ( !large_int ) 594 value = (FT_Int32)( (FT_UInt32)value << 16 ); 595 } 596 597 break; 598 599 default: 600 if ( ip[-1] >= 32 ) 601 { 602 if ( ip[-1] < 247 ) 603 value = (FT_Int32)ip[-1] - 139; 604 else 605 { 606 if ( ++ip > limit ) 607 { 608 FT_ERROR(( "t1_decoder_parse_charstrings:" 609 " unexpected EOF in integer\n" )); 610 goto Syntax_Error; 611 } 612 613 if ( ip[-2] < 251 ) 614 value = ( ( ip[-2] - 247 ) * 256 ) + ip[-1] + 108; 615 else 616 value = -( ( ( ip[-2] - 251 ) * 256 ) + ip[-1] + 108 ); 617 } 618 619 if ( !large_int ) 620 value = (FT_Int32)( (FT_UInt32)value << 16 ); 621 } 622 else 623 { 624 FT_ERROR(( "t1_decoder_parse_charstrings:" 625 " invalid byte (%d)\n", ip[-1] )); 626 goto Syntax_Error; 627 } 628 } 629 630 if ( unknown_othersubr_result_cnt > 0 ) 631 { 632 switch ( op ) 633 { 634 case op_callsubr: 635 case op_return: 636 case op_none: 637 case op_pop: 638 break; 639 640 default: 641 /* all operands have been transferred by previous pops */ 642 unknown_othersubr_result_cnt = 0; 643 break; 644 } 645 } 646 647 if ( large_int && !( op == op_none || op == op_div ) ) 648 { 649 FT_ERROR(( "t1_decoder_parse_charstrings:" 650 " no `div' after large integer\n" )); 651 652 large_int = FALSE; 653 } 654 655 /*********************************************************************/ 656 /* */ 657 /* Push value on stack, or process operator */ 658 /* */ 659 /* */ 660 if ( op == op_none ) 661 { 662 if ( top - decoder->stack >= T1_MAX_CHARSTRINGS_OPERANDS ) 663 { 664 FT_ERROR(( "t1_decoder_parse_charstrings: stack overflow\n" )); 665 goto Syntax_Error; 666 } 667 668#ifdef FT_DEBUG_LEVEL_TRACE 669 if ( large_int ) 670 FT_TRACE4(( " %ld", value )); 671 else 672 FT_TRACE4(( " %ld", Fix2Int( value ) )); 673#endif 674 675 *top++ = value; 676 decoder->top = top; 677 } 678 else if ( op == op_callothersubr ) /* callothersubr */ 679 { 680 FT_Int subr_no; 681 FT_Int arg_cnt; 682 683 684#ifdef FT_DEBUG_LEVEL_TRACE 685 FT_TRACE4(( " callothersubr\n" )); 686 bol = TRUE; 687#endif 688 689 if ( top - decoder->stack < 2 ) 690 goto Stack_Underflow; 691 692 top -= 2; 693 694 subr_no = Fix2Int( top[1] ); 695 arg_cnt = Fix2Int( top[0] ); 696 697 /***********************************************************/ 698 /* */ 699 /* remove all operands to callothersubr from the stack */ 700 /* */ 701 /* for handled othersubrs, where we know the number of */ 702 /* arguments, we increase the stack by the value of */ 703 /* known_othersubr_result_cnt */ 704 /* */ 705 /* for unhandled othersubrs the following pops adjust the */ 706 /* stack pointer as necessary */ 707 708 if ( arg_cnt > top - decoder->stack ) 709 goto Stack_Underflow; 710 711 top -= arg_cnt; 712 713 known_othersubr_result_cnt = 0; 714 unknown_othersubr_result_cnt = 0; 715 716 /* XXX TODO: The checks to `arg_count == <whatever>' */ 717 /* might not be correct; an othersubr expects a certain */ 718 /* number of operands on the PostScript stack (as opposed */ 719 /* to the T1 stack) but it doesn't have to put them there */ 720 /* by itself; previous othersubrs might have left the */ 721 /* operands there if they were not followed by an */ 722 /* appropriate number of pops */ 723 /* */ 724 /* On the other hand, Adobe Reader 7.0.8 for Linux doesn't */ 725 /* accept a font that contains charstrings like */ 726 /* */ 727 /* 100 200 2 20 callothersubr */ 728 /* 300 1 20 callothersubr pop */ 729 /* */ 730 /* Perhaps this is the reason why BuildCharArray exists. */ 731 732 switch ( subr_no ) 733 { 734 case 0: /* end flex feature */ 735 if ( arg_cnt != 3 ) 736 goto Unexpected_OtherSubr; 737 738 if ( decoder->flex_state == 0 || 739 decoder->num_flex_vectors != 7 ) 740 { 741 FT_ERROR(( "t1_decoder_parse_charstrings:" 742 " unexpected flex end\n" )); 743 goto Syntax_Error; 744 } 745 746 /* the two `results' are popped by the following setcurrentpoint */ 747 top[0] = x; 748 top[1] = y; 749 known_othersubr_result_cnt = 2; 750 break; 751 752 case 1: /* start flex feature */ 753 if ( arg_cnt != 0 ) 754 goto Unexpected_OtherSubr; 755 756 decoder->flex_state = 1; 757 decoder->num_flex_vectors = 0; 758 if ( ( error = t1_builder_start_point( builder, x, y ) ) 759 != FT_Err_Ok || 760 ( error = t1_builder_check_points( builder, 6 ) ) 761 != FT_Err_Ok ) 762 goto Fail; 763 break; 764 765 case 2: /* add flex vectors */ 766 { 767 FT_Int idx; 768 769 770 if ( arg_cnt != 0 ) 771 goto Unexpected_OtherSubr; 772 773 if ( decoder->flex_state == 0 ) 774 { 775 FT_ERROR(( "t1_decoder_parse_charstrings:" 776 " missing flex start\n" )); 777 goto Syntax_Error; 778 } 779 780 /* note that we should not add a point for index 0; */ 781 /* this will move our current position to the flex */ 782 /* point without adding any point to the outline */ 783 idx = decoder->num_flex_vectors++; 784 if ( idx > 0 && idx < 7 ) 785 t1_builder_add_point( builder, 786 x, 787 y, 788 (FT_Byte)( idx == 3 || idx == 6 ) ); 789 } 790 break; 791 792 case 3: /* change hints */ 793 if ( arg_cnt != 1 ) 794 goto Unexpected_OtherSubr; 795 796 known_othersubr_result_cnt = 1; 797 798 if ( hinter ) 799 hinter->reset( hinter->hints, builder->current->n_points ); 800 break; 801 802 case 12: 803 case 13: 804 /* counter control hints, clear stack */ 805 top = decoder->stack; 806 break; 807 808 case 14: 809 case 15: 810 case 16: 811 case 17: 812 case 18: /* multiple masters */ 813 { 814 PS_Blend blend = decoder->blend; 815 FT_UInt num_points, nn, mm; 816 FT_Long* delta; 817 FT_Long* values; 818 819 820 if ( !blend ) 821 { 822 FT_ERROR(( "t1_decoder_parse_charstrings:" 823 " unexpected multiple masters operator\n" )); 824 goto Syntax_Error; 825 } 826 827 num_points = (FT_UInt)subr_no - 13 + ( subr_no == 18 ); 828 if ( arg_cnt != (FT_Int)( num_points * blend->num_designs ) ) 829 { 830 FT_ERROR(( "t1_decoder_parse_charstrings:" 831 " incorrect number of multiple masters arguments\n" )); 832 goto Syntax_Error; 833 } 834 835 /* We want to compute */ 836 /* */ 837 /* a0*w0 + a1*w1 + ... + ak*wk */ 838 /* */ 839 /* but we only have a0, a1-a0, a2-a0, ..., ak-a0. */ 840 /* */ 841 /* However, given that w0 + w1 + ... + wk == 1, we can */ 842 /* rewrite it easily as */ 843 /* */ 844 /* a0 + (a1-a0)*w1 + (a2-a0)*w2 + ... + (ak-a0)*wk */ 845 /* */ 846 /* where k == num_designs-1. */ 847 /* */ 848 /* I guess that's why it's written in this `compact' */ 849 /* form. */ 850 /* */ 851 delta = top + num_points; 852 values = top; 853 for ( nn = 0; nn < num_points; nn++ ) 854 { 855 FT_Long tmp = values[0]; 856 857 858 for ( mm = 1; mm < blend->num_designs; mm++ ) 859 tmp += FT_MulFix( *delta++, blend->weight_vector[mm] ); 860 861 *values++ = tmp; 862 } 863 864 known_othersubr_result_cnt = num_points; 865 break; 866 } 867 868 case 19: 869 /* <idx> 1 19 callothersubr */ 870 /* => replace elements starting from index cvi( <idx> ) */ 871 /* of BuildCharArray with WeightVector */ 872 { 873 FT_Int idx; 874 PS_Blend blend = decoder->blend; 875 876 877 if ( arg_cnt != 1 || blend == NULL ) 878 goto Unexpected_OtherSubr; 879 880 idx = Fix2Int( top[0] ); 881 882 if ( idx < 0 || 883 idx + blend->num_designs > decoder->len_buildchar ) 884 goto Unexpected_OtherSubr; 885 886 ft_memcpy( &decoder->buildchar[idx], 887 blend->weight_vector, 888 blend->num_designs * 889 sizeof ( blend->weight_vector[0] ) ); 890 } 891 break; 892 893 case 20: 894 /* <arg1> <arg2> 2 20 callothersubr pop */ 895 /* ==> push <arg1> + <arg2> onto T1 stack */ 896 if ( arg_cnt != 2 ) 897 goto Unexpected_OtherSubr; 898 899 top[0] += top[1]; /* XXX (over|under)flow */ 900 901 known_othersubr_result_cnt = 1; 902 break; 903 904 case 21: 905 /* <arg1> <arg2> 2 21 callothersubr pop */ 906 /* ==> push <arg1> - <arg2> onto T1 stack */ 907 if ( arg_cnt != 2 ) 908 goto Unexpected_OtherSubr; 909 910 top[0] -= top[1]; /* XXX (over|under)flow */ 911 912 known_othersubr_result_cnt = 1; 913 break; 914 915 case 22: 916 /* <arg1> <arg2> 2 22 callothersubr pop */ 917 /* ==> push <arg1> * <arg2> onto T1 stack */ 918 if ( arg_cnt != 2 ) 919 goto Unexpected_OtherSubr; 920 921 top[0] = FT_MulFix( top[0], top[1] ); 922 923 known_othersubr_result_cnt = 1; 924 break; 925 926 case 23: 927 /* <arg1> <arg2> 2 23 callothersubr pop */ 928 /* ==> push <arg1> / <arg2> onto T1 stack */ 929 if ( arg_cnt != 2 || top[1] == 0 ) 930 goto Unexpected_OtherSubr; 931 932 top[0] = FT_DivFix( top[0], top[1] ); 933 934 known_othersubr_result_cnt = 1; 935 break; 936 937 case 24: 938 /* <val> <idx> 2 24 callothersubr */ 939 /* ==> set BuildCharArray[cvi( <idx> )] = <val> */ 940 { 941 FT_Int idx; 942 PS_Blend blend = decoder->blend; 943 944 945 if ( arg_cnt != 2 || blend == NULL ) 946 goto Unexpected_OtherSubr; 947 948 idx = Fix2Int( top[1] ); 949 950 if ( idx < 0 || (FT_UInt) idx >= decoder->len_buildchar ) 951 goto Unexpected_OtherSubr; 952 953 decoder->buildchar[idx] = top[0]; 954 } 955 break; 956 957 case 25: 958 /* <idx> 1 25 callothersubr pop */ 959 /* ==> push BuildCharArray[cvi( idx )] */ 960 /* onto T1 stack */ 961 { 962 FT_Int idx; 963 PS_Blend blend = decoder->blend; 964 965 966 if ( arg_cnt != 1 || blend == NULL ) 967 goto Unexpected_OtherSubr; 968 969 idx = Fix2Int( top[0] ); 970 971 if ( idx < 0 || (FT_UInt) idx >= decoder->len_buildchar ) 972 goto Unexpected_OtherSubr; 973 974 top[0] = decoder->buildchar[idx]; 975 } 976 977 known_othersubr_result_cnt = 1; 978 break; 979 980#if 0 981 case 26: 982 /* <val> mark <idx> ==> set BuildCharArray[cvi( <idx> )] = <val>, */ 983 /* leave mark on T1 stack */ 984 /* <val> <idx> ==> set BuildCharArray[cvi( <idx> )] = <val> */ 985 XXX which routine has left its mark on the (PostScript) stack?; 986 break; 987#endif 988 989 case 27: 990 /* <res1> <res2> <val1> <val2> 4 27 callothersubr pop */ 991 /* ==> push <res1> onto T1 stack if <val1> <= <val2>, */ 992 /* otherwise push <res2> */ 993 if ( arg_cnt != 4 ) 994 goto Unexpected_OtherSubr; 995 996 if ( top[2] > top[3] ) 997 top[0] = top[1]; 998 999 known_othersubr_result_cnt = 1; 1000 break; 1001 1002 case 28: 1003 /* 0 28 callothersubr pop */ 1004 /* => push random value from interval [0, 1) onto stack */ 1005 if ( arg_cnt != 0 ) 1006 goto Unexpected_OtherSubr; 1007 1008 { 1009 FT_Fixed Rand; 1010 1011 1012 Rand = seed; 1013 if ( Rand >= 0x8000L ) 1014 Rand++; 1015 1016 top[0] = Rand; 1017 1018 seed = FT_MulFix( seed, 0x10000L - seed ); 1019 if ( seed == 0 ) 1020 seed += 0x2873; 1021 } 1022 1023 known_othersubr_result_cnt = 1; 1024 break; 1025 1026 default: 1027 if ( arg_cnt >= 0 && subr_no >= 0 ) 1028 { 1029 FT_ERROR(( "t1_decoder_parse_charstrings:" 1030 " unknown othersubr [%d %d], wish me luck\n", 1031 arg_cnt, subr_no )); 1032 unknown_othersubr_result_cnt = arg_cnt; 1033 break; 1034 } 1035 /* fall through */ 1036 1037 Unexpected_OtherSubr: 1038 FT_ERROR(( "t1_decoder_parse_charstrings:" 1039 " invalid othersubr [%d %d]\n", arg_cnt, subr_no )); 1040 goto Syntax_Error; 1041 } 1042 1043 top += known_othersubr_result_cnt; 1044 1045 decoder->top = top; 1046 } 1047 else /* general operator */ 1048 { 1049 FT_Int num_args = t1_args_count[op]; 1050 1051 1052 FT_ASSERT( num_args >= 0 ); 1053 1054 if ( top - decoder->stack < num_args ) 1055 goto Stack_Underflow; 1056 1057 /* XXX Operators usually take their operands from the */ 1058 /* bottom of the stack, i.e., the operands are */ 1059 /* decoder->stack[0], ..., decoder->stack[num_args - 1]; */ 1060 /* only div, callsubr, and callothersubr are different. */ 1061 /* In practice it doesn't matter (?). */ 1062 1063#ifdef FT_DEBUG_LEVEL_TRACE 1064 1065 switch ( op ) 1066 { 1067 case op_callsubr: 1068 case op_div: 1069 case op_callothersubr: 1070 case op_pop: 1071 case op_return: 1072 break; 1073 1074 default: 1075 if ( top - decoder->stack != num_args ) 1076 FT_TRACE0(( "t1_decoder_parse_charstrings:" 1077 " too much operands on the stack" 1078 " (seen %d, expected %d)\n", 1079 top - decoder->stack, num_args )); 1080 break; 1081 } 1082 1083#endif /* FT_DEBUG_LEVEL_TRACE */ 1084 1085 top -= num_args; 1086 1087 switch ( op ) 1088 { 1089 case op_endchar: 1090 FT_TRACE4(( " endchar\n" )); 1091 1092 t1_builder_close_contour( builder ); 1093 1094 /* close hints recording session */ 1095 if ( hinter ) 1096 { 1097 if ( hinter->close( hinter->hints, builder->current->n_points ) ) 1098 goto Syntax_Error; 1099 1100 /* apply hints to the loaded glyph outline now */ 1101 hinter->apply( hinter->hints, 1102 builder->current, 1103 (PSH_Globals)builder->hints_globals, 1104 decoder->hint_mode ); 1105 } 1106 1107 /* add current outline to the glyph slot */ 1108 FT_GlyphLoader_Add( builder->loader ); 1109 1110 /* the compiler should optimize away this empty loop but ... */ 1111 1112#ifdef FT_DEBUG_LEVEL_TRACE 1113 1114 if ( decoder->len_buildchar > 0 ) 1115 { 1116 FT_UInt i; 1117 1118 1119 FT_TRACE4(( "BuildCharArray = [ " )); 1120 1121 for ( i = 0; i < decoder->len_buildchar; ++i ) 1122 FT_TRACE4(( "%d ", decoder->buildchar[i] )); 1123 1124 FT_TRACE4(( "]\n" )); 1125 } 1126 1127#endif /* FT_DEBUG_LEVEL_TRACE */ 1128 1129 FT_TRACE4(( "\n" )); 1130 1131 /* return now! */ 1132 return FT_Err_Ok; 1133 1134 case op_hsbw: 1135 FT_TRACE4(( " hsbw" )); 1136 1137 builder->parse_state = T1_Parse_Have_Width; 1138 1139 builder->left_bearing.x += top[0]; 1140 builder->advance.x = top[1]; 1141 builder->advance.y = 0; 1142 1143 orig_x = x = builder->pos_x + top[0]; 1144 orig_y = y = builder->pos_y; 1145 1146 FT_UNUSED( orig_y ); 1147 1148 /* the `metrics_only' indicates that we only want to compute */ 1149 /* the glyph's metrics (lsb + advance width), not load the */ 1150 /* rest of it; so exit immediately */ 1151 if ( builder->metrics_only ) 1152 return FT_Err_Ok; 1153 1154 break; 1155 1156 case op_seac: 1157 return t1operator_seac( decoder, 1158 top[0], 1159 top[1], 1160 top[2], 1161 Fix2Int( top[3] ), 1162 Fix2Int( top[4] ) ); 1163 1164 case op_sbw: 1165 FT_TRACE4(( " sbw" )); 1166 1167 builder->parse_state = T1_Parse_Have_Width; 1168 1169 builder->left_bearing.x += top[0]; 1170 builder->left_bearing.y += top[1]; 1171 builder->advance.x = top[2]; 1172 builder->advance.y = top[3]; 1173 1174 x = builder->pos_x + top[0]; 1175 y = builder->pos_y + top[1]; 1176 1177 /* the `metrics_only' indicates that we only want to compute */ 1178 /* the glyph's metrics (lsb + advance width), not load the */ 1179 /* rest of it; so exit immediately */ 1180 if ( builder->metrics_only ) 1181 return FT_Err_Ok; 1182 1183 break; 1184 1185 case op_closepath: 1186 FT_TRACE4(( " closepath" )); 1187 1188 /* if there is no path, `closepath' is a no-op */ 1189 if ( builder->parse_state == T1_Parse_Have_Path || 1190 builder->parse_state == T1_Parse_Have_Moveto ) 1191 t1_builder_close_contour( builder ); 1192 1193 builder->parse_state = T1_Parse_Have_Width; 1194 break; 1195 1196 case op_hlineto: 1197 FT_TRACE4(( " hlineto" )); 1198 1199 if ( ( error = t1_builder_start_point( builder, x, y ) ) 1200 != FT_Err_Ok ) 1201 goto Fail; 1202 1203 x += top[0]; 1204 goto Add_Line; 1205 1206 case op_hmoveto: 1207 FT_TRACE4(( " hmoveto" )); 1208 1209 x += top[0]; 1210 if ( !decoder->flex_state ) 1211 { 1212 if ( builder->parse_state == T1_Parse_Start ) 1213 goto Syntax_Error; 1214 builder->parse_state = T1_Parse_Have_Moveto; 1215 } 1216 break; 1217 1218 case op_hvcurveto: 1219 FT_TRACE4(( " hvcurveto" )); 1220 1221 if ( ( error = t1_builder_start_point( builder, x, y ) ) 1222 != FT_Err_Ok || 1223 ( error = t1_builder_check_points( builder, 3 ) ) 1224 != FT_Err_Ok ) 1225 goto Fail; 1226 1227 x += top[0]; 1228 t1_builder_add_point( builder, x, y, 0 ); 1229 x += top[1]; 1230 y += top[2]; 1231 t1_builder_add_point( builder, x, y, 0 ); 1232 y += top[3]; 1233 t1_builder_add_point( builder, x, y, 1 ); 1234 break; 1235 1236 case op_rlineto: 1237 FT_TRACE4(( " rlineto" )); 1238 1239 if ( ( error = t1_builder_start_point( builder, x, y ) ) 1240 != FT_Err_Ok ) 1241 goto Fail; 1242 1243 x += top[0]; 1244 y += top[1]; 1245 1246 Add_Line: 1247 if ( ( error = t1_builder_add_point1( builder, x, y ) ) 1248 != FT_Err_Ok ) 1249 goto Fail; 1250 break; 1251 1252 case op_rmoveto: 1253 FT_TRACE4(( " rmoveto" )); 1254 1255 x += top[0]; 1256 y += top[1]; 1257 if ( !decoder->flex_state ) 1258 { 1259 if ( builder->parse_state == T1_Parse_Start ) 1260 goto Syntax_Error; 1261 builder->parse_state = T1_Parse_Have_Moveto; 1262 } 1263 break; 1264 1265 case op_rrcurveto: 1266 FT_TRACE4(( " rrcurveto" )); 1267 1268 if ( ( error = t1_builder_start_point( builder, x, y ) ) 1269 != FT_Err_Ok || 1270 ( error = t1_builder_check_points( builder, 3 ) ) 1271 != FT_Err_Ok ) 1272 goto Fail; 1273 1274 x += top[0]; 1275 y += top[1]; 1276 t1_builder_add_point( builder, x, y, 0 ); 1277 1278 x += top[2]; 1279 y += top[3]; 1280 t1_builder_add_point( builder, x, y, 0 ); 1281 1282 x += top[4]; 1283 y += top[5]; 1284 t1_builder_add_point( builder, x, y, 1 ); 1285 break; 1286 1287 case op_vhcurveto: 1288 FT_TRACE4(( " vhcurveto" )); 1289 1290 if ( ( error = t1_builder_start_point( builder, x, y ) ) 1291 != FT_Err_Ok || 1292 ( error = t1_builder_check_points( builder, 3 ) ) 1293 != FT_Err_Ok ) 1294 goto Fail; 1295 1296 y += top[0]; 1297 t1_builder_add_point( builder, x, y, 0 ); 1298 x += top[1]; 1299 y += top[2]; 1300 t1_builder_add_point( builder, x, y, 0 ); 1301 x += top[3]; 1302 t1_builder_add_point( builder, x, y, 1 ); 1303 break; 1304 1305 case op_vlineto: 1306 FT_TRACE4(( " vlineto" )); 1307 1308 if ( ( error = t1_builder_start_point( builder, x, y ) ) 1309 != FT_Err_Ok ) 1310 goto Fail; 1311 1312 y += top[0]; 1313 goto Add_Line; 1314 1315 case op_vmoveto: 1316 FT_TRACE4(( " vmoveto" )); 1317 1318 y += top[0]; 1319 if ( !decoder->flex_state ) 1320 { 1321 if ( builder->parse_state == T1_Parse_Start ) 1322 goto Syntax_Error; 1323 builder->parse_state = T1_Parse_Have_Moveto; 1324 } 1325 break; 1326 1327 case op_div: 1328 FT_TRACE4(( " div" )); 1329 1330 /* if `large_int' is set, we divide unscaled numbers; */ 1331 /* otherwise, we divide numbers in 16.16 format -- */ 1332 /* in both cases, it is the same operation */ 1333 *top = FT_DivFix( top[0], top[1] ); 1334 ++top; 1335 1336 large_int = FALSE; 1337 break; 1338 1339 case op_callsubr: 1340 { 1341 FT_Int idx; 1342 1343 1344 FT_TRACE4(( " callsubr" )); 1345 1346 idx = Fix2Int( top[0] ); 1347 if ( idx < 0 || idx >= (FT_Int)decoder->num_subrs ) 1348 { 1349 FT_ERROR(( "t1_decoder_parse_charstrings:" 1350 " invalid subrs index\n" )); 1351 goto Syntax_Error; 1352 } 1353 1354 if ( zone - decoder->zones >= T1_MAX_SUBRS_CALLS ) 1355 { 1356 FT_ERROR(( "t1_decoder_parse_charstrings:" 1357 " too many nested subrs\n" )); 1358 goto Syntax_Error; 1359 } 1360 1361 zone->cursor = ip; /* save current instruction pointer */ 1362 1363 zone++; 1364 1365 /* The Type 1 driver stores subroutines without the seed bytes. */ 1366 /* The CID driver stores subroutines with seed bytes. This */ 1367 /* case is taken care of when decoder->subrs_len == 0. */ 1368 zone->base = decoder->subrs[idx]; 1369 1370 if ( decoder->subrs_len ) 1371 zone->limit = zone->base + decoder->subrs_len[idx]; 1372 else 1373 { 1374 /* We are using subroutines from a CID font. We must adjust */ 1375 /* for the seed bytes. */ 1376 zone->base += ( decoder->lenIV >= 0 ? decoder->lenIV : 0 ); 1377 zone->limit = decoder->subrs[idx + 1]; 1378 } 1379 1380 zone->cursor = zone->base; 1381 1382 if ( !zone->base ) 1383 { 1384 FT_ERROR(( "t1_decoder_parse_charstrings:" 1385 " invoking empty subrs\n" )); 1386 goto Syntax_Error; 1387 } 1388 1389 decoder->zone = zone; 1390 ip = zone->base; 1391 limit = zone->limit; 1392 break; 1393 } 1394 1395 case op_pop: 1396 FT_TRACE4(( " pop" )); 1397 1398 if ( known_othersubr_result_cnt > 0 ) 1399 { 1400 known_othersubr_result_cnt--; 1401 /* ignore, we pushed the operands ourselves */ 1402 break; 1403 } 1404 1405 if ( unknown_othersubr_result_cnt == 0 ) 1406 { 1407 FT_ERROR(( "t1_decoder_parse_charstrings:" 1408 " no more operands for othersubr\n" )); 1409 goto Syntax_Error; 1410 } 1411 1412 unknown_othersubr_result_cnt--; 1413 top++; /* `push' the operand to callothersubr onto the stack */ 1414 break; 1415 1416 case op_return: 1417 FT_TRACE4(( " return" )); 1418 1419 if ( zone <= decoder->zones ) 1420 { 1421 FT_ERROR(( "t1_decoder_parse_charstrings:" 1422 " unexpected return\n" )); 1423 goto Syntax_Error; 1424 } 1425 1426 zone--; 1427 ip = zone->cursor; 1428 limit = zone->limit; 1429 decoder->zone = zone; 1430 break; 1431 1432 case op_dotsection: 1433 FT_TRACE4(( " dotsection" )); 1434 1435 break; 1436 1437 case op_hstem: 1438 FT_TRACE4(( " hstem" )); 1439 1440 /* record horizontal hint */ 1441 if ( hinter ) 1442 { 1443 /* top[0] += builder->left_bearing.y; */ 1444 hinter->stem( hinter->hints, 1, top ); 1445 } 1446 break; 1447 1448 case op_hstem3: 1449 FT_TRACE4(( " hstem3" )); 1450 1451 /* record horizontal counter-controlled hints */ 1452 if ( hinter ) 1453 hinter->stem3( hinter->hints, 1, top ); 1454 break; 1455 1456 case op_vstem: 1457 FT_TRACE4(( " vstem" )); 1458 1459 /* record vertical hint */ 1460 if ( hinter ) 1461 { 1462 top[0] += orig_x; 1463 hinter->stem( hinter->hints, 0, top ); 1464 } 1465 break; 1466 1467 case op_vstem3: 1468 FT_TRACE4(( " vstem3" )); 1469 1470 /* record vertical counter-controlled hints */ 1471 if ( hinter ) 1472 { 1473 FT_Pos dx = orig_x; 1474 1475 1476 top[0] += dx; 1477 top[2] += dx; 1478 top[4] += dx; 1479 hinter->stem3( hinter->hints, 0, top ); 1480 } 1481 break; 1482 1483 case op_setcurrentpoint: 1484 FT_TRACE4(( " setcurrentpoint" )); 1485 1486 /* From the T1 specification, section 6.4: */ 1487 /* */ 1488 /* The setcurrentpoint command is used only in */ 1489 /* conjunction with results from OtherSubrs procedures. */ 1490 1491 /* known_othersubr_result_cnt != 0 is already handled */ 1492 /* above. */ 1493 1494 /* Note, however, that both Ghostscript and Adobe */ 1495 /* Distiller handle this situation by silently ignoring */ 1496 /* the inappropriate `setcurrentpoint' instruction. So */ 1497 /* we do the same. */ 1498#if 0 1499 1500 if ( decoder->flex_state != 1 ) 1501 { 1502 FT_ERROR(( "t1_decoder_parse_charstrings:" 1503 " unexpected `setcurrentpoint'\n" )); 1504 goto Syntax_Error; 1505 } 1506 else 1507 ... 1508#endif 1509 1510 x = top[0]; 1511 y = top[1]; 1512 decoder->flex_state = 0; 1513 break; 1514 1515 case op_unknown15: 1516 FT_TRACE4(( " opcode_15" )); 1517 /* nothing to do except to pop the two arguments */ 1518 break; 1519 1520 default: 1521 FT_ERROR(( "t1_decoder_parse_charstrings:" 1522 " unhandled opcode %d\n", op )); 1523 goto Syntax_Error; 1524 } 1525 1526 /* XXX Operators usually clear the operand stack; */ 1527 /* only div, callsubr, callothersubr, pop, and */ 1528 /* return are different. */ 1529 /* In practice it doesn't matter (?). */ 1530 1531 decoder->top = top; 1532 1533#ifdef FT_DEBUG_LEVEL_TRACE 1534 FT_TRACE4(( "\n" )); 1535 bol = TRUE; 1536#endif 1537 1538 } /* general operator processing */ 1539 1540 } /* while ip < limit */ 1541 1542 FT_TRACE4(( "..end..\n\n" )); 1543 1544 Fail: 1545 return error; 1546 1547 Syntax_Error: 1548 return FT_THROW( Syntax_Error ); 1549 1550 Stack_Underflow: 1551 return FT_THROW( Stack_Underflow ); 1552 } 1553 1554 1555 /* parse a single Type 1 glyph */ 1556 FT_LOCAL_DEF( FT_Error ) 1557 t1_decoder_parse_glyph( T1_Decoder decoder, 1558 FT_UInt glyph ) 1559 { 1560 return decoder->parse_callback( decoder, glyph ); 1561 } 1562 1563 1564 /* initialize T1 decoder */ 1565 FT_LOCAL_DEF( FT_Error ) 1566 t1_decoder_init( T1_Decoder decoder, 1567 FT_Face face, 1568 FT_Size size, 1569 FT_GlyphSlot slot, 1570 FT_Byte** glyph_names, 1571 PS_Blend blend, 1572 FT_Bool hinting, 1573 FT_Render_Mode hint_mode, 1574 T1_Decoder_Callback parse_callback ) 1575 { 1576 FT_MEM_ZERO( decoder, sizeof ( *decoder ) ); 1577 1578 /* retrieve PSNames interface from list of current modules */ 1579 { 1580 FT_Service_PsCMaps psnames = 0; 1581 1582 1583 FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS ); 1584 if ( !psnames ) 1585 { 1586 FT_ERROR(( "t1_decoder_init:" 1587 " the `psnames' module is not available\n" )); 1588 return FT_THROW( Unimplemented_Feature ); 1589 } 1590 1591 decoder->psnames = psnames; 1592 } 1593 1594 t1_builder_init( &decoder->builder, face, size, slot, hinting ); 1595 1596 /* decoder->buildchar and decoder->len_buildchar have to be */ 1597 /* initialized by the caller since we cannot know the length */ 1598 /* of the BuildCharArray */ 1599 1600 decoder->num_glyphs = (FT_UInt)face->num_glyphs; 1601 decoder->glyph_names = glyph_names; 1602 decoder->hint_mode = hint_mode; 1603 decoder->blend = blend; 1604 decoder->parse_callback = parse_callback; 1605 1606 decoder->funcs = t1_decoder_funcs; 1607 1608 return FT_Err_Ok; 1609 } 1610 1611 1612 /* finalize T1 decoder */ 1613 FT_LOCAL_DEF( void ) 1614 t1_decoder_done( T1_Decoder decoder ) 1615 { 1616 t1_builder_done( &decoder->builder ); 1617 } 1618 1619 1620/* END */ 1621