Subversion Repositories Kolibri OS

/***************************************************************************/

/*                                                                         */

/*  otvcommn.c                                                             */

/*                                                                         */

/*    OpenType common tables validation (body).                            */

/*                                                                         */

/*  Copyright 2004, 2005, 2006, 2007 by                                    */

/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */

/*                                                                         */

/*  This file is part of the FreeType project, and may only be used,       */

/*  modified, and distributed under the terms of the FreeType project      */

/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */

/*  this file you indicate that you have read the license and              */

/*  understand and accept it fully.                                        */

/*                                                                         */

/***************************************************************************/

#include "otvcommn.h"

  /*************************************************************************/

  /*                                                                       */

  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */

  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */

  /* messages during execution.                                            */

  /*                                                                       */

#undef  FT_COMPONENT

#define FT_COMPONENT  trace_otvcommon

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                       COVERAGE TABLE                          *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  FT_LOCAL_DEF( void )

  otv_Coverage_validate( FT_Bytes       table,

                         OTV_Validator  valid,

                         FT_Int         expected_count )

  {

    FT_Bytes  p = table;

    FT_UInt   CoverageFormat;

    FT_UInt   total = 0;

    OTV_NAME_ENTER( "Coverage" );

    OTV_LIMIT_CHECK( 4 );

    CoverageFormat = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (format %d)\n", CoverageFormat ));

    switch ( CoverageFormat )

    {

    case 1:     /* CoverageFormat1 */

      {

        FT_UInt  GlyphCount;

        FT_UInt  i;

        GlyphCount = FT_NEXT_USHORT( p );

        OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));

        OTV_LIMIT_CHECK( GlyphCount * 2 );        /* GlyphArray */

        for ( i = 0; i < GlyphCount; ++i )

        {

          FT_UInt  gid;

          gid = FT_NEXT_USHORT( p );

          if ( gid >= valid->glyph_count )

            FT_INVALID_GLYPH_ID;

        }

        total = GlyphCount;

      }

      break;

    case 2:     /* CoverageFormat2 */

      {

        FT_UInt  n, RangeCount;

        FT_UInt  Start, End, StartCoverageIndex, last = 0;

        RangeCount = FT_NEXT_USHORT( p );

        OTV_TRACE(( " (RangeCount = %d)\n", RangeCount ));

        OTV_LIMIT_CHECK( RangeCount * 6 );

        /* RangeRecord */

        for ( n = 0; n < RangeCount; n++ )

        {

          Start              = FT_NEXT_USHORT( p );

          End                = FT_NEXT_USHORT( p );

          StartCoverageIndex = FT_NEXT_USHORT( p );

          if ( Start > End || StartCoverageIndex != total )

            FT_INVALID_DATA;

          if ( End >= valid->glyph_count )

            FT_INVALID_GLYPH_ID;

          if ( n > 0 && Start <= last )

            FT_INVALID_DATA;

          total += End - Start + 1;

          last   = End;

        }

      }

      break;

    default:

      FT_INVALID_FORMAT;

    }

    /* Generally, a coverage table offset has an associated count field.  */

    /* The number of glyphs in the table should match this field.  If     */

    /* there is no associated count, a value of -1 tells us not to check. */

    if ( expected_count != -1 && (FT_UInt)expected_count != total )

      FT_INVALID_DATA;

    OTV_EXIT;

  }

  FT_LOCAL_DEF( FT_UInt )

  otv_Coverage_get_first( FT_Bytes  table )

  {

    FT_Bytes  p = table;

    p += 4;     /* skip CoverageFormat and Glyph/RangeCount */

    return FT_NEXT_USHORT( p );

  }

  FT_LOCAL_DEF( FT_UInt )

  otv_Coverage_get_last( FT_Bytes  table )

  {

    FT_Bytes  p = table;

    FT_UInt   CoverageFormat = FT_NEXT_USHORT( p );

    FT_UInt   count          = FT_NEXT_USHORT( p );     /* Glyph/RangeCount */

    FT_UInt   result = 0;

    switch ( CoverageFormat )

    {

    case 1:

      p += ( count - 1 ) * 2;

      result = FT_NEXT_USHORT( p );

      break;

    case 2:

      p += ( count - 1 ) * 6 + 2;

      result = FT_NEXT_USHORT( p );

      break;

    default:

      ;

    }

    return result;

  }

  FT_LOCAL_DEF( FT_UInt )

  otv_Coverage_get_count( FT_Bytes  table )

  {

    FT_Bytes  p              = table;

    FT_UInt   CoverageFormat = FT_NEXT_USHORT( p );

    FT_UInt   count          = FT_NEXT_USHORT( p );     /* Glyph/RangeCount */

    FT_UInt   result         = 0;

    switch ( CoverageFormat )

    {

    case 1:

      return count;

    case 2:

      {

        FT_UInt  Start, End;

        for ( ; count > 0; count-- )

        {

          Start = FT_NEXT_USHORT( p );

          End   = FT_NEXT_USHORT( p );

          p    += 2;                    /* skip StartCoverageIndex */

          result += End - Start + 1;

        }

      }

      break;

    default:

      ;

    }

    return result;

  }

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                   CLASS DEFINITION TABLE                      *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  FT_LOCAL_DEF( void )

  otv_ClassDef_validate( FT_Bytes       table,

                         OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   ClassFormat;

    OTV_NAME_ENTER( "ClassDef" );

    OTV_LIMIT_CHECK( 4 );

    ClassFormat = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (format %d)\n", ClassFormat ));

    switch ( ClassFormat )

    {

    case 1:     /* ClassDefFormat1 */

      {

        FT_UInt  StartGlyph;

        FT_UInt  GlyphCount;

        OTV_LIMIT_CHECK( 4 );

        StartGlyph = FT_NEXT_USHORT( p );

        GlyphCount = FT_NEXT_USHORT( p );

        OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));

        OTV_LIMIT_CHECK( GlyphCount * 2 );    /* ClassValueArray */

        if ( StartGlyph + GlyphCount - 1 >= valid->glyph_count )

          FT_INVALID_GLYPH_ID;

      }

      break;

    case 2:     /* ClassDefFormat2 */

      {

        FT_UInt  n, ClassRangeCount;

        FT_UInt  Start, End, last = 0;

        ClassRangeCount = FT_NEXT_USHORT( p );

        OTV_TRACE(( " (ClassRangeCount = %d)\n", ClassRangeCount ));

        OTV_LIMIT_CHECK( ClassRangeCount * 6 );

        /* ClassRangeRecord */

        for ( n = 0; n < ClassRangeCount; n++ )

        {

          Start = FT_NEXT_USHORT( p );

          End   = FT_NEXT_USHORT( p );

          p    += 2;                        /* skip Class */

          if ( Start > End || ( n > 0 && Start <= last ) )

            FT_INVALID_DATA;

          if ( End >= valid->glyph_count )

            FT_INVALID_GLYPH_ID;

          last = End;

        }

      }

      break;

    default:

      FT_INVALID_FORMAT;

    }

    /* no need to check glyph indices used as input to class definition   */

    /* tables since even invalid glyph indices return a meaningful result */

    OTV_EXIT;

  }

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                      DEVICE TABLE                             *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  FT_LOCAL_DEF( void )

  otv_Device_validate( FT_Bytes       table,

                       OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   StartSize, EndSize, DeltaFormat, count;

    OTV_NAME_ENTER( "Device" );

    OTV_LIMIT_CHECK( 8 );

    StartSize   = FT_NEXT_USHORT( p );

    EndSize     = FT_NEXT_USHORT( p );

    DeltaFormat = FT_NEXT_USHORT( p );

    if ( DeltaFormat < 1 || DeltaFormat > 3 )

      FT_INVALID_FORMAT;

    if ( EndSize < StartSize )

      FT_INVALID_DATA;

    count = EndSize - StartSize + 1;

    OTV_LIMIT_CHECK( ( 1 << DeltaFormat ) * count / 8 );  /* DeltaValue */

    OTV_EXIT;

  }

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                         LOOKUPS                               *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  /* uses valid->type_count */

  /* uses valid->type_funcs */

  FT_LOCAL_DEF( void )

  otv_Lookup_validate( FT_Bytes       table,

                       OTV_Validator  valid )

  {

    FT_Bytes           p = table;

    FT_UInt            LookupType, SubTableCount;

    OTV_Validate_Func  validate;

    OTV_NAME_ENTER( "Lookup" );

    OTV_LIMIT_CHECK( 6 );

    LookupType    = FT_NEXT_USHORT( p );

    p            += 2;                      /* skip LookupFlag */

    SubTableCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (type %d)\n", LookupType ));

    if ( LookupType == 0 || LookupType > valid->type_count )

      FT_INVALID_DATA;

    validate = valid->type_funcs[LookupType - 1];

    OTV_TRACE(( " (SubTableCount = %d)\n", SubTableCount ));

    OTV_LIMIT_CHECK( SubTableCount * 2 );

    /* SubTable */

    for ( ; SubTableCount > 0; SubTableCount-- )

      validate( table + FT_NEXT_USHORT( p ), valid );

    OTV_EXIT;

  }

  /* uses valid->lookup_count */

  FT_LOCAL_DEF( void )

  otv_LookupList_validate( FT_Bytes       table,

                           OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   LookupCount;

    OTV_NAME_ENTER( "LookupList" );

    OTV_LIMIT_CHECK( 2 );

    LookupCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (LookupCount = %d)\n", LookupCount ));

    OTV_LIMIT_CHECK( LookupCount * 2 );

    valid->lookup_count = LookupCount;

    /* Lookup */

    for ( ; LookupCount > 0; LookupCount-- )

      otv_Lookup_validate( table + FT_NEXT_USHORT( p ), valid );

    OTV_EXIT;

  }

  static FT_UInt

  otv_LookupList_get_count( FT_Bytes  table )

  {

    return FT_NEXT_USHORT( table );

  }

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                        FEATURES                               *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  /* uses valid->lookup_count */

  FT_LOCAL_DEF( void )

  otv_Feature_validate( FT_Bytes       table,

                        OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   LookupCount;

    OTV_NAME_ENTER( "Feature" );

    OTV_LIMIT_CHECK( 4 );

    p           += 2;                   /* skip FeatureParams (unused) */

    LookupCount  = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (LookupCount = %d)\n", LookupCount ));

    OTV_LIMIT_CHECK( LookupCount * 2 );

    /* LookupListIndex */

    for ( ; LookupCount > 0; LookupCount-- )

      if ( FT_NEXT_USHORT( p ) >= valid->lookup_count )

        FT_INVALID_DATA;

    OTV_EXIT;

  }

  static FT_UInt

  otv_Feature_get_count( FT_Bytes  table )

  {

    return FT_NEXT_USHORT( table );

  }

  /* sets valid->lookup_count */

  FT_LOCAL_DEF( void )

  otv_FeatureList_validate( FT_Bytes       table,

                            FT_Bytes       lookups,

                            OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   FeatureCount;

    OTV_NAME_ENTER( "FeatureList" );

    OTV_LIMIT_CHECK( 2 );

    FeatureCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (FeatureCount = %d)\n", FeatureCount ));

    OTV_LIMIT_CHECK( FeatureCount * 2 );

    valid->lookup_count = otv_LookupList_get_count( lookups );

    /* FeatureRecord */

    for ( ; FeatureCount > 0; FeatureCount-- )

    {

      p += 4;       /* skip FeatureTag */

      /* Feature */

      otv_Feature_validate( table + FT_NEXT_USHORT( p ), valid );

    }

    OTV_EXIT;

  }

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                       LANGUAGE SYSTEM                         *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  /* uses valid->extra1 (number of features) */

  FT_LOCAL_DEF( void )

  otv_LangSys_validate( FT_Bytes       table,

                        OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   ReqFeatureIndex;

    FT_UInt   FeatureCount;

    OTV_NAME_ENTER( "LangSys" );

    OTV_LIMIT_CHECK( 6 );

    p              += 2;                    /* skip LookupOrder (unused) */

    ReqFeatureIndex = FT_NEXT_USHORT( p );

    FeatureCount    = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (ReqFeatureIndex = %d)\n", ReqFeatureIndex ));

    OTV_TRACE(( " (FeatureCount = %d)\n",    FeatureCount    ));

    if ( ReqFeatureIndex != 0xFFFFU && ReqFeatureIndex >= valid->extra1 )

      FT_INVALID_DATA;

    OTV_LIMIT_CHECK( FeatureCount * 2 );

    /* FeatureIndex */

    for ( ; FeatureCount > 0; FeatureCount-- )

      if ( FT_NEXT_USHORT( p ) >= valid->extra1 )

        FT_INVALID_DATA;

    OTV_EXIT;

  }

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                           SCRIPTS                             *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  FT_LOCAL_DEF( void )

  otv_Script_validate( FT_Bytes       table,

                       OTV_Validator  valid )

  {

    FT_UInt   DefaultLangSys, LangSysCount;

    FT_Bytes  p = table;

    OTV_NAME_ENTER( "Script" );

    OTV_LIMIT_CHECK( 4 );

    DefaultLangSys = FT_NEXT_USHORT( p );

    LangSysCount   = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (LangSysCount = %d)\n", LangSysCount ));

    if ( DefaultLangSys != 0 )

      otv_LangSys_validate( table + DefaultLangSys, valid );

    OTV_LIMIT_CHECK( LangSysCount * 6 );

    /* LangSysRecord */

    for ( ; LangSysCount > 0; LangSysCount-- )

    {

      p += 4;       /* skip LangSysTag */

      /* LangSys */

      otv_LangSys_validate( table + FT_NEXT_USHORT( p ), valid );

    }

    OTV_EXIT;

  }

  /* sets valid->extra1 (number of features) */

  FT_LOCAL_DEF( void )

  otv_ScriptList_validate( FT_Bytes       table,

                           FT_Bytes       features,

                           OTV_Validator  valid )

  {

    FT_UInt   ScriptCount;

    FT_Bytes  p = table;

    OTV_NAME_ENTER( "ScriptList" );

    OTV_LIMIT_CHECK( 2 );

    ScriptCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (ScriptCount = %d)\n", ScriptCount ));

    OTV_LIMIT_CHECK( ScriptCount * 6 );

    valid->extra1 = otv_Feature_get_count( features );

    /* ScriptRecord */

    for ( ; ScriptCount > 0; ScriptCount-- )

    {

      p += 4;       /* skip ScriptTag */

      otv_Script_validate( table + FT_NEXT_USHORT( p ), valid ); /* Script */

    }

    OTV_EXIT;

  }

  /*************************************************************************/

  /*************************************************************************/

  /*****                                                               *****/

  /*****                      UTILITY FUNCTIONS                        *****/

  /*****                                                               *****/

  /*************************************************************************/

  /*************************************************************************/

  /*

     u:   uint16

     ux:  unit16 [x]

     s:   struct

     sx:  struct [x]

     sxy: struct [x], using external y count

     x:   uint16 x

     C:   Coverage

     O:   Offset

     On:  Offset (NULL)

     Ox:  Offset [x]

     Onx: Offset (NULL) [x]

  */

  FT_LOCAL_DEF( void )

  otv_x_Ox( FT_Bytes       table,

            OTV_Validator  valid )

  {

    FT_Bytes           p = table;

    FT_UInt            Count;

    OTV_Validate_Func  func;

    OTV_ENTER;

    OTV_LIMIT_CHECK( 2 );

    Count = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (Count = %d)\n", Count ));

    OTV_LIMIT_CHECK( Count * 2 );

    valid->nesting_level++;

    func = valid->func[valid->nesting_level];

    for ( ; Count > 0; Count-- )

      func( table + FT_NEXT_USHORT( p ), valid );

    valid->nesting_level--;

    OTV_EXIT;

  }

  FT_LOCAL_DEF( void )

  otv_u_C_x_Ox( FT_Bytes       table,

                OTV_Validator  valid )

  {

    FT_Bytes           p = table;

    FT_UInt            Count, Coverage;

    OTV_Validate_Func  func;

    OTV_ENTER;

    p += 2;     /* skip Format */

    OTV_LIMIT_CHECK( 4 );

    Coverage = FT_NEXT_USHORT( p );

    Count    = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (Count = %d)\n", Count ));

    otv_Coverage_validate( table + Coverage, valid, Count );

    OTV_LIMIT_CHECK( Count * 2 );

    valid->nesting_level++;

    func = valid->func[valid->nesting_level];

    for ( ; Count > 0; Count-- )

      func( table + FT_NEXT_USHORT( p ), valid );

    valid->nesting_level--;

    OTV_EXIT;

  }

  /* uses valid->extra1 (if > 0: array value limit) */

  FT_LOCAL_DEF( void )

  otv_x_ux( FT_Bytes       table,

            OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   Count;

    OTV_ENTER;

    OTV_LIMIT_CHECK( 2 );

    Count = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (Count = %d)\n", Count ));

    OTV_LIMIT_CHECK( Count * 2 );

    if ( valid->extra1 )

    {

      for ( ; Count > 0; Count-- )

        if ( FT_NEXT_USHORT( p ) >= valid->extra1 )

          FT_INVALID_DATA;

    }

    OTV_EXIT;

  }

  /* `ux' in the function's name is not really correct since only x-1 */

  /* elements are tested                                              */

  /* uses valid->extra1 (array value limit) */

  FT_LOCAL_DEF( void )

  otv_x_y_ux_sy( FT_Bytes       table,

                 OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   Count1, Count2;

    OTV_ENTER;

    OTV_LIMIT_CHECK( 4 );

    Count1 = FT_NEXT_USHORT( p );

    Count2 = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (Count1 = %d)\n", Count1 ));

    OTV_TRACE(( " (Count2 = %d)\n", Count2 ));

    if ( Count1 == 0 )

      FT_INVALID_DATA;

    OTV_LIMIT_CHECK( ( Count1 - 1 ) * 2 + Count2 * 4 );

    p += ( Count1 - 1 ) * 2;

    for ( ; Count2 > 0; Count2-- )

    {

      if ( FT_NEXT_USHORT( p ) >= Count1 )

        FT_INVALID_DATA;

      if ( FT_NEXT_USHORT( p ) >= valid->extra1 )

        FT_INVALID_DATA;

    }

    OTV_EXIT;

  }

  /* `uy' in the function's name is not really correct since only y-1 */

  /* elements are tested                                              */

  /* uses valid->extra1 (array value limit) */

  FT_LOCAL_DEF( void )

  otv_x_ux_y_uy_z_uz_p_sp( FT_Bytes       table,

                           OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   BacktrackCount, InputCount, LookaheadCount;

    FT_UInt   Count;

    OTV_ENTER;

    OTV_LIMIT_CHECK( 2 );

    BacktrackCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (BacktrackCount = %d)\n", BacktrackCount ));

    OTV_LIMIT_CHECK( BacktrackCount * 2 + 2 );

    p += BacktrackCount * 2;

    InputCount = FT_NEXT_USHORT( p );

    if ( InputCount == 0 )

      FT_INVALID_DATA;

    OTV_TRACE(( " (InputCount = %d)\n", InputCount ));

    OTV_LIMIT_CHECK( InputCount * 2 );

    p += ( InputCount - 1 ) * 2;

    LookaheadCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (LookaheadCount = %d)\n", LookaheadCount ));

    OTV_LIMIT_CHECK( LookaheadCount * 2 + 2 );

    p += LookaheadCount * 2;

    Count = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (Count = %d)\n", Count ));

    OTV_LIMIT_CHECK( Count * 4 );

    for ( ; Count > 0; Count-- )

    {

      if ( FT_NEXT_USHORT( p ) >= InputCount )

        FT_INVALID_DATA;

      if ( FT_NEXT_USHORT( p ) >= valid->extra1 )

        FT_INVALID_DATA;

    }

    OTV_EXIT;

  }

  /* sets valid->extra1 (valid->lookup_count) */

  FT_LOCAL_DEF( void )

  otv_u_O_O_x_Onx( FT_Bytes       table,

                   OTV_Validator  valid )

  {

    FT_Bytes           p = table;

    FT_UInt            Coverage, ClassDef, ClassSetCount;

    OTV_Validate_Func  func;

    OTV_ENTER;

    p += 2;     /* skip Format */

    OTV_LIMIT_CHECK( 6 );

    Coverage      = FT_NEXT_USHORT( p );

    ClassDef      = FT_NEXT_USHORT( p );

    ClassSetCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (ClassSetCount = %d)\n", ClassSetCount ));

    otv_Coverage_validate( table + Coverage, valid, -1 );

    otv_ClassDef_validate( table + ClassDef, valid );

    OTV_LIMIT_CHECK( ClassSetCount * 2 );

    valid->nesting_level++;

    func          = valid->func[valid->nesting_level];

    valid->extra1 = valid->lookup_count;

    for ( ; ClassSetCount > 0; ClassSetCount-- )

    {

      FT_UInt  offset = FT_NEXT_USHORT( p );

      if ( offset )

        func( table + offset, valid );

    }

    valid->nesting_level--;

    OTV_EXIT;

  }

  /* uses valid->lookup_count */

  FT_LOCAL_DEF( void )

  otv_u_x_y_Ox_sy( FT_Bytes       table,

                   OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   GlyphCount, Count, count1;

    OTV_ENTER;

    p += 2;     /* skip Format */

    OTV_LIMIT_CHECK( 4 );

    GlyphCount = FT_NEXT_USHORT( p );

    Count      = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));

    OTV_TRACE(( " (Count = %d)\n",      Count      ));

    OTV_LIMIT_CHECK( GlyphCount * 2 + Count * 4 );

    for ( count1 = GlyphCount; count1 > 0; count1-- )

      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );

    for ( ; Count > 0; Count-- )

    {

      if ( FT_NEXT_USHORT( p ) >= GlyphCount )

        FT_INVALID_DATA;

      if ( FT_NEXT_USHORT( p ) >= valid->lookup_count )

        FT_INVALID_DATA;

    }

    OTV_EXIT;

  }

  /* sets valid->extra1 (valid->lookup_count)    */

  FT_LOCAL_DEF( void )

  otv_u_O_O_O_O_x_Onx( FT_Bytes       table,

                       OTV_Validator  valid )

  {

    FT_Bytes           p = table;

    FT_UInt            Coverage;

    FT_UInt            BacktrackClassDef, InputClassDef, LookaheadClassDef;

    FT_UInt            ChainClassSetCount;

    OTV_Validate_Func  func;

    OTV_ENTER;

    p += 2;     /* skip Format */

    OTV_LIMIT_CHECK( 10 );

    Coverage           = FT_NEXT_USHORT( p );

    BacktrackClassDef  = FT_NEXT_USHORT( p );

    InputClassDef      = FT_NEXT_USHORT( p );

    LookaheadClassDef  = FT_NEXT_USHORT( p );

    ChainClassSetCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (ChainClassSetCount = %d)\n", ChainClassSetCount ));

    otv_Coverage_validate( table + Coverage, valid, -1 );

    otv_ClassDef_validate( table + BacktrackClassDef,  valid );

    otv_ClassDef_validate( table + InputClassDef, valid );

    otv_ClassDef_validate( table + LookaheadClassDef, valid );

    OTV_LIMIT_CHECK( ChainClassSetCount * 2 );

    valid->nesting_level++;

    func          = valid->func[valid->nesting_level];

    valid->extra1 = valid->lookup_count;

    for ( ; ChainClassSetCount > 0; ChainClassSetCount-- )

    {

      FT_UInt  offset = FT_NEXT_USHORT( p );

      if ( offset )

        func( table + offset, valid );

    }

    valid->nesting_level--;

    OTV_EXIT;

  }

  /* uses valid->lookup_count */

  FT_LOCAL_DEF( void )

  otv_u_x_Ox_y_Oy_z_Oz_p_sp( FT_Bytes       table,

                             OTV_Validator  valid )

  {

    FT_Bytes  p = table;

    FT_UInt   BacktrackGlyphCount, InputGlyphCount, LookaheadGlyphCount;

    FT_UInt   count1, count2;

    OTV_ENTER;

    p += 2;     /* skip Format */

    OTV_LIMIT_CHECK( 2 );

    BacktrackGlyphCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (BacktrackGlyphCount = %d)\n", BacktrackGlyphCount ));

    OTV_LIMIT_CHECK( BacktrackGlyphCount * 2 + 2 );

    for ( ; BacktrackGlyphCount > 0; BacktrackGlyphCount-- )

      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );

    InputGlyphCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (InputGlyphCount = %d)\n", InputGlyphCount ));

    OTV_LIMIT_CHECK( InputGlyphCount * 2 + 2 );

    for ( count1 = InputGlyphCount; count1 > 0; count1-- )

      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );

    LookaheadGlyphCount = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (LookaheadGlyphCount = %d)\n", LookaheadGlyphCount ));

    OTV_LIMIT_CHECK( LookaheadGlyphCount * 2 + 2 );

    for ( ; LookaheadGlyphCount > 0; LookaheadGlyphCount-- )

      otv_Coverage_validate( table + FT_NEXT_USHORT( p ), valid, -1 );

    count2 = FT_NEXT_USHORT( p );

    OTV_TRACE(( " (Count = %d)\n", count2 ));

    OTV_LIMIT_CHECK( count2 * 4 );

    for ( ; count2 > 0; count2-- )

    {

      if ( FT_NEXT_USHORT( p ) >= InputGlyphCount )

        FT_INVALID_DATA;

      if ( FT_NEXT_USHORT( p ) >= valid->lookup_count )

        FT_INVALID_DATA;

    }

    OTV_EXIT;

  }

  FT_LOCAL_DEF( FT_UInt )

  otv_GSUBGPOS_get_Lookup_count( FT_Bytes  table )

  {

    FT_Bytes  p = table + 8;

    return otv_LookupList_get_count( table + FT_NEXT_USHORT( p ) );

  }

  FT_LOCAL_DEF( FT_UInt )

  otv_GSUBGPOS_have_MarkAttachmentType_flag( FT_Bytes  table )

  {

    FT_Bytes  p, lookup;

    FT_UInt   count;

    if ( !table )

      return 0;

    /* LookupList */

    p      = table + 8;

    table += FT_NEXT_USHORT( p );

    /* LookupCount */

    p     = table;

    count = FT_NEXT_USHORT( p );

    for ( ; count > 0; count-- )

    {

      FT_Bytes  oldp;

      /* Lookup */

      lookup = table + FT_NEXT_USHORT( p );

      oldp = p;

      /* LookupFlag */

      p = lookup + 2;

      if ( FT_NEXT_USHORT( p ) & 0xFF00U )

        return 1;

      p = oldp;

    }

    return 0;

  }

/* END */