cffparse.c revision aacb8e1368a883fcbc9fe64fd0e460cef9c9b20c
1/***************************************************************************/ 2/* */ 3/* cffparse.c */ 4/* */ 5/* CFF token stream parser (body) */ 6/* */ 7/* Copyright 1996-2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010 by */ 8/* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9/* */ 10/* This file is part of the FreeType project, and may only be used, */ 11/* modified, and distributed under the terms of the FreeType project */ 12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13/* this file you indicate that you have read the license and */ 14/* understand and accept it fully. */ 15/* */ 16/***************************************************************************/ 17 18 19#include <ft2build.h> 20#include "cffparse.h" 21#include FT_INTERNAL_STREAM_H 22#include FT_INTERNAL_DEBUG_H 23 24#include "cfferrs.h" 25#include "cffpic.h" 26 27 28 /*************************************************************************/ 29 /* */ 30 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 31 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 32 /* messages during execution. */ 33 /* */ 34#undef FT_COMPONENT 35#define FT_COMPONENT trace_cffparse 36 37 38 39 40 FT_LOCAL_DEF( void ) 41 cff_parser_init( CFF_Parser parser, 42 FT_UInt code, 43 void* object, 44 FT_Library library) 45 { 46 FT_MEM_ZERO( parser, sizeof ( *parser ) ); 47 48 parser->top = parser->stack; 49 parser->object_code = code; 50 parser->object = object; 51 parser->library = library; 52 } 53 54 55 /* read an integer */ 56 static FT_Long 57 cff_parse_integer( FT_Byte* start, 58 FT_Byte* limit ) 59 { 60 FT_Byte* p = start; 61 FT_Int v = *p++; 62 FT_Long val = 0; 63 64 65 if ( v == 28 ) 66 { 67 if ( p + 2 > limit ) 68 goto Bad; 69 70 val = (FT_Short)( ( (FT_Int)p[0] << 8 ) | p[1] ); 71 p += 2; 72 } 73 else if ( v == 29 ) 74 { 75 if ( p + 4 > limit ) 76 goto Bad; 77 78 val = ( (FT_Long)p[0] << 24 ) | 79 ( (FT_Long)p[1] << 16 ) | 80 ( (FT_Long)p[2] << 8 ) | 81 p[3]; 82 p += 4; 83 } 84 else if ( v < 247 ) 85 { 86 val = v - 139; 87 } 88 else if ( v < 251 ) 89 { 90 if ( p + 1 > limit ) 91 goto Bad; 92 93 val = ( v - 247 ) * 256 + p[0] + 108; 94 p++; 95 } 96 else 97 { 98 if ( p + 1 > limit ) 99 goto Bad; 100 101 val = -( v - 251 ) * 256 - p[0] - 108; 102 p++; 103 } 104 105 Exit: 106 return val; 107 108 Bad: 109 val = 0; 110 goto Exit; 111 } 112 113 114 static const FT_Long power_tens[] = 115 { 116 1L, 117 10L, 118 100L, 119 1000L, 120 10000L, 121 100000L, 122 1000000L, 123 10000000L, 124 100000000L, 125 1000000000L 126 }; 127 128 129 /* read a real */ 130 static FT_Fixed 131 cff_parse_real( FT_Byte* start, 132 FT_Byte* limit, 133 FT_Long power_ten, 134 FT_Long* scaling ) 135 { 136 FT_Byte* p = start; 137 FT_UInt nib; 138 FT_UInt phase; 139 140 FT_Long result, number, exponent; 141 FT_Int sign = 0, exponent_sign = 0; 142 FT_Long exponent_add, integer_length, fraction_length; 143 144 145 if ( scaling ) 146 *scaling = 0; 147 148 result = 0; 149 150 number = 0; 151 exponent = 0; 152 153 exponent_add = 0; 154 integer_length = 0; 155 fraction_length = 0; 156 157 /* First of all, read the integer part. */ 158 phase = 4; 159 160 for (;;) 161 { 162 /* If we entered this iteration with phase == 4, we need to */ 163 /* read a new byte. This also skips past the initial 0x1E. */ 164 if ( phase ) 165 { 166 p++; 167 168 /* Make sure we don't read past the end. */ 169 if ( p >= limit ) 170 goto Exit; 171 } 172 173 /* Get the nibble. */ 174 nib = ( p[0] >> phase ) & 0xF; 175 phase = 4 - phase; 176 177 if ( nib == 0xE ) 178 sign = 1; 179 else if ( nib > 9 ) 180 break; 181 else 182 { 183 /* Increase exponent if we can't add the digit. */ 184 if ( number >= 0xCCCCCCCL ) 185 exponent_add++; 186 /* Skip leading zeros. */ 187 else if ( nib || number ) 188 { 189 integer_length++; 190 number = number * 10 + nib; 191 } 192 } 193 } 194 195 /* Read fraction part, if any. */ 196 if ( nib == 0xa ) 197 for (;;) 198 { 199 /* If we entered this iteration with phase == 4, we need */ 200 /* to read a new byte. */ 201 if ( phase ) 202 { 203 p++; 204 205 /* Make sure we don't read past the end. */ 206 if ( p >= limit ) 207 goto Exit; 208 } 209 210 /* Get the nibble. */ 211 nib = ( p[0] >> phase ) & 0xF; 212 phase = 4 - phase; 213 if ( nib >= 10 ) 214 break; 215 216 /* Skip leading zeros if possible. */ 217 if ( !nib && !number ) 218 exponent_add--; 219 /* Only add digit if we don't overflow. */ 220 else if ( number < 0xCCCCCCCL && fraction_length < 9 ) 221 { 222 fraction_length++; 223 number = number * 10 + nib; 224 } 225 } 226 227 /* Read exponent, if any. */ 228 if ( nib == 12 ) 229 { 230 exponent_sign = 1; 231 nib = 11; 232 } 233 234 if ( nib == 11 ) 235 { 236 for (;;) 237 { 238 /* If we entered this iteration with phase == 4, */ 239 /* we need to read a new byte. */ 240 if ( phase ) 241 { 242 p++; 243 244 /* Make sure we don't read past the end. */ 245 if ( p >= limit ) 246 goto Exit; 247 } 248 249 /* Get the nibble. */ 250 nib = ( p[0] >> phase ) & 0xF; 251 phase = 4 - phase; 252 if ( nib >= 10 ) 253 break; 254 255 exponent = exponent * 10 + nib; 256 257 /* Arbitrarily limit exponent. */ 258 if ( exponent > 1000 ) 259 goto Exit; 260 } 261 262 if ( exponent_sign ) 263 exponent = -exponent; 264 } 265 266 /* We don't check `power_ten' and `exponent_add'. */ 267 exponent += power_ten + exponent_add; 268 269 if ( scaling ) 270 { 271 /* Only use `fraction_length'. */ 272 fraction_length += integer_length; 273 exponent += integer_length; 274 275 if ( fraction_length <= 5 ) 276 { 277 if ( number > 0x7FFFL ) 278 { 279 result = FT_DivFix( number, 10 ); 280 *scaling = exponent - fraction_length + 1; 281 } 282 else 283 { 284 if ( exponent > 0 ) 285 { 286 FT_Long new_fraction_length, shift; 287 288 289 /* Make `scaling' as small as possible. */ 290 new_fraction_length = FT_MIN( exponent, 5 ); 291 exponent -= new_fraction_length; 292 shift = new_fraction_length - fraction_length; 293 294 number *= power_tens[shift]; 295 if ( number > 0x7FFFL ) 296 { 297 number /= 10; 298 exponent += 1; 299 } 300 } 301 else 302 exponent -= fraction_length; 303 304 result = number << 16; 305 *scaling = exponent; 306 } 307 } 308 else 309 { 310 if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL ) 311 { 312 result = FT_DivFix( number, power_tens[fraction_length - 4] ); 313 *scaling = exponent - 4; 314 } 315 else 316 { 317 result = FT_DivFix( number, power_tens[fraction_length - 5] ); 318 *scaling = exponent - 5; 319 } 320 } 321 } 322 else 323 { 324 integer_length += exponent; 325 fraction_length -= exponent; 326 327 /* Check for overflow and underflow. */ 328 if ( FT_ABS( integer_length ) > 5 ) 329 goto Exit; 330 331 /* Remove non-significant digits. */ 332 if ( integer_length < 0 ) 333 { 334 number /= power_tens[-integer_length]; 335 fraction_length += integer_length; 336 } 337 338 /* this can only happen if exponent was non-zero */ 339 if ( fraction_length == 10 ) 340 { 341 number /= 10; 342 fraction_length -= 1; 343 } 344 345 /* Convert into 16.16 format. */ 346 if ( fraction_length > 0 ) 347 { 348 if ( ( number / power_tens[fraction_length] ) > 0x7FFFL ) 349 goto Exit; 350 351 result = FT_DivFix( number, power_tens[fraction_length] ); 352 } 353 else 354 { 355 number *= power_tens[-fraction_length]; 356 357 if ( number > 0x7FFFL ) 358 goto Exit; 359 360 result = number << 16; 361 } 362 } 363 364 if ( sign ) 365 result = -result; 366 367 Exit: 368 return result; 369 } 370 371 372 /* read a number, either integer or real */ 373 static FT_Long 374 cff_parse_num( FT_Byte** d ) 375 { 376 return **d == 30 ? ( cff_parse_real( d[0], d[1], 0, NULL ) >> 16 ) 377 : cff_parse_integer( d[0], d[1] ); 378 } 379 380 381 /* read a floating point number, either integer or real */ 382 static FT_Fixed 383 cff_parse_fixed( FT_Byte** d ) 384 { 385 return **d == 30 ? cff_parse_real( d[0], d[1], 0, NULL ) 386 : cff_parse_integer( d[0], d[1] ) << 16; 387 } 388 389 390 /* read a floating point number, either integer or real, */ 391 /* but return `10^scaling' times the number read in */ 392 static FT_Fixed 393 cff_parse_fixed_scaled( FT_Byte** d, 394 FT_Long scaling ) 395 { 396 return **d == 30 ? cff_parse_real( d[0], d[1], scaling, NULL ) 397 : ( cff_parse_integer( d[0], d[1] ) * 398 power_tens[scaling] ) << 16; 399 } 400 401 402 /* read a floating point number, either integer or real, */ 403 /* and return it as precise as possible -- `scaling' returns */ 404 /* the scaling factor (as a power of 10) */ 405 static FT_Fixed 406 cff_parse_fixed_dynamic( FT_Byte** d, 407 FT_Long* scaling ) 408 { 409 FT_ASSERT( scaling ); 410 411 if ( **d == 30 ) 412 return cff_parse_real( d[0], d[1], 0, scaling ); 413 else 414 { 415 FT_Long number; 416 FT_Int integer_length; 417 418 419 number = cff_parse_integer( d[0], d[1] ); 420 421 if ( number > 0x7FFFL ) 422 { 423 for ( integer_length = 5; integer_length < 10; integer_length++ ) 424 if ( number < power_tens[integer_length] ) 425 break; 426 427 if ( ( number / power_tens[integer_length - 5] ) > 0x7FFFL ) 428 { 429 *scaling = integer_length - 4; 430 return FT_DivFix( number, power_tens[integer_length - 4] ); 431 } 432 else 433 { 434 *scaling = integer_length - 5; 435 return FT_DivFix( number, power_tens[integer_length - 5] ); 436 } 437 } 438 else 439 { 440 *scaling = 0; 441 return number << 16; 442 } 443 } 444 } 445 446 447 static FT_Error 448 cff_parse_font_matrix( CFF_Parser parser ) 449 { 450 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 451 FT_Matrix* matrix = &dict->font_matrix; 452 FT_Vector* offset = &dict->font_offset; 453 FT_ULong* upm = &dict->units_per_em; 454 FT_Byte** data = parser->stack; 455 FT_Error error = CFF_Err_Stack_Underflow; 456 457 458 if ( parser->top >= parser->stack + 6 ) 459 { 460 FT_Long scaling; 461 462 463 error = CFF_Err_Ok; 464 465 /* We expect a well-formed font matrix, this is, the matrix elements */ 466 /* `xx' and `yy' are of approximately the same magnitude. To avoid */ 467 /* loss of precision, we use the magnitude of element `xx' to scale */ 468 /* all other elements. The scaling factor is then contained in the */ 469 /* `units_per_em' value. */ 470 471 matrix->xx = cff_parse_fixed_dynamic( data++, &scaling ); 472 473 scaling = -scaling; 474 475 if ( scaling < 0 || scaling > 9 ) 476 { 477 /* Return default matrix in case of unlikely values. */ 478 matrix->xx = 0x10000L; 479 matrix->yx = 0; 480 matrix->yx = 0; 481 matrix->yy = 0x10000L; 482 offset->x = 0; 483 offset->y = 0; 484 *upm = 1; 485 486 goto Exit; 487 } 488 489 matrix->yx = cff_parse_fixed_scaled( data++, scaling ); 490 matrix->xy = cff_parse_fixed_scaled( data++, scaling ); 491 matrix->yy = cff_parse_fixed_scaled( data++, scaling ); 492 offset->x = cff_parse_fixed_scaled( data++, scaling ); 493 offset->y = cff_parse_fixed_scaled( data, scaling ); 494 495 *upm = power_tens[scaling]; 496 } 497 498 Exit: 499 return error; 500 } 501 502 503 static FT_Error 504 cff_parse_font_bbox( CFF_Parser parser ) 505 { 506 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 507 FT_BBox* bbox = &dict->font_bbox; 508 FT_Byte** data = parser->stack; 509 FT_Error error; 510 511 512 error = CFF_Err_Stack_Underflow; 513 514 if ( parser->top >= parser->stack + 4 ) 515 { 516 bbox->xMin = FT_RoundFix( cff_parse_fixed( data++ ) ); 517 bbox->yMin = FT_RoundFix( cff_parse_fixed( data++ ) ); 518 bbox->xMax = FT_RoundFix( cff_parse_fixed( data++ ) ); 519 bbox->yMax = FT_RoundFix( cff_parse_fixed( data ) ); 520 error = CFF_Err_Ok; 521 } 522 523 return error; 524 } 525 526 527 static FT_Error 528 cff_parse_private_dict( CFF_Parser parser ) 529 { 530 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 531 FT_Byte** data = parser->stack; 532 FT_Error error; 533 534 535 error = CFF_Err_Stack_Underflow; 536 537 if ( parser->top >= parser->stack + 2 ) 538 { 539 dict->private_size = cff_parse_num( data++ ); 540 dict->private_offset = cff_parse_num( data ); 541 error = CFF_Err_Ok; 542 } 543 544 return error; 545 } 546 547 548 static FT_Error 549 cff_parse_cid_ros( CFF_Parser parser ) 550 { 551 CFF_FontRecDict dict = (CFF_FontRecDict)parser->object; 552 FT_Byte** data = parser->stack; 553 FT_Error error; 554 555 556 error = CFF_Err_Stack_Underflow; 557 558 if ( parser->top >= parser->stack + 3 ) 559 { 560 dict->cid_registry = (FT_UInt)cff_parse_num ( data++ ); 561 dict->cid_ordering = (FT_UInt)cff_parse_num ( data++ ); 562 if ( **data == 30 ) 563 FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" )); 564 dict->cid_supplement = cff_parse_num( data ); 565 if ( dict->cid_supplement < 0 ) 566 FT_TRACE1(( "cff_parse_cid_ros: negative supplement %d is found\n", 567 dict->cid_supplement )); 568 error = CFF_Err_Ok; 569 } 570 571 return error; 572 } 573 574 575#define CFF_FIELD_NUM( code, name ) \ 576 CFF_FIELD( code, name, cff_kind_num ) 577#define CFF_FIELD_FIXED( code, name ) \ 578 CFF_FIELD( code, name, cff_kind_fixed ) 579#define CFF_FIELD_FIXED_1000( code, name ) \ 580 CFF_FIELD( code, name, cff_kind_fixed_thousand ) 581#define CFF_FIELD_STRING( code, name ) \ 582 CFF_FIELD( code, name, cff_kind_string ) 583#define CFF_FIELD_BOOL( code, name ) \ 584 CFF_FIELD( code, name, cff_kind_bool ) 585#define CFF_FIELD_DELTA( code, name, max ) \ 586 CFF_FIELD( code, name, cff_kind_delta ) 587 588#define CFFCODE_TOPDICT 0x1000 589#define CFFCODE_PRIVATE 0x2000 590 591#ifndef FT_CONFIG_OPTION_PIC 592 593#define CFF_FIELD_CALLBACK( code, name ) \ 594 { \ 595 cff_kind_callback, \ 596 code | CFFCODE, \ 597 0, 0, \ 598 cff_parse_ ## name, \ 599 0, 0 \ 600 }, 601 602#undef CFF_FIELD 603#define CFF_FIELD( code, name, kind ) \ 604 { \ 605 kind, \ 606 code | CFFCODE, \ 607 FT_FIELD_OFFSET( name ), \ 608 FT_FIELD_SIZE( name ), \ 609 0, 0, 0 \ 610 }, 611 612#undef CFF_FIELD_DELTA 613#define CFF_FIELD_DELTA( code, name, max ) \ 614 { \ 615 cff_kind_delta, \ 616 code | CFFCODE, \ 617 FT_FIELD_OFFSET( name ), \ 618 FT_FIELD_SIZE_DELTA( name ), \ 619 0, \ 620 max, \ 621 FT_FIELD_OFFSET( num_ ## name ) \ 622 }, 623 624 static const CFF_Field_Handler cff_field_handlers[] = 625 { 626 627#include "cfftoken.h" 628 629 { 0, 0, 0, 0, 0, 0, 0 } 630 }; 631 632 633#else /* FT_CONFIG_OPTION_PIC */ 634 635 void FT_Destroy_Class_cff_field_handlers(FT_Library library, CFF_Field_Handler* clazz) 636 { 637 FT_Memory memory = library->memory; 638 if ( clazz ) 639 FT_FREE( clazz ); 640 } 641 642 FT_Error FT_Create_Class_cff_field_handlers(FT_Library library, CFF_Field_Handler** output_class) 643 { 644 CFF_Field_Handler* clazz; 645 FT_Error error; 646 FT_Memory memory = library->memory; 647 int i=0; 648 649#undef CFF_FIELD 650#undef CFF_FIELD_DELTA 651#undef CFF_FIELD_CALLBACK 652#define CFF_FIELD_CALLBACK( code, name ) i++; 653#define CFF_FIELD( code, name, kind ) i++; 654#define CFF_FIELD_DELTA( code, name, max ) i++; 655 656#include "cfftoken.h" 657 i++;/*{ 0, 0, 0, 0, 0, 0, 0 }*/ 658 659 if ( FT_ALLOC( clazz, sizeof(CFF_Field_Handler)*i ) ) 660 return error; 661 662 i=0; 663#undef CFF_FIELD 664#undef CFF_FIELD_DELTA 665#undef CFF_FIELD_CALLBACK 666 667#define CFF_FIELD_CALLBACK( code_, name_ ) \ 668 clazz[i].kind = cff_kind_callback; \ 669 clazz[i].code = code_ | CFFCODE; \ 670 clazz[i].offset = 0; \ 671 clazz[i].size = 0; \ 672 clazz[i].reader = cff_parse_ ## name_; \ 673 clazz[i].array_max = 0; \ 674 clazz[i].count_offset = 0; \ 675 i++; 676 677#undef CFF_FIELD 678#define CFF_FIELD( code_, name_, kind_ ) \ 679 clazz[i].kind = kind_; \ 680 clazz[i].code = code_ | CFFCODE; \ 681 clazz[i].offset = FT_FIELD_OFFSET( name_ ); \ 682 clazz[i].size = FT_FIELD_SIZE( name_ ); \ 683 clazz[i].reader = 0; \ 684 clazz[i].array_max = 0; \ 685 clazz[i].count_offset = 0; \ 686 i++; \ 687 688#undef CFF_FIELD_DELTA 689#define CFF_FIELD_DELTA( code_, name_, max_ ) \ 690 clazz[i].kind = cff_kind_delta; \ 691 clazz[i].code = code_ | CFFCODE; \ 692 clazz[i].offset = FT_FIELD_OFFSET( name_ ); \ 693 clazz[i].size = FT_FIELD_SIZE_DELTA( name_ ); \ 694 clazz[i].reader = 0; \ 695 clazz[i].array_max = max_; \ 696 clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ ); \ 697 i++; 698 699#include "cfftoken.h" 700 701 clazz[i].kind = 0; 702 clazz[i].code = 0; 703 clazz[i].offset = 0; 704 clazz[i].size = 0; 705 clazz[i].reader = 0; 706 clazz[i].array_max = 0; 707 clazz[i].count_offset = 0; 708 709 *output_class = clazz; 710 return CFF_Err_Ok; 711 } 712 713 714#endif /* FT_CONFIG_OPTION_PIC */ 715 716 717 FT_LOCAL_DEF( FT_Error ) 718 cff_parser_run( CFF_Parser parser, 719 FT_Byte* start, 720 FT_Byte* limit ) 721 { 722 FT_Byte* p = start; 723 FT_Error error = CFF_Err_Ok; 724 FT_Library library = parser->library; 725 FT_UNUSED(library); 726 727 728 parser->top = parser->stack; 729 parser->start = start; 730 parser->limit = limit; 731 parser->cursor = start; 732 733 while ( p < limit ) 734 { 735 FT_UInt v = *p; 736 737 738 if ( v >= 27 && v != 31 ) 739 { 740 /* it's a number; we will push its position on the stack */ 741 if ( parser->top - parser->stack >= CFF_MAX_STACK_DEPTH ) 742 goto Stack_Overflow; 743 744 *parser->top ++ = p; 745 746 /* now, skip it */ 747 if ( v == 30 ) 748 { 749 /* skip real number */ 750 p++; 751 for (;;) 752 { 753 /* An unterminated floating point number at the */ 754 /* end of a dictionary is invalid but harmless. */ 755 if ( p >= limit ) 756 goto Exit; 757 v = p[0] >> 4; 758 if ( v == 15 ) 759 break; 760 v = p[0] & 0xF; 761 if ( v == 15 ) 762 break; 763 p++; 764 } 765 } 766 else if ( v == 28 ) 767 p += 2; 768 else if ( v == 29 ) 769 p += 4; 770 else if ( v > 246 ) 771 p += 1; 772 } 773 else 774 { 775 /* This is not a number, hence it's an operator. Compute its code */ 776 /* and look for it in our current list. */ 777 778 FT_UInt code; 779 FT_UInt num_args = (FT_UInt) 780 ( parser->top - parser->stack ); 781 const CFF_Field_Handler* field; 782 783 784 *parser->top = p; 785 code = v; 786 if ( v == 12 ) 787 { 788 /* two byte operator */ 789 p++; 790 if ( p >= limit ) 791 goto Syntax_Error; 792 793 code = 0x100 | p[0]; 794 } 795 code = code | parser->object_code; 796 797 for ( field = FT_CFF_FIELD_HANDLERS_GET; field->kind; field++ ) 798 { 799 if ( field->code == (FT_Int)code ) 800 { 801 /* we found our field's handler; read it */ 802 FT_Long val; 803 FT_Byte* q = (FT_Byte*)parser->object + field->offset; 804 805 806 /* check that we have enough arguments -- except for */ 807 /* delta encoded arrays, which can be empty */ 808 if ( field->kind != cff_kind_delta && num_args < 1 ) 809 goto Stack_Underflow; 810 811 switch ( field->kind ) 812 { 813 case cff_kind_bool: 814 case cff_kind_string: 815 case cff_kind_num: 816 val = cff_parse_num( parser->stack ); 817 goto Store_Number; 818 819 case cff_kind_fixed: 820 val = cff_parse_fixed( parser->stack ); 821 goto Store_Number; 822 823 case cff_kind_fixed_thousand: 824 val = cff_parse_fixed_scaled( parser->stack, 3 ); 825 826 Store_Number: 827 switch ( field->size ) 828 { 829 case (8 / FT_CHAR_BIT): 830 *(FT_Byte*)q = (FT_Byte)val; 831 break; 832 833 case (16 / FT_CHAR_BIT): 834 *(FT_Short*)q = (FT_Short)val; 835 break; 836 837 case (32 / FT_CHAR_BIT): 838 *(FT_Int32*)q = (FT_Int)val; 839 break; 840 841 default: /* for 64-bit systems */ 842 *(FT_Long*)q = val; 843 } 844 break; 845 846 case cff_kind_delta: 847 { 848 FT_Byte* qcount = (FT_Byte*)parser->object + 849 field->count_offset; 850 851 FT_Byte** data = parser->stack; 852 853 854 if ( num_args > field->array_max ) 855 num_args = field->array_max; 856 857 /* store count */ 858 *qcount = (FT_Byte)num_args; 859 860 val = 0; 861 while ( num_args > 0 ) 862 { 863 val += cff_parse_num( data++ ); 864 switch ( field->size ) 865 { 866 case (8 / FT_CHAR_BIT): 867 *(FT_Byte*)q = (FT_Byte)val; 868 break; 869 870 case (16 / FT_CHAR_BIT): 871 *(FT_Short*)q = (FT_Short)val; 872 break; 873 874 case (32 / FT_CHAR_BIT): 875 *(FT_Int32*)q = (FT_Int)val; 876 break; 877 878 default: /* for 64-bit systems */ 879 *(FT_Long*)q = val; 880 } 881 882 q += field->size; 883 num_args--; 884 } 885 } 886 break; 887 888 default: /* callback */ 889 error = field->reader( parser ); 890 if ( error ) 891 goto Exit; 892 } 893 goto Found; 894 } 895 } 896 897 /* this is an unknown operator, or it is unsupported; */ 898 /* we will ignore it for now. */ 899 900 Found: 901 /* clear stack */ 902 parser->top = parser->stack; 903 } 904 p++; 905 } 906 907 Exit: 908 return error; 909 910 Stack_Overflow: 911 error = CFF_Err_Invalid_Argument; 912 goto Exit; 913 914 Stack_Underflow: 915 error = CFF_Err_Invalid_Argument; 916 goto Exit; 917 918 Syntax_Error: 919 error = CFF_Err_Invalid_Argument; 920 goto Exit; 921 } 922 923 924/* END */ 925