otvgpos.c File Reference

#include "otvalid.h"
#include "otvcommn.h"
#include "otvgpos.h"

Include dependency graph for otvgpos.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FT_COMPONENT   trace_otvgpos
#define	BaseArrayFunc   otv_x_sxy
#define	LigatureAttachFunc   otv_x_sxy
#define	Mark2ArrayFunc   otv_x_sxy
#define	MarkBasePosFormat1Func   otv_u_O_O_u_O_O
#define	MarkLigPosFormat1Func   otv_u_O_O_u_O_O
#define	MarkMarkPosFormat1Func   otv_u_O_O_u_O_O

Functions
static void	otv_Anchor_validate (FT_Bytes table, OTV_Validator valid)
static void	otv_MarkArray_validate (FT_Bytes table, OTV_Validator valid)
static void	otv_x_sxy (FT_Bytes table, OTV_Validator otvalid)
static void	otv_u_O_O_u_O_O (FT_Bytes table, OTV_Validator otvalid)
static FT_UInt	otv_value_length (FT_UInt format)
static void	otv_ValueRecord_validate (FT_Bytes table, FT_UInt format, OTV_Validator otvalid)
static void	otv_SinglePos_validate (FT_Bytes table, OTV_Validator otvalid)
static void	otv_PairSet_validate (FT_Bytes table, FT_UInt format1, FT_UInt format2, OTV_Validator otvalid)
static void	otv_PairPos_validate (FT_Bytes table, OTV_Validator otvalid)
static void	otv_CursivePos_validate (FT_Bytes table, OTV_Validator otvalid)
static void	otv_MarkBasePos_validate (FT_Bytes table, OTV_Validator otvalid)
static void	otv_MarkLigPos_validate (FT_Bytes table, OTV_Validator otvalid)
static void	otv_MarkMarkPos_validate (FT_Bytes table, OTV_Validator otvalid)
static void	otv_ContextPos_validate (FT_Bytes table, OTV_Validator otvalid)
static void	otv_ChainContextPos_validate (FT_Bytes table, OTV_Validator otvalid)
static void	otv_ExtensionPos_validate (FT_Bytes table, OTV_Validator otvalid)
	otv_GPOS_subtable_validate (FT_Bytes table, OTV_Validator otvalid)
	otv_GPOS_validate (FT_Bytes table, FT_UInt glyph_count, FT_Validator ftvalid)

Variables
static const OTV_Validate_Func	otv_gpos_validate_funcs [9]

Macro Definition Documentation

BaseArrayFunc

#define BaseArrayFunc   otv_x_sxy

Definition at line 51 of file otvgpos.c.

FT_COMPONENT

#define FT_COMPONENT   trace_otvgpos

Definition at line 31 of file otvgpos.c.

LigatureAttachFunc

#define LigatureAttachFunc   otv_x_sxy

Definition at line 52 of file otvgpos.c.

Mark2ArrayFunc

#define Mark2ArrayFunc   otv_x_sxy

Definition at line 53 of file otvgpos.c.

MarkBasePosFormat1Func

#define MarkBasePosFormat1Func   otv_u_O_O_u_O_O

Definition at line 100 of file otvgpos.c.

MarkLigPosFormat1Func

#define MarkLigPosFormat1Func   otv_u_O_O_u_O_O

Definition at line 101 of file otvgpos.c.

MarkMarkPosFormat1Func

#define MarkMarkPosFormat1Func   otv_u_O_O_u_O_O

Definition at line 102 of file otvgpos.c.

Function Documentation

otv_Anchor_validate()

static void otv_Anchor_validate ( FT_Bytes  table, OTV_Validator  valid  )

static

