ref: 00c219c7d9c2b9f60c2db0e1ba7289b2301209a7
dir: /libfreetype/otlgpos.c/
#include "otlgpos.h"
#include "otlcommn.h"
/* forward declaration */
static OTL_ValidateFunc otl_gpos_validate_funcs[];
/************************************************************************/
/************************************************************************/
/***** *****/
/***** VALUE RECORDS *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static OTL_UInt
otl_value_length( OTL_UInt format )
{
FT_UInt count;
count = (( format & 0xAA ) >> 1) + ( format & 0x55 );
count = (( count & 0xCC ) >> 2) + ( count & 0x33 );
count = (( count & 0xF0 ) >> 4) + ( count & 0x0F );
return count;
}
static void
otl_value_validate( OTL_Bytes table,
OTL_Bytes pos_table,
OTL_UInt format,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count, device;
if ( format >= 0x100U )
OTL_INVALID_DATA;
for ( count = 4; count > 0; count-- )
{
if ( format & 1 )
{
OTL_CHECK( 2 );
p += 2;
}
format >>= 1;
}
for ( count = 4; count > 0; count-- )
{
if ( format & 1 )
{
OTL_CHECK( 2 );
device = OTL_NEXT_USHORT( p );
if ( device )
otl_device_table_validate( pos_table + device, valid );
}
format >>= 1;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** ANCHORS *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_anchor_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 6 );
format = OTL_NEXT_USHORT( p );
p += 4;
switch ( format )
{
case 1:
break;
case 2:
OTL_CHECK( 2 ); /* anchor point */
break;
case 3:
{
OTL_UInt x_device, y_device;
OTL_CHECK( 4 );
x_device = OTL_NEXT_USHORT( p );
y_device = OTL_NEXT_USHORT( p );
if ( x_device )
otl_device_table_validate( table + x_device, valid );
if ( y_device )
otl_device_table_validate( table + y_device, valid );
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** MARK ARRAY *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_mark_array_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( count * 4 );
for ( ; count > 0; count-- )
{
p += 2; /* ignore class index */
otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 1 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_gpos_lookup1_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch ( format )
{
case 1:
{
FT_UInt coverage, value_format;
OTL_CHECK( 4 );
coverage = OTL_NEXT_USHORT( p );
value_format = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + coverage, valid );
otl_value_validate( p, table, value_format, valid );
}
break;
case 2:
{
FT_UInt coverage, value_format, count, len;
OTL_CHECK( 6 );
coverage = OTL_NEXT_USHORT( p );
value_format = OTL_NEXT_USHORT( p );
count = OTL_NEXT_USHORT( p );
len = otl_value_length( value_format );
otl_coverage_validate( table + coverage, valid );
OTL_CHECK( count * len );
for ( ; count > 0; count-- )
{
otl_value_validate( p, table, value_format, valid );
p += len;
}
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 2 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static otl_gpos_pairset_validate( OTL_Bytes table,
OTL_Bytes pos_table,
OTL_UInt format1,
OTL_UInt format2,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt len1, len2, count;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
len1 = otl_value_length( format1 );
len2 = otl_value_length( format2 );
OTL_CHECK( count * (len1+len2+2) );
for ( ; count > 0; count-- )
{
p += 2; /* ignore glyph id */
otl_value_validate( p, pos_table, format1, valid );
p += len1;
otl_value_validate( p, pos_table, format2, valid );
p += len2;
}
}
static void
otl_gpos_lookup2_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch (format)
{
case 1:
{
OTL_UInt coverage, value1, value2, count;
OTL_CHECK( 8 );
coverage = OTL_NEXT_USHORT( p );
value1 = OTL_NEXT_USHORT( p );
value2 = OTL_NEXT_USHORT( p );
count = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + coverage, valid );
OTL_CHECK( count*2 );
for ( ; count > 0; count-- )
{
otl_gpos_pairset_validate( table + OTL_NEXT_USHORT( p ),
table, value1, value2, valid );
}
}
break;
case 2:
{
OTL_UInt coverage, value1, value2, class1, class2, count1, count2;
OTL_UInt len1, len2;
OTL_CHECK( 14 );
coverage = OTL_NEXT_USHORT( p );
value1 = OTL_NEXT_USHORT( p );
value2 = OTL_NEXT_USHORT( p );
class1 = OTL_NEXT_USHORT( p );
class2 = OTL_NEXT_USHORT( p );
count1 = OTL_NEXT_USHORT( p );
count2 = OTL_NEXT_USHORT( p );
len1 = otl_value_length( value1 );
len2 = otl_value_length( value2 );
otl_coverage_validate( table + coverage, valid );
OTL_CHECK( count1*count2*(len1+len2) );
for ( ; count1 > 0; count1-- )
{
for ( ; count2 > 0; count2-- )
{
otl_value_validate( p, table, value1, valid );
p += len1;
otl_value_validate( p, table, value2, valid );
p += len2;
}
}
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 3 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_gpos_lookup3_validate( OTL_Bytes table,
OTL_Valid valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch (format)
{
case 1:
{
OTL_UInt coverage, count, anchor1, anchor2;
OTL_CHECK( 4 );
coverage = OTL_NEXT_USHORT( p );
count = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + coverage, valid );
OTL_CHECK( count*4 );
for ( ; count > 0; count-- )
{
anchor1 = OTL_NEXT_USHORT( p );
anchor2 = OTL_NEXT_USHORT( p );
if ( anchor1 )
otl_anchor_validate( table + anchor1, valid );
if ( anchor2 )
otl_anchor_validate( table + anchor2, valid );
}
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 4 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_base_array_validate( OTL_Bytes table,
OTL_UInt class_count,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count, count2;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( count*class_count*2 );
for ( ; count > 0; count-- )
for ( count2 = class_count; count2 > 0; count2-- )
otl_anchor_validate( table + OTL_NEXT_USHORT( p ) );
}
static void
otl_gpos_lookup4_validate( OTL_Bytes table,
OTL_Valid valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch (format)
{
case 1:
{
OTL_UInt mark_coverage, base_coverage, class_count;
OTL_UInt mark_array, base_array;
OTL_CHECK( 10 );
mark_coverage = OTL_NEXT_USHORT( p );
base_coverage = OTL_NEXT_USHORT( p );
class_count = OTL_NEXT_USHORT( p );
mark_array = OTL_NEXT_USHORT( p );
base_array = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + mark_coverage, valid );
otl_coverage_validate( table + base_coverage, valid );
otl_mark_array_validate( table + mark_array, valid );
otl_base_array_validate( table, class_count, valid );
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 5 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_liga_attach_validate( OTL_Bytes table,
OTL_UInt class_count,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count, count2;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( count*class_count*2 );
for ( ; count > 0; count-- )
for ( count2 = class_count; class_count > 0; class_count-- )
otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
}
static void
otl_liga_array_validate( OTL_Bytes table,
OTL_UInt class_count,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count, count2;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( count*2 );
for ( ; count > 0; count-- )
otl_liga_attach_validate( table + OTL_NEXT_USHORT( p ), valid );
}
static void
otl_gpos_lookup5_validate( OTL_Bytes table,
OTL_Valid valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch (format)
{
case 1:
{
OTL_UInt mark_coverage, lig_coverage, class_count;
OTL_UInt mar_array, lig_array;
OTL_CHECK( 10 );
mark_coverage = OTL_NEXT_USHORT( p );
liga_coverage = OTL_NEXT_USHORT( p );
class_count = OTL_NEXT_USHORT( p );
mark_array = OTL_NEXT_USHORT( p );
liga_array = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + mark_coverage, valid );
otl_coverage_validate( table + liga_coverage, valid );
otl_mark_array_validate( table + mark_array, valid );
otl_liga_array_validate( table + liga_array, class_count, valid );
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 6 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_mark2_array_validate( OTL_Bytes table,
OTL_UInt class_count,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count, count2;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( count*class_count*2 );
for ( ; count > 0; count-- )
for ( count2 = class_count; class_count > 0; class_count-- )
otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
}
static void
otl_gpos_lookup6_validate( OTL_Bytes table,
OTL_Valid valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch (format)
{
case 1:
{
OTL_UInt coverage1, coverage2, class_count, array1, array2;
OTL_CHECK( 10 );
coverage1 = OTL_NEXT_USHORT( p );
coverage2 = OTL_NEXT_USHORT( p );
class_count = OTL_NEXT_USHORT( p );
array1 = OTL_NEXT_USHORT( p );
array2 = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + coverage1, valid );
otl_coverage_validate( table + coverage2, valid );
otl_mark_array_validate( table + array1, valid );
otl_mark2_array_validate( table + array2, valid );
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 7 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_pos_rule_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt glyph_count, pos_count;
OTL_CHECK( 4 );
glyph_count = OTL_NEXT_USHORT( p );
pos_count = OTL_NEXT_USHORT( p );
if ( glyph_count == 0 )
OTL_INVALID_DATA;
OTL_CHECK( (glyph_count-1)*2 + pos_count*4 );
/* XXX: check glyph indices and pos lookups */
}
static void
otl_pos_rule_set_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( count*2 );
for ( ; count > 0; count-- )
otl_pos_rule_validate( table + OTL_NEXT_USHORT(p), valid );
}
static void
otl_pos_class_rule_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt glyph_count, pos_count;
OTL_CHECK( 4 );
glyph_count = OTL_NEXT_USHORT( p );
pos_count = OTL_NEXT_USHORT( p );
if ( glyph_count == 0 )
OTL_INVALID_DATA;
OTL_CHECK( (glyph_count-1)*2 + pos_count*4 );
/* XXX: check glyph indices and pos lookups */
}
static void
otl_pos_class_set_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( count*2 );
for ( ; count > 0; count-- )
otl_pos_rule_validate( table + OTL_NEXT_USHORT(p), valid );
}
static void
otl_gpos_lookup7_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch (format)
{
case 1:
{
OTL_UInt coverage, count;
OTL_CHECK( 4 );
coverage = OTL_NEXT_USHORT( p );
count = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + coverage, valid );
OTL_CHECK( count*2 );
for ( ; count > 0; count-- )
otl_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ), valid );
}
break;
case 2:
{
OTL_UInt coverage, class_def, count;
OTL_CHECK( 6 );
coverage = OTL_NEXT_USHORT( p );
class_def = OTL_NEXT_USHORT( p );
count = OTL_NEXT_USHORT( p );
otl_coverage_validate ( table + coverage, valid );
otl_class_definition_validate( table + class_def, valid );
OTL_CHECK( count*2 );
for ( ; count > 0; count-- )
otl_
}
break;
case 3:
{
OTL_UInt glyph_count, pos_count;
OTL_CHECK( 4 );
glyph_count = OTL_NEXT_USHORT( p );
pos_count = OTL_NEXT_USHORT( p );
OTL_CHECK( glyph_count*2 + pos_count*4 );
for ( ; glyph_count > 0; glyph_count )
otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
/* XXX: check pos lookups */
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 8 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_chain_pos_rule_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt back_count, input_count, ahead_count, pos_count;
OTL_CHECK( 2 );
back_count = OTL_NEXT_USHORT( p );
OTL_CHECK( back_count*2 + 2 );
p += back_count*2;
input_count = OTL_NEXT_USHORT( p );
if ( input_count == 0 )
OTL_INVALID_DATA;
OTL_CHECK( input_count*2 );
p += (input_count-1)*2;
ahead_count = OTL_NEXT_USHORT( p );
OTL_CHECK( ahead_count*2 + 2 );
p += ahead_count*2;
pos_count = OTL_NEXT_USHORT( p );
OTL_CHECK( pos_count*4 );
}
static void
otl_chain_pos_rule_set_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( 2*count );
for ( ; count > 0; count-- )
otl_chain_pos_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
}
static void
otl_chain_pos_class_rule_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt back_count, input_count, ahead_count, pos_count;
OTL_CHECK( 2 );
back_count = OTL_NEXT_USHORT( p );
OTL_CHECK( back_count*2 + 2 );
p += back_count*2;
input_count = OTL_NEXT_USHORT( p );
if ( input_count == 0 )
OTL_INVALID_DATA;
OTL_CHECK( input_count*2 );
p += (input_count-1)*2;
ahead_count = OTL_NEXT_USHORT( p );
OTL_CHECK( ahead_count*2 + 2 );
p += ahead_count*2;
pos_count = OTL_NEXT_USHORT( p );
OTL_CHECK( pos_count*4 );
}
static void
otl_chain_pos_class_set_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt count;
OTL_CHECK( 2 );
count = OTL_NEXT_USHORT( p );
OTL_CHECK( 2*count );
for ( ; count > 0; count-- )
otl_chain_pos_class_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
}
static void
otl_gpos_lookup8_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch (format)
{
case 1:
{
OTL_UInt coverage, count;
OTL_CHECK( 4 );
coverage = OTL_NEXT_USHORT( p );
count = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + coverage, valid );
OTL_CHECK( count*2 );
for ( ; count > 0; count-- )
otl_chain_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ),
valid );
}
break;
case 2:
{
OTL_UInt coverage, back_class, input_class, ahead_class, count;
OTL_CHECK( 10 );
coverage = OTL_NEXT_USHORT( p );
back_class = OTL_NEXT_USHORT( p );
input_class = OTL_NEXT_USHORT( p );
ahead_class = OTL_NEXT_USHORT( p );
count = OTL_NEXT_USHORT( p );
otl_coverage_validate( table + coverage, valid );
otl_class_definition_validate( table + back_class, valid );
otl_class_definition_validate( table + input_class, valid );
otl_class_definition_validate( table + ahead_class, valid );
OTL_CHECK( count*2 );
for ( ; count > 0; count-- )
otl_chain_pos_class_set_validate( table + OTL_NEXT_USHORT( p ),
valid );
}
break;
case 3:
{
OTL_UInt back_count, input_count, ahead_count, pos_count, count;
OTL_CHECK( 2 );
back_count = OTL_NEXT_USHORT( p );
OTL_CHECK( 2*back_count+2 );
for ( count = back_count; count > 0; count-- )
otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
input_count = OTL_NEXT_USHORT( p );
OTL_CHECK( 2*input_count+2 );
for ( count = input_count; count > 0; count-- )
otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
ahead_count = OTL_NEXT_USHORT( p );
OTL_CHECK( 2*ahead_count+2 );
for ( count = ahead_count; count > 0; count-- )
otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
pos_count = OTL_NEXT_USHORT( p );
OTL_CHECK( pos_count*4 );
}
break;
default:
OTL_INVALID_DATA;
}
}
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS LOOKUP TYPE 9 *****/
/***** *****/
/************************************************************************/
/************************************************************************/
static void
otl_gpos_lookup9_validate( OTL_Bytes table,
OTL_Valid valid )
{
OTL_Bytes p = table;
OTL_UInt format;
OTL_CHECK( 2 );
format = OTL_NEXT_USHORT( p );
switch (format)
{
case 1:
{
OTL_UInt lookup_type, lookup_offset;
OTL_ValidateFunc validate;
OTL_CHECK( 6 );
lookup_type = OTL_NEXT_USHORT( p );
lookup_offset = OTL_NEXT_ULONG( p );
if ( lookup_type == 0 || lookup_type >= 9 )
OTL_INVALID_DATA;
validate = otl_gpos_validate_funcs[ lookup_type-1 ];
validate( table + lookup_offset, valid );
}
break;
default:
OTL_INVALID_DATA;
}
}
static OTL_ValidateFunc otl_gpos_validate_funcs[ 9 ] =
{
otl_gpos_lookup1_validate,
otl_gpos_lookup2_validate,
otl_gpos_lookup3_validate,
otl_gpos_lookup4_validate,
otl_gpos_lookup5_validate,
otl_gpos_lookup6_validate,
otl_gpos_lookup7_validate,
otl_gpos_lookup8_validate,
otl_gpos_lookup9_validate,
};
/************************************************************************/
/************************************************************************/
/***** *****/
/***** GPOS TABLE *****/
/***** *****/
/************************************************************************/
/************************************************************************/
OTL_LOCALDEF( void )
otl_gpos_validate( OTL_Bytes table,
OTL_Validator valid )
{
OTL_Bytes p = table;
OTL_UInt scripts, features, lookups;
OTL_CHECK( 10 );
if ( OTL_NEXT_USHORT( p ) != 0x10000UL )
OTL_INVALID_DATA;
scripts = OTL_NEXT_USHORT( p );
features = OTL_NEXT_USHORT( p );
lookups = OTL_NEXT_USHORT( p );
otl_script_list_validate ( table + scripts, valid );
otl_feature_list_validate( table + features, valid );
otl_lookup_list_validate( table + lookups, 9, otl_gpos_validate_funcs,
valid );
}