1 /* 2 * Copyright (C) 1998-2004 David Turner and Werner Lemberg 3 * Copyright (C) 2006 Behdad Esfahbod 4 * 5 * This is part of HarfBuzz, an OpenType Layout engine library. 6 * 7 * Permission is hereby granted, without written agreement and without 8 * license or royalty fees, to use, copy, modify, and distribute this 9 * software and its documentation for any purpose, provided that the 10 * above copyright notice and the following two paragraphs appear in 11 * all copies of this software. 12 * 13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR 14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 17 * DAMAGE. 18 * 19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO 23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 24 */ 25 26 #include "harfbuzz-impl.h" 27 #include "harfbuzz-gdef-private.h" 28 #include "harfbuzz-open-private.h" 29 30 static HB_Error Load_AttachList( HB_AttachList* al, 31 HB_Stream stream ); 32 static HB_Error Load_LigCaretList( HB_LigCaretList* lcl, 33 HB_Stream stream ); 34 35 static void Free_AttachList( HB_AttachList* al); 36 static void Free_LigCaretList( HB_LigCaretList* lcl); 37 38 static void Free_NewGlyphClasses( HB_GDEFHeader* gdef); 39 40 41 42 /* GDEF glyph classes */ 43 44 #define UNCLASSIFIED_GLYPH 0 45 #define SIMPLE_GLYPH 1 46 #define LIGATURE_GLYPH 2 47 #define MARK_GLYPH 3 48 #define COMPONENT_GLYPH 4 49 50 51 52 53 54 55 HB_Error HB_New_GDEF_Table( HB_GDEFHeader** retptr ) 56 { 57 HB_Error error; 58 59 HB_GDEFHeader* gdef; 60 61 if ( !retptr ) 62 return ERR(HB_Err_Invalid_Argument); 63 64 if ( ALLOC( gdef, sizeof( *gdef ) ) ) 65 return error; 66 67 gdef->GlyphClassDef.loaded = FALSE; 68 gdef->AttachList.loaded = FALSE; 69 gdef->LigCaretList.loaded = FALSE; 70 gdef->MarkAttachClassDef_offset = 0; 71 gdef->MarkAttachClassDef.loaded = FALSE; 72 73 gdef->LastGlyph = 0; 74 gdef->NewGlyphClasses = NULL; 75 76 *retptr = gdef; 77 78 return HB_Err_Ok; 79 } 80 81 82 HB_Error HB_Load_GDEF_Table( HB_Stream stream, 83 HB_GDEFHeader** retptr ) 84 { 85 HB_Error error; 86 HB_UInt cur_offset, new_offset, base_offset; 87 88 HB_GDEFHeader* gdef; 89 90 91 if ( !retptr ) 92 return ERR(HB_Err_Invalid_Argument); 93 94 if ( GOTO_Table( TTAG_GDEF ) ) 95 return error; 96 97 if (( error = HB_New_GDEF_Table ( &gdef ) )) 98 return error; 99 100 base_offset = FILE_Pos(); 101 102 /* skip version */ 103 104 if ( FILE_Seek( base_offset + 4L ) || 105 ACCESS_Frame( 2L ) ) 106 goto Fail0; 107 108 new_offset = GET_UShort(); 109 110 FORGET_Frame(); 111 112 /* all GDEF subtables are optional */ 113 114 if ( new_offset ) 115 { 116 new_offset += base_offset; 117 118 /* only classes 1-4 are allowed here */ 119 120 cur_offset = FILE_Pos(); 121 if ( FILE_Seek( new_offset ) || 122 ( error = _HB_OPEN_Load_ClassDefinition( &gdef->GlyphClassDef, 5, 123 stream ) ) != HB_Err_Ok ) 124 goto Fail0; 125 (void)FILE_Seek( cur_offset ); 126 } 127 128 if ( ACCESS_Frame( 2L ) ) 129 goto Fail1; 130 131 new_offset = GET_UShort(); 132 133 FORGET_Frame(); 134 135 if ( new_offset ) 136 { 137 new_offset += base_offset; 138 139 cur_offset = FILE_Pos(); 140 if ( FILE_Seek( new_offset ) || 141 ( error = Load_AttachList( &gdef->AttachList, 142 stream ) ) != HB_Err_Ok ) 143 goto Fail1; 144 (void)FILE_Seek( cur_offset ); 145 } 146 147 if ( ACCESS_Frame( 2L ) ) 148 goto Fail2; 149 150 new_offset = GET_UShort(); 151 152 FORGET_Frame(); 153 154 if ( new_offset ) 155 { 156 new_offset += base_offset; 157 158 cur_offset = FILE_Pos(); 159 if ( FILE_Seek( new_offset ) || 160 ( error = Load_LigCaretList( &gdef->LigCaretList, 161 stream ) ) != HB_Err_Ok ) 162 goto Fail2; 163 (void)FILE_Seek( cur_offset ); 164 } 165 166 /* OpenType 1.2 has introduced the `MarkAttachClassDef' field. We 167 first have to scan the LookupFlag values to find out whether we 168 must load it or not. Here we only store the offset of the table. */ 169 170 if ( ACCESS_Frame( 2L ) ) 171 goto Fail3; 172 173 new_offset = GET_UShort(); 174 175 FORGET_Frame(); 176 177 if ( new_offset ) 178 gdef->MarkAttachClassDef_offset = new_offset + base_offset; 179 else 180 gdef->MarkAttachClassDef_offset = 0; 181 182 *retptr = gdef; 183 184 return HB_Err_Ok; 185 186 Fail3: 187 Free_LigCaretList( &gdef->LigCaretList ); 188 189 Fail2: 190 Free_AttachList( &gdef->AttachList ); 191 192 Fail1: 193 _HB_OPEN_Free_ClassDefinition( &gdef->GlyphClassDef ); 194 195 Fail0: 196 FREE( gdef ); 197 198 return error; 199 } 200 201 202 HB_Error HB_Done_GDEF_Table ( HB_GDEFHeader* gdef ) 203 { 204 Free_LigCaretList( &gdef->LigCaretList ); 205 Free_AttachList( &gdef->AttachList ); 206 _HB_OPEN_Free_ClassDefinition( &gdef->GlyphClassDef ); 207 _HB_OPEN_Free_ClassDefinition( &gdef->MarkAttachClassDef ); 208 209 Free_NewGlyphClasses( gdef ); 210 211 FREE( gdef ); 212 213 return HB_Err_Ok; 214 } 215 216 217 218 219 /******************************* 220 * AttachList related functions 221 *******************************/ 222 223 224 /* AttachPoint */ 225 226 static HB_Error Load_AttachPoint( HB_AttachPoint* ap, 227 HB_Stream stream ) 228 { 229 HB_Error error; 230 231 HB_UShort n, count; 232 HB_UShort* pi; 233 234 235 if ( ACCESS_Frame( 2L ) ) 236 return error; 237 238 count = ap->PointCount = GET_UShort(); 239 240 FORGET_Frame(); 241 242 ap->PointIndex = NULL; 243 244 if ( count ) 245 { 246 if ( ALLOC_ARRAY( ap->PointIndex, count, HB_UShort ) ) 247 return error; 248 249 pi = ap->PointIndex; 250 251 if ( ACCESS_Frame( count * 2L ) ) 252 { 253 FREE( pi ); 254 return error; 255 } 256 257 for ( n = 0; n < count; n++ ) 258 pi[n] = GET_UShort(); 259 260 FORGET_Frame(); 261 } 262 263 return HB_Err_Ok; 264 } 265 266 267 static void Free_AttachPoint( HB_AttachPoint* ap ) 268 { 269 FREE( ap->PointIndex ); 270 } 271 272 273 /* AttachList */ 274 275 static HB_Error Load_AttachList( HB_AttachList* al, 276 HB_Stream stream ) 277 { 278 HB_Error error; 279 280 HB_UShort n, m, count; 281 HB_UInt cur_offset, new_offset, base_offset; 282 283 HB_AttachPoint* ap; 284 285 286 base_offset = FILE_Pos(); 287 288 if ( ACCESS_Frame( 2L ) ) 289 return error; 290 291 new_offset = GET_UShort() + base_offset; 292 293 FORGET_Frame(); 294 295 cur_offset = FILE_Pos(); 296 if ( FILE_Seek( new_offset ) || 297 ( error = _HB_OPEN_Load_Coverage( &al->Coverage, stream ) ) != HB_Err_Ok ) 298 return error; 299 (void)FILE_Seek( cur_offset ); 300 301 if ( ACCESS_Frame( 2L ) ) 302 goto Fail2; 303 304 count = al->GlyphCount = GET_UShort(); 305 306 FORGET_Frame(); 307 308 al->AttachPoint = NULL; 309 310 if ( ALLOC_ARRAY( al->AttachPoint, count, HB_AttachPoint ) ) 311 goto Fail2; 312 313 ap = al->AttachPoint; 314 315 for ( n = 0; n < count; n++ ) 316 { 317 if ( ACCESS_Frame( 2L ) ) 318 goto Fail1; 319 320 new_offset = GET_UShort() + base_offset; 321 322 FORGET_Frame(); 323 324 cur_offset = FILE_Pos(); 325 if ( FILE_Seek( new_offset ) || 326 ( error = Load_AttachPoint( &ap[n], stream ) ) != HB_Err_Ok ) 327 goto Fail1; 328 (void)FILE_Seek( cur_offset ); 329 } 330 331 al->loaded = TRUE; 332 333 return HB_Err_Ok; 334 335 Fail1: 336 for ( m = 0; m < n; m++ ) 337 Free_AttachPoint( &ap[m] ); 338 339 FREE( ap ); 340 341 Fail2: 342 _HB_OPEN_Free_Coverage( &al->Coverage ); 343 return error; 344 } 345 346 347 static void Free_AttachList( HB_AttachList* al) 348 { 349 HB_UShort n, count; 350 351 HB_AttachPoint* ap; 352 353 354 if ( !al->loaded ) 355 return; 356 357 if ( al->AttachPoint ) 358 { 359 count = al->GlyphCount; 360 ap = al->AttachPoint; 361 362 for ( n = 0; n < count; n++ ) 363 Free_AttachPoint( &ap[n] ); 364 365 FREE( ap ); 366 } 367 368 _HB_OPEN_Free_Coverage( &al->Coverage ); 369 } 370 371 372 373 /********************************* 374 * LigCaretList related functions 375 *********************************/ 376 377 378 /* CaretValueFormat1 */ 379 /* CaretValueFormat2 */ 380 /* CaretValueFormat3 */ 381 /* CaretValueFormat4 */ 382 383 static HB_Error Load_CaretValue( HB_CaretValue* cv, 384 HB_Stream stream ) 385 { 386 HB_Error error; 387 388 HB_UInt cur_offset, new_offset, base_offset; 389 390 391 base_offset = FILE_Pos(); 392 393 if ( ACCESS_Frame( 2L ) ) 394 return error; 395 396 cv->CaretValueFormat = GET_UShort(); 397 398 FORGET_Frame(); 399 400 switch ( cv->CaretValueFormat ) 401 { 402 case 1: 403 if ( ACCESS_Frame( 2L ) ) 404 return error; 405 406 cv->cvf.cvf1.Coordinate = GET_Short(); 407 408 FORGET_Frame(); 409 410 break; 411 412 case 2: 413 if ( ACCESS_Frame( 2L ) ) 414 return error; 415 416 cv->cvf.cvf2.CaretValuePoint = GET_UShort(); 417 418 FORGET_Frame(); 419 420 break; 421 422 case 3: 423 if ( ACCESS_Frame( 4L ) ) 424 return error; 425 426 cv->cvf.cvf3.Coordinate = GET_Short(); 427 428 new_offset = GET_UShort() + base_offset; 429 430 FORGET_Frame(); 431 432 cur_offset = FILE_Pos(); 433 if ( FILE_Seek( new_offset ) || 434 ( error = _HB_OPEN_Load_Device( &cv->cvf.cvf3.Device, 435 stream ) ) != HB_Err_Ok ) 436 return error; 437 (void)FILE_Seek( cur_offset ); 438 439 break; 440 441 case 4: 442 if ( ACCESS_Frame( 2L ) ) 443 return error; 444 445 #ifdef HB_SUPPORT_MULTIPLE_MASTER 446 cv->cvf.cvf4.IdCaretValue = GET_UShort(); 447 #else 448 (void) GET_UShort(); 449 #endif 450 451 FORGET_Frame(); 452 break; 453 454 default: 455 return ERR(HB_Err_Invalid_SubTable_Format); 456 } 457 458 return HB_Err_Ok; 459 } 460 461 462 static void Free_CaretValue( HB_CaretValue* cv) 463 { 464 if ( cv->CaretValueFormat == 3 ) 465 _HB_OPEN_Free_Device( cv->cvf.cvf3.Device ); 466 } 467 468 469 /* LigGlyph */ 470 471 static HB_Error Load_LigGlyph( HB_LigGlyph* lg, 472 HB_Stream stream ) 473 { 474 HB_Error error; 475 476 HB_UShort n, m, count; 477 HB_UInt cur_offset, new_offset, base_offset; 478 479 HB_CaretValue* cv; 480 481 482 base_offset = FILE_Pos(); 483 484 if ( ACCESS_Frame( 2L ) ) 485 return error; 486 487 count = lg->CaretCount = GET_UShort(); 488 489 FORGET_Frame(); 490 491 lg->CaretValue = NULL; 492 493 if ( ALLOC_ARRAY( lg->CaretValue, count, HB_CaretValue ) ) 494 return error; 495 496 cv = lg->CaretValue; 497 498 for ( n = 0; n < count; n++ ) 499 { 500 if ( ACCESS_Frame( 2L ) ) 501 goto Fail; 502 503 new_offset = GET_UShort() + base_offset; 504 505 FORGET_Frame(); 506 507 cur_offset = FILE_Pos(); 508 if ( FILE_Seek( new_offset ) || 509 ( error = Load_CaretValue( &cv[n], stream ) ) != HB_Err_Ok ) 510 goto Fail; 511 (void)FILE_Seek( cur_offset ); 512 } 513 514 return HB_Err_Ok; 515 516 Fail: 517 for ( m = 0; m < n; m++ ) 518 Free_CaretValue( &cv[m] ); 519 520 FREE( cv ); 521 return error; 522 } 523 524 525 static void Free_LigGlyph( HB_LigGlyph* lg) 526 { 527 HB_UShort n, count; 528 529 HB_CaretValue* cv; 530 531 532 if ( lg->CaretValue ) 533 { 534 count = lg->CaretCount; 535 cv = lg->CaretValue; 536 537 for ( n = 0; n < count; n++ ) 538 Free_CaretValue( &cv[n] ); 539 540 FREE( cv ); 541 } 542 } 543 544 545 /* LigCaretList */ 546 547 static HB_Error Load_LigCaretList( HB_LigCaretList* lcl, 548 HB_Stream stream ) 549 { 550 HB_Error error; 551 552 HB_UShort m, n, count; 553 HB_UInt cur_offset, new_offset, base_offset; 554 555 HB_LigGlyph* lg; 556 557 558 base_offset = FILE_Pos(); 559 560 if ( ACCESS_Frame( 2L ) ) 561 return error; 562 563 new_offset = GET_UShort() + base_offset; 564 565 FORGET_Frame(); 566 567 cur_offset = FILE_Pos(); 568 if ( FILE_Seek( new_offset ) || 569 ( error = _HB_OPEN_Load_Coverage( &lcl->Coverage, stream ) ) != HB_Err_Ok ) 570 return error; 571 (void)FILE_Seek( cur_offset ); 572 573 if ( ACCESS_Frame( 2L ) ) 574 goto Fail2; 575 576 count = lcl->LigGlyphCount = GET_UShort(); 577 578 FORGET_Frame(); 579 580 lcl->LigGlyph = NULL; 581 582 if ( ALLOC_ARRAY( lcl->LigGlyph, count, HB_LigGlyph ) ) 583 goto Fail2; 584 585 lg = lcl->LigGlyph; 586 587 for ( n = 0; n < count; n++ ) 588 { 589 if ( ACCESS_Frame( 2L ) ) 590 goto Fail1; 591 592 new_offset = GET_UShort() + base_offset; 593 594 FORGET_Frame(); 595 596 cur_offset = FILE_Pos(); 597 if ( FILE_Seek( new_offset ) || 598 ( error = Load_LigGlyph( &lg[n], stream ) ) != HB_Err_Ok ) 599 goto Fail1; 600 (void)FILE_Seek( cur_offset ); 601 } 602 603 lcl->loaded = TRUE; 604 605 return HB_Err_Ok; 606 607 Fail1: 608 for ( m = 0; m < n; m++ ) 609 Free_LigGlyph( &lg[m] ); 610 611 FREE( lg ); 612 613 Fail2: 614 _HB_OPEN_Free_Coverage( &lcl->Coverage ); 615 return error; 616 } 617 618 619 static void Free_LigCaretList( HB_LigCaretList* lcl ) 620 { 621 HB_UShort n, count; 622 623 HB_LigGlyph* lg; 624 625 626 if ( !lcl->loaded ) 627 return; 628 629 if ( lcl->LigGlyph ) 630 { 631 count = lcl->LigGlyphCount; 632 lg = lcl->LigGlyph; 633 634 for ( n = 0; n < count; n++ ) 635 Free_LigGlyph( &lg[n] ); 636 637 FREE( lg ); 638 } 639 640 _HB_OPEN_Free_Coverage( &lcl->Coverage ); 641 } 642 643 644 645 /*********** 646 * GDEF API 647 ***********/ 648 649 650 static HB_UShort Get_New_Class( HB_GDEFHeader* gdef, 651 HB_UShort glyphID, 652 HB_UShort index ) 653 { 654 HB_UShort glyph_index, array_index, count; 655 HB_UShort byte, bits; 656 657 HB_ClassRangeRecord* gcrr; 658 HB_UShort** ngc; 659 660 661 if ( glyphID >= gdef->LastGlyph ) 662 return 0; 663 664 count = gdef->GlyphClassDef.cd.cd2.ClassRangeCount; 665 gcrr = gdef->GlyphClassDef.cd.cd2.ClassRangeRecord; 666 ngc = gdef->NewGlyphClasses; 667 668 if ( index < count && glyphID < gcrr[index].Start ) 669 { 670 array_index = index; 671 if ( index == 0 ) 672 glyph_index = glyphID; 673 else 674 glyph_index = glyphID - gcrr[index - 1].End - 1; 675 } 676 else 677 { 678 array_index = index + 1; 679 glyph_index = glyphID - gcrr[index].End - 1; 680 } 681 682 byte = ngc[array_index][glyph_index / 4]; 683 bits = byte >> ( 16 - ( glyph_index % 4 + 1 ) * 4 ); 684 685 return bits & 0x000F; 686 } 687 688 689 690 HB_Error HB_GDEF_Get_Glyph_Property( HB_GDEFHeader* gdef, 691 HB_UShort glyphID, 692 HB_UShort* property ) 693 { 694 HB_UShort class = 0, index = 0; /* shut compiler up */ 695 696 HB_Error error; 697 698 699 if ( !gdef || !property ) 700 return ERR(HB_Err_Invalid_Argument); 701 702 /* first, we check for mark attach classes */ 703 704 if ( gdef->MarkAttachClassDef.loaded ) 705 { 706 error = _HB_OPEN_Get_Class( &gdef->MarkAttachClassDef, glyphID, &class, &index ); 707 if ( error && error != HB_Err_Not_Covered ) 708 return error; 709 if ( !error ) 710 { 711 *property = class << 8; 712 return HB_Err_Ok; 713 } 714 } 715 716 error = _HB_OPEN_Get_Class( &gdef->GlyphClassDef, glyphID, &class, &index ); 717 if ( error && error != HB_Err_Not_Covered ) 718 return error; 719 720 /* if we have a constructed class table, check whether additional 721 values have been assigned */ 722 723 if ( error == HB_Err_Not_Covered && gdef->NewGlyphClasses ) 724 class = Get_New_Class( gdef, glyphID, index ); 725 726 switch ( class ) 727 { 728 default: 729 case UNCLASSIFIED_GLYPH: 730 *property = 0; 731 break; 732 733 case SIMPLE_GLYPH: 734 *property = HB_GDEF_BASE_GLYPH; 735 break; 736 737 case LIGATURE_GLYPH: 738 *property = HB_GDEF_LIGATURE; 739 break; 740 741 case MARK_GLYPH: 742 *property = HB_GDEF_MARK; 743 break; 744 745 case COMPONENT_GLYPH: 746 *property = HB_GDEF_COMPONENT; 747 break; 748 } 749 750 return HB_Err_Ok; 751 } 752 753 754 static HB_Error Make_ClassRange( HB_ClassDefinition* cd, 755 HB_UShort start, 756 HB_UShort end, 757 HB_UShort class ) 758 { 759 HB_Error error; 760 HB_UShort index; 761 762 HB_ClassDefFormat2* cdf2; 763 HB_ClassRangeRecord* crr; 764 765 766 cdf2 = &cd->cd.cd2; 767 768 if ( REALLOC_ARRAY( cdf2->ClassRangeRecord, 769 cdf2->ClassRangeCount + 1 , 770 HB_ClassRangeRecord ) ) 771 return error; 772 773 cdf2->ClassRangeCount++; 774 775 crr = cdf2->ClassRangeRecord; 776 index = cdf2->ClassRangeCount - 1; 777 778 crr[index].Start = start; 779 crr[index].End = end; 780 crr[index].Class = class; 781 782 return HB_Err_Ok; 783 } 784 785 786 787 HB_Error HB_GDEF_Build_ClassDefinition( HB_GDEFHeader* gdef, 788 HB_UShort num_glyphs, 789 HB_UShort glyph_count, 790 HB_UShort* glyph_array, 791 HB_UShort* class_array ) 792 { 793 HB_UShort start, curr_glyph, curr_class; 794 HB_UShort n, m, count; 795 HB_Error error; 796 797 HB_ClassDefinition* gcd; 798 HB_ClassRangeRecord* gcrr; 799 HB_UShort** ngc; 800 801 802 if ( !gdef || !glyph_array || !class_array ) 803 return ERR(HB_Err_Invalid_Argument); 804 805 gcd = &gdef->GlyphClassDef; 806 807 /* We build a format 2 table */ 808 809 gcd->ClassFormat = 2; 810 811 gcd->cd.cd2.ClassRangeCount = 0; 812 gcd->cd.cd2.ClassRangeRecord = NULL; 813 814 start = glyph_array[0]; 815 curr_class = class_array[0]; 816 curr_glyph = start; 817 818 if ( curr_class >= 5 ) 819 { 820 error = ERR(HB_Err_Invalid_Argument); 821 goto Fail4; 822 } 823 824 glyph_count--; 825 826 for ( n = 0; n < glyph_count + 1; n++ ) 827 { 828 if ( curr_glyph == glyph_array[n] && curr_class == class_array[n] ) 829 { 830 if ( n == glyph_count ) 831 { 832 if ( ( error = Make_ClassRange( gcd, start, 833 curr_glyph, 834 curr_class) ) != HB_Err_Ok ) 835 goto Fail3; 836 } 837 else 838 { 839 if ( curr_glyph == 0xFFFF ) 840 { 841 error = ERR(HB_Err_Invalid_Argument); 842 goto Fail3; 843 } 844 else 845 curr_glyph++; 846 } 847 } 848 else 849 { 850 if ( ( error = Make_ClassRange( gcd, start, 851 curr_glyph - 1, 852 curr_class) ) != HB_Err_Ok ) 853 goto Fail3; 854 855 if ( curr_glyph > glyph_array[n] ) 856 { 857 error = ERR(HB_Err_Invalid_Argument); 858 goto Fail3; 859 } 860 861 start = glyph_array[n]; 862 curr_class = class_array[n]; 863 curr_glyph = start; 864 865 if ( curr_class >= 5 ) 866 { 867 error = ERR(HB_Err_Invalid_Argument); 868 goto Fail3; 869 } 870 871 if ( n == glyph_count ) 872 { 873 if ( ( error = Make_ClassRange( gcd, start, 874 curr_glyph, 875 curr_class) ) != HB_Err_Ok ) 876 goto Fail3; 877 } 878 else 879 { 880 if ( curr_glyph == 0xFFFF ) 881 { 882 error = ERR(HB_Err_Invalid_Argument); 883 goto Fail3; 884 } 885 else 886 curr_glyph++; 887 } 888 } 889 } 890 891 /* now prepare the arrays for class values assigned during the lookup 892 process */ 893 894 if ( ALLOC_ARRAY( gdef->NewGlyphClasses, 895 gcd->cd.cd2.ClassRangeCount + 1, HB_UShort* ) ) 896 goto Fail3; 897 898 count = gcd->cd.cd2.ClassRangeCount; 899 gcrr = gcd->cd.cd2.ClassRangeRecord; 900 ngc = gdef->NewGlyphClasses; 901 902 /* We allocate arrays for all glyphs not covered by the class range 903 records. Each element holds four class values. */ 904 905 if ( count > 0 ) 906 { 907 if ( gcrr[0].Start ) 908 { 909 if ( ALLOC_ARRAY( ngc[0], ( gcrr[0].Start + 3 ) / 4, HB_UShort ) ) 910 goto Fail2; 911 } 912 913 for ( n = 1; n < count; n++ ) 914 { 915 if ( gcrr[n].Start - gcrr[n - 1].End > 1 ) 916 if ( ALLOC_ARRAY( ngc[n], 917 ( gcrr[n].Start - gcrr[n - 1].End + 2 ) / 4, 918 HB_UShort ) ) 919 goto Fail1; 920 } 921 922 if ( gcrr[count - 1].End != num_glyphs - 1 ) 923 { 924 if ( ALLOC_ARRAY( ngc[count], 925 ( num_glyphs - gcrr[count - 1].End + 2 ) / 4, 926 HB_UShort ) ) 927 goto Fail1; 928 } 929 } 930 else if ( num_glyphs > 0 ) 931 { 932 if ( ALLOC_ARRAY( ngc[count], 933 ( num_glyphs + 3 ) / 4, 934 HB_UShort ) ) 935 goto Fail2; 936 } 937 938 gdef->LastGlyph = num_glyphs - 1; 939 940 gdef->MarkAttachClassDef_offset = 0L; 941 gdef->MarkAttachClassDef.loaded = FALSE; 942 943 gcd->loaded = TRUE; 944 945 return HB_Err_Ok; 946 947 Fail1: 948 for ( m = 0; m < n; m++ ) 949 FREE( ngc[m] ); 950 951 Fail2: 952 FREE( gdef->NewGlyphClasses ); 953 954 Fail3: 955 FREE( gcd->cd.cd2.ClassRangeRecord ); 956 957 Fail4: 958 return error; 959 } 960 961 962 static void Free_NewGlyphClasses( HB_GDEFHeader* gdef ) 963 { 964 HB_UShort** ngc; 965 HB_UShort n, count; 966 967 968 if ( gdef->NewGlyphClasses ) 969 { 970 count = gdef->GlyphClassDef.cd.cd2.ClassRangeCount + 1; 971 ngc = gdef->NewGlyphClasses; 972 973 for ( n = 0; n < count; n++ ) 974 FREE( ngc[n] ); 975 976 FREE( ngc ); 977 } 978 } 979 980 981 HB_INTERNAL HB_Error 982 _HB_GDEF_Add_Glyph_Property( HB_GDEFHeader* gdef, 983 HB_UShort glyphID, 984 HB_UShort property ) 985 { 986 HB_Error error; 987 HB_UShort class, new_class, index = 0; /* shut compiler up */ 988 HB_UShort byte, bits, mask; 989 HB_UShort array_index, glyph_index, count; 990 991 HB_ClassRangeRecord* gcrr; 992 HB_UShort** ngc; 993 994 995 error = _HB_OPEN_Get_Class( &gdef->GlyphClassDef, glyphID, &class, &index ); 996 if ( error && error != HB_Err_Not_Covered ) 997 return error; 998 999 /* we don't accept glyphs covered in `GlyphClassDef' */ 1000 1001 if ( !error ) 1002 return HB_Err_Not_Covered; 1003 1004 switch ( property ) 1005 { 1006 case 0: 1007 new_class = UNCLASSIFIED_GLYPH; 1008 break; 1009 1010 case HB_GDEF_BASE_GLYPH: 1011 new_class = SIMPLE_GLYPH; 1012 break; 1013 1014 case HB_GDEF_LIGATURE: 1015 new_class = LIGATURE_GLYPH; 1016 break; 1017 1018 case HB_GDEF_MARK: 1019 new_class = MARK_GLYPH; 1020 break; 1021 1022 case HB_GDEF_COMPONENT: 1023 new_class = COMPONENT_GLYPH; 1024 break; 1025 1026 default: 1027 return ERR(HB_Err_Invalid_Argument); 1028 } 1029 1030 count = gdef->GlyphClassDef.cd.cd2.ClassRangeCount; 1031 gcrr = gdef->GlyphClassDef.cd.cd2.ClassRangeRecord; 1032 ngc = gdef->NewGlyphClasses; 1033 1034 if ( index < count && glyphID < gcrr[index].Start ) 1035 { 1036 array_index = index; 1037 if ( index == 0 ) 1038 glyph_index = glyphID; 1039 else 1040 glyph_index = glyphID - gcrr[index - 1].End - 1; 1041 } 1042 else 1043 { 1044 array_index = index + 1; 1045 glyph_index = glyphID - gcrr[index].End - 1; 1046 } 1047 1048 byte = ngc[array_index][glyph_index / 4]; 1049 bits = byte >> ( 16 - ( glyph_index % 4 + 1 ) * 4 ); 1050 class = bits & 0x000F; 1051 1052 /* we don't overwrite existing entries */ 1053 1054 if ( !class ) 1055 { 1056 bits = new_class << ( 16 - ( glyph_index % 4 + 1 ) * 4 ); 1057 mask = ~( 0x000F << ( 16 - ( glyph_index % 4 + 1 ) * 4 ) ); 1058 1059 ngc[array_index][glyph_index / 4] &= mask; 1060 ngc[array_index][glyph_index / 4] |= bits; 1061 } 1062 1063 return HB_Err_Ok; 1064 } 1065 1066 1067 HB_INTERNAL HB_Error 1068 _HB_GDEF_Check_Property( HB_GDEFHeader* gdef, 1069 HB_GlyphItem gitem, 1070 HB_UShort flags, 1071 HB_UShort* property ) 1072 { 1073 HB_Error error; 1074 1075 if ( gdef ) 1076 { 1077 HB_UShort basic_glyph_class; 1078 HB_UShort desired_attachment_class; 1079 1080 if ( gitem->gproperties == HB_GLYPH_PROPERTIES_UNKNOWN ) 1081 { 1082 error = HB_GDEF_Get_Glyph_Property( gdef, gitem->gindex, &gitem->gproperties ); 1083 if ( error ) 1084 return error; 1085 } 1086 1087 *property = gitem->gproperties; 1088 1089 /* If the glyph was found in the MarkAttachmentClass table, 1090 * then that class value is the high byte of the result, 1091 * otherwise the low byte contains the basic type of the glyph 1092 * as defined by the GlyphClassDef table. 1093 */ 1094 if ( *property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) 1095 basic_glyph_class = HB_GDEF_MARK; 1096 else 1097 basic_glyph_class = *property; 1098 1099 /* Return Not_Covered, if, for example, basic_glyph_class 1100 * is HB_GDEF_LIGATURE and LookFlags includes HB_LOOKUP_FLAG_IGNORE_LIGATURES 1101 */ 1102 if ( flags & basic_glyph_class ) 1103 return HB_Err_Not_Covered; 1104 1105 /* The high byte of LookupFlags has the meaning 1106 * "ignore marks of attachment type different than 1107 * the attachment type specified." 1108 */ 1109 desired_attachment_class = flags & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS; 1110 if ( desired_attachment_class ) 1111 { 1112 if ( basic_glyph_class == HB_GDEF_MARK && 1113 *property != desired_attachment_class ) 1114 return HB_Err_Not_Covered; 1115 } 1116 } else { 1117 *property = 0; 1118 } 1119 1120 return HB_Err_Ok; 1121 } 1122 1123 HB_INTERNAL HB_Error 1124 _HB_GDEF_LoadMarkAttachClassDef_From_LookupFlags( HB_GDEFHeader* gdef, 1125 HB_Stream stream, 1126 HB_Lookup* lo, 1127 HB_UShort num_lookups) 1128 { 1129 HB_Error error = HB_Err_Ok; 1130 HB_UShort i; 1131 1132 /* We now check the LookupFlags for values larger than 0xFF to find 1133 out whether we need to load the `MarkAttachClassDef' field of the 1134 GDEF table -- this hack is necessary for OpenType 1.2 tables since 1135 the version field of the GDEF table hasn't been incremented. 1136 1137 For constructed GDEF tables, we only load it if 1138 `MarkAttachClassDef_offset' is not zero (nevertheless, a build of 1139 a constructed mark attach table is not supported currently). */ 1140 1141 if ( gdef && 1142 gdef->MarkAttachClassDef_offset && !gdef->MarkAttachClassDef.loaded ) 1143 { 1144 for ( i = 0; i < num_lookups; i++ ) 1145 { 1146 1147 if ( lo[i].LookupFlag & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) 1148 { 1149 if ( FILE_Seek( gdef->MarkAttachClassDef_offset ) || 1150 ( error = _HB_OPEN_Load_ClassDefinition( &gdef->MarkAttachClassDef, 1151 256, stream ) ) != HB_Err_Ok ) 1152 goto Done; 1153 1154 break; 1155 } 1156 } 1157 } 1158 1159 Done: 1160 return error; 1161 } 1162 1163 /* END */ 1164
