1 /***************************************************************************/ 2 /* */ 3 /* otvgpos.c */ 4 /* */ 5 /* OpenType GPOS table validation (body). */ 6 /* */ 7 /* Copyright 2002, 2004, 2005, 2006, 2007, 2008 by */ 8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9 /* */ 10 /* This file is part of the FreeType project, and may only be used, */ 11 /* modified, and distributed under the terms of the FreeType project */ 12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13 /* this file you indicate that you have read the license and */ 14 /* understand and accept it fully. */ 15 /* */ 16 /***************************************************************************/ 17 18 19 #include "otvalid.h" 20 #include "otvcommn.h" 21 #include "otvgpos.h" 22 23 24 /*************************************************************************/ 25 /* */ 26 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 27 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 28 /* messages during execution. */ 29 /* */ 30 #undef FT_COMPONENT 31 #define FT_COMPONENT trace_otvgpos 32 33 34 static void 35 otv_Anchor_validate( FT_Bytes table, 36 OTV_Validator valid ); 37 38 static void 39 otv_MarkArray_validate( FT_Bytes table, 40 OTV_Validator valid ); 41 42 43 /*************************************************************************/ 44 /*************************************************************************/ 45 /***** *****/ 46 /***** UTILITY FUNCTIONS *****/ 47 /***** *****/ 48 /*************************************************************************/ 49 /*************************************************************************/ 50 51 #define BaseArrayFunc otv_x_sxy 52 #define LigatureAttachFunc otv_x_sxy 53 #define Mark2ArrayFunc otv_x_sxy 54 55 /* uses valid->extra1 (counter) */ 56 /* uses valid->extra2 (boolean to handle NULL anchor field) */ 57 58 static void otv_x_sxy(FT_Bytes table,OTV_Validator valid)59 otv_x_sxy( FT_Bytes table, 60 OTV_Validator valid ) 61 { 62 FT_Bytes p = table; 63 FT_UInt Count, count1, table_size; 64 65 66 OTV_ENTER; 67 68 OTV_LIMIT_CHECK( 2 ); 69 70 Count = FT_NEXT_USHORT( p ); 71 72 OTV_TRACE(( " (Count = %d)\n", Count )); 73 74 OTV_LIMIT_CHECK( Count * valid->extra1 * 2 ); 75 76 table_size = Count * valid->extra1 * 2 + 2; 77 78 for ( ; Count > 0; Count-- ) 79 for ( count1 = valid->extra1; count1 > 0; count1-- ) 80 { 81 OTV_OPTIONAL_TABLE( anchor_offset ); 82 83 84 OTV_OPTIONAL_OFFSET( anchor_offset ); 85 86 if ( valid->extra2 ) 87 { 88 OTV_SIZE_CHECK( anchor_offset ); 89 if ( anchor_offset ) 90 otv_Anchor_validate( table + anchor_offset, valid ); 91 } 92 else 93 otv_Anchor_validate( table + anchor_offset, valid ); 94 } 95 96 OTV_EXIT; 97 } 98 99 100 #define MarkBasePosFormat1Func otv_u_O_O_u_O_O 101 #define MarkLigPosFormat1Func otv_u_O_O_u_O_O 102 #define MarkMarkPosFormat1Func otv_u_O_O_u_O_O 103 104 /* sets valid->extra1 (class count) */ 105 106 static void otv_u_O_O_u_O_O(FT_Bytes table,OTV_Validator valid)107 otv_u_O_O_u_O_O( FT_Bytes table, 108 OTV_Validator valid ) 109 { 110 FT_Bytes p = table; 111 FT_UInt Coverage1, Coverage2, ClassCount; 112 FT_UInt Array1, Array2; 113 OTV_Validate_Func func; 114 115 116 OTV_ENTER; 117 118 p += 2; /* skip PosFormat */ 119 120 OTV_LIMIT_CHECK( 10 ); 121 Coverage1 = FT_NEXT_USHORT( p ); 122 Coverage2 = FT_NEXT_USHORT( p ); 123 ClassCount = FT_NEXT_USHORT( p ); 124 Array1 = FT_NEXT_USHORT( p ); 125 Array2 = FT_NEXT_USHORT( p ); 126 127 otv_Coverage_validate( table + Coverage1, valid, -1 ); 128 otv_Coverage_validate( table + Coverage2, valid, -1 ); 129 130 otv_MarkArray_validate( table + Array1, valid ); 131 132 valid->nesting_level++; 133 func = valid->func[valid->nesting_level]; 134 valid->extra1 = ClassCount; 135 136 func( table + Array2, valid ); 137 138 valid->nesting_level--; 139 140 OTV_EXIT; 141 } 142 143 144 /*************************************************************************/ 145 /*************************************************************************/ 146 /***** *****/ 147 /***** VALUE RECORDS *****/ 148 /***** *****/ 149 /*************************************************************************/ 150 /*************************************************************************/ 151 152 static FT_UInt otv_value_length(FT_UInt format)153 otv_value_length( FT_UInt format ) 154 { 155 FT_UInt count; 156 157 158 count = ( ( format & 0xAA ) >> 1 ) + ( format & 0x55 ); 159 count = ( ( count & 0xCC ) >> 2 ) + ( count & 0x33 ); 160 count = ( ( count & 0xF0 ) >> 4 ) + ( count & 0x0F ); 161 162 return count * 2; 163 } 164 165 166 /* uses valid->extra3 (pointer to base table) */ 167 168 static void otv_ValueRecord_validate(FT_Bytes table,FT_UInt format,OTV_Validator valid)169 otv_ValueRecord_validate( FT_Bytes table, 170 FT_UInt format, 171 OTV_Validator valid ) 172 { 173 FT_Bytes p = table; 174 FT_UInt count; 175 176 #ifdef FT_DEBUG_LEVEL_TRACE 177 FT_Int loop; 178 FT_ULong res = 0; 179 180 181 OTV_NAME_ENTER( "ValueRecord" ); 182 183 /* display `format' in dual representation */ 184 for ( loop = 7; loop >= 0; loop-- ) 185 { 186 res <<= 4; 187 res += ( format >> loop ) & 1; 188 } 189 190 OTV_TRACE(( " (format 0b%08lx)\n", res )); 191 #endif 192 193 if ( format >= 0x100 ) 194 FT_INVALID_FORMAT; 195 196 for ( count = 4; count > 0; count-- ) 197 { 198 if ( format & 1 ) 199 { 200 /* XPlacement, YPlacement, XAdvance, YAdvance */ 201 OTV_LIMIT_CHECK( 2 ); 202 p += 2; 203 } 204 205 format >>= 1; 206 } 207 208 for ( count = 4; count > 0; count-- ) 209 { 210 if ( format & 1 ) 211 { 212 FT_PtrDist table_size; 213 214 OTV_OPTIONAL_TABLE( device ); 215 216 217 /* XPlaDevice, YPlaDevice, XAdvDevice, YAdvDevice */ 218 OTV_LIMIT_CHECK( 2 ); 219 OTV_OPTIONAL_OFFSET( device ); 220 221 /* XXX: this value is usually too small, especially if the current */ 222 /* ValueRecord is part of an array -- getting the correct table */ 223 /* size is probably not worth the trouble */ 224 225 table_size = p - valid->extra3; 226 227 OTV_SIZE_CHECK( device ); 228 if ( device ) 229 otv_Device_validate( valid->extra3 + device, valid ); 230 } 231 format >>= 1; 232 } 233 234 OTV_EXIT; 235 } 236 237 238 /*************************************************************************/ 239 /*************************************************************************/ 240 /***** *****/ 241 /***** ANCHORS *****/ 242 /***** *****/ 243 /*************************************************************************/ 244 /*************************************************************************/ 245 246 static void otv_Anchor_validate(FT_Bytes table,OTV_Validator valid)247 otv_Anchor_validate( FT_Bytes table, 248 OTV_Validator valid ) 249 { 250 FT_Bytes p = table; 251 FT_UInt AnchorFormat; 252 253 254 OTV_NAME_ENTER( "Anchor"); 255 256 OTV_LIMIT_CHECK( 6 ); 257 AnchorFormat = FT_NEXT_USHORT( p ); 258 259 OTV_TRACE(( " (format %d)\n", AnchorFormat )); 260 261 p += 4; /* skip XCoordinate and YCoordinate */ 262 263 switch ( AnchorFormat ) 264 { 265 case 1: 266 break; 267 268 case 2: 269 OTV_LIMIT_CHECK( 2 ); /* AnchorPoint */ 270 break; 271 272 case 3: 273 { 274 FT_UInt table_size; 275 276 OTV_OPTIONAL_TABLE( XDeviceTable ); 277 OTV_OPTIONAL_TABLE( YDeviceTable ); 278 279 280 OTV_LIMIT_CHECK( 4 ); 281 OTV_OPTIONAL_OFFSET( XDeviceTable ); 282 OTV_OPTIONAL_OFFSET( YDeviceTable ); 283 284 table_size = 6 + 4; 285 286 OTV_SIZE_CHECK( XDeviceTable ); 287 if ( XDeviceTable ) 288 otv_Device_validate( table + XDeviceTable, valid ); 289 290 OTV_SIZE_CHECK( YDeviceTable ); 291 if ( YDeviceTable ) 292 otv_Device_validate( table + YDeviceTable, valid ); 293 } 294 break; 295 296 default: 297 FT_INVALID_FORMAT; 298 } 299 300 OTV_EXIT; 301 } 302 303 304 /*************************************************************************/ 305 /*************************************************************************/ 306 /***** *****/ 307 /***** MARK ARRAYS *****/ 308 /***** *****/ 309 /*************************************************************************/ 310 /*************************************************************************/ 311 312 static void otv_MarkArray_validate(FT_Bytes table,OTV_Validator valid)313 otv_MarkArray_validate( FT_Bytes table, 314 OTV_Validator valid ) 315 { 316 FT_Bytes p = table; 317 FT_UInt MarkCount; 318 319 320 OTV_NAME_ENTER( "MarkArray" ); 321 322 OTV_LIMIT_CHECK( 2 ); 323 MarkCount = FT_NEXT_USHORT( p ); 324 325 OTV_TRACE(( " (MarkCount = %d)\n", MarkCount )); 326 327 OTV_LIMIT_CHECK( MarkCount * 4 ); 328 329 /* MarkRecord */ 330 for ( ; MarkCount > 0; MarkCount-- ) 331 { 332 p += 2; /* skip Class */ 333 /* MarkAnchor */ 334 otv_Anchor_validate( table + FT_NEXT_USHORT( p ), valid ); 335 } 336 337 OTV_EXIT; 338 } 339 340 341 /*************************************************************************/ 342 /*************************************************************************/ 343 /***** *****/ 344 /***** GPOS LOOKUP TYPE 1 *****/ 345 /***** *****/ 346 /*************************************************************************/ 347 /*************************************************************************/ 348 349 /* sets valid->extra3 (pointer to base table) */ 350 351 static void otv_SinglePos_validate(FT_Bytes table,OTV_Validator valid)352 otv_SinglePos_validate( FT_Bytes table, 353 OTV_Validator valid ) 354 { 355 FT_Bytes p = table; 356 FT_UInt PosFormat; 357 358 359 OTV_NAME_ENTER( "SinglePos" ); 360 361 OTV_LIMIT_CHECK( 2 ); 362 PosFormat = FT_NEXT_USHORT( p ); 363 364 OTV_TRACE(( " (format %d)\n", PosFormat )); 365 366 valid->extra3 = table; 367 368 switch ( PosFormat ) 369 { 370 case 1: /* SinglePosFormat1 */ 371 { 372 FT_UInt Coverage, ValueFormat; 373 374 375 OTV_LIMIT_CHECK( 4 ); 376 Coverage = FT_NEXT_USHORT( p ); 377 ValueFormat = FT_NEXT_USHORT( p ); 378 379 otv_Coverage_validate( table + Coverage, valid, -1 ); 380 otv_ValueRecord_validate( p, ValueFormat, valid ); /* Value */ 381 } 382 break; 383 384 case 2: /* SinglePosFormat2 */ 385 { 386 FT_UInt Coverage, ValueFormat, ValueCount, len_value; 387 388 389 OTV_LIMIT_CHECK( 6 ); 390 Coverage = FT_NEXT_USHORT( p ); 391 ValueFormat = FT_NEXT_USHORT( p ); 392 ValueCount = FT_NEXT_USHORT( p ); 393 394 OTV_TRACE(( " (ValueCount = %d)\n", ValueCount )); 395 396 len_value = otv_value_length( ValueFormat ); 397 398 otv_Coverage_validate( table + Coverage, valid, ValueCount ); 399 400 OTV_LIMIT_CHECK( ValueCount * len_value ); 401 402 /* Value */ 403 for ( ; ValueCount > 0; ValueCount-- ) 404 { 405 otv_ValueRecord_validate( p, ValueFormat, valid ); 406 p += len_value; 407 } 408 } 409 break; 410 411 default: 412 FT_INVALID_FORMAT; 413 } 414 415 OTV_EXIT; 416 } 417 418 419 /*************************************************************************/ 420 /*************************************************************************/ 421 /***** *****/ 422 /***** GPOS LOOKUP TYPE 2 *****/ 423 /***** *****/ 424 /*************************************************************************/ 425 /*************************************************************************/ 426 427 static void otv_PairSet_validate(FT_Bytes table,FT_UInt format1,FT_UInt format2,OTV_Validator valid)428 otv_PairSet_validate( FT_Bytes table, 429 FT_UInt format1, 430 FT_UInt format2, 431 OTV_Validator valid ) 432 { 433 FT_Bytes p = table; 434 FT_UInt value_len1, value_len2, PairValueCount; 435 436 437 OTV_NAME_ENTER( "PairSet" ); 438 439 OTV_LIMIT_CHECK( 2 ); 440 PairValueCount = FT_NEXT_USHORT( p ); 441 442 OTV_TRACE(( " (PairValueCount = %d)\n", PairValueCount )); 443 444 value_len1 = otv_value_length( format1 ); 445 value_len2 = otv_value_length( format2 ); 446 447 OTV_LIMIT_CHECK( PairValueCount * ( value_len1 + value_len2 + 2 ) ); 448 449 /* PairValueRecord */ 450 for ( ; PairValueCount > 0; PairValueCount-- ) 451 { 452 p += 2; /* skip SecondGlyph */ 453 454 if ( format1 ) 455 otv_ValueRecord_validate( p, format1, valid ); /* Value1 */ 456 p += value_len1; 457 458 if ( format2 ) 459 otv_ValueRecord_validate( p, format2, valid ); /* Value2 */ 460 p += value_len2; 461 } 462 463 OTV_EXIT; 464 } 465 466 467 /* sets valid->extra3 (pointer to base table) */ 468 469 static void otv_PairPos_validate(FT_Bytes table,OTV_Validator valid)470 otv_PairPos_validate( FT_Bytes table, 471 OTV_Validator valid ) 472 { 473 FT_Bytes p = table; 474 FT_UInt PosFormat; 475 476 477 OTV_NAME_ENTER( "PairPos" ); 478 479 OTV_LIMIT_CHECK( 2 ); 480 PosFormat = FT_NEXT_USHORT( p ); 481 482 OTV_TRACE(( " (format %d)\n", PosFormat )); 483 484 valid->extra3 = table; 485 486 switch ( PosFormat ) 487 { 488 case 1: /* PairPosFormat1 */ 489 { 490 FT_UInt Coverage, ValueFormat1, ValueFormat2, PairSetCount; 491 492 493 OTV_LIMIT_CHECK( 8 ); 494 Coverage = FT_NEXT_USHORT( p ); 495 ValueFormat1 = FT_NEXT_USHORT( p ); 496 ValueFormat2 = FT_NEXT_USHORT( p ); 497 PairSetCount = FT_NEXT_USHORT( p ); 498 499 OTV_TRACE(( " (PairSetCount = %d)\n", PairSetCount )); 500 501 otv_Coverage_validate( table + Coverage, valid, -1 ); 502 503 OTV_LIMIT_CHECK( PairSetCount * 2 ); 504 505 /* PairSetOffset */ 506 for ( ; PairSetCount > 0; PairSetCount-- ) 507 otv_PairSet_validate( table + FT_NEXT_USHORT( p ), 508 ValueFormat1, ValueFormat2, valid ); 509 } 510 break; 511 512 case 2: /* PairPosFormat2 */ 513 { 514 FT_UInt Coverage, ValueFormat1, ValueFormat2, ClassDef1, ClassDef2; 515 FT_UInt ClassCount1, ClassCount2, len_value1, len_value2, count; 516 517 518 OTV_LIMIT_CHECK( 14 ); 519 Coverage = FT_NEXT_USHORT( p ); 520 ValueFormat1 = FT_NEXT_USHORT( p ); 521 ValueFormat2 = FT_NEXT_USHORT( p ); 522 ClassDef1 = FT_NEXT_USHORT( p ); 523 ClassDef2 = FT_NEXT_USHORT( p ); 524 ClassCount1 = FT_NEXT_USHORT( p ); 525 ClassCount2 = FT_NEXT_USHORT( p ); 526 527 OTV_TRACE(( " (ClassCount1 = %d)\n", ClassCount1 )); 528 OTV_TRACE(( " (ClassCount2 = %d)\n", ClassCount2 )); 529 530 len_value1 = otv_value_length( ValueFormat1 ); 531 len_value2 = otv_value_length( ValueFormat2 ); 532 533 otv_Coverage_validate( table + Coverage, valid, -1 ); 534 otv_ClassDef_validate( table + ClassDef1, valid ); 535 otv_ClassDef_validate( table + ClassDef2, valid ); 536 537 OTV_LIMIT_CHECK( ClassCount1 * ClassCount2 * 538 ( len_value1 + len_value2 ) ); 539 540 /* Class1Record */ 541 for ( ; ClassCount1 > 0; ClassCount1-- ) 542 { 543 /* Class2Record */ 544 for ( count = ClassCount2; count > 0; count-- ) 545 { 546 if ( ValueFormat1 ) 547 /* Value1 */ 548 otv_ValueRecord_validate( p, ValueFormat1, valid ); 549 p += len_value1; 550 551 if ( ValueFormat2 ) 552 /* Value2 */ 553 otv_ValueRecord_validate( p, ValueFormat2, valid ); 554 p += len_value2; 555 } 556 } 557 } 558 break; 559 560 default: 561 FT_INVALID_FORMAT; 562 } 563 564 OTV_EXIT; 565 } 566 567 568 /*************************************************************************/ 569 /*************************************************************************/ 570 /***** *****/ 571 /***** GPOS LOOKUP TYPE 3 *****/ 572 /***** *****/ 573 /*************************************************************************/ 574 /*************************************************************************/ 575 576 static void otv_CursivePos_validate(FT_Bytes table,OTV_Validator valid)577 otv_CursivePos_validate( FT_Bytes table, 578 OTV_Validator valid ) 579 { 580 FT_Bytes p = table; 581 FT_UInt PosFormat; 582 583 584 OTV_NAME_ENTER( "CursivePos" ); 585 586 OTV_LIMIT_CHECK( 2 ); 587 PosFormat = FT_NEXT_USHORT( p ); 588 589 OTV_TRACE(( " (format %d)\n", PosFormat )); 590 591 switch ( PosFormat ) 592 { 593 case 1: /* CursivePosFormat1 */ 594 { 595 FT_UInt table_size; 596 FT_UInt Coverage, EntryExitCount; 597 598 OTV_OPTIONAL_TABLE( EntryAnchor ); 599 OTV_OPTIONAL_TABLE( ExitAnchor ); 600 601 602 OTV_LIMIT_CHECK( 4 ); 603 Coverage = FT_NEXT_USHORT( p ); 604 EntryExitCount = FT_NEXT_USHORT( p ); 605 606 OTV_TRACE(( " (EntryExitCount = %d)\n", EntryExitCount )); 607 608 otv_Coverage_validate( table + Coverage, valid, EntryExitCount ); 609 610 OTV_LIMIT_CHECK( EntryExitCount * 4 ); 611 612 table_size = EntryExitCount * 4 + 4; 613 614 /* EntryExitRecord */ 615 for ( ; EntryExitCount > 0; EntryExitCount-- ) 616 { 617 OTV_OPTIONAL_OFFSET( EntryAnchor ); 618 OTV_OPTIONAL_OFFSET( ExitAnchor ); 619 620 OTV_SIZE_CHECK( EntryAnchor ); 621 if ( EntryAnchor ) 622 otv_Anchor_validate( table + EntryAnchor, valid ); 623 624 OTV_SIZE_CHECK( ExitAnchor ); 625 if ( ExitAnchor ) 626 otv_Anchor_validate( table + ExitAnchor, valid ); 627 } 628 } 629 break; 630 631 default: 632 FT_INVALID_FORMAT; 633 } 634 635 OTV_EXIT; 636 } 637 638 639 /*************************************************************************/ 640 /*************************************************************************/ 641 /***** *****/ 642 /***** GPOS LOOKUP TYPE 4 *****/ 643 /***** *****/ 644 /*************************************************************************/ 645 /*************************************************************************/ 646 647 /* UNDOCUMENTED (in OpenType 1.5): */ 648 /* BaseRecord tables can contain NULL pointers. */ 649 650 /* sets valid->extra2 (1) */ 651 652 static void otv_MarkBasePos_validate(FT_Bytes table,OTV_Validator valid)653 otv_MarkBasePos_validate( FT_Bytes table, 654 OTV_Validator valid ) 655 { 656 FT_Bytes p = table; 657 FT_UInt PosFormat; 658 659 660 OTV_NAME_ENTER( "MarkBasePos" ); 661 662 OTV_LIMIT_CHECK( 2 ); 663 PosFormat = FT_NEXT_USHORT( p ); 664 665 OTV_TRACE(( " (format %d)\n", PosFormat )); 666 667 switch ( PosFormat ) 668 { 669 case 1: 670 valid->extra2 = 1; 671 OTV_NEST2( MarkBasePosFormat1, BaseArray ); 672 OTV_RUN( table, valid ); 673 break; 674 675 default: 676 FT_INVALID_FORMAT; 677 } 678 679 OTV_EXIT; 680 } 681 682 683 /*************************************************************************/ 684 /*************************************************************************/ 685 /***** *****/ 686 /***** GPOS LOOKUP TYPE 5 *****/ 687 /***** *****/ 688 /*************************************************************************/ 689 /*************************************************************************/ 690 691 /* sets valid->extra2 (1) */ 692 693 static void otv_MarkLigPos_validate(FT_Bytes table,OTV_Validator valid)694 otv_MarkLigPos_validate( FT_Bytes table, 695 OTV_Validator valid ) 696 { 697 FT_Bytes p = table; 698 FT_UInt PosFormat; 699 700 701 OTV_NAME_ENTER( "MarkLigPos" ); 702 703 OTV_LIMIT_CHECK( 2 ); 704 PosFormat = FT_NEXT_USHORT( p ); 705 706 OTV_TRACE(( " (format %d)\n", PosFormat )); 707 708 switch ( PosFormat ) 709 { 710 case 1: 711 valid->extra2 = 1; 712 OTV_NEST3( MarkLigPosFormat1, LigatureArray, LigatureAttach ); 713 OTV_RUN( table, valid ); 714 break; 715 716 default: 717 FT_INVALID_FORMAT; 718 } 719 720 OTV_EXIT; 721 } 722 723 724 /*************************************************************************/ 725 /*************************************************************************/ 726 /***** *****/ 727 /***** GPOS LOOKUP TYPE 6 *****/ 728 /***** *****/ 729 /*************************************************************************/ 730 /*************************************************************************/ 731 732 /* sets valid->extra2 (0) */ 733 734 static void otv_MarkMarkPos_validate(FT_Bytes table,OTV_Validator valid)735 otv_MarkMarkPos_validate( FT_Bytes table, 736 OTV_Validator valid ) 737 { 738 FT_Bytes p = table; 739 FT_UInt PosFormat; 740 741 742 OTV_NAME_ENTER( "MarkMarkPos" ); 743 744 OTV_LIMIT_CHECK( 2 ); 745 PosFormat = FT_NEXT_USHORT( p ); 746 747 OTV_TRACE(( " (format %d)\n", PosFormat )); 748 749 switch ( PosFormat ) 750 { 751 case 1: 752 valid->extra2 = 0; 753 OTV_NEST2( MarkMarkPosFormat1, Mark2Array ); 754 OTV_RUN( table, valid ); 755 break; 756 757 default: 758 FT_INVALID_FORMAT; 759 } 760 761 OTV_EXIT; 762 } 763 764 765 /*************************************************************************/ 766 /*************************************************************************/ 767 /***** *****/ 768 /***** GPOS LOOKUP TYPE 7 *****/ 769 /***** *****/ 770 /*************************************************************************/ 771 /*************************************************************************/ 772 773 /* sets valid->extra1 (lookup count) */ 774 775 static void otv_ContextPos_validate(FT_Bytes table,OTV_Validator valid)776 otv_ContextPos_validate( FT_Bytes table, 777 OTV_Validator valid ) 778 { 779 FT_Bytes p = table; 780 FT_UInt PosFormat; 781 782 783 OTV_NAME_ENTER( "ContextPos" ); 784 785 OTV_LIMIT_CHECK( 2 ); 786 PosFormat = FT_NEXT_USHORT( p ); 787 788 OTV_TRACE(( " (format %d)\n", PosFormat )); 789 790 switch ( PosFormat ) 791 { 792 case 1: 793 /* no need to check glyph indices/classes used as input for these */ 794 /* context rules since even invalid glyph indices/classes return */ 795 /* meaningful results */ 796 797 valid->extra1 = valid->lookup_count; 798 OTV_NEST3( ContextPosFormat1, PosRuleSet, PosRule ); 799 OTV_RUN( table, valid ); 800 break; 801 802 case 2: 803 /* no need to check glyph indices/classes used as input for these */ 804 /* context rules since even invalid glyph indices/classes return */ 805 /* meaningful results */ 806 807 OTV_NEST3( ContextPosFormat2, PosClassSet, PosClassRule ); 808 OTV_RUN( table, valid ); 809 break; 810 811 case 3: 812 OTV_NEST1( ContextPosFormat3 ); 813 OTV_RUN( table, valid ); 814 break; 815 816 default: 817 FT_INVALID_FORMAT; 818 } 819 820 OTV_EXIT; 821 } 822 823 824 /*************************************************************************/ 825 /*************************************************************************/ 826 /***** *****/ 827 /***** GPOS LOOKUP TYPE 8 *****/ 828 /***** *****/ 829 /*************************************************************************/ 830 /*************************************************************************/ 831 832 /* sets valid->extra1 (lookup count) */ 833 834 static void otv_ChainContextPos_validate(FT_Bytes table,OTV_Validator valid)835 otv_ChainContextPos_validate( FT_Bytes table, 836 OTV_Validator valid ) 837 { 838 FT_Bytes p = table; 839 FT_UInt PosFormat; 840 841 842 OTV_NAME_ENTER( "ChainContextPos" ); 843 844 OTV_LIMIT_CHECK( 2 ); 845 PosFormat = FT_NEXT_USHORT( p ); 846 847 OTV_TRACE(( " (format %d)\n", PosFormat )); 848 849 switch ( PosFormat ) 850 { 851 case 1: 852 /* no need to check glyph indices/classes used as input for these */ 853 /* context rules since even invalid glyph indices/classes return */ 854 /* meaningful results */ 855 856 valid->extra1 = valid->lookup_count; 857 OTV_NEST3( ChainContextPosFormat1, 858 ChainPosRuleSet, ChainPosRule ); 859 OTV_RUN( table, valid ); 860 break; 861 862 case 2: 863 /* no need to check glyph indices/classes used as input for these */ 864 /* context rules since even invalid glyph indices/classes return */ 865 /* meaningful results */ 866 867 OTV_NEST3( ChainContextPosFormat2, 868 ChainPosClassSet, ChainPosClassRule ); 869 OTV_RUN( table, valid ); 870 break; 871 872 case 3: 873 OTV_NEST1( ChainContextPosFormat3 ); 874 OTV_RUN( table, valid ); 875 break; 876 877 default: 878 FT_INVALID_FORMAT; 879 } 880 881 OTV_EXIT; 882 } 883 884 885 /*************************************************************************/ 886 /*************************************************************************/ 887 /***** *****/ 888 /***** GPOS LOOKUP TYPE 9 *****/ 889 /***** *****/ 890 /*************************************************************************/ 891 /*************************************************************************/ 892 893 /* uses valid->type_funcs */ 894 895 static void otv_ExtensionPos_validate(FT_Bytes table,OTV_Validator valid)896 otv_ExtensionPos_validate( FT_Bytes table, 897 OTV_Validator valid ) 898 { 899 FT_Bytes p = table; 900 FT_UInt PosFormat; 901 902 903 OTV_NAME_ENTER( "ExtensionPos" ); 904 905 OTV_LIMIT_CHECK( 2 ); 906 PosFormat = FT_NEXT_USHORT( p ); 907 908 OTV_TRACE(( " (format %d)\n", PosFormat )); 909 910 switch ( PosFormat ) 911 { 912 case 1: /* ExtensionPosFormat1 */ 913 { 914 FT_UInt ExtensionLookupType; 915 FT_ULong ExtensionOffset; 916 OTV_Validate_Func validate; 917 918 919 OTV_LIMIT_CHECK( 6 ); 920 ExtensionLookupType = FT_NEXT_USHORT( p ); 921 ExtensionOffset = FT_NEXT_ULONG( p ); 922 923 if ( ExtensionLookupType == 0 || ExtensionLookupType >= 9 ) 924 FT_INVALID_DATA; 925 926 validate = valid->type_funcs[ExtensionLookupType - 1]; 927 validate( table + ExtensionOffset, valid ); 928 } 929 break; 930 931 default: 932 FT_INVALID_FORMAT; 933 } 934 935 OTV_EXIT; 936 } 937 938 939 static const OTV_Validate_Func otv_gpos_validate_funcs[9] = 940 { 941 otv_SinglePos_validate, 942 otv_PairPos_validate, 943 otv_CursivePos_validate, 944 otv_MarkBasePos_validate, 945 otv_MarkLigPos_validate, 946 otv_MarkMarkPos_validate, 947 otv_ContextPos_validate, 948 otv_ChainContextPos_validate, 949 otv_ExtensionPos_validate 950 }; 951 952 953 /* sets valid->type_count */ 954 /* sets valid->type_funcs */ 955 956 FT_LOCAL_DEF( void ) otv_GPOS_subtable_validate(FT_Bytes table,OTV_Validator valid)957 otv_GPOS_subtable_validate( FT_Bytes table, 958 OTV_Validator valid ) 959 { 960 valid->type_count = 9; 961 valid->type_funcs = (OTV_Validate_Func*)otv_gpos_validate_funcs; 962 963 otv_Lookup_validate( table, valid ); 964 } 965 966 967 /*************************************************************************/ 968 /*************************************************************************/ 969 /***** *****/ 970 /***** GPOS TABLE *****/ 971 /***** *****/ 972 /*************************************************************************/ 973 /*************************************************************************/ 974 975 /* sets valid->glyph_count */ 976 977 FT_LOCAL_DEF( void ) otv_GPOS_validate(FT_Bytes table,FT_UInt glyph_count,FT_Validator ftvalid)978 otv_GPOS_validate( FT_Bytes table, 979 FT_UInt glyph_count, 980 FT_Validator ftvalid ) 981 { 982 OTV_ValidatorRec validrec; 983 OTV_Validator valid = &validrec; 984 FT_Bytes p = table; 985 FT_UInt ScriptList, FeatureList, LookupList; 986 987 988 valid->root = ftvalid; 989 990 FT_TRACE3(( "validating GPOS table\n" )); 991 OTV_INIT; 992 993 OTV_LIMIT_CHECK( 10 ); 994 995 if ( FT_NEXT_ULONG( p ) != 0x10000UL ) /* Version */ 996 FT_INVALID_FORMAT; 997 998 ScriptList = FT_NEXT_USHORT( p ); 999 FeatureList = FT_NEXT_USHORT( p ); 1000 LookupList = FT_NEXT_USHORT( p ); 1001 1002 valid->type_count = 9; 1003 valid->type_funcs = (OTV_Validate_Func*)otv_gpos_validate_funcs; 1004 valid->glyph_count = glyph_count; 1005 1006 otv_LookupList_validate( table + LookupList, 1007 valid ); 1008 otv_FeatureList_validate( table + FeatureList, table + LookupList, 1009 valid ); 1010 otv_ScriptList_validate( table + ScriptList, table + FeatureList, 1011 valid ); 1012 1013 FT_TRACE4(( "\n" )); 1014 } 1015 1016 1017 /* END */ 1018