/***************************************************************************/ | |
/* */ | |
/* otvcommn.c */ | |
/* */ | |
/* OpenType common tables validation (body). */ | |
/* */ | |
/* Copyright 2004-2015 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 otvalid, | |
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 >= otvalid->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 >= otvalid->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 otvalid ) | |
{ | |
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 >= otvalid->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 >= otvalid->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 otvalid ) | |
{ | |
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 otvalid->type_count */ | |
/* uses otvalid->type_funcs */ | |
FT_LOCAL_DEF( void ) | |
otv_Lookup_validate( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 > otvalid->type_count ) | |
FT_INVALID_DATA; | |
validate = otvalid->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 ), otvalid ); | |
OTV_EXIT; | |
} | |
/* uses valid->lookup_count */ | |
FT_LOCAL_DEF( void ) | |
otv_LookupList_validate( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 ); | |
otvalid->lookup_count = LookupCount; | |
/* Lookup */ | |
for ( ; LookupCount > 0; LookupCount-- ) | |
otv_Lookup_validate( table + FT_NEXT_USHORT( p ), otvalid ); | |
OTV_EXIT; | |
} | |
static FT_UInt | |
otv_LookupList_get_count( FT_Bytes table ) | |
{ | |
return FT_NEXT_USHORT( table ); | |
} | |
/*************************************************************************/ | |
/*************************************************************************/ | |
/***** *****/ | |
/***** FEATURES *****/ | |
/***** *****/ | |
/*************************************************************************/ | |
/*************************************************************************/ | |
/* uses otvalid->lookup_count */ | |
FT_LOCAL_DEF( void ) | |
otv_Feature_validate( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 ) >= otvalid->lookup_count ) | |
FT_INVALID_DATA; | |
OTV_EXIT; | |
} | |
static FT_UInt | |
otv_Feature_get_count( FT_Bytes table ) | |
{ | |
return FT_NEXT_USHORT( table ); | |
} | |
/* sets otvalid->lookup_count */ | |
FT_LOCAL_DEF( void ) | |
otv_FeatureList_validate( FT_Bytes table, | |
FT_Bytes lookups, | |
OTV_Validator otvalid ) | |
{ | |
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 ); | |
otvalid->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 ), otvalid ); | |
} | |
OTV_EXIT; | |
} | |
/*************************************************************************/ | |
/*************************************************************************/ | |
/***** *****/ | |
/***** LANGUAGE SYSTEM *****/ | |
/***** *****/ | |
/*************************************************************************/ | |
/*************************************************************************/ | |
/* uses otvalid->extra1 (number of features) */ | |
FT_LOCAL_DEF( void ) | |
otv_LangSys_validate( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 >= otvalid->extra1 ) | |
FT_INVALID_DATA; | |
OTV_LIMIT_CHECK( FeatureCount * 2 ); | |
/* FeatureIndex */ | |
for ( ; FeatureCount > 0; FeatureCount-- ) | |
if ( FT_NEXT_USHORT( p ) >= otvalid->extra1 ) | |
FT_INVALID_DATA; | |
OTV_EXIT; | |
} | |
/*************************************************************************/ | |
/*************************************************************************/ | |
/***** *****/ | |
/***** SCRIPTS *****/ | |
/***** *****/ | |
/*************************************************************************/ | |
/*************************************************************************/ | |
FT_LOCAL_DEF( void ) | |
otv_Script_validate( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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, otvalid ); | |
OTV_LIMIT_CHECK( LangSysCount * 6 ); | |
/* LangSysRecord */ | |
for ( ; LangSysCount > 0; LangSysCount-- ) | |
{ | |
p += 4; /* skip LangSysTag */ | |
/* LangSys */ | |
otv_LangSys_validate( table + FT_NEXT_USHORT( p ), otvalid ); | |
} | |
OTV_EXIT; | |
} | |
/* sets otvalid->extra1 (number of features) */ | |
FT_LOCAL_DEF( void ) | |
otv_ScriptList_validate( FT_Bytes table, | |
FT_Bytes features, | |
OTV_Validator otvalid ) | |
{ | |
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 ); | |
otvalid->extra1 = otv_Feature_get_count( features ); | |
/* ScriptRecord */ | |
for ( ; ScriptCount > 0; ScriptCount-- ) | |
{ | |
p += 4; /* skip ScriptTag */ | |
otv_Script_validate( table + FT_NEXT_USHORT( p ), otvalid ); /* 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 otvalid ) | |
{ | |
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 ); | |
otvalid->nesting_level++; | |
func = otvalid->func[otvalid->nesting_level]; | |
for ( ; Count > 0; Count-- ) | |
func( table + FT_NEXT_USHORT( p ), otvalid ); | |
otvalid->nesting_level--; | |
OTV_EXIT; | |
} | |
FT_LOCAL_DEF( void ) | |
otv_u_C_x_Ox( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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, otvalid, (FT_Int)Count ); | |
OTV_LIMIT_CHECK( Count * 2 ); | |
otvalid->nesting_level++; | |
func = otvalid->func[otvalid->nesting_level]; | |
for ( ; Count > 0; Count-- ) | |
func( table + FT_NEXT_USHORT( p ), otvalid ); | |
otvalid->nesting_level--; | |
OTV_EXIT; | |
} | |
/* uses otvalid->extra1 (if > 0: array value limit) */ | |
FT_LOCAL_DEF( void ) | |
otv_x_ux( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 ( otvalid->extra1 ) | |
{ | |
for ( ; Count > 0; Count-- ) | |
if ( FT_NEXT_USHORT( p ) >= otvalid->extra1 ) | |
FT_INVALID_DATA; | |
} | |
OTV_EXIT; | |
} | |
/* `ux' in the function's name is not really correct since only x-1 */ | |
/* elements are tested */ | |
/* uses otvalid->extra1 (array value limit) */ | |
FT_LOCAL_DEF( void ) | |
otv_x_y_ux_sy( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 ) >= otvalid->extra1 ) | |
FT_INVALID_DATA; | |
} | |
OTV_EXIT; | |
} | |
/* `uy' in the function's name is not really correct since only y-1 */ | |
/* elements are tested */ | |
/* uses otvalid->extra1 (array value limit) */ | |
FT_LOCAL_DEF( void ) | |
otv_x_ux_y_uy_z_uz_p_sp( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 ) >= otvalid->extra1 ) | |
FT_INVALID_DATA; | |
} | |
OTV_EXIT; | |
} | |
/* sets otvalid->extra1 (valid->lookup_count) */ | |
FT_LOCAL_DEF( void ) | |
otv_u_O_O_x_Onx( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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, otvalid, -1 ); | |
otv_ClassDef_validate( table + ClassDef, otvalid ); | |
OTV_LIMIT_CHECK( ClassSetCount * 2 ); | |
otvalid->nesting_level++; | |
func = otvalid->func[otvalid->nesting_level]; | |
otvalid->extra1 = otvalid->lookup_count; | |
for ( ; ClassSetCount > 0; ClassSetCount-- ) | |
{ | |
FT_UInt offset = FT_NEXT_USHORT( p ); | |
if ( offset ) | |
func( table + offset, otvalid ); | |
} | |
otvalid->nesting_level--; | |
OTV_EXIT; | |
} | |
/* uses otvalid->lookup_count */ | |
FT_LOCAL_DEF( void ) | |
otv_u_x_y_Ox_sy( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 ), otvalid, -1 ); | |
for ( ; Count > 0; Count-- ) | |
{ | |
if ( FT_NEXT_USHORT( p ) >= GlyphCount ) | |
FT_INVALID_DATA; | |
if ( FT_NEXT_USHORT( p ) >= otvalid->lookup_count ) | |
FT_INVALID_DATA; | |
} | |
OTV_EXIT; | |
} | |
/* sets otvalid->extra1 (valid->lookup_count) */ | |
FT_LOCAL_DEF( void ) | |
otv_u_O_O_O_O_x_Onx( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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, otvalid, -1 ); | |
otv_ClassDef_validate( table + BacktrackClassDef, otvalid ); | |
otv_ClassDef_validate( table + InputClassDef, otvalid ); | |
otv_ClassDef_validate( table + LookaheadClassDef, otvalid ); | |
OTV_LIMIT_CHECK( ChainClassSetCount * 2 ); | |
otvalid->nesting_level++; | |
func = otvalid->func[otvalid->nesting_level]; | |
otvalid->extra1 = otvalid->lookup_count; | |
for ( ; ChainClassSetCount > 0; ChainClassSetCount-- ) | |
{ | |
FT_UInt offset = FT_NEXT_USHORT( p ); | |
if ( offset ) | |
func( table + offset, otvalid ); | |
} | |
otvalid->nesting_level--; | |
OTV_EXIT; | |
} | |
/* uses otvalid->lookup_count */ | |
FT_LOCAL_DEF( void ) | |
otv_u_x_Ox_y_Oy_z_Oz_p_sp( FT_Bytes table, | |
OTV_Validator otvalid ) | |
{ | |
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 ), otvalid, -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 ), otvalid, -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 ), otvalid, -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 ) >= otvalid->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 */ |