1 /**************************************************************************** 2 * 3 * cffparse.c 4 * 5 * CFF token stream parser (body) 6 * 7 * Copyright (C) 1996-2022 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 "cffparse.h" 20 #include <freetype/internal/ftstream.h> 21 #include <freetype/internal/ftdebug.h> 22 #include <freetype/internal/ftcalc.h> 23 #include <freetype/internal/psaux.h> 24 #include <freetype/ftlist.h> 25 26 #include "cfferrs.h" 27 #include "cffload.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 cffparse 38 39 40 FT_LOCAL_DEF( FT_Error ) cff_parser_init(CFF_Parser parser,FT_UInt code,void * object,FT_Library library,FT_UInt stackSize,FT_UShort num_designs,FT_UShort num_axes)41 cff_parser_init( CFF_Parser parser, 42 FT_UInt code, 43 void* object, 44 FT_Library library, 45 FT_UInt stackSize, 46 FT_UShort num_designs, 47 FT_UShort num_axes ) 48 { 49 FT_Memory memory = library->memory; /* for FT_NEW_ARRAY */ 50 FT_Error error; /* for FT_NEW_ARRAY */ 51 52 53 FT_ZERO( parser ); 54 55 #if 0 56 parser->top = parser->stack; 57 #endif 58 parser->object_code = code; 59 parser->object = object; 60 parser->library = library; 61 parser->num_designs = num_designs; 62 parser->num_axes = num_axes; 63 64 /* allocate the stack buffer */ 65 if ( FT_QNEW_ARRAY( parser->stack, stackSize ) ) 66 { 67 FT_FREE( parser->stack ); 68 goto Exit; 69 } 70 71 parser->stackSize = stackSize; 72 parser->top = parser->stack; /* empty stack */ 73 74 Exit: 75 return error; 76 } 77 78 79 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE 80 static void finalize_t2_strings(FT_Memory memory,void * data,void * user)81 finalize_t2_strings( FT_Memory memory, 82 void* data, 83 void* user ) 84 { 85 CFF_T2_String t2 = (CFF_T2_String)data; 86 87 88 FT_UNUSED( user ); 89 90 memory->free( memory, t2->start ); 91 memory->free( memory, data ); 92 } 93 #endif /* CFF_CONFIG_OPTION_OLD_ENGINE */ 94 95 96 FT_LOCAL_DEF( void ) cff_parser_done(CFF_Parser parser)97 cff_parser_done( CFF_Parser parser ) 98 { 99 FT_Memory memory = parser->library->memory; /* for FT_FREE */ 100 101 102 FT_FREE( parser->stack ); 103 104 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE 105 FT_List_Finalize( &parser->t2_strings, 106 finalize_t2_strings, 107 memory, 108 NULL ); 109 #endif 110 } 111 112 113 /* Assuming `first >= last'. */ 114 115 static FT_Error cff_parser_within_limits(CFF_Parser parser,FT_Byte * first,FT_Byte * last)116 cff_parser_within_limits( CFF_Parser parser, 117 FT_Byte* first, 118 FT_Byte* last ) 119 { 120 #ifndef CFF_CONFIG_OPTION_OLD_ENGINE 121 122 /* Fast path for regular FreeType builds with the "new" engine; */ 123 /* `first >= parser->start' can be assumed. */ 124 125 FT_UNUSED( first ); 126 127 return last < parser->limit ? FT_Err_Ok : FT_THROW( Invalid_Argument ); 128 129 #else /* CFF_CONFIG_OPTION_OLD_ENGINE */ 130 131 FT_ListNode node; 132 133 134 if ( first >= parser->start && 135 last < parser->limit ) 136 return FT_Err_Ok; 137 138 node = parser->t2_strings.head; 139 140 while ( node ) 141 { 142 CFF_T2_String t2 = (CFF_T2_String)node->data; 143 144 145 if ( first >= t2->start && 146 last < t2->limit ) 147 return FT_Err_Ok; 148 149 node = node->next; 150 } 151 152 return FT_THROW( Invalid_Argument ); 153 154 #endif /* CFF_CONFIG_OPTION_OLD_ENGINE */ 155 } 156 157 158 /* read an integer */ 159 static FT_Long cff_parse_integer(CFF_Parser parser,FT_Byte * start)160 cff_parse_integer( CFF_Parser parser, 161 FT_Byte* start ) 162 { 163 FT_Byte* p = start; 164 FT_Int v = *p++; 165 FT_Long val = 0; 166 167 168 if ( v == 28 ) 169 { 170 if ( cff_parser_within_limits( parser, p, p + 1 ) ) 171 goto Bad; 172 173 val = (FT_Short)( ( (FT_UShort)p[0] << 8 ) | p[1] ); 174 } 175 else if ( v == 29 ) 176 { 177 if ( cff_parser_within_limits( parser, p, p + 3 ) ) 178 goto Bad; 179 180 val = (FT_Long)( ( (FT_ULong)p[0] << 24 ) | 181 ( (FT_ULong)p[1] << 16 ) | 182 ( (FT_ULong)p[2] << 8 ) | 183 (FT_ULong)p[3] ); 184 } 185 else if ( v < 247 ) 186 { 187 val = v - 139; 188 } 189 else if ( v < 251 ) 190 { 191 if ( cff_parser_within_limits( parser, p, p ) ) 192 goto Bad; 193 194 val = ( v - 247 ) * 256 + p[0] + 108; 195 } 196 else 197 { 198 if ( cff_parser_within_limits( parser, p, p ) ) 199 goto Bad; 200 201 val = -( v - 251 ) * 256 - p[0] - 108; 202 } 203 204 Exit: 205 return val; 206 207 Bad: 208 val = 0; 209 FT_TRACE4(( "!!!END OF DATA:!!!" )); 210 goto Exit; 211 } 212 213 214 static const FT_Long power_tens[] = 215 { 216 1L, 217 10L, 218 100L, 219 1000L, 220 10000L, 221 100000L, 222 1000000L, 223 10000000L, 224 100000000L, 225 1000000000L 226 }; 227 228 /* maximum values allowed for multiplying */ 229 /* with the corresponding `power_tens' element */ 230 static const FT_Long power_ten_limits[] = 231 { 232 FT_LONG_MAX / 1L, 233 FT_LONG_MAX / 10L, 234 FT_LONG_MAX / 100L, 235 FT_LONG_MAX / 1000L, 236 FT_LONG_MAX / 10000L, 237 FT_LONG_MAX / 100000L, 238 FT_LONG_MAX / 1000000L, 239 FT_LONG_MAX / 10000000L, 240 FT_LONG_MAX / 100000000L, 241 FT_LONG_MAX / 1000000000L, 242 }; 243 244 245 /* read a real */ 246 static FT_Fixed cff_parse_real(CFF_Parser parser,FT_Byte * start,FT_Long power_ten,FT_Long * scaling)247 cff_parse_real( CFF_Parser parser, 248 FT_Byte* start, 249 FT_Long power_ten, 250 FT_Long* scaling ) 251 { 252 FT_Byte* p = start; 253 FT_Int nib; 254 FT_UInt phase; 255 256 FT_Long result, number, exponent; 257 FT_Int sign = 0, exponent_sign = 0, have_overflow = 0; 258 FT_Long exponent_add, integer_length, fraction_length; 259 260 261 if ( scaling ) 262 *scaling = 0; 263 264 result = 0; 265 266 number = 0; 267 exponent = 0; 268 269 exponent_add = 0; 270 integer_length = 0; 271 fraction_length = 0; 272 273 /* First of all, read the integer part. */ 274 phase = 4; 275 276 for (;;) 277 { 278 /* If we entered this iteration with phase == 4, we need to */ 279 /* read a new byte. This also skips past the initial 0x1E. */ 280 if ( phase ) 281 { 282 p++; 283 284 /* Make sure we don't read past the end. */ 285 if ( cff_parser_within_limits( parser, p, p ) ) 286 goto Bad; 287 } 288 289 /* Get the nibble. */ 290 nib = (FT_Int)( p[0] >> phase ) & 0xF; 291 phase = 4 - phase; 292 293 if ( nib == 0xE ) 294 sign = 1; 295 else if ( nib > 9 ) 296 break; 297 else 298 { 299 /* Increase exponent if we can't add the digit. */ 300 if ( number >= 0xCCCCCCCL ) 301 exponent_add++; 302 /* Skip leading zeros. */ 303 else if ( nib || number ) 304 { 305 integer_length++; 306 number = number * 10 + nib; 307 } 308 } 309 } 310 311 /* Read fraction part, if any. */ 312 if ( nib == 0xA ) 313 for (;;) 314 { 315 /* If we entered this iteration with phase == 4, we need */ 316 /* to read a new byte. */ 317 if ( phase ) 318 { 319 p++; 320 321 /* Make sure we don't read past the end. */ 322 if ( cff_parser_within_limits( parser, p, p ) ) 323 goto Bad; 324 } 325 326 /* Get the nibble. */ 327 nib = ( p[0] >> phase ) & 0xF; 328 phase = 4 - phase; 329 if ( nib >= 10 ) 330 break; 331 332 /* Skip leading zeros if possible. */ 333 if ( !nib && !number ) 334 exponent_add--; 335 /* Only add digit if we don't overflow. */ 336 else if ( number < 0xCCCCCCCL && fraction_length < 9 ) 337 { 338 fraction_length++; 339 number = number * 10 + nib; 340 } 341 } 342 343 /* Read exponent, if any. */ 344 if ( nib == 12 ) 345 { 346 exponent_sign = 1; 347 nib = 11; 348 } 349 350 if ( nib == 11 ) 351 { 352 for (;;) 353 { 354 /* If we entered this iteration with phase == 4, */ 355 /* we need to read a new byte. */ 356 if ( phase ) 357 { 358 p++; 359 360 /* Make sure we don't read past the end. */ 361 if ( cff_parser_within_limits( parser, p, p ) ) 362 goto Bad; 363 } 364 365 /* Get the nibble. */ 366 nib = ( p[0] >> phase ) & 0xF; 367 phase = 4 - phase; 368 if ( nib >= 10 ) 369 break; 370 371 /* Arbitrarily limit exponent. */ 372 if ( exponent > 1000 ) 373 have_overflow = 1; 374 else 375 exponent = exponent * 10 + nib; 376 } 377 378 if ( exponent_sign ) 379 exponent = -exponent; 380 } 381 382 if ( !number ) 383 goto Exit; 384 385 if ( have_overflow ) 386 { 387 if ( exponent_sign ) 388 goto Underflow; 389 else 390 goto Overflow; 391 } 392 393 /* We don't check `power_ten' and `exponent_add'. */ 394 exponent += power_ten + exponent_add; 395 396 if ( scaling ) 397 { 398 /* Only use `fraction_length'. */ 399 fraction_length += integer_length; 400 exponent += integer_length; 401 402 if ( fraction_length <= 5 ) 403 { 404 if ( number > 0x7FFFL ) 405 { 406 result = FT_DivFix( number, 10 ); 407 *scaling = exponent - fraction_length + 1; 408 } 409 else 410 { 411 if ( exponent > 0 ) 412 { 413 FT_Long new_fraction_length, shift; 414 415 416 /* Make `scaling' as small as possible. */ 417 new_fraction_length = FT_MIN( exponent, 5 ); 418 shift = new_fraction_length - fraction_length; 419 420 if ( shift > 0 ) 421 { 422 exponent -= new_fraction_length; 423 number *= power_tens[shift]; 424 if ( number > 0x7FFFL ) 425 { 426 number /= 10; 427 exponent += 1; 428 } 429 } 430 else 431 exponent -= fraction_length; 432 } 433 else 434 exponent -= fraction_length; 435 436 result = (FT_Long)( (FT_ULong)number << 16 ); 437 *scaling = exponent; 438 } 439 } 440 else 441 { 442 if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL ) 443 { 444 result = FT_DivFix( number, power_tens[fraction_length - 4] ); 445 *scaling = exponent - 4; 446 } 447 else 448 { 449 result = FT_DivFix( number, power_tens[fraction_length - 5] ); 450 *scaling = exponent - 5; 451 } 452 } 453 } 454 else 455 { 456 integer_length += exponent; 457 fraction_length -= exponent; 458 459 if ( integer_length > 5 ) 460 goto Overflow; 461 if ( integer_length < -5 ) 462 goto Underflow; 463 464 /* Remove non-significant digits. */ 465 if ( integer_length < 0 ) 466 { 467 number /= power_tens[-integer_length]; 468 fraction_length += integer_length; 469 } 470 471 /* this can only happen if exponent was non-zero */ 472 if ( fraction_length == 10 ) 473 { 474 number /= 10; 475 fraction_length -= 1; 476 } 477 478 /* Convert into 16.16 format. */ 479 if ( fraction_length > 0 ) 480 { 481 if ( ( number / power_tens[fraction_length] ) > 0x7FFFL ) 482 goto Exit; 483 484 result = FT_DivFix( number, power_tens[fraction_length] ); 485 } 486 else 487 { 488 number *= power_tens[-fraction_length]; 489 490 if ( number > 0x7FFFL ) 491 goto Overflow; 492 493 result = (FT_Long)( (FT_ULong)number << 16 ); 494 } 495 } 496 497 Exit: 498 if ( sign ) 499 result = -result; 500 501 return result; 502 503 Overflow: 504 result = 0x7FFFFFFFL; 505 FT_TRACE4(( "!!!OVERFLOW:!!!" )); 506 goto Exit; 507 508 Underflow: 509 result = 0; 510 FT_TRACE4(( "!!!UNDERFLOW:!!!" )); 511 goto Exit; 512 513 Bad: 514 result = 0; 515 FT_TRACE4(( "!!!END OF DATA:!!!" )); 516 goto Exit; 517 } 518 519 520 /* read a number, either integer or real */ 521 FT_LOCAL_DEF( FT_Long ) cff_parse_num(CFF_Parser parser,FT_Byte ** d)522 cff_parse_num( CFF_Parser parser, 523 FT_Byte** d ) 524 { 525 if ( **d == 30 ) 526 { 527 /* binary-coded decimal is truncated to integer */ 528 return cff_parse_real( parser, *d, 0, NULL ) >> 16; 529 } 530 531 else if ( **d == 255 ) 532 { 533 /* 16.16 fixed point is used internally for CFF2 blend results. */ 534 /* Since these are trusted values, a limit check is not needed. */ 535 536 /* After the 255, 4 bytes give the number. */ 537 /* The blend value is converted to integer, with rounding; */ 538 /* due to the right-shift we don't need the lowest byte. */ 539 #if 0 540 return (FT_Short)( 541 ( ( ( (FT_UInt32)*( d[0] + 1 ) << 24 ) | 542 ( (FT_UInt32)*( d[0] + 2 ) << 16 ) | 543 ( (FT_UInt32)*( d[0] + 3 ) << 8 ) | 544 (FT_UInt32)*( d[0] + 4 ) ) + 0x8000U ) >> 16 ); 545 #else 546 return (FT_Short)( 547 ( ( ( (FT_UInt32)*( d[0] + 1 ) << 16 ) | 548 ( (FT_UInt32)*( d[0] + 2 ) << 8 ) | 549 (FT_UInt32)*( d[0] + 3 ) ) + 0x80U ) >> 8 ); 550 #endif 551 } 552 553 else 554 return cff_parse_integer( parser, *d ); 555 } 556 557 558 /* read a floating point number, either integer or real */ 559 static FT_Fixed do_fixed(CFF_Parser parser,FT_Byte ** d,FT_Long scaling)560 do_fixed( CFF_Parser parser, 561 FT_Byte** d, 562 FT_Long scaling ) 563 { 564 if ( **d == 30 ) 565 return cff_parse_real( parser, *d, scaling, NULL ); 566 else 567 { 568 FT_Long val = cff_parse_integer( parser, *d ); 569 570 571 if ( scaling ) 572 { 573 if ( FT_ABS( val ) > power_ten_limits[scaling] ) 574 { 575 val = val > 0 ? 0x7FFFFFFFL : -0x7FFFFFFFL; 576 goto Overflow; 577 } 578 579 val *= power_tens[scaling]; 580 } 581 582 if ( val > 0x7FFF ) 583 { 584 val = 0x7FFFFFFFL; 585 goto Overflow; 586 } 587 else if ( val < -0x7FFF ) 588 { 589 val = -0x7FFFFFFFL; 590 goto Overflow; 591 } 592 593 return (FT_Long)( (FT_ULong)val << 16 ); 594 595 Overflow: 596 FT_TRACE4(( "!!!OVERFLOW:!!!" )); 597 return val; 598 } 599 } 600 601 602 /* read a floating point number, either integer or real */ 603 static FT_Fixed cff_parse_fixed(CFF_Parser parser,FT_Byte ** d)604 cff_parse_fixed( CFF_Parser parser, 605 FT_Byte** d ) 606 { 607 return do_fixed( parser, d, 0 ); 608 } 609 610 611 /* read a floating point number, either integer or real, */ 612 /* but return `10^scaling' times the number read in */ 613 static FT_Fixed cff_parse_fixed_scaled(CFF_Parser parser,FT_Byte ** d,FT_Long scaling)614 cff_parse_fixed_scaled( CFF_Parser parser, 615 FT_Byte** d, 616 FT_Long scaling ) 617 { 618 return do_fixed( parser, d, scaling ); 619 } 620 621 622 /* read a floating point number, either integer or real, */ 623 /* and return it as precise as possible -- `scaling' returns */ 624 /* the scaling factor (as a power of 10) */ 625 static FT_Fixed cff_parse_fixed_dynamic(CFF_Parser parser,FT_Byte ** d,FT_Long * scaling)626 cff_parse_fixed_dynamic( CFF_Parser parser, 627 FT_Byte** d, 628 FT_Long* scaling ) 629 { 630 FT_ASSERT( scaling ); 631 632 if ( **d == 30 ) 633 return cff_parse_real( parser, *d, 0, scaling ); 634 else 635 { 636 FT_Long number; 637 FT_Int integer_length; 638 639 640 number = cff_parse_integer( parser, d[0] ); 641 642 if ( number > 0x7FFFL ) 643 { 644 for ( integer_length = 5; integer_length < 10; integer_length++ ) 645 if ( number < power_tens[integer_length] ) 646 break; 647 648 if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL ) 649 { 650 *scaling = integer_length - 4; 651 return FT_DivFix( number, power_tens[integer_length - 4] ); 652 } 653 else 654 { 655 *scaling = integer_length - 5; 656 return FT_DivFix( number, power_tens[integer_length - 5] ); 657 } 658 } 659 else 660 { 661 *scaling = 0; 662 return (FT_Long)( (FT_ULong)number << 16 ); 663 } 664 } 665 } 666 667 668 static FT_Error cff_parse_font_matrix(CFF_Parser parser)669 cff_parse_font_matrix( CFF_Parser parser ) 670 { 671 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 672 FT_Matrix* matrix = &dict->font_matrix; 673 FT_Vector* offset = &dict->font_offset; 674 FT_ULong* upm = &dict->units_per_em; 675 FT_Byte** data = parser->stack; 676 677 678 if ( parser->top >= parser->stack + 6 ) 679 { 680 FT_Fixed values[6]; 681 FT_Long scalings[6]; 682 683 FT_Long min_scaling, max_scaling; 684 int i; 685 686 687 dict->has_font_matrix = TRUE; 688 689 /* We expect a well-formed font matrix, this is, the matrix elements */ 690 /* `xx' and `yy' are of approximately the same magnitude. To avoid */ 691 /* loss of precision, we use the magnitude of the largest matrix */ 692 /* element to scale all other elements. The scaling factor is then */ 693 /* contained in the `units_per_em' value. */ 694 695 max_scaling = FT_LONG_MIN; 696 min_scaling = FT_LONG_MAX; 697 698 for ( i = 0; i < 6; i++ ) 699 { 700 values[i] = cff_parse_fixed_dynamic( parser, data++, &scalings[i] ); 701 if ( values[i] ) 702 { 703 if ( scalings[i] > max_scaling ) 704 max_scaling = scalings[i]; 705 if ( scalings[i] < min_scaling ) 706 min_scaling = scalings[i]; 707 } 708 } 709 710 if ( max_scaling < -9 || 711 max_scaling > 0 || 712 ( max_scaling - min_scaling ) < 0 || 713 ( max_scaling - min_scaling ) > 9 ) 714 { 715 FT_TRACE1(( "cff_parse_font_matrix:" 716 " strange scaling values (minimum %ld, maximum %ld),\n", 717 min_scaling, max_scaling )); 718 FT_TRACE1(( " " 719 " using default matrix\n" )); 720 goto Unlikely; 721 } 722 723 for ( i = 0; i < 6; i++ ) 724 { 725 FT_Fixed value = values[i]; 726 FT_Long divisor, half_divisor; 727 728 729 if ( !value ) 730 continue; 731 732 divisor = power_tens[max_scaling - scalings[i]]; 733 half_divisor = divisor >> 1; 734 735 if ( value < 0 ) 736 { 737 if ( FT_LONG_MIN + half_divisor < value ) 738 values[i] = ( value - half_divisor ) / divisor; 739 else 740 values[i] = FT_LONG_MIN / divisor; 741 } 742 else 743 { 744 if ( FT_LONG_MAX - half_divisor > value ) 745 values[i] = ( value + half_divisor ) / divisor; 746 else 747 values[i] = FT_LONG_MAX / divisor; 748 } 749 } 750 751 matrix->xx = values[0]; 752 matrix->yx = values[1]; 753 matrix->xy = values[2]; 754 matrix->yy = values[3]; 755 offset->x = values[4]; 756 offset->y = values[5]; 757 758 *upm = (FT_ULong)power_tens[-max_scaling]; 759 760 FT_TRACE4(( " [%f %f %f %f %f %f]\n", 761 (double)matrix->xx / *upm / 65536, 762 (double)matrix->xy / *upm / 65536, 763 (double)matrix->yx / *upm / 65536, 764 (double)matrix->yy / *upm / 65536, 765 (double)offset->x / *upm / 65536, 766 (double)offset->y / *upm / 65536 )); 767 768 if ( !FT_Matrix_Check( matrix ) ) 769 { 770 FT_TRACE1(( "cff_parse_font_matrix:" 771 " degenerate values, using default matrix\n" )); 772 goto Unlikely; 773 } 774 775 return FT_Err_Ok; 776 } 777 else 778 return FT_THROW( Stack_Underflow ); 779 780 Unlikely: 781 /* Return default matrix in case of unlikely values. */ 782 783 matrix->xx = 0x10000L; 784 matrix->yx = 0; 785 matrix->xy = 0; 786 matrix->yy = 0x10000L; 787 offset->x = 0; 788 offset->y = 0; 789 *upm = 1; 790 791 return FT_Err_Ok; 792 } 793 794 795 static FT_Error cff_parse_font_bbox(CFF_Parser parser)796 cff_parse_font_bbox( CFF_Parser parser ) 797 { 798 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 799 FT_BBox* bbox = &dict->font_bbox; 800 FT_Byte** data = parser->stack; 801 FT_Error error; 802 803 804 error = FT_ERR( Stack_Underflow ); 805 806 if ( parser->top >= parser->stack + 4 ) 807 { 808 bbox->xMin = FT_RoundFix( cff_parse_fixed( parser, data++ ) ); 809 bbox->yMin = FT_RoundFix( cff_parse_fixed( parser, data++ ) ); 810 bbox->xMax = FT_RoundFix( cff_parse_fixed( parser, data++ ) ); 811 bbox->yMax = FT_RoundFix( cff_parse_fixed( parser, data ) ); 812 error = FT_Err_Ok; 813 814 FT_TRACE4(( " [%ld %ld %ld %ld]\n", 815 bbox->xMin / 65536, 816 bbox->yMin / 65536, 817 bbox->xMax / 65536, 818 bbox->yMax / 65536 )); 819 } 820 821 return error; 822 } 823 824 825 static FT_Error cff_parse_private_dict(CFF_Parser parser)826 cff_parse_private_dict( CFF_Parser parser ) 827 { 828 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 829 FT_Byte** data = parser->stack; 830 FT_Error error; 831 832 833 error = FT_ERR( Stack_Underflow ); 834 835 if ( parser->top >= parser->stack + 2 ) 836 { 837 FT_Long tmp; 838 839 840 tmp = cff_parse_num( parser, data++ ); 841 if ( tmp < 0 ) 842 { 843 FT_ERROR(( "cff_parse_private_dict: Invalid dictionary size\n" )); 844 error = FT_THROW( Invalid_File_Format ); 845 goto Fail; 846 } 847 dict->private_size = (FT_ULong)tmp; 848 849 tmp = cff_parse_num( parser, data ); 850 if ( tmp < 0 ) 851 { 852 FT_ERROR(( "cff_parse_private_dict: Invalid dictionary offset\n" )); 853 error = FT_THROW( Invalid_File_Format ); 854 goto Fail; 855 } 856 dict->private_offset = (FT_ULong)tmp; 857 858 FT_TRACE4(( " %lu %lu\n", 859 dict->private_size, dict->private_offset )); 860 861 error = FT_Err_Ok; 862 } 863 864 Fail: 865 return error; 866 } 867 868 869 /* The `MultipleMaster' operator comes before any */ 870 /* top DICT operators that contain T2 charstrings. */ 871 872 static FT_Error cff_parse_multiple_master(CFF_Parser parser)873 cff_parse_multiple_master( CFF_Parser parser ) 874 { 875 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 876 FT_Error error; 877 878 879 #ifdef FT_DEBUG_LEVEL_TRACE 880 /* beautify tracing message */ 881 if ( ft_trace_levels[FT_TRACE_COMP( FT_COMPONENT )] < 4 ) 882 FT_TRACE1(( "Multiple Master CFFs not supported yet," 883 " handling first master design only\n" )); 884 else 885 FT_TRACE1(( " (not supported yet," 886 " handling first master design only)\n" )); 887 #endif 888 889 error = FT_ERR( Stack_Underflow ); 890 891 /* currently, we handle only the first argument */ 892 if ( parser->top >= parser->stack + 5 ) 893 { 894 FT_Long num_designs = cff_parse_num( parser, parser->stack ); 895 896 897 if ( num_designs > 16 || num_designs < 2 ) 898 { 899 FT_ERROR(( "cff_parse_multiple_master:" 900 " Invalid number of designs\n" )); 901 error = FT_THROW( Invalid_File_Format ); 902 } 903 else 904 { 905 dict->num_designs = (FT_UShort)num_designs; 906 dict->num_axes = (FT_UShort)( parser->top - parser->stack - 4 ); 907 908 parser->num_designs = dict->num_designs; 909 parser->num_axes = dict->num_axes; 910 911 error = FT_Err_Ok; 912 } 913 } 914 915 return error; 916 } 917 918 919 static FT_Error cff_parse_cid_ros(CFF_Parser parser)920 cff_parse_cid_ros( CFF_Parser parser ) 921 { 922 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 923 FT_Byte** data = parser->stack; 924 FT_Error error; 925 926 927 error = FT_ERR( Stack_Underflow ); 928 929 if ( parser->top >= parser->stack + 3 ) 930 { 931 dict->cid_registry = (FT_UInt)cff_parse_num( parser, data++ ); 932 dict->cid_ordering = (FT_UInt)cff_parse_num( parser, data++ ); 933 if ( **data == 30 ) 934 FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" )); 935 dict->cid_supplement = cff_parse_num( parser, data ); 936 if ( dict->cid_supplement < 0 ) 937 FT_TRACE1(( "cff_parse_cid_ros: negative supplement %ld is found\n", 938 dict->cid_supplement )); 939 error = FT_Err_Ok; 940 941 FT_TRACE4(( " %d %d %ld\n", 942 dict->cid_registry, 943 dict->cid_ordering, 944 dict->cid_supplement )); 945 } 946 947 return error; 948 } 949 950 951 static FT_Error cff_parse_vsindex(CFF_Parser parser)952 cff_parse_vsindex( CFF_Parser parser ) 953 { 954 /* vsindex operator can only be used in a Private DICT */ 955 CFF_Private priv = (CFF_Private)parser->object; 956 FT_Byte** data = parser->stack; 957 CFF_Blend blend; 958 FT_Error error; 959 960 961 if ( !priv || !priv->subfont ) 962 { 963 error = FT_THROW( Invalid_File_Format ); 964 goto Exit; 965 } 966 967 blend = &priv->subfont->blend; 968 969 if ( blend->usedBV ) 970 { 971 FT_ERROR(( " cff_parse_vsindex: vsindex not allowed after blend\n" )); 972 error = FT_THROW( Syntax_Error ); 973 goto Exit; 974 } 975 976 priv->vsindex = (FT_UInt)cff_parse_num( parser, data++ ); 977 978 FT_TRACE4(( " %d\n", priv->vsindex )); 979 980 error = FT_Err_Ok; 981 982 Exit: 983 return error; 984 } 985 986 987 static FT_Error cff_parse_blend(CFF_Parser parser)988 cff_parse_blend( CFF_Parser parser ) 989 { 990 /* blend operator can only be used in a Private DICT */ 991 CFF_Private priv = (CFF_Private)parser->object; 992 CFF_SubFont subFont; 993 CFF_Blend blend; 994 FT_UInt numBlends; 995 FT_Error error; 996 997 998 if ( !priv || !priv->subfont ) 999 { 1000 error = FT_THROW( Invalid_File_Format ); 1001 goto Exit; 1002 } 1003 1004 subFont = priv->subfont; 1005 blend = &subFont->blend; 1006 1007 if ( cff_blend_check_vector( blend, 1008 priv->vsindex, 1009 subFont->lenNDV, 1010 subFont->NDV ) ) 1011 { 1012 error = cff_blend_build_vector( blend, 1013 priv->vsindex, 1014 subFont->lenNDV, 1015 subFont->NDV ); 1016 if ( error ) 1017 goto Exit; 1018 } 1019 1020 numBlends = (FT_UInt)cff_parse_num( parser, parser->top - 1 ); 1021 if ( numBlends > parser->stackSize ) 1022 { 1023 FT_ERROR(( "cff_parse_blend: Invalid number of blends\n" )); 1024 error = FT_THROW( Invalid_File_Format ); 1025 goto Exit; 1026 } 1027 1028 FT_TRACE4(( " %d value%s blended\n", 1029 numBlends, 1030 numBlends == 1 ? "" : "s" )); 1031 1032 error = cff_blend_doBlend( subFont, parser, numBlends ); 1033 1034 blend->usedBV = TRUE; 1035 1036 Exit: 1037 return error; 1038 } 1039 1040 1041 /* maxstack operator increases parser and operand stacks for CFF2 */ 1042 static FT_Error cff_parse_maxstack(CFF_Parser parser)1043 cff_parse_maxstack( CFF_Parser parser ) 1044 { 1045 /* maxstack operator can only be used in a Top DICT */ 1046 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 1047 FT_Byte** data = parser->stack; 1048 FT_Error error = FT_Err_Ok; 1049 1050 1051 if ( !dict ) 1052 { 1053 error = FT_THROW( Invalid_File_Format ); 1054 goto Exit; 1055 } 1056 1057 dict->maxstack = (FT_UInt)cff_parse_num( parser, data++ ); 1058 if ( dict->maxstack > CFF2_MAX_STACK ) 1059 dict->maxstack = CFF2_MAX_STACK; 1060 if ( dict->maxstack < CFF2_DEFAULT_STACK ) 1061 dict->maxstack = CFF2_DEFAULT_STACK; 1062 1063 FT_TRACE4(( " %d\n", dict->maxstack )); 1064 1065 Exit: 1066 return error; 1067 } 1068 1069 1070 #define CFF_FIELD_NUM( code, name, id ) \ 1071 CFF_FIELD( code, name, id, cff_kind_num ) 1072 #define CFF_FIELD_FIXED( code, name, id ) \ 1073 CFF_FIELD( code, name, id, cff_kind_fixed ) 1074 #define CFF_FIELD_FIXED_1000( code, name, id ) \ 1075 CFF_FIELD( code, name, id, cff_kind_fixed_thousand ) 1076 #define CFF_FIELD_STRING( code, name, id ) \ 1077 CFF_FIELD( code, name, id, cff_kind_string ) 1078 #define CFF_FIELD_BOOL( code, name, id ) \ 1079 CFF_FIELD( code, name, id, cff_kind_bool ) 1080 1081 1082 #undef CFF_FIELD 1083 #undef CFF_FIELD_DELTA 1084 1085 1086 #ifndef FT_DEBUG_LEVEL_TRACE 1087 1088 1089 #define CFF_FIELD_CALLBACK( code, name, id ) \ 1090 { \ 1091 cff_kind_callback, \ 1092 code | CFFCODE, \ 1093 0, 0, \ 1094 cff_parse_ ## name, \ 1095 0, 0 \ 1096 }, 1097 1098 #define CFF_FIELD_BLEND( code, id ) \ 1099 { \ 1100 cff_kind_blend, \ 1101 code | CFFCODE, \ 1102 0, 0, \ 1103 cff_parse_blend, \ 1104 0, 0 \ 1105 }, 1106 1107 #define CFF_FIELD( code, name, id, kind ) \ 1108 { \ 1109 kind, \ 1110 code | CFFCODE, \ 1111 FT_FIELD_OFFSET( name ), \ 1112 FT_FIELD_SIZE( name ), \ 1113 0, 0, 0 \ 1114 }, 1115 1116 #define CFF_FIELD_DELTA( code, name, max, id ) \ 1117 { \ 1118 cff_kind_delta, \ 1119 code | CFFCODE, \ 1120 FT_FIELD_OFFSET( name ), \ 1121 FT_FIELD_SIZE_DELTA( name ), \ 1122 0, \ 1123 max, \ 1124 FT_FIELD_OFFSET( num_ ## name ) \ 1125 }, 1126 1127 static const CFF_Field_Handler cff_field_handlers[] = 1128 { 1129 1130 #include "cfftoken.h" 1131 1132 { 0, 0, 0, 0, 0, 0, 0 } 1133 }; 1134 1135 1136 #else /* FT_DEBUG_LEVEL_TRACE */ 1137 1138 1139 1140 #define CFF_FIELD_CALLBACK( code, name, id ) \ 1141 { \ 1142 cff_kind_callback, \ 1143 code | CFFCODE, \ 1144 0, 0, \ 1145 cff_parse_ ## name, \ 1146 0, 0, \ 1147 id \ 1148 }, 1149 1150 #define CFF_FIELD_BLEND( code, id ) \ 1151 { \ 1152 cff_kind_blend, \ 1153 code | CFFCODE, \ 1154 0, 0, \ 1155 cff_parse_blend, \ 1156 0, 0, \ 1157 id \ 1158 }, 1159 1160 #define CFF_FIELD( code, name, id, kind ) \ 1161 { \ 1162 kind, \ 1163 code | CFFCODE, \ 1164 FT_FIELD_OFFSET( name ), \ 1165 FT_FIELD_SIZE( name ), \ 1166 0, 0, 0, \ 1167 id \ 1168 }, 1169 1170 #define CFF_FIELD_DELTA( code, name, max, id ) \ 1171 { \ 1172 cff_kind_delta, \ 1173 code | CFFCODE, \ 1174 FT_FIELD_OFFSET( name ), \ 1175 FT_FIELD_SIZE_DELTA( name ), \ 1176 0, \ 1177 max, \ 1178 FT_FIELD_OFFSET( num_ ## name ), \ 1179 id \ 1180 }, 1181 1182 static const CFF_Field_Handler cff_field_handlers[] = 1183 { 1184 1185 #include "cfftoken.h" 1186 1187 { 0, 0, 0, 0, 0, 0, 0, 0 } 1188 }; 1189 1190 1191 #endif /* FT_DEBUG_LEVEL_TRACE */ 1192 1193 1194 FT_LOCAL_DEF( FT_Error ) cff_parser_run(CFF_Parser parser,FT_Byte * start,FT_Byte * limit)1195 cff_parser_run( CFF_Parser parser, 1196 FT_Byte* start, 1197 FT_Byte* limit ) 1198 { 1199 FT_Byte* p = start; 1200 FT_Error error = FT_Err_Ok; 1201 1202 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE 1203 PSAux_Service psaux; 1204 1205 FT_Library library = parser->library; 1206 FT_Memory memory = library->memory; 1207 #endif 1208 1209 parser->top = parser->stack; 1210 parser->start = start; 1211 parser->limit = limit; 1212 parser->cursor = start; 1213 1214 while ( p < limit ) 1215 { 1216 FT_UInt v = *p; 1217 1218 1219 /* Opcode 31 is legacy MM T2 operator, not a number. */ 1220 /* Opcode 255 is reserved and should not appear in fonts; */ 1221 /* it is used internally for CFF2 blends. */ 1222 if ( v >= 27 && v != 31 && v != 255 ) 1223 { 1224 /* it's a number; we will push its position on the stack */ 1225 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize ) 1226 goto Stack_Overflow; 1227 1228 *parser->top++ = p; 1229 1230 /* now, skip it */ 1231 if ( v == 30 ) 1232 { 1233 /* skip real number */ 1234 p++; 1235 for (;;) 1236 { 1237 /* An unterminated floating point number at the */ 1238 /* end of a dictionary is invalid but harmless. */ 1239 if ( p >= limit ) 1240 goto Exit; 1241 v = p[0] >> 4; 1242 if ( v == 15 ) 1243 break; 1244 v = p[0] & 0xF; 1245 if ( v == 15 ) 1246 break; 1247 p++; 1248 } 1249 } 1250 else if ( v == 28 ) 1251 p += 2; 1252 else if ( v == 29 ) 1253 p += 4; 1254 else if ( v > 246 ) 1255 p += 1; 1256 } 1257 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE 1258 else if ( v == 31 ) 1259 { 1260 /* a Type 2 charstring */ 1261 1262 CFF_Decoder decoder; 1263 CFF_FontRec cff_rec; 1264 FT_Byte* charstring_base; 1265 FT_ULong charstring_len; 1266 1267 FT_Fixed* stack; 1268 FT_ListNode node; 1269 CFF_T2_String t2; 1270 FT_Fixed t2_size; 1271 FT_Byte* q; 1272 1273 1274 charstring_base = ++p; 1275 1276 /* search `endchar' operator */ 1277 for (;;) 1278 { 1279 if ( p >= limit ) 1280 goto Exit; 1281 if ( *p == 14 ) 1282 break; 1283 p++; 1284 } 1285 1286 charstring_len = (FT_ULong)( p - charstring_base ) + 1; 1287 1288 /* construct CFF_Decoder object */ 1289 FT_ZERO( &decoder ); 1290 FT_ZERO( &cff_rec ); 1291 1292 cff_rec.top_font.font_dict.num_designs = parser->num_designs; 1293 cff_rec.top_font.font_dict.num_axes = parser->num_axes; 1294 decoder.cff = &cff_rec; 1295 1296 psaux = (PSAux_Service)FT_Get_Module_Interface( library, "psaux" ); 1297 if ( !psaux ) 1298 { 1299 FT_ERROR(( "cff_parser_run: cannot access `psaux' module\n" )); 1300 error = FT_THROW( Missing_Module ); 1301 goto Exit; 1302 } 1303 1304 error = psaux->cff_decoder_funcs->parse_charstrings_old( 1305 &decoder, charstring_base, charstring_len, 1 ); 1306 if ( error ) 1307 goto Exit; 1308 1309 /* Now copy the stack data in the temporary decoder object, */ 1310 /* converting it back to charstring number representations */ 1311 /* (this is ugly, I know). */ 1312 1313 node = (FT_ListNode)memory->alloc( memory, 1314 sizeof ( FT_ListNodeRec ) ); 1315 if ( !node ) 1316 goto Out_Of_Memory_Error; 1317 1318 FT_List_Add( &parser->t2_strings, node ); 1319 1320 t2 = (CFF_T2_String)memory->alloc( memory, 1321 sizeof ( CFF_T2_StringRec ) ); 1322 if ( !t2 ) 1323 goto Out_Of_Memory_Error; 1324 1325 node->data = t2; 1326 1327 /* `5' is the conservative upper bound of required bytes per stack */ 1328 /* element. */ 1329 1330 t2_size = 5 * ( decoder.top - decoder.stack ); 1331 1332 q = (FT_Byte*)memory->alloc( memory, t2_size ); 1333 if ( !q ) 1334 goto Out_Of_Memory_Error; 1335 1336 t2->start = q; 1337 t2->limit = q + t2_size; 1338 1339 stack = decoder.stack; 1340 1341 while ( stack < decoder.top ) 1342 { 1343 FT_ULong num; 1344 FT_Bool neg; 1345 1346 1347 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize ) 1348 goto Stack_Overflow; 1349 1350 *parser->top++ = q; 1351 1352 if ( *stack < 0 ) 1353 { 1354 num = (FT_ULong)NEG_LONG( *stack ); 1355 neg = 1; 1356 } 1357 else 1358 { 1359 num = (FT_ULong)*stack; 1360 neg = 0; 1361 } 1362 1363 if ( num & 0xFFFFU ) 1364 { 1365 if ( neg ) 1366 num = (FT_ULong)-num; 1367 1368 *q++ = 255; 1369 *q++ = ( num & 0xFF000000U ) >> 24; 1370 *q++ = ( num & 0x00FF0000U ) >> 16; 1371 *q++ = ( num & 0x0000FF00U ) >> 8; 1372 *q++ = num & 0x000000FFU; 1373 } 1374 else 1375 { 1376 num >>= 16; 1377 1378 if ( neg ) 1379 { 1380 if ( num <= 107 ) 1381 *q++ = (FT_Byte)( 139 - num ); 1382 else if ( num <= 1131 ) 1383 { 1384 *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 251 ); 1385 *q++ = (FT_Byte)( ( num - 108 ) & 0xFF ); 1386 } 1387 else 1388 { 1389 num = (FT_ULong)-num; 1390 1391 *q++ = 28; 1392 *q++ = (FT_Byte)( num >> 8 ); 1393 *q++ = (FT_Byte)( num & 0xFF ); 1394 } 1395 } 1396 else 1397 { 1398 if ( num <= 107 ) 1399 *q++ = (FT_Byte)( num + 139 ); 1400 else if ( num <= 1131 ) 1401 { 1402 *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 247 ); 1403 *q++ = (FT_Byte)( ( num - 108 ) & 0xFF ); 1404 } 1405 else 1406 { 1407 *q++ = 28; 1408 *q++ = (FT_Byte)( num >> 8 ); 1409 *q++ = (FT_Byte)( num & 0xFF ); 1410 } 1411 } 1412 } 1413 1414 stack++; 1415 } 1416 } 1417 #endif /* CFF_CONFIG_OPTION_OLD_ENGINE */ 1418 else 1419 { 1420 /* This is not a number, hence it's an operator. Compute its code */ 1421 /* and look for it in our current list. */ 1422 1423 FT_UInt code; 1424 FT_UInt num_args; 1425 const CFF_Field_Handler* field; 1426 1427 1428 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize ) 1429 goto Stack_Overflow; 1430 1431 num_args = (FT_UInt)( parser->top - parser->stack ); 1432 *parser->top = p; 1433 code = v; 1434 1435 if ( v == 12 ) 1436 { 1437 /* two byte operator */ 1438 p++; 1439 if ( p >= limit ) 1440 goto Syntax_Error; 1441 1442 code = 0x100 | p[0]; 1443 } 1444 code = code | parser->object_code; 1445 1446 for ( field = cff_field_handlers; field->kind; field++ ) 1447 { 1448 if ( field->code == (FT_Int)code ) 1449 { 1450 /* we found our field's handler; read it */ 1451 FT_Long val; 1452 FT_Byte* q = (FT_Byte*)parser->object + field->offset; 1453 1454 1455 #ifdef FT_DEBUG_LEVEL_TRACE 1456 FT_TRACE4(( " %s", field->id )); 1457 #endif 1458 1459 /* check that we have enough arguments -- except for */ 1460 /* delta encoded arrays, which can be empty */ 1461 if ( field->kind != cff_kind_delta && num_args < 1 ) 1462 goto Stack_Underflow; 1463 1464 switch ( field->kind ) 1465 { 1466 case cff_kind_bool: 1467 case cff_kind_string: 1468 case cff_kind_num: 1469 val = cff_parse_num( parser, parser->stack ); 1470 goto Store_Number; 1471 1472 case cff_kind_fixed: 1473 val = cff_parse_fixed( parser, parser->stack ); 1474 goto Store_Number; 1475 1476 case cff_kind_fixed_thousand: 1477 val = cff_parse_fixed_scaled( parser, parser->stack, 3 ); 1478 1479 Store_Number: 1480 switch ( field->size ) 1481 { 1482 case (8 / FT_CHAR_BIT): 1483 *(FT_Byte*)q = (FT_Byte)val; 1484 break; 1485 1486 case (16 / FT_CHAR_BIT): 1487 *(FT_Short*)q = (FT_Short)val; 1488 break; 1489 1490 case (32 / FT_CHAR_BIT): 1491 *(FT_Int32*)q = (FT_Int)val; 1492 break; 1493 1494 default: /* for 64-bit systems */ 1495 *(FT_Long*)q = val; 1496 } 1497 1498 #ifdef FT_DEBUG_LEVEL_TRACE 1499 switch ( field->kind ) 1500 { 1501 case cff_kind_bool: 1502 FT_TRACE4(( " %s\n", val ? "true" : "false" )); 1503 break; 1504 1505 case cff_kind_string: 1506 FT_TRACE4(( " %ld (SID)\n", val )); 1507 break; 1508 1509 case cff_kind_num: 1510 FT_TRACE4(( " %ld\n", val )); 1511 break; 1512 1513 case cff_kind_fixed: 1514 FT_TRACE4(( " %f\n", (double)val / 65536 )); 1515 break; 1516 1517 case cff_kind_fixed_thousand: 1518 FT_TRACE4(( " %f\n", (double)val / 65536 / 1000 )); 1519 break; 1520 1521 default: 1522 ; /* never reached */ 1523 } 1524 #endif 1525 1526 break; 1527 1528 case cff_kind_delta: 1529 { 1530 FT_Byte* qcount = (FT_Byte*)parser->object + 1531 field->count_offset; 1532 1533 FT_Byte** data = parser->stack; 1534 1535 1536 if ( num_args > field->array_max ) 1537 num_args = field->array_max; 1538 1539 FT_TRACE4(( " [" )); 1540 1541 /* store count */ 1542 *qcount = (FT_Byte)num_args; 1543 1544 val = 0; 1545 while ( num_args > 0 ) 1546 { 1547 val = ADD_LONG( val, cff_parse_num( parser, data++ ) ); 1548 switch ( field->size ) 1549 { 1550 case (8 / FT_CHAR_BIT): 1551 *(FT_Byte*)q = (FT_Byte)val; 1552 break; 1553 1554 case (16 / FT_CHAR_BIT): 1555 *(FT_Short*)q = (FT_Short)val; 1556 break; 1557 1558 case (32 / FT_CHAR_BIT): 1559 *(FT_Int32*)q = (FT_Int)val; 1560 break; 1561 1562 default: /* for 64-bit systems */ 1563 *(FT_Long*)q = val; 1564 } 1565 1566 FT_TRACE4(( " %ld", val )); 1567 1568 q += field->size; 1569 num_args--; 1570 } 1571 1572 FT_TRACE4(( "]\n" )); 1573 } 1574 break; 1575 1576 default: /* callback or blend */ 1577 error = field->reader( parser ); 1578 if ( error ) 1579 goto Exit; 1580 } 1581 goto Found; 1582 } 1583 } 1584 1585 /* this is an unknown operator, or it is unsupported; */ 1586 /* we will ignore it for now. */ 1587 1588 Found: 1589 /* clear stack */ 1590 /* TODO: could clear blend stack here, */ 1591 /* but we don't have access to subFont */ 1592 if ( field->kind != cff_kind_blend ) 1593 parser->top = parser->stack; 1594 } 1595 p++; 1596 } /* while ( p < limit ) */ 1597 1598 Exit: 1599 return error; 1600 1601 #ifdef CFF_CONFIG_OPTION_OLD_ENGINE 1602 Out_Of_Memory_Error: 1603 error = FT_THROW( Out_Of_Memory ); 1604 goto Exit; 1605 #endif 1606 1607 Stack_Overflow: 1608 error = FT_THROW( Invalid_Argument ); 1609 goto Exit; 1610 1611 Stack_Underflow: 1612 error = FT_THROW( Invalid_Argument ); 1613 goto Exit; 1614 1615 Syntax_Error: 1616 error = FT_THROW( Invalid_Argument ); 1617 goto Exit; 1618 } 1619 1620 1621 /* END */ 1622