Definition at line 243 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   AnchorFormat;
 
 
    OTV_NAME_ENTER( "Anchor");
 
    OTV_LIMIT_CHECK( 6 );
    AnchorFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", AnchorFormat ));
 
    p += 4;     /* skip XCoordinate and YCoordinate */
 
    switch ( AnchorFormat )
    {
    case 1:
      break;
 
    case 2:
      OTV_LIMIT_CHECK( 2 );  /* AnchorPoint */
      break;
 
    case 3:
      {
        FT_UInt  table_size;
 
        OTV_OPTIONAL_TABLE( XDeviceTable );
        OTV_OPTIONAL_TABLE( YDeviceTable );
 
 
        OTV_LIMIT_CHECK( 4 );
        OTV_OPTIONAL_OFFSET( XDeviceTable );
        OTV_OPTIONAL_OFFSET( YDeviceTable );
 
        table_size = 6 + 4;
 
        OTV_SIZE_CHECK( XDeviceTable );
        if ( XDeviceTable )
          otv_Device_validate( table + XDeviceTable, otvalid );
 
        OTV_SIZE_CHECK( YDeviceTable );
        if ( YDeviceTable )
          otv_Device_validate( table + YDeviceTable, otvalid );
      }
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

Referenced by otv_CursivePos_validate(), otv_MarkArray_validate(), and otv_x_sxy().

otv_ChainContextPos_validate()

static void otv_ChainContextPos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 839 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "ChainContextPos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    switch ( PosFormat )
    {
    case 1:
      /* no need to check glyph indices/classes used as input for these */
      /* context rules since even invalid glyph indices/classes return  */
      /* meaningful results                                             */
 
      otvalid->extra1 = otvalid->lookup_count;
      OTV_NEST3( ChainContextPosFormat1,
                 ChainPosRuleSet, ChainPosRule );
      OTV_RUN( table, otvalid );
      break;
 
    case 2:
      /* no need to check glyph indices/classes used as input for these */
      /* context rules since even invalid glyph indices/classes return  */
      /* meaningful results                                             */
 
      OTV_NEST3( ChainContextPosFormat2,
                 ChainPosClassSet, ChainPosClassRule );
      OTV_RUN( table, otvalid );
      break;
 
    case 3:
      OTV_NEST1( ChainContextPosFormat3 );
      OTV_RUN( table, otvalid );
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_ContextPos_validate()

static void otv_ContextPos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 780 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "ContextPos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    switch ( PosFormat )
    {
    case 1:
      /* no need to check glyph indices/classes used as input for these */
      /* context rules since even invalid glyph indices/classes return  */
      /* meaningful results                                             */
 
      otvalid->extra1 = otvalid->lookup_count;
      OTV_NEST3( ContextPosFormat1, PosRuleSet, PosRule );
      OTV_RUN( table, otvalid );
      break;
 
    case 2:
      /* no need to check glyph indices/classes used as input for these */
      /* context rules since even invalid glyph indices/classes return  */
      /* meaningful results                                             */
 
      OTV_NEST3( ContextPosFormat2, PosClassSet, PosClassRule );
      OTV_RUN( table, otvalid );
      break;
 
    case 3:
      OTV_NEST1( ContextPosFormat3 );
      OTV_RUN( table, otvalid );
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_CursivePos_validate()

static void otv_CursivePos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 579 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "CursivePos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    switch ( PosFormat )
    {
    case 1:     /* CursivePosFormat1 */
      {
        FT_UInt   table_size;
        FT_UInt   Coverage, EntryExitCount;
 
        OTV_OPTIONAL_TABLE( EntryAnchor );
        OTV_OPTIONAL_TABLE( ExitAnchor  );
 
 
        OTV_LIMIT_CHECK( 4 );
        Coverage       = FT_NEXT_USHORT( p );
        EntryExitCount = FT_NEXT_USHORT( p );
 
        OTV_TRACE(( " (EntryExitCount = %d)\n", EntryExitCount ));
 
        otv_Coverage_validate( table + Coverage,
                               otvalid,
                               (FT_Int)EntryExitCount );
 
        OTV_LIMIT_CHECK( EntryExitCount * 4 );
 
        table_size = EntryExitCount * 4 + 4;
 
        /* EntryExitRecord */
        for ( ; EntryExitCount > 0; EntryExitCount-- )
        {
          OTV_OPTIONAL_OFFSET( EntryAnchor );
          OTV_OPTIONAL_OFFSET( ExitAnchor  );
 
          OTV_SIZE_CHECK( EntryAnchor );
          if ( EntryAnchor )
            otv_Anchor_validate( table + EntryAnchor, otvalid );
 
          OTV_SIZE_CHECK( ExitAnchor );
          if ( ExitAnchor )
            otv_Anchor_validate( table + ExitAnchor, otvalid );
        }
      }
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_ExtensionPos_validate()

static void otv_ExtensionPos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 900 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "ExtensionPos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    switch ( PosFormat )
    {
    case 1:     /* ExtensionPosFormat1 */
      {
        FT_UInt            ExtensionLookupType;
        FT_ULong           ExtensionOffset;
        OTV_Validate_Func  validate;
 
 
        OTV_LIMIT_CHECK( 6 );
        ExtensionLookupType = FT_NEXT_USHORT( p );
        ExtensionOffset     = FT_NEXT_ULONG( p );
 
        if ( ExtensionLookupType == 0 || ExtensionLookupType >= 9 )
          FT_INVALID_DATA;
 
        validate = otvalid->type_funcs[ExtensionLookupType - 1];
        validate( table + ExtensionOffset, otvalid );
      }
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_GPOS_subtable_validate()

otv_GPOS_subtable_validate	(	FT_Bytes	table,
		OTV_Validator	otvalid
	)

Definition at line 961 of file otvgpos.c.

  {
    otvalid->type_count = 9;
    otvalid->type_funcs = (OTV_Validate_Func*)otv_gpos_validate_funcs;
 
    otv_Lookup_validate( table, otvalid );
  }

otv_GPOS_validate()

otv_GPOS_validate	(	FT_Bytes	table,
		FT_UInt	glyph_count,
		FT_Validator	ftvalid
	)

Definition at line 982 of file otvgpos.c.

  {
    OTV_ValidatorRec  validrec;
    OTV_Validator     otvalid = &validrec;
    FT_Bytes          p       = table;
    FT_UInt           table_size;
    FT_UShort         version;
    FT_UInt           ScriptList, FeatureList, LookupList;
 
    OTV_OPTIONAL_TABLE32( featureVariations );
 
 
    otvalid->root = ftvalid;
 
    FT_TRACE3(( "validating GPOS table\n" ));
    OTV_INIT;
 
    OTV_LIMIT_CHECK( 4 );
 
    if ( FT_NEXT_USHORT( p ) != 1 )  /* majorVersion */
      FT_INVALID_FORMAT;
 
    version = FT_NEXT_USHORT( p );   /* minorVersion */
 
    table_size = 10;
    switch ( version )
    {
    case 0:
      OTV_LIMIT_CHECK( 6 );
      break;
 
    case 1:
      OTV_LIMIT_CHECK( 10 );
      table_size += 4;
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    ScriptList  = FT_NEXT_USHORT( p );
    FeatureList = FT_NEXT_USHORT( p );
    LookupList  = FT_NEXT_USHORT( p );
 
    otvalid->type_count  = 9;
    otvalid->type_funcs  = (OTV_Validate_Func*)otv_gpos_validate_funcs;
    otvalid->glyph_count = glyph_count;
 
    otv_LookupList_validate( table + LookupList,
                             otvalid );
    otv_FeatureList_validate( table + FeatureList, table + LookupList,
                              otvalid );
    otv_ScriptList_validate( table + ScriptList, table + FeatureList,
                             otvalid );
 
    if ( version > 0 )
    {
      OTV_OPTIONAL_OFFSET32( featureVariations );
      OTV_SIZE_CHECK32( featureVariations );
      if ( featureVariations )
        OTV_TRACE(( "  [omitting featureVariations validation]\n" )); /* XXX */
    }
 
    FT_TRACE4(( "\n" ));
  }

Referenced by otv_validate().

otv_MarkArray_validate()

static void otv_MarkArray_validate ( FT_Bytes  table, OTV_Validator  valid  )

static

Definition at line 309 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   MarkCount;
 
 
    OTV_NAME_ENTER( "MarkArray" );
 
    OTV_LIMIT_CHECK( 2 );
    MarkCount = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (MarkCount = %d)\n", MarkCount ));
 
    OTV_LIMIT_CHECK( MarkCount * 4 );
 
    /* MarkRecord */
    for ( ; MarkCount > 0; MarkCount-- )
    {
      p += 2;   /* skip Class */
      /* MarkAnchor */
      otv_Anchor_validate( table + FT_NEXT_USHORT( p ), otvalid );
    }
 
    OTV_EXIT;
  }

Referenced by otv_u_O_O_u_O_O().

otv_MarkBasePos_validate()

static void otv_MarkBasePos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 657 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "MarkBasePos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    switch ( PosFormat )
    {
    case 1:
      otvalid->extra2 = 1;
      OTV_NEST2( MarkBasePosFormat1, BaseArray );
      OTV_RUN( table, otvalid );
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_MarkLigPos_validate()

static void otv_MarkLigPos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 698 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "MarkLigPos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    switch ( PosFormat )
    {
    case 1:
      otvalid->extra2 = 1;
      OTV_NEST3( MarkLigPosFormat1, LigatureArray, LigatureAttach );
      OTV_RUN( table, otvalid );
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_MarkMarkPos_validate()

static void otv_MarkMarkPos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 739 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "MarkMarkPos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    switch ( PosFormat )
    {
    case 1:
      otvalid->extra2 = 0;
      OTV_NEST2( MarkMarkPosFormat1, Mark2Array );
      OTV_RUN( table, otvalid );
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_PairPos_validate()

static void otv_PairPos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 472 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "PairPos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    switch ( PosFormat )
    {
    case 1:     /* PairPosFormat1 */
      {
        FT_UInt  Coverage, ValueFormat1, ValueFormat2, PairSetCount;
 
 
        OTV_LIMIT_CHECK( 8 );
        Coverage     = FT_NEXT_USHORT( p );
        ValueFormat1 = FT_NEXT_USHORT( p );
        ValueFormat2 = FT_NEXT_USHORT( p );
        PairSetCount = FT_NEXT_USHORT( p );
 
        OTV_TRACE(( " (PairSetCount = %d)\n", PairSetCount ));
 
        otv_Coverage_validate( table + Coverage, otvalid, -1 );
 
        OTV_LIMIT_CHECK( PairSetCount * 2 );
 
        /* PairSetOffset */
        for ( ; PairSetCount > 0; PairSetCount-- )
          otv_PairSet_validate( table + FT_NEXT_USHORT( p ),
                                ValueFormat1, ValueFormat2, otvalid );
      }
      break;
 
    case 2:     /* PairPosFormat2 */
      {
        FT_UInt  Coverage, ValueFormat1, ValueFormat2, ClassDef1, ClassDef2;
        FT_UInt  ClassCount1, ClassCount2, len_value1, len_value2, count;
 
 
        OTV_LIMIT_CHECK( 14 );
        Coverage     = FT_NEXT_USHORT( p );
        ValueFormat1 = FT_NEXT_USHORT( p );
        ValueFormat2 = FT_NEXT_USHORT( p );
        ClassDef1    = FT_NEXT_USHORT( p );
        ClassDef2    = FT_NEXT_USHORT( p );
        ClassCount1  = FT_NEXT_USHORT( p );
        ClassCount2  = FT_NEXT_USHORT( p );
 
        OTV_TRACE(( " (ClassCount1 = %d)\n", ClassCount1 ));
        OTV_TRACE(( " (ClassCount2 = %d)\n", ClassCount2 ));
 
        len_value1 = otv_value_length( ValueFormat1 );
        len_value2 = otv_value_length( ValueFormat2 );
 
        otv_Coverage_validate( table + Coverage, otvalid, -1 );
        otv_ClassDef_validate( table + ClassDef1, otvalid );
        otv_ClassDef_validate( table + ClassDef2, otvalid );
 
        OTV_LIMIT_CHECK( ClassCount1 * ClassCount2 *
                         ( len_value1 + len_value2 ) );
 
        otvalid->extra3 = table;
 
        /* Class1Record */
        for ( ; ClassCount1 > 0; ClassCount1-- )
        {
          /* Class2Record */
          for ( count = ClassCount2; count > 0; count-- )
          {
            if ( ValueFormat1 )
              /* Value1 */
              otv_ValueRecord_validate( p, ValueFormat1, otvalid );
            p += len_value1;
 
            if ( ValueFormat2 )
              /* Value2 */
              otv_ValueRecord_validate( p, ValueFormat2, otvalid );
            p += len_value2;
          }
        }
      }
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_PairSet_validate()

static void otv_PairSet_validate ( FT_Bytes  table, FT_UInt  format1, FT_UInt  format2, OTV_Validator  otvalid  )

static

Definition at line 428 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   value_len1, value_len2, PairValueCount;
 
 
    OTV_NAME_ENTER( "PairSet" );
 
    otvalid->extra3 = table;
 
    OTV_LIMIT_CHECK( 2 );
    PairValueCount = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (PairValueCount = %d)\n", PairValueCount ));
 
    value_len1 = otv_value_length( format1 );
    value_len2 = otv_value_length( format2 );
 
    OTV_LIMIT_CHECK( PairValueCount * ( value_len1 + value_len2 + 2 ) );
 
    /* PairValueRecord */
    for ( ; PairValueCount > 0; PairValueCount-- )
    {
      p += 2;       /* skip SecondGlyph */
 
      if ( format1 )
        otv_ValueRecord_validate( p, format1, otvalid ); /* Value1 */
      p += value_len1;
 
      if ( format2 )
        otv_ValueRecord_validate( p, format2, otvalid ); /* Value2 */
      p += value_len2;
    }
 
    OTV_EXIT;
  }

Referenced by otv_PairPos_validate().

otv_SinglePos_validate()

static void otv_SinglePos_validate ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 348 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   PosFormat;
 
 
    OTV_NAME_ENTER( "SinglePos" );
 
    OTV_LIMIT_CHECK( 2 );
    PosFormat = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (format %d)\n", PosFormat ));
 
    otvalid->extra3 = table;
 
    switch ( PosFormat )
    {
    case 1:     /* SinglePosFormat1 */
      {
        FT_UInt  Coverage, ValueFormat;
 
 
        OTV_LIMIT_CHECK( 4 );
        Coverage    = FT_NEXT_USHORT( p );
        ValueFormat = FT_NEXT_USHORT( p );
 
        otv_Coverage_validate( table + Coverage, otvalid, -1 );
        otv_ValueRecord_validate( p, ValueFormat, otvalid ); /* Value */
      }
      break;
 
    case 2:     /* SinglePosFormat2 */
      {
        FT_UInt  Coverage, ValueFormat, ValueCount, len_value;
 
 
        OTV_LIMIT_CHECK( 6 );
        Coverage    = FT_NEXT_USHORT( p );
        ValueFormat = FT_NEXT_USHORT( p );
        ValueCount  = FT_NEXT_USHORT( p );
 
        OTV_TRACE(( " (ValueCount = %d)\n", ValueCount ));
 
        len_value = otv_value_length( ValueFormat );
 
        otv_Coverage_validate( table + Coverage,
                               otvalid,
                               (FT_Int)ValueCount );
 
        OTV_LIMIT_CHECK( ValueCount * len_value );
 
        /* Value */
        for ( ; ValueCount > 0; ValueCount-- )
        {
          otv_ValueRecord_validate( p, ValueFormat, otvalid );
          p += len_value;
        }
      }
      break;
 
    default:
      FT_INVALID_FORMAT;
    }
 
    OTV_EXIT;
  }

otv_u_O_O_u_O_O()

static void otv_u_O_O_u_O_O ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 107 of file otvgpos.c.

  {
    FT_Bytes           p = table;
    FT_UInt            Coverage1, Coverage2, ClassCount;
    FT_UInt            Array1, Array2;
    OTV_Validate_Func  func;
 
 
    OTV_ENTER;
 
    p += 2;     /* skip PosFormat */
 
    OTV_LIMIT_CHECK( 10 );
    Coverage1  = FT_NEXT_USHORT( p );
    Coverage2  = FT_NEXT_USHORT( p );
    ClassCount = FT_NEXT_USHORT( p );
    Array1     = FT_NEXT_USHORT( p );
    Array2     = FT_NEXT_USHORT( p );
 
    otv_Coverage_validate( table + Coverage1, otvalid, -1 );
    otv_Coverage_validate( table + Coverage2, otvalid, -1 );
 
    otv_MarkArray_validate( table + Array1, otvalid );
 
    otvalid->nesting_level++;
    func            = otvalid->func[otvalid->nesting_level];
    otvalid->extra1 = ClassCount;
 
    func( table + Array2, otvalid );
 
    otvalid->nesting_level--;
 
    OTV_EXIT;
  }

otv_value_length()

static FT_UInt otv_value_length ( FT_UInt  format )

static

Definition at line 153 of file otvgpos.c.

  {
    FT_UInt  count;
 
 
    count = ( ( format & 0xAA ) >> 1 ) + ( format & 0x55 );
    count = ( ( count  & 0xCC ) >> 2 ) + ( count  & 0x33 );
    count = ( ( count  & 0xF0 ) >> 4 ) + ( count  & 0x0F );
 
    return count * 2;
  }

Referenced by otv_PairPos_validate(), otv_PairSet_validate(), and otv_SinglePos_validate().

otv_ValueRecord_validate()

static void otv_ValueRecord_validate ( FT_Bytes  table, FT_UInt  format, OTV_Validator  otvalid  )

static

Definition at line 169 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   count;
 
#ifdef FT_DEBUG_LEVEL_TRACE
    FT_Int    loop;
    FT_ULong  res = 0;
 
 
    OTV_NAME_ENTER( "ValueRecord" );
 
    /* display `format' in dual representation */
    for ( loop = 7; loop >= 0; loop-- )
    {
      res <<= 4;
      res  += ( format >> loop ) & 1;
    }
 
    OTV_TRACE(( " (format 0b%08lx)\n", res ));
#endif
 
    if ( format >= 0x100 )
      FT_INVALID_FORMAT;
 
    for ( count = 4; count > 0; count-- )
    {
      if ( format & 1 )
      {
        /* XPlacement, YPlacement, XAdvance, YAdvance */
        OTV_LIMIT_CHECK( 2 );
        p += 2;
      }
 
      format >>= 1;
    }
 
    for ( count = 4; count > 0; count-- )
    {
      if ( format & 1 )
      {
        FT_PtrDist  table_size;
 
        OTV_OPTIONAL_TABLE( device );
 
 
        /* XPlaDevice, YPlaDevice, XAdvDevice, YAdvDevice */
        OTV_LIMIT_CHECK( 2 );
        OTV_OPTIONAL_OFFSET( device );
 
        table_size = p - otvalid->extra3;
 
        OTV_SIZE_CHECK( device );
        if ( device )
          otv_Device_validate( otvalid->extra3 + device, otvalid );
      }
      format >>= 1;
    }
 
    OTV_EXIT;
  }

Referenced by otv_PairPos_validate(), otv_PairSet_validate(), and otv_SinglePos_validate().

otv_x_sxy()

static void otv_x_sxy ( FT_Bytes  table, OTV_Validator  otvalid  )

static

Definition at line 59 of file otvgpos.c.

  {
    FT_Bytes  p = table;
    FT_UInt   Count, count1, table_size;
 
 
    OTV_ENTER;
 
    OTV_LIMIT_CHECK( 2 );
 
    Count = FT_NEXT_USHORT( p );
 
    OTV_TRACE(( " (Count = %d)\n", Count ));
 
    OTV_LIMIT_CHECK( Count * otvalid->extra1 * 2 );
 
    table_size = Count * otvalid->extra1 * 2 + 2;
 
    for ( ; Count > 0; Count-- )
      for ( count1 = otvalid->extra1; count1 > 0; count1-- )
      {
        OTV_OPTIONAL_TABLE( anchor_offset );
 
 
        OTV_OPTIONAL_OFFSET( anchor_offset );
 
        if ( otvalid->extra2 )
        {
          OTV_SIZE_CHECK( anchor_offset );
          if ( anchor_offset )
            otv_Anchor_validate( table + anchor_offset, otvalid );
        }
        else
          otv_Anchor_validate( table + anchor_offset, otvalid );
      }
 
    OTV_EXIT;
  }

Variable Documentation

otv_gpos_validate_funcs

const OTV_Validate_Func otv_gpos_validate_funcs[9]

static

Initial value:

=
  {
    otv_SinglePos_validate,
    otv_PairPos_validate,
    otv_CursivePos_validate,
    otv_MarkBasePos_validate,
    otv_MarkLigPos_validate,
    otv_MarkMarkPos_validate,
    otv_ContextPos_validate,
    otv_ChainContextPos_validate,
    otv_ExtensionPos_validate
  }

Definition at line 943 of file otvgpos.c.

Referenced by otv_GPOS_subtable_validate(), and otv_GPOS_validate().