1 /* 2 * Copyright (C) 1998-2004 David Turner and Werner Lemberg 3 * Copyright (C) 2006 Behdad Esfahbod 4 * Copyright (C) 2007 Red Hat, Inc. 5 * 6 * This is part of HarfBuzz, an OpenType Layout engine library. 7 * 8 * Permission is hereby granted, without written agreement and without 9 * license or royalty fees, to use, copy, modify, and distribute this 10 * software and its documentation for any purpose, provided that the 11 * above copyright notice and the following two paragraphs appear in 12 * all copies of this software. 13 * 14 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR 15 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 16 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 17 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 18 * DAMAGE. 19 * 20 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 21 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 22 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 23 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO 24 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 25 * 26 * Red Hat Author(s): Behdad Esfahbod 27 */ 28 29 #include "harfbuzz-impl.h" 30 #include "harfbuzz-gpos-private.h" 31 #include "harfbuzz-open-private.h" 32 #include "harfbuzz-gdef-private.h" 33 #include "harfbuzz-shaper.h" 34 35 struct GPOS_Instance_ 36 { 37 HB_GPOSHeader* gpos; 38 HB_Font font; 39 HB_Bool dvi; 40 HB_UShort load_flags; /* how the glyph should be loaded */ 41 HB_Bool r2l; 42 43 HB_UShort last; /* the last valid glyph -- used 44 with cursive positioning */ 45 HB_Fixed anchor_x; /* the coordinates of the anchor point */ 46 HB_Fixed anchor_y; /* of the last valid glyph */ 47 }; 48 49 typedef struct GPOS_Instance_ GPOS_Instance; 50 51 52 static HB_Error GPOS_Do_Glyph_Lookup( GPOS_Instance* gpi, 53 HB_UShort lookup_index, 54 HB_Buffer buffer, 55 HB_UShort context_length, 56 int nesting_level ); 57 58 59 60 #ifdef HB_SUPPORT_MULTIPLE_MASTER 61 /* the client application must replace this with something more 62 meaningful if multiple master fonts are to be supported. */ 63 64 static HB_Error default_mmfunc( HB_Font font, 65 HB_UShort metric_id, 66 HB_Fixed* metric_value, 67 void* data ) 68 { 69 HB_UNUSED(font); 70 HB_UNUSED(metric_id); 71 HB_UNUSED(metric_value); 72 HB_UNUSED(data); 73 return ERR(HB_Err_Not_Covered); /* ERR() call intended */ 74 } 75 #endif 76 77 78 79 HB_Error HB_Load_GPOS_Table( HB_Stream stream, 80 HB_GPOSHeader** retptr, 81 HB_GDEFHeader* gdef, 82 HB_Stream gdefStream ) 83 { 84 HB_UInt cur_offset, new_offset, base_offset; 85 86 HB_GPOSHeader* gpos; 87 88 HB_Error error; 89 90 91 if ( !retptr ) 92 return ERR(HB_Err_Invalid_Argument); 93 94 if ( GOTO_Table( TTAG_GPOS ) ) 95 return error; 96 97 base_offset = FILE_Pos(); 98 99 if ( ALLOC ( gpos, sizeof( *gpos ) ) ) 100 return error; 101 102 #ifdef HB_SUPPORT_MULTIPLE_MASTER 103 gpos->mmfunc = default_mmfunc; 104 #endif 105 106 /* skip version */ 107 108 if ( FILE_Seek( base_offset + 4L ) || 109 ACCESS_Frame( 2L ) ) 110 goto Fail4; 111 112 new_offset = GET_UShort() + base_offset; 113 114 FORGET_Frame(); 115 116 cur_offset = FILE_Pos(); 117 if ( FILE_Seek( new_offset ) || 118 ( error = _HB_OPEN_Load_ScriptList( &gpos->ScriptList, 119 stream ) ) != HB_Err_Ok ) 120 goto Fail4; 121 (void)FILE_Seek( cur_offset ); 122 123 if ( ACCESS_Frame( 2L ) ) 124 goto Fail3; 125 126 new_offset = GET_UShort() + base_offset; 127 128 FORGET_Frame(); 129 130 cur_offset = FILE_Pos(); 131 if ( FILE_Seek( new_offset ) || 132 ( error = _HB_OPEN_Load_FeatureList( &gpos->FeatureList, 133 stream ) ) != HB_Err_Ok ) 134 goto Fail3; 135 (void)FILE_Seek( cur_offset ); 136 137 if ( ACCESS_Frame( 2L ) ) 138 goto Fail2; 139 140 new_offset = GET_UShort() + base_offset; 141 142 FORGET_Frame(); 143 144 cur_offset = FILE_Pos(); 145 if ( FILE_Seek( new_offset ) || 146 ( error = _HB_OPEN_Load_LookupList( &gpos->LookupList, 147 stream, HB_Type_GPOS ) ) != HB_Err_Ok ) 148 goto Fail2; 149 150 gpos->gdef = gdef; /* can be NULL */ 151 152 if ( ( error = _HB_GDEF_LoadMarkAttachClassDef_From_LookupFlags( gdef, gdefStream, 153 gpos->LookupList.Lookup, 154 gpos->LookupList.LookupCount ) ) ) 155 goto Fail1; 156 157 *retptr = gpos; 158 159 return HB_Err_Ok; 160 161 Fail1: 162 _HB_OPEN_Free_LookupList( &gpos->LookupList, HB_Type_GPOS ); 163 164 Fail2: 165 _HB_OPEN_Free_FeatureList( &gpos->FeatureList ); 166 167 Fail3: 168 _HB_OPEN_Free_ScriptList( &gpos->ScriptList ); 169 170 Fail4: 171 FREE( gpos ); 172 173 return error; 174 } 175 176 177 HB_Error HB_Done_GPOS_Table( HB_GPOSHeader* gpos ) 178 { 179 _HB_OPEN_Free_LookupList( &gpos->LookupList, HB_Type_GPOS ); 180 _HB_OPEN_Free_FeatureList( &gpos->FeatureList ); 181 _HB_OPEN_Free_ScriptList( &gpos->ScriptList ); 182 183 FREE( gpos ); 184 185 return HB_Err_Ok; 186 } 187 188 189 /***************************** 190 * SubTable related functions 191 *****************************/ 192 193 /* shared tables */ 194 195 /* ValueRecord */ 196 197 /* There is a subtle difference in the specs between a `table' and a 198 `record' -- offsets for device tables in ValueRecords are taken from 199 the parent table and not the parent record. */ 200 201 static HB_Error Load_ValueRecord( HB_ValueRecord* vr, 202 HB_UShort format, 203 HB_UInt base_offset, 204 HB_Stream stream ) 205 { 206 HB_Error error; 207 208 HB_UInt cur_offset, new_offset; 209 210 211 if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT ) 212 { 213 if ( ACCESS_Frame( 2L ) ) 214 return error; 215 216 vr->XPlacement = GET_Short(); 217 218 FORGET_Frame(); 219 } 220 else 221 vr->XPlacement = 0; 222 223 if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT ) 224 { 225 if ( ACCESS_Frame( 2L ) ) 226 return error; 227 228 vr->YPlacement = GET_Short(); 229 230 FORGET_Frame(); 231 } 232 else 233 vr->YPlacement = 0; 234 235 if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE ) 236 { 237 if ( ACCESS_Frame( 2L ) ) 238 return error; 239 240 vr->XAdvance = GET_Short(); 241 242 FORGET_Frame(); 243 } 244 else 245 vr->XAdvance = 0; 246 247 if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE ) 248 { 249 if ( ACCESS_Frame( 2L ) ) 250 return error; 251 252 vr->YAdvance = GET_Short(); 253 254 FORGET_Frame(); 255 } 256 else 257 vr->YAdvance = 0; 258 259 if ( format & HB_GPOS_FORMAT_HAVE_DEVICE_TABLES ) 260 { 261 if ( ALLOC_ARRAY( vr->DeviceTables, 4, HB_Device ) ) 262 return error; 263 vr->DeviceTables[VR_X_ADVANCE_DEVICE] = 0; 264 vr->DeviceTables[VR_Y_ADVANCE_DEVICE] = 0; 265 vr->DeviceTables[VR_X_PLACEMENT_DEVICE] = 0; 266 vr->DeviceTables[VR_Y_PLACEMENT_DEVICE] = 0; 267 } 268 else 269 { 270 vr->DeviceTables = 0; 271 } 272 273 if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT_DEVICE ) 274 { 275 if ( ACCESS_Frame( 2L ) ) 276 goto Fail4; 277 278 new_offset = GET_UShort(); 279 280 FORGET_Frame(); 281 282 if ( new_offset ) 283 { 284 new_offset += base_offset; 285 286 cur_offset = FILE_Pos(); 287 if ( FILE_Seek( new_offset ) || 288 ( error = _HB_OPEN_Load_Device( &vr->DeviceTables[VR_X_PLACEMENT_DEVICE], 289 stream ) ) != HB_Err_Ok ) 290 goto Fail4; 291 (void)FILE_Seek( cur_offset ); 292 } 293 } 294 295 if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT_DEVICE ) 296 { 297 if ( ACCESS_Frame( 2L ) ) 298 goto Fail3; 299 300 new_offset = GET_UShort(); 301 302 FORGET_Frame(); 303 304 if ( new_offset ) 305 { 306 new_offset += base_offset; 307 308 cur_offset = FILE_Pos(); 309 if ( FILE_Seek( new_offset ) || 310 ( error = _HB_OPEN_Load_Device( &vr->DeviceTables[VR_Y_PLACEMENT_DEVICE], 311 stream ) ) != HB_Err_Ok ) 312 goto Fail3; 313 (void)FILE_Seek( cur_offset ); 314 } 315 } 316 317 if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE_DEVICE ) 318 { 319 if ( ACCESS_Frame( 2L ) ) 320 goto Fail2; 321 322 new_offset = GET_UShort(); 323 324 FORGET_Frame(); 325 326 if ( new_offset ) 327 { 328 new_offset += base_offset; 329 330 cur_offset = FILE_Pos(); 331 if ( FILE_Seek( new_offset ) || 332 ( error = _HB_OPEN_Load_Device( &vr->DeviceTables[VR_X_ADVANCE_DEVICE], 333 stream ) ) != HB_Err_Ok ) 334 goto Fail2; 335 (void)FILE_Seek( cur_offset ); 336 } 337 } 338 339 if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE_DEVICE ) 340 { 341 if ( ACCESS_Frame( 2L ) ) 342 goto Fail1; 343 344 new_offset = GET_UShort(); 345 346 FORGET_Frame(); 347 348 if ( new_offset ) 349 { 350 new_offset += base_offset; 351 352 cur_offset = FILE_Pos(); 353 if ( FILE_Seek( new_offset ) || 354 ( error = _HB_OPEN_Load_Device( &vr->DeviceTables[VR_Y_ADVANCE_DEVICE], 355 stream ) ) != HB_Err_Ok ) 356 goto Fail1; 357 (void)FILE_Seek( cur_offset ); 358 } 359 } 360 361 if ( format & HB_GPOS_FORMAT_HAVE_X_ID_PLACEMENT ) 362 { 363 if ( ACCESS_Frame( 2L ) ) 364 goto Fail1; 365 366 #ifdef HB_SUPPORT_MULTIPLE_MASTER 367 vr->XIdPlacement = GET_UShort(); 368 #else 369 (void) GET_UShort(); 370 #endif 371 372 FORGET_Frame(); 373 } 374 #ifdef HB_SUPPORT_MULTIPLE_MASTER 375 else 376 vr->XIdPlacement = 0; 377 #endif 378 379 if ( format & HB_GPOS_FORMAT_HAVE_Y_ID_PLACEMENT ) 380 { 381 if ( ACCESS_Frame( 2L ) ) 382 goto Fail1; 383 384 #ifdef HB_SUPPORT_MULTIPLE_MASTER 385 vr->YIdPlacement = GET_UShort(); 386 #else 387 (void) GET_UShort(); 388 #endif 389 390 FORGET_Frame(); 391 } 392 #ifdef HB_SUPPORT_MULTIPLE_MASTER 393 else 394 vr->YIdPlacement = 0; 395 #endif 396 397 if ( format & HB_GPOS_FORMAT_HAVE_X_ID_ADVANCE ) 398 { 399 if ( ACCESS_Frame( 2L ) ) 400 goto Fail1; 401 402 #ifdef HB_SUPPORT_MULTIPLE_MASTER 403 vr->XIdAdvance = GET_UShort(); 404 #else 405 (void) GET_UShort(); 406 #endif 407 408 FORGET_Frame(); 409 } 410 #ifdef HB_SUPPORT_MULTIPLE_MASTER 411 else 412 vr->XIdAdvance = 0; 413 #endif 414 415 if ( format & HB_GPOS_FORMAT_HAVE_Y_ID_ADVANCE ) 416 { 417 if ( ACCESS_Frame( 2L ) ) 418 goto Fail1; 419 420 #ifdef HB_SUPPORT_MULTIPLE_MASTER 421 vr->YIdAdvance = GET_UShort(); 422 #else 423 (void) GET_UShort(); 424 #endif 425 426 FORGET_Frame(); 427 } 428 #ifdef HB_SUPPORT_MULTIPLE_MASTER 429 else 430 vr->YIdAdvance = 0; 431 #endif 432 433 return HB_Err_Ok; 434 435 Fail1: 436 if ( vr->DeviceTables ) 437 _HB_OPEN_Free_Device( vr->DeviceTables[VR_Y_ADVANCE_DEVICE] ); 438 439 Fail2: 440 if ( vr->DeviceTables ) 441 _HB_OPEN_Free_Device( vr->DeviceTables[VR_X_ADVANCE_DEVICE] ); 442 443 Fail3: 444 if ( vr->DeviceTables ) 445 _HB_OPEN_Free_Device( vr->DeviceTables[VR_Y_PLACEMENT_DEVICE] ); 446 447 Fail4: 448 FREE( vr->DeviceTables ); 449 return error; 450 } 451 452 453 static void Free_ValueRecord( HB_ValueRecord* vr, 454 HB_UShort format ) 455 { 456 if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE_DEVICE ) 457 _HB_OPEN_Free_Device( vr->DeviceTables[VR_Y_ADVANCE_DEVICE] ); 458 if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE_DEVICE ) 459 _HB_OPEN_Free_Device( vr->DeviceTables[VR_X_ADVANCE_DEVICE] ); 460 if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT_DEVICE ) 461 _HB_OPEN_Free_Device( vr->DeviceTables[VR_Y_PLACEMENT_DEVICE] ); 462 if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT_DEVICE ) 463 _HB_OPEN_Free_Device( vr->DeviceTables[VR_X_PLACEMENT_DEVICE] ); 464 FREE( vr->DeviceTables ); 465 } 466 467 468 static HB_Error Get_ValueRecord( GPOS_Instance* gpi, 469 HB_ValueRecord* vr, 470 HB_UShort format, 471 HB_Position gd ) 472 { 473 HB_Short pixel_value; 474 HB_Error error = HB_Err_Ok; 475 #ifdef HB_SUPPORT_MULTIPLE_MASTER 476 HB_GPOSHeader* gpos = gpi->gpos; 477 HB_Fixed value; 478 #endif 479 480 HB_UShort x_ppem, y_ppem; 481 HB_16Dot16 x_scale, y_scale; 482 483 484 if ( !format ) 485 return HB_Err_Ok; 486 487 x_ppem = gpi->font->x_ppem; 488 y_ppem = gpi->font->y_ppem; 489 x_scale = gpi->font->x_scale; 490 y_scale = gpi->font->y_scale; 491 492 /* design units -> fractional pixel */ 493 494 if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT ) 495 gd->x_pos += x_scale * vr->XPlacement / 0x10000; 496 if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT ) 497 gd->y_pos += y_scale * vr->YPlacement / 0x10000; 498 if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE ) 499 gd->x_advance += x_scale * vr->XAdvance / 0x10000; 500 if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE ) 501 gd->y_advance += y_scale * vr->YAdvance / 0x10000; 502 503 if ( !gpi->dvi ) 504 { 505 /* pixel -> fractional pixel */ 506 507 if ( format & HB_GPOS_FORMAT_HAVE_X_PLACEMENT_DEVICE ) 508 { 509 _HB_OPEN_Get_Device( vr->DeviceTables[VR_X_PLACEMENT_DEVICE], x_ppem, &pixel_value ); 510 gd->x_pos += pixel_value << 6; 511 } 512 if ( format & HB_GPOS_FORMAT_HAVE_Y_PLACEMENT_DEVICE ) 513 { 514 _HB_OPEN_Get_Device( vr->DeviceTables[VR_Y_PLACEMENT_DEVICE], y_ppem, &pixel_value ); 515 gd->y_pos += pixel_value << 6; 516 } 517 if ( format & HB_GPOS_FORMAT_HAVE_X_ADVANCE_DEVICE ) 518 { 519 _HB_OPEN_Get_Device( vr->DeviceTables[VR_X_ADVANCE_DEVICE], x_ppem, &pixel_value ); 520 gd->x_advance += pixel_value << 6; 521 } 522 if ( format & HB_GPOS_FORMAT_HAVE_Y_ADVANCE_DEVICE ) 523 { 524 _HB_OPEN_Get_Device( vr->DeviceTables[VR_Y_ADVANCE_DEVICE], y_ppem, &pixel_value ); 525 gd->y_advance += pixel_value << 6; 526 } 527 } 528 529 #ifdef HB_SUPPORT_MULTIPLE_MASTER 530 /* values returned from mmfunc() are already in fractional pixels */ 531 532 if ( format & HB_GPOS_FORMAT_HAVE_X_ID_PLACEMENT ) 533 { 534 error = (gpos->mmfunc)( gpi->font, vr->XIdPlacement, 535 &value, gpos->data ); 536 if ( error ) 537 return error; 538 gd->x_pos += value; 539 } 540 if ( format & HB_GPOS_FORMAT_HAVE_Y_ID_PLACEMENT ) 541 { 542 error = (gpos->mmfunc)( gpi->font, vr->YIdPlacement, 543 &value, gpos->data ); 544 if ( error ) 545 return error; 546 gd->y_pos += value; 547 } 548 if ( format & HB_GPOS_FORMAT_HAVE_X_ID_ADVANCE ) 549 { 550 error = (gpos->mmfunc)( gpi->font, vr->XIdAdvance, 551 &value, gpos->data ); 552 if ( error ) 553 return error; 554 gd->x_advance += value; 555 } 556 if ( format & HB_GPOS_FORMAT_HAVE_Y_ID_ADVANCE ) 557 { 558 error = (gpos->mmfunc)( gpi->font, vr->YIdAdvance, 559 &value, gpos->data ); 560 if ( error ) 561 return error; 562 gd->y_advance += value; 563 } 564 #endif 565 566 return error; 567 } 568 569 570 /* AnchorFormat1 */ 571 /* AnchorFormat2 */ 572 /* AnchorFormat3 */ 573 /* AnchorFormat4 */ 574 575 static HB_Error Load_Anchor( HB_Anchor* an, 576 HB_Stream stream ) 577 { 578 HB_Error error; 579 580 HB_UInt cur_offset, new_offset, base_offset; 581 582 583 base_offset = FILE_Pos(); 584 585 if ( ACCESS_Frame( 2L ) ) 586 return error; 587 588 an->PosFormat = GET_UShort(); 589 590 FORGET_Frame(); 591 592 switch ( an->PosFormat ) 593 { 594 case 1: 595 if ( ACCESS_Frame( 4L ) ) 596 return error; 597 598 an->af.af1.XCoordinate = GET_Short(); 599 an->af.af1.YCoordinate = GET_Short(); 600 601 FORGET_Frame(); 602 break; 603 604 case 2: 605 if ( ACCESS_Frame( 6L ) ) 606 return error; 607 608 an->af.af2.XCoordinate = GET_Short(); 609 an->af.af2.YCoordinate = GET_Short(); 610 an->af.af2.AnchorPoint = GET_UShort(); 611 612 FORGET_Frame(); 613 break; 614 615 case 3: 616 if ( ACCESS_Frame( 6L ) ) 617 return error; 618 619 an->af.af3.XCoordinate = GET_Short(); 620 an->af.af3.YCoordinate = GET_Short(); 621 622 new_offset = GET_UShort(); 623 624 FORGET_Frame(); 625 626 if ( new_offset ) 627 { 628 if ( ALLOC_ARRAY( an->af.af3.DeviceTables, 2, HB_Device ) ) 629 return error; 630 631 an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE] = 0; 632 an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE] = 0; 633 634 new_offset += base_offset; 635 636 cur_offset = FILE_Pos(); 637 if ( FILE_Seek( new_offset ) || 638 ( error = _HB_OPEN_Load_Device( &an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE], 639 stream ) ) != HB_Err_Ok ) 640 goto Fail2; 641 (void)FILE_Seek( cur_offset ); 642 } 643 644 if ( ACCESS_Frame( 2L ) ) 645 goto Fail; 646 647 new_offset = GET_UShort(); 648 649 FORGET_Frame(); 650 651 if ( new_offset ) 652 { 653 if ( !an->af.af3.DeviceTables ) 654 { 655 if ( ALLOC_ARRAY( an->af.af3.DeviceTables, 2, HB_Device ) ) 656 return error; 657 658 an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE] = 0; 659 an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE] = 0; 660 } 661 662 new_offset += base_offset; 663 664 cur_offset = FILE_Pos(); 665 if ( FILE_Seek( new_offset ) || 666 ( error = _HB_OPEN_Load_Device( &an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE], 667 stream ) ) != HB_Err_Ok ) 668 goto Fail; 669 (void)FILE_Seek( cur_offset ); 670 } 671 break; 672 673 case 4: 674 if ( ACCESS_Frame( 4L ) ) 675 return error; 676 677 #ifdef HB_SUPPORT_MULTIPLE_MASTER 678 an->af.af4.XIdAnchor = GET_UShort(); 679 an->af.af4.YIdAnchor = GET_UShort(); 680 #else 681 (void) GET_UShort(); 682 (void) GET_UShort(); 683 #endif 684 685 FORGET_Frame(); 686 break; 687 688 default: 689 return ERR(HB_Err_Invalid_SubTable_Format); 690 } 691 692 return HB_Err_Ok; 693 694 Fail: 695 if ( an->af.af3.DeviceTables ) 696 _HB_OPEN_Free_Device( an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE] ); 697 698 Fail2: 699 FREE( an->af.af3.DeviceTables ); 700 return error; 701 } 702 703 704 static void Free_Anchor( HB_Anchor* an) 705 { 706 if ( an->PosFormat == 3 && an->af.af3.DeviceTables ) 707 { 708 _HB_OPEN_Free_Device( an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE] ); 709 _HB_OPEN_Free_Device( an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE] ); 710 FREE( an->af.af3.DeviceTables ); 711 } 712 } 713 714 715 static HB_Error Get_Anchor( GPOS_Instance* gpi, 716 HB_Anchor* an, 717 HB_UShort glyph_index, 718 HB_Fixed* x_value, 719 HB_Fixed* y_value ) 720 { 721 HB_Error error = HB_Err_Ok; 722 723 #ifdef HB_SUPPORT_MULTIPLE_MASTER 724 HB_GPOSHeader* gpos = gpi->gpos; 725 #endif 726 HB_UShort ap; 727 728 HB_Short pixel_value; 729 730 HB_UShort x_ppem, y_ppem; 731 HB_16Dot16 x_scale, y_scale; 732 733 734 x_ppem = gpi->font->x_ppem; 735 y_ppem = gpi->font->y_ppem; 736 x_scale = gpi->font->x_scale; 737 y_scale = gpi->font->y_scale; 738 739 switch ( an->PosFormat ) 740 { 741 case 0: 742 /* The special case of an empty AnchorTable */ 743 default: 744 745 return HB_Err_Not_Covered; 746 747 case 1: 748 *x_value = x_scale * an->af.af1.XCoordinate / 0x10000; 749 *y_value = y_scale * an->af.af1.YCoordinate / 0x10000; 750 break; 751 752 case 2: 753 if ( !gpi->dvi ) 754 { 755 hb_uint32 n_points = 0; 756 ap = an->af.af2.AnchorPoint; 757 if (!gpi->font->klass->getPointInOutline) 758 goto no_contour_point; 759 error = gpi->font->klass->getPointInOutline(gpi->font, glyph_index, gpi->load_flags, ap, x_value, y_value, &n_points); 760 if (error) 761 return error; 762 /* if n_points is set to zero, we use the design coordinate value pair. 763 * This can happen e.g. for sbit glyphs. */ 764 if (!n_points) 765 goto no_contour_point; 766 } 767 else 768 { 769 no_contour_point: 770 *x_value = x_scale * an->af.af3.XCoordinate / 0x10000; 771 *y_value = y_scale * an->af.af3.YCoordinate / 0x10000; 772 } 773 break; 774 775 case 3: 776 if ( !gpi->dvi ) 777 { 778 _HB_OPEN_Get_Device( an->af.af3.DeviceTables[AF3_X_DEVICE_TABLE], x_ppem, &pixel_value ); 779 *x_value = pixel_value << 6; 780 _HB_OPEN_Get_Device( an->af.af3.DeviceTables[AF3_Y_DEVICE_TABLE], y_ppem, &pixel_value ); 781 *y_value = pixel_value << 6; 782 } 783 else 784 *x_value = *y_value = 0; 785 786 *x_value += x_scale * an->af.af3.XCoordinate / 0x10000; 787 *y_value += y_scale * an->af.af3.YCoordinate / 0x10000; 788 break; 789 790 case 4: 791 #ifdef HB_SUPPORT_MULTIPLE_MASTER 792 error = (gpos->mmfunc)( gpi->font, an->af.af4.XIdAnchor, 793 x_value, gpos->data ); 794 if ( error ) 795 return error; 796 797 error = (gpos->mmfunc)( gpi->font, an->af.af4.YIdAnchor, 798 y_value, gpos->data ); 799 if ( error ) 800 return error; 801 break; 802 #else 803 return ERR(HB_Err_Not_Covered); 804 #endif 805 } 806 807 return error; 808 } 809 810 811 /* MarkArray */ 812 813 static HB_Error Load_MarkArray ( HB_MarkArray* ma, 814 HB_Stream stream ) 815 { 816 HB_Error error; 817 818 HB_UShort n, m, count; 819 HB_UInt cur_offset, new_offset, base_offset; 820 821 HB_MarkRecord* mr; 822 823 824 base_offset = FILE_Pos(); 825 826 if ( ACCESS_Frame( 2L ) ) 827 return error; 828 829 count = ma->MarkCount = GET_UShort(); 830 831 FORGET_Frame(); 832 833 ma->MarkRecord = NULL; 834 835 if ( ALLOC_ARRAY( ma->MarkRecord, count, HB_MarkRecord ) ) 836 return error; 837 838 mr = ma->MarkRecord; 839 840 for ( n = 0; n < count; n++ ) 841 { 842 if ( ACCESS_Frame( 4L ) ) 843 goto Fail; 844 845 mr[n].Class = GET_UShort(); 846 new_offset = GET_UShort() + base_offset; 847 848 FORGET_Frame(); 849 850 cur_offset = FILE_Pos(); 851 if ( FILE_Seek( new_offset ) || 852 ( error = Load_Anchor( &mr[n].MarkAnchor, stream ) ) != HB_Err_Ok ) 853 goto Fail; 854 (void)FILE_Seek( cur_offset ); 855 } 856 857 return HB_Err_Ok; 858 859 Fail: 860 for ( m = 0; m < n; m++ ) 861 Free_Anchor( &mr[m].MarkAnchor ); 862 863 FREE( mr ); 864 return error; 865 } 866 867 868 static void Free_MarkArray( HB_MarkArray* ma ) 869 { 870 HB_UShort n, count; 871 872 HB_MarkRecord* mr; 873 874 875 if ( ma->MarkRecord ) 876 { 877 count = ma->MarkCount; 878 mr = ma->MarkRecord; 879 880 for ( n = 0; n < count; n++ ) 881 Free_Anchor( &mr[n].MarkAnchor ); 882 883 FREE( mr ); 884 } 885 } 886 887 888 /* LookupType 1 */ 889 890 /* SinglePosFormat1 */ 891 /* SinglePosFormat2 */ 892 893 static HB_Error Load_SinglePos( HB_GPOS_SubTable* st, 894 HB_Stream stream ) 895 { 896 HB_Error error; 897 HB_SinglePos* sp = &st->single; 898 899 HB_UShort n, m, count, format; 900 HB_UInt cur_offset, new_offset, base_offset; 901 902 HB_ValueRecord* vr; 903 904 905 base_offset = FILE_Pos(); 906 907 if ( ACCESS_Frame( 6L ) ) 908 return error; 909 910 sp->PosFormat = GET_UShort(); 911 new_offset = GET_UShort() + base_offset; 912 913 format = sp->ValueFormat = GET_UShort(); 914 915 FORGET_Frame(); 916 917 if ( !format ) 918 return ERR(HB_Err_Invalid_SubTable); 919 920 cur_offset = FILE_Pos(); 921 if ( FILE_Seek( new_offset ) || 922 ( error = _HB_OPEN_Load_Coverage( &sp->Coverage, stream ) ) != HB_Err_Ok ) 923 return error; 924 (void)FILE_Seek( cur_offset ); 925 926 switch ( sp->PosFormat ) 927 { 928 case 1: 929 error = Load_ValueRecord( &sp->spf.spf1.Value, format, 930 base_offset, stream ); 931 if ( error ) 932 goto Fail2; 933 break; 934 935 case 2: 936 if ( ACCESS_Frame( 2L ) ) 937 goto Fail2; 938 939 count = sp->spf.spf2.ValueCount = GET_UShort(); 940 941 FORGET_Frame(); 942 943 sp->spf.spf2.Value = NULL; 944 945 if ( ALLOC_ARRAY( sp->spf.spf2.Value, count, HB_ValueRecord ) ) 946 goto Fail2; 947 948 vr = sp->spf.spf2.Value; 949 950 for ( n = 0; n < count; n++ ) 951 { 952 error = Load_ValueRecord( &vr[n], format, base_offset, stream ); 953 if ( error ) 954 goto Fail1; 955 } 956 break; 957 958 default: 959 return ERR(HB_Err_Invalid_SubTable_Format); 960 } 961 962 return HB_Err_Ok; 963 964 Fail1: 965 for ( m = 0; m < n; m++ ) 966 Free_ValueRecord( &vr[m], format ); 967 968 FREE( vr ); 969 970 Fail2: 971 _HB_OPEN_Free_Coverage( &sp->Coverage ); 972 return error; 973 } 974 975 976 static void Free_SinglePos( HB_GPOS_SubTable* st ) 977 { 978 HB_UShort n, count, format; 979 HB_SinglePos* sp = &st->single; 980 981 HB_ValueRecord* v; 982 983 984 format = sp->ValueFormat; 985 986 switch ( sp->PosFormat ) 987 { 988 case 1: 989 Free_ValueRecord( &sp->spf.spf1.Value, format ); 990 break; 991 992 case 2: 993 if ( sp->spf.spf2.Value ) 994 { 995 count = sp->spf.spf2.ValueCount; 996 v = sp->spf.spf2.Value; 997 998 for ( n = 0; n < count; n++ ) 999 Free_ValueRecord( &v[n], format ); 1000 1001 FREE( v ); 1002 } 1003 break; 1004 default: 1005 break; 1006 } 1007 1008 _HB_OPEN_Free_Coverage( &sp->Coverage ); 1009 } 1010 1011 static HB_Error Lookup_SinglePos( GPOS_Instance* gpi, 1012 HB_GPOS_SubTable* st, 1013 HB_Buffer buffer, 1014 HB_UShort flags, 1015 HB_UShort context_length, 1016 int nesting_level ) 1017 { 1018 HB_UShort index, property; 1019 HB_Error error; 1020 HB_GPOSHeader* gpos = gpi->gpos; 1021 HB_SinglePos* sp = &st->single; 1022 1023 HB_UNUSED(nesting_level); 1024 1025 if ( context_length != 0xFFFF && context_length < 1 ) 1026 return HB_Err_Not_Covered; 1027 1028 if ( CHECK_Property( gpos->gdef, IN_CURITEM(), flags, &property ) ) 1029 return error; 1030 1031 error = _HB_OPEN_Coverage_Index( &sp->Coverage, IN_CURGLYPH(), &index ); 1032 if ( error ) 1033 return error; 1034 1035 switch ( sp->PosFormat ) 1036 { 1037 case 1: 1038 error = Get_ValueRecord( gpi, &sp->spf.spf1.Value, 1039 sp->ValueFormat, POSITION( buffer->in_pos ) ); 1040 if ( error ) 1041 return error; 1042 break; 1043 1044 case 2: 1045 if ( index >= sp->spf.spf2.ValueCount ) 1046 return ERR(HB_Err_Invalid_SubTable); 1047 error = Get_ValueRecord( gpi, &sp->spf.spf2.Value[index], 1048 sp->ValueFormat, POSITION( buffer->in_pos ) ); 1049 if ( error ) 1050 return error; 1051 break; 1052 1053 default: 1054 return ERR(HB_Err_Invalid_SubTable); 1055 } 1056 1057 (buffer->in_pos)++; 1058 1059 return HB_Err_Ok; 1060 } 1061 1062 1063 /* LookupType 2 */ 1064 1065 /* PairSet */ 1066 1067 static HB_Error Load_PairSet ( HB_PairSet* ps, 1068 HB_UShort format1, 1069 HB_UShort format2, 1070 HB_Stream stream ) 1071 { 1072 HB_Error error; 1073 1074 HB_UShort n, m, count; 1075 HB_UInt base_offset; 1076 1077 HB_PairValueRecord* pvr; 1078 1079 1080 base_offset = FILE_Pos(); 1081 1082 if ( ACCESS_Frame( 2L ) ) 1083 return error; 1084 1085 count = ps->PairValueCount = GET_UShort(); 1086 1087 FORGET_Frame(); 1088 1089 ps->PairValueRecord = NULL; 1090 1091 if ( ALLOC_ARRAY( ps->PairValueRecord, count, HB_PairValueRecord ) ) 1092 return error; 1093 1094 pvr = ps->PairValueRecord; 1095 1096 for ( n = 0; n < count; n++ ) 1097 { 1098 if ( ACCESS_Frame( 2L ) ) 1099 goto Fail; 1100 1101 pvr[n].SecondGlyph = GET_UShort(); 1102 1103 FORGET_Frame(); 1104 1105 if ( format1 ) 1106 { 1107 error = Load_ValueRecord( &pvr[n].Value1, format1, 1108 base_offset, stream ); 1109 if ( error ) 1110 goto Fail; 1111 } 1112 if ( format2 ) 1113 { 1114 error = Load_ValueRecord( &pvr[n].Value2, format2, 1115 base_offset, stream ); 1116 if ( error ) 1117 { 1118 if ( format1 ) 1119 Free_ValueRecord( &pvr[n].Value1, format1 ); 1120 goto Fail; 1121 } 1122 } 1123 } 1124 1125 return HB_Err_Ok; 1126 1127 Fail: 1128 for ( m = 0; m < n; m++ ) 1129 { 1130 if ( format1 ) 1131 Free_ValueRecord( &pvr[m].Value1, format1 ); 1132 if ( format2 ) 1133 Free_ValueRecord( &pvr[m].Value2, format2 ); 1134 } 1135 1136 FREE( pvr ); 1137 return error; 1138 } 1139 1140 1141 static void Free_PairSet( HB_PairSet* ps, 1142 HB_UShort format1, 1143 HB_UShort format2 ) 1144 { 1145 HB_UShort n, count; 1146 1147 HB_PairValueRecord* pvr; 1148 1149 1150 if ( ps->PairValueRecord ) 1151 { 1152 count = ps->PairValueCount; 1153 pvr = ps->PairValueRecord; 1154 1155 for ( n = 0; n < count; n++ ) 1156 { 1157 if ( format1 ) 1158 Free_ValueRecord( &pvr[n].Value1, format1 ); 1159 if ( format2 ) 1160 Free_ValueRecord( &pvr[n].Value2, format2 ); 1161 } 1162 1163 FREE( pvr ); 1164 } 1165 } 1166 1167 1168 /* PairPosFormat1 */ 1169 1170 static HB_Error Load_PairPos1( HB_PairPosFormat1* ppf1, 1171 HB_UShort format1, 1172 HB_UShort format2, 1173 HB_Stream stream ) 1174 { 1175 HB_Error error; 1176 1177 HB_UShort n, m, count; 1178 HB_UInt cur_offset, new_offset, base_offset; 1179 1180 HB_PairSet* ps; 1181 1182 1183 base_offset = FILE_Pos() - 8L; 1184 1185 if ( ACCESS_Frame( 2L ) ) 1186 return error; 1187 1188 count = ppf1->PairSetCount = GET_UShort(); 1189 1190 FORGET_Frame(); 1191 1192 ppf1->PairSet = NULL; 1193 1194 if ( ALLOC_ARRAY( ppf1->PairSet, count, HB_PairSet ) ) 1195 return error; 1196 1197 ps = ppf1->PairSet; 1198 1199 for ( n = 0; n < count; n++ ) 1200 { 1201 if ( ACCESS_Frame( 2L ) ) 1202 goto Fail; 1203 1204 new_offset = GET_UShort() + base_offset; 1205 1206 FORGET_Frame(); 1207 1208 cur_offset = FILE_Pos(); 1209 if ( FILE_Seek( new_offset ) || 1210 ( error = Load_PairSet( &ps[n], format1, 1211 format2, stream ) ) != HB_Err_Ok ) 1212 goto Fail; 1213 (void)FILE_Seek( cur_offset ); 1214 } 1215 1216 return HB_Err_Ok; 1217 1218 Fail: 1219 for ( m = 0; m < n; m++ ) 1220 Free_PairSet( &ps[m], format1, format2 ); 1221 1222 FREE( ps ); 1223 return error; 1224 } 1225 1226 1227 static void Free_PairPos1( HB_PairPosFormat1* ppf1, 1228 HB_UShort format1, 1229 HB_UShort format2 ) 1230 { 1231 HB_UShort n, count; 1232 1233 HB_PairSet* ps; 1234 1235 1236 if ( ppf1->PairSet ) 1237 { 1238 count = ppf1->PairSetCount; 1239 ps = ppf1->PairSet; 1240 1241 for ( n = 0; n < count; n++ ) 1242 Free_PairSet( &ps[n], format1, format2 ); 1243 1244 FREE( ps ); 1245 } 1246 } 1247 1248 1249 /* PairPosFormat2 */ 1250 1251 static HB_Error Load_PairPos2( HB_PairPosFormat2* ppf2, 1252 HB_UShort format1, 1253 HB_UShort format2, 1254 HB_Stream stream ) 1255 { 1256 HB_Error error; 1257 1258 HB_UShort m, n, k, count1, count2; 1259 HB_UInt cur_offset, new_offset1, new_offset2, base_offset; 1260 1261 HB_Class1Record* c1r; 1262 HB_Class2Record* c2r; 1263 1264 1265 base_offset = FILE_Pos() - 8L; 1266 1267 if ( ACCESS_Frame( 8L ) ) 1268 return error; 1269 1270 new_offset1 = GET_UShort() + base_offset; 1271 new_offset2 = GET_UShort() + base_offset; 1272 1273 /* `Class1Count' and `Class2Count' are the upper limits for class 1274 values, thus we read it now to make additional safety checks. */ 1275 1276 count1 = ppf2->Class1Count = GET_UShort(); 1277 count2 = ppf2->Class2Count = GET_UShort(); 1278 1279 FORGET_Frame(); 1280 1281 cur_offset = FILE_Pos(); 1282 if ( FILE_Seek( new_offset1 ) || 1283 ( error = _HB_OPEN_Load_ClassDefinition( &ppf2->ClassDef1, count1, 1284 stream ) ) != HB_Err_Ok ) 1285 return error; 1286 if ( FILE_Seek( new_offset2 ) || 1287 ( error = _HB_OPEN_Load_ClassDefinition( &ppf2->ClassDef2, count2, 1288 stream ) ) != HB_Err_Ok ) 1289 goto Fail3; 1290 (void)FILE_Seek( cur_offset ); 1291 1292 ppf2->Class1Record = NULL; 1293 1294 if ( ALLOC_ARRAY( ppf2->Class1Record, count1, HB_Class1Record ) ) 1295 goto Fail2; 1296 1297 c1r = ppf2->Class1Record; 1298 1299 for ( m = 0; m < count1; m++ ) 1300 { 1301 c1r[m].Class2Record = NULL; 1302 1303 if ( ALLOC_ARRAY( c1r[m].Class2Record, count2, HB_Class2Record ) ) 1304 goto Fail1; 1305 1306 c2r = c1r[m].Class2Record; 1307 1308 for ( n = 0; n < count2; n++ ) 1309 { 1310 if ( format1 ) 1311 { 1312 error = Load_ValueRecord( &c2r[n].Value1, format1, 1313 base_offset, stream ); 1314 if ( error ) 1315 goto Fail0; 1316 } 1317 if ( format2 ) 1318 { 1319 error = Load_ValueRecord( &c2r[n].Value2, format2, 1320 base_offset, stream ); 1321 if ( error ) 1322 { 1323 if ( format1 ) 1324 Free_ValueRecord( &c2r[n].Value1, format1 ); 1325 goto Fail0; 1326 } 1327 } 1328 } 1329 1330 continue; 1331 1332 Fail0: 1333 for ( k = 0; k < n; k++ ) 1334 { 1335 if ( format1 ) 1336 Free_ValueRecord( &c2r[k].Value1, format1 ); 1337 if ( format2 ) 1338 Free_ValueRecord( &c2r[k].Value2, format2 ); 1339 } 1340 goto Fail1; 1341 } 1342 1343 return HB_Err_Ok; 1344 1345 Fail1: 1346 for ( k = 0; k < m; k++ ) 1347 { 1348 c2r = c1r[k].Class2Record; 1349 1350 for ( n = 0; n < count2; n++ ) 1351 { 1352 if ( format1 ) 1353 Free_ValueRecord( &c2r[n].Value1, format1 ); 1354 if ( format2 ) 1355 Free_ValueRecord( &c2r[n].Value2, format2 ); 1356 } 1357 1358 FREE( c2r ); 1359 } 1360 1361 FREE( c1r ); 1362 Fail2: 1363 1364 _HB_OPEN_Free_ClassDefinition( &ppf2->ClassDef2 ); 1365 1366 Fail3: 1367 _HB_OPEN_Free_ClassDefinition( &ppf2->ClassDef1 ); 1368 return error; 1369 } 1370 1371 1372 static void Free_PairPos2( HB_PairPosFormat2* ppf2, 1373 HB_UShort format1, 1374 HB_UShort format2) 1375 { 1376 HB_UShort m, n, count1, count2; 1377 1378 HB_Class1Record* c1r; 1379 HB_Class2Record* c2r; 1380 1381 1382 if ( ppf2->Class1Record ) 1383 { 1384 c1r = ppf2->Class1Record; 1385 count1 = ppf2->Class1Count; 1386 count2 = ppf2->Class2Count; 1387 1388 for ( m = 0; m < count1; m++ ) 1389 { 1390 c2r = c1r[m].Class2Record; 1391 1392 for ( n = 0; n < count2; n++ ) 1393 { 1394 if ( format1 ) 1395 Free_ValueRecord( &c2r[n].Value1, format1 ); 1396 if ( format2 ) 1397 Free_ValueRecord( &c2r[n].Value2, format2 ); 1398 } 1399 1400 FREE( c2r ); 1401 } 1402 1403 FREE( c1r ); 1404 1405 _HB_OPEN_Free_ClassDefinition( &ppf2->ClassDef2 ); 1406 _HB_OPEN_Free_ClassDefinition( &ppf2->ClassDef1 ); 1407 } 1408 } 1409 1410 1411 static HB_Error Load_PairPos( HB_GPOS_SubTable* st, 1412 HB_Stream stream ) 1413 { 1414 HB_Error error; 1415 HB_PairPos* pp = &st->pair; 1416 1417 HB_UShort format1, format2; 1418 HB_UInt cur_offset, new_offset, base_offset; 1419 1420 1421 base_offset = FILE_Pos(); 1422 1423 if ( ACCESS_Frame( 8L ) ) 1424 return error; 1425 1426 pp->PosFormat = GET_UShort(); 1427 new_offset = GET_UShort() + base_offset; 1428 1429 format1 = pp->ValueFormat1 = GET_UShort(); 1430 format2 = pp->ValueFormat2 = GET_UShort(); 1431 1432 FORGET_Frame(); 1433 1434 cur_offset = FILE_Pos(); 1435 if ( FILE_Seek( new_offset ) || 1436 ( error = _HB_OPEN_Load_Coverage( &pp->Coverage, stream ) ) != HB_Err_Ok ) 1437 return error; 1438 (void)FILE_Seek( cur_offset ); 1439 1440 switch ( pp->PosFormat ) 1441 { 1442 case 1: 1443 error = Load_PairPos1( &pp->ppf.ppf1, format1, format2, stream ); 1444 if ( error ) 1445 goto Fail; 1446 break; 1447 1448 case 2: 1449 error = Load_PairPos2( &pp->ppf.ppf2, format1, format2, stream ); 1450 if ( error ) 1451 goto Fail; 1452 break; 1453 1454 default: 1455 return ERR(HB_Err_Invalid_SubTable_Format); 1456 } 1457 1458 return HB_Err_Ok; 1459 1460 Fail: 1461 _HB_OPEN_Free_Coverage( &pp->Coverage ); 1462 return error; 1463 } 1464 1465 1466 static void Free_PairPos( HB_GPOS_SubTable* st ) 1467 { 1468 HB_UShort format1, format2; 1469 HB_PairPos* pp = &st->pair; 1470 1471 1472 format1 = pp->ValueFormat1; 1473 format2 = pp->ValueFormat2; 1474 1475 switch ( pp->PosFormat ) 1476 { 1477 case 1: 1478 Free_PairPos1( &pp->ppf.ppf1, format1, format2 ); 1479 break; 1480 1481 case 2: 1482 Free_PairPos2( &pp->ppf.ppf2, format1, format2 ); 1483 break; 1484 1485 default: 1486 break; 1487 } 1488 1489 _HB_OPEN_Free_Coverage( &pp->Coverage ); 1490 } 1491 1492 1493 static HB_Error Lookup_PairPos1( GPOS_Instance* gpi, 1494 HB_PairPosFormat1* ppf1, 1495 HB_Buffer buffer, 1496 HB_UInt first_pos, 1497 HB_UShort index, 1498 HB_UShort format1, 1499 HB_UShort format2 ) 1500 { 1501 HB_Error error; 1502 HB_UShort numpvr, glyph2; 1503 1504 HB_PairValueRecord* pvr; 1505 1506 1507 if ( index >= ppf1->PairSetCount ) 1508 return ERR(HB_Err_Invalid_SubTable); 1509 1510 pvr = ppf1->PairSet[index].PairValueRecord; 1511 if ( !pvr ) 1512 return ERR(HB_Err_Invalid_SubTable); 1513 1514 glyph2 = IN_CURGLYPH(); 1515 1516 for ( numpvr = ppf1->PairSet[index].PairValueCount; 1517 numpvr; 1518 numpvr--, pvr++ ) 1519 { 1520 if ( glyph2 == pvr->SecondGlyph ) 1521 { 1522 error = Get_ValueRecord( gpi, &pvr->Value1, format1, 1523 POSITION( first_pos ) ); 1524 if ( error ) 1525 return error; 1526 return Get_ValueRecord( gpi, &pvr->Value2, format2, 1527 POSITION( buffer->in_pos ) ); 1528 } 1529 } 1530 1531 return HB_Err_Not_Covered; 1532 } 1533 1534 1535 static HB_Error Lookup_PairPos2( GPOS_Instance* gpi, 1536 HB_PairPosFormat2* ppf2, 1537 HB_Buffer buffer, 1538 HB_UInt first_pos, 1539 HB_UShort format1, 1540 HB_UShort format2 ) 1541 { 1542 HB_Error error; 1543 HB_UShort cl1 = 0, cl2 = 0; /* shut compiler up */ 1544 1545 HB_Class1Record* c1r; 1546 HB_Class2Record* c2r; 1547 1548 1549 error = _HB_OPEN_Get_Class( &ppf2->ClassDef1, IN_GLYPH( first_pos ), 1550 &cl1, NULL ); 1551 if ( error && error != HB_Err_Not_Covered ) 1552 return error; 1553 error = _HB_OPEN_Get_Class( &ppf2->ClassDef2, IN_CURGLYPH(), 1554 &cl2, NULL ); 1555 if ( error && error != HB_Err_Not_Covered ) 1556 return error; 1557 1558 c1r = &ppf2->Class1Record[cl1]; 1559 if ( !c1r ) 1560 return ERR(HB_Err_Invalid_SubTable); 1561 c2r = &c1r->Class2Record[cl2]; 1562 1563 error = Get_ValueRecord( gpi, &c2r->Value1, format1, POSITION( first_pos ) ); 1564 if ( error ) 1565 return error; 1566 return Get_ValueRecord( gpi, &c2r->Value2, format2, POSITION( buffer->in_pos ) ); 1567 } 1568 1569 1570 static HB_Error Lookup_PairPos( GPOS_Instance* gpi, 1571 HB_GPOS_SubTable* st, 1572 HB_Buffer buffer, 1573 HB_UShort flags, 1574 HB_UShort context_length, 1575 int nesting_level ) 1576 { 1577 HB_Error error; 1578 HB_UShort index, property; 1579 HB_UInt first_pos; 1580 HB_GPOSHeader* gpos = gpi->gpos; 1581 HB_PairPos* pp = &st->pair; 1582 1583 HB_UNUSED(nesting_level); 1584 1585 if ( buffer->in_pos >= buffer->in_length - 1 ) 1586 return HB_Err_Not_Covered; /* Not enough glyphs in stream */ 1587 1588 if ( context_length != 0xFFFF && context_length < 2 ) 1589 return HB_Err_Not_Covered; 1590 1591 if ( CHECK_Property( gpos->gdef, IN_CURITEM(), flags, &property ) ) 1592 return error; 1593 1594 error = _HB_OPEN_Coverage_Index( &pp->Coverage, IN_CURGLYPH(), &index ); 1595 if ( error ) 1596 return error; 1597 1598 /* second glyph */ 1599 1600 first_pos = buffer->in_pos; 1601 (buffer->in_pos)++; 1602 1603 while ( CHECK_Property( gpos->gdef, IN_CURITEM(), 1604 flags, &property ) ) 1605 { 1606 if ( error && error != HB_Err_Not_Covered ) 1607 return error; 1608 1609 if ( buffer->in_pos == buffer->in_length ) 1610 { 1611 buffer->in_pos = first_pos; 1612 return HB_Err_Not_Covered; 1613 } 1614 (buffer->in_pos)++; 1615 1616 } 1617 1618 switch ( pp->PosFormat ) 1619 { 1620 case 1: 1621 error = Lookup_PairPos1( gpi, &pp->ppf.ppf1, buffer, 1622 first_pos, index, 1623 pp->ValueFormat1, pp->ValueFormat2 ); 1624 break; 1625 1626 case 2: 1627 error = Lookup_PairPos2( gpi, &pp->ppf.ppf2, buffer, first_pos, 1628 pp->ValueFormat1, pp->ValueFormat2 ); 1629 break; 1630 1631 default: 1632 return ERR(HB_Err_Invalid_SubTable_Format); 1633 } 1634 1635 /* if we don't have coverage for the second glyph don't skip it for 1636 further lookups but reset in_pos back to the first_glyph and let 1637 the caller in Do_String_Lookup increment in_pos */ 1638 if ( error == HB_Err_Not_Covered ) 1639 buffer->in_pos = first_pos; 1640 1641 /* adjusting the `next' glyph */ 1642 1643 if ( pp->ValueFormat2 ) 1644 (buffer->in_pos)++; 1645 1646 return error; 1647 } 1648 1649 1650 /* LookupType 3 */ 1651 1652 /* CursivePosFormat1 */ 1653 1654 static HB_Error Load_CursivePos( HB_GPOS_SubTable* st, 1655 HB_Stream stream ) 1656 { 1657 HB_Error error; 1658 HB_CursivePos* cp = &st->cursive; 1659 1660 HB_UShort n, m, count; 1661 HB_UInt cur_offset, new_offset, base_offset; 1662 1663 HB_EntryExitRecord* eer; 1664 1665 1666 base_offset = FILE_Pos(); 1667 1668 if ( ACCESS_Frame( 4L ) ) 1669 return error; 1670 1671 cp->PosFormat = GET_UShort(); 1672 new_offset = GET_UShort() + base_offset; 1673 1674 FORGET_Frame(); 1675 1676 cur_offset = FILE_Pos(); 1677 if ( FILE_Seek( new_offset ) || 1678 ( error = _HB_OPEN_Load_Coverage( &cp->Coverage, stream ) ) != HB_Err_Ok ) 1679 return error; 1680 (void)FILE_Seek( cur_offset ); 1681 1682 if ( ACCESS_Frame( 2L ) ) 1683 goto Fail2; 1684 1685 count = cp->EntryExitCount = GET_UShort(); 1686 1687 FORGET_Frame(); 1688 1689 cp->EntryExitRecord = NULL; 1690 1691 if ( ALLOC_ARRAY( cp->EntryExitRecord, count, HB_EntryExitRecord ) ) 1692 goto Fail2; 1693 1694 eer = cp->EntryExitRecord; 1695 1696 for ( n = 0; n < count; n++ ) 1697 { 1698 HB_UInt entry_offset; 1699 1700 if ( ACCESS_Frame( 2L ) ) 1701 return error; 1702 1703 entry_offset = new_offset = GET_UShort(); 1704 1705 FORGET_Frame(); 1706 1707 if ( new_offset ) 1708 { 1709 new_offset += base_offset; 1710 1711 cur_offset = FILE_Pos(); 1712 if ( FILE_Seek( new_offset ) || 1713 ( error = Load_Anchor( &eer[n].EntryAnchor, 1714 stream ) ) != HB_Err_Ok ) 1715 goto Fail1; 1716 (void)FILE_Seek( cur_offset ); 1717 } 1718 else 1719 eer[n].EntryAnchor.PosFormat = 0; 1720 1721 if ( ACCESS_Frame( 2L ) ) 1722 return error; 1723 1724 new_offset = GET_UShort(); 1725 1726 FORGET_Frame(); 1727 1728 if ( new_offset ) 1729 { 1730 new_offset += base_offset; 1731 1732 cur_offset = FILE_Pos(); 1733 if ( FILE_Seek( new_offset ) || 1734 ( error = Load_Anchor( &eer[n].ExitAnchor, 1735 stream ) ) != HB_Err_Ok ) 1736 { 1737 if ( entry_offset ) 1738 Free_Anchor( &eer[n].EntryAnchor ); 1739 goto Fail1; 1740 } 1741 (void)FILE_Seek( cur_offset ); 1742 } 1743 else 1744 eer[n].ExitAnchor.PosFormat = 0; 1745 } 1746 1747 return HB_Err_Ok; 1748 1749 Fail1: 1750 for ( m = 0; m < n; m++ ) 1751 { 1752 Free_Anchor( &eer[m].EntryAnchor ); 1753 Free_Anchor( &eer[m].ExitAnchor ); 1754 } 1755 1756 FREE( eer ); 1757 1758 Fail2: 1759 _HB_OPEN_Free_Coverage( &cp->Coverage ); 1760 return error; 1761 } 1762 1763 1764 static void Free_CursivePos( HB_GPOS_SubTable* st ) 1765 { 1766 HB_UShort n, count; 1767 HB_CursivePos* cp = &st->cursive; 1768 1769 HB_EntryExitRecord* eer; 1770 1771 1772 if ( cp->EntryExitRecord ) 1773 { 1774 count = cp->EntryExitCount; 1775 eer = cp->EntryExitRecord; 1776 1777 for ( n = 0; n < count; n++ ) 1778 { 1779 Free_Anchor( &eer[n].EntryAnchor ); 1780 Free_Anchor( &eer[n].ExitAnchor ); 1781 } 1782 1783 FREE( eer ); 1784 } 1785 1786 _HB_OPEN_Free_Coverage( &cp->Coverage ); 1787 } 1788 1789 1790 static HB_Error Lookup_CursivePos( GPOS_Instance* gpi, 1791 HB_GPOS_SubTable* st, 1792 HB_Buffer buffer, 1793 HB_UShort flags, 1794 HB_UShort context_length, 1795 int nesting_level ) 1796 { 1797 HB_UShort index, property; 1798 HB_Error error; 1799 HB_GPOSHeader* gpos = gpi->gpos; 1800 HB_CursivePos* cp = &st->cursive; 1801 1802 HB_EntryExitRecord* eer; 1803 HB_Fixed entry_x, entry_y; 1804 HB_Fixed exit_x, exit_y; 1805 1806 HB_UNUSED(nesting_level); 1807 1808 if ( context_length != 0xFFFF && context_length < 1 ) 1809 { 1810 gpi->last = 0xFFFF; 1811 return HB_Err_Not_Covered; 1812 } 1813 1814 /* Glyphs not having the right GDEF properties will be ignored, i.e., 1815 gpi->last won't be reset (contrary to user defined properties). */ 1816 1817 if ( CHECK_Property( gpos->gdef, IN_CURITEM(), flags, &property ) ) 1818 return error; 1819 1820 /* We don't handle mark glyphs here. According to Andrei, this isn't 1821 possible, but who knows... */ 1822 1823 if ( property == HB_GDEF_MARK ) 1824 { 1825 gpi->last = 0xFFFF; 1826 return HB_Err_Not_Covered; 1827 } 1828 1829 error = _HB_OPEN_Coverage_Index( &cp->Coverage, IN_CURGLYPH(), &index ); 1830 if ( error ) 1831 { 1832 gpi->last = 0xFFFF; 1833 return error; 1834 } 1835 1836 if ( index >= cp->EntryExitCount ) 1837 return ERR(HB_Err_Invalid_SubTable); 1838 1839 eer = &cp->EntryExitRecord[index]; 1840 1841 /* Now comes the messiest part of the whole OpenType 1842 specification. At first glance, cursive connections seem easy 1843 to understand, but there are pitfalls! The reason is that 1844 the specs don't mention how to compute the advance values 1845 resp. glyph offsets. I was told it would be an omission, to 1846 be fixed in the next OpenType version... Again many thanks to 1847 Andrei Burago <andreib (at) microsoft.com> for clarifications. 1848 1849 Consider the following example: 1850 1851 | xadv1 | 1852 +---------+ 1853 | | 1854 +-----+--+ 1 | 1855 | | .| | 1856 | 0+--+------+ 1857 | 2 | 1858 | | 1859 0+--------+ 1860 | xadv2 | 1861 1862 glyph1: advance width = 12 1863 anchor point = (3,1) 1864 1865 glyph2: advance width = 11 1866 anchor point = (9,4) 1867 1868 LSB is 1 for both glyphs (so the boxes drawn above are glyph 1869 bboxes). Writing direction is R2L; `0' denotes the glyph's 1870 coordinate origin. 1871 1872 Now the surprising part: The advance width of the *left* glyph 1873 (resp. of the *bottom* glyph) will be modified, no matter 1874 whether the writing direction is L2R or R2L (resp. T2B or 1875 B2T)! This assymetry is caused by the fact that the glyph's 1876 coordinate origin is always the lower left corner for all 1877 writing directions. 1878 1879 Continuing the above example, we can compute the new 1880 (horizontal) advance width of glyph2 as 1881 1882 9 - 3 = 6 , 1883 1884 and the new vertical offset of glyph2 as 1885 1886 1 - 4 = -3 . 1887 1888 1889 Vertical writing direction is far more complicated: 1890 1891 a) Assuming that we recompute the advance height of the lower glyph: 1892 1893 -- 1894 +---------+ 1895 -- | | 1896 +-----+--+ 1 | yadv1 1897 | | .| | 1898 yadv2 | 0+--+------+ -- BSB1 -- 1899 | 2 | -- -- y_offset 1900 | | 1901 BSB2 -- 0+--------+ -- 1902 -- -- 1903 1904 glyph1: advance height = 6 1905 anchor point = (3,1) 1906 1907 glyph2: advance height = 7 1908 anchor point = (9,4) 1909 1910 TSB is 1 for both glyphs; writing direction is T2B. 1911 1912 1913 BSB1 = yadv1 - (TSB1 + ymax1) 1914 BSB2 = yadv2 - (TSB2 + ymax2) 1915 y_offset = y2 - y1 1916 1917 vertical advance width of glyph2 1918 = y_offset + BSB2 - BSB1 1919 = (y2 - y1) + (yadv2 - (TSB2 + ymax2)) - (yadv1 - (TSB1 + ymax1)) 1920 = y2 - y1 + yadv2 - TSB2 - ymax2 - (yadv1 - TSB1 - ymax1) 1921 = y2 - y1 + yadv2 - TSB2 - ymax2 - yadv1 + TSB1 + ymax1 1922 1923 1924 b) Assuming that we recompute the advance height of the upper glyph: 1925 1926 -- -- 1927 +---------+ -- TSB1 1928 -- -- | | 1929 TSB2 -- +-----+--+ 1 | yadv1 ymax1 1930 | | .| | 1931 yadv2 | 0+--+------+ -- -- 1932 ymax2 | 2 | -- y_offset 1933 | | 1934 -- 0+--------+ -- 1935 -- 1936 1937 glyph1: advance height = 6 1938 anchor point = (3,1) 1939 1940 glyph2: advance height = 7 1941 anchor point = (9,4) 1942 1943 TSB is 1 for both glyphs; writing direction is T2B. 1944 1945 y_offset = y2 - y1 1946 1947 vertical advance width of glyph2 1948 = TSB1 + ymax1 + y_offset - (TSB2 + ymax2) 1949 = TSB1 + ymax1 + y2 - y1 - TSB2 - ymax2 1950 1951 1952 Comparing a) with b) shows that b) is easier to compute. I'll wait 1953 for a reply from Andrei to see what should really be implemented... 1954 1955 Since horizontal advance widths or vertical advance heights 1956 can be used alone but not together, no ambiguity occurs. */ 1957 1958 if ( gpi->last == 0xFFFF ) 1959 goto end; 1960 1961 /* Get_Anchor() returns HB_Err_Not_Covered if there is no anchor 1962 table. */ 1963 1964 error = Get_Anchor( gpi, &eer->EntryAnchor, IN_CURGLYPH(), 1965 &entry_x, &entry_y ); 1966 if ( error == HB_Err_Not_Covered ) 1967 goto end; 1968 if ( error ) 1969 return error; 1970 1971 if ( gpi->r2l ) 1972 { 1973 POSITION( buffer->in_pos )->x_advance = entry_x - gpi->anchor_x; 1974 POSITION( buffer->in_pos )->new_advance = TRUE; 1975 } 1976 else 1977 { 1978 POSITION( gpi->last )->x_advance = gpi->anchor_x - entry_x; 1979 POSITION( gpi->last )->new_advance = TRUE; 1980 } 1981 1982 if ( flags & HB_LOOKUP_FLAG_RIGHT_TO_LEFT ) 1983 { 1984 POSITION( gpi->last )->cursive_chain = gpi->last - buffer->in_pos; 1985 POSITION( gpi->last )->y_pos = entry_y - gpi->anchor_y; 1986 } 1987 else 1988 { 1989 POSITION( buffer->in_pos )->cursive_chain = buffer->in_pos - gpi->last; 1990 POSITION( buffer->in_pos )->y_pos = gpi->anchor_y - entry_y; 1991 } 1992 1993 end: 1994 error = Get_Anchor( gpi, &eer->ExitAnchor, IN_CURGLYPH(), 1995 &exit_x, &exit_y ); 1996 if ( error == HB_Err_Not_Covered ) 1997 gpi->last = 0xFFFF; 1998 else 1999 { 2000 gpi->last = buffer->in_pos; 2001 gpi->anchor_x = exit_x; 2002 gpi->anchor_y = exit_y; 2003 } 2004 if ( error ) 2005 return error; 2006 2007 (buffer->in_pos)++; 2008 2009 return HB_Err_Ok; 2010 } 2011 2012 2013 /* LookupType 4 */ 2014 2015 /* BaseArray */ 2016 2017 static HB_Error Load_BaseArray( HB_BaseArray* ba, 2018 HB_UShort num_classes, 2019 HB_Stream stream ) 2020 { 2021 HB_Error error; 2022 2023 HB_UShort m, n, count; 2024 HB_UInt cur_offset, new_offset, base_offset; 2025 2026 HB_BaseRecord *br; 2027 HB_Anchor *ban, *bans; 2028 2029 2030 base_offset = FILE_Pos(); 2031 2032 if ( ACCESS_Frame( 2L ) ) 2033 return error; 2034 2035 count = ba->BaseCount = GET_UShort(); 2036 2037 FORGET_Frame(); 2038 2039 ba->BaseRecord = NULL; 2040 2041 if ( ALLOC_ARRAY( ba->BaseRecord, count, HB_BaseRecord ) ) 2042 return error; 2043 2044 br = ba->BaseRecord; 2045 2046 bans = NULL; 2047 2048 if ( ALLOC_ARRAY( bans, count * num_classes, HB_Anchor ) ) 2049 goto Fail; 2050 2051 for ( m = 0; m < count; m++ ) 2052 { 2053 br[m].BaseAnchor = NULL; 2054 2055 ban = br[m].BaseAnchor = bans + m * num_classes; 2056 2057 for ( n = 0; n < num_classes; n++ ) 2058 { 2059 if ( ACCESS_Frame( 2L ) ) 2060 goto Fail; 2061 2062 new_offset = GET_UShort() + base_offset; 2063 2064 FORGET_Frame(); 2065 2066 if (new_offset == base_offset) { 2067 /* XXX 2068 * Doulos SIL Regular is buggy and has zero offsets here. 2069 * Skip it 2070 */ 2071 ban[n].PosFormat = 0; 2072 continue; 2073 } 2074 2075 cur_offset = FILE_Pos(); 2076 if ( FILE_Seek( new_offset ) || 2077 ( error = Load_Anchor( &ban[n], stream ) ) != HB_Err_Ok ) 2078 goto Fail; 2079 (void)FILE_Seek( cur_offset ); 2080 } 2081 } 2082 2083 return HB_Err_Ok; 2084 2085 Fail: 2086 FREE( bans ); 2087 FREE( br ); 2088 return error; 2089 } 2090 2091 2092 static void Free_BaseArray( HB_BaseArray* ba, 2093 HB_UShort num_classes ) 2094 { 2095 HB_BaseRecord *br; 2096 HB_Anchor *bans; 2097 2098 if ( ba->BaseRecord ) 2099 { 2100 br = ba->BaseRecord; 2101 2102 if ( ba->BaseCount ) 2103 { 2104 HB_UShort i, count; 2105 count = num_classes * ba->BaseCount; 2106 bans = br[0].BaseAnchor; 2107 for (i = 0; i < count; i++) 2108 Free_Anchor (&bans[i]); 2109 FREE( bans ); 2110 } 2111 2112 FREE( br ); 2113 } 2114 } 2115 2116 2117 /* MarkBasePosFormat1 */ 2118 2119 static HB_Error Load_MarkBasePos( HB_GPOS_SubTable* st, 2120 HB_Stream stream ) 2121 { 2122 HB_Error error; 2123 HB_MarkBasePos* mbp = &st->markbase; 2124 2125 HB_UInt cur_offset, new_offset, base_offset; 2126 2127 2128 base_offset = FILE_Pos(); 2129 2130 if ( ACCESS_Frame( 4L ) ) 2131 return error; 2132 2133 mbp->PosFormat = GET_UShort(); 2134 new_offset = GET_UShort() + base_offset; 2135 2136 FORGET_Frame(); 2137 2138 if (mbp->PosFormat != 1) 2139 return ERR(HB_Err_Invalid_SubTable_Format); 2140 2141 cur_offset = FILE_Pos(); 2142 if ( FILE_Seek( new_offset ) || 2143 ( error = _HB_OPEN_Load_Coverage( &mbp->MarkCoverage, stream ) ) != HB_Err_Ok ) 2144 return error; 2145 (void)FILE_Seek( cur_offset ); 2146 2147 if ( ACCESS_Frame( 2L ) ) 2148 goto Fail3; 2149 2150 new_offset = GET_UShort() + base_offset; 2151 2152 FORGET_Frame(); 2153 2154 cur_offset = FILE_Pos(); 2155 if ( FILE_Seek( new_offset ) || 2156 ( error = _HB_OPEN_Load_Coverage( &mbp->BaseCoverage, stream ) ) != HB_Err_Ok ) 2157 goto Fail3; 2158 (void)FILE_Seek( cur_offset ); 2159 2160 if ( ACCESS_Frame( 4L ) ) 2161 goto Fail2; 2162 2163 mbp->ClassCount = GET_UShort(); 2164 new_offset = GET_UShort() + base_offset; 2165 2166 FORGET_Frame(); 2167 2168 cur_offset = FILE_Pos(); 2169 if ( FILE_Seek( new_offset ) || 2170 ( error = Load_MarkArray( &mbp->MarkArray, stream ) ) != HB_Err_Ok ) 2171 goto Fail2; 2172 (void)FILE_Seek( cur_offset ); 2173 2174 if ( ACCESS_Frame( 2L ) ) 2175 goto Fail1; 2176 2177 new_offset = GET_UShort() + base_offset; 2178 2179 FORGET_Frame(); 2180 2181 cur_offset = FILE_Pos(); 2182 if ( FILE_Seek( new_offset ) || 2183 ( error = Load_BaseArray( &mbp->BaseArray, mbp->ClassCount, 2184 stream ) ) != HB_Err_Ok ) 2185 goto Fail1; 2186 2187 return HB_Err_Ok; 2188 2189 Fail1: 2190 Free_MarkArray( &mbp->MarkArray ); 2191 2192 Fail2: 2193 _HB_OPEN_Free_Coverage( &mbp->BaseCoverage ); 2194 2195 Fail3: 2196 _HB_OPEN_Free_Coverage( &mbp->MarkCoverage ); 2197 return error; 2198 } 2199 2200 2201 static void Free_MarkBasePos( HB_GPOS_SubTable* st ) 2202 { 2203 HB_MarkBasePos* mbp = &st->markbase; 2204 2205 Free_BaseArray( &mbp->BaseArray, mbp->ClassCount ); 2206 Free_MarkArray( &mbp->MarkArray ); 2207 _HB_OPEN_Free_Coverage( &mbp->BaseCoverage ); 2208 _HB_OPEN_Free_Coverage( &mbp->MarkCoverage ); 2209 } 2210 2211 2212 static HB_Error Lookup_MarkBasePos( GPOS_Instance* gpi, 2213 HB_GPOS_SubTable* st, 2214 HB_Buffer buffer, 2215 HB_UShort flags, 2216 HB_UShort context_length, 2217 int nesting_level ) 2218 { 2219 HB_UShort i, j, mark_index, base_index, property, class; 2220 HB_Fixed x_mark_value, y_mark_value, x_base_value, y_base_value; 2221 HB_Error error; 2222 HB_GPOSHeader* gpos = gpi->gpos; 2223 HB_MarkBasePos* mbp = &st->markbase; 2224 2225 HB_MarkArray* ma; 2226 HB_BaseArray* ba; 2227 HB_BaseRecord* br; 2228 HB_Anchor* mark_anchor; 2229 HB_Anchor* base_anchor; 2230 2231 HB_Position o; 2232 2233 HB_UNUSED(nesting_level); 2234 2235 if ( context_length != 0xFFFF && context_length < 1 ) 2236 return HB_Err_Not_Covered; 2237 2238 if ( flags & HB_LOOKUP_FLAG_IGNORE_BASE_GLYPHS ) 2239 return HB_Err_Not_Covered; 2240 2241 if ( CHECK_Property( gpos->gdef, IN_CURITEM(), 2242 flags, &property ) ) 2243 return error; 2244 2245 error = _HB_OPEN_Coverage_Index( &mbp->MarkCoverage, IN_CURGLYPH(), 2246 &mark_index ); 2247 if ( error ) 2248 return error; 2249 2250 /* now we search backwards for a non-mark glyph */ 2251 2252 i = 1; 2253 j = buffer->in_pos - 1; 2254 2255 while ( i <= buffer->in_pos ) 2256 { 2257 error = HB_GDEF_Get_Glyph_Property( gpos->gdef, IN_GLYPH( j ), 2258 &property ); 2259 if ( error ) 2260 return error; 2261 2262 if ( !( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) ) 2263 break; 2264 2265 i++; 2266 j--; 2267 } 2268 2269 /* The following assertion is too strong -- at least for mangal.ttf. */ 2270 #if 0 2271 if ( property != HB_GDEF_BASE_GLYPH ) 2272 return HB_Err_Not_Covered; 2273 #endif 2274 2275 if ( i > buffer->in_pos ) 2276 return HB_Err_Not_Covered; 2277 2278 error = _HB_OPEN_Coverage_Index( &mbp->BaseCoverage, IN_GLYPH( j ), 2279 &base_index ); 2280 if ( error ) 2281 return error; 2282 2283 ma = &mbp->MarkArray; 2284 2285 if ( mark_index >= ma->MarkCount ) 2286 return ERR(HB_Err_Invalid_SubTable); 2287 2288 class = ma->MarkRecord[mark_index].Class; 2289 mark_anchor = &ma->MarkRecord[mark_index].MarkAnchor; 2290 2291 if ( class >= mbp->ClassCount ) 2292 return ERR(HB_Err_Invalid_SubTable); 2293 2294 ba = &mbp->BaseArray; 2295 2296 if ( base_index >= ba->BaseCount ) 2297 return ERR(HB_Err_Invalid_SubTable); 2298 2299 br = &ba->BaseRecord[base_index]; 2300 base_anchor = &br->BaseAnchor[class]; 2301 2302 error = Get_Anchor( gpi, mark_anchor, IN_CURGLYPH(), 2303 &x_mark_value, &y_mark_value ); 2304 if ( error ) 2305 return error; 2306 2307 error = Get_Anchor( gpi, base_anchor, IN_GLYPH( j ), 2308 &x_base_value, &y_base_value ); 2309 if ( error ) 2310 return error; 2311 2312 /* anchor points are not cumulative */ 2313 2314 o = POSITION( buffer->in_pos ); 2315 2316 o->x_pos = x_base_value - x_mark_value; 2317 o->y_pos = y_base_value - y_mark_value; 2318 o->x_advance = 0; 2319 o->y_advance = 0; 2320 o->back = i; 2321 2322 (buffer->in_pos)++; 2323 2324 return HB_Err_Ok; 2325 } 2326 2327 2328 /* LookupType 5 */ 2329 2330 /* LigatureAttach */ 2331 2332 static HB_Error Load_LigatureAttach( HB_LigatureAttach* lat, 2333 HB_UShort num_classes, 2334 HB_Stream stream ) 2335 { 2336 HB_Error error; 2337 2338 HB_UShort m, n, k, count; 2339 HB_UInt cur_offset, new_offset, base_offset; 2340 2341 HB_ComponentRecord* cr; 2342 HB_Anchor* lan; 2343 2344 2345 base_offset = FILE_Pos(); 2346 2347 if ( ACCESS_Frame( 2L ) ) 2348 return error; 2349 2350 count = lat->ComponentCount = GET_UShort(); 2351 2352 FORGET_Frame(); 2353 2354 lat->ComponentRecord = NULL; 2355 2356 if ( ALLOC_ARRAY( lat->ComponentRecord, count, HB_ComponentRecord ) ) 2357 return error; 2358 2359 cr = lat->ComponentRecord; 2360 2361 for ( m = 0; m < count; m++ ) 2362 { 2363 cr[m].LigatureAnchor = NULL; 2364 2365 if ( ALLOC_ARRAY( cr[m].LigatureAnchor, num_classes, HB_Anchor ) ) 2366 goto Fail; 2367 2368 lan = cr[m].LigatureAnchor; 2369 2370 for ( n = 0; n < num_classes; n++ ) 2371 { 2372 if ( ACCESS_Frame( 2L ) ) 2373 goto Fail0; 2374 2375 new_offset = GET_UShort(); 2376 2377 FORGET_Frame(); 2378 2379 if ( new_offset ) 2380 { 2381 new_offset += base_offset; 2382 2383 cur_offset = FILE_Pos(); 2384 if ( FILE_Seek( new_offset ) || 2385 ( error = Load_Anchor( &lan[n], stream ) ) != HB_Err_Ok ) 2386 goto Fail0; 2387 (void)FILE_Seek( cur_offset ); 2388 } 2389 else 2390 lan[n].PosFormat = 0; 2391 } 2392 2393 continue; 2394 Fail0: 2395 for ( k = 0; k < n; k++ ) 2396 Free_Anchor( &lan[k] ); 2397 goto Fail; 2398 } 2399 2400 return HB_Err_Ok; 2401 2402 Fail: 2403 for ( k = 0; k < m; k++ ) 2404 { 2405 lan = cr[k].LigatureAnchor; 2406 2407 for ( n = 0; n < num_classes; n++ ) 2408 Free_Anchor( &lan[n] ); 2409 2410 FREE( lan ); 2411 } 2412 2413 FREE( cr ); 2414 return error; 2415 } 2416 2417 2418 static void Free_LigatureAttach( HB_LigatureAttach* lat, 2419 HB_UShort num_classes ) 2420 { 2421 HB_UShort m, n, count; 2422 2423 HB_ComponentRecord* cr; 2424 HB_Anchor* lan; 2425 2426 2427 if ( lat->ComponentRecord ) 2428 { 2429 count = lat->ComponentCount; 2430 cr = lat->ComponentRecord; 2431 2432 for ( m = 0; m < count; m++ ) 2433 { 2434 lan = cr[m].LigatureAnchor; 2435 2436 for ( n = 0; n < num_classes; n++ ) 2437 Free_Anchor( &lan[n] ); 2438 2439 FREE( lan ); 2440 } 2441 2442 FREE( cr ); 2443 } 2444 } 2445 2446 2447 /* LigatureArray */ 2448 2449 static HB_Error Load_LigatureArray( HB_LigatureArray* la, 2450 HB_UShort num_classes, 2451 HB_Stream stream ) 2452 { 2453 HB_Error error; 2454 2455 HB_UShort n, m, count; 2456 HB_UInt cur_offset, new_offset, base_offset; 2457 2458 HB_LigatureAttach* lat; 2459 2460 2461 base_offset = FILE_Pos(); 2462 2463 if ( ACCESS_Frame( 2L ) ) 2464 return error; 2465 2466 count = la->LigatureCount = GET_UShort(); 2467 2468 FORGET_Frame(); 2469 2470 la->LigatureAttach = NULL; 2471 2472 if ( ALLOC_ARRAY( la->LigatureAttach, count, HB_LigatureAttach ) ) 2473 return error; 2474 2475 lat = la->LigatureAttach; 2476 2477 for ( n = 0; n < count; n++ ) 2478 { 2479 if ( ACCESS_Frame( 2L ) ) 2480 goto Fail; 2481 2482 new_offset = GET_UShort() + base_offset; 2483 2484 FORGET_Frame(); 2485 2486 cur_offset = FILE_Pos(); 2487 if ( FILE_Seek( new_offset ) || 2488 ( error = Load_LigatureAttach( &lat[n], num_classes, 2489 stream ) ) != HB_Err_Ok ) 2490 goto Fail; 2491 (void)FILE_Seek( cur_offset ); 2492 } 2493 2494 return HB_Err_Ok; 2495 2496 Fail: 2497 for ( m = 0; m < n; m++ ) 2498 Free_LigatureAttach( &lat[m], num_classes ); 2499 2500 FREE( lat ); 2501 return error; 2502 } 2503 2504 2505 static void Free_LigatureArray( HB_LigatureArray* la, 2506 HB_UShort num_classes ) 2507 { 2508 HB_UShort n, count; 2509 2510 HB_LigatureAttach* lat; 2511 2512 2513 if ( la->LigatureAttach ) 2514 { 2515 count = la->LigatureCount; 2516 lat = la->LigatureAttach; 2517 2518 for ( n = 0; n < count; n++ ) 2519 Free_LigatureAttach( &lat[n], num_classes ); 2520 2521 FREE( lat ); 2522 } 2523 } 2524 2525 2526 /* MarkLigPosFormat1 */ 2527 2528 static HB_Error Load_MarkLigPos( HB_GPOS_SubTable* st, 2529 HB_Stream stream ) 2530 { 2531 HB_Error error; 2532 HB_MarkLigPos* mlp = &st->marklig; 2533 2534 HB_UInt cur_offset, new_offset, base_offset; 2535 2536 2537 base_offset = FILE_Pos(); 2538 2539 if ( ACCESS_Frame( 4L ) ) 2540 return error; 2541 2542 mlp->PosFormat = GET_UShort(); 2543 new_offset = GET_UShort() + base_offset; 2544 2545 FORGET_Frame(); 2546 2547 cur_offset = FILE_Pos(); 2548 if ( FILE_Seek( new_offset ) || 2549 ( error = _HB_OPEN_Load_Coverage( &mlp->MarkCoverage, stream ) ) != HB_Err_Ok ) 2550 return error; 2551 (void)FILE_Seek( cur_offset ); 2552 2553 if ( ACCESS_Frame( 2L ) ) 2554 goto Fail3; 2555 2556 new_offset = GET_UShort() + base_offset; 2557 2558 FORGET_Frame(); 2559 2560 cur_offset = FILE_Pos(); 2561 if ( FILE_Seek( new_offset ) || 2562 ( error = _HB_OPEN_Load_Coverage( &mlp->LigatureCoverage, 2563 stream ) ) != HB_Err_Ok ) 2564 goto Fail3; 2565 (void)FILE_Seek( cur_offset ); 2566 2567 if ( ACCESS_Frame( 4L ) ) 2568 goto Fail2; 2569 2570 mlp->ClassCount = GET_UShort(); 2571 new_offset = GET_UShort() + base_offset; 2572 2573 FORGET_Frame(); 2574 2575 cur_offset = FILE_Pos(); 2576 if ( FILE_Seek( new_offset ) || 2577 ( error = Load_MarkArray( &mlp->MarkArray, stream ) ) != HB_Err_Ok ) 2578 goto Fail2; 2579 (void)FILE_Seek( cur_offset ); 2580 2581 if ( ACCESS_Frame( 2L ) ) 2582 goto Fail1; 2583 2584 new_offset = GET_UShort() + base_offset; 2585 2586 FORGET_Frame(); 2587 2588 cur_offset = FILE_Pos(); 2589 if ( FILE_Seek( new_offset ) || 2590 ( error = Load_LigatureArray( &mlp->LigatureArray, mlp->ClassCount, 2591 stream ) ) != HB_Err_Ok ) 2592 goto Fail1; 2593 2594 return HB_Err_Ok; 2595 2596 Fail1: 2597 Free_MarkArray( &mlp->MarkArray ); 2598 2599 Fail2: 2600 _HB_OPEN_Free_Coverage( &mlp->LigatureCoverage ); 2601 2602 Fail3: 2603 _HB_OPEN_Free_Coverage( &mlp->MarkCoverage ); 2604 return error; 2605 } 2606 2607 2608 static void Free_MarkLigPos( HB_GPOS_SubTable* st) 2609 { 2610 HB_MarkLigPos* mlp = &st->marklig; 2611 2612 Free_LigatureArray( &mlp->LigatureArray, mlp->ClassCount ); 2613 Free_MarkArray( &mlp->MarkArray ); 2614 _HB_OPEN_Free_Coverage( &mlp->LigatureCoverage ); 2615 _HB_OPEN_Free_Coverage( &mlp->MarkCoverage ); 2616 } 2617 2618 2619 static HB_Error Lookup_MarkLigPos( GPOS_Instance* gpi, 2620 HB_GPOS_SubTable* st, 2621 HB_Buffer buffer, 2622 HB_UShort flags, 2623 HB_UShort context_length, 2624 int nesting_level ) 2625 { 2626 HB_UShort i, j, mark_index, lig_index, property, class; 2627 HB_UShort mark_glyph; 2628 HB_Fixed x_mark_value, y_mark_value, x_lig_value, y_lig_value; 2629 HB_Error error; 2630 HB_GPOSHeader* gpos = gpi->gpos; 2631 HB_MarkLigPos* mlp = &st->marklig; 2632 2633 HB_MarkArray* ma; 2634 HB_LigatureArray* la; 2635 HB_LigatureAttach* lat; 2636 HB_ComponentRecord* cr; 2637 HB_UShort comp_index; 2638 HB_Anchor* mark_anchor; 2639 HB_Anchor* lig_anchor; 2640 2641 HB_Position o; 2642 2643 HB_UNUSED(nesting_level); 2644 2645 if ( context_length != 0xFFFF && context_length < 1 ) 2646 return HB_Err_Not_Covered; 2647 2648 if ( flags & HB_LOOKUP_FLAG_IGNORE_LIGATURES ) 2649 return HB_Err_Not_Covered; 2650 2651 mark_glyph = IN_CURGLYPH(); 2652 2653 if ( CHECK_Property( gpos->gdef, IN_CURITEM(), flags, &property ) ) 2654 return error; 2655 2656 error = _HB_OPEN_Coverage_Index( &mlp->MarkCoverage, mark_glyph, &mark_index ); 2657 if ( error ) 2658 return error; 2659 2660 /* now we search backwards for a non-mark glyph */ 2661 2662 i = 1; 2663 j = buffer->in_pos - 1; 2664 2665 while ( i <= buffer->in_pos ) 2666 { 2667 error = HB_GDEF_Get_Glyph_Property( gpos->gdef, IN_GLYPH( j ), 2668 &property ); 2669 if ( error ) 2670 return error; 2671 2672 if ( !( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) ) 2673 break; 2674 2675 i++; 2676 j--; 2677 } 2678 2679 /* Similar to Lookup_MarkBasePos(), I suspect that this assertion is 2680 too strong, thus it is commented out. */ 2681 #if 0 2682 if ( property != HB_GDEF_LIGATURE ) 2683 return HB_Err_Not_Covered; 2684 #endif 2685 2686 if ( i > buffer->in_pos ) 2687 return HB_Err_Not_Covered; 2688 2689 error = _HB_OPEN_Coverage_Index( &mlp->LigatureCoverage, IN_GLYPH( j ), 2690 &lig_index ); 2691 if ( error ) 2692 return error; 2693 2694 ma = &mlp->MarkArray; 2695 2696 if ( mark_index >= ma->MarkCount ) 2697 return ERR(HB_Err_Invalid_SubTable); 2698 2699 class = ma->MarkRecord[mark_index].Class; 2700 mark_anchor = &ma->MarkRecord[mark_index].MarkAnchor; 2701 2702 if ( class >= mlp->ClassCount ) 2703 return ERR(HB_Err_Invalid_SubTable); 2704 2705 la = &mlp->LigatureArray; 2706 2707 if ( lig_index >= la->LigatureCount ) 2708 return ERR(HB_Err_Invalid_SubTable); 2709 2710 lat = &la->LigatureAttach[lig_index]; 2711 2712 /* We must now check whether the ligature ID of the current mark glyph 2713 is identical to the ligature ID of the found ligature. If yes, we 2714 can directly use the component index. If not, we attach the mark 2715 glyph to the last component of the ligature. */ 2716 2717 if ( IN_LIGID( j ) == IN_LIGID( buffer->in_pos) ) 2718 { 2719 comp_index = IN_COMPONENT( buffer->in_pos ); 2720 if ( comp_index >= lat->ComponentCount ) 2721 return HB_Err_Not_Covered; 2722 } 2723 else 2724 comp_index = lat->ComponentCount - 1; 2725 2726 cr = &lat->ComponentRecord[comp_index]; 2727 lig_anchor = &cr->LigatureAnchor[class]; 2728 2729 error = Get_Anchor( gpi, mark_anchor, IN_CURGLYPH(), 2730 &x_mark_value, &y_mark_value ); 2731 if ( error ) 2732 return error; 2733 error = Get_Anchor( gpi, lig_anchor, IN_GLYPH( j ), 2734 &x_lig_value, &y_lig_value ); 2735 if ( error ) 2736 return error; 2737 2738 /* anchor points are not cumulative */ 2739 2740 o = POSITION( buffer->in_pos ); 2741 2742 o->x_pos = x_lig_value - x_mark_value; 2743 o->y_pos = y_lig_value - y_mark_value; 2744 o->x_advance = 0; 2745 o->y_advance = 0; 2746 o->back = i; 2747 2748 (buffer->in_pos)++; 2749 2750 return HB_Err_Ok; 2751 } 2752 2753 2754 /* LookupType 6 */ 2755 2756 /* Mark2Array */ 2757 2758 static HB_Error Load_Mark2Array( HB_Mark2Array* m2a, 2759 HB_UShort num_classes, 2760 HB_Stream stream ) 2761 { 2762 HB_Error error; 2763 2764 HB_UShort m, n, count; 2765 HB_UInt cur_offset, new_offset, base_offset; 2766 2767 HB_Mark2Record *m2r; 2768 HB_Anchor *m2an, *m2ans; 2769 2770 2771 base_offset = FILE_Pos(); 2772 2773 if ( ACCESS_Frame( 2L ) ) 2774 return error; 2775 2776 count = m2a->Mark2Count = GET_UShort(); 2777 2778 FORGET_Frame(); 2779 2780 m2a->Mark2Record = NULL; 2781 2782 if ( ALLOC_ARRAY( m2a->Mark2Record, count, HB_Mark2Record ) ) 2783 return error; 2784 2785 m2r = m2a->Mark2Record; 2786 2787 m2ans = NULL; 2788 2789 if ( ALLOC_ARRAY( m2ans, count * num_classes, HB_Anchor ) ) 2790 goto Fail; 2791 2792 for ( m = 0; m < count; m++ ) 2793 { 2794 m2an = m2r[m].Mark2Anchor = m2ans + m * num_classes; 2795 2796 for ( n = 0; n < num_classes; n++ ) 2797 { 2798 if ( ACCESS_Frame( 2L ) ) 2799 goto Fail; 2800 2801 new_offset = GET_UShort() + base_offset; 2802 2803 FORGET_Frame(); 2804 2805 if (new_offset == base_offset) { 2806 /* Anchor table not provided. Skip loading. 2807 * Some versions of FreeSans hit this. */ 2808 m2an[n].PosFormat = 0; 2809 continue; 2810 } 2811 2812 cur_offset = FILE_Pos(); 2813 if ( FILE_Seek( new_offset ) || 2814 ( error = Load_Anchor( &m2an[n], stream ) ) != HB_Err_Ok ) 2815 goto Fail; 2816 (void)FILE_Seek( cur_offset ); 2817 } 2818 } 2819 2820 return HB_Err_Ok; 2821 2822 Fail: 2823 FREE( m2ans ); 2824 FREE( m2r ); 2825 return error; 2826 } 2827 2828 2829 static void Free_Mark2Array( HB_Mark2Array* m2a, 2830 HB_UShort num_classes ) 2831 { 2832 HB_Mark2Record *m2r; 2833 HB_Anchor *m2ans; 2834 2835 HB_UNUSED(num_classes); 2836 2837 if ( m2a->Mark2Record ) 2838 { 2839 m2r = m2a->Mark2Record; 2840 2841 if ( m2a->Mark2Count ) 2842 { 2843 m2ans = m2r[0].Mark2Anchor; 2844 FREE( m2ans ); 2845 } 2846 2847 FREE( m2r ); 2848 } 2849 } 2850 2851 2852 /* MarkMarkPosFormat1 */ 2853 2854 static HB_Error Load_MarkMarkPos( HB_GPOS_SubTable* st, 2855 HB_Stream stream ) 2856 { 2857 HB_Error error; 2858 HB_MarkMarkPos* mmp = &st->markmark; 2859 2860 HB_UInt cur_offset, new_offset, base_offset; 2861 2862 2863 base_offset = FILE_Pos(); 2864 2865 if ( ACCESS_Frame( 4L ) ) 2866 return error; 2867 2868 mmp->PosFormat = GET_UShort(); 2869 new_offset = GET_UShort() + base_offset; 2870 2871 FORGET_Frame(); 2872 2873 cur_offset = FILE_Pos(); 2874 if ( FILE_Seek( new_offset ) || 2875 ( error = _HB_OPEN_Load_Coverage( &mmp->Mark1Coverage, 2876 stream ) ) != HB_Err_Ok ) 2877 return error; 2878 (void)FILE_Seek( cur_offset ); 2879 2880 if ( ACCESS_Frame( 2L ) ) 2881 goto Fail3; 2882 2883 new_offset = GET_UShort() + base_offset; 2884 2885 FORGET_Frame(); 2886 2887 cur_offset = FILE_Pos(); 2888 if ( FILE_Seek( new_offset ) || 2889 ( error = _HB_OPEN_Load_Coverage( &mmp->Mark2Coverage, 2890 stream ) ) != HB_Err_Ok ) 2891 goto Fail3; 2892 (void)FILE_Seek( cur_offset ); 2893 2894 if ( ACCESS_Frame( 4L ) ) 2895 goto Fail2; 2896 2897 mmp->ClassCount = GET_UShort(); 2898 new_offset = GET_UShort() + base_offset; 2899 2900 FORGET_Frame(); 2901 2902 cur_offset = FILE_Pos(); 2903 if ( FILE_Seek( new_offset ) || 2904 ( error = Load_MarkArray( &mmp->Mark1Array, stream ) ) != HB_Err_Ok ) 2905 goto Fail2; 2906 (void)FILE_Seek( cur_offset ); 2907 2908 if ( ACCESS_Frame( 2L ) ) 2909 goto Fail1; 2910 2911 new_offset = GET_UShort() + base_offset; 2912 2913 FORGET_Frame(); 2914 2915 cur_offset = FILE_Pos(); 2916 if ( FILE_Seek( new_offset ) || 2917 ( error = Load_Mark2Array( &mmp->Mark2Array, mmp->ClassCount, 2918 stream ) ) != HB_Err_Ok ) 2919 goto Fail1; 2920 2921 return HB_Err_Ok; 2922 2923 Fail1: 2924 Free_MarkArray( &mmp->Mark1Array ); 2925 2926 Fail2: 2927 _HB_OPEN_Free_Coverage( &mmp->Mark2Coverage ); 2928 2929 Fail3: 2930 _HB_OPEN_Free_Coverage( &mmp->Mark1Coverage ); 2931 return error; 2932 } 2933 2934 2935 static void Free_MarkMarkPos( HB_GPOS_SubTable* st) 2936 { 2937 HB_MarkMarkPos* mmp = &st->markmark; 2938 2939 Free_Mark2Array( &mmp->Mark2Array, mmp->ClassCount ); 2940 Free_MarkArray( &mmp->Mark1Array ); 2941 _HB_OPEN_Free_Coverage( &mmp->Mark2Coverage ); 2942 _HB_OPEN_Free_Coverage( &mmp->Mark1Coverage ); 2943 } 2944 2945 2946 static HB_Error Lookup_MarkMarkPos( GPOS_Instance* gpi, 2947 HB_GPOS_SubTable* st, 2948 HB_Buffer buffer, 2949 HB_UShort flags, 2950 HB_UShort context_length, 2951 int nesting_level ) 2952 { 2953 HB_UShort i, j, mark1_index, mark2_index, property, class; 2954 HB_Fixed x_mark1_value, y_mark1_value, 2955 x_mark2_value, y_mark2_value; 2956 HB_Error error; 2957 HB_GPOSHeader* gpos = gpi->gpos; 2958 HB_MarkMarkPos* mmp = &st->markmark; 2959 2960 HB_MarkArray* ma1; 2961 HB_Mark2Array* ma2; 2962 HB_Mark2Record* m2r; 2963 HB_Anchor* mark1_anchor; 2964 HB_Anchor* mark2_anchor; 2965 2966 HB_Position o; 2967 2968 HB_UNUSED(nesting_level); 2969 2970 if ( context_length != 0xFFFF && context_length < 1 ) 2971 return HB_Err_Not_Covered; 2972 2973 if ( flags & HB_LOOKUP_FLAG_IGNORE_MARKS ) 2974 return HB_Err_Not_Covered; 2975 2976 if ( CHECK_Property( gpos->gdef, IN_CURITEM(), 2977 flags, &property ) ) 2978 return error; 2979 2980 error = _HB_OPEN_Coverage_Index( &mmp->Mark1Coverage, IN_CURGLYPH(), 2981 &mark1_index ); 2982 if ( error ) 2983 return error; 2984 2985 /* now we search backwards for a suitable mark glyph until a non-mark 2986 glyph */ 2987 2988 if ( buffer->in_pos == 0 ) 2989 return HB_Err_Not_Covered; 2990 2991 i = 1; 2992 j = buffer->in_pos - 1; 2993 while ( i <= buffer->in_pos ) 2994 { 2995 error = HB_GDEF_Get_Glyph_Property( gpos->gdef, IN_GLYPH( j ), 2996 &property ); 2997 if ( error ) 2998 return error; 2999 3000 if ( !( property == HB_GDEF_MARK || property & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) ) 3001 return HB_Err_Not_Covered; 3002 3003 if ( flags & HB_LOOKUP_FLAG_IGNORE_SPECIAL_MARKS ) 3004 { 3005 if ( property == (flags & 0xFF00) ) 3006 break; 3007 } 3008 else 3009 break; 3010 3011 i++; 3012 j--; 3013 } 3014 3015 error = _HB_OPEN_Coverage_Index( &mmp->Mark2Coverage, IN_GLYPH( j ), 3016 &mark2_index ); 3017 if ( error ) 3018 return error; 3019 3020 ma1 = &mmp->Mark1Array; 3021 3022 if ( mark1_index >= ma1->MarkCount ) 3023 return ERR(HB_Err_Invalid_SubTable); 3024 3025 class = ma1->MarkRecord[mark1_index].Class; 3026 mark1_anchor = &ma1->MarkRecord[mark1_index].MarkAnchor; 3027 3028 if ( class >= mmp->ClassCount ) 3029 return ERR(HB_Err_Invalid_SubTable); 3030 3031 ma2 = &mmp->Mark2Array; 3032 3033 if ( mark2_index >= ma2->Mark2Count ) 3034 return ERR(HB_Err_Invalid_SubTable); 3035 3036 m2r = &ma2->Mark2Record[mark2_index]; 3037 mark2_anchor = &m2r->Mark2Anchor[class]; 3038 3039 error = Get_Anchor( gpi, mark1_anchor, IN_CURGLYPH(), 3040 &x_mark1_value, &y_mark1_value ); 3041 if ( error ) 3042 return error; 3043 error = Get_Anchor( gpi, mark2_anchor, IN_GLYPH( j ), 3044 &x_mark2_value, &y_mark2_value ); 3045 if ( error ) 3046 return error; 3047 3048 /* anchor points are not cumulative */ 3049 3050 o = POSITION( buffer->in_pos ); 3051 3052 o->x_pos = x_mark2_value - x_mark1_value; 3053 o->y_pos = y_mark2_value - y_mark1_value; 3054 o->x_advance = 0; 3055 o->y_advance = 0; 3056 o->back = 1; 3057 3058 (buffer->in_pos)++; 3059 3060 return HB_Err_Ok; 3061 } 3062 3063 3064 /* Do the actual positioning for a context positioning (either format 3065 7 or 8). This is only called after we've determined that the stream 3066 matches the subrule. */ 3067 3068 static HB_Error Do_ContextPos( GPOS_Instance* gpi, 3069 HB_UShort GlyphCount, 3070 HB_UShort PosCount, 3071 HB_PosLookupRecord* pos, 3072 HB_Buffer buffer, 3073 int nesting_level ) 3074 { 3075 HB_Error error; 3076 HB_UInt i, old_pos; 3077 3078 3079 i = 0; 3080 3081 while ( i < GlyphCount ) 3082 { 3083 if ( PosCount && i == pos->SequenceIndex ) 3084 { 3085 old_pos = buffer->in_pos; 3086 3087 /* Do a positioning */ 3088 3089 error = GPOS_Do_Glyph_Lookup( gpi, pos->LookupListIndex, buffer, 3090 GlyphCount, nesting_level ); 3091 3092 if ( error ) 3093 return error; 3094 3095 pos++; 3096 PosCount--; 3097 i += buffer->in_pos - old_pos; 3098 } 3099 else 3100 { 3101 i++; 3102 (buffer->in_pos)++; 3103 } 3104 } 3105 3106 return HB_Err_Ok; 3107 } 3108 3109 3110 /* LookupType 7 */ 3111 3112 /* PosRule */ 3113 3114 static HB_Error Load_PosRule( HB_PosRule* pr, 3115 HB_Stream stream ) 3116 { 3117 HB_Error error; 3118 3119 HB_UShort n, count; 3120 HB_UShort* i; 3121 3122 HB_PosLookupRecord* plr; 3123 3124 3125 if ( ACCESS_Frame( 4L ) ) 3126 return error; 3127 3128 pr->GlyphCount = GET_UShort(); 3129 pr->PosCount = GET_UShort(); 3130 3131 FORGET_Frame(); 3132 3133 pr->Input = NULL; 3134 3135 count = pr->GlyphCount - 1; /* only GlyphCount - 1 elements */ 3136 3137 if ( ALLOC_ARRAY( pr->Input, count, HB_UShort ) ) 3138 return error; 3139 3140 i = pr->Input; 3141 3142 if ( ACCESS_Frame( count * 2L ) ) 3143 goto Fail2; 3144 3145 for ( n = 0; n < count; n++ ) 3146 i[n] = GET_UShort(); 3147 3148 FORGET_Frame(); 3149 3150 pr->PosLookupRecord = NULL; 3151 3152 count = pr->PosCount; 3153 3154 if ( ALLOC_ARRAY( pr->PosLookupRecord, count, HB_PosLookupRecord ) ) 3155 goto Fail2; 3156 3157 plr = pr->PosLookupRecord; 3158 3159 if ( ACCESS_Frame( count * 4L ) ) 3160 goto Fail1; 3161 3162 for ( n = 0; n < count; n++ ) 3163 { 3164 plr[n].SequenceIndex = GET_UShort(); 3165 plr[n].LookupListIndex = GET_UShort(); 3166 } 3167 3168 FORGET_Frame(); 3169 3170 return HB_Err_Ok; 3171 3172 Fail1: 3173 FREE( plr ); 3174 3175 Fail2: 3176 FREE( i ); 3177 return error; 3178 } 3179 3180 3181 static void Free_PosRule( HB_PosRule* pr ) 3182 { 3183 FREE( pr->PosLookupRecord ); 3184 FREE( pr->Input ); 3185 } 3186 3187 3188 /* PosRuleSet */ 3189 3190 static HB_Error Load_PosRuleSet( HB_PosRuleSet* prs, 3191 HB_Stream stream ) 3192 { 3193 HB_Error error; 3194 3195 HB_UShort n, m, count; 3196 HB_UInt cur_offset, new_offset, base_offset; 3197 3198 HB_PosRule* pr; 3199 3200 3201 base_offset = FILE_Pos(); 3202 3203 if ( ACCESS_Frame( 2L ) ) 3204 return error; 3205 3206 count = prs->PosRuleCount = GET_UShort(); 3207 3208 FORGET_Frame(); 3209 3210 prs->PosRule = NULL; 3211 3212 if ( ALLOC_ARRAY( prs->PosRule, count, HB_PosRule ) ) 3213 return error; 3214 3215 pr = prs->PosRule; 3216 3217 for ( n = 0; n < count; n++ ) 3218 { 3219 if ( ACCESS_Frame( 2L ) ) 3220 goto Fail; 3221 3222 new_offset = GET_UShort() + base_offset; 3223 3224 FORGET_Frame(); 3225 3226 cur_offset = FILE_Pos(); 3227 if ( FILE_Seek( new_offset ) || 3228 ( error = Load_PosRule( &pr[n], stream ) ) != HB_Err_Ok ) 3229 goto Fail; 3230 (void)FILE_Seek( cur_offset ); 3231 } 3232 3233 return HB_Err_Ok; 3234 3235 Fail: 3236 for ( m = 0; m < n; m++ ) 3237 Free_PosRule( &pr[m] ); 3238 3239 FREE( pr ); 3240 return error; 3241 } 3242 3243 3244 static void Free_PosRuleSet( HB_PosRuleSet* prs ) 3245 { 3246 HB_UShort n, count; 3247 3248 HB_PosRule* pr; 3249 3250 3251 if ( prs->PosRule ) 3252 { 3253 count = prs->PosRuleCount; 3254 pr = prs->PosRule; 3255 3256 for ( n = 0; n < count; n++ ) 3257 Free_PosRule( &pr[n] ); 3258 3259 FREE( pr ); 3260 } 3261 } 3262 3263 3264 /* ContextPosFormat1 */ 3265 3266 static HB_Error Load_ContextPos1( HB_ContextPosFormat1* cpf1, 3267 HB_Stream stream ) 3268 { 3269 HB_Error error; 3270 3271 HB_UShort n, m, count; 3272 HB_UInt cur_offset, new_offset, base_offset; 3273 3274 HB_PosRuleSet* prs; 3275 3276 3277 base_offset = FILE_Pos() - 2L; 3278 3279 if ( ACCESS_Frame( 2L ) ) 3280 return error; 3281 3282 new_offset = GET_UShort() + base_offset; 3283 3284 FORGET_Frame(); 3285 3286 cur_offset = FILE_Pos(); 3287 if ( FILE_Seek( new_offset ) || 3288 ( error = _HB_OPEN_Load_Coverage( &cpf1->Coverage, stream ) ) != HB_Err_Ok ) 3289 return error; 3290 (void)FILE_Seek( cur_offset ); 3291 3292 if ( ACCESS_Frame( 2L ) ) 3293 goto Fail2; 3294 3295 count = cpf1->PosRuleSetCount = GET_UShort(); 3296 3297 FORGET_Frame(); 3298 3299 cpf1->PosRuleSet = NULL; 3300 3301 if ( ALLOC_ARRAY( cpf1->PosRuleSet, count, HB_PosRuleSet ) ) 3302 goto Fail2; 3303 3304 prs = cpf1->PosRuleSet; 3305 3306 for ( n = 0; n < count; n++ ) 3307 { 3308 if ( ACCESS_Frame( 2L ) ) 3309 goto Fail1; 3310 3311 new_offset = GET_UShort() + base_offset; 3312 3313 FORGET_Frame(); 3314 3315 cur_offset = FILE_Pos(); 3316 if ( FILE_Seek( new_offset ) || 3317 ( error = Load_PosRuleSet( &prs[n], stream ) ) != HB_Err_Ok ) 3318 goto Fail1; 3319 (void)FILE_Seek( cur_offset ); 3320 } 3321 3322 return HB_Err_Ok; 3323 3324 Fail1: 3325 for ( m = 0; m < n; m++ ) 3326 Free_PosRuleSet( &prs[m] ); 3327 3328 FREE( prs ); 3329 3330 Fail2: 3331 _HB_OPEN_Free_Coverage( &cpf1->Coverage ); 3332 return error; 3333 } 3334 3335 3336 static void Free_ContextPos1( HB_ContextPosFormat1* cpf1 ) 3337 { 3338 HB_UShort n, count; 3339 3340 HB_PosRuleSet* prs; 3341 3342 3343 if ( cpf1->PosRuleSet ) 3344 { 3345 count = cpf1->PosRuleSetCount; 3346 prs = cpf1->PosRuleSet; 3347 3348 for ( n = 0; n < count; n++ ) 3349 Free_PosRuleSet( &prs[n] ); 3350 3351 FREE( prs ); 3352 } 3353 3354 _HB_OPEN_Free_Coverage( &cpf1->Coverage ); 3355 } 3356 3357 3358 /* PosClassRule */ 3359 3360 static HB_Error Load_PosClassRule( HB_ContextPosFormat2* cpf2, 3361 HB_PosClassRule* pcr, 3362 HB_Stream stream ) 3363 { 3364 HB_Error error; 3365 3366 HB_UShort n, count; 3367 3368 HB_UShort* c; 3369 HB_PosLookupRecord* plr; 3370 3371 3372 if ( ACCESS_Frame( 4L ) ) 3373 return error; 3374 3375 pcr->GlyphCount = GET_UShort(); 3376 pcr->PosCount = GET_UShort(); 3377 3378 FORGET_Frame(); 3379 3380 if ( pcr->GlyphCount > cpf2->MaxContextLength ) 3381 cpf2->MaxContextLength = pcr->GlyphCount; 3382 3383 pcr->Class = NULL; 3384 3385 count = pcr->GlyphCount - 1; /* only GlyphCount - 1 elements */ 3386 3387 if ( ALLOC_ARRAY( pcr->Class, count, HB_UShort ) ) 3388 return error; 3389 3390 c = pcr->Class; 3391 3392 if ( ACCESS_Frame( count * 2L ) ) 3393 goto Fail2; 3394 3395 for ( n = 0; n < count; n++ ) 3396 c[n] = GET_UShort(); 3397 3398 FORGET_Frame(); 3399 3400 pcr->PosLookupRecord = NULL; 3401 3402 count = pcr->PosCount; 3403 3404 if ( ALLOC_ARRAY( pcr->PosLookupRecord, count, HB_PosLookupRecord ) ) 3405 goto Fail2; 3406 3407 plr = pcr->PosLookupRecord; 3408 3409 if ( ACCESS_Frame( count * 4L ) ) 3410 goto Fail1; 3411 3412 for ( n = 0; n < count; n++ ) 3413 { 3414 plr[n].SequenceIndex = GET_UShort(); 3415 plr[n].LookupListIndex = GET_UShort(); 3416 } 3417 3418 FORGET_Frame(); 3419 3420 return HB_Err_Ok; 3421 3422 Fail1: 3423 FREE( plr ); 3424 3425 Fail2: 3426 FREE( c ); 3427 return error; 3428 } 3429 3430 3431 static void Free_PosClassRule( HB_PosClassRule* pcr ) 3432 { 3433 FREE( pcr->PosLookupRecord ); 3434 FREE( pcr->Class ); 3435 } 3436 3437 3438 /* PosClassSet */ 3439 3440 static HB_Error Load_PosClassSet( HB_ContextPosFormat2* cpf2, 3441 HB_PosClassSet* pcs, 3442 HB_Stream stream ) 3443 { 3444 HB_Error error; 3445 3446 HB_UShort n, m, count; 3447 HB_UInt cur_offset, new_offset, base_offset; 3448 3449 HB_PosClassRule* pcr; 3450 3451 3452 base_offset = FILE_Pos(); 3453 3454 if ( ACCESS_Frame( 2L ) ) 3455 return error; 3456 3457 count = pcs->PosClassRuleCount = GET_UShort(); 3458 3459 FORGET_Frame(); 3460 3461 pcs->PosClassRule = NULL; 3462 3463 if ( ALLOC_ARRAY( pcs->PosClassRule, count, HB_PosClassRule ) ) 3464 return error; 3465 3466 pcr = pcs->PosClassRule; 3467 3468 for ( n = 0; n < count; n++ ) 3469 { 3470 if ( ACCESS_Frame( 2L ) ) 3471 goto Fail; 3472 3473 new_offset = GET_UShort() + base_offset; 3474 3475 FORGET_Frame(); 3476 3477 cur_offset = FILE_Pos(); 3478 if ( FILE_Seek( new_offset ) || 3479 ( error = Load_PosClassRule( cpf2, &pcr[n], 3480 stream ) ) != HB_Err_Ok ) 3481 goto Fail; 3482 (void)FILE_Seek( cur_offset ); 3483 } 3484 3485 return HB_Err_Ok; 3486 3487 Fail: 3488 for ( m = 0; m < n; m++ ) 3489 Free_PosClassRule( &pcr[m] ); 3490 3491 FREE( pcr ); 3492 return error; 3493 } 3494 3495 3496 static void Free_PosClassSet( HB_PosClassSet* pcs ) 3497 { 3498 HB_UShort n, count; 3499 3500 HB_PosClassRule* pcr; 3501 3502 3503 if ( pcs->PosClassRule ) 3504 { 3505 count = pcs->PosClassRuleCount; 3506 pcr = pcs->PosClassRule; 3507 3508 for ( n = 0; n < count; n++ ) 3509 Free_PosClassRule( &pcr[n] ); 3510 3511 FREE( pcr ); 3512 } 3513 } 3514 3515 3516 /* ContextPosFormat2 */ 3517 3518 static HB_Error Load_ContextPos2( HB_ContextPosFormat2* cpf2, 3519 HB_Stream stream ) 3520 { 3521 HB_Error error; 3522 3523 HB_UShort n, m, count; 3524 HB_UInt cur_offset, new_offset, base_offset; 3525 3526 HB_PosClassSet* pcs; 3527 3528 3529 base_offset = FILE_Pos() - 2; 3530 3531 if ( ACCESS_Frame( 2L ) ) 3532 return error; 3533 3534 new_offset = GET_UShort() + base_offset; 3535 3536 FORGET_Frame(); 3537 3538 cur_offset = FILE_Pos(); 3539 if ( FILE_Seek( new_offset ) || 3540 ( error = _HB_OPEN_Load_Coverage( &cpf2->Coverage, stream ) ) != HB_Err_Ok ) 3541 return error; 3542 (void)FILE_Seek( cur_offset ); 3543 3544 if ( ACCESS_Frame( 4L ) ) 3545 goto Fail3; 3546 3547 new_offset = GET_UShort() + base_offset; 3548 3549 /* `PosClassSetCount' is the upper limit for class values, thus we 3550 read it now to make an additional safety check. */ 3551 3552 count = cpf2->PosClassSetCount = GET_UShort(); 3553 3554 FORGET_Frame(); 3555 3556 cur_offset = FILE_Pos(); 3557 if ( FILE_Seek( new_offset ) || 3558 ( error = _HB_OPEN_Load_ClassDefinition( &cpf2->ClassDef, count, 3559 stream ) ) != HB_Err_Ok ) 3560 goto Fail3; 3561 (void)FILE_Seek( cur_offset ); 3562 3563 cpf2->PosClassSet = NULL; 3564 cpf2->MaxContextLength = 0; 3565 3566 if ( ALLOC_ARRAY( cpf2->PosClassSet, count, HB_PosClassSet ) ) 3567 goto Fail2; 3568 3569 pcs = cpf2->PosClassSet; 3570 3571 for ( n = 0; n < count; n++ ) 3572 { 3573 if ( ACCESS_Frame( 2L ) ) 3574 goto Fail1; 3575 3576 new_offset = GET_UShort() + base_offset; 3577 3578 FORGET_Frame(); 3579 3580 if ( new_offset != base_offset ) /* not a NULL offset */ 3581 { 3582 cur_offset = FILE_Pos(); 3583 if ( FILE_Seek( new_offset ) || 3584 ( error = Load_PosClassSet( cpf2, &pcs[n], 3585 stream ) ) != HB_Err_Ok ) 3586 goto Fail1; 3587 (void)FILE_Seek( cur_offset ); 3588 } 3589 else 3590 { 3591 /* we create a PosClassSet table with no entries */ 3592 3593 cpf2->PosClassSet[n].PosClassRuleCount = 0; 3594 cpf2->PosClassSet[n].PosClassRule = NULL; 3595 } 3596 } 3597 3598 return HB_Err_Ok; 3599 3600 Fail1: 3601 for ( m = 0; m < n; n++ ) 3602 Free_PosClassSet( &pcs[m] ); 3603 3604 FREE( pcs ); 3605 3606 Fail2: 3607 _HB_OPEN_Free_ClassDefinition( &cpf2->ClassDef ); 3608 3609 Fail3: 3610 _HB_OPEN_Free_Coverage( &cpf2->Coverage ); 3611 return error; 3612 } 3613 3614 3615 static void Free_ContextPos2( HB_ContextPosFormat2* cpf2 ) 3616 { 3617 HB_UShort n, count; 3618 3619 HB_PosClassSet* pcs; 3620 3621 3622 if ( cpf2->PosClassSet ) 3623 { 3624 count = cpf2->PosClassSetCount; 3625 pcs = cpf2->PosClassSet; 3626 3627 for ( n = 0; n < count; n++ ) 3628 Free_PosClassSet( &pcs[n] ); 3629 3630 FREE( pcs ); 3631 } 3632 3633 _HB_OPEN_Free_ClassDefinition( &cpf2->ClassDef ); 3634 _HB_OPEN_Free_Coverage( &cpf2->Coverage ); 3635 } 3636 3637 3638 /* ContextPosFormat3 */ 3639 3640 static HB_Error Load_ContextPos3( HB_ContextPosFormat3* cpf3, 3641 HB_Stream stream ) 3642 { 3643 HB_Error error; 3644 3645 HB_UShort n, count; 3646 HB_UInt cur_offset, new_offset, base_offset; 3647 3648 HB_Coverage* c; 3649 HB_PosLookupRecord* plr; 3650 3651 3652 base_offset = FILE_Pos() - 2L; 3653 3654 if ( ACCESS_Frame( 4L ) ) 3655 return error; 3656 3657 cpf3->GlyphCount = GET_UShort(); 3658 cpf3->PosCount = GET_UShort(); 3659 3660 FORGET_Frame(); 3661 3662 cpf3->Coverage = NULL; 3663 3664 count = cpf3->GlyphCount; 3665 3666 if ( ALLOC_ARRAY( cpf3->Coverage, count, HB_Coverage ) ) 3667 return error; 3668 3669 c = cpf3->Coverage; 3670 3671 for ( n = 0; n < count; n++ ) 3672 { 3673 if ( ACCESS_Frame( 2L ) ) 3674 goto Fail2; 3675 3676 new_offset = GET_UShort() + base_offset; 3677 3678 FORGET_Frame(); 3679 3680 cur_offset = FILE_Pos(); 3681 if ( FILE_Seek( new_offset ) || 3682 ( error = _HB_OPEN_Load_Coverage( &c[n], stream ) ) != HB_Err_Ok ) 3683 goto Fail2; 3684 (void)FILE_Seek( cur_offset ); 3685 } 3686 3687 cpf3->PosLookupRecord = NULL; 3688 3689 count = cpf3->PosCount; 3690 3691 if ( ALLOC_ARRAY( cpf3->PosLookupRecord, count, HB_PosLookupRecord ) ) 3692 goto Fail2; 3693 3694 plr = cpf3->PosLookupRecord; 3695 3696 if ( ACCESS_Frame( count * 4L ) ) 3697 goto Fail1; 3698 3699 for ( n = 0; n < count; n++ ) 3700 { 3701 plr[n].SequenceIndex = GET_UShort(); 3702 plr[n].LookupListIndex = GET_UShort(); 3703 } 3704 3705 FORGET_Frame(); 3706 3707 return HB_Err_Ok; 3708 3709 Fail1: 3710 FREE( plr ); 3711 3712 Fail2: 3713 for ( n = 0; n < count; n++ ) 3714 _HB_OPEN_Free_Coverage( &c[n] ); 3715 3716 FREE( c ); 3717 return error; 3718 } 3719 3720 3721 static void Free_ContextPos3( HB_ContextPosFormat3* cpf3 ) 3722 { 3723 HB_UShort n, count; 3724 3725 HB_Coverage* c; 3726 3727 3728 FREE( cpf3->PosLookupRecord ); 3729 3730 if ( cpf3->Coverage ) 3731 { 3732 count = cpf3->GlyphCount; 3733 c = cpf3->Coverage; 3734 3735 for ( n = 0; n < count; n++ ) 3736 _HB_OPEN_Free_Coverage( &c[n] ); 3737 3738 FREE( c ); 3739 } 3740 } 3741 3742 3743 /* ContextPos */ 3744 3745 static HB_Error Load_ContextPos( HB_GPOS_SubTable* st, 3746 HB_Stream stream ) 3747 { 3748 HB_Error error; 3749 HB_ContextPos* cp = &st->context; 3750 3751 3752 if ( ACCESS_Frame( 2L ) ) 3753 return error; 3754 3755 cp->PosFormat = GET_UShort(); 3756 3757 FORGET_Frame(); 3758 3759 switch ( cp->PosFormat ) 3760 { 3761 case 1: 3762 return Load_ContextPos1( &cp->cpf.cpf1, stream ); 3763 3764 case 2: 3765 return Load_ContextPos2( &cp->cpf.cpf2, stream ); 3766 3767 case 3: 3768 return Load_ContextPos3( &cp->cpf.cpf3, stream ); 3769 3770 default: 3771 return ERR(HB_Err_Invalid_SubTable_Format); 3772 } 3773 3774 return HB_Err_Ok; /* never reached */ 3775 } 3776 3777 3778 static void Free_ContextPos( HB_GPOS_SubTable* st ) 3779 { 3780 HB_ContextPos* cp = &st->context; 3781 3782 switch ( cp->PosFormat ) 3783 { 3784 case 1: Free_ContextPos1( &cp->cpf.cpf1 ); break; 3785 case 2: Free_ContextPos2( &cp->cpf.cpf2 ); break; 3786 case 3: Free_ContextPos3( &cp->cpf.cpf3 ); break; 3787 default: break; 3788 } 3789 } 3790 3791 3792 static HB_Error Lookup_ContextPos1( GPOS_Instance* gpi, 3793 HB_ContextPosFormat1* cpf1, 3794 HB_Buffer buffer, 3795 HB_UShort flags, 3796 HB_UShort context_length, 3797 int nesting_level ) 3798 { 3799 HB_UShort index, property; 3800 HB_UShort i, j, k, numpr; 3801 HB_Error error; 3802 HB_GPOSHeader* gpos = gpi->gpos; 3803 3804 HB_PosRule* pr; 3805 HB_GDEFHeader* gdef; 3806 3807 3808 gdef = gpos->gdef; 3809 3810 if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) ) 3811 return error; 3812 3813 error = _HB_OPEN_Coverage_Index( &cpf1->Coverage, IN_CURGLYPH(), &index ); 3814 if ( error ) 3815 return error; 3816 3817 pr = cpf1->PosRuleSet[index].PosRule; 3818 numpr = cpf1->PosRuleSet[index].PosRuleCount; 3819 3820 for ( k = 0; k < numpr; k++ ) 3821 { 3822 if ( context_length != 0xFFFF && context_length < pr[k].GlyphCount ) 3823 goto next_posrule; 3824 3825 if ( buffer->in_pos + pr[k].GlyphCount > buffer->in_length ) 3826 goto next_posrule; /* context is too long */ 3827 3828 for ( i = 1, j = buffer->in_pos + 1; i < pr[k].GlyphCount; i++, j++ ) 3829 { 3830 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 3831 { 3832 if ( error && error != HB_Err_Not_Covered ) 3833 return error; 3834 3835 if ( j + pr[k].GlyphCount - i == (HB_Int)buffer->in_length ) 3836 goto next_posrule; 3837 j++; 3838 } 3839 3840 if ( IN_GLYPH( j ) != pr[k].Input[i - 1] ) 3841 goto next_posrule; 3842 } 3843 3844 return Do_ContextPos( gpi, pr[k].GlyphCount, 3845 pr[k].PosCount, pr[k].PosLookupRecord, 3846 buffer, 3847 nesting_level ); 3848 3849 next_posrule: 3850 ; 3851 } 3852 3853 return HB_Err_Not_Covered; 3854 } 3855 3856 3857 static HB_Error Lookup_ContextPos2( GPOS_Instance* gpi, 3858 HB_ContextPosFormat2* cpf2, 3859 HB_Buffer buffer, 3860 HB_UShort flags, 3861 HB_UShort context_length, 3862 int nesting_level ) 3863 { 3864 HB_UShort index, property; 3865 HB_Error error; 3866 HB_UShort i, j, k, known_classes; 3867 3868 HB_UShort* classes; 3869 HB_UShort* cl; 3870 HB_GPOSHeader* gpos = gpi->gpos; 3871 3872 HB_PosClassSet* pcs; 3873 HB_PosClassRule* pr; 3874 HB_GDEFHeader* gdef; 3875 3876 3877 gdef = gpos->gdef; 3878 3879 if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) ) 3880 return error; 3881 3882 /* Note: The coverage table in format 2 doesn't give an index into 3883 anything. It just lets us know whether or not we need to 3884 do any lookup at all. */ 3885 3886 error = _HB_OPEN_Coverage_Index( &cpf2->Coverage, IN_CURGLYPH(), &index ); 3887 if ( error ) 3888 return error; 3889 3890 if (cpf2->MaxContextLength < 1) 3891 return HB_Err_Not_Covered; 3892 3893 if ( ALLOC_ARRAY( classes, cpf2->MaxContextLength, HB_UShort ) ) 3894 return error; 3895 3896 error = _HB_OPEN_Get_Class( &cpf2->ClassDef, IN_CURGLYPH(), 3897 &classes[0], NULL ); 3898 if ( error && error != HB_Err_Not_Covered ) 3899 goto End; 3900 known_classes = 0; 3901 3902 pcs = &cpf2->PosClassSet[classes[0]]; 3903 if ( !pcs ) 3904 { 3905 error = ERR(HB_Err_Invalid_SubTable); 3906 goto End; 3907 } 3908 3909 for ( k = 0; k < pcs->PosClassRuleCount; k++ ) 3910 { 3911 pr = &pcs->PosClassRule[k]; 3912 3913 if ( context_length != 0xFFFF && context_length < pr->GlyphCount ) 3914 goto next_posclassrule; 3915 3916 if ( buffer->in_pos + pr->GlyphCount > buffer->in_length ) 3917 goto next_posclassrule; /* context is too long */ 3918 3919 cl = pr->Class; 3920 3921 /* Start at 1 because [0] is implied */ 3922 3923 for ( i = 1, j = buffer->in_pos + 1; i < pr->GlyphCount; i++, j++ ) 3924 { 3925 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 3926 { 3927 if ( error && error != HB_Err_Not_Covered ) 3928 goto End; 3929 3930 if ( j + pr->GlyphCount - i == (HB_Int)buffer->in_length ) 3931 goto next_posclassrule; 3932 j++; 3933 } 3934 3935 if ( i > known_classes ) 3936 { 3937 /* Keeps us from having to do this for each rule */ 3938 3939 error = _HB_OPEN_Get_Class( &cpf2->ClassDef, IN_GLYPH( j ), &classes[i], NULL ); 3940 if ( error && error != HB_Err_Not_Covered ) 3941 goto End; 3942 known_classes = i; 3943 } 3944 3945 if ( cl[i - 1] != classes[i] ) 3946 goto next_posclassrule; 3947 } 3948 3949 error = Do_ContextPos( gpi, pr->GlyphCount, 3950 pr->PosCount, pr->PosLookupRecord, 3951 buffer, 3952 nesting_level ); 3953 goto End; 3954 3955 next_posclassrule: 3956 ; 3957 } 3958 3959 error = HB_Err_Not_Covered; 3960 3961 End: 3962 FREE( classes ); 3963 return error; 3964 } 3965 3966 3967 static HB_Error Lookup_ContextPos3( GPOS_Instance* gpi, 3968 HB_ContextPosFormat3* cpf3, 3969 HB_Buffer buffer, 3970 HB_UShort flags, 3971 HB_UShort context_length, 3972 int nesting_level ) 3973 { 3974 HB_Error error; 3975 HB_UShort index, i, j, property; 3976 HB_GPOSHeader* gpos = gpi->gpos; 3977 3978 HB_Coverage* c; 3979 HB_GDEFHeader* gdef; 3980 3981 3982 gdef = gpos->gdef; 3983 3984 if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) ) 3985 return error; 3986 3987 if ( context_length != 0xFFFF && context_length < cpf3->GlyphCount ) 3988 return HB_Err_Not_Covered; 3989 3990 if ( buffer->in_pos + cpf3->GlyphCount > buffer->in_length ) 3991 return HB_Err_Not_Covered; /* context is too long */ 3992 3993 c = cpf3->Coverage; 3994 3995 for ( i = 1, j = 1; i < cpf3->GlyphCount; i++, j++ ) 3996 { 3997 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 3998 { 3999 if ( error && error != HB_Err_Not_Covered ) 4000 return error; 4001 4002 if ( j + cpf3->GlyphCount - i == (HB_Int)buffer->in_length ) 4003 return HB_Err_Not_Covered; 4004 j++; 4005 } 4006 4007 error = _HB_OPEN_Coverage_Index( &c[i], IN_GLYPH( j ), &index ); 4008 if ( error ) 4009 return error; 4010 } 4011 4012 return Do_ContextPos( gpi, cpf3->GlyphCount, 4013 cpf3->PosCount, cpf3->PosLookupRecord, 4014 buffer, 4015 nesting_level ); 4016 } 4017 4018 4019 static HB_Error Lookup_ContextPos( GPOS_Instance* gpi, 4020 HB_GPOS_SubTable* st, 4021 HB_Buffer buffer, 4022 HB_UShort flags, 4023 HB_UShort context_length, 4024 int nesting_level ) 4025 { 4026 HB_ContextPos* cp = &st->context; 4027 4028 switch ( cp->PosFormat ) 4029 { 4030 case 1: 4031 return Lookup_ContextPos1( gpi, &cp->cpf.cpf1, buffer, 4032 flags, context_length, nesting_level ); 4033 4034 case 2: 4035 return Lookup_ContextPos2( gpi, &cp->cpf.cpf2, buffer, 4036 flags, context_length, nesting_level ); 4037 4038 case 3: 4039 return Lookup_ContextPos3( gpi, &cp->cpf.cpf3, buffer, 4040 flags, context_length, nesting_level ); 4041 4042 default: 4043 return ERR(HB_Err_Invalid_SubTable_Format); 4044 } 4045 4046 return HB_Err_Ok; /* never reached */ 4047 } 4048 4049 4050 /* LookupType 8 */ 4051 4052 /* ChainPosRule */ 4053 4054 static HB_Error Load_ChainPosRule( HB_ChainPosRule* cpr, 4055 HB_Stream stream ) 4056 { 4057 HB_Error error; 4058 4059 HB_UShort n, count; 4060 HB_UShort* b; 4061 HB_UShort* i; 4062 HB_UShort* l; 4063 4064 HB_PosLookupRecord* plr; 4065 4066 4067 if ( ACCESS_Frame( 2L ) ) 4068 return error; 4069 4070 cpr->BacktrackGlyphCount = GET_UShort(); 4071 4072 FORGET_Frame(); 4073 4074 cpr->Backtrack = NULL; 4075 4076 count = cpr->BacktrackGlyphCount; 4077 4078 if ( ALLOC_ARRAY( cpr->Backtrack, count, HB_UShort ) ) 4079 return error; 4080 4081 b = cpr->Backtrack; 4082 4083 if ( ACCESS_Frame( count * 2L ) ) 4084 goto Fail4; 4085 4086 for ( n = 0; n < count; n++ ) 4087 b[n] = GET_UShort(); 4088 4089 FORGET_Frame(); 4090 4091 if ( ACCESS_Frame( 2L ) ) 4092 goto Fail4; 4093 4094 cpr->InputGlyphCount = GET_UShort(); 4095 4096 FORGET_Frame(); 4097 4098 cpr->Input = NULL; 4099 4100 count = cpr->InputGlyphCount - 1; /* only InputGlyphCount - 1 elements */ 4101 4102 if ( ALLOC_ARRAY( cpr->Input, count, HB_UShort ) ) 4103 goto Fail4; 4104 4105 i = cpr->Input; 4106 4107 if ( ACCESS_Frame( count * 2L ) ) 4108 goto Fail3; 4109 4110 for ( n = 0; n < count; n++ ) 4111 i[n] = GET_UShort(); 4112 4113 FORGET_Frame(); 4114 4115 if ( ACCESS_Frame( 2L ) ) 4116 goto Fail3; 4117 4118 cpr->LookaheadGlyphCount = GET_UShort(); 4119 4120 FORGET_Frame(); 4121 4122 cpr->Lookahead = NULL; 4123 4124 count = cpr->LookaheadGlyphCount; 4125 4126 if ( ALLOC_ARRAY( cpr->Lookahead, count, HB_UShort ) ) 4127 goto Fail3; 4128 4129 l = cpr->Lookahead; 4130 4131 if ( ACCESS_Frame( count * 2L ) ) 4132 goto Fail2; 4133 4134 for ( n = 0; n < count; n++ ) 4135 l[n] = GET_UShort(); 4136 4137 FORGET_Frame(); 4138 4139 if ( ACCESS_Frame( 2L ) ) 4140 goto Fail2; 4141 4142 cpr->PosCount = GET_UShort(); 4143 4144 FORGET_Frame(); 4145 4146 cpr->PosLookupRecord = NULL; 4147 4148 count = cpr->PosCount; 4149 4150 if ( ALLOC_ARRAY( cpr->PosLookupRecord, count, HB_PosLookupRecord ) ) 4151 goto Fail2; 4152 4153 plr = cpr->PosLookupRecord; 4154 4155 if ( ACCESS_Frame( count * 4L ) ) 4156 goto Fail1; 4157 4158 for ( n = 0; n < count; n++ ) 4159 { 4160 plr[n].SequenceIndex = GET_UShort(); 4161 plr[n].LookupListIndex = GET_UShort(); 4162 } 4163 4164 FORGET_Frame(); 4165 4166 return HB_Err_Ok; 4167 4168 Fail1: 4169 FREE( plr ); 4170 4171 Fail2: 4172 FREE( l ); 4173 4174 Fail3: 4175 FREE( i ); 4176 4177 Fail4: 4178 FREE( b ); 4179 return error; 4180 } 4181 4182 4183 static void Free_ChainPosRule( HB_ChainPosRule* cpr ) 4184 { 4185 FREE( cpr->PosLookupRecord ); 4186 FREE( cpr->Lookahead ); 4187 FREE( cpr->Input ); 4188 FREE( cpr->Backtrack ); 4189 } 4190 4191 4192 /* ChainPosRuleSet */ 4193 4194 static HB_Error Load_ChainPosRuleSet( HB_ChainPosRuleSet* cprs, 4195 HB_Stream stream ) 4196 { 4197 HB_Error error; 4198 4199 HB_UShort n, m, count; 4200 HB_UInt cur_offset, new_offset, base_offset; 4201 4202 HB_ChainPosRule* cpr; 4203 4204 4205 base_offset = FILE_Pos(); 4206 4207 if ( ACCESS_Frame( 2L ) ) 4208 return error; 4209 4210 count = cprs->ChainPosRuleCount = GET_UShort(); 4211 4212 FORGET_Frame(); 4213 4214 cprs->ChainPosRule = NULL; 4215 4216 if ( ALLOC_ARRAY( cprs->ChainPosRule, count, HB_ChainPosRule ) ) 4217 return error; 4218 4219 cpr = cprs->ChainPosRule; 4220 4221 for ( n = 0; n < count; n++ ) 4222 { 4223 if ( ACCESS_Frame( 2L ) ) 4224 goto Fail; 4225 4226 new_offset = GET_UShort() + base_offset; 4227 4228 FORGET_Frame(); 4229 4230 cur_offset = FILE_Pos(); 4231 if ( FILE_Seek( new_offset ) || 4232 ( error = Load_ChainPosRule( &cpr[n], stream ) ) != HB_Err_Ok ) 4233 goto Fail; 4234 (void)FILE_Seek( cur_offset ); 4235 } 4236 4237 return HB_Err_Ok; 4238 4239 Fail: 4240 for ( m = 0; m < n; m++ ) 4241 Free_ChainPosRule( &cpr[m] ); 4242 4243 FREE( cpr ); 4244 return error; 4245 } 4246 4247 4248 static void Free_ChainPosRuleSet( HB_ChainPosRuleSet* cprs ) 4249 { 4250 HB_UShort n, count; 4251 4252 HB_ChainPosRule* cpr; 4253 4254 4255 if ( cprs->ChainPosRule ) 4256 { 4257 count = cprs->ChainPosRuleCount; 4258 cpr = cprs->ChainPosRule; 4259 4260 for ( n = 0; n < count; n++ ) 4261 Free_ChainPosRule( &cpr[n] ); 4262 4263 FREE( cpr ); 4264 } 4265 } 4266 4267 4268 /* ChainContextPosFormat1 */ 4269 4270 static HB_Error Load_ChainContextPos1( HB_ChainContextPosFormat1* ccpf1, 4271 HB_Stream stream ) 4272 { 4273 HB_Error error; 4274 4275 HB_UShort n, m, count; 4276 HB_UInt cur_offset, new_offset, base_offset; 4277 4278 HB_ChainPosRuleSet* cprs; 4279 4280 4281 base_offset = FILE_Pos() - 2L; 4282 4283 if ( ACCESS_Frame( 2L ) ) 4284 return error; 4285 4286 new_offset = GET_UShort() + base_offset; 4287 4288 FORGET_Frame(); 4289 4290 cur_offset = FILE_Pos(); 4291 if ( FILE_Seek( new_offset ) || 4292 ( error = _HB_OPEN_Load_Coverage( &ccpf1->Coverage, stream ) ) != HB_Err_Ok ) 4293 return error; 4294 (void)FILE_Seek( cur_offset ); 4295 4296 if ( ACCESS_Frame( 2L ) ) 4297 goto Fail2; 4298 4299 count = ccpf1->ChainPosRuleSetCount = GET_UShort(); 4300 4301 FORGET_Frame(); 4302 4303 ccpf1->ChainPosRuleSet = NULL; 4304 4305 if ( ALLOC_ARRAY( ccpf1->ChainPosRuleSet, count, HB_ChainPosRuleSet ) ) 4306 goto Fail2; 4307 4308 cprs = ccpf1->ChainPosRuleSet; 4309 4310 for ( n = 0; n < count; n++ ) 4311 { 4312 if ( ACCESS_Frame( 2L ) ) 4313 goto Fail1; 4314 4315 new_offset = GET_UShort() + base_offset; 4316 4317 FORGET_Frame(); 4318 4319 cur_offset = FILE_Pos(); 4320 if ( FILE_Seek( new_offset ) || 4321 ( error = Load_ChainPosRuleSet( &cprs[n], stream ) ) != HB_Err_Ok ) 4322 goto Fail1; 4323 (void)FILE_Seek( cur_offset ); 4324 } 4325 4326 return HB_Err_Ok; 4327 4328 Fail1: 4329 for ( m = 0; m < n; m++ ) 4330 Free_ChainPosRuleSet( &cprs[m] ); 4331 4332 FREE( cprs ); 4333 4334 Fail2: 4335 _HB_OPEN_Free_Coverage( &ccpf1->Coverage ); 4336 return error; 4337 } 4338 4339 4340 static void Free_ChainContextPos1( HB_ChainContextPosFormat1* ccpf1 ) 4341 { 4342 HB_UShort n, count; 4343 4344 HB_ChainPosRuleSet* cprs; 4345 4346 4347 if ( ccpf1->ChainPosRuleSet ) 4348 { 4349 count = ccpf1->ChainPosRuleSetCount; 4350 cprs = ccpf1->ChainPosRuleSet; 4351 4352 for ( n = 0; n < count; n++ ) 4353 Free_ChainPosRuleSet( &cprs[n] ); 4354 4355 FREE( cprs ); 4356 } 4357 4358 _HB_OPEN_Free_Coverage( &ccpf1->Coverage ); 4359 } 4360 4361 4362 /* ChainPosClassRule */ 4363 4364 static HB_Error Load_ChainPosClassRule( 4365 HB_ChainContextPosFormat2* ccpf2, 4366 HB_ChainPosClassRule* cpcr, 4367 HB_Stream stream ) 4368 { 4369 HB_Error error; 4370 4371 HB_UShort n, count; 4372 4373 HB_UShort* b; 4374 HB_UShort* i; 4375 HB_UShort* l; 4376 HB_PosLookupRecord* plr; 4377 4378 4379 if ( ACCESS_Frame( 2L ) ) 4380 return error; 4381 4382 cpcr->BacktrackGlyphCount = GET_UShort(); 4383 4384 FORGET_Frame(); 4385 4386 if ( cpcr->BacktrackGlyphCount > ccpf2->MaxBacktrackLength ) 4387 ccpf2->MaxBacktrackLength = cpcr->BacktrackGlyphCount; 4388 4389 cpcr->Backtrack = NULL; 4390 4391 count = cpcr->BacktrackGlyphCount; 4392 4393 if ( ALLOC_ARRAY( cpcr->Backtrack, count, HB_UShort ) ) 4394 return error; 4395 4396 b = cpcr->Backtrack; 4397 4398 if ( ACCESS_Frame( count * 2L ) ) 4399 goto Fail4; 4400 4401 for ( n = 0; n < count; n++ ) 4402 b[n] = GET_UShort(); 4403 4404 FORGET_Frame(); 4405 4406 if ( ACCESS_Frame( 2L ) ) 4407 goto Fail4; 4408 4409 cpcr->InputGlyphCount = GET_UShort(); 4410 4411 if ( cpcr->InputGlyphCount > ccpf2->MaxInputLength ) 4412 ccpf2->MaxInputLength = cpcr->InputGlyphCount; 4413 4414 FORGET_Frame(); 4415 4416 cpcr->Input = NULL; 4417 4418 count = cpcr->InputGlyphCount - 1; /* only InputGlyphCount - 1 elements */ 4419 4420 if ( ALLOC_ARRAY( cpcr->Input, count, HB_UShort ) ) 4421 goto Fail4; 4422 4423 i = cpcr->Input; 4424 4425 if ( ACCESS_Frame( count * 2L ) ) 4426 goto Fail3; 4427 4428 for ( n = 0; n < count; n++ ) 4429 i[n] = GET_UShort(); 4430 4431 FORGET_Frame(); 4432 4433 if ( ACCESS_Frame( 2L ) ) 4434 goto Fail3; 4435 4436 cpcr->LookaheadGlyphCount = GET_UShort(); 4437 4438 FORGET_Frame(); 4439 4440 if ( cpcr->LookaheadGlyphCount > ccpf2->MaxLookaheadLength ) 4441 ccpf2->MaxLookaheadLength = cpcr->LookaheadGlyphCount; 4442 4443 cpcr->Lookahead = NULL; 4444 4445 count = cpcr->LookaheadGlyphCount; 4446 4447 if ( ALLOC_ARRAY( cpcr->Lookahead, count, HB_UShort ) ) 4448 goto Fail3; 4449 4450 l = cpcr->Lookahead; 4451 4452 if ( ACCESS_Frame( count * 2L ) ) 4453 goto Fail2; 4454 4455 for ( n = 0; n < count; n++ ) 4456 l[n] = GET_UShort(); 4457 4458 FORGET_Frame(); 4459 4460 if ( ACCESS_Frame( 2L ) ) 4461 goto Fail2; 4462 4463 cpcr->PosCount = GET_UShort(); 4464 4465 FORGET_Frame(); 4466 4467 cpcr->PosLookupRecord = NULL; 4468 4469 count = cpcr->PosCount; 4470 4471 if ( ALLOC_ARRAY( cpcr->PosLookupRecord, count, HB_PosLookupRecord ) ) 4472 goto Fail2; 4473 4474 plr = cpcr->PosLookupRecord; 4475 4476 if ( ACCESS_Frame( count * 4L ) ) 4477 goto Fail1; 4478 4479 for ( n = 0; n < count; n++ ) 4480 { 4481 plr[n].SequenceIndex = GET_UShort(); 4482 plr[n].LookupListIndex = GET_UShort(); 4483 } 4484 4485 FORGET_Frame(); 4486 4487 return HB_Err_Ok; 4488 4489 Fail1: 4490 FREE( plr ); 4491 4492 Fail2: 4493 FREE( l ); 4494 4495 Fail3: 4496 FREE( i ); 4497 4498 Fail4: 4499 FREE( b ); 4500 return error; 4501 } 4502 4503 4504 static void Free_ChainPosClassRule( HB_ChainPosClassRule* cpcr ) 4505 { 4506 FREE( cpcr->PosLookupRecord ); 4507 FREE( cpcr->Lookahead ); 4508 FREE( cpcr->Input ); 4509 FREE( cpcr->Backtrack ); 4510 } 4511 4512 4513 /* PosClassSet */ 4514 4515 static HB_Error Load_ChainPosClassSet( 4516 HB_ChainContextPosFormat2* ccpf2, 4517 HB_ChainPosClassSet* cpcs, 4518 HB_Stream stream ) 4519 { 4520 HB_Error error; 4521 4522 HB_UShort n, m, count; 4523 HB_UInt cur_offset, new_offset, base_offset; 4524 4525 HB_ChainPosClassRule* cpcr; 4526 4527 4528 base_offset = FILE_Pos(); 4529 4530 if ( ACCESS_Frame( 2L ) ) 4531 return error; 4532 4533 count = cpcs->ChainPosClassRuleCount = GET_UShort(); 4534 4535 FORGET_Frame(); 4536 4537 cpcs->ChainPosClassRule = NULL; 4538 4539 if ( ALLOC_ARRAY( cpcs->ChainPosClassRule, count, 4540 HB_ChainPosClassRule ) ) 4541 return error; 4542 4543 cpcr = cpcs->ChainPosClassRule; 4544 4545 for ( n = 0; n < count; n++ ) 4546 { 4547 if ( ACCESS_Frame( 2L ) ) 4548 goto Fail; 4549 4550 new_offset = GET_UShort() + base_offset; 4551 4552 FORGET_Frame(); 4553 4554 cur_offset = FILE_Pos(); 4555 if ( FILE_Seek( new_offset ) || 4556 ( error = Load_ChainPosClassRule( ccpf2, &cpcr[n], 4557 stream ) ) != HB_Err_Ok ) 4558 goto Fail; 4559 (void)FILE_Seek( cur_offset ); 4560 } 4561 4562 return HB_Err_Ok; 4563 4564 Fail: 4565 for ( m = 0; m < n; m++ ) 4566 Free_ChainPosClassRule( &cpcr[m] ); 4567 4568 FREE( cpcr ); 4569 return error; 4570 } 4571 4572 4573 static void Free_ChainPosClassSet( HB_ChainPosClassSet* cpcs ) 4574 { 4575 HB_UShort n, count; 4576 4577 HB_ChainPosClassRule* cpcr; 4578 4579 4580 if ( cpcs->ChainPosClassRule ) 4581 { 4582 count = cpcs->ChainPosClassRuleCount; 4583 cpcr = cpcs->ChainPosClassRule; 4584 4585 for ( n = 0; n < count; n++ ) 4586 Free_ChainPosClassRule( &cpcr[n] ); 4587 4588 FREE( cpcr ); 4589 } 4590 } 4591 4592 4593 /* ChainContextPosFormat2 */ 4594 4595 static HB_Error Load_ChainContextPos2( HB_ChainContextPosFormat2* ccpf2, 4596 HB_Stream stream ) 4597 { 4598 HB_Error error; 4599 4600 HB_UShort n, m, count; 4601 HB_UInt cur_offset, new_offset, base_offset; 4602 HB_UInt backtrack_offset, input_offset, lookahead_offset; 4603 4604 HB_ChainPosClassSet* cpcs; 4605 4606 4607 base_offset = FILE_Pos() - 2; 4608 4609 if ( ACCESS_Frame( 2L ) ) 4610 return error; 4611 4612 new_offset = GET_UShort() + base_offset; 4613 4614 FORGET_Frame(); 4615 4616 cur_offset = FILE_Pos(); 4617 if ( FILE_Seek( new_offset ) || 4618 ( error = _HB_OPEN_Load_Coverage( &ccpf2->Coverage, stream ) ) != HB_Err_Ok ) 4619 return error; 4620 (void)FILE_Seek( cur_offset ); 4621 4622 if ( ACCESS_Frame( 8L ) ) 4623 goto Fail5; 4624 4625 backtrack_offset = GET_UShort(); 4626 input_offset = GET_UShort(); 4627 lookahead_offset = GET_UShort(); 4628 4629 /* `ChainPosClassSetCount' is the upper limit for input class values, 4630 thus we read it now to make an additional safety check. No limit 4631 is known or needed for the other two class definitions */ 4632 4633 count = ccpf2->ChainPosClassSetCount = GET_UShort(); 4634 4635 FORGET_Frame(); 4636 4637 if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccpf2->BacktrackClassDef, 65535, 4638 backtrack_offset, base_offset, 4639 stream ) ) != HB_Err_Ok ) 4640 goto Fail5; 4641 if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccpf2->InputClassDef, count, 4642 input_offset, base_offset, 4643 stream ) ) != HB_Err_Ok ) 4644 goto Fail4; 4645 if ( ( error = _HB_OPEN_Load_EmptyOrClassDefinition( &ccpf2->LookaheadClassDef, 65535, 4646 lookahead_offset, base_offset, 4647 stream ) ) != HB_Err_Ok ) 4648 goto Fail3; 4649 4650 ccpf2->ChainPosClassSet = NULL; 4651 ccpf2->MaxBacktrackLength = 0; 4652 ccpf2->MaxInputLength = 0; 4653 ccpf2->MaxLookaheadLength = 0; 4654 4655 if ( ALLOC_ARRAY( ccpf2->ChainPosClassSet, count, HB_ChainPosClassSet ) ) 4656 goto Fail2; 4657 4658 cpcs = ccpf2->ChainPosClassSet; 4659 4660 for ( n = 0; n < count; n++ ) 4661 { 4662 if ( ACCESS_Frame( 2L ) ) 4663 goto Fail1; 4664 4665 new_offset = GET_UShort() + base_offset; 4666 4667 FORGET_Frame(); 4668 4669 if ( new_offset != base_offset ) /* not a NULL offset */ 4670 { 4671 cur_offset = FILE_Pos(); 4672 if ( FILE_Seek( new_offset ) || 4673 ( error = Load_ChainPosClassSet( ccpf2, &cpcs[n], 4674 stream ) ) != HB_Err_Ok ) 4675 goto Fail1; 4676 (void)FILE_Seek( cur_offset ); 4677 } 4678 else 4679 { 4680 /* we create a ChainPosClassSet table with no entries */ 4681 4682 ccpf2->ChainPosClassSet[n].ChainPosClassRuleCount = 0; 4683 ccpf2->ChainPosClassSet[n].ChainPosClassRule = NULL; 4684 } 4685 } 4686 4687 return HB_Err_Ok; 4688 4689 Fail1: 4690 for ( m = 0; m < n; m++ ) 4691 Free_ChainPosClassSet( &cpcs[m] ); 4692 4693 FREE( cpcs ); 4694 4695 Fail2: 4696 _HB_OPEN_Free_ClassDefinition( &ccpf2->LookaheadClassDef ); 4697 4698 Fail3: 4699 _HB_OPEN_Free_ClassDefinition( &ccpf2->InputClassDef ); 4700 4701 Fail4: 4702 _HB_OPEN_Free_ClassDefinition( &ccpf2->BacktrackClassDef ); 4703 4704 Fail5: 4705 _HB_OPEN_Free_Coverage( &ccpf2->Coverage ); 4706 return error; 4707 } 4708 4709 4710 static void Free_ChainContextPos2( HB_ChainContextPosFormat2* ccpf2 ) 4711 { 4712 HB_UShort n, count; 4713 4714 HB_ChainPosClassSet* cpcs; 4715 4716 4717 if ( ccpf2->ChainPosClassSet ) 4718 { 4719 count = ccpf2->ChainPosClassSetCount; 4720 cpcs = ccpf2->ChainPosClassSet; 4721 4722 for ( n = 0; n < count; n++ ) 4723 Free_ChainPosClassSet( &cpcs[n] ); 4724 4725 FREE( cpcs ); 4726 } 4727 4728 _HB_OPEN_Free_ClassDefinition( &ccpf2->LookaheadClassDef ); 4729 _HB_OPEN_Free_ClassDefinition( &ccpf2->InputClassDef ); 4730 _HB_OPEN_Free_ClassDefinition( &ccpf2->BacktrackClassDef ); 4731 4732 _HB_OPEN_Free_Coverage( &ccpf2->Coverage ); 4733 } 4734 4735 4736 /* ChainContextPosFormat3 */ 4737 4738 static HB_Error Load_ChainContextPos3( HB_ChainContextPosFormat3* ccpf3, 4739 HB_Stream stream ) 4740 { 4741 HB_Error error; 4742 4743 HB_UShort n, nb, ni, nl, m, count; 4744 HB_UShort backtrack_count, input_count, lookahead_count; 4745 HB_UInt cur_offset, new_offset, base_offset; 4746 4747 HB_Coverage* b; 4748 HB_Coverage* i; 4749 HB_Coverage* l; 4750 HB_PosLookupRecord* plr; 4751 4752 4753 base_offset = FILE_Pos() - 2L; 4754 4755 if ( ACCESS_Frame( 2L ) ) 4756 return error; 4757 4758 ccpf3->BacktrackGlyphCount = GET_UShort(); 4759 4760 FORGET_Frame(); 4761 4762 ccpf3->BacktrackCoverage = NULL; 4763 4764 backtrack_count = ccpf3->BacktrackGlyphCount; 4765 4766 if ( ALLOC_ARRAY( ccpf3->BacktrackCoverage, backtrack_count, 4767 HB_Coverage ) ) 4768 return error; 4769 4770 b = ccpf3->BacktrackCoverage; 4771 4772 for ( nb = 0; nb < backtrack_count; nb++ ) 4773 { 4774 if ( ACCESS_Frame( 2L ) ) 4775 goto Fail4; 4776 4777 new_offset = GET_UShort() + base_offset; 4778 4779 FORGET_Frame(); 4780 4781 cur_offset = FILE_Pos(); 4782 if ( FILE_Seek( new_offset ) || 4783 ( error = _HB_OPEN_Load_Coverage( &b[nb], stream ) ) != HB_Err_Ok ) 4784 goto Fail4; 4785 (void)FILE_Seek( cur_offset ); 4786 } 4787 4788 if ( ACCESS_Frame( 2L ) ) 4789 goto Fail4; 4790 4791 ccpf3->InputGlyphCount = GET_UShort(); 4792 4793 FORGET_Frame(); 4794 4795 ccpf3->InputCoverage = NULL; 4796 4797 input_count = ccpf3->InputGlyphCount; 4798 4799 if ( ALLOC_ARRAY( ccpf3->InputCoverage, input_count, HB_Coverage ) ) 4800 goto Fail4; 4801 4802 i = ccpf3->InputCoverage; 4803 4804 for ( ni = 0; ni < input_count; ni++ ) 4805 { 4806 if ( ACCESS_Frame( 2L ) ) 4807 goto Fail3; 4808 4809 new_offset = GET_UShort() + base_offset; 4810 4811 FORGET_Frame(); 4812 4813 cur_offset = FILE_Pos(); 4814 if ( FILE_Seek( new_offset ) || 4815 ( error = _HB_OPEN_Load_Coverage( &i[ni], stream ) ) != HB_Err_Ok ) 4816 goto Fail3; 4817 (void)FILE_Seek( cur_offset ); 4818 } 4819 4820 if ( ACCESS_Frame( 2L ) ) 4821 goto Fail3; 4822 4823 ccpf3->LookaheadGlyphCount = GET_UShort(); 4824 4825 FORGET_Frame(); 4826 4827 ccpf3->LookaheadCoverage = NULL; 4828 4829 lookahead_count = ccpf3->LookaheadGlyphCount; 4830 4831 if ( ALLOC_ARRAY( ccpf3->LookaheadCoverage, lookahead_count, 4832 HB_Coverage ) ) 4833 goto Fail3; 4834 4835 l = ccpf3->LookaheadCoverage; 4836 4837 for ( nl = 0; nl < lookahead_count; nl++ ) 4838 { 4839 if ( ACCESS_Frame( 2L ) ) 4840 goto Fail2; 4841 4842 new_offset = GET_UShort() + base_offset; 4843 4844 FORGET_Frame(); 4845 4846 cur_offset = FILE_Pos(); 4847 if ( FILE_Seek( new_offset ) || 4848 ( error = _HB_OPEN_Load_Coverage( &l[nl], stream ) ) != HB_Err_Ok ) 4849 goto Fail2; 4850 (void)FILE_Seek( cur_offset ); 4851 } 4852 4853 if ( ACCESS_Frame( 2L ) ) 4854 goto Fail2; 4855 4856 ccpf3->PosCount = GET_UShort(); 4857 4858 FORGET_Frame(); 4859 4860 ccpf3->PosLookupRecord = NULL; 4861 4862 count = ccpf3->PosCount; 4863 4864 if ( ALLOC_ARRAY( ccpf3->PosLookupRecord, count, HB_PosLookupRecord ) ) 4865 goto Fail2; 4866 4867 plr = ccpf3->PosLookupRecord; 4868 4869 if ( ACCESS_Frame( count * 4L ) ) 4870 goto Fail1; 4871 4872 for ( n = 0; n < count; n++ ) 4873 { 4874 plr[n].SequenceIndex = GET_UShort(); 4875 plr[n].LookupListIndex = GET_UShort(); 4876 } 4877 4878 FORGET_Frame(); 4879 4880 return HB_Err_Ok; 4881 4882 Fail1: 4883 FREE( plr ); 4884 4885 Fail2: 4886 for ( m = 0; m < nl; m++ ) 4887 _HB_OPEN_Free_Coverage( &l[m] ); 4888 4889 FREE( l ); 4890 4891 Fail3: 4892 for ( m = 0; m < ni; m++ ) 4893 _HB_OPEN_Free_Coverage( &i[m] ); 4894 4895 FREE( i ); 4896 4897 Fail4: 4898 for ( m = 0; m < nb; m++ ) 4899 _HB_OPEN_Free_Coverage( &b[m] ); 4900 4901 FREE( b ); 4902 return error; 4903 } 4904 4905 4906 static void Free_ChainContextPos3( HB_ChainContextPosFormat3* ccpf3 ) 4907 { 4908 HB_UShort n, count; 4909 4910 HB_Coverage* c; 4911 4912 4913 FREE( ccpf3->PosLookupRecord ); 4914 4915 if ( ccpf3->LookaheadCoverage ) 4916 { 4917 count = ccpf3->LookaheadGlyphCount; 4918 c = ccpf3->LookaheadCoverage; 4919 4920 for ( n = 0; n < count; n++ ) 4921 _HB_OPEN_Free_Coverage( &c[n] ); 4922 4923 FREE( c ); 4924 } 4925 4926 if ( ccpf3->InputCoverage ) 4927 { 4928 count = ccpf3->InputGlyphCount; 4929 c = ccpf3->InputCoverage; 4930 4931 for ( n = 0; n < count; n++ ) 4932 _HB_OPEN_Free_Coverage( &c[n] ); 4933 4934 FREE( c ); 4935 } 4936 4937 if ( ccpf3->BacktrackCoverage ) 4938 { 4939 count = ccpf3->BacktrackGlyphCount; 4940 c = ccpf3->BacktrackCoverage; 4941 4942 for ( n = 0; n < count; n++ ) 4943 _HB_OPEN_Free_Coverage( &c[n] ); 4944 4945 FREE( c ); 4946 } 4947 } 4948 4949 4950 /* ChainContextPos */ 4951 4952 static HB_Error Load_ChainContextPos( HB_GPOS_SubTable* st, 4953 HB_Stream stream ) 4954 { 4955 HB_Error error; 4956 HB_ChainContextPos* ccp = &st->chain; 4957 4958 4959 if ( ACCESS_Frame( 2L ) ) 4960 return error; 4961 4962 ccp->PosFormat = GET_UShort(); 4963 4964 FORGET_Frame(); 4965 4966 switch ( ccp->PosFormat ) 4967 { 4968 case 1: 4969 return Load_ChainContextPos1( &ccp->ccpf.ccpf1, stream ); 4970 4971 case 2: 4972 return Load_ChainContextPos2( &ccp->ccpf.ccpf2, stream ); 4973 4974 case 3: 4975 return Load_ChainContextPos3( &ccp->ccpf.ccpf3, stream ); 4976 4977 default: 4978 return ERR(HB_Err_Invalid_SubTable_Format); 4979 } 4980 4981 return HB_Err_Ok; /* never reached */ 4982 } 4983 4984 4985 static void Free_ChainContextPos( HB_GPOS_SubTable* st ) 4986 { 4987 HB_ChainContextPos* ccp = &st->chain; 4988 4989 switch ( ccp->PosFormat ) 4990 { 4991 case 1: Free_ChainContextPos1( &ccp->ccpf.ccpf1 ); break; 4992 case 2: Free_ChainContextPos2( &ccp->ccpf.ccpf2 ); break; 4993 case 3: Free_ChainContextPos3( &ccp->ccpf.ccpf3 ); break; 4994 default: break; 4995 } 4996 } 4997 4998 4999 static HB_Error Lookup_ChainContextPos1( 5000 GPOS_Instance* gpi, 5001 HB_ChainContextPosFormat1* ccpf1, 5002 HB_Buffer buffer, 5003 HB_UShort flags, 5004 HB_UShort context_length, 5005 int nesting_level ) 5006 { 5007 HB_UShort index, property; 5008 HB_UShort i, j, k, num_cpr; 5009 HB_UShort bgc, igc, lgc; 5010 HB_Error error; 5011 HB_GPOSHeader* gpos = gpi->gpos; 5012 5013 HB_ChainPosRule* cpr; 5014 HB_ChainPosRule curr_cpr; 5015 HB_GDEFHeader* gdef; 5016 5017 5018 gdef = gpos->gdef; 5019 5020 if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) ) 5021 return error; 5022 5023 error = _HB_OPEN_Coverage_Index( &ccpf1->Coverage, IN_CURGLYPH(), &index ); 5024 if ( error ) 5025 return error; 5026 5027 cpr = ccpf1->ChainPosRuleSet[index].ChainPosRule; 5028 num_cpr = ccpf1->ChainPosRuleSet[index].ChainPosRuleCount; 5029 5030 for ( k = 0; k < num_cpr; k++ ) 5031 { 5032 curr_cpr = cpr[k]; 5033 bgc = curr_cpr.BacktrackGlyphCount; 5034 igc = curr_cpr.InputGlyphCount; 5035 lgc = curr_cpr.LookaheadGlyphCount; 5036 5037 if ( context_length != 0xFFFF && context_length < igc ) 5038 goto next_chainposrule; 5039 5040 /* check whether context is too long; it is a first guess only */ 5041 5042 if ( bgc > buffer->in_pos || buffer->in_pos + igc + lgc > buffer->in_length ) 5043 goto next_chainposrule; 5044 5045 if ( bgc ) 5046 { 5047 /* Since we don't know in advance the number of glyphs to inspect, 5048 we search backwards for matches in the backtrack glyph array */ 5049 5050 for ( i = 0, j = buffer->in_pos - 1; i < bgc; i++, j-- ) 5051 { 5052 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5053 { 5054 if ( error && error != HB_Err_Not_Covered ) 5055 return error; 5056 5057 if ( j + 1 == bgc - i ) 5058 goto next_chainposrule; 5059 j--; 5060 } 5061 5062 /* In OpenType 1.3, it is undefined whether the offsets of 5063 backtrack glyphs is in logical order or not. Version 1.4 5064 will clarify this: 5065 5066 Logical order - a b c d e f g h i j 5067 i 5068 Input offsets - 0 1 5069 Backtrack offsets - 3 2 1 0 5070 Lookahead offsets - 0 1 2 3 */ 5071 5072 if ( IN_GLYPH( j ) != curr_cpr.Backtrack[i] ) 5073 goto next_chainposrule; 5074 } 5075 } 5076 5077 /* Start at 1 because [0] is implied */ 5078 5079 for ( i = 1, j = buffer->in_pos + 1; i < igc; i++, j++ ) 5080 { 5081 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5082 { 5083 if ( error && error != HB_Err_Not_Covered ) 5084 return error; 5085 5086 if ( j + igc - i + lgc == (HB_Int)buffer->in_length ) 5087 goto next_chainposrule; 5088 j++; 5089 } 5090 5091 if ( IN_GLYPH( j ) != curr_cpr.Input[i - 1] ) 5092 goto next_chainposrule; 5093 } 5094 5095 /* we are starting to check for lookahead glyphs right after the 5096 last context glyph */ 5097 5098 for ( i = 0; i < lgc; i++, j++ ) 5099 { 5100 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5101 { 5102 if ( error && error != HB_Err_Not_Covered ) 5103 return error; 5104 5105 if ( j + lgc - i == (HB_Int)buffer->in_length ) 5106 goto next_chainposrule; 5107 j++; 5108 } 5109 5110 if ( IN_GLYPH( j ) != curr_cpr.Lookahead[i] ) 5111 goto next_chainposrule; 5112 } 5113 5114 return Do_ContextPos( gpi, igc, 5115 curr_cpr.PosCount, 5116 curr_cpr.PosLookupRecord, 5117 buffer, 5118 nesting_level ); 5119 5120 next_chainposrule: 5121 ; 5122 } 5123 5124 return HB_Err_Not_Covered; 5125 } 5126 5127 5128 static HB_Error Lookup_ChainContextPos2( 5129 GPOS_Instance* gpi, 5130 HB_ChainContextPosFormat2* ccpf2, 5131 HB_Buffer buffer, 5132 HB_UShort flags, 5133 HB_UShort context_length, 5134 int nesting_level ) 5135 { 5136 HB_UShort index, property; 5137 HB_Error error; 5138 HB_UShort i, j, k; 5139 HB_UShort bgc, igc, lgc; 5140 HB_UShort known_backtrack_classes, 5141 known_input_classes, 5142 known_lookahead_classes; 5143 5144 HB_UShort* backtrack_classes; 5145 HB_UShort* input_classes; 5146 HB_UShort* lookahead_classes; 5147 5148 HB_UShort* bc; 5149 HB_UShort* ic; 5150 HB_UShort* lc; 5151 HB_GPOSHeader* gpos = gpi->gpos; 5152 5153 HB_ChainPosClassSet* cpcs; 5154 HB_ChainPosClassRule cpcr; 5155 HB_GDEFHeader* gdef; 5156 5157 5158 gdef = gpos->gdef; 5159 5160 if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) ) 5161 return error; 5162 5163 /* Note: The coverage table in format 2 doesn't give an index into 5164 anything. It just lets us know whether or not we need to 5165 do any lookup at all. */ 5166 5167 error = _HB_OPEN_Coverage_Index( &ccpf2->Coverage, IN_CURGLYPH(), &index ); 5168 if ( error ) 5169 return error; 5170 5171 if ( ALLOC_ARRAY( backtrack_classes, ccpf2->MaxBacktrackLength, HB_UShort ) ) 5172 return error; 5173 known_backtrack_classes = 0; 5174 5175 if (ccpf2->MaxInputLength < 1) 5176 return HB_Err_Not_Covered; 5177 5178 if ( ALLOC_ARRAY( input_classes, ccpf2->MaxInputLength, HB_UShort ) ) 5179 goto End3; 5180 known_input_classes = 1; 5181 5182 if ( ALLOC_ARRAY( lookahead_classes, ccpf2->MaxLookaheadLength, HB_UShort ) ) 5183 goto End2; 5184 known_lookahead_classes = 0; 5185 5186 error = _HB_OPEN_Get_Class( &ccpf2->InputClassDef, IN_CURGLYPH(), 5187 &input_classes[0], NULL ); 5188 if ( error && error != HB_Err_Not_Covered ) 5189 goto End1; 5190 5191 cpcs = &ccpf2->ChainPosClassSet[input_classes[0]]; 5192 if ( !cpcs ) 5193 { 5194 error = ERR(HB_Err_Invalid_SubTable); 5195 goto End1; 5196 } 5197 5198 for ( k = 0; k < cpcs->ChainPosClassRuleCount; k++ ) 5199 { 5200 cpcr = cpcs->ChainPosClassRule[k]; 5201 bgc = cpcr.BacktrackGlyphCount; 5202 igc = cpcr.InputGlyphCount; 5203 lgc = cpcr.LookaheadGlyphCount; 5204 5205 if ( context_length != 0xFFFF && context_length < igc ) 5206 goto next_chainposclassrule; 5207 5208 /* check whether context is too long; it is a first guess only */ 5209 5210 if ( bgc > buffer->in_pos || buffer->in_pos + igc + lgc > buffer->in_length ) 5211 goto next_chainposclassrule; 5212 5213 if ( bgc ) 5214 { 5215 /* Since we don't know in advance the number of glyphs to inspect, 5216 we search backwards for matches in the backtrack glyph array. 5217 Note that `known_backtrack_classes' starts at index 0. */ 5218 5219 bc = cpcr.Backtrack; 5220 5221 for ( i = 0, j = buffer->in_pos - 1; i < bgc; i++, j-- ) 5222 { 5223 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5224 { 5225 if ( error && error != HB_Err_Not_Covered ) 5226 goto End1; 5227 5228 if ( j + 1 == bgc - i ) 5229 goto next_chainposclassrule; 5230 j++; 5231 } 5232 5233 if ( i >= known_backtrack_classes ) 5234 { 5235 /* Keeps us from having to do this for each rule */ 5236 5237 error = _HB_OPEN_Get_Class( &ccpf2->BacktrackClassDef, IN_GLYPH( j ), 5238 &backtrack_classes[i], NULL ); 5239 if ( error && error != HB_Err_Not_Covered ) 5240 goto End1; 5241 known_backtrack_classes = i; 5242 } 5243 5244 if ( bc[i] != backtrack_classes[i] ) 5245 goto next_chainposclassrule; 5246 } 5247 } 5248 5249 ic = cpcr.Input; 5250 5251 /* Start at 1 because [0] is implied */ 5252 5253 for ( i = 1, j = buffer->in_pos + 1; i < igc; i++, j++ ) 5254 { 5255 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5256 { 5257 if ( error && error != HB_Err_Not_Covered ) 5258 goto End1; 5259 5260 if ( j + igc - i + lgc == (HB_Int)buffer->in_length ) 5261 goto next_chainposclassrule; 5262 j++; 5263 } 5264 5265 if ( i >= known_input_classes ) 5266 { 5267 error = _HB_OPEN_Get_Class( &ccpf2->InputClassDef, IN_GLYPH( j ), 5268 &input_classes[i], NULL ); 5269 if ( error && error != HB_Err_Not_Covered ) 5270 goto End1; 5271 known_input_classes = i; 5272 } 5273 5274 if ( ic[i - 1] != input_classes[i] ) 5275 goto next_chainposclassrule; 5276 } 5277 5278 /* we are starting to check for lookahead glyphs right after the 5279 last context glyph */ 5280 5281 lc = cpcr.Lookahead; 5282 5283 for ( i = 0; i < lgc; i++, j++ ) 5284 { 5285 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5286 { 5287 if ( error && error != HB_Err_Not_Covered ) 5288 goto End1; 5289 5290 if ( j + lgc - i == (HB_Int)buffer->in_length ) 5291 goto next_chainposclassrule; 5292 j++; 5293 } 5294 5295 if ( i >= known_lookahead_classes ) 5296 { 5297 error = _HB_OPEN_Get_Class( &ccpf2->LookaheadClassDef, IN_GLYPH( j ), 5298 &lookahead_classes[i], NULL ); 5299 if ( error && error != HB_Err_Not_Covered ) 5300 goto End1; 5301 known_lookahead_classes = i; 5302 } 5303 5304 if ( lc[i] != lookahead_classes[i] ) 5305 goto next_chainposclassrule; 5306 } 5307 5308 error = Do_ContextPos( gpi, igc, 5309 cpcr.PosCount, 5310 cpcr.PosLookupRecord, 5311 buffer, 5312 nesting_level ); 5313 goto End1; 5314 5315 next_chainposclassrule: 5316 ; 5317 } 5318 5319 error = HB_Err_Not_Covered; 5320 5321 End1: 5322 FREE( lookahead_classes ); 5323 5324 End2: 5325 FREE( input_classes ); 5326 5327 End3: 5328 FREE( backtrack_classes ); 5329 return error; 5330 } 5331 5332 5333 static HB_Error Lookup_ChainContextPos3( 5334 GPOS_Instance* gpi, 5335 HB_ChainContextPosFormat3* ccpf3, 5336 HB_Buffer buffer, 5337 HB_UShort flags, 5338 HB_UShort context_length, 5339 int nesting_level ) 5340 { 5341 HB_UShort index, i, j, property; 5342 HB_UShort bgc, igc, lgc; 5343 HB_Error error; 5344 HB_GPOSHeader* gpos = gpi->gpos; 5345 5346 HB_Coverage* bc; 5347 HB_Coverage* ic; 5348 HB_Coverage* lc; 5349 HB_GDEFHeader* gdef; 5350 5351 5352 gdef = gpos->gdef; 5353 5354 if ( CHECK_Property( gdef, IN_CURITEM(), flags, &property ) ) 5355 return error; 5356 5357 bgc = ccpf3->BacktrackGlyphCount; 5358 igc = ccpf3->InputGlyphCount; 5359 lgc = ccpf3->LookaheadGlyphCount; 5360 5361 if ( context_length != 0xFFFF && context_length < igc ) 5362 return HB_Err_Not_Covered; 5363 5364 /* check whether context is too long; it is a first guess only */ 5365 5366 if ( bgc > buffer->in_pos || buffer->in_pos + igc + lgc > buffer->in_length ) 5367 return HB_Err_Not_Covered; 5368 5369 if ( bgc ) 5370 { 5371 /* Since we don't know in advance the number of glyphs to inspect, 5372 we search backwards for matches in the backtrack glyph array */ 5373 5374 bc = ccpf3->BacktrackCoverage; 5375 5376 for ( i = 0, j = buffer->in_pos - 1; i < bgc; i++, j-- ) 5377 { 5378 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5379 { 5380 if ( error && error != HB_Err_Not_Covered ) 5381 return error; 5382 5383 if ( j + 1 == bgc - i ) 5384 return HB_Err_Not_Covered; 5385 j--; 5386 } 5387 5388 error = _HB_OPEN_Coverage_Index( &bc[i], IN_GLYPH( j ), &index ); 5389 if ( error ) 5390 return error; 5391 } 5392 } 5393 5394 ic = ccpf3->InputCoverage; 5395 5396 for ( i = 0, j = buffer->in_pos; i < igc; i++, j++ ) 5397 { 5398 /* We already called CHECK_Property for IN_GLYPH ( buffer->in_pos ) */ 5399 while ( j > buffer->in_pos && CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5400 { 5401 if ( error && error != HB_Err_Not_Covered ) 5402 return error; 5403 5404 if ( j + igc - i + lgc == (HB_Int)buffer->in_length ) 5405 return HB_Err_Not_Covered; 5406 j++; 5407 } 5408 5409 error = _HB_OPEN_Coverage_Index( &ic[i], IN_GLYPH( j ), &index ); 5410 if ( error ) 5411 return error; 5412 } 5413 5414 /* we are starting to check for lookahead glyphs right after the 5415 last context glyph */ 5416 5417 lc = ccpf3->LookaheadCoverage; 5418 5419 for ( i = 0; i < lgc; i++, j++ ) 5420 { 5421 while ( CHECK_Property( gdef, IN_ITEM( j ), flags, &property ) ) 5422 { 5423 if ( error && error != HB_Err_Not_Covered ) 5424 return error; 5425 5426 if ( j + lgc - i == (HB_Int)buffer->in_length ) 5427 return HB_Err_Not_Covered; 5428 j++; 5429 } 5430 5431 error = _HB_OPEN_Coverage_Index( &lc[i], IN_GLYPH( j ), &index ); 5432 if ( error ) 5433 return error; 5434 } 5435 5436 return Do_ContextPos( gpi, igc, 5437 ccpf3->PosCount, 5438 ccpf3->PosLookupRecord, 5439 buffer, 5440 nesting_level ); 5441 } 5442 5443 5444 static HB_Error Lookup_ChainContextPos( 5445 GPOS_Instance* gpi, 5446 HB_GPOS_SubTable* st, 5447 HB_Buffer buffer, 5448 HB_UShort flags, 5449 HB_UShort context_length, 5450 int nesting_level ) 5451 { 5452 HB_ChainContextPos* ccp = &st->chain; 5453 5454 switch ( ccp->PosFormat ) 5455 { 5456 case 1: 5457 return Lookup_ChainContextPos1( gpi, &ccp->ccpf.ccpf1, buffer, 5458 flags, context_length, 5459 nesting_level ); 5460 5461 case 2: 5462 return Lookup_ChainContextPos2( gpi, &ccp->ccpf.ccpf2, buffer, 5463 flags, context_length, 5464 nesting_level ); 5465 5466 case 3: 5467 return Lookup_ChainContextPos3( gpi, &ccp->ccpf.ccpf3, buffer, 5468 flags, context_length, 5469 nesting_level ); 5470 5471 default: 5472 return ERR(HB_Err_Invalid_SubTable_Format); 5473 } 5474 5475 return HB_Err_Ok; /* never reached */ 5476 } 5477 5478 5479 5480 /*********** 5481 * GPOS API 5482 ***********/ 5483 5484 5485 5486 HB_Error HB_GPOS_Select_Script( HB_GPOSHeader* gpos, 5487 HB_UInt script_tag, 5488 HB_UShort* script_index ) 5489 { 5490 HB_UShort n; 5491 5492 HB_ScriptList* sl; 5493 HB_ScriptRecord* sr; 5494 5495 5496 if ( !gpos || !script_index ) 5497 return ERR(HB_Err_Invalid_Argument); 5498 5499 sl = &gpos->ScriptList; 5500 sr = sl->ScriptRecord; 5501 5502 for ( n = 0; n < sl->ScriptCount; n++ ) 5503 if ( script_tag == sr[n].ScriptTag ) 5504 { 5505 *script_index = n; 5506 5507 return HB_Err_Ok; 5508 } 5509 5510 return HB_Err_Not_Covered; 5511 } 5512 5513 5514 5515 HB_Error HB_GPOS_Select_Language( HB_GPOSHeader* gpos, 5516 HB_UInt language_tag, 5517 HB_UShort script_index, 5518 HB_UShort* language_index, 5519 HB_UShort* req_feature_index ) 5520 { 5521 HB_UShort n; 5522 5523 HB_ScriptList* sl; 5524 HB_ScriptRecord* sr; 5525 HB_ScriptTable* s; 5526 HB_LangSysRecord* lsr; 5527 5528 5529 if ( !gpos || !language_index || !req_feature_index ) 5530 return ERR(HB_Err_Invalid_Argument); 5531 5532 sl = &gpos->ScriptList; 5533 sr = sl->ScriptRecord; 5534 5535 if ( script_index >= sl->ScriptCount ) 5536 return ERR(HB_Err_Invalid_Argument); 5537 5538 s = &sr[script_index].Script; 5539 lsr = s->LangSysRecord; 5540 5541 for ( n = 0; n < s->LangSysCount; n++ ) 5542 if ( language_tag == lsr[n].LangSysTag ) 5543 { 5544 *language_index = n; 5545 *req_feature_index = lsr[n].LangSys.ReqFeatureIndex; 5546 5547 return HB_Err_Ok; 5548 } 5549 5550 return HB_Err_Not_Covered; 5551 } 5552 5553 5554 /* selecting 0xFFFF for language_index asks for the values of the 5555 default language (DefaultLangSys) */ 5556 5557 5558 HB_Error HB_GPOS_Select_Feature( HB_GPOSHeader* gpos, 5559 HB_UInt feature_tag, 5560 HB_UShort script_index, 5561 HB_UShort language_index, 5562 HB_UShort* feature_index ) 5563 { 5564 HB_UShort n; 5565 5566 HB_ScriptList* sl; 5567 HB_ScriptRecord* sr; 5568 HB_ScriptTable* s; 5569 HB_LangSysRecord* lsr; 5570 HB_LangSys* ls; 5571 HB_UShort* fi; 5572 5573 HB_FeatureList* fl; 5574 HB_FeatureRecord* fr; 5575 5576 5577 if ( !gpos || !feature_index ) 5578 return ERR(HB_Err_Invalid_Argument); 5579 5580 sl = &gpos->ScriptList; 5581 sr = sl->ScriptRecord; 5582 5583 fl = &gpos->FeatureList; 5584 fr = fl->FeatureRecord; 5585 5586 if ( script_index >= sl->ScriptCount ) 5587 return ERR(HB_Err_Invalid_Argument); 5588 5589 s = &sr[script_index].Script; 5590 lsr = s->LangSysRecord; 5591 5592 if ( language_index == 0xFFFF ) 5593 ls = &s->DefaultLangSys; 5594 else 5595 { 5596 if ( language_index >= s->LangSysCount ) 5597 return ERR(HB_Err_Invalid_Argument); 5598 5599 ls = &lsr[language_index].LangSys; 5600 } 5601 5602 fi = ls->FeatureIndex; 5603 5604 for ( n = 0; n < ls->FeatureCount; n++ ) 5605 { 5606 if ( fi[n] >= fl->FeatureCount ) 5607 return ERR(HB_Err_Invalid_SubTable_Format); 5608 5609 if ( feature_tag == fr[fi[n]].FeatureTag ) 5610 { 5611 *feature_index = fi[n]; 5612 5613 return HB_Err_Ok; 5614 } 5615 } 5616 5617 return HB_Err_Not_Covered; 5618 } 5619 5620 5621 /* The next three functions return a null-terminated list */ 5622 5623 5624 HB_Error HB_GPOS_Query_Scripts( HB_GPOSHeader* gpos, 5625 HB_UInt** script_tag_list ) 5626 { 5627 HB_Error error; 5628 HB_UShort n; 5629 HB_UInt* stl; 5630 5631 HB_ScriptList* sl; 5632 HB_ScriptRecord* sr; 5633 5634 5635 if ( !gpos || !script_tag_list ) 5636 return ERR(HB_Err_Invalid_Argument); 5637 5638 sl = &gpos->ScriptList; 5639 sr = sl->ScriptRecord; 5640 5641 if ( ALLOC_ARRAY( stl, sl->ScriptCount + 1, HB_UInt ) ) 5642 return error; 5643 5644 for ( n = 0; n < sl->ScriptCount; n++ ) 5645 stl[n] = sr[n].ScriptTag; 5646 stl[n] = 0; 5647 5648 *script_tag_list = stl; 5649 5650 return HB_Err_Ok; 5651 } 5652 5653 5654 5655 HB_Error HB_GPOS_Query_Languages( HB_GPOSHeader* gpos, 5656 HB_UShort script_index, 5657 HB_UInt** language_tag_list ) 5658 { 5659 HB_Error error; 5660 HB_UShort n; 5661 HB_UInt* ltl; 5662 5663 HB_ScriptList* sl; 5664 HB_ScriptRecord* sr; 5665 HB_ScriptTable* s; 5666 HB_LangSysRecord* lsr; 5667 5668 5669 if ( !gpos || !language_tag_list ) 5670 return ERR(HB_Err_Invalid_Argument); 5671 5672 sl = &gpos->ScriptList; 5673 sr = sl->ScriptRecord; 5674 5675 if ( script_index >= sl->ScriptCount ) 5676 return ERR(HB_Err_Invalid_Argument); 5677 5678 s = &sr[script_index].Script; 5679 lsr = s->LangSysRecord; 5680 5681 if ( ALLOC_ARRAY( ltl, s->LangSysCount + 1, HB_UInt ) ) 5682 return error; 5683 5684 for ( n = 0; n < s->LangSysCount; n++ ) 5685 ltl[n] = lsr[n].LangSysTag; 5686 ltl[n] = 0; 5687 5688 *language_tag_list = ltl; 5689 5690 return HB_Err_Ok; 5691 } 5692 5693 5694 /* selecting 0xFFFF for language_index asks for the values of the 5695 default language (DefaultLangSys) */ 5696 5697 5698 HB_Error HB_GPOS_Query_Features( HB_GPOSHeader* gpos, 5699 HB_UShort script_index, 5700 HB_UShort language_index, 5701 HB_UInt** feature_tag_list ) 5702 { 5703 HB_UShort n; 5704 HB_Error error; 5705 HB_UInt* ftl; 5706 5707 HB_ScriptList* sl; 5708 HB_ScriptRecord* sr; 5709 HB_ScriptTable* s; 5710 HB_LangSysRecord* lsr; 5711 HB_LangSys* ls; 5712 HB_UShort* fi; 5713 5714 HB_FeatureList* fl; 5715 HB_FeatureRecord* fr; 5716 5717 5718 if ( !gpos || !feature_tag_list ) 5719 return ERR(HB_Err_Invalid_Argument); 5720 5721 sl = &gpos->ScriptList; 5722 sr = sl->ScriptRecord; 5723 5724 fl = &gpos->FeatureList; 5725 fr = fl->FeatureRecord; 5726 5727 if ( script_index >= sl->ScriptCount ) 5728 return ERR(HB_Err_Invalid_Argument); 5729 5730 s = &sr[script_index].Script; 5731 lsr = s->LangSysRecord; 5732 5733 if ( language_index == 0xFFFF ) 5734 ls = &s->DefaultLangSys; 5735 else 5736 { 5737 if ( language_index >= s->LangSysCount ) 5738 return ERR(HB_Err_Invalid_Argument); 5739 5740 ls = &lsr[language_index].LangSys; 5741 } 5742 5743 fi = ls->FeatureIndex; 5744 5745 if ( ALLOC_ARRAY( ftl, ls->FeatureCount + 1, HB_UInt ) ) 5746 return error; 5747 5748 for ( n = 0; n < ls->FeatureCount; n++ ) 5749 { 5750 if ( fi[n] >= fl->FeatureCount ) 5751 { 5752 FREE( ftl ); 5753 return ERR(HB_Err_Invalid_SubTable_Format); 5754 } 5755 ftl[n] = fr[fi[n]].FeatureTag; 5756 } 5757 ftl[n] = 0; 5758 5759 *feature_tag_list = ftl; 5760 5761 return HB_Err_Ok; 5762 } 5763 5764 5765 /* Do an individual subtable lookup. Returns HB_Err_Ok if positioning 5766 has been done, or HB_Err_Not_Covered if not. */ 5767 static HB_Error GPOS_Do_Glyph_Lookup( GPOS_Instance* gpi, 5768 HB_UShort lookup_index, 5769 HB_Buffer buffer, 5770 HB_UShort context_length, 5771 int nesting_level ) 5772 { 5773 HB_Error error = HB_Err_Not_Covered; 5774 HB_UShort i, flags, lookup_count; 5775 HB_GPOSHeader* gpos = gpi->gpos; 5776 HB_Lookup* lo; 5777 int lookup_type; 5778 5779 5780 nesting_level++; 5781 5782 if ( nesting_level > HB_MAX_NESTING_LEVEL ) 5783 return ERR(HB_Err_Not_Covered); /* ERR() call intended */ 5784 5785 lookup_count = gpos->LookupList.LookupCount; 5786 if (lookup_index >= lookup_count) 5787 return error; 5788 5789 lo = &gpos->LookupList.Lookup[lookup_index]; 5790 flags = lo->LookupFlag; 5791 lookup_type = lo->LookupType; 5792 5793 for ( i = 0; i < lo->SubTableCount; i++ ) 5794 { 5795 HB_GPOS_SubTable *st = &lo->SubTable[i].st.gpos; 5796 5797 switch (lookup_type) { 5798 case HB_GPOS_LOOKUP_SINGLE: 5799 error = Lookup_SinglePos ( gpi, st, buffer, flags, context_length, nesting_level ); break; 5800 case HB_GPOS_LOOKUP_PAIR: 5801 error = Lookup_PairPos ( gpi, st, buffer, flags, context_length, nesting_level ); break; 5802 case HB_GPOS_LOOKUP_CURSIVE: 5803 error = Lookup_CursivePos ( gpi, st, buffer, flags, context_length, nesting_level ); break; 5804 case HB_GPOS_LOOKUP_MARKBASE: 5805 error = Lookup_MarkBasePos ( gpi, st, buffer, flags, context_length, nesting_level ); break; 5806 case HB_GPOS_LOOKUP_MARKLIG: 5807 error = Lookup_MarkLigPos ( gpi, st, buffer, flags, context_length, nesting_level ); break; 5808 case HB_GPOS_LOOKUP_MARKMARK: 5809 error = Lookup_MarkMarkPos ( gpi, st, buffer, flags, context_length, nesting_level ); break; 5810 case HB_GPOS_LOOKUP_CONTEXT: 5811 error = Lookup_ContextPos ( gpi, st, buffer, flags, context_length, nesting_level ); break; 5812 case HB_GPOS_LOOKUP_CHAIN: 5813 error = Lookup_ChainContextPos ( gpi, st, buffer, flags, context_length, nesting_level ); break; 5814 /*case HB_GPOS_LOOKUP_EXTENSION: 5815 error = Lookup_ExtensionPos ( gpi, st, buffer, flags, context_length, nesting_level ); break;*/ 5816 default: 5817 error = HB_Err_Not_Covered; 5818 } 5819 5820 /* Check whether we have a successful positioning or an error other 5821 than HB_Err_Not_Covered */ 5822 if ( error != HB_Err_Not_Covered ) 5823 return error; 5824 } 5825 5826 return HB_Err_Not_Covered; 5827 } 5828 5829 5830 HB_INTERNAL HB_Error 5831 _HB_GPOS_Load_SubTable( HB_GPOS_SubTable* st, 5832 HB_Stream stream, 5833 HB_UShort lookup_type ) 5834 { 5835 switch ( lookup_type ) { 5836 case HB_GPOS_LOOKUP_SINGLE: return Load_SinglePos ( st, stream ); 5837 case HB_GPOS_LOOKUP_PAIR: return Load_PairPos ( st, stream ); 5838 case HB_GPOS_LOOKUP_CURSIVE: return Load_CursivePos ( st, stream ); 5839 case HB_GPOS_LOOKUP_MARKBASE: return Load_MarkBasePos ( st, stream ); 5840 case HB_GPOS_LOOKUP_MARKLIG: return Load_MarkLigPos ( st, stream ); 5841 case HB_GPOS_LOOKUP_MARKMARK: return Load_MarkMarkPos ( st, stream ); 5842 case HB_GPOS_LOOKUP_CONTEXT: return Load_ContextPos ( st, stream ); 5843 case HB_GPOS_LOOKUP_CHAIN: return Load_ChainContextPos ( st, stream ); 5844 /*case HB_GPOS_LOOKUP_EXTENSION: return Load_ExtensionPos ( st, stream );*/ 5845 default: return ERR(HB_Err_Invalid_SubTable_Format); 5846 } 5847 } 5848 5849 5850 HB_INTERNAL void 5851 _HB_GPOS_Free_SubTable( HB_GPOS_SubTable* st, 5852 HB_UShort lookup_type ) 5853 { 5854 switch ( lookup_type ) { 5855 case HB_GPOS_LOOKUP_SINGLE: Free_SinglePos ( st ); return; 5856 case HB_GPOS_LOOKUP_PAIR: Free_PairPos ( st ); return; 5857 case HB_GPOS_LOOKUP_CURSIVE: Free_CursivePos ( st ); return; 5858 case HB_GPOS_LOOKUP_MARKBASE: Free_MarkBasePos ( st ); return; 5859 case HB_GPOS_LOOKUP_MARKLIG: Free_MarkLigPos ( st ); return; 5860 case HB_GPOS_LOOKUP_MARKMARK: Free_MarkMarkPos ( st ); return; 5861 case HB_GPOS_LOOKUP_CONTEXT: Free_ContextPos ( st ); return; 5862 case HB_GPOS_LOOKUP_CHAIN: Free_ChainContextPos ( st ); return; 5863 /*case HB_GPOS_LOOKUP_EXTENSION: Free_ExtensionPos ( st ); return;*/ 5864 default: return; 5865 } 5866 } 5867 5868 5869 /* apply one lookup to the input string object */ 5870 5871 static HB_Error GPOS_Do_String_Lookup( GPOS_Instance* gpi, 5872 HB_UShort lookup_index, 5873 HB_Buffer buffer ) 5874 { 5875 HB_Error error, retError = HB_Err_Not_Covered; 5876 HB_GPOSHeader* gpos = gpi->gpos; 5877 5878 HB_UInt* properties = gpos->LookupList.Properties; 5879 5880 const int nesting_level = 0; 5881 /* 0xFFFF indicates that we don't have a context length yet */ 5882 const HB_UShort context_length = 0xFFFF; 5883 5884 5885 gpi->last = 0xFFFF; /* no last valid glyph for cursive pos. */ 5886 5887 buffer->in_pos = 0; 5888 while ( buffer->in_pos < buffer->in_length ) 5889 { 5890 if ( ~IN_PROPERTIES( buffer->in_pos ) & properties[lookup_index] ) 5891 { 5892 /* Note that the connection between mark and base glyphs hold 5893 exactly one (string) lookup. For example, it would be possible 5894 that in the first lookup, mark glyph X is attached to base 5895 glyph A, and in the next lookup it is attached to base glyph B. 5896 It is up to the font designer to provide meaningful lookups and 5897 lookup order. */ 5898 5899 error = GPOS_Do_Glyph_Lookup( gpi, lookup_index, buffer, context_length, nesting_level ); 5900 if ( error && error != HB_Err_Not_Covered ) 5901 return error; 5902 } 5903 else 5904 { 5905 /* Contrary to properties defined in GDEF, user-defined properties 5906 will always stop a possible cursive positioning. */ 5907 gpi->last = 0xFFFF; 5908 5909 error = HB_Err_Not_Covered; 5910 } 5911 5912 if ( error == HB_Err_Not_Covered ) 5913 (buffer->in_pos)++; 5914 else 5915 retError = error; 5916 } 5917 5918 return retError; 5919 } 5920 5921 5922 static HB_Error Position_CursiveChain ( HB_Buffer buffer ) 5923 { 5924 HB_UInt i, j; 5925 HB_Position positions = buffer->positions; 5926 5927 /* First handle all left-to-right connections */ 5928 for (j = 0; j < buffer->in_length; j++) 5929 { 5930 if (positions[j].cursive_chain > 0) 5931 positions[j].y_pos += positions[j - positions[j].cursive_chain].y_pos; 5932 } 5933 5934 /* Then handle all right-to-left connections */ 5935 for (i = buffer->in_length; i > 0; i--) 5936 { 5937 j = i - 1; 5938 5939 if (positions[j].cursive_chain < 0) 5940 positions[j].y_pos += positions[j - positions[j].cursive_chain].y_pos; 5941 } 5942 5943 return HB_Err_Ok; 5944 } 5945 5946 5947 HB_Error HB_GPOS_Add_Feature( HB_GPOSHeader* gpos, 5948 HB_UShort feature_index, 5949 HB_UInt property ) 5950 { 5951 HB_UShort i; 5952 5953 HB_Feature feature; 5954 HB_UInt* properties; 5955 HB_UShort* index; 5956 HB_UShort lookup_count; 5957 5958 /* Each feature can only be added once */ 5959 5960 if ( !gpos || 5961 feature_index >= gpos->FeatureList.FeatureCount || 5962 gpos->FeatureList.ApplyCount == gpos->FeatureList.FeatureCount ) 5963 return ERR(HB_Err_Invalid_Argument); 5964 5965 gpos->FeatureList.ApplyOrder[gpos->FeatureList.ApplyCount++] = feature_index; 5966 5967 properties = gpos->LookupList.Properties; 5968 5969 feature = gpos->FeatureList.FeatureRecord[feature_index].Feature; 5970 index = feature.LookupListIndex; 5971 lookup_count = gpos->LookupList.LookupCount; 5972 5973 for ( i = 0; i < feature.LookupListCount; i++ ) 5974 { 5975 HB_UShort lookup_index = index[i]; 5976 if (lookup_index < lookup_count) 5977 properties[lookup_index] |= property; 5978 } 5979 5980 return HB_Err_Ok; 5981 } 5982 5983 5984 5985 HB_Error HB_GPOS_Clear_Features( HB_GPOSHeader* gpos ) 5986 { 5987 HB_UShort i; 5988 5989 HB_UInt* properties; 5990 5991 5992 if ( !gpos ) 5993 return ERR(HB_Err_Invalid_Argument); 5994 5995 gpos->FeatureList.ApplyCount = 0; 5996 5997 properties = gpos->LookupList.Properties; 5998 5999 for ( i = 0; i < gpos->LookupList.LookupCount; i++ ) 6000 properties[i] = 0; 6001 6002 return HB_Err_Ok; 6003 } 6004 6005 #ifdef HB_SUPPORT_MULTIPLE_MASTER 6006 HB_Error HB_GPOS_Register_MM_Function( HB_GPOSHeader* gpos, 6007 HB_MMFunction mmfunc, 6008 void* data ) 6009 { 6010 if ( !gpos ) 6011 return ERR(HB_Err_Invalid_Argument); 6012 6013 gpos->mmfunc = mmfunc; 6014 gpos->data = data; 6015 6016 return HB_Err_Ok; 6017 } 6018 #endif 6019 6020 /* If `dvi' is TRUE, glyph contour points for anchor points and device 6021 tables are ignored -- you will get device independent values. */ 6022 6023 6024 HB_Error HB_GPOS_Apply_String( HB_Font font, 6025 HB_GPOSHeader* gpos, 6026 HB_UShort load_flags, 6027 HB_Buffer buffer, 6028 HB_Bool dvi, 6029 HB_Bool r2l ) 6030 { 6031 HB_Error error, retError = HB_Err_Not_Covered; 6032 GPOS_Instance gpi; 6033 int i, j, lookup_count, num_features; 6034 6035 if ( !font || !gpos || !buffer ) 6036 return ERR(HB_Err_Invalid_Argument); 6037 6038 if ( buffer->in_length == 0 ) 6039 return HB_Err_Not_Covered; 6040 6041 gpi.font = font; 6042 gpi.gpos = gpos; 6043 gpi.load_flags = load_flags; 6044 gpi.r2l = r2l; 6045 gpi.dvi = dvi; 6046 6047 lookup_count = gpos->LookupList.LookupCount; 6048 num_features = gpos->FeatureList.ApplyCount; 6049 6050 if ( num_features ) 6051 { 6052 error = _hb_buffer_clear_positions( buffer ); 6053 if ( error ) 6054 return error; 6055 } 6056 6057 for ( i = 0; i < num_features; i++ ) 6058 { 6059 HB_UShort feature_index = gpos->FeatureList.ApplyOrder[i]; 6060 HB_Feature feature = gpos->FeatureList.FeatureRecord[feature_index].Feature; 6061 6062 for ( j = 0; j < feature.LookupListCount; j++ ) 6063 { 6064 HB_UShort lookup_index = feature.LookupListIndex[j]; 6065 6066 /* Skip nonexistant lookups */ 6067 if (lookup_index >= lookup_count) 6068 continue; 6069 6070 error = GPOS_Do_String_Lookup( &gpi, lookup_index, buffer ); 6071 if ( error ) 6072 { 6073 if ( error != HB_Err_Not_Covered ) 6074 return error; 6075 } 6076 else 6077 retError = error; 6078 } 6079 } 6080 6081 if ( num_features ) 6082 { 6083 error = Position_CursiveChain ( buffer ); 6084 if ( error ) 6085 return error; 6086 } 6087 6088 return retError; 6089 } 6090 6091 /* END */ 6092
