WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/freetype/src/otvalid/otvgpos.c

Rev	Author	Line No.	Line
4349	Serge	1	/***************************************************************************/
		2	/* */
		3	/* otvgpos.c */
		4	/* */
		5	/* OpenType GPOS table validation (body). */
		6	/* */
		7	/* Copyright 2002, 2004, 2005, 2006, 2007, 2008 by */
		8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
		9	/* */
		10	/* This file is part of the FreeType project, and may only be used, */
		11	/* modified, and distributed under the terms of the FreeType project */
		12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
		13	/* this file you indicate that you have read the license and */
		14	/* understand and accept it fully. */
		15	/* */
		16	/***************************************************************************/
		17
		18
		19	#include "otvalid.h"
		20	#include "otvcommn.h"
		21	#include "otvgpos.h"
		22
		23
		24	/*************************************************************************/
		25	/* */
		26	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
		27	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
		28	/* messages during execution. */
		29	/* */
		30	#undef FT_COMPONENT
		31	#define FT_COMPONENT trace_otvgpos
		32
		33
		34	static void
		35	otv_Anchor_validate( FT_Bytes table,
		36	OTV_Validator valid );
		37
		38	static void
		39	otv_MarkArray_validate( FT_Bytes table,
		40	OTV_Validator valid );
		41
		42
		43	/*************************************************************************/
		44	/*************************************************************************/
		45	/*** ***/
		46	/*** UTILITY FUNCTIONS ***/
		47	/*** ***/
		48	/*************************************************************************/
		49	/*************************************************************************/
		50
		51	#define BaseArrayFunc otv_x_sxy
		52	#define LigatureAttachFunc otv_x_sxy
		53	#define Mark2ArrayFunc otv_x_sxy
		54
		55	/* uses valid->extra1 (counter) */
		56	/* uses valid->extra2 (boolean to handle NULL anchor field) */
		57
		58	static void
		59	otv_x_sxy( FT_Bytes table,
		60	OTV_Validator valid )
		61	{
		62	FT_Bytes p = table;
		63	FT_UInt Count, count1, table_size;
		64
		65
		66	OTV_ENTER;
		67
		68	OTV_LIMIT_CHECK( 2 );
		69
		70	Count = FT_NEXT_USHORT( p );
		71
		72	OTV_TRACE(( " (Count = %d)\n", Count ));
		73
		74	OTV_LIMIT_CHECK( Count * valid->extra1 * 2 );
		75
		76	table_size = Count * valid->extra1 * 2 + 2;
		77
		78	for ( ; Count > 0; Count-- )
		79	for ( count1 = valid->extra1; count1 > 0; count1-- )
		80	{
		81	OTV_OPTIONAL_TABLE( anchor_offset );
		82
		83
		84	OTV_OPTIONAL_OFFSET( anchor_offset );
		85
		86	if ( valid->extra2 )
		87	{
		88	OTV_SIZE_CHECK( anchor_offset );
		89	if ( anchor_offset )
		90	otv_Anchor_validate( table + anchor_offset, valid );
		91	}
		92	else
		93	otv_Anchor_validate( table + anchor_offset, valid );
		94	}
		95
		96	OTV_EXIT;
		97	}
		98
		99
		100	#define MarkBasePosFormat1Func otv_u_O_O_u_O_O
		101	#define MarkLigPosFormat1Func otv_u_O_O_u_O_O
		102	#define MarkMarkPosFormat1Func otv_u_O_O_u_O_O
		103
		104	/* sets valid->extra1 (class count) */
		105
		106	static void
		107	otv_u_O_O_u_O_O( FT_Bytes table,
		108	OTV_Validator valid )
		109	{
		110	FT_Bytes p = table;
		111	FT_UInt Coverage1, Coverage2, ClassCount;
		112	FT_UInt Array1, Array2;
		113	OTV_Validate_Func func;
		114
		115
		116	OTV_ENTER;
		117
		118	p += 2; /* skip PosFormat */
		119
		120	OTV_LIMIT_CHECK( 10 );
		121	Coverage1 = FT_NEXT_USHORT( p );
		122	Coverage2 = FT_NEXT_USHORT( p );
		123	ClassCount = FT_NEXT_USHORT( p );
		124	Array1 = FT_NEXT_USHORT( p );
		125	Array2 = FT_NEXT_USHORT( p );
		126
		127	otv_Coverage_validate( table + Coverage1, valid, -1 );
		128	otv_Coverage_validate( table + Coverage2, valid, -1 );
		129
		130	otv_MarkArray_validate( table + Array1, valid );
		131
		132	valid->nesting_level++;
		133	func = valid->func[valid->nesting_level];
		134	valid->extra1 = ClassCount;
		135
		136	func( table + Array2, valid );
		137
		138	valid->nesting_level--;
		139
		140	OTV_EXIT;
		141	}
		142
		143
		144	/*************************************************************************/
		145	/*************************************************************************/
		146	/*** ***/
		147	/*** VALUE RECORDS ***/
		148	/*** ***/
		149	/*************************************************************************/
		150	/*************************************************************************/
		151
		152	static FT_UInt
		153	otv_value_length( FT_UInt format )
		154	{
		155	FT_UInt count;
		156
		157
		158	count = ( ( format & 0xAA ) >> 1 ) + ( format & 0x55 );
		159	count = ( ( count & 0xCC ) >> 2 ) + ( count & 0x33 );
		160	count = ( ( count & 0xF0 ) >> 4 ) + ( count & 0x0F );
		161
		162	return count * 2;
		163	}
		164
		165
		166	/* uses valid->extra3 (pointer to base table) */
		167
		168	static void
		169	otv_ValueRecord_validate( FT_Bytes table,
		170	FT_UInt format,
		171	OTV_Validator valid )
		172	{
		173	FT_Bytes p = table;
		174	FT_UInt count;
		175
		176	#ifdef FT_DEBUG_LEVEL_TRACE
		177	FT_Int loop;
		178	FT_ULong res = 0;
		179
		180
		181	OTV_NAME_ENTER( "ValueRecord" );
		182
		183	/* display `format' in dual representation */
		184	for ( loop = 7; loop >= 0; loop-- )
		185	{
		186	res <<= 4;
		187	res += ( format >> loop ) & 1;
		188	}
		189
		190	OTV_TRACE(( " (format 0b%08lx)\n", res ));
		191	#endif
		192
		193	if ( format >= 0x100 )
		194	FT_INVALID_FORMAT;
		195
		196	for ( count = 4; count > 0; count-- )
		197	{
		198	if ( format & 1 )
		199	{
		200	/* XPlacement, YPlacement, XAdvance, YAdvance */
		201	OTV_LIMIT_CHECK( 2 );
		202	p += 2;
		203	}
		204
		205	format >>= 1;
		206	}
		207
		208	for ( count = 4; count > 0; count-- )
		209	{
		210	if ( format & 1 )
		211	{
		212	FT_PtrDist table_size;
		213
		214	OTV_OPTIONAL_TABLE( device );
		215
		216
		217	/* XPlaDevice, YPlaDevice, XAdvDevice, YAdvDevice */
		218	OTV_LIMIT_CHECK( 2 );
		219	OTV_OPTIONAL_OFFSET( device );
		220
		221	/* XXX: this value is usually too small, especially if the current */
		222	/* ValueRecord is part of an array -- getting the correct table */
		223	/* size is probably not worth the trouble */
		224
		225	table_size = p - valid->extra3;
		226
		227	OTV_SIZE_CHECK( device );
		228	if ( device )
		229	otv_Device_validate( valid->extra3 + device, valid );
		230	}
		231	format >>= 1;
		232	}
		233
		234	OTV_EXIT;
		235	}
		236
		237
		238	/*************************************************************************/
		239	/*************************************************************************/
		240	/*** ***/
		241	/*** ANCHORS ***/
		242	/*** ***/
		243	/*************************************************************************/
		244	/*************************************************************************/
		245
		246	static void
		247	otv_Anchor_validate( FT_Bytes table,
		248	OTV_Validator valid )
		249	{
		250	FT_Bytes p = table;
		251	FT_UInt AnchorFormat;
		252
		253
		254	OTV_NAME_ENTER( "Anchor");
		255
		256	OTV_LIMIT_CHECK( 6 );
		257	AnchorFormat = FT_NEXT_USHORT( p );
		258
		259	OTV_TRACE(( " (format %d)\n", AnchorFormat ));
		260
		261	p += 4; /* skip XCoordinate and YCoordinate */
		262
		263	switch ( AnchorFormat )
		264	{
		265	case 1:
		266	break;
		267
		268	case 2:
		269	OTV_LIMIT_CHECK( 2 ); /* AnchorPoint */
		270	break;
		271
		272	case 3:
		273	{
		274	FT_UInt table_size;
		275
		276	OTV_OPTIONAL_TABLE( XDeviceTable );
		277	OTV_OPTIONAL_TABLE( YDeviceTable );
		278
		279
		280	OTV_LIMIT_CHECK( 4 );
		281	OTV_OPTIONAL_OFFSET( XDeviceTable );
		282	OTV_OPTIONAL_OFFSET( YDeviceTable );
		283
		284	table_size = 6 + 4;
		285
		286	OTV_SIZE_CHECK( XDeviceTable );
		287	if ( XDeviceTable )
		288	otv_Device_validate( table + XDeviceTable, valid );
		289
		290	OTV_SIZE_CHECK( YDeviceTable );
		291	if ( YDeviceTable )
		292	otv_Device_validate( table + YDeviceTable, valid );
		293	}
		294	break;
		295
		296	default:
		297	FT_INVALID_FORMAT;
		298	}
		299
		300	OTV_EXIT;
		301	}
		302
		303
		304	/*************************************************************************/
		305	/*************************************************************************/
		306	/*** ***/
		307	/*** MARK ARRAYS ***/
		308	/*** ***/
		309	/*************************************************************************/
		310	/*************************************************************************/
		311
		312	static void
		313	otv_MarkArray_validate( FT_Bytes table,
		314	OTV_Validator valid )
		315	{
		316	FT_Bytes p = table;
		317	FT_UInt MarkCount;
		318
		319
		320	OTV_NAME_ENTER( "MarkArray" );
		321
		322	OTV_LIMIT_CHECK( 2 );
		323	MarkCount = FT_NEXT_USHORT( p );
		324
		325	OTV_TRACE(( " (MarkCount = %d)\n", MarkCount ));
		326
		327	OTV_LIMIT_CHECK( MarkCount * 4 );
		328
		329	/* MarkRecord */
		330	for ( ; MarkCount > 0; MarkCount-- )
		331	{
		332	p += 2; /* skip Class */
		333	/* MarkAnchor */
		334	otv_Anchor_validate( table + FT_NEXT_USHORT( p ), valid );
		335	}
		336
		337	OTV_EXIT;
		338	}
		339
		340
		341	/*************************************************************************/
		342	/*************************************************************************/
		343	/*** ***/
		344	/*** GPOS LOOKUP TYPE 1 ***/
		345	/*** ***/
		346	/*************************************************************************/
		347	/*************************************************************************/
		348
		349	/* sets valid->extra3 (pointer to base table) */
		350
		351	static void
		352	otv_SinglePos_validate( FT_Bytes table,
		353	OTV_Validator valid )
		354	{
		355	FT_Bytes p = table;
		356	FT_UInt PosFormat;
		357
		358
		359	OTV_NAME_ENTER( "SinglePos" );
		360
		361	OTV_LIMIT_CHECK( 2 );
		362	PosFormat = FT_NEXT_USHORT( p );
		363
		364	OTV_TRACE(( " (format %d)\n", PosFormat ));
		365
		366	valid->extra3 = table;
		367
		368	switch ( PosFormat )
		369	{
		370	case 1: /* SinglePosFormat1 */
		371	{
		372	FT_UInt Coverage, ValueFormat;
		373
		374
		375	OTV_LIMIT_CHECK( 4 );
		376	Coverage = FT_NEXT_USHORT( p );
		377	ValueFormat = FT_NEXT_USHORT( p );
		378
		379	otv_Coverage_validate( table + Coverage, valid, -1 );
		380	otv_ValueRecord_validate( p, ValueFormat, valid ); /* Value */
		381	}
		382	break;
		383
		384	case 2: /* SinglePosFormat2 */
		385	{
		386	FT_UInt Coverage, ValueFormat, ValueCount, len_value;
		387
		388
		389	OTV_LIMIT_CHECK( 6 );
		390	Coverage = FT_NEXT_USHORT( p );
		391	ValueFormat = FT_NEXT_USHORT( p );
		392	ValueCount = FT_NEXT_USHORT( p );
		393
		394	OTV_TRACE(( " (ValueCount = %d)\n", ValueCount ));
		395
		396	len_value = otv_value_length( ValueFormat );
		397
		398	otv_Coverage_validate( table + Coverage, valid, ValueCount );
		399
		400	OTV_LIMIT_CHECK( ValueCount * len_value );
		401
		402	/* Value */
		403	for ( ; ValueCount > 0; ValueCount-- )
		404	{
		405	otv_ValueRecord_validate( p, ValueFormat, valid );
		406	p += len_value;
		407	}
		408	}
		409	break;
		410
		411	default:
		412	FT_INVALID_FORMAT;
		413	}
		414
		415	OTV_EXIT;
		416	}
		417
		418
		419	/*************************************************************************/
		420	/*************************************************************************/
		421	/*** ***/
		422	/*** GPOS LOOKUP TYPE 2 ***/
		423	/*** ***/
		424	/*************************************************************************/
		425	/*************************************************************************/
		426
		427	static void
		428	otv_PairSet_validate( FT_Bytes table,
		429	FT_UInt format1,
		430	FT_UInt format2,
		431	OTV_Validator valid )
		432	{
		433	FT_Bytes p = table;
		434	FT_UInt value_len1, value_len2, PairValueCount;
		435
		436
		437	OTV_NAME_ENTER( "PairSet" );
		438
		439	OTV_LIMIT_CHECK( 2 );
		440	PairValueCount = FT_NEXT_USHORT( p );
		441
		442	OTV_TRACE(( " (PairValueCount = %d)\n", PairValueCount ));
		443
		444	value_len1 = otv_value_length( format1 );
		445	value_len2 = otv_value_length( format2 );
		446
		447	OTV_LIMIT_CHECK( PairValueCount * ( value_len1 + value_len2 + 2 ) );
		448
		449	/* PairValueRecord */
		450	for ( ; PairValueCount > 0; PairValueCount-- )
		451	{
		452	p += 2; /* skip SecondGlyph */
		453
		454	if ( format1 )
		455	otv_ValueRecord_validate( p, format1, valid ); /* Value1 */
		456	p += value_len1;
		457
		458	if ( format2 )
		459	otv_ValueRecord_validate( p, format2, valid ); /* Value2 */
		460	p += value_len2;
		461	}
		462
		463	OTV_EXIT;
		464	}
		465
		466
		467	/* sets valid->extra3 (pointer to base table) */
		468
		469	static void
		470	otv_PairPos_validate( FT_Bytes table,
		471	OTV_Validator valid )
		472	{
		473	FT_Bytes p = table;
		474	FT_UInt PosFormat;
		475
		476
		477	OTV_NAME_ENTER( "PairPos" );
		478
		479	OTV_LIMIT_CHECK( 2 );
		480	PosFormat = FT_NEXT_USHORT( p );
		481
		482	OTV_TRACE(( " (format %d)\n", PosFormat ));
		483
		484	valid->extra3 = table;
		485
		486	switch ( PosFormat )
		487	{
		488	case 1: /* PairPosFormat1 */
		489	{
		490	FT_UInt Coverage, ValueFormat1, ValueFormat2, PairSetCount;
		491
		492
		493	OTV_LIMIT_CHECK( 8 );
		494	Coverage = FT_NEXT_USHORT( p );
		495	ValueFormat1 = FT_NEXT_USHORT( p );
		496	ValueFormat2 = FT_NEXT_USHORT( p );
		497	PairSetCount = FT_NEXT_USHORT( p );
		498
		499	OTV_TRACE(( " (PairSetCount = %d)\n", PairSetCount ));
		500
		501	otv_Coverage_validate( table + Coverage, valid, -1 );
		502
		503	OTV_LIMIT_CHECK( PairSetCount * 2 );
		504
		505	/* PairSetOffset */
		506	for ( ; PairSetCount > 0; PairSetCount-- )
		507	otv_PairSet_validate( table + FT_NEXT_USHORT( p ),
		508	ValueFormat1, ValueFormat2, valid );
		509	}
		510	break;
		511
		512	case 2: /* PairPosFormat2 */
		513	{
		514	FT_UInt Coverage, ValueFormat1, ValueFormat2, ClassDef1, ClassDef2;
		515	FT_UInt ClassCount1, ClassCount2, len_value1, len_value2, count;
		516
		517
		518	OTV_LIMIT_CHECK( 14 );
		519	Coverage = FT_NEXT_USHORT( p );
		520	ValueFormat1 = FT_NEXT_USHORT( p );
		521	ValueFormat2 = FT_NEXT_USHORT( p );
		522	ClassDef1 = FT_NEXT_USHORT( p );
		523	ClassDef2 = FT_NEXT_USHORT( p );
		524	ClassCount1 = FT_NEXT_USHORT( p );
		525	ClassCount2 = FT_NEXT_USHORT( p );
		526
		527	OTV_TRACE(( " (ClassCount1 = %d)\n", ClassCount1 ));
		528	OTV_TRACE(( " (ClassCount2 = %d)\n", ClassCount2 ));
		529
		530	len_value1 = otv_value_length( ValueFormat1 );
		531	len_value2 = otv_value_length( ValueFormat2 );
		532
		533	otv_Coverage_validate( table + Coverage, valid, -1 );
		534	otv_ClassDef_validate( table + ClassDef1, valid );
		535	otv_ClassDef_validate( table + ClassDef2, valid );
		536
		537	OTV_LIMIT_CHECK( ClassCount1 * ClassCount2 *
		538	( len_value1 + len_value2 ) );
		539
		540	/* Class1Record */
		541	for ( ; ClassCount1 > 0; ClassCount1-- )
		542	{
		543	/* Class2Record */
		544	for ( count = ClassCount2; count > 0; count-- )
		545	{
		546	if ( ValueFormat1 )
		547	/* Value1 */
		548	otv_ValueRecord_validate( p, ValueFormat1, valid );
		549	p += len_value1;
		550
		551	if ( ValueFormat2 )
		552	/* Value2 */
		553	otv_ValueRecord_validate( p, ValueFormat2, valid );
		554	p += len_value2;
		555	}
		556	}
		557	}
		558	break;
		559
		560	default:
		561	FT_INVALID_FORMAT;
		562	}
		563
		564	OTV_EXIT;
		565	}
		566
		567
		568	/*************************************************************************/
		569	/*************************************************************************/
		570	/*** ***/
		571	/*** GPOS LOOKUP TYPE 3 ***/
		572	/*** ***/
		573	/*************************************************************************/
		574	/*************************************************************************/
		575
		576	static void
		577	otv_CursivePos_validate( FT_Bytes table,
		578	OTV_Validator valid )
		579	{
		580	FT_Bytes p = table;
		581	FT_UInt PosFormat;
		582
		583
		584	OTV_NAME_ENTER( "CursivePos" );
		585
		586	OTV_LIMIT_CHECK( 2 );
		587	PosFormat = FT_NEXT_USHORT( p );
		588
		589	OTV_TRACE(( " (format %d)\n", PosFormat ));
		590
		591	switch ( PosFormat )
		592	{
		593	case 1: /* CursivePosFormat1 */
		594	{
		595	FT_UInt table_size;
		596	FT_UInt Coverage, EntryExitCount;
		597
		598	OTV_OPTIONAL_TABLE( EntryAnchor );
		599	OTV_OPTIONAL_TABLE( ExitAnchor );
		600
		601
		602	OTV_LIMIT_CHECK( 4 );
		603	Coverage = FT_NEXT_USHORT( p );
		604	EntryExitCount = FT_NEXT_USHORT( p );
		605
		606	OTV_TRACE(( " (EntryExitCount = %d)\n", EntryExitCount ));
		607
		608	otv_Coverage_validate( table + Coverage, valid, EntryExitCount );
		609
		610	OTV_LIMIT_CHECK( EntryExitCount * 4 );
		611
		612	table_size = EntryExitCount * 4 + 4;
		613
		614	/* EntryExitRecord */
		615	for ( ; EntryExitCount > 0; EntryExitCount-- )
		616	{
		617	OTV_OPTIONAL_OFFSET( EntryAnchor );
		618	OTV_OPTIONAL_OFFSET( ExitAnchor );
		619
		620	OTV_SIZE_CHECK( EntryAnchor );
		621	if ( EntryAnchor )
		622	otv_Anchor_validate( table + EntryAnchor, valid );
		623
		624	OTV_SIZE_CHECK( ExitAnchor );
		625	if ( ExitAnchor )
		626	otv_Anchor_validate( table + ExitAnchor, valid );
		627	}
		628	}
		629	break;
		630
		631	default:
		632	FT_INVALID_FORMAT;
		633	}
		634
		635	OTV_EXIT;
		636	}
		637
		638
		639	/*************************************************************************/
		640	/*************************************************************************/
		641	/*** ***/
		642	/*** GPOS LOOKUP TYPE 4 ***/
		643	/*** ***/
		644	/*************************************************************************/
		645	/*************************************************************************/
		646
		647	/* UNDOCUMENTED (in OpenType 1.5): */
		648	/* BaseRecord tables can contain NULL pointers. */
		649
		650	/* sets valid->extra2 (1) */
		651
		652	static void
		653	otv_MarkBasePos_validate( FT_Bytes table,
		654	OTV_Validator valid )
		655	{
		656	FT_Bytes p = table;
		657	FT_UInt PosFormat;
		658
		659
		660	OTV_NAME_ENTER( "MarkBasePos" );
		661
		662	OTV_LIMIT_CHECK( 2 );
		663	PosFormat = FT_NEXT_USHORT( p );
		664
		665	OTV_TRACE(( " (format %d)\n", PosFormat ));
		666
		667	switch ( PosFormat )
		668	{
		669	case 1:
		670	valid->extra2 = 1;
		671	OTV_NEST2( MarkBasePosFormat1, BaseArray );
		672	OTV_RUN( table, valid );
		673	break;
		674
		675	default:
		676	FT_INVALID_FORMAT;
		677	}
		678
		679	OTV_EXIT;
		680	}
		681
		682
		683	/*************************************************************************/
		684	/*************************************************************************/
		685	/*** ***/
		686	/*** GPOS LOOKUP TYPE 5 ***/
		687	/*** ***/
		688	/*************************************************************************/
		689	/*************************************************************************/
		690
		691	/* sets valid->extra2 (1) */
		692
		693	static void
		694	otv_MarkLigPos_validate( FT_Bytes table,
		695	OTV_Validator valid )
		696	{
		697	FT_Bytes p = table;
		698	FT_UInt PosFormat;
		699
		700
		701	OTV_NAME_ENTER( "MarkLigPos" );
		702
		703	OTV_LIMIT_CHECK( 2 );
		704	PosFormat = FT_NEXT_USHORT( p );
		705
		706	OTV_TRACE(( " (format %d)\n", PosFormat ));
		707
		708	switch ( PosFormat )
		709	{
		710	case 1:
		711	valid->extra2 = 1;
		712	OTV_NEST3( MarkLigPosFormat1, LigatureArray, LigatureAttach );
		713	OTV_RUN( table, valid );
		714	break;
		715
		716	default:
		717	FT_INVALID_FORMAT;
		718	}
		719
		720	OTV_EXIT;
		721	}
		722
		723
		724	/*************************************************************************/
		725	/*************************************************************************/
		726	/*** ***/
		727	/*** GPOS LOOKUP TYPE 6 ***/
		728	/*** ***/
		729	/*************************************************************************/
		730	/*************************************************************************/
		731
		732	/* sets valid->extra2 (0) */
		733
		734	static void
		735	otv_MarkMarkPos_validate( FT_Bytes table,
		736	OTV_Validator valid )
		737	{
		738	FT_Bytes p = table;
		739	FT_UInt PosFormat;
		740
		741
		742	OTV_NAME_ENTER( "MarkMarkPos" );
		743
		744	OTV_LIMIT_CHECK( 2 );
		745	PosFormat = FT_NEXT_USHORT( p );
		746
		747	OTV_TRACE(( " (format %d)\n", PosFormat ));
		748
		749	switch ( PosFormat )
		750	{
		751	case 1:
		752	valid->extra2 = 0;
		753	OTV_NEST2( MarkMarkPosFormat1, Mark2Array );
		754	OTV_RUN( table, valid );
		755	break;
		756
		757	default:
		758	FT_INVALID_FORMAT;
		759	}
		760
		761	OTV_EXIT;
		762	}
		763
		764
		765	/*************************************************************************/
		766	/*************************************************************************/
		767	/*** ***/
		768	/*** GPOS LOOKUP TYPE 7 ***/
		769	/*** ***/
		770	/*************************************************************************/
		771	/*************************************************************************/
		772
		773	/* sets valid->extra1 (lookup count) */
		774
		775	static void
		776	otv_ContextPos_validate( FT_Bytes table,
		777	OTV_Validator valid )
		778	{
		779	FT_Bytes p = table;
		780	FT_UInt PosFormat;
		781
		782
		783	OTV_NAME_ENTER( "ContextPos" );
		784
		785	OTV_LIMIT_CHECK( 2 );
		786	PosFormat = FT_NEXT_USHORT( p );
		787
		788	OTV_TRACE(( " (format %d)\n", PosFormat ));
		789
		790	switch ( PosFormat )
		791	{
		792	case 1:
		793	/* no need to check glyph indices/classes used as input for these */
		794	/* context rules since even invalid glyph indices/classes return */
		795	/* meaningful results */
		796
		797	valid->extra1 = valid->lookup_count;
		798	OTV_NEST3( ContextPosFormat1, PosRuleSet, PosRule );
		799	OTV_RUN( table, valid );
		800	break;
		801
		802	case 2:
		803	/* no need to check glyph indices/classes used as input for these */
		804	/* context rules since even invalid glyph indices/classes return */
		805	/* meaningful results */
		806
		807	OTV_NEST3( ContextPosFormat2, PosClassSet, PosClassRule );
		808	OTV_RUN( table, valid );
		809	break;
		810
		811	case 3:
		812	OTV_NEST1( ContextPosFormat3 );
		813	OTV_RUN( table, valid );
		814	break;
		815
		816	default:
		817	FT_INVALID_FORMAT;
		818	}
		819
		820	OTV_EXIT;
		821	}
		822
		823
		824	/*************************************************************************/
		825	/*************************************************************************/
		826	/*** ***/
		827	/*** GPOS LOOKUP TYPE 8 ***/
		828	/*** ***/
		829	/*************************************************************************/
		830	/*************************************************************************/
		831
		832	/* sets valid->extra1 (lookup count) */
		833
		834	static void
		835	otv_ChainContextPos_validate( FT_Bytes table,
		836	OTV_Validator valid )
		837	{
		838	FT_Bytes p = table;
		839	FT_UInt PosFormat;
		840
		841
		842	OTV_NAME_ENTER( "ChainContextPos" );
		843
		844	OTV_LIMIT_CHECK( 2 );
		845	PosFormat = FT_NEXT_USHORT( p );
		846
		847	OTV_TRACE(( " (format %d)\n", PosFormat ));
		848
		849	switch ( PosFormat )
		850	{
		851	case 1:
		852	/* no need to check glyph indices/classes used as input for these */
		853	/* context rules since even invalid glyph indices/classes return */
		854	/* meaningful results */
		855
		856	valid->extra1 = valid->lookup_count;
		857	OTV_NEST3( ChainContextPosFormat1,
		858	ChainPosRuleSet, ChainPosRule );
		859	OTV_RUN( table, valid );
		860	break;
		861
		862	case 2:
		863	/* no need to check glyph indices/classes used as input for these */
		864	/* context rules since even invalid glyph indices/classes return */
		865	/* meaningful results */
		866
		867	OTV_NEST3( ChainContextPosFormat2,
		868	ChainPosClassSet, ChainPosClassRule );
		869	OTV_RUN( table, valid );
		870	break;
		871
		872	case 3:
		873	OTV_NEST1( ChainContextPosFormat3 );
		874	OTV_RUN( table, valid );
		875	break;
		876
		877	default:
		878	FT_INVALID_FORMAT;
		879	}
		880
		881	OTV_EXIT;
		882	}
		883
		884
		885	/*************************************************************************/
		886	/*************************************************************************/
		887	/*** ***/
		888	/*** GPOS LOOKUP TYPE 9 ***/
		889	/*** ***/
		890	/*************************************************************************/
		891	/*************************************************************************/
		892
		893	/* uses valid->type_funcs */
		894
		895	static void
		896	otv_ExtensionPos_validate( FT_Bytes table,
		897	OTV_Validator valid )
		898	{
		899	FT_Bytes p = table;
		900	FT_UInt PosFormat;
		901
		902
		903	OTV_NAME_ENTER( "ExtensionPos" );
		904
		905	OTV_LIMIT_CHECK( 2 );
		906	PosFormat = FT_NEXT_USHORT( p );
		907
		908	OTV_TRACE(( " (format %d)\n", PosFormat ));
		909
		910	switch ( PosFormat )
		911	{
		912	case 1: /* ExtensionPosFormat1 */
		913	{
		914	FT_UInt ExtensionLookupType;
		915	FT_ULong ExtensionOffset;
		916	OTV_Validate_Func validate;
		917
		918
		919	OTV_LIMIT_CHECK( 6 );
		920	ExtensionLookupType = FT_NEXT_USHORT( p );
		921	ExtensionOffset = FT_NEXT_ULONG( p );
		922
		923	if ( ExtensionLookupType == 0 \|\| ExtensionLookupType >= 9 )
		924	FT_INVALID_DATA;
		925
		926	validate = valid->type_funcs[ExtensionLookupType - 1];
		927	validate( table + ExtensionOffset, valid );
		928	}
		929	break;
		930
		931	default:
		932	FT_INVALID_FORMAT;
		933	}
		934
		935	OTV_EXIT;
		936	}
		937
		938
		939	static const OTV_Validate_Func otv_gpos_validate_funcs[9] =
		940	{
		941	otv_SinglePos_validate,
		942	otv_PairPos_validate,
		943	otv_CursivePos_validate,
		944	otv_MarkBasePos_validate,
		945	otv_MarkLigPos_validate,
		946	otv_MarkMarkPos_validate,
		947	otv_ContextPos_validate,
		948	otv_ChainContextPos_validate,
		949	otv_ExtensionPos_validate
		950	};
		951
		952
		953	/* sets valid->type_count */
		954	/* sets valid->type_funcs */
		955
		956	FT_LOCAL_DEF( void )
		957	otv_GPOS_subtable_validate( FT_Bytes table,
		958	OTV_Validator valid )
		959	{
		960	valid->type_count = 9;
		961	valid->type_funcs = (OTV_Validate_Func*)otv_gpos_validate_funcs;
		962
		963	otv_Lookup_validate( table, valid );
		964	}
		965
		966
		967	/*************************************************************************/
		968	/*************************************************************************/
		969	/*** ***/
		970	/*** GPOS TABLE ***/
		971	/*** ***/
		972	/*************************************************************************/
		973	/*************************************************************************/
		974
		975	/* sets valid->glyph_count */
		976
		977	FT_LOCAL_DEF( void )
		978	otv_GPOS_validate( FT_Bytes table,
		979	FT_UInt glyph_count,
		980	FT_Validator ftvalid )
		981	{
		982	OTV_ValidatorRec validrec;
		983	OTV_Validator valid = &validrec;
		984	FT_Bytes p = table;
		985	FT_UInt ScriptList, FeatureList, LookupList;
		986
		987
		988	valid->root = ftvalid;
		989
		990	FT_TRACE3(( "validating GPOS table\n" ));
		991	OTV_INIT;
		992
		993	OTV_LIMIT_CHECK( 10 );
		994
		995	if ( FT_NEXT_ULONG( p ) != 0x10000UL ) /* Version */
		996	FT_INVALID_FORMAT;
		997
		998	ScriptList = FT_NEXT_USHORT( p );
		999	FeatureList = FT_NEXT_USHORT( p );
		1000	LookupList = FT_NEXT_USHORT( p );
		1001
		1002	valid->type_count = 9;
		1003	valid->type_funcs = (OTV_Validate_Func*)otv_gpos_validate_funcs;
		1004	valid->glyph_count = glyph_count;
		1005
		1006	otv_LookupList_validate( table + LookupList,
		1007	valid );
		1008	otv_FeatureList_validate( table + FeatureList, table + LookupList,
		1009	valid );
		1010	otv_ScriptList_validate( table + ScriptList, table + FeatureList,
		1011	valid );
		1012
		1013	FT_TRACE4(( "\n" ));
		1014	}
		1015
		1016
		1017	/* END */

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/freetype/src/otvalid/otvgpos.c – Rev 8031