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