1/***************************************************************************/ 2/* */ 3/* psobjs.c */ 4/* */ 5/* Auxiliary functions for PostScript fonts (body). */ 6/* */ 7/* Copyright 1996-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 "../../include/ft2build.h" 20#include "../../include/freetype/internal/psaux.h" 21#include "../../include/freetype/internal/ftdebug.h" 22#include "../../include/freetype/internal/ftcalc.h" 23 24#include "psobjs.h" 25#include "psconv.h" 26 27#include "psauxerr.h" 28 29 30 /*************************************************************************/ 31 /* */ 32 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 33 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 34 /* messages during execution. */ 35 /* */ 36#undef FT_COMPONENT 37#define FT_COMPONENT trace_psobjs 38 39 40 /*************************************************************************/ 41 /*************************************************************************/ 42 /***** *****/ 43 /***** PS_TABLE *****/ 44 /***** *****/ 45 /*************************************************************************/ 46 /*************************************************************************/ 47 48 /*************************************************************************/ 49 /* */ 50 /* <Function> */ 51 /* ps_table_new */ 52 /* */ 53 /* <Description> */ 54 /* Initializes a PS_Table. */ 55 /* */ 56 /* <InOut> */ 57 /* table :: The address of the target table. */ 58 /* */ 59 /* <Input> */ 60 /* count :: The table size = the maximum number of elements. */ 61 /* */ 62 /* memory :: The memory object to use for all subsequent */ 63 /* reallocations. */ 64 /* */ 65 /* <Return> */ 66 /* FreeType error code. 0 means success. */ 67 /* */ 68 FT_LOCAL_DEF( FT_Error ) 69 ps_table_new( PS_Table table, 70 FT_Int count, 71 FT_Memory memory ) 72 { 73 FT_Error error; 74 75 76 table->memory = memory; 77 if ( FT_NEW_ARRAY( table->elements, count ) || 78 FT_NEW_ARRAY( table->lengths, count ) ) 79 goto Exit; 80 81 table->max_elems = count; 82 table->init = 0xDEADBEEFUL; 83 table->num_elems = 0; 84 table->block = 0; 85 table->capacity = 0; 86 table->cursor = 0; 87 88 *(PS_Table_FuncsRec*)&table->funcs = ps_table_funcs; 89 90 Exit: 91 if ( error ) 92 FT_FREE( table->elements ); 93 94 return error; 95 } 96 97 98 static void 99 shift_elements( PS_Table table, 100 FT_Byte* old_base ) 101 { 102 FT_PtrDist delta = table->block - old_base; 103 FT_Byte** offset = table->elements; 104 FT_Byte** limit = offset + table->max_elems; 105 106 107 for ( ; offset < limit; offset++ ) 108 { 109 if ( offset[0] ) 110 offset[0] += delta; 111 } 112 } 113 114 115 static FT_Error 116 reallocate_t1_table( PS_Table table, 117 FT_Offset new_size ) 118 { 119 FT_Memory memory = table->memory; 120 FT_Byte* old_base = table->block; 121 FT_Error error; 122 123 124 /* allocate new base block */ 125 if ( FT_ALLOC( table->block, new_size ) ) 126 { 127 table->block = old_base; 128 return error; 129 } 130 131 /* copy elements and shift offsets */ 132 if ( old_base ) 133 { 134 FT_MEM_COPY( table->block, old_base, table->capacity ); 135 shift_elements( table, old_base ); 136 FT_FREE( old_base ); 137 } 138 139 table->capacity = new_size; 140 141 return FT_Err_Ok; 142 } 143 144 145 /*************************************************************************/ 146 /* */ 147 /* <Function> */ 148 /* ps_table_add */ 149 /* */ 150 /* <Description> */ 151 /* Adds an object to a PS_Table, possibly growing its memory block. */ 152 /* */ 153 /* <InOut> */ 154 /* table :: The target table. */ 155 /* */ 156 /* <Input> */ 157 /* idx :: The index of the object in the table. */ 158 /* */ 159 /* object :: The address of the object to copy in memory. */ 160 /* */ 161 /* length :: The length in bytes of the source object. */ 162 /* */ 163 /* <Return> */ 164 /* FreeType error code. 0 means success. An error is returned if a */ 165 /* reallocation fails. */ 166 /* */ 167 FT_LOCAL_DEF( FT_Error ) 168 ps_table_add( PS_Table table, 169 FT_Int idx, 170 void* object, 171 FT_PtrDist length ) 172 { 173 if ( idx < 0 || idx >= table->max_elems ) 174 { 175 FT_ERROR(( "ps_table_add: invalid index\n" )); 176 return FT_THROW( Invalid_Argument ); 177 } 178 179 if ( length < 0 ) 180 { 181 FT_ERROR(( "ps_table_add: invalid length\n" )); 182 return FT_THROW( Invalid_Argument ); 183 } 184 185 /* grow the base block if needed */ 186 if ( table->cursor + length > table->capacity ) 187 { 188 FT_Error error; 189 FT_Offset new_size = table->capacity; 190 FT_PtrDist in_offset; 191 192 193 in_offset = (FT_Byte*)object - table->block; 194 if ( in_offset < 0 || (FT_Offset)in_offset >= table->capacity ) 195 in_offset = -1; 196 197 while ( new_size < table->cursor + length ) 198 { 199 /* increase size by 25% and round up to the nearest multiple 200 of 1024 */ 201 new_size += ( new_size >> 2 ) + 1; 202 new_size = FT_PAD_CEIL( new_size, 1024 ); 203 } 204 205 error = reallocate_t1_table( table, new_size ); 206 if ( error ) 207 return error; 208 209 if ( in_offset >= 0 ) 210 object = table->block + in_offset; 211 } 212 213 /* add the object to the base block and adjust offset */ 214 table->elements[idx] = table->block + table->cursor; 215 table->lengths [idx] = length; 216 FT_MEM_COPY( table->block + table->cursor, object, length ); 217 218 table->cursor += length; 219 return FT_Err_Ok; 220 } 221 222 223 /*************************************************************************/ 224 /* */ 225 /* <Function> */ 226 /* ps_table_done */ 227 /* */ 228 /* <Description> */ 229 /* Finalizes a PS_TableRec (i.e., reallocate it to its current */ 230 /* cursor). */ 231 /* */ 232 /* <InOut> */ 233 /* table :: The target table. */ 234 /* */ 235 /* <Note> */ 236 /* This function does NOT release the heap's memory block. It is up */ 237 /* to the caller to clean it, or reference it in its own structures. */ 238 /* */ 239 FT_LOCAL_DEF( void ) 240 ps_table_done( PS_Table table ) 241 { 242 FT_Memory memory = table->memory; 243 FT_Error error; 244 FT_Byte* old_base = table->block; 245 246 247 /* should never fail, because rec.cursor <= rec.size */ 248 if ( !old_base ) 249 return; 250 251 if ( FT_ALLOC( table->block, table->cursor ) ) 252 return; 253 FT_MEM_COPY( table->block, old_base, table->cursor ); 254 shift_elements( table, old_base ); 255 256 table->capacity = table->cursor; 257 FT_FREE( old_base ); 258 259 FT_UNUSED( error ); 260 } 261 262 263 FT_LOCAL_DEF( void ) 264 ps_table_release( PS_Table table ) 265 { 266 FT_Memory memory = table->memory; 267 268 269 if ( (FT_ULong)table->init == 0xDEADBEEFUL ) 270 { 271 FT_FREE( table->block ); 272 FT_FREE( table->elements ); 273 FT_FREE( table->lengths ); 274 table->init = 0; 275 } 276 } 277 278 279 /*************************************************************************/ 280 /*************************************************************************/ 281 /***** *****/ 282 /***** T1 PARSER *****/ 283 /***** *****/ 284 /*************************************************************************/ 285 /*************************************************************************/ 286 287 288 /* first character must be already part of the comment */ 289 290 static void 291 skip_comment( FT_Byte* *acur, 292 FT_Byte* limit ) 293 { 294 FT_Byte* cur = *acur; 295 296 297 while ( cur < limit ) 298 { 299 if ( IS_PS_NEWLINE( *cur ) ) 300 break; 301 cur++; 302 } 303 304 *acur = cur; 305 } 306 307 308 static void 309 skip_spaces( FT_Byte* *acur, 310 FT_Byte* limit ) 311 { 312 FT_Byte* cur = *acur; 313 314 315 while ( cur < limit ) 316 { 317 if ( !IS_PS_SPACE( *cur ) ) 318 { 319 if ( *cur == '%' ) 320 /* According to the PLRM, a comment is equal to a space. */ 321 skip_comment( &cur, limit ); 322 else 323 break; 324 } 325 cur++; 326 } 327 328 *acur = cur; 329 } 330 331 332#define IS_OCTAL_DIGIT( c ) ( '0' <= (c) && (c) <= '7' ) 333 334 335 /* first character must be `('; */ 336 /* *acur is positioned at the character after the closing `)' */ 337 338 static FT_Error 339 skip_literal_string( FT_Byte* *acur, 340 FT_Byte* limit ) 341 { 342 FT_Byte* cur = *acur; 343 FT_Int embed = 0; 344 FT_Error error = FT_ERR( Invalid_File_Format ); 345 unsigned int i; 346 347 348 while ( cur < limit ) 349 { 350 FT_Byte c = *cur; 351 352 353 ++cur; 354 355 if ( c == '\\' ) 356 { 357 /* Red Book 3rd ed., section `Literal Text Strings', p. 29: */ 358 /* A backslash can introduce three different types */ 359 /* of escape sequences: */ 360 /* - a special escaped char like \r, \n, etc. */ 361 /* - a one-, two-, or three-digit octal number */ 362 /* - none of the above in which case the backslash is ignored */ 363 364 if ( cur == limit ) 365 /* error (or to be ignored?) */ 366 break; 367 368 switch ( *cur ) 369 { 370 /* skip `special' escape */ 371 case 'n': 372 case 'r': 373 case 't': 374 case 'b': 375 case 'f': 376 case '\\': 377 case '(': 378 case ')': 379 ++cur; 380 break; 381 382 default: 383 /* skip octal escape or ignore backslash */ 384 for ( i = 0; i < 3 && cur < limit; ++i ) 385 { 386 if ( !IS_OCTAL_DIGIT( *cur ) ) 387 break; 388 389 ++cur; 390 } 391 } 392 } 393 else if ( c == '(' ) 394 embed++; 395 else if ( c == ')' ) 396 { 397 embed--; 398 if ( embed == 0 ) 399 { 400 error = FT_Err_Ok; 401 break; 402 } 403 } 404 } 405 406 *acur = cur; 407 408 return error; 409 } 410 411 412 /* first character must be `<' */ 413 414 static FT_Error 415 skip_string( FT_Byte* *acur, 416 FT_Byte* limit ) 417 { 418 FT_Byte* cur = *acur; 419 FT_Error err = FT_Err_Ok; 420 421 422 while ( ++cur < limit ) 423 { 424 /* All whitespace characters are ignored. */ 425 skip_spaces( &cur, limit ); 426 if ( cur >= limit ) 427 break; 428 429 if ( !IS_PS_XDIGIT( *cur ) ) 430 break; 431 } 432 433 if ( cur < limit && *cur != '>' ) 434 { 435 FT_ERROR(( "skip_string: missing closing delimiter `>'\n" )); 436 err = FT_THROW( Invalid_File_Format ); 437 } 438 else 439 cur++; 440 441 *acur = cur; 442 return err; 443 } 444 445 446 /* first character must be the opening brace that */ 447 /* starts the procedure */ 448 449 /* NB: [ and ] need not match: */ 450 /* `/foo {[} def' is a valid PostScript fragment, */ 451 /* even within a Type1 font */ 452 453 static FT_Error 454 skip_procedure( FT_Byte* *acur, 455 FT_Byte* limit ) 456 { 457 FT_Byte* cur; 458 FT_Int embed = 0; 459 FT_Error error = FT_Err_Ok; 460 461 462 FT_ASSERT( **acur == '{' ); 463 464 for ( cur = *acur; cur < limit && error == FT_Err_Ok; ++cur ) 465 { 466 switch ( *cur ) 467 { 468 case '{': 469 ++embed; 470 break; 471 472 case '}': 473 --embed; 474 if ( embed == 0 ) 475 { 476 ++cur; 477 goto end; 478 } 479 break; 480 481 case '(': 482 error = skip_literal_string( &cur, limit ); 483 break; 484 485 case '<': 486 error = skip_string( &cur, limit ); 487 break; 488 489 case '%': 490 skip_comment( &cur, limit ); 491 break; 492 } 493 } 494 495 end: 496 if ( embed != 0 ) 497 error = FT_THROW( Invalid_File_Format ); 498 499 *acur = cur; 500 501 return error; 502 } 503 504 505 /***********************************************************************/ 506 /* */ 507 /* All exported parsing routines handle leading whitespace and stop at */ 508 /* the first character which isn't part of the just handled token. */ 509 /* */ 510 /***********************************************************************/ 511 512 513 FT_LOCAL_DEF( void ) 514 ps_parser_skip_PS_token( PS_Parser parser ) 515 { 516 /* Note: PostScript allows any non-delimiting, non-whitespace */ 517 /* character in a name (PS Ref Manual, 3rd ed, p31). */ 518 /* PostScript delimiters are (, ), <, >, [, ], {, }, /, and %. */ 519 520 FT_Byte* cur = parser->cursor; 521 FT_Byte* limit = parser->limit; 522 FT_Error error = FT_Err_Ok; 523 524 525 skip_spaces( &cur, limit ); /* this also skips comments */ 526 if ( cur >= limit ) 527 goto Exit; 528 529 /* self-delimiting, single-character tokens */ 530 if ( *cur == '[' || *cur == ']' ) 531 { 532 cur++; 533 goto Exit; 534 } 535 536 /* skip balanced expressions (procedures and strings) */ 537 538 if ( *cur == '{' ) /* {...} */ 539 { 540 error = skip_procedure( &cur, limit ); 541 goto Exit; 542 } 543 544 if ( *cur == '(' ) /* (...) */ 545 { 546 error = skip_literal_string( &cur, limit ); 547 goto Exit; 548 } 549 550 if ( *cur == '<' ) /* <...> */ 551 { 552 if ( cur + 1 < limit && *(cur + 1) == '<' ) /* << */ 553 { 554 cur++; 555 cur++; 556 } 557 else 558 error = skip_string( &cur, limit ); 559 560 goto Exit; 561 } 562 563 if ( *cur == '>' ) 564 { 565 cur++; 566 if ( cur >= limit || *cur != '>' ) /* >> */ 567 { 568 FT_ERROR(( "ps_parser_skip_PS_token:" 569 " unexpected closing delimiter `>'\n" )); 570 error = FT_THROW( Invalid_File_Format ); 571 goto Exit; 572 } 573 cur++; 574 goto Exit; 575 } 576 577 if ( *cur == '/' ) 578 cur++; 579 580 /* anything else */ 581 while ( cur < limit ) 582 { 583 /* *cur might be invalid (e.g., ')' or '}'), but this */ 584 /* is handled by the test `cur == parser->cursor' below */ 585 if ( IS_PS_DELIM( *cur ) ) 586 break; 587 588 cur++; 589 } 590 591 Exit: 592 if ( cur < limit && cur == parser->cursor ) 593 { 594 FT_ERROR(( "ps_parser_skip_PS_token:" 595 " current token is `%c' which is self-delimiting\n" 596 " " 597 " but invalid at this point\n", 598 *cur )); 599 600 error = FT_THROW( Invalid_File_Format ); 601 } 602 603 parser->error = error; 604 parser->cursor = cur; 605 } 606 607 608 FT_LOCAL_DEF( void ) 609 ps_parser_skip_spaces( PS_Parser parser ) 610 { 611 skip_spaces( &parser->cursor, parser->limit ); 612 } 613 614 615 /* `token' here means either something between balanced delimiters */ 616 /* or the next token; the delimiters are not removed. */ 617 618 FT_LOCAL_DEF( void ) 619 ps_parser_to_token( PS_Parser parser, 620 T1_Token token ) 621 { 622 FT_Byte* cur; 623 FT_Byte* limit; 624 FT_Int embed; 625 626 627 token->type = T1_TOKEN_TYPE_NONE; 628 token->start = 0; 629 token->limit = 0; 630 631 /* first of all, skip leading whitespace */ 632 ps_parser_skip_spaces( parser ); 633 634 cur = parser->cursor; 635 limit = parser->limit; 636 637 if ( cur >= limit ) 638 return; 639 640 switch ( *cur ) 641 { 642 /************* check for literal string *****************/ 643 case '(': 644 token->type = T1_TOKEN_TYPE_STRING; 645 token->start = cur; 646 647 if ( skip_literal_string( &cur, limit ) == FT_Err_Ok ) 648 token->limit = cur; 649 break; 650 651 /************* check for programs/array *****************/ 652 case '{': 653 token->type = T1_TOKEN_TYPE_ARRAY; 654 token->start = cur; 655 656 if ( skip_procedure( &cur, limit ) == FT_Err_Ok ) 657 token->limit = cur; 658 break; 659 660 /************* check for table/array ********************/ 661 /* XXX: in theory we should also look for "<<" */ 662 /* since this is semantically equivalent to "["; */ 663 /* in practice it doesn't matter (?) */ 664 case '[': 665 token->type = T1_TOKEN_TYPE_ARRAY; 666 embed = 1; 667 token->start = cur++; 668 669 /* we need this to catch `[ ]' */ 670 parser->cursor = cur; 671 ps_parser_skip_spaces( parser ); 672 cur = parser->cursor; 673 674 while ( cur < limit && !parser->error ) 675 { 676 /* XXX: this is wrong because it does not */ 677 /* skip comments, procedures, and strings */ 678 if ( *cur == '[' ) 679 embed++; 680 else if ( *cur == ']' ) 681 { 682 embed--; 683 if ( embed <= 0 ) 684 { 685 token->limit = ++cur; 686 break; 687 } 688 } 689 690 parser->cursor = cur; 691 ps_parser_skip_PS_token( parser ); 692 /* we need this to catch `[XXX ]' */ 693 ps_parser_skip_spaces ( parser ); 694 cur = parser->cursor; 695 } 696 break; 697 698 /* ************ otherwise, it is any token **************/ 699 default: 700 token->start = cur; 701 token->type = ( *cur == '/' ? T1_TOKEN_TYPE_KEY : T1_TOKEN_TYPE_ANY ); 702 ps_parser_skip_PS_token( parser ); 703 cur = parser->cursor; 704 if ( !parser->error ) 705 token->limit = cur; 706 } 707 708 if ( !token->limit ) 709 { 710 token->start = 0; 711 token->type = T1_TOKEN_TYPE_NONE; 712 } 713 714 parser->cursor = cur; 715 } 716 717 718 /* NB: `tokens' can be NULL if we only want to count */ 719 /* the number of array elements */ 720 721 FT_LOCAL_DEF( void ) 722 ps_parser_to_token_array( PS_Parser parser, 723 T1_Token tokens, 724 FT_UInt max_tokens, 725 FT_Int* pnum_tokens ) 726 { 727 T1_TokenRec master; 728 729 730 *pnum_tokens = -1; 731 732 /* this also handles leading whitespace */ 733 ps_parser_to_token( parser, &master ); 734 735 if ( master.type == T1_TOKEN_TYPE_ARRAY ) 736 { 737 FT_Byte* old_cursor = parser->cursor; 738 FT_Byte* old_limit = parser->limit; 739 T1_Token cur = tokens; 740 T1_Token limit = cur + max_tokens; 741 742 743 /* don't include outermost delimiters */ 744 parser->cursor = master.start + 1; 745 parser->limit = master.limit - 1; 746 747 while ( parser->cursor < parser->limit ) 748 { 749 T1_TokenRec token; 750 751 752 ps_parser_to_token( parser, &token ); 753 if ( !token.type ) 754 break; 755 756 if ( tokens != NULL && cur < limit ) 757 *cur = token; 758 759 cur++; 760 } 761 762 *pnum_tokens = (FT_Int)( cur - tokens ); 763 764 parser->cursor = old_cursor; 765 parser->limit = old_limit; 766 } 767 } 768 769 770 /* first character must be a delimiter or a part of a number */ 771 /* NB: `coords' can be NULL if we just want to skip the */ 772 /* array; in this case we ignore `max_coords' */ 773 774 static FT_Int 775 ps_tocoordarray( FT_Byte* *acur, 776 FT_Byte* limit, 777 FT_Int max_coords, 778 FT_Short* coords ) 779 { 780 FT_Byte* cur = *acur; 781 FT_Int count = 0; 782 FT_Byte c, ender; 783 784 785 if ( cur >= limit ) 786 goto Exit; 787 788 /* check for the beginning of an array; otherwise, only one number */ 789 /* will be read */ 790 c = *cur; 791 ender = 0; 792 793 if ( c == '[' ) 794 ender = ']'; 795 else if ( c == '{' ) 796 ender = '}'; 797 798 if ( ender ) 799 cur++; 800 801 /* now, read the coordinates */ 802 while ( cur < limit ) 803 { 804 FT_Short dummy; 805 FT_Byte* old_cur; 806 807 808 /* skip whitespace in front of data */ 809 skip_spaces( &cur, limit ); 810 if ( cur >= limit ) 811 goto Exit; 812 813 if ( *cur == ender ) 814 { 815 cur++; 816 break; 817 } 818 819 old_cur = cur; 820 821 if ( coords != NULL && count >= max_coords ) 822 break; 823 824 /* call PS_Conv_ToFixed() even if coords == NULL */ 825 /* to properly parse number at `cur' */ 826 *( coords != NULL ? &coords[count] : &dummy ) = 827 (FT_Short)( PS_Conv_ToFixed( &cur, limit, 0 ) >> 16 ); 828 829 if ( old_cur == cur ) 830 { 831 count = -1; 832 goto Exit; 833 } 834 else 835 count++; 836 837 if ( !ender ) 838 break; 839 } 840 841 Exit: 842 *acur = cur; 843 return count; 844 } 845 846 847 /* first character must be a delimiter or a part of a number */ 848 /* NB: `values' can be NULL if we just want to skip the */ 849 /* array; in this case we ignore `max_values' */ 850 851 static FT_Int 852 ps_tofixedarray( FT_Byte* *acur, 853 FT_Byte* limit, 854 FT_Int max_values, 855 FT_Fixed* values, 856 FT_Int power_ten ) 857 { 858 FT_Byte* cur = *acur; 859 FT_Int count = 0; 860 FT_Byte c, ender; 861 862 863 if ( cur >= limit ) 864 goto Exit; 865 866 /* Check for the beginning of an array. Otherwise, only one number */ 867 /* will be read. */ 868 c = *cur; 869 ender = 0; 870 871 if ( c == '[' ) 872 ender = ']'; 873 else if ( c == '{' ) 874 ender = '}'; 875 876 if ( ender ) 877 cur++; 878 879 /* now, read the values */ 880 while ( cur < limit ) 881 { 882 FT_Fixed dummy; 883 FT_Byte* old_cur; 884 885 886 /* skip whitespace in front of data */ 887 skip_spaces( &cur, limit ); 888 if ( cur >= limit ) 889 goto Exit; 890 891 if ( *cur == ender ) 892 { 893 cur++; 894 break; 895 } 896 897 old_cur = cur; 898 899 if ( values != NULL && count >= max_values ) 900 break; 901 902 /* call PS_Conv_ToFixed() even if coords == NULL */ 903 /* to properly parse number at `cur' */ 904 *( values != NULL ? &values[count] : &dummy ) = 905 PS_Conv_ToFixed( &cur, limit, power_ten ); 906 907 if ( old_cur == cur ) 908 { 909 count = -1; 910 goto Exit; 911 } 912 else 913 count++; 914 915 if ( !ender ) 916 break; 917 } 918 919 Exit: 920 *acur = cur; 921 return count; 922 } 923 924 925#if 0 926 927 static FT_String* 928 ps_tostring( FT_Byte** cursor, 929 FT_Byte* limit, 930 FT_Memory memory ) 931 { 932 FT_Byte* cur = *cursor; 933 FT_PtrDist len = 0; 934 FT_Int count; 935 FT_String* result; 936 FT_Error error; 937 938 939 /* XXX: some stupid fonts have a `Notice' or `Copyright' string */ 940 /* that simply doesn't begin with an opening parenthesis, even */ 941 /* though they have a closing one! E.g. "amuncial.pfb" */ 942 /* */ 943 /* We must deal with these ill-fated cases there. Note that */ 944 /* these fonts didn't work with the old Type 1 driver as the */ 945 /* notice/copyright was not recognized as a valid string token */ 946 /* and made the old token parser commit errors. */ 947 948 while ( cur < limit && ( *cur == ' ' || *cur == '\t' ) ) 949 cur++; 950 if ( cur + 1 >= limit ) 951 return 0; 952 953 if ( *cur == '(' ) 954 cur++; /* skip the opening parenthesis, if there is one */ 955 956 *cursor = cur; 957 count = 0; 958 959 /* then, count its length */ 960 for ( ; cur < limit; cur++ ) 961 { 962 if ( *cur == '(' ) 963 count++; 964 965 else if ( *cur == ')' ) 966 { 967 count--; 968 if ( count < 0 ) 969 break; 970 } 971 } 972 973 len = cur - *cursor; 974 if ( cur >= limit || FT_ALLOC( result, len + 1 ) ) 975 return 0; 976 977 /* now copy the string */ 978 FT_MEM_COPY( result, *cursor, len ); 979 result[len] = '\0'; 980 *cursor = cur; 981 return result; 982 } 983 984#endif /* 0 */ 985 986 987 static int 988 ps_tobool( FT_Byte* *acur, 989 FT_Byte* limit ) 990 { 991 FT_Byte* cur = *acur; 992 FT_Bool result = 0; 993 994 995 /* return 1 if we find `true', 0 otherwise */ 996 if ( cur + 3 < limit && 997 cur[0] == 't' && 998 cur[1] == 'r' && 999 cur[2] == 'u' && 1000 cur[3] == 'e' ) 1001 { 1002 result = 1; 1003 cur += 5; 1004 } 1005 else if ( cur + 4 < limit && 1006 cur[0] == 'f' && 1007 cur[1] == 'a' && 1008 cur[2] == 'l' && 1009 cur[3] == 's' && 1010 cur[4] == 'e' ) 1011 { 1012 result = 0; 1013 cur += 6; 1014 } 1015 1016 *acur = cur; 1017 return result; 1018 } 1019 1020 1021 /* load a simple field (i.e. non-table) into the current list of objects */ 1022 1023 FT_LOCAL_DEF( FT_Error ) 1024 ps_parser_load_field( PS_Parser parser, 1025 const T1_Field field, 1026 void** objects, 1027 FT_UInt max_objects, 1028 FT_ULong* pflags ) 1029 { 1030 T1_TokenRec token; 1031 FT_Byte* cur; 1032 FT_Byte* limit; 1033 FT_UInt count; 1034 FT_UInt idx; 1035 FT_Error error; 1036 T1_FieldType type; 1037 1038 1039 /* this also skips leading whitespace */ 1040 ps_parser_to_token( parser, &token ); 1041 if ( !token.type ) 1042 goto Fail; 1043 1044 count = 1; 1045 idx = 0; 1046 cur = token.start; 1047 limit = token.limit; 1048 1049 type = field->type; 1050 1051 /* we must detect arrays in /FontBBox */ 1052 if ( type == T1_FIELD_TYPE_BBOX ) 1053 { 1054 T1_TokenRec token2; 1055 FT_Byte* old_cur = parser->cursor; 1056 FT_Byte* old_limit = parser->limit; 1057 1058 1059 /* don't include delimiters */ 1060 parser->cursor = token.start + 1; 1061 parser->limit = token.limit - 1; 1062 1063 ps_parser_to_token( parser, &token2 ); 1064 parser->cursor = old_cur; 1065 parser->limit = old_limit; 1066 1067 if ( token2.type == T1_TOKEN_TYPE_ARRAY ) 1068 { 1069 type = T1_FIELD_TYPE_MM_BBOX; 1070 goto FieldArray; 1071 } 1072 } 1073 else if ( token.type == T1_TOKEN_TYPE_ARRAY ) 1074 { 1075 count = max_objects; 1076 1077 FieldArray: 1078 /* if this is an array and we have no blend, an error occurs */ 1079 if ( max_objects == 0 ) 1080 goto Fail; 1081 1082 idx = 1; 1083 1084 /* don't include delimiters */ 1085 cur++; 1086 limit--; 1087 } 1088 1089 for ( ; count > 0; count--, idx++ ) 1090 { 1091 FT_Byte* q = (FT_Byte*)objects[idx] + field->offset; 1092 FT_Long val; 1093 FT_String* string; 1094 1095 1096 skip_spaces( &cur, limit ); 1097 1098 switch ( type ) 1099 { 1100 case T1_FIELD_TYPE_BOOL: 1101 val = ps_tobool( &cur, limit ); 1102 goto Store_Integer; 1103 1104 case T1_FIELD_TYPE_FIXED: 1105 val = PS_Conv_ToFixed( &cur, limit, 0 ); 1106 goto Store_Integer; 1107 1108 case T1_FIELD_TYPE_FIXED_1000: 1109 val = PS_Conv_ToFixed( &cur, limit, 3 ); 1110 goto Store_Integer; 1111 1112 case T1_FIELD_TYPE_INTEGER: 1113 { FT_Bool ret = xyq_PS_Conv_ToInt( &cur, limit, &val ); /* XYQ 2007-10-10: abort if not a number*/ 1114 if (!ret) break; } 1115 /* fall through */ 1116 1117 Store_Integer: 1118 switch ( field->size ) 1119 { 1120 case (8 / FT_CHAR_BIT): 1121 *(FT_Byte*)q = (FT_Byte)val; 1122 break; 1123 1124 case (16 / FT_CHAR_BIT): 1125 *(FT_UShort*)q = (FT_UShort)val; 1126 break; 1127 1128 case (32 / FT_CHAR_BIT): 1129 *(FT_UInt32*)q = (FT_UInt32)val; 1130 break; 1131 1132 default: /* for 64-bit systems */ 1133 *(FT_Long*)q = val; 1134 } 1135 break; 1136 1137 case T1_FIELD_TYPE_STRING: 1138 case T1_FIELD_TYPE_KEY: 1139 { 1140 FT_Memory memory = parser->memory; 1141 FT_UInt len = (FT_UInt)( limit - cur ); 1142 1143 1144 if ( cur >= limit ) 1145 break; 1146 1147 /* we allow both a string or a name */ 1148 /* for cases like /FontName (foo) def */ 1149 if ( token.type == T1_TOKEN_TYPE_KEY ) 1150 { 1151 /* don't include leading `/' */ 1152 len--; 1153 cur++; 1154 } 1155 else if ( token.type == T1_TOKEN_TYPE_STRING ) 1156 { 1157 /* don't include delimiting parentheses */ 1158 /* XXX we don't handle <<...>> here */ 1159 /* XXX should we convert octal escapes? */ 1160 /* if so, what encoding should we use? */ 1161 cur++; 1162 len -= 2; 1163 } 1164 else 1165 { 1166 FT_ERROR(( "ps_parser_load_field:" 1167 " expected a name or string\n" 1168 " " 1169 " but found token of type %d instead\n", 1170 token.type )); 1171 error = FT_THROW( Invalid_File_Format ); 1172 goto Exit; 1173 } 1174 1175 /* for this to work (FT_String**)q must have been */ 1176 /* initialized to NULL */ 1177 if ( *(FT_String**)q != NULL ) 1178 { 1179 FT_TRACE0(( "ps_parser_load_field: overwriting field %s\n", 1180 field->ident )); 1181 FT_FREE( *(FT_String**)q ); 1182 *(FT_String**)q = NULL; 1183 } 1184 1185 if ( FT_ALLOC( string, len + 1 ) ) 1186 goto Exit; 1187 1188 FT_MEM_COPY( string, cur, len ); 1189 string[len] = 0; 1190 1191 *(FT_String**)q = string; 1192 } 1193 break; 1194 1195 case T1_FIELD_TYPE_BBOX: 1196 { 1197 // Add by Johnson, fix a Error #1: UNINITIALIZED READ. #testdoc 1282.pdf 1198 FT_Fixed temp[4] = {0,0,0,0}; 1199 FT_BBox* bbox = (FT_BBox*)q; 1200 FT_Int result; 1201 1202 1203 result = ps_tofixedarray( &cur, limit, 4, temp, 0 ); 1204 1205 if ( result < 0 ) 1206 { 1207 FT_ERROR(( "ps_parser_load_field:" 1208 " expected four integers in bounding box\n" )); 1209 error = FT_THROW( Invalid_File_Format ); 1210 goto Exit; 1211 } 1212 1213 bbox->xMin = FT_RoundFix( temp[0] ); 1214 bbox->yMin = FT_RoundFix( temp[1] ); 1215 bbox->xMax = FT_RoundFix( temp[2] ); 1216 bbox->yMax = FT_RoundFix( temp[3] ); 1217 } 1218 break; 1219 1220 case T1_FIELD_TYPE_MM_BBOX: 1221 { 1222 FT_Memory memory = parser->memory; 1223 FT_Fixed* temp; 1224 FT_Int result; 1225 FT_UInt i; 1226 1227 1228 if ( FT_NEW_ARRAY( temp, max_objects * 4 ) ) 1229 goto Exit; 1230 1231 for ( i = 0; i < 4; i++ ) 1232 { 1233 result = ps_tofixedarray( &cur, limit, max_objects, 1234 temp + i * max_objects, 0 ); 1235 if ( result < 0 ) 1236 { 1237 FT_ERROR(( "ps_parser_load_field:" 1238 " expected %d integers in the %s subarray\n" 1239 " " 1240 " of /FontBBox in the /Blend dictionary\n", 1241 max_objects, 1242 i == 0 ? "first" 1243 : ( i == 1 ? "second" 1244 : ( i == 2 ? "third" 1245 : "fourth" ) ) )); 1246 error = FT_THROW( Invalid_File_Format ); 1247 goto Exit; 1248 } 1249 1250 skip_spaces( &cur, limit ); 1251 } 1252 1253 for ( i = 0; i < max_objects; i++ ) 1254 { 1255 FT_BBox* bbox = (FT_BBox*)objects[i]; 1256 1257 1258 bbox->xMin = FT_RoundFix( temp[i ] ); 1259 bbox->yMin = FT_RoundFix( temp[i + max_objects] ); 1260 bbox->xMax = FT_RoundFix( temp[i + 2 * max_objects] ); 1261 bbox->yMax = FT_RoundFix( temp[i + 3 * max_objects] ); 1262 } 1263 1264 FT_FREE( temp ); 1265 } 1266 break; 1267 1268 default: 1269 /* an error occurred */ 1270 goto Fail; 1271 } 1272 } 1273 1274#if 0 /* obsolete -- keep for reference */ 1275 if ( pflags ) 1276 *pflags |= 1L << field->flag_bit; 1277#else 1278 FT_UNUSED( pflags ); 1279#endif 1280 1281 error = FT_Err_Ok; 1282 1283 Exit: 1284 return error; 1285 1286 Fail: 1287 error = FT_THROW( Invalid_File_Format ); 1288 goto Exit; 1289 } 1290 1291 1292#define T1_MAX_TABLE_ELEMENTS 32 1293 1294 1295 FT_LOCAL_DEF( FT_Error ) 1296 ps_parser_load_field_table( PS_Parser parser, 1297 const T1_Field field, 1298 void** objects, 1299 FT_UInt max_objects, 1300 FT_ULong* pflags ) 1301 { 1302 T1_TokenRec elements[T1_MAX_TABLE_ELEMENTS]; 1303 T1_Token token; 1304 FT_Int num_elements; 1305 FT_Error error = FT_Err_Ok; 1306 FT_Byte* old_cursor; 1307 FT_Byte* old_limit; 1308 T1_FieldRec fieldrec = *(T1_Field)field; 1309 1310 1311 fieldrec.type = T1_FIELD_TYPE_INTEGER; 1312 if ( field->type == T1_FIELD_TYPE_FIXED_ARRAY || 1313 field->type == T1_FIELD_TYPE_BBOX ) 1314 fieldrec.type = T1_FIELD_TYPE_FIXED; 1315 1316 ps_parser_to_token_array( parser, elements, 1317 T1_MAX_TABLE_ELEMENTS, &num_elements ); 1318 if ( num_elements < 0 ) 1319 { 1320 error = FT_ERR( Ignore ); 1321 goto Exit; 1322 } 1323 if ( (FT_UInt)num_elements > field->array_max ) 1324 num_elements = field->array_max; 1325 1326 old_cursor = parser->cursor; 1327 old_limit = parser->limit; 1328 1329 /* we store the elements count if necessary; */ 1330 /* we further assume that `count_offset' can't be zero */ 1331 if ( field->type != T1_FIELD_TYPE_BBOX && field->count_offset != 0 ) 1332 *(FT_Byte*)( (FT_Byte*)objects[0] + field->count_offset ) = 1333 (FT_Byte)num_elements; 1334 1335 /* we now load each element, adjusting the field.offset on each one */ 1336 token = elements; 1337 for ( ; num_elements > 0; num_elements--, token++ ) 1338 { 1339 parser->cursor = token->start; 1340 parser->limit = token->limit; 1341 ps_parser_load_field( parser, &fieldrec, objects, max_objects, 0 ); 1342 fieldrec.offset += fieldrec.size; 1343 } 1344 1345#if 0 /* obsolete -- keep for reference */ 1346 if ( pflags ) 1347 *pflags |= 1L << field->flag_bit; 1348#else 1349 FT_UNUSED( pflags ); 1350#endif 1351 1352 parser->cursor = old_cursor; 1353 parser->limit = old_limit; 1354 1355 Exit: 1356 return error; 1357 } 1358 1359 1360 FT_LOCAL_DEF( FT_Long ) 1361 ps_parser_to_int( PS_Parser parser ) 1362 { 1363 ps_parser_skip_spaces( parser ); 1364 return PS_Conv_ToInt( &parser->cursor, parser->limit ); 1365 } 1366 1367 1368 /* first character must be `<' if `delimiters' is non-zero */ 1369 1370 FT_LOCAL_DEF( FT_Error ) 1371 ps_parser_to_bytes( PS_Parser parser, 1372 FT_Byte* bytes, 1373 FT_Offset max_bytes, 1374 FT_Long* pnum_bytes, 1375 FT_Bool delimiters ) 1376 { 1377 FT_Error error = FT_Err_Ok; 1378 FT_Byte* cur; 1379 1380 1381 ps_parser_skip_spaces( parser ); 1382 cur = parser->cursor; 1383 1384 if ( cur >= parser->limit ) 1385 goto Exit; 1386 1387 if ( delimiters ) 1388 { 1389 if ( *cur != '<' ) 1390 { 1391 FT_ERROR(( "ps_parser_to_bytes: Missing starting delimiter `<'\n" )); 1392 error = FT_THROW( Invalid_File_Format ); 1393 goto Exit; 1394 } 1395 1396 cur++; 1397 } 1398 1399 *pnum_bytes = PS_Conv_ASCIIHexDecode( &cur, 1400 parser->limit, 1401 bytes, 1402 max_bytes ); 1403 1404 if ( delimiters ) 1405 { 1406 if ( cur < parser->limit && *cur != '>' ) 1407 { 1408 FT_ERROR(( "ps_parser_to_bytes: Missing closing delimiter `>'\n" )); 1409 error = FT_THROW( Invalid_File_Format ); 1410 goto Exit; 1411 } 1412 1413 cur++; 1414 } 1415 1416 parser->cursor = cur; 1417 1418 Exit: 1419 return error; 1420 } 1421 1422 1423 FT_LOCAL_DEF( FT_Fixed ) 1424 ps_parser_to_fixed( PS_Parser parser, 1425 FT_Int power_ten ) 1426 { 1427 ps_parser_skip_spaces( parser ); 1428 return PS_Conv_ToFixed( &parser->cursor, parser->limit, power_ten ); 1429 } 1430 1431 1432 FT_LOCAL_DEF( FT_Int ) 1433 ps_parser_to_coord_array( PS_Parser parser, 1434 FT_Int max_coords, 1435 FT_Short* coords ) 1436 { 1437 ps_parser_skip_spaces( parser ); 1438 return ps_tocoordarray( &parser->cursor, parser->limit, 1439 max_coords, coords ); 1440 } 1441 1442 1443 FT_LOCAL_DEF( FT_Int ) 1444 ps_parser_to_fixed_array( PS_Parser parser, 1445 FT_Int max_values, 1446 FT_Fixed* values, 1447 FT_Int power_ten ) 1448 { 1449 ps_parser_skip_spaces( parser ); 1450 return ps_tofixedarray( &parser->cursor, parser->limit, 1451 max_values, values, power_ten ); 1452 } 1453 1454 1455#if 0 1456 1457 FT_LOCAL_DEF( FT_String* ) 1458 T1_ToString( PS_Parser parser ) 1459 { 1460 return ps_tostring( &parser->cursor, parser->limit, parser->memory ); 1461 } 1462 1463 1464 FT_LOCAL_DEF( FT_Bool ) 1465 T1_ToBool( PS_Parser parser ) 1466 { 1467 return ps_tobool( &parser->cursor, parser->limit ); 1468 } 1469 1470#endif /* 0 */ 1471 1472 1473 FT_LOCAL_DEF( void ) 1474 ps_parser_init( PS_Parser parser, 1475 FT_Byte* base, 1476 FT_Byte* limit, 1477 FT_Memory memory ) 1478 { 1479 parser->error = FT_Err_Ok; 1480 parser->base = base; 1481 parser->limit = limit; 1482 parser->cursor = base; 1483 parser->memory = memory; 1484 parser->funcs = ps_parser_funcs; 1485 } 1486 1487 1488 FT_LOCAL_DEF( void ) 1489 ps_parser_done( PS_Parser parser ) 1490 { 1491 FT_UNUSED( parser ); 1492 } 1493 1494 1495 /*************************************************************************/ 1496 /*************************************************************************/ 1497 /***** *****/ 1498 /***** T1 BUILDER *****/ 1499 /***** *****/ 1500 /*************************************************************************/ 1501 /*************************************************************************/ 1502 1503 /*************************************************************************/ 1504 /* */ 1505 /* <Function> */ 1506 /* t1_builder_init */ 1507 /* */ 1508 /* <Description> */ 1509 /* Initializes a given glyph builder. */ 1510 /* */ 1511 /* <InOut> */ 1512 /* builder :: A pointer to the glyph builder to initialize. */ 1513 /* */ 1514 /* <Input> */ 1515 /* face :: The current face object. */ 1516 /* */ 1517 /* size :: The current size object. */ 1518 /* */ 1519 /* glyph :: The current glyph object. */ 1520 /* */ 1521 /* hinting :: Whether hinting should be applied. */ 1522 /* */ 1523 FT_LOCAL_DEF( void ) 1524 t1_builder_init( T1_Builder builder, 1525 FT_Face face, 1526 FT_Size size, 1527 FT_GlyphSlot glyph, 1528 FT_Bool hinting ) 1529 { 1530 builder->parse_state = T1_Parse_Start; 1531 builder->load_points = 1; 1532 1533 builder->face = face; 1534 builder->glyph = glyph; 1535 builder->memory = face->memory; 1536 1537 if ( glyph ) 1538 { 1539 FT_GlyphLoader loader = glyph->internal->loader; 1540 1541 1542 builder->loader = loader; 1543 builder->base = &loader->base.outline; 1544 builder->current = &loader->current.outline; 1545 FT_GlyphLoader_Rewind( loader ); 1546 1547 builder->hints_globals = size->internal; 1548 builder->hints_funcs = 0; 1549 1550 if ( hinting ) 1551 builder->hints_funcs = glyph->internal->glyph_hints; 1552 } 1553 1554 builder->pos_x = 0; 1555 builder->pos_y = 0; 1556 1557 builder->left_bearing.x = 0; 1558 builder->left_bearing.y = 0; 1559 builder->advance.x = 0; 1560 builder->advance.y = 0; 1561 1562 builder->funcs = t1_builder_funcs; 1563 } 1564 1565 1566 /*************************************************************************/ 1567 /* */ 1568 /* <Function> */ 1569 /* t1_builder_done */ 1570 /* */ 1571 /* <Description> */ 1572 /* Finalizes a given glyph builder. Its contents can still be used */ 1573 /* after the call, but the function saves important information */ 1574 /* within the corresponding glyph slot. */ 1575 /* */ 1576 /* <Input> */ 1577 /* builder :: A pointer to the glyph builder to finalize. */ 1578 /* */ 1579 FT_LOCAL_DEF( void ) 1580 t1_builder_done( T1_Builder builder ) 1581 { 1582 FT_GlyphSlot glyph = builder->glyph; 1583 1584 1585 if ( glyph ) 1586 glyph->outline = *builder->base; 1587 } 1588 1589 1590 /* check that there is enough space for `count' more points */ 1591 FT_LOCAL_DEF( FT_Error ) 1592 t1_builder_check_points( T1_Builder builder, 1593 FT_Int count ) 1594 { 1595 return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 ); 1596 } 1597 1598 1599 /* add a new point, do not check space */ 1600 FT_LOCAL_DEF( void ) 1601 t1_builder_add_point( T1_Builder builder, 1602 FT_Pos x, 1603 FT_Pos y, 1604 FT_Byte flag ) 1605 { 1606 FT_Outline* outline = builder->current; 1607 1608 1609 if ( builder->load_points ) 1610 { 1611 FT_Vector* point = outline->points + outline->n_points; 1612 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points; 1613 1614 1615 point->x = FIXED_TO_INT( x ); 1616 point->y = FIXED_TO_INT( y ); 1617 *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC ); 1618 } 1619 outline->n_points++; 1620 } 1621 1622 1623 /* check space for a new on-curve point, then add it */ 1624 FT_LOCAL_DEF( FT_Error ) 1625 t1_builder_add_point1( T1_Builder builder, 1626 FT_Pos x, 1627 FT_Pos y ) 1628 { 1629 FT_Error error; 1630 1631 1632 error = t1_builder_check_points( builder, 1 ); 1633 if ( !error ) 1634 t1_builder_add_point( builder, x, y, 1 ); 1635 1636 return error; 1637 } 1638 1639 1640 /* check space for a new contour, then add it */ 1641 FT_LOCAL_DEF( FT_Error ) 1642 t1_builder_add_contour( T1_Builder builder ) 1643 { 1644 FT_Outline* outline = builder->current; 1645 FT_Error error; 1646 1647 1648 /* this might happen in invalid fonts */ 1649 if ( !outline ) 1650 { 1651 FT_ERROR(( "t1_builder_add_contour: no outline to add points to\n" )); 1652 return FT_THROW( Invalid_File_Format ); 1653 } 1654 1655 if ( !builder->load_points ) 1656 { 1657 outline->n_contours++; 1658 return FT_Err_Ok; 1659 } 1660 1661 error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 ); 1662 if ( !error ) 1663 { 1664 if ( outline->n_contours > 0 ) 1665 outline->contours[outline->n_contours - 1] = 1666 (short)( outline->n_points - 1 ); 1667 1668 outline->n_contours++; 1669 } 1670 1671 return error; 1672 } 1673 1674 1675 /* if a path was begun, add its first on-curve point */ 1676 FT_LOCAL_DEF( FT_Error ) 1677 t1_builder_start_point( T1_Builder builder, 1678 FT_Pos x, 1679 FT_Pos y ) 1680 { 1681 FT_Error error = FT_ERR( Invalid_File_Format ); 1682 1683 1684 /* test whether we are building a new contour */ 1685 1686 if ( builder->parse_state == T1_Parse_Have_Path ) 1687 error = FT_Err_Ok; 1688 else 1689 { 1690 builder->parse_state = T1_Parse_Have_Path; 1691 error = t1_builder_add_contour( builder ); 1692 if ( !error ) 1693 error = t1_builder_add_point1( builder, x, y ); 1694 } 1695 1696 return error; 1697 } 1698 1699 1700 /* close the current contour */ 1701 FT_LOCAL_DEF( void ) 1702 t1_builder_close_contour( T1_Builder builder ) 1703 { 1704 FT_Outline* outline = builder->current; 1705 FT_Int first; 1706 1707 1708 if ( !outline ) 1709 return; 1710 1711 first = outline->n_contours <= 1 1712 ? 0 : outline->contours[outline->n_contours - 2] + 1; 1713 1714 /* We must not include the last point in the path if it */ 1715 /* is located on the first point. */ 1716 if ( outline->n_points > 1 ) 1717 { 1718 FT_Vector* p1 = outline->points + first; 1719 FT_Vector* p2 = outline->points + outline->n_points - 1; 1720 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1; 1721 1722 1723 /* `delete' last point only if it coincides with the first */ 1724 /* point and it is not a control point (which can happen). */ 1725 if ( p1->x == p2->x && p1->y == p2->y ) 1726 if ( *control == FT_CURVE_TAG_ON ) 1727 outline->n_points--; 1728 } 1729 1730 if ( outline->n_contours > 0 ) 1731 { 1732 /* Don't add contours only consisting of one point, i.e., */ 1733 /* check whether the first and the last point is the same. */ 1734 if ( first == outline->n_points - 1 ) 1735 { 1736 outline->n_contours--; 1737 outline->n_points--; 1738 } 1739 else 1740 outline->contours[outline->n_contours - 1] = 1741 (short)( outline->n_points - 1 ); 1742 } 1743 } 1744 1745 1746 /*************************************************************************/ 1747 /*************************************************************************/ 1748 /***** *****/ 1749 /***** OTHER *****/ 1750 /***** *****/ 1751 /*************************************************************************/ 1752 /*************************************************************************/ 1753 1754 FT_LOCAL_DEF( void ) 1755 t1_decrypt( FT_Byte* buffer, 1756 FT_Offset length, 1757 FT_UShort seed ) 1758 { 1759 PS_Conv_EexecDecode( &buffer, 1760 buffer + length, 1761 buffer, 1762 length, 1763 &seed ); 1764 } 1765 1766 1767/* END */ 1768