src/otvalid/otvgpos.c

   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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 )
 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 )
 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 */