ttcmap.c source code [Godot/thirdparty/freetype/src/sfnt/ttcmap.c]

1	/****************************************************************************
2	*
3	* ttcmap.c
4	*
5	* TrueType character mapping table (cmap) support (body).
6	*
7	* Copyright (C) 2002-2023 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 <freetype/internal/ftdebug.h>
20
21	#include "sferrors.h" /* must come before `ftvalid.h' */
22
23	#include <freetype/internal/ftvalid.h>
24	#include <freetype/internal/ftstream.h>
25	#include <freetype/internal/services/svpscmap.h>
26	#include "ttload.h"
27	#include "ttcmap.h"
28	#include "ttpost.h"
29
30
31	/**************************************************************************
32	*
33	* The macro FT_COMPONENT is used in trace mode. It is an implicit
34	* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
35	* messages during execution.
36	*/
37	#undef FT_COMPONENT
38	#define FT_COMPONENT ttcmap
39
40
41	#define TT_PEEK_SHORT FT_PEEK_SHORT
42	#define TT_PEEK_USHORT FT_PEEK_USHORT
43	#define TT_PEEK_UINT24 FT_PEEK_UOFF3
44	#define TT_PEEK_LONG FT_PEEK_LONG
45	#define TT_PEEK_ULONG FT_PEEK_ULONG
46
47	#define TT_NEXT_SHORT FT_NEXT_SHORT
48	#define TT_NEXT_USHORT FT_NEXT_USHORT
49	#define TT_NEXT_UINT24 FT_NEXT_UOFF3
50	#define TT_NEXT_LONG FT_NEXT_LONG
51	#define TT_NEXT_ULONG FT_NEXT_ULONG
52
53
54	/ Too large glyph index return values are caught in `FT_Get_Char_Index' /
55	/ and `FT_Get_Next_Char' (the latter calls the internal `next' function /
56	/ again in this case). To mark character code return values as invalid /
57	/ it is sufficient to set the corresponding glyph index return value to /
58	/ zero. /
59
60
61	FT_CALLBACK_DEF( FT_Error )
62	tt_cmap_init( FT_CMap cmap, / TT_CMap /
63	void* table_ )
64	{
65	TT_CMap ttcmap = (TT_CMap)cmap;
66	FT_Byte* table = (FT_Byte*)table_;
67
68
69	ttcmap->data = table;
70	return FT_Err_Ok;
71	}
72
73
74	/***********************************************************************/
75	/***********************************************************************/
76	/** **/
77	/** FORMAT 0 **/
78	/** **/
79	/***********************************************************************/
80	/***********************************************************************/
81
82	/**************************************************************************
83	*
84	* TABLE OVERVIEW
85	* --------------
86	*
87	* NAME OFFSET TYPE DESCRIPTION
88	*
89	* format 0 USHORT must be 0
90	* length 2 USHORT table length in bytes
91	* language 4 USHORT Mac language code
92	* glyph_ids 6 BYTE[256] array of glyph indices
93	* 262
94	*/
95
96	#ifdef TT_CONFIG_CMAP_FORMAT_0
97
98	FT_CALLBACK_DEF( FT_Error )
99	tt_cmap0_validate( FT_Byte* table,
100	FT_Validator valid )
101	{
102	FT_Byte* p;
103	FT_UInt length;
104
105
106	if ( table + `2` + `2` > valid->limit )
107	FT_INVALID_TOO_SHORT;
108
109	p = table + `2`; / skip format /
110	length = TT_NEXT_USHORT( p );
111
112	if ( table + length > valid->limit \|\| length < `262` )
113	FT_INVALID_TOO_SHORT;
114
115	/ check glyph indices whenever necessary /
116	if ( valid->level >= FT_VALIDATE_TIGHT )
117	{
118	FT_UInt n, idx;
119
120
121	p = table + `6`;
122	for ( n = `0`; n < `256`; n++ )
123	{
124	idx = *p++;
125	if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
126	FT_INVALID_GLYPH_ID;
127	}
128	}
129
130	return FT_Err_Ok;
131	}
132
133
134	FT_CALLBACK_DEF( FT_UInt )
135	tt_cmap0_char_index( FT_CMap cmap, / TT_CMap /
136	FT_UInt32 char_code )
137	{
138	TT_CMap ttcmap = (TT_CMap)cmap;
139	FT_Byte* table = ttcmap->data;
140
141
142	return char_code < `256` ? table[`6` + char_code] : `0`;
143	}
144
145
146	FT_CALLBACK_DEF( FT_UInt )
147	tt_cmap0_char_next( FT_CMap cmap, / TT_CMap /
148	FT_UInt32 *pchar_code )
149	{
150	TT_CMap ttcmap = (TT_CMap)cmap;
151	FT_Byte* table = ttcmap->data;
152	FT_UInt32 charcode = *pchar_code;
153	FT_UInt32 result = `0`;
154	FT_UInt gindex = `0`;
155
156
157	table += `6`; / go to glyph IDs /
158	while ( ++charcode < `256` )
159	{
160	gindex = table[charcode];
161	if ( gindex != `0` )
162	{
163	result = charcode;
164	break;
165	}
166	}
167
168	*pchar_code = result;
169	return gindex;
170	}
171
172
173	FT_CALLBACK_DEF( FT_Error )
174	tt_cmap0_get_info( FT_CharMap cmap, / TT_CMap /
175	TT_CMapInfo *cmap_info )
176	{
177	TT_CMap ttcmap = (TT_CMap)cmap;
178	FT_Byte* p = ttcmap->data + `4`;
179
180
181	cmap_info->format = `0`;
182	cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
183
184	return FT_Err_Ok;
185	}
186
187
188	FT_DEFINE_TT_CMAP(
189	tt_cmap0_class_rec,
190
191	sizeof ( TT_CMapRec ),
192
193	(FT_CMap_InitFunc) tt_cmap_init, / init /
194	(FT_CMap_DoneFunc) NULL, / done /
195	(FT_CMap_CharIndexFunc)tt_cmap0_char_index, / char_index /
196	(FT_CMap_CharNextFunc) tt_cmap0_char_next, / char_next /
197
198	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
199	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
200	(FT_CMap_VariantListFunc) NULL, / variant_list /
201	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
202	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
203
204	`0`,
205	(TT_CMap_ValidateFunc)tt_cmap0_validate, / validate /
206	(TT_CMap_Info_GetFunc)tt_cmap0_get_info / get_cmap_info /
207	)
208
209	#endif /* TT_CONFIG_CMAP_FORMAT_0 */
210
211
212	/***********************************************************************/
213	/***********************************************************************/
214	/** **/
215	/** FORMAT 2 **/
216	/** **/
217	/** This is used for certain CJK encodings that encode text in a **/
218	/** mixed 8/16 bits encoding along the following lines. **/
219	/** **/
220	/**** * Certain byte values correspond to an 8-bit character code ****/
221	/** (typically in the range 0..127 for ASCII compatibility). **/
222	/** **/
223	/**** * Certain byte values signal the first byte of a 2-byte ****/
224	/** character code (but these values are also valid as the **/
225	/** second byte of a 2-byte character). **/
226	/** **/
227	/** The following charmap lookup and iteration functions all **/
228	/** assume that the value `charcode' fulfills the following. **/
229	/** **/
230	/** - For one-byte characters, `charcode' is simply the **/
231	/** character code. **/
232	/** **/
233	/** - For two-byte characters, `charcode' is the 2-byte **/
234	/** character code in big endian format. More precisely: **/
235	/** **/
236	/** (charcode >> 8) is the first byte value **/
237	/** (charcode & 0xFF) is the second byte value **/
238	/** **/
239	/** Note that not all values of `charcode' are valid according **/
240	/** to these rules, and the function moderately checks the **/
241	/** arguments. **/
242	/** **/
243	/***********************************************************************/
244	/***********************************************************************/
245
246	/**************************************************************************
247	*
248	* TABLE OVERVIEW
249	* --------------
250	*
251	* NAME OFFSET TYPE DESCRIPTION
252	*
253	* format 0 USHORT must be 2
254	* length 2 USHORT table length in bytes
255	* language 4 USHORT Mac language code
256	* keys 6 USHORT[256] sub-header keys
257	* subs 518 SUBHEAD[NSUBS] sub-headers array
258	* glyph_ids 518+NSUB*8 USHORT[] glyph ID array
259	*
260	* The `keys' table is used to map charcode high bytes to sub-headers.
261	* The value of `NSUBS' is the number of sub-headers defined in the
262	* table and is computed by finding the maximum of the `keys' table.
263	*
264	* Note that for any `n', `keys[n]' is a byte offset within the `subs'
265	* table, i.e., it is the corresponding sub-header index multiplied
266	* by 8.
267	*
268	* Each sub-header has the following format.
269	*
270	* NAME OFFSET TYPE DESCRIPTION
271	*
272	* first 0 USHORT first valid low-byte
273	* count 2 USHORT number of valid low-bytes
274	* delta 4 SHORT see below
275	* offset 6 USHORT see below
276	*
277	* A sub-header defines, for each high byte, the range of valid
278	* low bytes within the charmap. Note that the range defined by `first'
279	* and `count' must be completely included in the interval [0..255]
280	* according to the specification.
281	*
282	* If a character code is contained within a given sub-header, then
283	* mapping it to a glyph index is done as follows.
284	*
285	* - The value of `offset' is read. This is a _byte_ distance from the
286	* location of the `offset' field itself into a slice of the
287	* `glyph_ids' table. Let's call it `slice' (it is a USHORT[], too).
288	*
289	* - The value `slice[char.lo - first]' is read. If it is 0, there is
290	* no glyph for the charcode. Otherwise, the value of `delta' is
291	* added to it (modulo 65536) to form a new glyph index.
292	*
293	* It is up to the validation routine to check that all offsets fall
294	* within the glyph IDs table (and not within the `subs' table itself or
295	* outside of the CMap).
296	*/
297
298	#ifdef TT_CONFIG_CMAP_FORMAT_2
299
300	FT_CALLBACK_DEF( FT_Error )
301	tt_cmap2_validate( FT_Byte* table,
302	FT_Validator valid )
303	{
304	FT_Byte* p;
305	FT_UInt length;
306
307	FT_UInt n, max_subs;
308	FT_Byte* keys; / keys table /
309	FT_Byte* subs; / sub-headers /
310	FT_Byte* glyph_ids; / glyph ID array /
311
312
313	if ( table + `2` + `2` > valid->limit )
314	FT_INVALID_TOO_SHORT;
315
316	p = table + `2`; / skip format /
317	length = TT_NEXT_USHORT( p );
318
319	if ( table + length > valid->limit \|\| length < `6` + `512` )
320	FT_INVALID_TOO_SHORT;
321
322	keys = table + `6`;
323
324	/ parse keys to compute sub-headers count /
325	p = keys;
326	max_subs = `0`;
327	for ( n = `0`; n < `256`; n++ )
328	{
329	FT_UInt idx = TT_NEXT_USHORT( p );
330
331
332	/ value must be multiple of 8 /
333	if ( valid->level >= FT_VALIDATE_PARANOID && ( idx & `7` ) != `0` )
334	FT_INVALID_DATA;
335
336	idx >>= `3`;
337
338	if ( idx > max_subs )
339	max_subs = idx;
340	}
341
342	FT_ASSERT( p == table + `518` );
343
344	subs = p;
345	glyph_ids = subs + ( max_subs + `1` ) * `8`;
346	if ( glyph_ids > valid->limit )
347	FT_INVALID_TOO_SHORT;
348
349	/ parse sub-headers /
350	for ( n = `0`; n <= max_subs; n++ )
351	{
352	FT_UInt first_code, code_count, offset;
353	FT_Int delta;
354
355
356	first_code = TT_NEXT_USHORT( p );
357	code_count = TT_NEXT_USHORT( p );
358	delta = TT_NEXT_SHORT( p );
359	offset = TT_NEXT_USHORT( p );
360
361	/ many Dynalab fonts have empty sub-headers /
362	if ( code_count == `0` )
363	continue;
364
365	/ check range within 0..255 /
366	if ( valid->level >= FT_VALIDATE_PARANOID )
367	{
368	if ( first_code >= `256` \|\| code_count > `256` - first_code )
369	FT_INVALID_DATA;
370	}
371
372	/ check offset /
373	if ( offset != `0` )
374	{
375	FT_Byte* ids;
376
377
378	ids = p - `2` + offset;
379	if ( ids < glyph_ids \|\| ids + code_count * `2` > table + length )
380	FT_INVALID_OFFSET;
381
382	/ check glyph IDs /
383	if ( valid->level >= FT_VALIDATE_TIGHT )
384	{
385	FT_Byte* limit = p + code_count * `2`;
386	FT_UInt idx;
387
388
389	for ( ; p < limit; )
390	{
391	idx = TT_NEXT_USHORT( p );
392	if ( idx != `0` )
393	{
394	idx = (FT_UInt)( (FT_Int)idx + delta ) & `0xFFFFU`;
395	if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
396	FT_INVALID_GLYPH_ID;
397	}
398	}
399	}
400	}
401	}
402
403	return FT_Err_Ok;
404	}
405
406
407	/ return sub header corresponding to a given character code /
408	/ NULL on invalid charcode /
409	static FT_Byte*
410	tt_cmap2_get_subheader( FT_Byte* table,
411	FT_UInt32 char_code )
412	{
413	FT_Byte* result = NULL;
414
415
416	if ( char_code < `0x10000UL` )
417	{
418	FT_UInt char_lo = (FT_UInt)( char_code & `0xFF` );
419	FT_UInt char_hi = (FT_UInt)( char_code >> `8` );
420	FT_Byte* p = table + `6`; / keys table /
421	FT_Byte* subs = table + `518`; / subheaders table /
422	FT_Byte* sub;
423
424
425	if ( char_hi == `0` )
426	{
427	/ an 8-bit character code -- we use subHeader 0 in this case /
428	/ to test whether the character code is in the charmap /
429	/ /
430	sub = subs; / jump to first sub-header /
431
432	/ check that the sub-header for this byte is 0, which /
433	/ indicates that it is really a valid one-byte value; /
434	/ otherwise, return 0 /
435	/ /
436	p += char_lo * `2`;
437	if ( TT_PEEK_USHORT( p ) != `0` )
438	goto Exit;
439	}
440	else
441	{
442	/ a 16-bit character code /
443
444	/ jump to key entry /
445	p += char_hi * `2`;
446	/ jump to sub-header /
447	sub = subs + ( FT_PAD_FLOOR( TT_PEEK_USHORT( p ), `8` ) );
448
449	/ check that the high byte isn't a valid one-byte value /
450	if ( sub == subs )
451	goto Exit;
452	}
453
454	result = sub;
455	}
456
457	Exit:
458	return result;
459	}
460
461
462	FT_CALLBACK_DEF( FT_UInt )
463	tt_cmap2_char_index( FT_CMap cmap, / TT_CMap /
464	FT_UInt32 char_code )
465	{
466	TT_CMap ttcmap = (TT_CMap)cmap;
467	FT_Byte* table = ttcmap->data;
468	FT_UInt result = `0`;
469	FT_Byte* subheader;
470
471
472	subheader = tt_cmap2_get_subheader( table, char_code );
473	if ( subheader )
474	{
475	FT_Byte* p = subheader;
476	FT_UInt idx = (FT_UInt)( char_code & `0xFF` );
477	FT_UInt start, count;
478	FT_Int delta;
479	FT_UInt offset;
480
481
482	start = TT_NEXT_USHORT( p );
483	count = TT_NEXT_USHORT( p );
484	delta = TT_NEXT_SHORT ( p );
485	offset = TT_PEEK_USHORT( p );
486
487	idx -= start;
488	if ( idx < count && offset != `0` )
489	{
490	p += offset + `2` * idx;
491	idx = TT_PEEK_USHORT( p );
492
493	if ( idx != `0` )
494	result = (FT_UInt)( (FT_Int)idx + delta ) & `0xFFFFU`;
495	}
496	}
497
498	return result;
499	}
500
501
502	FT_CALLBACK_DEF( FT_UInt )
503	tt_cmap2_char_next( FT_CMap cmap, / TT_CMap /
504	FT_UInt32 *pcharcode )
505	{
506	TT_CMap ttcmap = (TT_CMap)cmap;
507	FT_Byte* table = ttcmap->data;
508	FT_UInt gindex = `0`;
509	FT_UInt32 result = `0`;
510	FT_UInt32 charcode = *pcharcode + `1`;
511	FT_Byte* subheader;
512
513
514	while ( charcode < `0x10000UL` )
515	{
516	subheader = tt_cmap2_get_subheader( table, charcode );
517	if ( subheader )
518	{
519	FT_Byte* p = subheader;
520	FT_UInt start = TT_NEXT_USHORT( p );
521	FT_UInt count = TT_NEXT_USHORT( p );
522	FT_Int delta = TT_NEXT_SHORT ( p );
523	FT_UInt offset = TT_PEEK_USHORT( p );
524	FT_UInt char_lo = (FT_UInt)( charcode & `0xFF` );
525	FT_UInt pos, idx;
526
527
528	if ( char_lo >= start + count && charcode <= `0xFF` )
529	{
530	/ this happens only for a malformed cmap /
531	charcode = `0x100`;
532	continue;
533	}
534
535	if ( offset == `0` )
536	{
537	if ( charcode == `0x100` )
538	goto Exit; / this happens only for a malformed cmap /
539	goto Next_SubHeader;
540	}
541
542	if ( char_lo < start )
543	{
544	char_lo = start;
545	pos = `0`;
546	}
547	else
548	pos = (FT_UInt)( char_lo - start );
549
550	p += offset + pos * `2`;
551	charcode = FT_PAD_FLOOR( charcode, `256` ) + char_lo;
552
553	for ( ; pos < count; pos++, charcode++ )
554	{
555	idx = TT_NEXT_USHORT( p );
556
557	if ( idx != `0` )
558	{
559	gindex = (FT_UInt)( (FT_Int)idx + delta ) & `0xFFFFU`;
560	if ( gindex != `0` )
561	{
562	result = charcode;
563	goto Exit;
564	}
565	}
566	}
567
568	/ if unsuccessful, avoid `charcode' leaving /
569	/ the current 256-character block /
570	if ( count )
571	charcode--;
572	}
573
574	/ If `charcode' is <= 0xFF, retry with `charcode + 1'. /
575	/ Otherwise jump to the next 256-character block and retry. /
576	Next_SubHeader:
577	if ( charcode <= `0xFF` )
578	charcode++;
579	else
580	charcode = FT_PAD_FLOOR( charcode, `0x100` ) + `0x100`;
581	}
582
583	Exit:
584	*pcharcode = result;
585
586	return gindex;
587	}
588
589
590	FT_CALLBACK_DEF( FT_Error )
591	tt_cmap2_get_info( FT_CharMap cmap, / TT_CMap /
592	TT_CMapInfo *cmap_info )
593	{
594	TT_CMap ttcmap = (TT_CMap)cmap;
595	FT_Byte* p = ttcmap->data + `4`;
596
597
598	cmap_info->format = `2`;
599	cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
600
601	return FT_Err_Ok;
602	}
603
604
605	FT_DEFINE_TT_CMAP(
606	tt_cmap2_class_rec,
607
608	sizeof ( TT_CMapRec ),
609
610	(FT_CMap_InitFunc) tt_cmap_init, / init /
611	(FT_CMap_DoneFunc) NULL, / done /
612	(FT_CMap_CharIndexFunc)tt_cmap2_char_index, / char_index /
613	(FT_CMap_CharNextFunc) tt_cmap2_char_next, / char_next /
614
615	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
616	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
617	(FT_CMap_VariantListFunc) NULL, / variant_list /
618	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
619	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
620
621	`2`,
622	(TT_CMap_ValidateFunc)tt_cmap2_validate, / validate /
623	(TT_CMap_Info_GetFunc)tt_cmap2_get_info / get_cmap_info /
624	)
625
626	#endif /* TT_CONFIG_CMAP_FORMAT_2 */
627
628
629	/***********************************************************************/
630	/***********************************************************************/
631	/** **/
632	/** FORMAT 4 **/
633	/** **/
634	/***********************************************************************/
635	/***********************************************************************/
636
637	/**************************************************************************
638	*
639	* TABLE OVERVIEW
640	* --------------
641	*
642	* NAME OFFSET TYPE DESCRIPTION
643	*
644	* format 0 USHORT must be 4
645	* length 2 USHORT table length
646	* in bytes
647	* language 4 USHORT Mac language code
648	*
649	* segCountX2 6 USHORT 2*NUM_SEGS
650	* searchRange 8 USHORT 2*(1 << LOG_SEGS)
651	* entrySelector 10 USHORT LOG_SEGS
652	* rangeShift 12 USHORT segCountX2 -
653	* searchRange
654	*
655	* endCount 14 USHORT[NUM_SEGS] end charcode for
656	* each segment; last
657	* is 0xFFFF
658	*
659	* pad 14+NUM_SEGS*2 USHORT padding
660	*
661	* startCount 16+NUM_SEGS*2 USHORT[NUM_SEGS] first charcode for
662	* each segment
663	*
664	* idDelta 16+NUM_SEGS*4 SHORT[NUM_SEGS] delta for each
665	* segment
666	* idOffset 16+NUM_SEGS*6 SHORT[NUM_SEGS] range offset for
667	* each segment; can be
668	* zero
669	*
670	* glyphIds 16+NUM_SEGS*8 USHORT[] array of glyph ID
671	* ranges
672	*
673	* Character codes are modelled by a series of ordered (increasing)
674	* intervals called segments. Each segment has start and end codes,
675	* provided by the `startCount' and `endCount' arrays. Segments must
676	* not overlap, and the last segment should always contain the value
677	* 0xFFFF for `endCount'.
678	*
679	* The fields `searchRange', `entrySelector' and `rangeShift' are better
680	* ignored (they are traces of over-engineering in the TrueType
681	* specification).
682	*
683	* Each segment also has a signed `delta', as well as an optional offset
684	* within the `glyphIds' table.
685	*
686	* If a segment's idOffset is 0, the glyph index corresponding to any
687	* charcode within the segment is obtained by adding the value of
688	* `idDelta' directly to the charcode, modulo 65536.
689	*
690	* Otherwise, a glyph index is taken from the glyph IDs sub-array for
691	* the segment, and the value of `idDelta' is added to it.
692	*
693	*
694	* Finally, note that a lot of fonts contain an invalid last segment,
695	* where `start' and `end' are correctly set to 0xFFFF but both `delta'
696	* and `offset' are incorrect (e.g., `opens___.ttf' which comes with
697	* OpenOffice.org). We need special code to deal with them correctly.
698	*/
699
700	#ifdef TT_CONFIG_CMAP_FORMAT_4
701
702	typedef struct TT_CMap4Rec_
703	{
704	TT_CMapRec cmap;
705	FT_UInt32 cur_charcode; / current charcode /
706	FT_UInt cur_gindex; / current glyph index /
707
708	FT_UInt num_ranges;
709	FT_UInt cur_range;
710	FT_UInt cur_start;
711	FT_UInt cur_end;
712	FT_Int cur_delta;
713	FT_Byte* cur_values;
714
715	} TT_CMap4Rec, *TT_CMap4;
716
717
718	FT_CALLBACK_DEF( FT_Error )
719	tt_cmap4_init( FT_CMap cmap, / TT_CMap4 /
720	void* table_ )
721	{
722	TT_CMap4 ttcmap = (TT_CMap4)cmap;
723	FT_Byte* table = (FT_Byte*)table_;
724	FT_Byte* p;
725
726
727	ttcmap->cmap.data = table;
728
729	p = table + `6`;
730	ttcmap->num_ranges = FT_PEEK_USHORT( p ) >> `1`;
731	ttcmap->cur_charcode = (FT_UInt32)`0xFFFFFFFFUL`;
732	ttcmap->cur_gindex = `0`;
733
734	return FT_Err_Ok;
735	}
736
737
738	static FT_Int
739	tt_cmap4_set_range( TT_CMap4 cmap,
740	FT_UInt range_index )
741	{
742	FT_Byte* table = cmap->cmap.data;
743	FT_Byte* p;
744	FT_UInt num_ranges = cmap->num_ranges;
745
746
747	while ( range_index < num_ranges )
748	{
749	FT_UInt offset;
750
751
752	p = table + `14` + range_index * `2`;
753	cmap->cur_end = FT_PEEK_USHORT( p );
754
755	p += `2` + num_ranges * `2`;
756	cmap->cur_start = FT_PEEK_USHORT( p );
757
758	p += num_ranges * `2`;
759	cmap->cur_delta = FT_PEEK_SHORT( p );
760
761	p += num_ranges * `2`;
762	offset = FT_PEEK_USHORT( p );
763
764	/ some fonts have an incorrect last segment; /
765	/ we have to catch it /
766	if ( range_index >= num_ranges - `1` &&
767	cmap->cur_start == `0xFFFFU` &&
768	cmap->cur_end == `0xFFFFU` )
769	{
770	TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
771	FT_Byte* limit = face->cmap_table + face->cmap_size;
772
773
774	if ( offset && p + offset + `2` > limit )
775	{
776	cmap->cur_delta = `1`;
777	offset = `0`;
778	}
779	}
780
781	if ( offset != `0xFFFFU` )
782	{
783	cmap->cur_values = offset ? p + offset : NULL;
784	cmap->cur_range = range_index;
785	return `0`;
786	}
787
788	/ we skip empty segments /
789	range_index++;
790	}
791
792	return -`1`;
793	}
794
795
796	/ search the index of the charcode next to cmap->cur_charcode; /
797	/ caller should call tt_cmap4_set_range with proper range /
798	/ before calling this function /
799	/ /
800	static void
801	tt_cmap4_next( TT_CMap4 cmap )
802	{
803	TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
804	FT_Byte* limit = face->cmap_table + face->cmap_size;
805
806	FT_UInt charcode;
807
808
809	charcode = (FT_UInt)cmap->cur_charcode + `1`;
810
811	if ( charcode < cmap->cur_start )
812	charcode = cmap->cur_start;
813
814	for (;;)
815	{
816	FT_Byte* values = cmap->cur_values;
817	FT_UInt end = cmap->cur_end;
818	FT_Int delta = cmap->cur_delta;
819
820
821	if ( charcode <= end )
822	{
823	if ( values )
824	{
825	FT_Byte* p = values + `2` * ( charcode - cmap->cur_start );
826
827
828	/ if p > limit, the whole segment is invalid /
829	if ( p > limit )
830	goto Next_Segment;
831
832	do
833	{
834	FT_UInt gindex = FT_NEXT_USHORT( p );
835
836
837	if ( gindex )
838	{
839	gindex = (FT_UInt)( (FT_Int)gindex + delta ) & `0xFFFFU`;
840	if ( gindex )
841	{
842	cmap->cur_charcode = charcode;
843	cmap->cur_gindex = gindex;
844	return;
845	}
846	}
847	} while ( ++charcode <= end );
848	}
849	else
850	{
851	do
852	{
853	FT_UInt gindex = (FT_UInt)( (FT_Int)charcode + delta ) & `0xFFFFU`;
854
855
856	if ( gindex >= (FT_UInt)face->root.num_glyphs )
857	{
858	/ we have an invalid glyph index; if there is an overflow, /
859	/ we can adjust `charcode', otherwise the whole segment is /
860	/ invalid /
861	gindex = `0`;
862
863	if ( (FT_Int)charcode + delta < `0` &&
864	(FT_Int)end + delta >= `0` )
865	charcode = (FT_UInt)( -delta );
866
867	else if ( (FT_Int)charcode + delta < `0x10000L` &&
868	(FT_Int)end + delta >= `0x10000L` )
869	charcode = (FT_UInt)( `0x10000L` - delta );
870
871	else
872	goto Next_Segment;
873	}
874
875	if ( gindex )
876	{
877	cmap->cur_charcode = charcode;
878	cmap->cur_gindex = gindex;
879	return;
880	}
881	} while ( ++charcode <= end );
882	}
883	}
884
885	Next_Segment:
886	/ we need to find another range /
887	if ( tt_cmap4_set_range( cmap, cmap->cur_range + `1` ) < `0` )
888	break;
889
890	if ( charcode < cmap->cur_start )
891	charcode = cmap->cur_start;
892	}
893
894	cmap->cur_charcode = (FT_UInt32)`0xFFFFFFFFUL`;
895	cmap->cur_gindex = `0`;
896	}
897
898
899	FT_CALLBACK_DEF( FT_Error )
900	tt_cmap4_validate( FT_Byte* table,
901	FT_Validator valid )
902	{
903	FT_Byte* p;
904	FT_UInt length;
905
906	FT_Byte ends, starts, offsets, deltas, *glyph_ids;
907	FT_UInt num_segs;
908	FT_Error error = FT_Err_Ok;
909
910
911	if ( table + `2` + `2` > valid->limit )
912	FT_INVALID_TOO_SHORT;
913
914	p = table + `2`; / skip format /
915	length = TT_NEXT_USHORT( p );
916
917	/ in certain fonts, the `length' field is invalid and goes /
918	/ out of bound. We try to correct this here... /
919	if ( table + length > valid->limit )
920	{
921	if ( valid->level >= FT_VALIDATE_TIGHT )
922	FT_INVALID_TOO_SHORT;
923
924	length = (FT_UInt)( valid->limit - table );
925	}
926
927	/ it also happens that the `length' field is too small; /
928	/ this is easy to correct /
929	if ( length < (FT_UInt)( valid->limit - table ) )
930	{
931	if ( valid->level >= FT_VALIDATE_PARANOID )
932	FT_INVALID_DATA;
933
934	length = (FT_UInt)( valid->limit - table );
935	}
936
937	if ( length < `16` )
938	FT_INVALID_TOO_SHORT;
939
940	p = table + `6`;
941	num_segs = TT_NEXT_USHORT( p ); / read segCountX2 /
942
943	if ( valid->level >= FT_VALIDATE_PARANOID )
944	{
945	/ check that we have an even value here /
946	if ( num_segs & `1` )
947	FT_INVALID_DATA;
948	}
949
950	num_segs /= `2`;
951
952	if ( length < `16` + num_segs * `2` * `4` )
953	FT_INVALID_TOO_SHORT;
954
955	/ check the search parameters - even though we never use them /
956	/ /
957	if ( valid->level >= FT_VALIDATE_PARANOID )
958	{
959	/ check the values of `searchRange', `entrySelector', `rangeShift' /
960	FT_UInt search_range = TT_NEXT_USHORT( p );
961	FT_UInt entry_selector = TT_NEXT_USHORT( p );
962	FT_UInt range_shift = TT_NEXT_USHORT( p );
963
964
965	if ( ( search_range \| range_shift ) & `1` ) / must be even values /
966	FT_INVALID_DATA;
967
968	search_range /= `2`;
969	range_shift /= `2`;
970
971	/ `search range' is the greatest power of 2 that is <= num_segs /
972
973	if ( search_range > num_segs \|\|
974	search_range * `2` < num_segs \|\|
975	search_range + range_shift != num_segs \|\|
976	search_range != ( `1U` << entry_selector ) )
977	FT_INVALID_DATA;
978	}
979
980	ends = table + `14`;
981	starts = table + `16` + num_segs * `2`;
982	deltas = starts + num_segs * `2`;
983	offsets = deltas + num_segs * `2`;
984	glyph_ids = offsets + num_segs * `2`;
985
986	/ check last segment; its end count value must be 0xFFFF /
987	if ( valid->level >= FT_VALIDATE_PARANOID )
988	{
989	p = ends + ( num_segs - `1` ) * `2`;
990	if ( TT_PEEK_USHORT( p ) != `0xFFFFU` )
991	FT_INVALID_DATA;
992	}
993
994	{
995	FT_UInt start, end, offset, n;
996	FT_UInt last_start = `0`, last_end = `0`;
997	FT_Int delta;
998	FT_Byte* p_start = starts;
999	FT_Byte* p_end = ends;
1000	FT_Byte* p_delta = deltas;
1001	FT_Byte* p_offset = offsets;
1002
1003
1004	for ( n = `0`; n < num_segs; n++ )
1005	{
1006	p = p_offset;
1007	start = TT_NEXT_USHORT( p_start );
1008	end = TT_NEXT_USHORT( p_end );
1009	delta = TT_NEXT_SHORT( p_delta );
1010	offset = TT_NEXT_USHORT( p_offset );
1011
1012	if ( start > end )
1013	FT_INVALID_DATA;
1014
1015	/ this test should be performed at default validation level; /
1016	/ unfortunately, some popular Asian fonts have overlapping /
1017	/ ranges in their charmaps /
1018	/ /
1019	if ( start <= last_end && n > `0` )
1020	{
1021	if ( valid->level >= FT_VALIDATE_TIGHT )
1022	FT_INVALID_DATA;
1023	else
1024	{
1025	/ allow overlapping segments, provided their start points /
1026	/ and end points, respectively, are in ascending order /
1027	/ /
1028	if ( last_start > start \|\| last_end > end )
1029	error \|= TT_CMAP_FLAG_UNSORTED;
1030	else
1031	error \|= TT_CMAP_FLAG_OVERLAPPING;
1032	}
1033	}
1034
1035	if ( offset && offset != `0xFFFFU` )
1036	{
1037	p += offset; / start of glyph ID array /
1038
1039	/ check that we point within the glyph IDs table only /
1040	if ( valid->level >= FT_VALIDATE_TIGHT )
1041	{
1042	if ( p < glyph_ids \|\|
1043	p + ( end - start + `1` ) * `2` > table + length )
1044	FT_INVALID_DATA;
1045	}
1046	/ Some fonts handle the last segment incorrectly. In /
1047	/ theory, 0xFFFF might point to an ordinary glyph -- /
1048	/ a cmap 4 is versatile and could be used for any /
1049	/ encoding, not only Unicode. However, reality shows /
1050	/ that far too many fonts are sloppy and incorrectly /
1051	/ set all fields but `start' and `end' for the last /
1052	/ segment if it contains only a single character. /
1053	/ /
1054	/ We thus omit the test here, delaying it to the /
1055	/ routines that actually access the cmap. /
1056	else if ( n != num_segs - `1` \|\|
1057	!( start == `0xFFFFU` && end == `0xFFFFU` ) )
1058	{
1059	if ( p < glyph_ids \|\|
1060	p + ( end - start + `1` ) * `2` > valid->limit )
1061	FT_INVALID_DATA;
1062	}
1063
1064	/ check glyph indices within the segment range /
1065	if ( valid->level >= FT_VALIDATE_TIGHT )
1066	{
1067	FT_UInt i, idx;
1068
1069
1070	for ( i = start; i < end; i++ )
1071	{
1072	idx = FT_NEXT_USHORT( p );
1073	if ( idx != `0` )
1074	{
1075	idx = (FT_UInt)( (FT_Int)idx + delta ) & `0xFFFFU`;
1076
1077	if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
1078	FT_INVALID_GLYPH_ID;
1079	}
1080	}
1081	}
1082	}
1083	else if ( offset == `0xFFFFU` )
1084	{
1085	/ some fonts (erroneously?) use a range offset of 0xFFFF /
1086	/ to mean missing glyph in cmap table /
1087	/ /
1088	if ( valid->level >= FT_VALIDATE_PARANOID \|\|
1089	n != num_segs - `1` \|\|
1090	!( start == `0xFFFFU` && end == `0xFFFFU` ) )
1091	FT_INVALID_DATA;
1092	}
1093
1094	last_start = start;
1095	last_end = end;
1096	}
1097	}
1098
1099	return error;
1100	}
1101
1102
1103	static FT_UInt
1104	tt_cmap4_char_map_linear( TT_CMap cmap,
1105	FT_UInt32* pcharcode,
1106	FT_Bool next )
1107	{
1108	TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
1109	FT_Byte* limit = face->cmap_table + face->cmap_size;
1110
1111
1112	FT_UInt num_segs2, start, end, offset;
1113	FT_Int delta;
1114	FT_UInt i, num_segs;
1115	FT_UInt32 charcode = *pcharcode + next;
1116	FT_UInt gindex = `0`;
1117	FT_Byte* p;
1118	FT_Byte* q;
1119
1120
1121	p = cmap->data + `6`;
1122	num_segs = TT_PEEK_USHORT( p ) >> `1`;
1123
1124	if ( !num_segs )
1125	return `0`;
1126
1127	num_segs2 = num_segs << `1`;
1128
1129	/ linear search /
1130	p = cmap->data + `14`; / ends table /
1131	q = cmap->data + `16` + num_segs2; / starts table /
1132
1133	for ( i = `0`; i < num_segs; i++ )
1134	{
1135	end = TT_NEXT_USHORT( p );
1136	start = TT_NEXT_USHORT( q );
1137
1138	if ( charcode < start )
1139	{
1140	if ( next )
1141	charcode = start;
1142	else
1143	break;
1144	}
1145
1146	Again:
1147	if ( charcode <= end )
1148	{
1149	FT_Byte* r;
1150
1151
1152	r = q - `2` + num_segs2;
1153	delta = TT_PEEK_SHORT( r );
1154	r += num_segs2;
1155	offset = TT_PEEK_USHORT( r );
1156
1157	/ some fonts have an incorrect last segment; /
1158	/ we have to catch it /
1159	if ( i >= num_segs - `1` &&
1160	start == `0xFFFFU` && end == `0xFFFFU` )
1161	{
1162	if ( offset && r + offset + `2` > limit )
1163	{
1164	delta = `1`;
1165	offset = `0`;
1166	}
1167	}
1168
1169	if ( offset == `0xFFFFU` )
1170	continue;
1171
1172	if ( offset )
1173	{
1174	r += offset + ( charcode - start ) * `2`;
1175
1176	/ if r > limit, the whole segment is invalid /
1177	if ( next && r > limit )
1178	continue;
1179
1180	gindex = TT_PEEK_USHORT( r );
1181	if ( gindex )
1182	{
1183	gindex = (FT_UInt)( (FT_Int)gindex + delta ) & `0xFFFFU`;
1184	if ( gindex >= (FT_UInt)face->root.num_glyphs )
1185	gindex = `0`;
1186	}
1187	}
1188	else
1189	{
1190	gindex = (FT_UInt)( (FT_Int)charcode + delta ) & `0xFFFFU`;
1191
1192	if ( next && gindex >= (FT_UInt)face->root.num_glyphs )
1193	{
1194	/ we have an invalid glyph index; if there is an overflow, /
1195	/ we can adjust `charcode', otherwise the whole segment is /
1196	/ invalid /
1197	gindex = `0`;
1198
1199	if ( (FT_Int)charcode + delta < `0` &&
1200	(FT_Int)end + delta >= `0` )
1201	charcode = (FT_UInt)( -delta );
1202
1203	else if ( (FT_Int)charcode + delta < `0x10000L` &&
1204	(FT_Int)end + delta >= `0x10000L` )
1205	charcode = (FT_UInt)( `0x10000L` - delta );
1206
1207	else
1208	continue;
1209	}
1210	}
1211
1212	if ( next && !gindex )
1213	{
1214	if ( charcode >= `0xFFFFU` )
1215	break;
1216
1217	charcode++;
1218	goto Again;
1219	}
1220
1221	break;
1222	}
1223	}
1224
1225	if ( next )
1226	*pcharcode = charcode;
1227
1228	return gindex;
1229	}
1230
1231
1232	static FT_UInt
1233	tt_cmap4_char_map_binary( TT_CMap cmap,
1234	FT_UInt32* pcharcode,
1235	FT_Bool next )
1236	{
1237	TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
1238	FT_Byte* limit = face->cmap_table + face->cmap_size;
1239
1240	FT_UInt num_segs2, start, end, offset;
1241	FT_Int delta;
1242	FT_UInt max, min, mid, num_segs;
1243	FT_UInt charcode = (FT_UInt)*pcharcode + next;
1244	FT_UInt gindex = `0`;
1245	FT_Byte* p;
1246
1247
1248	p = cmap->data + `6`;
1249	num_segs = TT_PEEK_USHORT( p ) >> `1`;
1250
1251	if ( !num_segs )
1252	return `0`;
1253
1254	num_segs2 = num_segs << `1`;
1255
1256	min = `0`;
1257	max = num_segs;
1258
1259	/ binary search /
1260	do
1261	{
1262	mid = ( min + max ) >> `1`;
1263	p = cmap->data + `14` + mid * `2`;
1264	end = TT_PEEK_USHORT( p );
1265	p += `2` + num_segs2;
1266	start = TT_PEEK_USHORT( p );
1267
1268	if ( charcode < start )
1269	max = mid;
1270	else if ( charcode > end )
1271	min = mid + `1`;
1272	else
1273	{
1274	p += num_segs2;
1275	delta = TT_PEEK_SHORT( p );
1276	p += num_segs2;
1277	offset = TT_PEEK_USHORT( p );
1278
1279	/ some fonts have an incorrect last segment; /
1280	/ we have to catch it /
1281	if ( mid >= num_segs - `1` &&
1282	start == `0xFFFFU` && end == `0xFFFFU` )
1283	{
1284	if ( offset && p + offset + `2` > limit )
1285	{
1286	delta = `1`;
1287	offset = `0`;
1288	}
1289	}
1290
1291	/ search the first segment containing `charcode' /
1292	if ( cmap->flags & TT_CMAP_FLAG_OVERLAPPING )
1293	{
1294	FT_UInt i;
1295
1296
1297	/ call the current segment `max' /
1298	max = mid;
1299
1300	if ( offset == `0xFFFFU` )
1301	mid = max + `1`;
1302
1303	/ search in segments before the current segment /
1304	for ( i = max; i > `0`; i-- )
1305	{
1306	FT_UInt prev_end;
1307	FT_Byte* old_p;
1308
1309
1310	old_p = p;
1311	p = cmap->data + `14` + ( i - `1` ) * `2`;
1312	prev_end = TT_PEEK_USHORT( p );
1313
1314	if ( charcode > prev_end )
1315	{
1316	p = old_p;
1317	break;
1318	}
1319
1320	end = prev_end;
1321	p += `2` + num_segs2;
1322	start = TT_PEEK_USHORT( p );
1323	p += num_segs2;
1324	delta = TT_PEEK_SHORT( p );
1325	p += num_segs2;
1326	offset = TT_PEEK_USHORT( p );
1327
1328	if ( offset != `0xFFFFU` )
1329	mid = i - `1`;
1330	}
1331
1332	/ no luck /
1333	if ( mid == max + `1` )
1334	{
1335	if ( i != max )
1336	{
1337	p = cmap->data + `14` + max * `2`;
1338	end = TT_PEEK_USHORT( p );
1339	p += `2` + num_segs2;
1340	start = TT_PEEK_USHORT( p );
1341	p += num_segs2;
1342	delta = TT_PEEK_SHORT( p );
1343	p += num_segs2;
1344	offset = TT_PEEK_USHORT( p );
1345	}
1346
1347	mid = max;
1348
1349	/ search in segments after the current segment /
1350	for ( i = max + `1`; i < num_segs; i++ )
1351	{
1352	FT_UInt next_end, next_start;
1353
1354
1355	p = cmap->data + `14` + i * `2`;
1356	next_end = TT_PEEK_USHORT( p );
1357	p += `2` + num_segs2;
1358	next_start = TT_PEEK_USHORT( p );
1359
1360	if ( charcode < next_start )
1361	break;
1362
1363	end = next_end;
1364	start = next_start;
1365	p += num_segs2;
1366	delta = TT_PEEK_SHORT( p );
1367	p += num_segs2;
1368	offset = TT_PEEK_USHORT( p );
1369
1370	if ( offset != `0xFFFFU` )
1371	mid = i;
1372	}
1373	i--;
1374
1375	/ still no luck /
1376	if ( mid == max )
1377	{
1378	mid = i;
1379
1380	break;
1381	}
1382	}
1383
1384	/ end, start, delta, and offset are for the i'th segment /
1385	if ( mid != i )
1386	{
1387	p = cmap->data + `14` + mid * `2`;
1388	end = TT_PEEK_USHORT( p );
1389	p += `2` + num_segs2;
1390	start = TT_PEEK_USHORT( p );
1391	p += num_segs2;
1392	delta = TT_PEEK_SHORT( p );
1393	p += num_segs2;
1394	offset = TT_PEEK_USHORT( p );
1395	}
1396	}
1397	else
1398	{
1399	if ( offset == `0xFFFFU` )
1400	break;
1401	}
1402
1403	if ( offset )
1404	{
1405	p += offset + ( charcode - start ) * `2`;
1406
1407	/ if p > limit, the whole segment is invalid /
1408	if ( next && p > limit )
1409	break;
1410
1411	gindex = TT_PEEK_USHORT( p );
1412	if ( gindex )
1413	{
1414	gindex = (FT_UInt)( (FT_Int)gindex + delta ) & `0xFFFFU`;
1415	if ( gindex >= (FT_UInt)face->root.num_glyphs )
1416	gindex = `0`;
1417	}
1418	}
1419	else
1420	{
1421	gindex = (FT_UInt)( (FT_Int)charcode + delta ) & `0xFFFFU`;
1422
1423	if ( next && gindex >= (FT_UInt)face->root.num_glyphs )
1424	{
1425	/ we have an invalid glyph index; if there is an overflow, /
1426	/ we can adjust `charcode', otherwise the whole segment is /
1427	/ invalid /
1428	gindex = `0`;
1429
1430	if ( (FT_Int)charcode + delta < `0` &&
1431	(FT_Int)end + delta >= `0` )
1432	charcode = (FT_UInt)( -delta );
1433
1434	else if ( (FT_Int)charcode + delta < `0x10000L` &&
1435	(FT_Int)end + delta >= `0x10000L` )
1436	charcode = (FT_UInt)( `0x10000L` - delta );
1437	}
1438	}
1439
1440	break;
1441	}
1442	}
1443	while ( min < max );
1444
1445	if ( next )
1446	{
1447	TT_CMap4 cmap4 = (TT_CMap4)cmap;
1448
1449
1450	/ if `charcode' is not in any segment, then `mid' is /
1451	/ the segment nearest to `charcode' /
1452
1453	if ( charcode > end && ++mid == num_segs )
1454	return `0`;
1455
1456	if ( tt_cmap4_set_range( cmap4, mid ) )
1457	{
1458	if ( gindex )
1459	*pcharcode = charcode;
1460	}
1461	else
1462	{
1463	cmap4->cur_charcode = charcode;
1464
1465	if ( gindex )
1466	cmap4->cur_gindex = gindex;
1467	else
1468	{
1469	tt_cmap4_next( cmap4 );
1470	gindex = cmap4->cur_gindex;
1471	}
1472
1473	if ( gindex )
1474	*pcharcode = cmap4->cur_charcode;
1475	}
1476	}
1477
1478	return gindex;
1479	}
1480
1481
1482	FT_CALLBACK_DEF( FT_UInt )
1483	tt_cmap4_char_index( FT_CMap cmap, / TT_CMap /
1484	FT_UInt32 char_code )
1485	{
1486	TT_CMap ttcmap = (TT_CMap)cmap;
1487
1488
1489	if ( char_code >= `0x10000UL` )
1490	return `0`;
1491
1492	if ( ttcmap->flags & TT_CMAP_FLAG_UNSORTED )
1493	return tt_cmap4_char_map_linear( ttcmap, &char_code, `0` );
1494	else
1495	return tt_cmap4_char_map_binary( ttcmap, &char_code, `0` );
1496	}
1497
1498
1499	FT_CALLBACK_DEF( FT_UInt )
1500	tt_cmap4_char_next( FT_CMap cmap, / TT_CMap /
1501	FT_UInt32 *pchar_code )
1502	{
1503	TT_CMap ttcmap = (TT_CMap)cmap;
1504	FT_UInt gindex;
1505
1506
1507	if ( *pchar_code >= `0xFFFFU` )
1508	return `0`;
1509
1510	if ( ttcmap->flags & TT_CMAP_FLAG_UNSORTED )
1511	gindex = tt_cmap4_char_map_linear( ttcmap, pchar_code, `1` );
1512	else
1513	{
1514	TT_CMap4 cmap4 = (TT_CMap4)cmap;
1515
1516
1517	/ no need to search /
1518	if ( *pchar_code == cmap4->cur_charcode )
1519	{
1520	tt_cmap4_next( cmap4 );
1521	gindex = cmap4->cur_gindex;
1522	if ( gindex )
1523	*pchar_code = cmap4->cur_charcode;
1524	}
1525	else
1526	gindex = tt_cmap4_char_map_binary( ttcmap, pchar_code, `1` );
1527	}
1528
1529	return gindex;
1530	}
1531
1532
1533	FT_CALLBACK_DEF( FT_Error )
1534	tt_cmap4_get_info( FT_CharMap cmap, / TT_CMap /
1535	TT_CMapInfo *cmap_info )
1536	{
1537	TT_CMap ttcmap = (TT_CMap)cmap;
1538	FT_Byte* p = ttcmap->data + `4`;
1539
1540
1541	cmap_info->format = `4`;
1542	cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
1543
1544	return FT_Err_Ok;
1545	}
1546
1547
1548	FT_DEFINE_TT_CMAP(
1549	tt_cmap4_class_rec,
1550
1551	sizeof ( TT_CMap4Rec ),
1552
1553	(FT_CMap_InitFunc) tt_cmap4_init, / init /
1554	(FT_CMap_DoneFunc) NULL, / done /
1555	(FT_CMap_CharIndexFunc)tt_cmap4_char_index, / char_index /
1556	(FT_CMap_CharNextFunc) tt_cmap4_char_next, / char_next /
1557
1558	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
1559	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
1560	(FT_CMap_VariantListFunc) NULL, / variant_list /
1561	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
1562	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
1563
1564	`4`,
1565	(TT_CMap_ValidateFunc)tt_cmap4_validate, / validate /
1566	(TT_CMap_Info_GetFunc)tt_cmap4_get_info / get_cmap_info /
1567	)
1568
1569	#endif /* TT_CONFIG_CMAP_FORMAT_4 */
1570
1571
1572	/***********************************************************************/
1573	/***********************************************************************/
1574	/** **/
1575	/** FORMAT 6 **/
1576	/** **/
1577	/***********************************************************************/
1578	/***********************************************************************/
1579
1580	/**************************************************************************
1581	*
1582	* TABLE OVERVIEW
1583	* --------------
1584	*
1585	* NAME OFFSET TYPE DESCRIPTION
1586	*
1587	* format 0 USHORT must be 6
1588	* length 2 USHORT table length in bytes
1589	* language 4 USHORT Mac language code
1590	*
1591	* first 6 USHORT first segment code
1592	* count 8 USHORT segment size in chars
1593	* glyphIds 10 USHORT[count] glyph IDs
1594	*
1595	* A very simplified segment mapping.
1596	*/
1597
1598	#ifdef TT_CONFIG_CMAP_FORMAT_6
1599
1600	FT_CALLBACK_DEF( FT_Error )
1601	tt_cmap6_validate( FT_Byte* table,
1602	FT_Validator valid )
1603	{
1604	FT_Byte* p;
1605	FT_UInt length, count;
1606
1607
1608	if ( table + `10` > valid->limit )
1609	FT_INVALID_TOO_SHORT;
1610
1611	p = table + `2`;
1612	length = TT_NEXT_USHORT( p );
1613
1614	p = table + `8`; / skip language and start index /
1615	count = TT_NEXT_USHORT( p );
1616
1617	if ( table + length > valid->limit \|\| length < `10` + count * `2` )
1618	FT_INVALID_TOO_SHORT;
1619
1620	/ check glyph indices /
1621	if ( valid->level >= FT_VALIDATE_TIGHT )
1622	{
1623	FT_UInt gindex;
1624
1625
1626	for ( ; count > `0`; count-- )
1627	{
1628	gindex = TT_NEXT_USHORT( p );
1629	if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
1630	FT_INVALID_GLYPH_ID;
1631	}
1632	}
1633
1634	return FT_Err_Ok;
1635	}
1636
1637
1638	FT_CALLBACK_DEF( FT_UInt )
1639	tt_cmap6_char_index( FT_CMap cmap, / TT_CMap /
1640	FT_UInt32 char_code )
1641	{
1642	TT_CMap ttcmap = (TT_CMap)cmap;
1643	FT_Byte* table = ttcmap->data;
1644	FT_UInt result = `0`;
1645	FT_Byte* p = table + `6`;
1646	FT_UInt start = TT_NEXT_USHORT( p );
1647	FT_UInt count = TT_NEXT_USHORT( p );
1648	FT_UInt idx = (FT_UInt)( char_code - start );
1649
1650
1651	if ( idx < count )
1652	{
1653	p += `2` * idx;
1654	result = TT_PEEK_USHORT( p );
1655	}
1656
1657	return result;
1658	}
1659
1660
1661	FT_CALLBACK_DEF( FT_UInt )
1662	tt_cmap6_char_next( FT_CMap cmap, / TT_CMap /
1663	FT_UInt32 *pchar_code )
1664	{
1665	TT_CMap ttcmap = (TT_CMap)cmap;
1666	FT_Byte* table = ttcmap->data;
1667	FT_UInt32 result = `0`;
1668	FT_UInt32 char_code = *pchar_code + `1`;
1669	FT_UInt gindex = `0`;
1670
1671	FT_Byte* p = table + `6`;
1672	FT_UInt start = TT_NEXT_USHORT( p );
1673	FT_UInt count = TT_NEXT_USHORT( p );
1674	FT_UInt idx;
1675
1676
1677	if ( char_code >= `0x10000UL` )
1678	return `0`;
1679
1680	if ( char_code < start )
1681	char_code = start;
1682
1683	idx = (FT_UInt)( char_code - start );
1684	p += `2` * idx;
1685
1686	for ( ; idx < count; idx++ )
1687	{
1688	gindex = TT_NEXT_USHORT( p );
1689	if ( gindex != `0` )
1690	{
1691	result = char_code;
1692	break;
1693	}
1694
1695	if ( char_code >= `0xFFFFU` )
1696	return `0`;
1697
1698	char_code++;
1699	}
1700
1701	*pchar_code = result;
1702	return gindex;
1703	}
1704
1705
1706	FT_CALLBACK_DEF( FT_Error )
1707	tt_cmap6_get_info( FT_CharMap cmap, / TT_CMap /
1708	TT_CMapInfo *cmap_info )
1709	{
1710	TT_CMap ttcmap = (TT_CMap)cmap;
1711	FT_Byte* p = ttcmap->data + `4`;
1712
1713
1714	cmap_info->format = `6`;
1715	cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
1716
1717	return FT_Err_Ok;
1718	}
1719
1720
1721	FT_DEFINE_TT_CMAP(
1722	tt_cmap6_class_rec,
1723
1724	sizeof ( TT_CMapRec ),
1725
1726	(FT_CMap_InitFunc) tt_cmap_init, / init /
1727	(FT_CMap_DoneFunc) NULL, / done /
1728	(FT_CMap_CharIndexFunc)tt_cmap6_char_index, / char_index /
1729	(FT_CMap_CharNextFunc) tt_cmap6_char_next, / char_next /
1730
1731	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
1732	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
1733	(FT_CMap_VariantListFunc) NULL, / variant_list /
1734	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
1735	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
1736
1737	`6`,
1738	(TT_CMap_ValidateFunc)tt_cmap6_validate, / validate /
1739	(TT_CMap_Info_GetFunc)tt_cmap6_get_info / get_cmap_info /
1740	)
1741
1742	#endif /* TT_CONFIG_CMAP_FORMAT_6 */
1743
1744
1745	/***********************************************************************/
1746	/***********************************************************************/
1747	/** **/
1748	/** FORMAT 8 **/
1749	/** **/
1750	/** It is hard to completely understand what the OpenType spec **/
1751	/** says about this format, but here is my conclusion. **/
1752	/** **/
1753	/** The purpose of this format is to easily map UTF-16 text to **/
1754	/** glyph indices. Basically, the `char_code' must be in one of **/
1755	/** the following formats. **/
1756	/** **/
1757	/** - A 16-bit value that isn't part of the Unicode Surrogates **/
1758	/** Area (i.e. U+D800-U+DFFF). **/
1759	/** **/
1760	/** - A 32-bit value, made of two surrogate values, i.e.. if **/
1761	/** `char_code = (char_hi << 16) \| char_lo', then both **/
1762	/** `char_hi' and `char_lo' must be in the Surrogates Area. **/
1763	/** Area. **/
1764	/** **/
1765	/** The `is32' table embedded in the charmap indicates whether a **/
1766	/** given 16-bit value is in the surrogates area or not. **/
1767	/** **/
1768	/** So, for any given `char_code', we can assert the following. **/
1769	/** **/
1770	/** If `char_hi == 0' then we must have `is32[char_lo] == 0'. **/
1771	/** **/
1772	/** If `char_hi != 0' then we must have both **/
1773	/** `is32[char_hi] != 0' and `is32[char_lo] != 0'. **/
1774	/** **/
1775	/***********************************************************************/
1776	/***********************************************************************/
1777
1778	/**************************************************************************
1779	*
1780	* TABLE OVERVIEW
1781	* --------------
1782	*
1783	* NAME OFFSET TYPE DESCRIPTION
1784	*
1785	* format 0 USHORT must be 8
1786	* reserved 2 USHORT reserved
1787	* length 4 ULONG length in bytes
1788	* language 8 ULONG Mac language code
1789	* is32 12 BYTE[8192] 32-bitness bitmap
1790	* count 8204 ULONG number of groups
1791	*
1792	* This header is followed by `count' groups of the following format:
1793	*
1794	* start 0 ULONG first charcode
1795	* end 4 ULONG last charcode
1796	* startId 8 ULONG start glyph ID for the group
1797	*/
1798
1799	#ifdef TT_CONFIG_CMAP_FORMAT_8
1800
1801	FT_CALLBACK_DEF( FT_Error )
1802	tt_cmap8_validate( FT_Byte* table,
1803	FT_Validator valid )
1804	{
1805	FT_Byte* p = table + `4`;
1806	FT_Byte* is32;
1807	FT_UInt32 length;
1808	FT_UInt32 num_groups;
1809
1810
1811	if ( table + `16` + `8192` > valid->limit )
1812	FT_INVALID_TOO_SHORT;
1813
1814	length = TT_NEXT_ULONG( p );
1815	if ( length > (FT_UInt32)( valid->limit - table ) \|\| length < `8192` + `16` )
1816	FT_INVALID_TOO_SHORT;
1817
1818	is32 = table + `12`;
1819	p = is32 + `8192`; / skip `is32' array /
1820	num_groups = TT_NEXT_ULONG( p );
1821
1822	/ p + num_groups * 12 > valid->limit ? /
1823	if ( num_groups > (FT_UInt32)( valid->limit - p ) / `12` )
1824	FT_INVALID_TOO_SHORT;
1825
1826	/ check groups, they must be in increasing order /
1827	{
1828	FT_UInt32 n, start, end, start_id, count, last = `0`;
1829
1830
1831	for ( n = `0`; n < num_groups; n++ )
1832	{
1833	FT_UInt hi, lo;
1834
1835
1836	start = TT_NEXT_ULONG( p );
1837	end = TT_NEXT_ULONG( p );
1838	start_id = TT_NEXT_ULONG( p );
1839
1840	if ( start > end )
1841	FT_INVALID_DATA;
1842
1843	if ( n > `0` && start <= last )
1844	FT_INVALID_DATA;
1845
1846	if ( valid->level >= FT_VALIDATE_TIGHT )
1847	{
1848	FT_UInt32 d = end - start;
1849
1850
1851	/ start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) ? /
1852	if ( d > TT_VALID_GLYPH_COUNT( valid ) \|\|
1853	start_id >= TT_VALID_GLYPH_COUNT( valid ) - d )
1854	FT_INVALID_GLYPH_ID;
1855
1856	count = (FT_UInt32)( end - start + `1` );
1857
1858	if ( start & ~`0xFFFFU` )
1859	{
1860	/ start_hi != 0; check that is32[i] is 1 for each i in /
1861	/ the `hi' and `lo' of the range [start..end] /
1862	for ( ; count > `0`; count--, start++ )
1863	{
1864	hi = (FT_UInt)( start >> `16` );
1865	lo = (FT_UInt)( start & `0xFFFFU` );
1866
1867	if ( (is32[hi >> `3`] & ( `0x80` >> ( hi & `7` ) ) ) == `0` )
1868	FT_INVALID_DATA;
1869
1870	if ( (is32[lo >> `3`] & ( `0x80` >> ( lo & `7` ) ) ) == `0` )
1871	FT_INVALID_DATA;
1872	}
1873	}
1874	else
1875	{
1876	/ start_hi == 0; check that is32[i] is 0 for each i in /
1877	/ the range [start..end] /
1878
1879	/ end_hi cannot be != 0! /
1880	if ( end & ~`0xFFFFU` )
1881	FT_INVALID_DATA;
1882
1883	for ( ; count > `0`; count--, start++ )
1884	{
1885	lo = (FT_UInt)( start & `0xFFFFU` );
1886
1887	if ( (is32[lo >> `3`] & ( `0x80` >> ( lo & `7` ) ) ) != `0` )
1888	FT_INVALID_DATA;
1889	}
1890	}
1891	}
1892
1893	last = end;
1894	}
1895	}
1896
1897	return FT_Err_Ok;
1898	}
1899
1900
1901	FT_CALLBACK_DEF( FT_UInt )
1902	tt_cmap8_char_index( FT_CMap cmap, / TT_CMap /
1903	FT_UInt32 char_code )
1904	{
1905	TT_CMap ttcmap = (TT_CMap)cmap;
1906	FT_Byte* table = ttcmap->data;
1907	FT_UInt result = `0`;
1908	FT_Byte* p = table + `8204`;
1909	FT_UInt32 num_groups = TT_NEXT_ULONG( p );
1910	FT_UInt32 start, end, start_id;
1911
1912
1913	for ( ; num_groups > `0`; num_groups-- )
1914	{
1915	start = TT_NEXT_ULONG( p );
1916	end = TT_NEXT_ULONG( p );
1917	start_id = TT_NEXT_ULONG( p );
1918
1919	if ( char_code < start )
1920	break;
1921
1922	if ( char_code <= end )
1923	{
1924	if ( start_id > `0xFFFFFFFFUL` - ( char_code - start ) )
1925	return `0`;
1926
1927	result = (FT_UInt)( start_id + ( char_code - start ) );
1928	break;
1929	}
1930	}
1931	return result;
1932	}
1933
1934
1935	FT_CALLBACK_DEF( FT_UInt )
1936	tt_cmap8_char_next( FT_CMap cmap, / TT_CMap /
1937	FT_UInt32 *pchar_code )
1938	{
1939	TT_CMap ttcmap = (TT_CMap)cmap;
1940	FT_Face face = FT_CMAP_FACE( cmap );
1941	FT_UInt32 result = `0`;
1942	FT_UInt32 char_code;
1943	FT_UInt gindex = `0`;
1944	FT_Byte* table = ttcmap->data;
1945	FT_Byte* p = table + `8204`;
1946	FT_UInt32 num_groups = TT_NEXT_ULONG( p );
1947	FT_UInt32 start, end, start_id;
1948
1949
1950	if ( *pchar_code >= `0xFFFFFFFFUL` )
1951	return `0`;
1952
1953	char_code = *pchar_code + `1`;
1954
1955	p = table + `8208`;
1956
1957	for ( ; num_groups > `0`; num_groups-- )
1958	{
1959	start = TT_NEXT_ULONG( p );
1960	end = TT_NEXT_ULONG( p );
1961	start_id = TT_NEXT_ULONG( p );
1962
1963	if ( char_code < start )
1964	char_code = start;
1965
1966	Again:
1967	if ( char_code <= end )
1968	{
1969	/ ignore invalid group /
1970	if ( start_id > `0xFFFFFFFFUL` - ( char_code - start ) )
1971	continue;
1972
1973	gindex = (FT_UInt)( start_id + ( char_code - start ) );
1974
1975	/ does first element of group point to `.notdef' glyph? /
1976	if ( gindex == `0` )
1977	{
1978	if ( char_code >= `0xFFFFFFFFUL` )
1979	break;
1980
1981	char_code++;
1982	goto Again;
1983	}
1984
1985	/ if `gindex' is invalid, the remaining values /
1986	/ in this group are invalid, too /
1987	if ( gindex >= (FT_UInt)face->num_glyphs )
1988	{
1989	gindex = `0`;
1990	continue;
1991	}
1992
1993	result = char_code;
1994	break;
1995	}
1996	}
1997
1998	*pchar_code = result;
1999	return gindex;
2000	}
2001
2002
2003	FT_CALLBACK_DEF( FT_Error )
2004	tt_cmap8_get_info( FT_CharMap cmap, / TT_CMap /
2005	TT_CMapInfo *cmap_info )
2006	{
2007	TT_CMap ttcmap = (TT_CMap)cmap;
2008	FT_Byte* p = ttcmap->data + `8`;
2009
2010
2011	cmap_info->format = `8`;
2012	cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
2013
2014	return FT_Err_Ok;
2015	}
2016
2017
2018	FT_DEFINE_TT_CMAP(
2019	tt_cmap8_class_rec,
2020
2021	sizeof ( TT_CMapRec ),
2022
2023	(FT_CMap_InitFunc) tt_cmap_init, / init /
2024	(FT_CMap_DoneFunc) NULL, / done /
2025	(FT_CMap_CharIndexFunc)tt_cmap8_char_index, / char_index /
2026	(FT_CMap_CharNextFunc) tt_cmap8_char_next, / char_next /
2027
2028	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
2029	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
2030	(FT_CMap_VariantListFunc) NULL, / variant_list /
2031	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
2032	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
2033
2034	`8`,
2035	(TT_CMap_ValidateFunc)tt_cmap8_validate, / validate /
2036	(TT_CMap_Info_GetFunc)tt_cmap8_get_info / get_cmap_info /
2037	)
2038
2039	#endif /* TT_CONFIG_CMAP_FORMAT_8 */
2040
2041
2042	/***********************************************************************/
2043	/***********************************************************************/
2044	/** **/
2045	/** FORMAT 10 **/
2046	/** **/
2047	/***********************************************************************/
2048	/***********************************************************************/
2049
2050	/**************************************************************************
2051	*
2052	* TABLE OVERVIEW
2053	* --------------
2054	*
2055	* NAME OFFSET TYPE DESCRIPTION
2056	*
2057	* format 0 USHORT must be 10
2058	* reserved 2 USHORT reserved
2059	* length 4 ULONG length in bytes
2060	* language 8 ULONG Mac language code
2061	*
2062	* start 12 ULONG first char in range
2063	* count 16 ULONG number of chars in range
2064	* glyphIds 20 USHORT[count] glyph indices covered
2065	*/
2066
2067	#ifdef TT_CONFIG_CMAP_FORMAT_10
2068
2069	FT_CALLBACK_DEF( FT_Error )
2070	tt_cmap10_validate( FT_Byte* table,
2071	FT_Validator valid )
2072	{
2073	FT_Byte* p = table + `4`;
2074	FT_ULong length, count;
2075
2076
2077	if ( table + `20` > valid->limit )
2078	FT_INVALID_TOO_SHORT;
2079
2080	length = TT_NEXT_ULONG( p );
2081	p = table + `16`;
2082	count = TT_NEXT_ULONG( p );
2083
2084	if ( length > (FT_ULong)( valid->limit - table ) \|\|
2085	/ length < 20 + count * 2 ? /
2086	length < `20` \|\|
2087	( length - `20` ) / `2` < count )
2088	FT_INVALID_TOO_SHORT;
2089
2090	/ check glyph indices /
2091	if ( valid->level >= FT_VALIDATE_TIGHT )
2092	{
2093	FT_UInt gindex;
2094
2095
2096	for ( ; count > `0`; count-- )
2097	{
2098	gindex = TT_NEXT_USHORT( p );
2099	if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
2100	FT_INVALID_GLYPH_ID;
2101	}
2102	}
2103
2104	return FT_Err_Ok;
2105	}
2106
2107
2108	FT_CALLBACK_DEF( FT_UInt )
2109	tt_cmap10_char_index( FT_CMap cmap, / TT_CMap /
2110	FT_UInt32 char_code )
2111	{
2112	TT_CMap ttcmap = (TT_CMap)cmap;
2113	FT_Byte* table = ttcmap->data;
2114	FT_UInt result = `0`;
2115	FT_Byte* p = table + `12`;
2116	FT_UInt32 start = TT_NEXT_ULONG( p );
2117	FT_UInt32 count = TT_NEXT_ULONG( p );
2118	FT_UInt32 idx;
2119
2120
2121	if ( char_code < start )
2122	return `0`;
2123
2124	idx = char_code - start;
2125
2126	if ( idx < count )
2127	{
2128	p += `2` * idx;
2129	result = TT_PEEK_USHORT( p );
2130	}
2131
2132	return result;
2133	}
2134
2135
2136	FT_CALLBACK_DEF( FT_UInt )
2137	tt_cmap10_char_next( FT_CMap cmap, / TT_CMap /
2138	FT_UInt32 *pchar_code )
2139	{
2140	TT_CMap ttcmap = (TT_CMap)cmap;
2141	FT_Byte* table = ttcmap->data;
2142	FT_UInt32 char_code;
2143	FT_UInt gindex = `0`;
2144	FT_Byte* p = table + `12`;
2145	FT_UInt32 start = TT_NEXT_ULONG( p );
2146	FT_UInt32 count = TT_NEXT_ULONG( p );
2147	FT_UInt32 idx;
2148
2149
2150	if ( *pchar_code >= `0xFFFFFFFFUL` )
2151	return `0`;
2152
2153	char_code = *pchar_code + `1`;
2154
2155	if ( char_code < start )
2156	char_code = start;
2157
2158	idx = char_code - start;
2159	p += `2` * idx;
2160
2161	for ( ; idx < count; idx++ )
2162	{
2163	gindex = TT_NEXT_USHORT( p );
2164	if ( gindex != `0` )
2165	break;
2166
2167	if ( char_code >= `0xFFFFFFFFUL` )
2168	return `0`;
2169
2170	char_code++;
2171	}
2172
2173	*pchar_code = char_code;
2174	return gindex;
2175	}
2176
2177
2178	FT_CALLBACK_DEF( FT_Error )
2179	tt_cmap10_get_info( FT_CharMap cmap, / TT_CMap /
2180	TT_CMapInfo *cmap_info )
2181	{
2182	TT_CMap ttcmap = (TT_CMap)cmap;
2183	FT_Byte* p = ttcmap->data + `8`;
2184
2185
2186	cmap_info->format = `10`;
2187	cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
2188
2189	return FT_Err_Ok;
2190	}
2191
2192
2193	FT_DEFINE_TT_CMAP(
2194	tt_cmap10_class_rec,
2195
2196	sizeof ( TT_CMapRec ),
2197
2198	(FT_CMap_InitFunc) tt_cmap_init, / init /
2199	(FT_CMap_DoneFunc) NULL, / done /
2200	(FT_CMap_CharIndexFunc)tt_cmap10_char_index, / char_index /
2201	(FT_CMap_CharNextFunc) tt_cmap10_char_next, / char_next /
2202
2203	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
2204	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
2205	(FT_CMap_VariantListFunc) NULL, / variant_list /
2206	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
2207	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
2208
2209	`10`,
2210	(TT_CMap_ValidateFunc)tt_cmap10_validate, / validate /
2211	(TT_CMap_Info_GetFunc)tt_cmap10_get_info / get_cmap_info /
2212	)
2213
2214	#endif /* TT_CONFIG_CMAP_FORMAT_10 */
2215
2216
2217	/***********************************************************************/
2218	/***********************************************************************/
2219	/** **/
2220	/** FORMAT 12 **/
2221	/** **/
2222	/***********************************************************************/
2223	/***********************************************************************/
2224
2225	/**************************************************************************
2226	*
2227	* TABLE OVERVIEW
2228	* --------------
2229	*
2230	* NAME OFFSET TYPE DESCRIPTION
2231	*
2232	* format 0 USHORT must be 12
2233	* reserved 2 USHORT reserved
2234	* length 4 ULONG length in bytes
2235	* language 8 ULONG Mac language code
2236	* count 12 ULONG number of groups
2237	* 16
2238	*
2239	* This header is followed by `count' groups of the following format:
2240	*
2241	* start 0 ULONG first charcode
2242	* end 4 ULONG last charcode
2243	* startId 8 ULONG start glyph ID for the group
2244	*/
2245
2246	#ifdef TT_CONFIG_CMAP_FORMAT_12
2247
2248	typedef struct TT_CMap12Rec_
2249	{
2250	TT_CMapRec cmap;
2251	FT_Bool valid;
2252	FT_ULong cur_charcode;
2253	FT_UInt cur_gindex;
2254	FT_ULong cur_group;
2255	FT_ULong num_groups;
2256
2257	} TT_CMap12Rec, *TT_CMap12;
2258
2259
2260	FT_CALLBACK_DEF( FT_Error )
2261	tt_cmap12_init( FT_CMap cmap, / TT_CMap12 /
2262	void* table_ )
2263	{
2264	TT_CMap12 ttcmap = (TT_CMap12)cmap;
2265	FT_Byte* table = (FT_Byte*)table_;
2266
2267
2268	ttcmap->cmap.data = table;
2269
2270	table += `12`;
2271	ttcmap->num_groups = FT_PEEK_ULONG( table );
2272
2273	ttcmap->valid = `0`;
2274
2275	return FT_Err_Ok;
2276	}
2277
2278
2279	FT_CALLBACK_DEF( FT_Error )
2280	tt_cmap12_validate( FT_Byte* table,
2281	FT_Validator valid )
2282	{
2283	FT_Byte* p;
2284	FT_ULong length;
2285	FT_ULong num_groups;
2286
2287
2288	if ( table + `16` > valid->limit )
2289	FT_INVALID_TOO_SHORT;
2290
2291	p = table + `4`;
2292	length = TT_NEXT_ULONG( p );
2293
2294	p = table + `12`;
2295	num_groups = TT_NEXT_ULONG( p );
2296
2297	if ( length > (FT_ULong)( valid->limit - table ) \|\|
2298	/ length < 16 + 12 * num_groups ? /
2299	length < `16` \|\|
2300	( length - `16` ) / `12` < num_groups )
2301	FT_INVALID_TOO_SHORT;
2302
2303	/ check groups, they must be in increasing order /
2304	{
2305	FT_ULong n, start, end, start_id, last = `0`;
2306
2307
2308	for ( n = `0`; n < num_groups; n++ )
2309	{
2310	start = TT_NEXT_ULONG( p );
2311	end = TT_NEXT_ULONG( p );
2312	start_id = TT_NEXT_ULONG( p );
2313
2314	if ( start > end )
2315	FT_INVALID_DATA;
2316
2317	if ( n > `0` && start <= last )
2318	FT_INVALID_DATA;
2319
2320	if ( valid->level >= FT_VALIDATE_TIGHT )
2321	{
2322	FT_UInt32 d = end - start;
2323
2324
2325	/ start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) ? /
2326	if ( d > TT_VALID_GLYPH_COUNT( valid ) \|\|
2327	start_id >= TT_VALID_GLYPH_COUNT( valid ) - d )
2328	FT_INVALID_GLYPH_ID;
2329	}
2330
2331	last = end;
2332	}
2333	}
2334
2335	return FT_Err_Ok;
2336	}
2337
2338
2339	/ search the index of the charcode next to cmap->cur_charcode /
2340	/ cmap->cur_group should be set up properly by caller /
2341	/ /
2342	static void
2343	tt_cmap12_next( FT_CMap cmap ) / TT_CMap12 /
2344	{
2345	TT_CMap12 ttcmap = (TT_CMap12)cmap;
2346	FT_Face face = FT_CMAP_FACE( cmap );
2347	FT_Byte* p;
2348	FT_ULong start, end, start_id, char_code;
2349	FT_ULong n;
2350	FT_UInt gindex;
2351
2352
2353	char_code = ttcmap->cur_charcode + `1`;
2354
2355	for ( n = ttcmap->cur_group; n < ttcmap->num_groups; n++ )
2356	{
2357	p = ttcmap->cmap.data + `16` + `12` * n;
2358	start = TT_NEXT_ULONG( p );
2359	end = TT_NEXT_ULONG( p );
2360	start_id = TT_PEEK_ULONG( p );
2361
2362	if ( char_code < start )
2363	char_code = start;
2364
2365	Again:
2366	if ( char_code <= end )
2367	{
2368	/ ignore invalid group /
2369	if ( start_id > `0xFFFFFFFFUL` - ( char_code - start ) )
2370	continue;
2371
2372	gindex = (FT_UInt)( start_id + ( char_code - start ) );
2373
2374	/ does first element of group point to `.notdef' glyph? /
2375	if ( gindex == `0` )
2376	{
2377	if ( char_code >= `0xFFFFFFFFUL` )
2378	goto Fail;
2379
2380	char_code++;
2381	goto Again;
2382	}
2383
2384	/ if `gindex' is invalid, the remaining values /
2385	/ in this group are invalid, too /
2386	if ( gindex >= (FT_UInt)face->num_glyphs )
2387	continue;
2388
2389	ttcmap->cur_charcode = char_code;
2390	ttcmap->cur_gindex = gindex;
2391	ttcmap->cur_group = n;
2392
2393	return;
2394	}
2395	}
2396
2397	Fail:
2398	ttcmap->valid = `0`;
2399	}
2400
2401
2402	static FT_UInt
2403	tt_cmap12_char_map_binary( TT_CMap cmap,
2404	FT_UInt32* pchar_code,
2405	FT_Bool next )
2406	{
2407	FT_UInt gindex = `0`;
2408	FT_Byte* p = cmap->data + `12`;
2409	FT_UInt32 num_groups = TT_PEEK_ULONG( p );
2410	FT_UInt32 char_code = *pchar_code + next;
2411	FT_UInt32 start, end, start_id;
2412	FT_UInt32 max, min, mid;
2413
2414
2415	if ( !num_groups )
2416	return `0`;
2417
2418	min = `0`;
2419	max = num_groups;
2420
2421	/ binary search /
2422	do
2423	{
2424	mid = ( min + max ) >> `1`;
2425	p = cmap->data + `16` + `12` * mid;
2426
2427	start = TT_NEXT_ULONG( p );
2428	end = TT_NEXT_ULONG( p );
2429
2430	if ( char_code < start )
2431	max = mid;
2432	else if ( char_code > end )
2433	min = mid + `1`;
2434	else
2435	{
2436	start_id = TT_PEEK_ULONG( p );
2437
2438	/ reject invalid glyph index /
2439	if ( start_id > `0xFFFFFFFFUL` - ( char_code - start ) )
2440	gindex = `0`;
2441	else
2442	gindex = (FT_UInt)( start_id + ( char_code - start ) );
2443	break;
2444	}
2445	}
2446	while ( min < max );
2447
2448	if ( next )
2449	{
2450	FT_Face face = FT_CMAP_FACE( cmap );
2451	TT_CMap12 cmap12 = (TT_CMap12)cmap;
2452
2453
2454	/ if `char_code' is not in any group, then `mid' is /
2455	/ the group nearest to `char_code' /
2456
2457	if ( char_code > end && ++mid == num_groups )
2458	return `0`;
2459
2460	cmap12->valid = `1`;
2461	cmap12->cur_charcode = char_code;
2462	cmap12->cur_group = mid;
2463
2464	if ( gindex >= (FT_UInt)face->num_glyphs )
2465	gindex = `0`;
2466
2467	if ( !gindex )
2468	{
2469	tt_cmap12_next( FT_CMAP( cmap12 ) );
2470
2471	if ( cmap12->valid )
2472	gindex = cmap12->cur_gindex;
2473	}
2474	else
2475	cmap12->cur_gindex = gindex;
2476
2477	*pchar_code = cmap12->cur_charcode;
2478	}
2479
2480	return gindex;
2481	}
2482
2483
2484	FT_CALLBACK_DEF( FT_UInt )
2485	tt_cmap12_char_index( FT_CMap cmap, / TT_CMap /
2486	FT_UInt32 char_code )
2487	{
2488	return tt_cmap12_char_map_binary( (TT_CMap)cmap, &char_code, `0` );
2489	}
2490
2491
2492	FT_CALLBACK_DEF( FT_UInt )
2493	tt_cmap12_char_next( FT_CMap cmap, / TT_CMap12 /
2494	FT_UInt32 *pchar_code )
2495	{
2496	TT_CMap12 cmap12 = (TT_CMap12)cmap;
2497	FT_UInt gindex;
2498
2499
2500	if ( *pchar_code >= `0xFFFFFFFFUL` )
2501	return `0`;
2502
2503	/ no need to search /
2504	if ( cmap12->valid && cmap12->cur_charcode == *pchar_code )
2505	{
2506	tt_cmap12_next( FT_CMAP( cmap12 ) );
2507	if ( cmap12->valid )
2508	{
2509	gindex = cmap12->cur_gindex;
2510	*pchar_code = (FT_UInt32)cmap12->cur_charcode;
2511	}
2512	else
2513	gindex = `0`;
2514	}
2515	else
2516	gindex = tt_cmap12_char_map_binary( (TT_CMap)cmap, pchar_code, `1` );
2517
2518	return gindex;
2519	}
2520
2521
2522	FT_CALLBACK_DEF( FT_Error )
2523	tt_cmap12_get_info( FT_CharMap cmap, / TT_CMap /
2524	TT_CMapInfo *cmap_info )
2525	{
2526	TT_CMap ttcmap = (TT_CMap)cmap;
2527	FT_Byte* p = ttcmap->data + `8`;
2528
2529
2530	cmap_info->format = `12`;
2531	cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
2532
2533	return FT_Err_Ok;
2534	}
2535
2536
2537	FT_DEFINE_TT_CMAP(
2538	tt_cmap12_class_rec,
2539
2540	sizeof ( TT_CMap12Rec ),
2541
2542	(FT_CMap_InitFunc) tt_cmap12_init, / init /
2543	(FT_CMap_DoneFunc) NULL, / done /
2544	(FT_CMap_CharIndexFunc)tt_cmap12_char_index, / char_index /
2545	(FT_CMap_CharNextFunc) tt_cmap12_char_next, / char_next /
2546
2547	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
2548	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
2549	(FT_CMap_VariantListFunc) NULL, / variant_list /
2550	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
2551	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
2552
2553	`12`,
2554	(TT_CMap_ValidateFunc)tt_cmap12_validate, / validate /
2555	(TT_CMap_Info_GetFunc)tt_cmap12_get_info / get_cmap_info /
2556	)
2557
2558	#endif /* TT_CONFIG_CMAP_FORMAT_12 */
2559
2560
2561	/***********************************************************************/
2562	/***********************************************************************/
2563	/** **/
2564	/** FORMAT 13 **/
2565	/** **/
2566	/***********************************************************************/
2567	/***********************************************************************/
2568
2569	/**************************************************************************
2570	*
2571	* TABLE OVERVIEW
2572	* --------------
2573	*
2574	* NAME OFFSET TYPE DESCRIPTION
2575	*
2576	* format 0 USHORT must be 13
2577	* reserved 2 USHORT reserved
2578	* length 4 ULONG length in bytes
2579	* language 8 ULONG Mac language code
2580	* count 12 ULONG number of groups
2581	* 16
2582	*
2583	* This header is followed by `count' groups of the following format:
2584	*
2585	* start 0 ULONG first charcode
2586	* end 4 ULONG last charcode
2587	* glyphId 8 ULONG glyph ID for the whole group
2588	*/
2589
2590	#ifdef TT_CONFIG_CMAP_FORMAT_13
2591
2592	typedef struct TT_CMap13Rec_
2593	{
2594	TT_CMapRec cmap;
2595	FT_Bool valid;
2596	FT_ULong cur_charcode;
2597	FT_UInt cur_gindex;
2598	FT_ULong cur_group;
2599	FT_ULong num_groups;
2600
2601	} TT_CMap13Rec, *TT_CMap13;
2602
2603
2604	FT_CALLBACK_DEF( FT_Error )
2605	tt_cmap13_init( FT_CMap cmap, / TT_CMap13 /
2606	void* table_ )
2607	{
2608	TT_CMap13 ttcmap = (TT_CMap13)cmap;
2609	FT_Byte* table = (FT_Byte*)table_;
2610
2611
2612	ttcmap->cmap.data = table;
2613
2614	table += `12`;
2615	ttcmap->num_groups = FT_PEEK_ULONG( table );
2616
2617	ttcmap->valid = `0`;
2618
2619	return FT_Err_Ok;
2620	}
2621
2622
2623	FT_CALLBACK_DEF( FT_Error )
2624	tt_cmap13_validate( FT_Byte* table,
2625	FT_Validator valid )
2626	{
2627	FT_Byte* p;
2628	FT_ULong length;
2629	FT_ULong num_groups;
2630
2631
2632	if ( table + `16` > valid->limit )
2633	FT_INVALID_TOO_SHORT;
2634
2635	p = table + `4`;
2636	length = TT_NEXT_ULONG( p );
2637
2638	p = table + `12`;
2639	num_groups = TT_NEXT_ULONG( p );
2640
2641	if ( length > (FT_ULong)( valid->limit - table ) \|\|
2642	/ length < 16 + 12 * num_groups ? /
2643	length < `16` \|\|
2644	( length - `16` ) / `12` < num_groups )
2645	FT_INVALID_TOO_SHORT;
2646
2647	/ check groups, they must be in increasing order /
2648	{
2649	FT_ULong n, start, end, glyph_id, last = `0`;
2650
2651
2652	for ( n = `0`; n < num_groups; n++ )
2653	{
2654	start = TT_NEXT_ULONG( p );
2655	end = TT_NEXT_ULONG( p );
2656	glyph_id = TT_NEXT_ULONG( p );
2657
2658	if ( start > end )
2659	FT_INVALID_DATA;
2660
2661	if ( n > `0` && start <= last )
2662	FT_INVALID_DATA;
2663
2664	if ( valid->level >= FT_VALIDATE_TIGHT )
2665	{
2666	if ( glyph_id >= TT_VALID_GLYPH_COUNT( valid ) )
2667	FT_INVALID_GLYPH_ID;
2668	}
2669
2670	last = end;
2671	}
2672	}
2673
2674	return FT_Err_Ok;
2675	}
2676
2677
2678	/ search the index of the charcode next to cmap->cur_charcode /
2679	/ cmap->cur_group should be set up properly by caller /
2680	/ /
2681	static void
2682	tt_cmap13_next( FT_CMap cmap ) / TT_CMap13 /
2683	{
2684	TT_CMap13 ttcmap = (TT_CMap13)cmap;
2685	FT_Face face = FT_CMAP_FACE( cmap );
2686	FT_Byte* p;
2687	FT_ULong start, end, glyph_id, char_code;
2688	FT_ULong n;
2689	FT_UInt gindex;
2690
2691
2692	char_code = ttcmap->cur_charcode + `1`;
2693
2694	for ( n = ttcmap->cur_group; n < ttcmap->num_groups; n++ )
2695	{
2696	p = ttcmap->cmap.data + `16` + `12` * n;
2697	start = TT_NEXT_ULONG( p );
2698	end = TT_NEXT_ULONG( p );
2699	glyph_id = TT_PEEK_ULONG( p );
2700
2701	if ( char_code < start )
2702	char_code = start;
2703
2704	if ( char_code <= end )
2705	{
2706	gindex = (FT_UInt)glyph_id;
2707
2708	if ( gindex && gindex < (FT_UInt)face->num_glyphs )
2709	{
2710	ttcmap->cur_charcode = char_code;
2711	ttcmap->cur_gindex = gindex;
2712	ttcmap->cur_group = n;
2713
2714	return;
2715	}
2716	}
2717	}
2718
2719	ttcmap->valid = `0`;
2720	}
2721
2722
2723	static FT_UInt
2724	tt_cmap13_char_map_binary( TT_CMap cmap,
2725	FT_UInt32* pchar_code,
2726	FT_Bool next )
2727	{
2728	FT_UInt gindex = `0`;
2729	FT_Byte* p = cmap->data + `12`;
2730	FT_UInt32 num_groups = TT_PEEK_ULONG( p );
2731	FT_UInt32 char_code = *pchar_code + next;
2732	FT_UInt32 start, end;
2733	FT_UInt32 max, min, mid;
2734
2735
2736	if ( !num_groups )
2737	return `0`;
2738
2739	min = `0`;
2740	max = num_groups;
2741
2742	/ binary search /
2743	do
2744	{
2745	mid = ( min + max ) >> `1`;
2746	p = cmap->data + `16` + `12` * mid;
2747
2748	start = TT_NEXT_ULONG( p );
2749	end = TT_NEXT_ULONG( p );
2750
2751	if ( char_code < start )
2752	max = mid;
2753	else if ( char_code > end )
2754	min = mid + `1`;
2755	else
2756	{
2757	gindex = (FT_UInt)TT_PEEK_ULONG( p );
2758
2759	break;
2760	}
2761	}
2762	while ( min < max );
2763
2764	if ( next )
2765	{
2766	FT_Face face = cmap->cmap.charmap.face;
2767	TT_CMap13 cmap13 = (TT_CMap13)cmap;
2768
2769
2770	/ if `char_code' is not in any group, then `mid' is /
2771	/ the group nearest to `char_code' /
2772
2773	if ( char_code > end && ++mid == num_groups )
2774	return `0`;
2775
2776	cmap13->valid = `1`;
2777	cmap13->cur_charcode = char_code;
2778	cmap13->cur_group = mid;
2779
2780	if ( gindex >= (FT_UInt)face->num_glyphs )
2781	gindex = `0`;
2782
2783	if ( !gindex )
2784	{
2785	tt_cmap13_next( FT_CMAP( cmap13 ) );
2786
2787	if ( cmap13->valid )
2788	gindex = cmap13->cur_gindex;
2789	}
2790	else
2791	cmap13->cur_gindex = gindex;
2792
2793	*pchar_code = cmap13->cur_charcode;
2794	}
2795
2796	return gindex;
2797	}
2798
2799
2800	FT_CALLBACK_DEF( FT_UInt )
2801	tt_cmap13_char_index( FT_CMap cmap, / TT_CMap /
2802	FT_UInt32 char_code )
2803	{
2804	return tt_cmap13_char_map_binary( (TT_CMap)cmap, &char_code, `0` );
2805	}
2806
2807
2808	FT_CALLBACK_DEF( FT_UInt )
2809	tt_cmap13_char_next( FT_CMap cmap, / TT_CMap13 /
2810	FT_UInt32 *pchar_code )
2811	{
2812	TT_CMap13 cmap13 = (TT_CMap13)cmap;
2813	FT_UInt gindex;
2814
2815
2816	if ( *pchar_code >= `0xFFFFFFFFUL` )
2817	return `0`;
2818
2819	/ no need to search /
2820	if ( cmap13->valid && cmap13->cur_charcode == *pchar_code )
2821	{
2822	tt_cmap13_next( FT_CMAP( cmap13 ) );
2823	if ( cmap13->valid )
2824	{
2825	gindex = cmap13->cur_gindex;
2826	*pchar_code = cmap13->cur_charcode;
2827	}
2828	else
2829	gindex = `0`;
2830	}
2831	else
2832	gindex = tt_cmap13_char_map_binary( (TT_CMap)cmap, pchar_code, `1` );
2833
2834	return gindex;
2835	}
2836
2837
2838	FT_CALLBACK_DEF( FT_Error )
2839	tt_cmap13_get_info( FT_CharMap cmap, / TT_CMap /
2840	TT_CMapInfo *cmap_info )
2841	{
2842	TT_CMap ttcmap = (TT_CMap)cmap;
2843	FT_Byte* p = ttcmap->data + `8`;
2844
2845
2846	cmap_info->format = `13`;
2847	cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
2848
2849	return FT_Err_Ok;
2850	}
2851
2852
2853	FT_DEFINE_TT_CMAP(
2854	tt_cmap13_class_rec,
2855
2856	sizeof ( TT_CMap13Rec ),
2857
2858	(FT_CMap_InitFunc) tt_cmap13_init, / init /
2859	(FT_CMap_DoneFunc) NULL, / done /
2860	(FT_CMap_CharIndexFunc)tt_cmap13_char_index, / char_index /
2861	(FT_CMap_CharNextFunc) tt_cmap13_char_next, / char_next /
2862
2863	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
2864	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
2865	(FT_CMap_VariantListFunc) NULL, / variant_list /
2866	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
2867	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
2868
2869	`13`,
2870	(TT_CMap_ValidateFunc)tt_cmap13_validate, / validate /
2871	(TT_CMap_Info_GetFunc)tt_cmap13_get_info / get_cmap_info /
2872	)
2873
2874	#endif /* TT_CONFIG_CMAP_FORMAT_13 */
2875
2876
2877	/***********************************************************************/
2878	/***********************************************************************/
2879	/** **/
2880	/** FORMAT 14 **/
2881	/** **/
2882	/***********************************************************************/
2883	/***********************************************************************/
2884
2885	/**************************************************************************
2886	*
2887	* TABLE OVERVIEW
2888	* --------------
2889	*
2890	* NAME OFFSET TYPE DESCRIPTION
2891	*
2892	* format 0 USHORT must be 14
2893	* length 2 ULONG table length in bytes
2894	* numSelector 6 ULONG number of variation sel. records
2895	*
2896	* Followed by numSelector records, each of which looks like
2897	*
2898	* varSelector 0 UINT24 Unicode codepoint of sel.
2899	* defaultOff 3 ULONG offset to a default UVS table
2900	* describing any variants to be found in
2901	* the normal Unicode subtable.
2902	* nonDefOff 7 ULONG offset to a non-default UVS table
2903	* describing any variants not in the
2904	* standard cmap, with GIDs here
2905	* (either offset may be 0 NULL)
2906	*
2907	* Selectors are sorted by code point.
2908	*
2909	* A default Unicode Variation Selector (UVS) subtable is just a list of
2910	* ranges of code points which are to be found in the standard cmap. No
2911	* glyph IDs (GIDs) here.
2912	*
2913	* numRanges 0 ULONG number of ranges following
2914	*
2915	* A range looks like
2916	*
2917	* uniStart 0 UINT24 code point of the first character in
2918	* this range
2919	* additionalCnt 3 UBYTE count of additional characters in this
2920	* range (zero means a range of a single
2921	* character)
2922	*
2923	* Ranges are sorted by `uniStart'.
2924	*
2925	* A non-default Unicode Variation Selector (UVS) subtable is a list of
2926	* mappings from codepoint to GID.
2927	*
2928	* numMappings 0 ULONG number of mappings
2929	*
2930	* A range looks like
2931	*
2932	* uniStart 0 UINT24 code point of the first character in
2933	* this range
2934	* GID 3 USHORT and its GID
2935	*
2936	* Ranges are sorted by `uniStart'.
2937	*/
2938
2939	#ifdef TT_CONFIG_CMAP_FORMAT_14
2940
2941	typedef struct TT_CMap14Rec_
2942	{
2943	TT_CMapRec cmap;
2944	FT_ULong num_selectors;
2945
2946	/ This array is used to store the results of various*
2947	* cmap 14 query functions. The data is overwritten
2948	* on each call to these functions.
2949	*/
2950	FT_UInt32 max_results;
2951	FT_UInt32* results;
2952	FT_Memory memory;
2953
2954	} TT_CMap14Rec, *TT_CMap14;
2955
2956
2957	FT_CALLBACK_DEF( void )
2958	tt_cmap14_done( FT_CMap cmap ) / TT_CMap14 /
2959	{
2960	TT_CMap14 ttcmap = (TT_CMap14)cmap;
2961	FT_Memory memory = ttcmap->memory;
2962
2963
2964	ttcmap->max_results = `0`;
2965	if ( memory && ttcmap->results )
2966	FT_FREE( ttcmap->results );
2967	}
2968
2969
2970	static FT_Error
2971	tt_cmap14_ensure( TT_CMap14 cmap,
2972	FT_UInt32 num_results,
2973	FT_Memory memory )
2974	{
2975	FT_UInt32 old_max = cmap->max_results;
2976	FT_Error error = FT_Err_Ok;
2977
2978
2979	if ( num_results > cmap->max_results )
2980	{
2981	cmap->memory = memory;
2982
2983	if ( FT_QRENEW_ARRAY( cmap->results, old_max, num_results ) )
2984	return error;
2985
2986	cmap->max_results = num_results;
2987	}
2988
2989	return error;
2990	}
2991
2992
2993	FT_CALLBACK_DEF( FT_Error )
2994	tt_cmap14_init( FT_CMap cmap, / TT_CMap14 /
2995	void* table_ )
2996	{
2997	TT_CMap14 ttcmap = (TT_CMap14)cmap;
2998	FT_Byte* table = (FT_Byte*)table_;
2999
3000
3001	ttcmap->cmap.data = table;
3002
3003	table += `6`;
3004	ttcmap->num_selectors = FT_PEEK_ULONG( table );
3005	ttcmap->max_results = `0`;
3006	ttcmap->results = NULL;
3007
3008	return FT_Err_Ok;
3009	}
3010
3011
3012	FT_CALLBACK_DEF( FT_Error )
3013	tt_cmap14_validate( FT_Byte* table,
3014	FT_Validator valid )
3015	{
3016	FT_Byte* p;
3017	FT_ULong length;
3018	FT_ULong num_selectors;
3019
3020
3021	if ( table + `2` + `4` + `4` > valid->limit )
3022	FT_INVALID_TOO_SHORT;
3023
3024	p = table + `2`;
3025	length = TT_NEXT_ULONG( p );
3026	num_selectors = TT_NEXT_ULONG( p );
3027
3028	if ( length > (FT_ULong)( valid->limit - table ) \|\|
3029	/ length < 10 + 11 * num_selectors ? /
3030	length < `10` \|\|
3031	( length - `10` ) / `11` < num_selectors )
3032	FT_INVALID_TOO_SHORT;
3033
3034	/ check selectors, they must be in increasing order /
3035	{
3036	/ we start lastVarSel at 1 because a variant selector value of 0*
3037	* isn't valid.
3038	*/
3039	FT_ULong n, lastVarSel = `1`;
3040
3041
3042	for ( n = `0`; n < num_selectors; n++ )
3043	{
3044	FT_ULong varSel = TT_NEXT_UINT24( p );
3045	FT_ULong defOff = TT_NEXT_ULONG( p );
3046	FT_ULong nondefOff = TT_NEXT_ULONG( p );
3047
3048
3049	if ( defOff >= length \|\| nondefOff >= length )
3050	FT_INVALID_TOO_SHORT;
3051
3052	if ( varSel < lastVarSel )
3053	FT_INVALID_DATA;
3054
3055	lastVarSel = varSel + `1`;
3056
3057	/ check the default table (these glyphs should be reached /
3058	/ through the normal Unicode cmap, no GIDs, just check order) /
3059	if ( defOff != `0` )
3060	{
3061	FT_Byte* defp = table + defOff;
3062	FT_ULong numRanges;
3063	FT_ULong i;
3064	FT_ULong lastBase = `0`;
3065
3066
3067	if ( defp + `4` > valid->limit )
3068	FT_INVALID_TOO_SHORT;
3069
3070	numRanges = TT_NEXT_ULONG( defp );
3071
3072	/ defp + numRanges * 4 > valid->limit ? /
3073	if ( numRanges > (FT_ULong)( valid->limit - defp ) / `4` )
3074	FT_INVALID_TOO_SHORT;
3075
3076	for ( i = `0`; i < numRanges; i++ )
3077	{
3078	FT_ULong base = TT_NEXT_UINT24( defp );
3079	FT_ULong cnt = FT_NEXT_BYTE( defp );
3080
3081
3082	if ( base + cnt >= `0x110000UL` ) / end of Unicode /
3083	FT_INVALID_DATA;
3084
3085	if ( base < lastBase )
3086	FT_INVALID_DATA;
3087
3088	lastBase = base + cnt + `1U`;
3089	}
3090	}
3091
3092	/ and the non-default table (these glyphs are specified here) /
3093	if ( nondefOff != `0` )
3094	{
3095	FT_Byte* ndp = table + nondefOff;
3096	FT_ULong numMappings;
3097	FT_ULong i, lastUni = `0`;
3098
3099
3100	if ( ndp + `4` > valid->limit )
3101	FT_INVALID_TOO_SHORT;
3102
3103	numMappings = TT_NEXT_ULONG( ndp );
3104
3105	/ numMappings * 5 > (FT_ULong)( valid->limit - ndp ) ? /
3106	if ( numMappings > ( (FT_ULong)( valid->limit - ndp ) ) / `5` )
3107	FT_INVALID_TOO_SHORT;
3108
3109	for ( i = `0`; i < numMappings; i++ )
3110	{
3111	FT_ULong uni = TT_NEXT_UINT24( ndp );
3112	FT_ULong gid = TT_NEXT_USHORT( ndp );
3113
3114
3115	if ( uni >= `0x110000UL` ) / end of Unicode /
3116	FT_INVALID_DATA;
3117
3118	if ( uni < lastUni )
3119	FT_INVALID_DATA;
3120
3121	lastUni = uni + `1U`;
3122
3123	if ( valid->level >= FT_VALIDATE_TIGHT &&
3124	gid >= TT_VALID_GLYPH_COUNT( valid ) )
3125	FT_INVALID_GLYPH_ID;
3126	}
3127	}
3128	}
3129	}
3130
3131	return FT_Err_Ok;
3132	}
3133
3134
3135	FT_CALLBACK_DEF( FT_UInt )
3136	tt_cmap14_char_index( FT_CMap cmap,
3137	FT_UInt32 char_code )
3138	{
3139	FT_UNUSED( cmap );
3140	FT_UNUSED( char_code );
3141
3142	/ This can't happen /
3143	return `0`;
3144	}
3145
3146
3147	FT_CALLBACK_DEF( FT_UInt )
3148	tt_cmap14_char_next( FT_CMap cmap,
3149	FT_UInt32 *pchar_code )
3150	{
3151	FT_UNUSED( cmap );
3152
3153	/ This can't happen /
3154	*pchar_code = `0`;
3155	return `0`;
3156	}
3157
3158
3159	FT_CALLBACK_DEF( FT_Error )
3160	tt_cmap14_get_info( FT_CharMap cmap,
3161	TT_CMapInfo *cmap_info )
3162	{
3163	FT_UNUSED( cmap );
3164
3165	cmap_info->format = `14`;
3166	/ subtable 14 does not define a language field /
3167	cmap_info->language = `0xFFFFFFFFUL`;
3168
3169	return FT_Err_Ok;
3170	}
3171
3172
3173	static FT_UInt
3174	tt_cmap14_char_map_def_binary( FT_Byte *base,
3175	FT_UInt32 char_code )
3176	{
3177	FT_UInt32 numRanges = TT_PEEK_ULONG( base );
3178	FT_UInt32 max, min;
3179
3180
3181	min = `0`;
3182	max = numRanges;
3183
3184	base += `4`;
3185
3186	/ binary search /
3187	while ( min < max )
3188	{
3189	FT_UInt32 mid = ( min + max ) >> `1`;
3190	FT_Byte* p = base + `4` * mid;
3191	FT_ULong start = TT_NEXT_UINT24( p );
3192	FT_UInt cnt = FT_NEXT_BYTE( p );
3193
3194
3195	if ( char_code < start )
3196	max = mid;
3197	else if ( char_code > start + cnt )
3198	min = mid + `1`;
3199	else
3200	return TRUE;
3201	}
3202
3203	return FALSE;
3204	}
3205
3206
3207	static FT_UInt
3208	tt_cmap14_char_map_nondef_binary( FT_Byte *base,
3209	FT_UInt32 char_code )
3210	{
3211	FT_UInt32 numMappings = TT_PEEK_ULONG( base );
3212	FT_UInt32 max, min;
3213
3214
3215	min = `0`;
3216	max = numMappings;
3217
3218	base += `4`;
3219
3220	/ binary search /
3221	while ( min < max )
3222	{
3223	FT_UInt32 mid = ( min + max ) >> `1`;
3224	FT_Byte* p = base + `5` * mid;
3225	FT_UInt32 uni = (FT_UInt32)TT_NEXT_UINT24( p );
3226
3227
3228	if ( char_code < uni )
3229	max = mid;
3230	else if ( char_code > uni )
3231	min = mid + `1`;
3232	else
3233	return TT_PEEK_USHORT( p );
3234	}
3235
3236	return `0`;
3237	}
3238
3239
3240	static FT_Byte*
3241	tt_cmap14_find_variant( FT_Byte *base,
3242	FT_UInt32 variantCode )
3243	{
3244	FT_UInt32 numVar = TT_PEEK_ULONG( base );
3245	FT_UInt32 max, min;
3246
3247
3248	min = `0`;
3249	max = numVar;
3250
3251	base += `4`;
3252
3253	/ binary search /
3254	while ( min < max )
3255	{
3256	FT_UInt32 mid = ( min + max ) >> `1`;
3257	FT_Byte* p = base + `11` * mid;
3258	FT_ULong varSel = TT_NEXT_UINT24( p );
3259
3260
3261	if ( variantCode < varSel )
3262	max = mid;
3263	else if ( variantCode > varSel )
3264	min = mid + `1`;
3265	else
3266	return p;
3267	}
3268
3269	return NULL;
3270	}
3271
3272
3273	FT_CALLBACK_DEF( FT_UInt )
3274	tt_cmap14_char_var_index( FT_CMap cmap, / TT_CMap /
3275	FT_CMap ucmap, / TT_CMap /
3276	FT_UInt32 charcode,
3277	FT_UInt32 variantSelector )
3278	{
3279	TT_CMap ttcmap = (TT_CMap)cmap;
3280	TT_CMap ttucmap = (TT_CMap)ucmap;
3281
3282	FT_Byte* p = tt_cmap14_find_variant( ttcmap->data + `6`,
3283	variantSelector );
3284	FT_ULong defOff;
3285	FT_ULong nondefOff;
3286
3287
3288	if ( !p )
3289	return `0`;
3290
3291	defOff = TT_NEXT_ULONG( p );
3292	nondefOff = TT_PEEK_ULONG( p );
3293
3294	if ( defOff != `0` &&
3295	tt_cmap14_char_map_def_binary( ttcmap->data + defOff, charcode ) )
3296	{
3297	/ This is the default variant of this charcode. GID not stored /
3298	/ here; stored in the normal Unicode charmap instead. /
3299	return ttucmap->cmap.clazz->char_index( &ttucmap->cmap, charcode );
3300	}
3301
3302	if ( nondefOff != `0` )
3303	return tt_cmap14_char_map_nondef_binary( ttcmap->data + nondefOff,
3304	charcode );
3305
3306	return `0`;
3307	}
3308
3309
3310	FT_CALLBACK_DEF( FT_Int )
3311	tt_cmap14_char_var_isdefault( FT_CMap cmap, / TT_CMap /
3312	FT_UInt32 charcode,
3313	FT_UInt32 variantSelector )
3314	{
3315	TT_CMap ttcmap = (TT_CMap)cmap;
3316	FT_Byte* p = tt_cmap14_find_variant( ttcmap->data + `6`,
3317	variantSelector );
3318	FT_ULong defOff;
3319	FT_ULong nondefOff;
3320
3321
3322	if ( !p )
3323	return -`1`;
3324
3325	defOff = TT_NEXT_ULONG( p );
3326	nondefOff = TT_NEXT_ULONG( p );
3327
3328	if ( defOff != `0` &&
3329	tt_cmap14_char_map_def_binary( ttcmap->data + defOff, charcode ) )
3330	return `1`;
3331
3332	if ( nondefOff != `0` &&
3333	tt_cmap14_char_map_nondef_binary( ttcmap->data + nondefOff,
3334	charcode ) != `0` )
3335	return `0`;
3336
3337	return -`1`;
3338	}
3339
3340
3341	FT_CALLBACK_DEF( FT_UInt32* )
3342	tt_cmap14_variants( FT_CMap cmap, / TT_CMap14 /
3343	FT_Memory memory )
3344	{
3345	TT_CMap ttcmap = (TT_CMap)cmap;
3346	TT_CMap14 cmap14 = (TT_CMap14)cmap;
3347	FT_UInt32 count = cmap14->num_selectors;
3348	FT_Byte* p = ttcmap->data + `10`;
3349	FT_UInt32* result;
3350	FT_UInt32 i;
3351
3352
3353	if ( tt_cmap14_ensure( cmap14, ( count + `1` ), memory ) )
3354	return NULL;
3355
3356	result = cmap14->results;
3357	for ( i = `0`; i < count; i++ )
3358	{
3359	result[i] = (FT_UInt32)TT_NEXT_UINT24( p );
3360	p += `8`;
3361	}
3362	result[i] = `0`;
3363
3364	return result;
3365	}
3366
3367
3368	FT_CALLBACK_DEF( FT_UInt32 * )
3369	tt_cmap14_char_variants( FT_CMap cmap, / TT_CMap14 /
3370	FT_Memory memory,
3371	FT_UInt32 charCode )
3372	{
3373	TT_CMap ttcmap = (TT_CMap)cmap;
3374	TT_CMap14 cmap14 = (TT_CMap14)cmap;
3375	FT_UInt32 count = cmap14->num_selectors;
3376	FT_Byte* p = ttcmap->data + `10`;
3377	FT_UInt32* q;
3378
3379
3380	if ( tt_cmap14_ensure( cmap14, ( count + `1` ), memory ) )
3381	return NULL;
3382
3383	for ( q = cmap14->results; count > `0`; count-- )
3384	{
3385	FT_UInt32 varSel = TT_NEXT_UINT24( p );
3386	FT_ULong defOff = TT_NEXT_ULONG( p );
3387	FT_ULong nondefOff = TT_NEXT_ULONG( p );
3388
3389
3390	if ( ( defOff != `0` &&
3391	tt_cmap14_char_map_def_binary( ttcmap->data + defOff,
3392	charCode ) ) \|\|
3393	( nondefOff != `0` &&
3394	tt_cmap14_char_map_nondef_binary( ttcmap->data + nondefOff,
3395	charCode ) != `0` ) )
3396	{
3397	q[`0`] = varSel;
3398	q++;
3399	}
3400	}
3401	q[`0`] = `0`;
3402
3403	return cmap14->results;
3404	}
3405
3406
3407	static FT_UInt
3408	tt_cmap14_def_char_count( FT_Byte *p )
3409	{
3410	FT_UInt32 numRanges = (FT_UInt32)TT_NEXT_ULONG( p );
3411	FT_UInt tot = `0`;
3412
3413
3414	p += `3`; / point to the first `cnt' field /
3415	for ( ; numRanges > `0`; numRanges-- )
3416	{
3417	tot += `1` + p[`0`];
3418	p += `4`;
3419	}
3420
3421	return tot;
3422	}
3423
3424
3425	static FT_UInt32*
3426	tt_cmap14_get_def_chars( TT_CMap cmap,
3427	FT_Byte* p,
3428	FT_Memory memory )
3429	{
3430	TT_CMap14 cmap14 = (TT_CMap14) cmap;
3431	FT_UInt32 numRanges;
3432	FT_UInt cnt;
3433	FT_UInt32* q;
3434
3435
3436	cnt = tt_cmap14_def_char_count( p );
3437	numRanges = (FT_UInt32)TT_NEXT_ULONG( p );
3438
3439	if ( tt_cmap14_ensure( cmap14, ( cnt + `1` ), memory ) )
3440	return NULL;
3441
3442	for ( q = cmap14->results; numRanges > `0`; numRanges-- )
3443	{
3444	FT_UInt32 uni = (FT_UInt32)TT_NEXT_UINT24( p );
3445
3446
3447	cnt = FT_NEXT_BYTE( p ) + `1`;
3448	do
3449	{
3450	q[`0`] = uni;
3451	uni += `1`;
3452	q += `1`;
3453
3454	} while ( --cnt != `0` );
3455	}
3456	q[`0`] = `0`;
3457
3458	return cmap14->results;
3459	}
3460
3461
3462	static FT_UInt32*
3463	tt_cmap14_get_nondef_chars( TT_CMap cmap,
3464	FT_Byte *p,
3465	FT_Memory memory )
3466	{
3467	TT_CMap14 cmap14 = (TT_CMap14) cmap;
3468	FT_UInt32 numMappings;
3469	FT_UInt i;
3470	FT_UInt32 *ret;
3471
3472
3473	numMappings = (FT_UInt32)TT_NEXT_ULONG( p );
3474
3475	if ( tt_cmap14_ensure( cmap14, ( numMappings + `1` ), memory ) )
3476	return NULL;
3477
3478	ret = cmap14->results;
3479	for ( i = `0`; i < numMappings; i++ )
3480	{
3481	ret[i] = (FT_UInt32)TT_NEXT_UINT24( p );
3482	p += `2`;
3483	}
3484	ret[i] = `0`;
3485
3486	return ret;
3487	}
3488
3489
3490	FT_CALLBACK_DEF( FT_UInt32 * )
3491	tt_cmap14_variant_chars( FT_CMap cmap, / TT_CMap /
3492	FT_Memory memory,
3493	FT_UInt32 variantSelector )
3494	{
3495	TT_CMap ttcmap = (TT_CMap)cmap;
3496	FT_Byte *p = tt_cmap14_find_variant( ttcmap->data + `6`,
3497	variantSelector );
3498	FT_Int i;
3499	FT_ULong defOff;
3500	FT_ULong nondefOff;
3501
3502
3503	if ( !p )
3504	return NULL;
3505
3506	defOff = TT_NEXT_ULONG( p );
3507	nondefOff = TT_NEXT_ULONG( p );
3508
3509	if ( defOff == `0` && nondefOff == `0` )
3510	return NULL;
3511
3512	if ( defOff == `0` )
3513	return tt_cmap14_get_nondef_chars( ttcmap, ttcmap->data + nondefOff,
3514	memory );
3515	else if ( nondefOff == `0` )
3516	return tt_cmap14_get_def_chars( ttcmap, ttcmap->data + defOff,
3517	memory );
3518	else
3519	{
3520	/ Both a default and a non-default glyph set? That's probably not /
3521	/ good font design, but the spec allows for it... /
3522	TT_CMap14 cmap14 = (TT_CMap14)cmap;
3523	FT_UInt32 numRanges;
3524	FT_UInt32 numMappings;
3525	FT_UInt32 duni;
3526	FT_UInt32 dcnt;
3527	FT_UInt32 nuni;
3528	FT_Byte* dp;
3529	FT_UInt di, ni, k;
3530
3531	FT_UInt32 *ret;
3532
3533
3534	p = ttcmap->data + nondefOff;
3535	dp = ttcmap->data + defOff;
3536
3537	numMappings = (FT_UInt32)TT_NEXT_ULONG( p );
3538	dcnt = tt_cmap14_def_char_count( dp );
3539	numRanges = (FT_UInt32)TT_NEXT_ULONG( dp );
3540
3541	if ( numMappings == `0` )
3542	return tt_cmap14_get_def_chars( ttcmap, ttcmap->data + defOff,
3543	memory );
3544	if ( dcnt == `0` )
3545	return tt_cmap14_get_nondef_chars( ttcmap, ttcmap->data + nondefOff,
3546	memory );
3547
3548	if ( tt_cmap14_ensure( cmap14, ( dcnt + numMappings + `1` ), memory ) )
3549	return NULL;
3550
3551	ret = cmap14->results;
3552	duni = (FT_UInt32)TT_NEXT_UINT24( dp );
3553	dcnt = FT_NEXT_BYTE( dp );
3554	di = `1`;
3555	nuni = (FT_UInt32)TT_NEXT_UINT24( p );
3556	p += `2`;
3557	ni = `1`;
3558	i = `0`;
3559
3560	for (;;)
3561	{
3562	if ( nuni > duni + dcnt )
3563	{
3564	for ( k = `0`; k <= dcnt; k++ )
3565	ret[i++] = duni + k;
3566
3567	di++;
3568
3569	if ( di > numRanges )
3570	break;
3571
3572	duni = (FT_UInt32)TT_NEXT_UINT24( dp );
3573	dcnt = FT_NEXT_BYTE( dp );
3574	}
3575	else
3576	{
3577	if ( nuni < duni )
3578	ret[i++] = nuni;
3579	/ If it is within the default range then ignore it -- /
3580	/ that should not have happened /
3581	ni++;
3582	if ( ni > numMappings )
3583	break;
3584
3585	nuni = (FT_UInt32)TT_NEXT_UINT24( p );
3586	p += `2`;
3587	}
3588	}
3589
3590	if ( ni <= numMappings )
3591	{
3592	/ If we get here then we have run out of all default ranges. /
3593	/ We have read one non-default mapping which we haven't stored /
3594	/ and there may be others that need to be read. /
3595	ret[i++] = nuni;
3596	while ( ni < numMappings )
3597	{
3598	ret[i++] = (FT_UInt32)TT_NEXT_UINT24( p );
3599	p += `2`;
3600	ni++;
3601	}
3602	}
3603	else if ( di <= numRanges )
3604	{
3605	/ If we get here then we have run out of all non-default /
3606	/ mappings. We have read one default range which we haven't /
3607	/ stored and there may be others that need to be read. /
3608	for ( k = `0`; k <= dcnt; k++ )
3609	ret[i++] = duni + k;
3610
3611	while ( di < numRanges )
3612	{
3613	duni = (FT_UInt32)TT_NEXT_UINT24( dp );
3614	dcnt = FT_NEXT_BYTE( dp );
3615
3616	for ( k = `0`; k <= dcnt; k++ )
3617	ret[i++] = duni + k;
3618	di++;
3619	}
3620	}
3621
3622	ret[i] = `0`;
3623
3624	return ret;
3625	}
3626	}
3627
3628
3629	FT_DEFINE_TT_CMAP(
3630	tt_cmap14_class_rec,
3631
3632	sizeof ( TT_CMap14Rec ),
3633
3634	(FT_CMap_InitFunc) tt_cmap14_init, / init /
3635	(FT_CMap_DoneFunc) tt_cmap14_done, / done /
3636	(FT_CMap_CharIndexFunc)tt_cmap14_char_index, / char_index /
3637	(FT_CMap_CharNextFunc) tt_cmap14_char_next, / char_next /
3638
3639	/ Format 14 extension functions /
3640	(FT_CMap_CharVarIndexFunc) tt_cmap14_char_var_index,
3641	(FT_CMap_CharVarIsDefaultFunc)tt_cmap14_char_var_isdefault,
3642	(FT_CMap_VariantListFunc) tt_cmap14_variants,
3643	(FT_CMap_CharVariantListFunc) tt_cmap14_char_variants,
3644	(FT_CMap_VariantCharListFunc) tt_cmap14_variant_chars,
3645
3646	`14`,
3647	(TT_CMap_ValidateFunc)tt_cmap14_validate, / validate /
3648	(TT_CMap_Info_GetFunc)tt_cmap14_get_info / get_cmap_info /
3649	)
3650
3651	#endif /* TT_CONFIG_CMAP_FORMAT_14 */
3652
3653
3654	/***********************************************************************/
3655	/***********************************************************************/
3656	/** **/
3657	/** SYNTHETIC UNICODE **/
3658	/** **/
3659	/***********************************************************************/
3660	/***********************************************************************/
3661
3662	/ This charmap is generated using postscript glyph names. /
3663
3664	#ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
3665
3666	FT_CALLBACK_DEF( const char * )
3667	tt_get_glyph_name( void* face_, / TT_Face /
3668	FT_UInt idx )
3669	{
3670	TT_Face face = (TT_Face)face_;
3671	FT_String* PSname = NULL;
3672
3673
3674	tt_face_get_ps_name( face, idx, &PSname );
3675
3676	return PSname;
3677	}
3678
3679
3680	FT_CALLBACK_DEF( FT_Error )
3681	tt_cmap_unicode_init( FT_CMap cmap, / PS_Unicodes /
3682	FT_Pointer pointer )
3683	{
3684	PS_Unicodes unicodes = (PS_Unicodes)cmap;
3685	TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
3686	FT_Memory memory = FT_FACE_MEMORY( face );
3687	FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
3688
3689	FT_UNUSED( pointer );
3690
3691
3692	if ( !psnames->unicodes_init )
3693	return FT_THROW( Unimplemented_Feature );
3694
3695	return psnames->unicodes_init( memory,
3696	unicodes,
3697	face->root.num_glyphs,
3698	&tt_get_glyph_name,
3699	(PS_FreeGlyphNameFunc)NULL,
3700	(FT_Pointer)face );
3701	}
3702
3703
3704	FT_CALLBACK_DEF( void )
3705	tt_cmap_unicode_done( FT_CMap cmap ) / PS_Unicodes /
3706	{
3707	PS_Unicodes unicodes = (PS_Unicodes)cmap;
3708	FT_Face face = FT_CMAP_FACE( cmap );
3709	FT_Memory memory = FT_FACE_MEMORY( face );
3710
3711
3712	FT_FREE( unicodes->maps );
3713	unicodes->num_maps = `0`;
3714	}
3715
3716
3717	FT_CALLBACK_DEF( FT_UInt )
3718	tt_cmap_unicode_char_index( FT_CMap cmap, / PS_Unicodes /
3719	FT_UInt32 char_code )
3720	{
3721	PS_Unicodes unicodes = (PS_Unicodes)cmap;
3722	TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
3723	FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
3724
3725
3726	return psnames->unicodes_char_index( unicodes, char_code );
3727	}
3728
3729
3730	FT_CALLBACK_DEF( FT_UInt )
3731	tt_cmap_unicode_char_next( FT_CMap cmap, / PS_Unicodes /
3732	FT_UInt32 *pchar_code )
3733	{
3734	PS_Unicodes unicodes = (PS_Unicodes)cmap;
3735	TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
3736	FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
3737
3738
3739	return psnames->unicodes_char_next( unicodes, pchar_code );
3740	}
3741
3742
3743	FT_DEFINE_TT_CMAP(
3744	tt_cmap_unicode_class_rec,
3745
3746	sizeof ( PS_UnicodesRec ),
3747
3748	(FT_CMap_InitFunc) tt_cmap_unicode_init, / init /
3749	(FT_CMap_DoneFunc) tt_cmap_unicode_done, / done /
3750	(FT_CMap_CharIndexFunc)tt_cmap_unicode_char_index, / char_index /
3751	(FT_CMap_CharNextFunc) tt_cmap_unicode_char_next, / char_next /
3752
3753	(FT_CMap_CharVarIndexFunc) NULL, / char_var_index /
3754	(FT_CMap_CharVarIsDefaultFunc)NULL, / char_var_default /
3755	(FT_CMap_VariantListFunc) NULL, / variant_list /
3756	(FT_CMap_CharVariantListFunc) NULL, / charvariant_list /
3757	(FT_CMap_VariantCharListFunc) NULL, / variantchar_list /
3758
3759	~`0U`,
3760	(TT_CMap_ValidateFunc)NULL, / validate /
3761	(TT_CMap_Info_GetFunc)NULL / get_cmap_info /
3762	)
3763
3764	#endif /* FT_CONFIG_OPTION_POSTSCRIPT_NAMES */
3765
3766
3767	static const TT_CMap_Class tt_cmap_classes[] =
3768	{
3769	#undef TTCMAPCITEM
3770	#define TTCMAPCITEM( a ) &a,
3771	#include "ttcmapc.h"
3772	NULL,
3773	};
3774
3775
3776	/ parse the `cmap' table and build the corresponding TT_CMap objects /
3777	/ in the current face /
3778	/ /
3779	FT_LOCAL_DEF( FT_Error )
3780	tt_face_build_cmaps( TT_Face face )
3781	{
3782	FT_Byte* const table = face->cmap_table;
3783	FT_Byte* limit;
3784	FT_UInt volatile num_cmaps;
3785	FT_Byte* volatile p = table;
3786	FT_Library library = FT_FACE_LIBRARY( face );
3787
3788	FT_UNUSED( library );
3789
3790
3791	if ( !p \|\| face->cmap_size < `4` )
3792	return FT_THROW( Invalid_Table );
3793
3794	/ Version 1.8.3 of the OpenType specification contains the following /
3795	/ (https://docs.microsoft.com/en-us/typography/opentype/spec/cmap): /
3796	/ /
3797	/ The 'cmap' table version number remains at 0x0000 for fonts that /
3798	/ make use of the newer subtable formats. /
3799	/ /
3800	/ This essentially means that a version format test is useless. /
3801
3802	/ ignore format /
3803	p += `2`;
3804
3805	num_cmaps = TT_NEXT_USHORT( p );
3806	FT_TRACE4(( "tt_face_build_cmaps: %d cmaps\n", num_cmaps ));
3807
3808	limit = table + face->cmap_size;
3809	for ( ; num_cmaps > `0` && p + `8` <= limit; num_cmaps-- )
3810	{
3811	FT_CharMapRec charmap;
3812	FT_UInt32 offset;
3813
3814
3815	charmap.platform_id = TT_NEXT_USHORT( p );
3816	charmap.encoding_id = TT_NEXT_USHORT( p );
3817	charmap.face = FT_FACE( face );
3818	charmap.encoding = FT_ENCODING_NONE; / will be filled later /
3819	offset = TT_NEXT_ULONG( p );
3820
3821	if ( offset && offset <= face->cmap_size - `2` )
3822	{
3823	FT_Byte* volatile cmap = table + offset;
3824	volatile FT_UInt format = TT_PEEK_USHORT( cmap );
3825	const TT_CMap_Class* volatile pclazz = tt_cmap_classes;
3826	TT_CMap_Class volatile clazz;
3827
3828
3829	for ( ; *pclazz; pclazz++ )
3830	{
3831	clazz = *pclazz;
3832	if ( clazz->format == format )
3833	{
3834	volatile TT_ValidatorRec valid;
3835	volatile FT_Error error = FT_Err_Ok;
3836
3837
3838	ft_validator_init( FT_VALIDATOR( &valid ), cmap, limit,
3839	FT_VALIDATE_DEFAULT );
3840
3841	valid.num_glyphs = (FT_UInt)face->max_profile.numGlyphs;
3842
3843	if ( ft_setjmp( FT_VALIDATOR( &valid )->jump_buffer) == `0` )
3844	{
3845	/ validate this cmap sub-table /
3846	error = clazz->validate( cmap, FT_VALIDATOR( &valid ) );
3847	}
3848
3849	if ( !valid.validator.error )
3850	{
3851	FT_CMap ttcmap;
3852
3853
3854	/ It might make sense to store the single variation /
3855	/ selector cmap somewhere special. But it would have to be /
3856	/ in the public FT_FaceRec, and we can't change that. /
3857
3858	if ( !FT_CMap_New( (FT_CMap_Class)clazz,
3859	cmap, &charmap, &ttcmap ) )
3860	{
3861	/ it is simpler to directly set `flags' than adding /
3862	/ a parameter to FT_CMap_New /
3863	((TT_CMap)ttcmap)->flags = (FT_Int)error;
3864	}
3865	}
3866	else
3867	{
3868	FT_TRACE0(( "tt_face_build_cmaps:"
3869	" broken cmap sub-table ignored\n" ));
3870	}
3871	break;
3872	}
3873	}
3874
3875	if ( !*pclazz )
3876	{
3877	FT_TRACE0(( "tt_face_build_cmaps:"
3878	" unsupported cmap sub-table ignored\n" ));
3879	}
3880	}
3881	}
3882
3883	return FT_Err_Ok;
3884	}
3885
3886
3887	FT_LOCAL_DEF( FT_Error )
3888	tt_get_cmap_info( FT_CharMap charmap,
3889	TT_CMapInfo *cmap_info )
3890	{
3891	FT_CMap cmap = FT_CMAP( charmap );
3892	TT_CMap_Class clazz = (TT_CMap_Class)cmap->clazz;
3893
3894
3895	if ( clazz->get_cmap_info )
3896	return clazz->get_cmap_info( charmap, cmap_info );
3897	else
3898	return FT_THROW( Invalid_CharMap_Format );
3899	}
3900
3901
3902	/ END /
3903

Browse the source code of Godot/thirdparty/freetype/src/sfnt/ttcmap.c