1 /**************************************************************************** 2 * 3 * otvgpos.c 4 * 5 * OpenType GPOS table validation (body). 6 * 7 * Copyright (C) 2002-2020 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 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 otvalid)59 otv_x_sxy( FT_Bytes table, 60 OTV_Validator otvalid ) 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 * otvalid->extra1 * 2 ); 75 76 table_size = Count * otvalid->extra1 * 2 + 2; 77 78 for ( ; Count > 0; Count-- ) 79 for ( count1 = otvalid->extra1; count1 > 0; count1-- ) 80 { 81 OTV_OPTIONAL_TABLE( anchor_offset ); 82 83 84 OTV_OPTIONAL_OFFSET( anchor_offset ); 85 86 if ( otvalid->extra2 ) 87 { 88 OTV_SIZE_CHECK( anchor_offset ); 89 if ( anchor_offset ) 90 otv_Anchor_validate( table + anchor_offset, otvalid ); 91 } 92 else 93 otv_Anchor_validate( table + anchor_offset, otvalid ); 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 otvalid->extra1 (class count) */ 105 106 static void otv_u_O_O_u_O_O(FT_Bytes table,OTV_Validator otvalid)107 otv_u_O_O_u_O_O( FT_Bytes table, 108 OTV_Validator otvalid ) 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, otvalid, -1 ); 128 otv_Coverage_validate( table + Coverage2, otvalid, -1 ); 129 130 otv_MarkArray_validate( table + Array1, otvalid ); 131 132 otvalid->nesting_level++; 133 func = otvalid->func[otvalid->nesting_level]; 134 otvalid->extra1 = ClassCount; 135 136 func( table + Array2, otvalid ); 137 138 otvalid->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 otvalid->extra3 (pointer to base table) */ 167 168 static void otv_ValueRecord_validate(FT_Bytes table,FT_UInt format,OTV_Validator otvalid)169 otv_ValueRecord_validate( FT_Bytes table, 170 FT_UInt format, 171 OTV_Validator otvalid ) 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 table_size = p - otvalid->extra3; 222 223 OTV_SIZE_CHECK( device ); 224 if ( device ) 225 otv_Device_validate( otvalid->extra3 + device, otvalid ); 226 } 227 format >>= 1; 228 } 229 230 OTV_EXIT; 231 } 232 233 234 /*************************************************************************/ 235 /*************************************************************************/ 236 /***** *****/ 237 /***** ANCHORS *****/ 238 /***** *****/ 239 /*************************************************************************/ 240 /*************************************************************************/ 241 242 static void otv_Anchor_validate(FT_Bytes table,OTV_Validator otvalid)243 otv_Anchor_validate( FT_Bytes table, 244 OTV_Validator otvalid ) 245 { 246 FT_Bytes p = table; 247 FT_UInt AnchorFormat; 248 249 250 OTV_NAME_ENTER( "Anchor"); 251 252 OTV_LIMIT_CHECK( 6 ); 253 AnchorFormat = FT_NEXT_USHORT( p ); 254 255 OTV_TRACE(( " (format %d)\n", AnchorFormat )); 256 257 p += 4; /* skip XCoordinate and YCoordinate */ 258 259 switch ( AnchorFormat ) 260 { 261 case 1: 262 break; 263 264 case 2: 265 OTV_LIMIT_CHECK( 2 ); /* AnchorPoint */ 266 break; 267 268 case 3: 269 { 270 FT_UInt table_size; 271 272 OTV_OPTIONAL_TABLE( XDeviceTable ); 273 OTV_OPTIONAL_TABLE( YDeviceTable ); 274 275 276 OTV_LIMIT_CHECK( 4 ); 277 OTV_OPTIONAL_OFFSET( XDeviceTable ); 278 OTV_OPTIONAL_OFFSET( YDeviceTable ); 279 280 table_size = 6 + 4; 281 282 OTV_SIZE_CHECK( XDeviceTable ); 283 if ( XDeviceTable ) 284 otv_Device_validate( table + XDeviceTable, otvalid ); 285 286 OTV_SIZE_CHECK( YDeviceTable ); 287 if ( YDeviceTable ) 288 otv_Device_validate( table + YDeviceTable, otvalid ); 289 } 290 break; 291 292 default: 293 FT_INVALID_FORMAT; 294 } 295 296 OTV_EXIT; 297 } 298 299 300 /*************************************************************************/ 301 /*************************************************************************/ 302 /***** *****/ 303 /***** MARK ARRAYS *****/ 304 /***** *****/ 305 /*************************************************************************/ 306 /*************************************************************************/ 307 308 static void otv_MarkArray_validate(FT_Bytes table,OTV_Validator otvalid)309 otv_MarkArray_validate( FT_Bytes table, 310 OTV_Validator otvalid ) 311 { 312 FT_Bytes p = table; 313 FT_UInt MarkCount; 314 315 316 OTV_NAME_ENTER( "MarkArray" ); 317 318 OTV_LIMIT_CHECK( 2 ); 319 MarkCount = FT_NEXT_USHORT( p ); 320 321 OTV_TRACE(( " (MarkCount = %d)\n", MarkCount )); 322 323 OTV_LIMIT_CHECK( MarkCount * 4 ); 324 325 /* MarkRecord */ 326 for ( ; MarkCount > 0; MarkCount-- ) 327 { 328 p += 2; /* skip Class */ 329 /* MarkAnchor */ 330 otv_Anchor_validate( table + FT_NEXT_USHORT( p ), otvalid ); 331 } 332 333 OTV_EXIT; 334 } 335 336 337 /*************************************************************************/ 338 /*************************************************************************/ 339 /***** *****/ 340 /***** GPOS LOOKUP TYPE 1 *****/ 341 /***** *****/ 342 /*************************************************************************/ 343 /*************************************************************************/ 344 345 /* sets otvalid->extra3 (pointer to base table) */ 346 347 static void otv_SinglePos_validate(FT_Bytes table,OTV_Validator otvalid)348 otv_SinglePos_validate( FT_Bytes table, 349 OTV_Validator otvalid ) 350 { 351 FT_Bytes p = table; 352 FT_UInt PosFormat; 353 354 355 OTV_NAME_ENTER( "SinglePos" ); 356 357 OTV_LIMIT_CHECK( 2 ); 358 PosFormat = FT_NEXT_USHORT( p ); 359 360 OTV_TRACE(( " (format %d)\n", PosFormat )); 361 362 otvalid->extra3 = table; 363 364 switch ( PosFormat ) 365 { 366 case 1: /* SinglePosFormat1 */ 367 { 368 FT_UInt Coverage, ValueFormat; 369 370 371 OTV_LIMIT_CHECK( 4 ); 372 Coverage = FT_NEXT_USHORT( p ); 373 ValueFormat = FT_NEXT_USHORT( p ); 374 375 otv_Coverage_validate( table + Coverage, otvalid, -1 ); 376 otv_ValueRecord_validate( p, ValueFormat, otvalid ); /* Value */ 377 } 378 break; 379 380 case 2: /* SinglePosFormat2 */ 381 { 382 FT_UInt Coverage, ValueFormat, ValueCount, len_value; 383 384 385 OTV_LIMIT_CHECK( 6 ); 386 Coverage = FT_NEXT_USHORT( p ); 387 ValueFormat = FT_NEXT_USHORT( p ); 388 ValueCount = FT_NEXT_USHORT( p ); 389 390 OTV_TRACE(( " (ValueCount = %d)\n", ValueCount )); 391 392 len_value = otv_value_length( ValueFormat ); 393 394 otv_Coverage_validate( table + Coverage, 395 otvalid, 396 (FT_Int)ValueCount ); 397 398 OTV_LIMIT_CHECK( ValueCount * len_value ); 399 400 /* Value */ 401 for ( ; ValueCount > 0; ValueCount-- ) 402 { 403 otv_ValueRecord_validate( p, ValueFormat, otvalid ); 404 p += len_value; 405 } 406 } 407 break; 408 409 default: 410 FT_INVALID_FORMAT; 411 } 412 413 OTV_EXIT; 414 } 415 416 417 /*************************************************************************/ 418 /*************************************************************************/ 419 /***** *****/ 420 /***** GPOS LOOKUP TYPE 2 *****/ 421 /***** *****/ 422 /*************************************************************************/ 423 /*************************************************************************/ 424 425 /* sets otvalid->extra3 (pointer to base table) */ 426 427 static void otv_PairSet_validate(FT_Bytes table,FT_UInt format1,FT_UInt format2,OTV_Validator otvalid)428 otv_PairSet_validate( FT_Bytes table, 429 FT_UInt format1, 430 FT_UInt format2, 431 OTV_Validator otvalid ) 432 { 433 FT_Bytes p = table; 434 FT_UInt value_len1, value_len2, PairValueCount; 435 436 437 OTV_NAME_ENTER( "PairSet" ); 438 439 otvalid->extra3 = table; 440 441 OTV_LIMIT_CHECK( 2 ); 442 PairValueCount = FT_NEXT_USHORT( p ); 443 444 OTV_TRACE(( " (PairValueCount = %d)\n", PairValueCount )); 445 446 value_len1 = otv_value_length( format1 ); 447 value_len2 = otv_value_length( format2 ); 448 449 OTV_LIMIT_CHECK( PairValueCount * ( value_len1 + value_len2 + 2 ) ); 450 451 /* PairValueRecord */ 452 for ( ; PairValueCount > 0; PairValueCount-- ) 453 { 454 p += 2; /* skip SecondGlyph */ 455 456 if ( format1 ) 457 otv_ValueRecord_validate( p, format1, otvalid ); /* Value1 */ 458 p += value_len1; 459 460 if ( format2 ) 461 otv_ValueRecord_validate( p, format2, otvalid ); /* Value2 */ 462 p += value_len2; 463 } 464 465 OTV_EXIT; 466 } 467 468 469 /* sets otvalid->extra3 (pointer to base table) */ 470 471 static void otv_PairPos_validate(FT_Bytes table,OTV_Validator otvalid)472 otv_PairPos_validate( FT_Bytes table, 473 OTV_Validator otvalid ) 474 { 475 FT_Bytes p = table; 476 FT_UInt PosFormat; 477 478 479 OTV_NAME_ENTER( "PairPos" ); 480 481 OTV_LIMIT_CHECK( 2 ); 482 PosFormat = FT_NEXT_USHORT( p ); 483 484 OTV_TRACE(( " (format %d)\n", PosFormat )); 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, otvalid, -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, otvalid ); 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, otvalid, -1 ); 534 otv_ClassDef_validate( table + ClassDef1, otvalid ); 535 otv_ClassDef_validate( table + ClassDef2, otvalid ); 536 537 OTV_LIMIT_CHECK( ClassCount1 * ClassCount2 * 538 ( len_value1 + len_value2 ) ); 539 540 otvalid->extra3 = table; 541 542 /* Class1Record */ 543 for ( ; ClassCount1 > 0; ClassCount1-- ) 544 { 545 /* Class2Record */ 546 for ( count = ClassCount2; count > 0; count-- ) 547 { 548 if ( ValueFormat1 ) 549 /* Value1 */ 550 otv_ValueRecord_validate( p, ValueFormat1, otvalid ); 551 p += len_value1; 552 553 if ( ValueFormat2 ) 554 /* Value2 */ 555 otv_ValueRecord_validate( p, ValueFormat2, otvalid ); 556 p += len_value2; 557 } 558 } 559 } 560 break; 561 562 default: 563 FT_INVALID_FORMAT; 564 } 565 566 OTV_EXIT; 567 } 568 569 570 /*************************************************************************/ 571 /*************************************************************************/ 572 /***** *****/ 573 /***** GPOS LOOKUP TYPE 3 *****/ 574 /***** *****/ 575 /*************************************************************************/ 576 /*************************************************************************/ 577 578 static void otv_CursivePos_validate(FT_Bytes table,OTV_Validator otvalid)579 otv_CursivePos_validate( FT_Bytes table, 580 OTV_Validator otvalid ) 581 { 582 FT_Bytes p = table; 583 FT_UInt PosFormat; 584 585 586 OTV_NAME_ENTER( "CursivePos" ); 587 588 OTV_LIMIT_CHECK( 2 ); 589 PosFormat = FT_NEXT_USHORT( p ); 590 591 OTV_TRACE(( " (format %d)\n", PosFormat )); 592 593 switch ( PosFormat ) 594 { 595 case 1: /* CursivePosFormat1 */ 596 { 597 FT_UInt table_size; 598 FT_UInt Coverage, EntryExitCount; 599 600 OTV_OPTIONAL_TABLE( EntryAnchor ); 601 OTV_OPTIONAL_TABLE( ExitAnchor ); 602 603 604 OTV_LIMIT_CHECK( 4 ); 605 Coverage = FT_NEXT_USHORT( p ); 606 EntryExitCount = FT_NEXT_USHORT( p ); 607 608 OTV_TRACE(( " (EntryExitCount = %d)\n", EntryExitCount )); 609 610 otv_Coverage_validate( table + Coverage, 611 otvalid, 612 (FT_Int)EntryExitCount ); 613 614 OTV_LIMIT_CHECK( EntryExitCount * 4 ); 615 616 table_size = EntryExitCount * 4 + 4; 617 618 /* EntryExitRecord */ 619 for ( ; EntryExitCount > 0; EntryExitCount-- ) 620 { 621 OTV_OPTIONAL_OFFSET( EntryAnchor ); 622 OTV_OPTIONAL_OFFSET( ExitAnchor ); 623 624 OTV_SIZE_CHECK( EntryAnchor ); 625 if ( EntryAnchor ) 626 otv_Anchor_validate( table + EntryAnchor, otvalid ); 627 628 OTV_SIZE_CHECK( ExitAnchor ); 629 if ( ExitAnchor ) 630 otv_Anchor_validate( table + ExitAnchor, otvalid ); 631 } 632 } 633 break; 634 635 default: 636 FT_INVALID_FORMAT; 637 } 638 639 OTV_EXIT; 640 } 641 642 643 /*************************************************************************/ 644 /*************************************************************************/ 645 /***** *****/ 646 /***** GPOS LOOKUP TYPE 4 *****/ 647 /***** *****/ 648 /*************************************************************************/ 649 /*************************************************************************/ 650 651 /* UNDOCUMENTED (in OpenType 1.5): */ 652 /* BaseRecord tables can contain NULL pointers. */ 653 654 /* sets otvalid->extra2 (1) */ 655 656 static void otv_MarkBasePos_validate(FT_Bytes table,OTV_Validator otvalid)657 otv_MarkBasePos_validate( FT_Bytes table, 658 OTV_Validator otvalid ) 659 { 660 FT_Bytes p = table; 661 FT_UInt PosFormat; 662 663 664 OTV_NAME_ENTER( "MarkBasePos" ); 665 666 OTV_LIMIT_CHECK( 2 ); 667 PosFormat = FT_NEXT_USHORT( p ); 668 669 OTV_TRACE(( " (format %d)\n", PosFormat )); 670 671 switch ( PosFormat ) 672 { 673 case 1: 674 otvalid->extra2 = 1; 675 OTV_NEST2( MarkBasePosFormat1, BaseArray ); 676 OTV_RUN( table, otvalid ); 677 break; 678 679 default: 680 FT_INVALID_FORMAT; 681 } 682 683 OTV_EXIT; 684 } 685 686 687 /*************************************************************************/ 688 /*************************************************************************/ 689 /***** *****/ 690 /***** GPOS LOOKUP TYPE 5 *****/ 691 /***** *****/ 692 /*************************************************************************/ 693 /*************************************************************************/ 694 695 /* sets otvalid->extra2 (1) */ 696 697 static void otv_MarkLigPos_validate(FT_Bytes table,OTV_Validator otvalid)698 otv_MarkLigPos_validate( FT_Bytes table, 699 OTV_Validator otvalid ) 700 { 701 FT_Bytes p = table; 702 FT_UInt PosFormat; 703 704 705 OTV_NAME_ENTER( "MarkLigPos" ); 706 707 OTV_LIMIT_CHECK( 2 ); 708 PosFormat = FT_NEXT_USHORT( p ); 709 710 OTV_TRACE(( " (format %d)\n", PosFormat )); 711 712 switch ( PosFormat ) 713 { 714 case 1: 715 otvalid->extra2 = 1; 716 OTV_NEST3( MarkLigPosFormat1, LigatureArray, LigatureAttach ); 717 OTV_RUN( table, otvalid ); 718 break; 719 720 default: 721 FT_INVALID_FORMAT; 722 } 723 724 OTV_EXIT; 725 } 726 727 728 /*************************************************************************/ 729 /*************************************************************************/ 730 /***** *****/ 731 /***** GPOS LOOKUP TYPE 6 *****/ 732 /***** *****/ 733 /*************************************************************************/ 734 /*************************************************************************/ 735 736 /* sets otvalid->extra2 (0) */ 737 738 static void otv_MarkMarkPos_validate(FT_Bytes table,OTV_Validator otvalid)739 otv_MarkMarkPos_validate( FT_Bytes table, 740 OTV_Validator otvalid ) 741 { 742 FT_Bytes p = table; 743 FT_UInt PosFormat; 744 745 746 OTV_NAME_ENTER( "MarkMarkPos" ); 747 748 OTV_LIMIT_CHECK( 2 ); 749 PosFormat = FT_NEXT_USHORT( p ); 750 751 OTV_TRACE(( " (format %d)\n", PosFormat )); 752 753 switch ( PosFormat ) 754 { 755 case 1: 756 otvalid->extra2 = 0; 757 OTV_NEST2( MarkMarkPosFormat1, Mark2Array ); 758 OTV_RUN( table, otvalid ); 759 break; 760 761 default: 762 FT_INVALID_FORMAT; 763 } 764 765 OTV_EXIT; 766 } 767 768 769 /*************************************************************************/ 770 /*************************************************************************/ 771 /***** *****/ 772 /***** GPOS LOOKUP TYPE 7 *****/ 773 /***** *****/ 774 /*************************************************************************/ 775 /*************************************************************************/ 776 777 /* sets otvalid->extra1 (lookup count) */ 778 779 static void otv_ContextPos_validate(FT_Bytes table,OTV_Validator otvalid)780 otv_ContextPos_validate( FT_Bytes table, 781 OTV_Validator otvalid ) 782 { 783 FT_Bytes p = table; 784 FT_UInt PosFormat; 785 786 787 OTV_NAME_ENTER( "ContextPos" ); 788 789 OTV_LIMIT_CHECK( 2 ); 790 PosFormat = FT_NEXT_USHORT( p ); 791 792 OTV_TRACE(( " (format %d)\n", PosFormat )); 793 794 switch ( PosFormat ) 795 { 796 case 1: 797 /* no need to check glyph indices/classes used as input for these */ 798 /* context rules since even invalid glyph indices/classes return */ 799 /* meaningful results */ 800 801 otvalid->extra1 = otvalid->lookup_count; 802 OTV_NEST3( ContextPosFormat1, PosRuleSet, PosRule ); 803 OTV_RUN( table, otvalid ); 804 break; 805 806 case 2: 807 /* no need to check glyph indices/classes used as input for these */ 808 /* context rules since even invalid glyph indices/classes return */ 809 /* meaningful results */ 810 811 OTV_NEST3( ContextPosFormat2, PosClassSet, PosClassRule ); 812 OTV_RUN( table, otvalid ); 813 break; 814 815 case 3: 816 OTV_NEST1( ContextPosFormat3 ); 817 OTV_RUN( table, otvalid ); 818 break; 819 820 default: 821 FT_INVALID_FORMAT; 822 } 823 824 OTV_EXIT; 825 } 826 827 828 /*************************************************************************/ 829 /*************************************************************************/ 830 /***** *****/ 831 /***** GPOS LOOKUP TYPE 8 *****/ 832 /***** *****/ 833 /*************************************************************************/ 834 /*************************************************************************/ 835 836 /* sets otvalid->extra1 (lookup count) */ 837 838 static void otv_ChainContextPos_validate(FT_Bytes table,OTV_Validator otvalid)839 otv_ChainContextPos_validate( FT_Bytes table, 840 OTV_Validator otvalid ) 841 { 842 FT_Bytes p = table; 843 FT_UInt PosFormat; 844 845 846 OTV_NAME_ENTER( "ChainContextPos" ); 847 848 OTV_LIMIT_CHECK( 2 ); 849 PosFormat = FT_NEXT_USHORT( p ); 850 851 OTV_TRACE(( " (format %d)\n", PosFormat )); 852 853 switch ( PosFormat ) 854 { 855 case 1: 856 /* no need to check glyph indices/classes used as input for these */ 857 /* context rules since even invalid glyph indices/classes return */ 858 /* meaningful results */ 859 860 otvalid->extra1 = otvalid->lookup_count; 861 OTV_NEST3( ChainContextPosFormat1, 862 ChainPosRuleSet, ChainPosRule ); 863 OTV_RUN( table, otvalid ); 864 break; 865 866 case 2: 867 /* no need to check glyph indices/classes used as input for these */ 868 /* context rules since even invalid glyph indices/classes return */ 869 /* meaningful results */ 870 871 OTV_NEST3( ChainContextPosFormat2, 872 ChainPosClassSet, ChainPosClassRule ); 873 OTV_RUN( table, otvalid ); 874 break; 875 876 case 3: 877 OTV_NEST1( ChainContextPosFormat3 ); 878 OTV_RUN( table, otvalid ); 879 break; 880 881 default: 882 FT_INVALID_FORMAT; 883 } 884 885 OTV_EXIT; 886 } 887 888 889 /*************************************************************************/ 890 /*************************************************************************/ 891 /***** *****/ 892 /***** GPOS LOOKUP TYPE 9 *****/ 893 /***** *****/ 894 /*************************************************************************/ 895 /*************************************************************************/ 896 897 /* uses otvalid->type_funcs */ 898 899 static void otv_ExtensionPos_validate(FT_Bytes table,OTV_Validator otvalid)900 otv_ExtensionPos_validate( FT_Bytes table, 901 OTV_Validator otvalid ) 902 { 903 FT_Bytes p = table; 904 FT_UInt PosFormat; 905 906 907 OTV_NAME_ENTER( "ExtensionPos" ); 908 909 OTV_LIMIT_CHECK( 2 ); 910 PosFormat = FT_NEXT_USHORT( p ); 911 912 OTV_TRACE(( " (format %d)\n", PosFormat )); 913 914 switch ( PosFormat ) 915 { 916 case 1: /* ExtensionPosFormat1 */ 917 { 918 FT_UInt ExtensionLookupType; 919 FT_ULong ExtensionOffset; 920 OTV_Validate_Func validate; 921 922 923 OTV_LIMIT_CHECK( 6 ); 924 ExtensionLookupType = FT_NEXT_USHORT( p ); 925 ExtensionOffset = FT_NEXT_ULONG( p ); 926 927 if ( ExtensionLookupType == 0 || ExtensionLookupType >= 9 ) 928 FT_INVALID_DATA; 929 930 validate = otvalid->type_funcs[ExtensionLookupType - 1]; 931 validate( table + ExtensionOffset, otvalid ); 932 } 933 break; 934 935 default: 936 FT_INVALID_FORMAT; 937 } 938 939 OTV_EXIT; 940 } 941 942 943 static const OTV_Validate_Func otv_gpos_validate_funcs[9] = 944 { 945 otv_SinglePos_validate, 946 otv_PairPos_validate, 947 otv_CursivePos_validate, 948 otv_MarkBasePos_validate, 949 otv_MarkLigPos_validate, 950 otv_MarkMarkPos_validate, 951 otv_ContextPos_validate, 952 otv_ChainContextPos_validate, 953 otv_ExtensionPos_validate 954 }; 955 956 957 /* sets otvalid->type_count */ 958 /* sets otvalid->type_funcs */ 959 960 FT_LOCAL_DEF( void ) otv_GPOS_subtable_validate(FT_Bytes table,OTV_Validator otvalid)961 otv_GPOS_subtable_validate( FT_Bytes table, 962 OTV_Validator otvalid ) 963 { 964 otvalid->type_count = 9; 965 otvalid->type_funcs = (OTV_Validate_Func*)otv_gpos_validate_funcs; 966 967 otv_Lookup_validate( table, otvalid ); 968 } 969 970 971 /*************************************************************************/ 972 /*************************************************************************/ 973 /***** *****/ 974 /***** GPOS TABLE *****/ 975 /***** *****/ 976 /*************************************************************************/ 977 /*************************************************************************/ 978 979 /* sets otvalid->glyph_count */ 980 981 FT_LOCAL_DEF( void ) otv_GPOS_validate(FT_Bytes table,FT_UInt glyph_count,FT_Validator ftvalid)982 otv_GPOS_validate( FT_Bytes table, 983 FT_UInt glyph_count, 984 FT_Validator ftvalid ) 985 { 986 OTV_ValidatorRec validrec; 987 OTV_Validator otvalid = &validrec; 988 FT_Bytes p = table; 989 FT_UInt table_size; 990 FT_UShort version; 991 FT_UInt ScriptList, FeatureList, LookupList; 992 993 OTV_OPTIONAL_TABLE32( featureVariations ); 994 995 996 otvalid->root = ftvalid; 997 998 FT_TRACE3(( "validating GPOS table\n" )); 999 OTV_INIT; 1000 1001 OTV_LIMIT_CHECK( 4 ); 1002 1003 if ( FT_NEXT_USHORT( p ) != 1 ) /* majorVersion */ 1004 FT_INVALID_FORMAT; 1005 1006 version = FT_NEXT_USHORT( p ); /* minorVersion */ 1007 1008 table_size = 10; 1009 switch ( version ) 1010 { 1011 case 0: 1012 OTV_LIMIT_CHECK( 6 ); 1013 break; 1014 1015 case 1: 1016 OTV_LIMIT_CHECK( 10 ); 1017 table_size += 4; 1018 break; 1019 1020 default: 1021 FT_INVALID_FORMAT; 1022 } 1023 1024 ScriptList = FT_NEXT_USHORT( p ); 1025 FeatureList = FT_NEXT_USHORT( p ); 1026 LookupList = FT_NEXT_USHORT( p ); 1027 1028 otvalid->type_count = 9; 1029 otvalid->type_funcs = (OTV_Validate_Func*)otv_gpos_validate_funcs; 1030 otvalid->glyph_count = glyph_count; 1031 1032 otv_LookupList_validate( table + LookupList, 1033 otvalid ); 1034 otv_FeatureList_validate( table + FeatureList, table + LookupList, 1035 otvalid ); 1036 otv_ScriptList_validate( table + ScriptList, table + FeatureList, 1037 otvalid ); 1038 1039 if ( version > 0 ) 1040 { 1041 OTV_OPTIONAL_OFFSET32( featureVariations ); 1042 OTV_SIZE_CHECK32( featureVariations ); 1043 if ( featureVariations ) 1044 OTV_TRACE(( " [omitting featureVariations validation]\n" )); /* XXX */ 1045 } 1046 1047 FT_TRACE4(( "\n" )); 1048 } 1049 1050 1051 /* END */ 1052