?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bringing apdf from vendor into main branch.
[AROS-Contrib.git] / apdf / freetype2 / sfnt / ttcmap0.c
blob17bb776de9eb1fd76f1769cd81658543ad17abf6
1 /***************************************************************************/
2 /* */
3 /* ttcmap0.c */
4 /* */
5 /* TrueType new character mapping table (cmap) support (body). */
6 /* */
7 /* Copyright 2002 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 <ft2build.h>
20 #include FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_OBJECTS_H
22 #include FT_INTERNAL_STREAM_H
23 #include "ttload.h"
24 #include "ttcmap0.h"
25
26 #include "sferrors.h"
27
28 /*************************************************************************/
29 /* */
30 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
31 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
32 /* messages during execution. */
33 /* */
34 #undef FT_COMPONENT
35 #define FT_COMPONENT trace_ttcmap
36
37
38 #define TT_PEEK_SHORT FT_PEEK_SHORT
39 #define TT_PEEK_USHORT FT_PEEK_USHORT
40 #define TT_PEEK_LONG FT_PEEK_LONG
41 #define TT_PEEK_ULONG FT_PEEK_ULONG
42
43 #define TT_NEXT_SHORT FT_NEXT_SHORT
44 #define TT_NEXT_USHORT FT_NEXT_USHORT
45 #define TT_NEXT_LONG FT_NEXT_LONG
46 #define TT_NEXT_ULONG FT_NEXT_ULONG
47
48
49 FT_CALLBACK_DEF( FT_Error )
50 tt_cmap_init( TT_CMap cmap,
51 FT_Byte* table )
52 {
53 cmap->data = table;
54 return 0;
55 }
56
57
58 /*************************************************************************/
59 /*************************************************************************/
60 /***** *****/
61 /***** FORMAT 0 *****/
62 /***** *****/
63 /*************************************************************************/
64 /*************************************************************************/
65
66 /*************************************************************************/
67 /* */
68 /* TABLE OVERVIEW */
69 /* -------------- */
70 /* */
71 /* NAME OFFSET TYPE DESCRIPTION */
72 /* */
73 /* format 0 USHORT must be 0 */
74 /* length 2 USHORT table length in bytes */
75 /* language 4 USHORT Mac language code */
76 /* glyph_ids 6 BYTE[256] array of glyph indices */
77 /* 262 */
78 /* */
79
80 #ifdef TT_CONFIG_CMAP_FORMAT_0
81
82 FT_CALLBACK_DEF( void )
83 tt_cmap0_validate( FT_Byte* table,
84 FT_Validator valid )
85 {
86 FT_Byte* p = table + 2;
87 FT_UInt length = TT_NEXT_USHORT( p );
88
89
90 if ( table + length > valid->limit || length < 262 )
91 FT_INVALID_TOO_SHORT;
92
93 /* check glyph indices whenever necessary */
94 if ( valid->level >= FT_VALIDATE_TIGHT )
95 {
96 FT_UInt n, idx;
97
98
99 p = table + 6;
100 for ( n = 0; n < 256; n++ )
101 {
102 idx = *p++;
103 if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
104 FT_INVALID_GLYPH_ID;
105 }
106 }
107 }
108
109
110 FT_CALLBACK_DEF( FT_UInt )
111 tt_cmap0_char_index( TT_CMap cmap,
112 FT_UInt32 char_code )
113 {
114 FT_Byte* table = cmap->data;
115
116
117 return char_code < 256 ? table[6 + char_code] : 0;
118 }
119
120
121 FT_CALLBACK_DEF( FT_UInt )
122 tt_cmap0_char_next( TT_CMap cmap,
123 FT_UInt32 *pchar_code )
124 {
125 FT_Byte* table = cmap->data;
126 FT_UInt32 charcode = *pchar_code;
127 FT_UInt32 result = 0;
128 FT_UInt gindex = 0;
129
130
131 table += 6; /* go to glyph ids */
132 while ( ++charcode < 256 )
133 {
134 gindex = table[charcode];
135 if ( gindex != 0 )
136 {
137 result = charcode;
138 break;
139 }
140 }
141
142 *pchar_code = result;
143 return gindex;
144 }
145
146
147 FT_CALLBACK_TABLE_DEF
148 const TT_CMap_ClassRec tt_cmap0_class_rec =
149 {
150 {
151 sizeof( TT_CMapRec ),
152
153 (FT_CMap_InitFunc) tt_cmap_init,
154 (FT_CMap_DoneFunc) NULL,
155 (FT_CMap_CharIndexFunc)tt_cmap0_char_index,
156 (FT_CMap_CharNextFunc) tt_cmap0_char_next
157 },
158 0,
159 (TT_CMap_ValidateFunc) tt_cmap0_validate
160 };
161
162 #endif /* TT_CONFIG_CMAP_FORMAT_0 */
163
164
165 /*************************************************************************/
166 /*************************************************************************/
167 /***** *****/
168 /***** FORMAT 2 *****/
169 /***** *****/
170 /***** This is used for certain CJK encodings that encode text in a *****/
171 /***** mixed 8/16 bits encoding along the following lines: *****/
172 /***** *****/
173 /***** * Certain byte values correspond to an 8-bit character code *****/
174 /***** (typically in the range 0..127 for ASCII compatibility). *****/
175 /***** *****/
176 /***** * Certain byte values signal the first byte of a 2-byte *****/
177 /***** character code (but these values are also valid as the *****/
178 /***** second byte of a 2-byte character). *****/
179 /***** *****/
180 /***** The following charmap lookup and iteration functions all *****/
181 /***** assume that the value "charcode" correspond to following: *****/
182 /***** *****/
183 /***** - For one byte characters, "charcode" is simply the *****/
184 /***** character code. *****/
185 /***** *****/
186 /***** - For two byte characters, "charcode" is the 2-byte *****/
187 /***** character code in big endian format. More exactly: *****/
188 /***** *****/
189 /***** (charcode >> 8) is the first byte value *****/
190 /***** (charcode & 0xFF) is the second byte value *****/
191 /***** *****/
192 /***** Note that not all values of "charcode" are valid according *****/
193 /***** to these rules, and the function moderately check the *****/
194 /***** arguments. *****/
195 /***** *****/
196 /*************************************************************************/
197 /*************************************************************************/
198
199 /*************************************************************************/
200 /* */
201 /* TABLE OVERVIEW */
202 /* -------------- */
203 /* */
204 /* NAME OFFSET TYPE DESCRIPTION */
205 /* */
206 /* format 0 USHORT must be 2 */
207 /* length 2 USHORT table length in bytes */
208 /* language 4 USHORT Mac language code */
209 /* keys 6 USHORT[256] sub-header keys */
210 /* subs 518 SUBHEAD[NSUBS] sub-headers array */
211 /* glyph_ids 518+NSUB*8 USHORT[] glyph id array */
212 /* */
213 /* The `keys' table is used to map charcode high-bytes to sub-headers. */
214 /* The value of `NSUBS' is the number of sub-headers defined in the */
215 /* table and is computed by finding the maximum of the `keys' table. */
216 /* */
217 /* Note that for any n, `keys[n]' is a byte offset within the `subs' */
218 /* table, i.e., it is the corresponding sub-header index multiplied */
219 /* by 8. */
220 /* */
221 /* Each sub-header has the following format: */
222 /* */
223 /* NAME OFFSET TYPE DESCRIPTION */
224 /* */
225 /* first 0 USHORT first valid low-byte */
226 /* count 2 USHORT number of valid low-bytes */
227 /* delta 4 SHORT see below */
228 /* offset 6 USHORT see below */
229 /* */
230 /* A sub-header defines, for each high-byte, the range of valid */
231 /* low-bytes within the charmap. Note that the range defined by `first' */
232 /* and `count' must be completely included in the interval [0..255] */
233 /* according to the specification. */
234 /* */
235 /* If a character code is contained within a given sub-header, then */
236 /* mapping it to a glyph index is done as follows: */
237 /* */
238 /* * The value of `offset' is read. This is a _byte_ distance from the */
239 /* location of the `offset' field itself into a slice of the */
240 /* `glyph_ids' table. Let's call it `slice' (it's a USHORT[] too). */
241 /* */
242 /* * The value `slice[char.lo - first]' is read. If it is 0, there is */
243 /* no glyph for the charcode. Otherwise, the value of `delta' is */
244 /* added to it (modulo 65536) to form a new glyph index. */
245 /* */
246 /* It is up to the validation routine to check that all offsets fall */
247 /* within the glyph ids table (and not within the `subs' table itself or */
248 /* outside of the CMap). */
249 /* */
250
251 #ifdef TT_CONFIG_CMAP_FORMAT_2
252
253 FT_CALLBACK_DEF( void )
254 tt_cmap2_validate( FT_Byte* table,
255 FT_Validator valid )
256 {
257 FT_Byte* p = table + 2; /* skip format */
258 FT_UInt length = TT_PEEK_USHORT( p );
259 FT_UInt n, max_subs;
260 FT_Byte* keys; /* keys table */
261 FT_Byte* subs; /* sub-headers */
262 FT_Byte* glyph_ids; /* glyph id array */
263
264
265 if ( table + length > valid->limit || length < 6 + 512 )
266 FT_INVALID_TOO_SHORT;
267
268 keys = table + 6;
269
270 /* parse keys to compute sub-headers count */
271 p = keys;
272 max_subs = 0;
273 for ( n = 0; n < 256; n++ )
274 {
275 FT_UInt idx = TT_NEXT_USHORT( p );
276
277
278 /* value must be multiple of 8 */
279 if ( valid->level >= FT_VALIDATE_PARANOID && ( idx & 7 ) != 0 )
280 FT_INVALID_DATA;
281
282 idx >>= 3;
283
284 if ( idx > max_subs )
285 max_subs = idx;
286 }
287
288 FT_ASSERT( p == table + 518 );
289
290 subs = p;
291 glyph_ids = subs + (max_subs + 1) * 8;
292 if ( glyph_ids > valid->limit )
293 FT_INVALID_TOO_SHORT;
294
295 /* parse sub-headers */
296 for ( n = 0; n <= max_subs; n++ )
297 {
298 FT_UInt first_code, code_count, offset;
299 FT_Int delta;
300 FT_Byte* ids;
301
302
303 first_code = TT_NEXT_USHORT( p );
304 code_count = TT_NEXT_USHORT( p );
305 delta = TT_NEXT_SHORT( p );
306 offset = TT_NEXT_USHORT( p );
307
308 /* check range within 0..255 */
309 if ( valid->level >= FT_VALIDATE_PARANOID )
310 {
311 if ( first_code >= 256 || first_code + code_count > 256 )
312 FT_INVALID_DATA;
313 }
314
315 /* check offset */
316 if ( offset != 0 )
317 {
318 ids = p - 2 + offset;
319 if ( ids < glyph_ids || ids + code_count*2 > table + length )
320 FT_INVALID_OFFSET;
321
322 /* check glyph ids */
323 if ( valid->level >= FT_VALIDATE_TIGHT )
324 {
325 FT_Byte* limit = p + code_count * 2;
326 FT_UInt idx;
327
328
329 for ( ; p < limit; )
330 {
331 idx = TT_NEXT_USHORT( p );
332 if ( idx != 0 )
333 {
334 idx = ( idx + delta ) & 0xFFFFU;
335 if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
336 FT_INVALID_GLYPH_ID;
337 }
338 }
339 }
340 }
341 }
342 }
343
344
345 /* return sub header corresponding to a given character code */
346 /* NULL on invalid charcode */
347 static FT_Byte*
348 tt_cmap2_get_subheader( FT_Byte* table,
349 FT_UInt32 char_code )
350 {
351 FT_Byte* result = NULL;
352
353
354 if ( char_code < 0x10000UL )
355 {
356 FT_UInt char_lo = (FT_UInt)( char_code & 0xFF );
357 FT_UInt char_hi = (FT_UInt)( char_code >> 8 );
358 FT_Byte* p = table + 6; /* keys table */
359 FT_Byte* subs = table + 518; /* subheaders table */
360 FT_Byte* sub;
361
362
363 if ( char_hi == 0 )
364 {
365 /* an 8-bit character code -- we use subHeader 0 in this case */
366 /* to test whether the character code is in the charmap */
367 /* */
368 sub = subs; /* jump to first sub-header */
369
370 /* check that the sub-header for this byte is 0, which */
371 /* indicates that it's really a valid one-byte value */
372 /* Otherwise, return 0 */
373 /* */
374 p += char_lo * 2;
375 if ( TT_PEEK_USHORT( p ) != 0 )
376 goto Exit;
377 }
378 else
379 {
380 /* a 16-bit character code */
381 p += char_hi * 2; /* jump to key entry */
382 sub = subs + ( TT_PEEK_USHORT( p ) & -8 ); /* jump to sub-header */
383
384 /* check that the hi byte isn't a valid one-byte value */
385 if ( sub == subs )
386 goto Exit;
387 }
388 result = sub;
389 }
390 Exit:
391 return result;
392 }
393
394
395 FT_CALLBACK_DEF( FT_UInt )
396 tt_cmap2_char_index( TT_CMap cmap,
397 FT_UInt32 char_code )
398 {
399 FT_Byte* table = cmap->data;
400 FT_UInt result = 0;
401 FT_Byte* subheader;
402
403
404 subheader = tt_cmap2_get_subheader( table, char_code );
405 if ( subheader )
406 {
407 FT_Byte* p = subheader;
408 FT_UInt idx = (FT_UInt)(char_code & 0xFF);
409 FT_UInt start, count;
410 FT_Int delta;
411 FT_UInt offset;
412
413
414 start = TT_NEXT_USHORT( p );
415 count = TT_NEXT_USHORT( p );
416 delta = TT_NEXT_SHORT ( p );
417 offset = TT_PEEK_USHORT( p );
418
419 idx -= start;
420 if ( idx < count && offset != 0 )
421 {
422 p += offset + 2 * idx;
423 idx = TT_PEEK_USHORT( p );
424
425 if ( idx != 0 )
426 result = (FT_UInt)( idx + delta ) & 0xFFFFU;
427 }
428 }
429 return result;
430 }
431
432
433 FT_CALLBACK_DEF( FT_UInt )
434 tt_cmap2_char_next( TT_CMap cmap,
435 FT_UInt32 *pcharcode )
436 {
437 FT_Byte* table = cmap->data;
438 FT_UInt gindex = 0;
439 FT_UInt32 result = 0;
440 FT_UInt32 charcode = *pcharcode + 1;
441 FT_Byte* subheader;
442
443
444 while ( charcode < 0x10000UL )
445 {
446 subheader = tt_cmap2_get_subheader( table, charcode );
447 if ( subheader )
448 {
449 FT_Byte* p = subheader;
450 FT_UInt start = TT_NEXT_USHORT( p );
451 FT_UInt count = TT_NEXT_USHORT( p );
452 FT_Int delta = TT_NEXT_SHORT ( p );
453 FT_UInt offset = TT_PEEK_USHORT( p );
454 FT_UInt char_lo = (FT_UInt)( charcode & 0xFF );
455 FT_UInt pos, idx;
456
457
458 if ( offset == 0 )
459 goto Next_SubHeader;
460
461 if ( char_lo < start )
462 {
463 char_lo = start;
464 pos = 0;
465 }
466 else
467 pos = (FT_UInt)( char_lo - start );
468
469 p += offset + pos * 2;
470 charcode = ( charcode & -256 ) + char_lo;
471
472 for ( ; pos < count; pos++, charcode++ )
473 {
474 idx = TT_NEXT_USHORT( p );
475
476 if ( idx != 0 )
477 {
478 gindex = ( idx + delta ) & 0xFFFFU;
479 if ( gindex != 0 )
480 {
481 result = charcode;
482 goto Exit;
483 }
484 }
485 }
486 }
487
488 /* jump to next sub-header, i.e. higher byte value */
489 Next_SubHeader:
490 charcode = ( charcode & -256 ) + 256;
491 }
492
493 Exit:
494 *pcharcode = result;
495
496 return gindex;
497 }
498
499
500 FT_CALLBACK_TABLE_DEF
501 const TT_CMap_ClassRec tt_cmap2_class_rec =
502 {
503 {
504 sizeof( TT_CMapRec ),
505
506 (FT_CMap_InitFunc) tt_cmap_init,
507 (FT_CMap_DoneFunc) NULL,
508 (FT_CMap_CharIndexFunc)tt_cmap2_char_index,
509 (FT_CMap_CharNextFunc) tt_cmap2_char_next
510 },
511 2,
512 (TT_CMap_ValidateFunc) tt_cmap2_validate
513 };
514
515 #endif /* TT_CONFIG_CMAP_FORMAT_2 */
516
517
518 /*************************************************************************/
519 /*************************************************************************/
520 /***** *****/
521 /***** FORMAT 4 *****/
522 /***** *****/
523 /*************************************************************************/
524 /*************************************************************************/
525
526 /*************************************************************************/
527 /* */
528 /* TABLE OVERVIEW */
529 /* -------------- */
530 /* */
531 /* NAME OFFSET TYPE DESCRIPTION */
532 /* */
533 /* format 0 USHORT must be 4 */
534 /* length 2 USHORT table length */
535 /* in bytes */
536 /* language 4 USHORT Mac language code */
537 /* */
538 /* segCountX2 6 USHORT 2*NUM_SEGS */
539 /* searchRange 8 USHORT 2*(1 << LOG_SEGS) */
540 /* entrySelector 10 USHORT LOG_SEGS */
541 /* rangeShift 12 USHORT segCountX2 - */
542 /* searchRange */
543 /* */
544 /* endCount 14 USHORT[NUM_SEGS] end charcode for */
545 /* each segment; last */
546 /* is 0xFFFF */
547 /* */
548 /* pad 14+NUM_SEGS*2 USHORT padding */
549 /* */
550 /* startCount 16+NUM_SEGS*2 USHORT[NUM_SEGS] first charcode for */
551 /* each segment */
552 /* */
553 /* idDelta 16+NUM_SEGS*4 SHORT[NUM_SEGS] delta for each */
554 /* segment */
555 /* idOffset 16+NUM_SEGS*6 SHORT[NUM_SEGS] range offset for */
556 /* each segment; can be */
557 /* zero */
558 /* */
559 /* glyphIds 16+NUM_SEGS*8 USHORT[] array of glyph id */
560 /* ranges */
561 /* */
562 /* Character codes are modelled by a series of ordered (increasing) */
563 /* intervals called segments. Each segment has start and end codes, */
564 /* provided by the `startCount' and `endCount' arrays. Segments must */
565 /* not be overlapping and the last segment should always contain the */
566 /* `0xFFFF' endCount. */
567 /* */
568 /* The fields `searchRange', `entrySelector' and `rangeShift' are better */
569 /* ignored (they are traces of over-engineering in the TrueType */
570 /* specification). */
571 /* */
572 /* Each segment also has a signed `delta', as well as an optional offset */
573 /* within the `glyphIds' table. */
574 /* */
575 /* If a segment's idOffset is 0, the glyph index corresponding to any */
576 /* charcode within the segment is obtained by adding the value of */
577 /* `idDelta' directly to the charcode, modulo 65536. */
578 /* */
579 /* Otherwise, a glyph index is taken from the glyph ids sub-array for */
580 /* the segment, and the value of `idDelta' is added to it. */
581 /* */
582
583 #ifdef TT_CONFIG_CMAP_FORMAT_4
584
585 FT_CALLBACK_DEF( void )
586 tt_cmap4_validate( FT_Byte* table,
587 FT_Validator valid )
588 {
589 FT_Byte* p = table + 2; /* skip format */
590 FT_UInt length = TT_NEXT_USHORT( p );
591 FT_Byte *ends, *starts, *offsets, *deltas, *glyph_ids;
592 FT_UInt num_segs;
593
594
595 if ( table + length > valid->limit || length < 16 )
596 FT_INVALID_TOO_SHORT;
597
598 p = table + 6;
599 num_segs = TT_NEXT_USHORT( p ); /* read segCountX2 */
600
601 if ( valid->level >= FT_VALIDATE_PARANOID )
602 {
603 /* check that we have an even value here */
604 if ( num_segs & 1 )
605 FT_INVALID_DATA;
606 }
607
608 num_segs /= 2;
609
610 /* check the search parameters - even though we never use them */
611 /* */
612 if ( valid->level >= FT_VALIDATE_PARANOID )
613 {
614 /* check the values of 'searchRange', 'entrySelector', 'rangeShift' */
615 FT_UInt search_range = TT_NEXT_USHORT( p );
616 FT_UInt entry_selector = TT_NEXT_USHORT( p );
617 FT_UInt range_shift = TT_NEXT_USHORT( p );
618
619
620 if ( ( search_range | range_shift ) & 1 ) /* must be even values */
621 FT_INVALID_DATA;
622
623 search_range /= 2;
624 range_shift /= 2;
625
626 /* `search range' is the greatest power of 2 that is <= num_segs */
627
628 if ( search_range > num_segs ||
629 search_range * 2 < num_segs ||
630 search_range + range_shift != num_segs ||
631 search_range != ( 1U << entry_selector ) )
632 FT_INVALID_DATA;
633 }
634
635 ends = table + 14;
636 starts = table + 16 + num_segs * 2;
637 deltas = starts + num_segs * 2;
638 offsets = deltas + num_segs * 2;
639 glyph_ids = offsets + num_segs * 2;
640
641 if ( glyph_ids > table + length )
642 FT_INVALID_TOO_SHORT;
643
644 /* check last segment, its end count must be FFFF */
645 if ( valid->level >= FT_VALIDATE_PARANOID )
646 {
647 p = ends + ( num_segs - 1 ) * 2;
648 if ( TT_PEEK_USHORT( p ) != 0xFFFFU )
649 FT_INVALID_DATA;
650 }
651
652 /* check that segments are sorted in increasing order and do not */
653 /* overlap; check also the offsets */
654 {
655 FT_UInt start, end, last = 0, offset, n;
656 FT_Int delta;
657
658
659 for ( n = 0; n < num_segs; n++ )
660 {
661 p = starts + n * 2;
662 start = TT_PEEK_USHORT( p );
663 p = ends + n * 2;
664 end = TT_PEEK_USHORT( p );
665 p = deltas + n * 2;
666 delta = TT_PEEK_SHORT( p );
667 p = offsets + n * 2;
668 offset = TT_PEEK_USHORT( p );
669
670 if ( start > end )
671 FT_INVALID_DATA;
672
673 /* this test should be performed at default validation level; */
674 /* unfortunately, some popular Asian fonts present overlapping */
675 /* ranges in their charmaps */
676 /* */
677 if ( valid->level >= FT_VALIDATE_TIGHT )
678 {
679 if ( n > 0 && start <= last )
680 FT_INVALID_DATA;
681 }
682
683 if ( offset )
684 {
685 p += offset; /* start of glyph id array */
686
687 /* check that we point within the glyph ids table only */
688 if ( p < glyph_ids ||
689 p + ( end - start + 1 ) * 2 > table + length )
690 FT_INVALID_DATA;
691
692 /* check glyph indices within the segment range */
693 if ( valid->level >= FT_VALIDATE_TIGHT )
694 {
695 FT_UInt idx;
696
697
698 for ( ; start < end; )
699 {
700 idx = FT_NEXT_USHORT( p );
701 if ( idx != 0 )
702 {
703 idx = (FT_UInt)( idx + delta ) & 0xFFFFU;
704
705 if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
706 FT_INVALID_GLYPH_ID;
707 }
708 }
709 }
710 }
711
712 last = end;
713 }
714 }
715 }
716
717
718 FT_CALLBACK_DEF( FT_UInt )
719 tt_cmap4_char_index( TT_CMap cmap,
720 FT_UInt32 char_code )
721 {
722 FT_Byte* table = cmap->data;
723 FT_UInt result = 0;
724
725
726 if ( char_code < 0x10000UL )
727 {
728 FT_UInt idx, num_segs2;
729 FT_Int delta;
730 FT_UInt code = (FT_UInt)char_code;
731 FT_Byte* p;
732
733
734 p = table + 6;
735 num_segs2 = TT_PEEK_USHORT( p ) & -2; /* be paranoid! */
736
737 #if 1
738 /* Some fonts have more than 170 segments in their charmaps! */
739 /* We changed this function to use a more efficient binary */
740 /* search for improving performance */
741 {
742 FT_UInt min = 0;
743 FT_UInt max = num_segs2 >> 1;
744 FT_UInt mid, start, end, offset;
745
746
747 while ( min < max )
748 {
749 mid = ( min + max ) >> 1;
750 p = table + 14 + mid * 2;
751 end = TT_NEXT_USHORT( p );
752 p += num_segs2;
753 start = TT_PEEK_USHORT( p);
754
755 if ( code < start )
756 max = mid;
757
758 else if ( code > end )
759 min = mid + 1;
760
761 else
762 {
763 /* we found the segment */
764 idx = code;
765
766 p += num_segs2;
767 delta = TT_PEEK_SHORT( p );
768
769 p += num_segs2;
770 offset = TT_PEEK_USHORT( p );
771
772 if ( offset != 0 )
773 {
774 p += offset + 2 * ( idx - start );
775 idx = TT_PEEK_USHORT( p );
776 }
777
778 if ( idx != 0 )
779 result = (FT_UInt)( idx + delta ) & 0xFFFFU;
780
781 goto Exit;
782 }
783 }
784 }
785
786 #else /* 0 - old code */
787
788 {
789 FT_UInt n;
790 FT_Byte* q;
791
792
793 p = table + 14; /* ends table */
794 q = table + 16 + num_segs2; /* starts table */
795
796
797 for ( n = 0; n < num_segs2; n += 2 )
798 {
799 FT_UInt end = TT_NEXT_USHORT( p );
800 FT_UInt start = TT_NEXT_USHORT( q );
801 FT_UInt offset;
802
803
804 if ( code < start )
805 break;
806
807 if ( code <= end )
808 {
809 idx = code;
810
811 p = q + num_segs2 - 2;
812 delta = TT_PEEK_SHORT( p );
813 p += num_segs2;
814 offset = TT_PEEK_USHORT( p );
815
816 if ( offset != 0 )
817 {
818 p += offset + 2 * ( idx - start );
819 idx = TT_PEEK_USHORT( p );
820 }
821
822 if ( idx != 0 )
823 result = (FT_UInt)( idx + delta ) & 0xFFFFU;
824 }
825 }
826 }
827
828 #endif /* 0 */
829
830 }
831
832 Exit:
833 return result;
834 }
835
836
837 FT_CALLBACK_DEF( FT_UInt )
838 tt_cmap4_char_next( TT_CMap cmap,
839 FT_UInt32 *pchar_code )
840 {
841 FT_Byte* table = cmap->data;
842 FT_UInt32 result = 0;
843 FT_UInt32 char_code = *pchar_code + 1;
844 FT_UInt gindex = 0;
845 FT_Byte* p;
846 FT_Byte* q;
847 FT_UInt code, num_segs2;
848
849
850 if ( char_code >= 0x10000UL )
851 goto Exit;
852
853 code = (FT_UInt)char_code;
854 p = table + 6;
855 num_segs2 = TT_PEEK_USHORT(p) & -2; /* ensure even-ness */
856
857 for (;;)
858 {
859 FT_UInt offset, n;
860 FT_Int delta;
861
862
863 p = table + 14; /* ends table */
864 q = table + 16 + num_segs2; /* starts table */
865
866 for ( n = 0; n < num_segs2; n += 2 )
867 {
868 FT_UInt end = TT_NEXT_USHORT( p );
869 FT_UInt start = TT_NEXT_USHORT( q );
870
871
872 if ( code < start )
873 code = start;
874
875 if ( code <= end )
876 {
877 p = q + num_segs2 - 2;
878 delta = TT_PEEK_SHORT( p );
879 p += num_segs2;
880 offset = TT_PEEK_USHORT( p );
881
882 if ( offset != 0 )
883 {
884 /* parse the glyph ids array for non-0 index */
885 p += offset + ( code - start ) * 2;
886 while ( code <= end )
887 {
888 gindex = TT_NEXT_USHORT( p );
889 if ( gindex != 0 )
890 {
891 gindex = (FT_UInt)( gindex + delta ) & 0xFFFFU;
892 if ( gindex != 0 )
893 break;
894 }
895 code++;
896 }
897 }
898 else
899 gindex = (FT_UInt)( code + delta ) & 0xFFFFU;
900
901 if ( gindex == 0 )
902 break;
903
904 result = code;
905 goto Exit;
906 }
907 }
908
909 /* loop to next trial charcode */
910 if ( code >= 0xFFFFU )
911 break;
912
913 code++;
914 }
915 return result;
916
917 Exit:
918 *pchar_code = result;
919 return gindex;
920 }
921
922
923 FT_CALLBACK_TABLE_DEF
924 const TT_CMap_ClassRec tt_cmap4_class_rec =
925 {
926 {
927 sizeof ( TT_CMapRec ),
928
929 (FT_CMap_InitFunc) tt_cmap_init,
930 (FT_CMap_DoneFunc) NULL,
931 (FT_CMap_CharIndexFunc)tt_cmap4_char_index,
932 (FT_CMap_CharNextFunc) tt_cmap4_char_next
933 },
934 4,
935 (TT_CMap_ValidateFunc) tt_cmap4_validate
936 };
937
938 #endif /* TT_CONFIG_CMAP_FORMAT_4 */
939
940
941 /*************************************************************************/
942 /*************************************************************************/
943 /***** *****/
944 /***** FORMAT 6 *****/
945 /***** *****/
946 /*************************************************************************/
947 /*************************************************************************/
948
949 /*************************************************************************/
950 /* */
951 /* TABLE OVERVIEW */
952 /* -------------- */
953 /* */
954 /* NAME OFFSET TYPE DESCRIPTION */
955 /* */
956 /* format 0 USHORT must be 4 */
957 /* length 2 USHORT table length in bytes */
958 /* language 4 USHORT Mac language code */
959 /* */
960 /* first 6 USHORT first segment code */
961 /* count 8 USHORT segment size in chars */
962 /* glyphIds 10 USHORT[count] glyph ids */
963 /* */
964 /* A very simplified segment mapping. */
965 /* */
966
967 #ifdef TT_CONFIG_CMAP_FORMAT_6
968
969 FT_CALLBACK_DEF( void )
970 tt_cmap6_validate( FT_Byte* table,
971 FT_Validator valid )
972 {
973 FT_Byte* p;
974 FT_UInt length, start, count;
975
976
977 if ( table + 10 > valid->limit )
978 FT_INVALID_TOO_SHORT;
979
980 p = table + 2;
981 length = TT_NEXT_USHORT( p );
982
983 p = table + 6; /* skip language */
984 start = TT_NEXT_USHORT( p );
985 count = TT_NEXT_USHORT( p );
986
987 if ( table + length > valid->limit || length < 10 + count * 2 )
988 FT_INVALID_TOO_SHORT;
989
990 /* check glyph indices */
991 if ( valid->level >= FT_VALIDATE_TIGHT )
992 {
993 FT_UInt gindex;
994
995
996 for ( ; count > 0; count-- )
997 {
998 gindex = TT_NEXT_USHORT( p );
999 if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
1000 FT_INVALID_GLYPH_ID;
1001 }
1002 }
1003 }
1004
1005
1006 FT_CALLBACK_DEF( FT_UInt )
1007 tt_cmap6_char_index( TT_CMap cmap,
1008 FT_UInt32 char_code )
1009 {
1010 FT_Byte* table = cmap->data;
1011 FT_UInt result = 0;
1012 FT_Byte* p = table + 6;
1013 FT_UInt start = TT_NEXT_USHORT( p );
1014 FT_UInt count = TT_NEXT_USHORT( p );
1015 FT_UInt idx = (FT_UInt)( char_code - start );
1016
1017
1018 if ( idx < count )
1019 {
1020 p += 2 * idx;
1021 result = TT_PEEK_USHORT( p );
1022 }
1023 return result;
1024 }
1025
1026
1027 FT_CALLBACK_DEF( FT_UInt )
1028 tt_cmap6_char_next( TT_CMap cmap,
1029 FT_UInt32 *pchar_code )
1030 {
1031 FT_Byte* table = cmap->data;
1032 FT_UInt32 result = 0;
1033 FT_UInt32 char_code = *pchar_code + 1;
1034 FT_UInt gindex = 0;
1035
1036 FT_Byte* p = table + 6;
1037 FT_UInt start = TT_NEXT_USHORT( p );
1038 FT_UInt count = TT_NEXT_USHORT( p );
1039 FT_UInt idx;
1040
1041
1042 if ( char_code >= 0x10000UL )
1043 goto Exit;
1044
1045 if ( char_code < start )
1046 char_code = start;
1047
1048 idx = (FT_UInt)( char_code - start );
1049 p += 2 * idx;
1050
1051 for ( ; idx < count; idx++ )
1052 {
1053 gindex = TT_NEXT_USHORT( p );
1054 if ( gindex != 0 )
1055 {
1056 result = char_code;
1057 break;
1058 }
1059 char_code++;
1060 }
1061
1062 Exit:
1063 *pchar_code = result;
1064 return gindex;
1065 }
1066
1067
1068 FT_CALLBACK_TABLE_DEF
1069 const TT_CMap_ClassRec tt_cmap6_class_rec =
1070 {
1071 {
1072 sizeof ( TT_CMapRec ),
1073
1074 (FT_CMap_InitFunc) tt_cmap_init,
1075 (FT_CMap_DoneFunc) NULL,
1076 (FT_CMap_CharIndexFunc)tt_cmap6_char_index,
1077 (FT_CMap_CharNextFunc) tt_cmap6_char_next
1078 },
1079 6,
1080 (TT_CMap_ValidateFunc) tt_cmap6_validate
1081 };
1082
1083 #endif /* TT_CONFIG_CMAP_FORMAT_6 */
1084
1085
1086 /*************************************************************************/
1087 /*************************************************************************/
1088 /***** *****/
1089 /***** FORMAT 8 *****/
1090 /***** *****/
1091 /***** It's hard to completely understand what the OpenType spec *****/
1092 /***** says about this format, but here is my conclusion. *****/
1093 /***** *****/
1094 /***** The purpose of this format is to easily map UTF-16 text to *****/
1095 /***** glyph indices. Basically, the `char_code' must be in one of *****/
1096 /***** the following formats: *****/
1097 /***** *****/
1098 /***** - A 16-bit value that isn't part of the Unicode Surrogates *****/
1099 /***** Area (i.e. U+D800-U+DFFF). *****/
1100 /***** *****/
1101 /***** - A 32-bit value, made of two surrogate values, i.e.. if *****/
1102 /***** `char_code = (char_hi << 16) | char_lo', then both *****/
1103 /***** `char_hi' and `char_lo' must be in the Surrogates Area. *****/
1104 /***** Area. *****/
1105 /***** *****/
1106 /***** The 'is32' table embedded in the charmap indicates whether a *****/
1107 /***** given 16-bit value is in the surrogates area or not. *****/
1108 /***** *****/
1109 /***** So, for any given `char_code', we can assert the following: *****/
1110 /***** *****/
1111 /***** If `char_hi == 0' then we must have `is32[char_lo] == 0'. *****/
1112 /***** *****/
1113 /***** If `char_hi != 0' then we must have both *****/
1114 /***** `is32[char_hi] != 0' and `is32[char_lo] != 0'. *****/
1115 /***** *****/
1116 /*************************************************************************/
1117 /*************************************************************************/
1118
1119 /*************************************************************************/
1120 /* */
1121 /* TABLE OVERVIEW */
1122 /* -------------- */
1123 /* */
1124 /* NAME OFFSET TYPE DESCRIPTION */
1125 /* */
1126 /* format 0 USHORT must be 8 */
1127 /* reseved 2 USHORT reserved */
1128 /* length 4 ULONG length in bytes */
1129 /* language 8 ULONG Mac language code */
1130 /* is32 12 BYTE[8192] 32-bitness bitmap */
1131 /* count 8204 ULONG number of groups */
1132 /* */
1133 /* This header is followed by 'count' groups of the following format: */
1134 /* */
1135 /* start 0 ULONG first charcode */
1136 /* end 4 ULONG last charcode */
1137 /* startId 8 ULONG start glyph id for the group */
1138 /* */
1139
1140 #ifdef TT_CONFIG_CMAP_FORMAT_8
1141
1142 FT_CALLBACK_DEF( void )
1143 tt_cmap8_validate( FT_Byte* table,
1144 FT_Validator valid )
1145 {
1146 FT_Byte* p = table + 4;
1147 FT_Byte* is32;
1148 FT_UInt32 length;
1149 FT_UInt32 num_groups;
1150
1151
1152 if ( table + 16 + 8192 > valid->limit )
1153 FT_INVALID_TOO_SHORT;
1154
1155 length = TT_NEXT_ULONG( p );
1156 if ( table + length > valid->limit || length < 8208 )
1157 FT_INVALID_TOO_SHORT;
1158
1159 is32 = table + 12;
1160 p = is32 + 8192; /* skip `is32' array */
1161 num_groups = TT_NEXT_ULONG( p );
1162
1163 if ( p + num_groups * 12 > valid->limit )
1164 FT_INVALID_TOO_SHORT;
1165
1166 /* check groups, they must be in increasing order */
1167 {
1168 FT_UInt32 n, start, end, start_id, count, last = 0;
1169
1170
1171 for ( n = 0; n < num_groups; n++ )
1172 {
1173 FT_UInt hi, lo;
1174
1175
1176 start = TT_NEXT_ULONG( p );
1177 end = TT_NEXT_ULONG( p );
1178 start_id = TT_NEXT_ULONG( p );
1179
1180 if ( start > end )
1181 FT_INVALID_DATA;
1182
1183 if ( n > 0 && start <= last )
1184 FT_INVALID_DATA;
1185
1186 if ( valid->level >= FT_VALIDATE_TIGHT )
1187 {
1188 if ( start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) )
1189 FT_INVALID_GLYPH_ID;
1190
1191 count = (FT_UInt32)( end - start + 1 );
1192
1193 if ( start & ~0xFFFFU )
1194 {
1195 /* start_hi != 0; check that is32[i] is 1 for each i in */
1196 /* the `hi' and `lo' of the range [start..end] */
1197 for ( ; count > 0; count--, start++ )
1198 {
1199 hi = (FT_UInt)( start >> 16 );
1200 lo = (FT_UInt)( start & 0xFFFFU );
1201
1202 if ( (is32[hi >> 3] & ( 0x80 >> ( hi & 7 ) ) ) == 0 )
1203 FT_INVALID_DATA;
1204
1205 if ( (is32[lo >> 3] & ( 0x80 >> ( lo & 7 ) ) ) == 0 )
1206 FT_INVALID_DATA;
1207 }
1208 }
1209 else
1210 {
1211 /* start_hi == 0; check that is32[i] is 0 for each i in */
1212 /* the range [start..end] */
1213
1214 /* end_hi cannot be != 0! */
1215 if ( end & ~0xFFFFU )
1216 FT_INVALID_DATA;
1217
1218 for ( ; count > 0; count--, start++ )
1219 {
1220 lo = (FT_UInt)( start & 0xFFFFU );
1221
1222 if ( (is32[lo >> 3] & ( 0x80 >> ( lo & 7 ) ) ) != 0 )
1223 FT_INVALID_DATA;
1224 }
1225 }
1226 }
1227
1228 last = end;
1229 }
1230 }
1231 }
1232
1233
1234 FT_CALLBACK_DEF( FT_UInt )
1235 tt_cmap8_char_index( TT_CMap cmap,
1236 FT_UInt32 char_code )
1237 {
1238 FT_Byte* table = cmap->data;
1239 FT_UInt result = 0;
1240 FT_Byte* p = table + 8204;
1241 FT_UInt32 num_groups = TT_NEXT_ULONG( p );
1242 FT_UInt32 start, end, start_id;
1243
1244
1245 for ( ; num_groups > 0; num_groups-- )
1246 {
1247 start = TT_NEXT_ULONG( p );
1248 end = TT_NEXT_ULONG( p );
1249 start_id = TT_NEXT_ULONG( p );
1250
1251 if ( char_code < start )
1252 break;
1253
1254 if ( char_code <= end )
1255 {
1256 result = start_id + char_code - start;
1257 break;
1258 }
1259 }
1260 return result;
1261 }
1262
1263
1264 FT_CALLBACK_DEF( FT_UInt )
1265 tt_cmap8_char_next( TT_CMap cmap,
1266 FT_UInt32 *pchar_code )
1267 {
1268 FT_UInt32 result = 0;
1269 FT_UInt32 char_code = *pchar_code + 1;
1270 FT_UInt gindex = 0;
1271 FT_Byte* table = cmap->data;
1272 FT_Byte* p = table + 8204;
1273 FT_UInt32 num_groups = TT_NEXT_ULONG( p );
1274 FT_UInt32 n, start, end, start_id;
1275
1276
1277 p = table + 8208;
1278
1279 for ( n = 0; n < num_groups++; n++ )
1280 {
1281 start = TT_NEXT_ULONG( p );
1282 end = TT_NEXT_ULONG( p );
1283 start_id = TT_NEXT_ULONG( p );
1284
1285 if ( char_code < start )
1286 char_code = start;
1287
1288 if ( char_code <= end )
1289 {
1290 gindex = (FT_UInt)( char_code - start + start_id );
1291 if ( gindex != 0 )
1292 {
1293 result = char_code;
1294 goto Exit;
1295 }
1296 }
1297 }
1298
1299 Exit:
1300 *pchar_code = result;
1301 return gindex;
1302 }
1303
1304
1305 FT_CALLBACK_TABLE_DEF
1306 const TT_CMap_ClassRec tt_cmap8_class_rec =
1307 {
1308 {
1309 sizeof ( TT_CMapRec ),
1310
1311 (FT_CMap_InitFunc) tt_cmap_init,
1312 (FT_CMap_DoneFunc) NULL,
1313 (FT_CMap_CharIndexFunc)tt_cmap8_char_index,
1314 (FT_CMap_CharNextFunc) tt_cmap8_char_next
1315 },
1316 8,
1317 (TT_CMap_ValidateFunc) tt_cmap8_validate
1318 };
1319
1320 #endif /* TT_CONFIG_CMAP_FORMAT_8 */
1321
1322
1323 /*************************************************************************/
1324 /*************************************************************************/
1325 /***** *****/
1326 /***** FORMAT 10 *****/
1327 /***** *****/
1328 /*************************************************************************/
1329 /*************************************************************************/
1330
1331 /*************************************************************************/
1332 /* */
1333 /* TABLE OVERVIEW */
1334 /* -------------- */
1335 /* */
1336 /* NAME OFFSET TYPE DESCRIPTION */
1337 /* */
1338 /* format 0 USHORT must be 10 */
1339 /* reserved 2 USHORT reserved */
1340 /* length 4 ULONG length in bytes */
1341 /* language 8 ULONG Mac language code */
1342 /* */
1343 /* start 12 ULONG first char in range */
1344 /* count 16 ULONG number of chars in range */
1345 /* glyphIds 20 USHORT[count] glyph indices covered */
1346 /* */
1347
1348 #ifdef TT_CONFIG_CMAP_FORMAT_10
1349
1350 FT_CALLBACK_DEF( void )
1351 tt_cmap10_validate( FT_Byte* table,
1352 FT_Validator valid )
1353 {
1354 FT_Byte* p = table + 4;
1355 FT_ULong length, start, count;
1356
1357
1358 if ( table + 20 > valid->limit )
1359 FT_INVALID_TOO_SHORT;
1360
1361 length = TT_NEXT_ULONG( p );
1362 p = table + 12;
1363 start = TT_NEXT_ULONG( p );
1364 count = TT_NEXT_ULONG( p );
1365
1366 if ( table + length > valid->limit || length < 20 + count * 2 )
1367 FT_INVALID_TOO_SHORT;
1368
1369 /* check glyph indices */
1370 if ( valid->level >= FT_VALIDATE_TIGHT )
1371 {
1372 FT_UInt gindex;
1373
1374
1375 for ( ; count > 0; count-- )
1376 {
1377 gindex = TT_NEXT_USHORT( p );
1378 if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
1379 FT_INVALID_GLYPH_ID;
1380 }
1381 }
1382 }
1383
1384
1385 FT_CALLBACK_DEF( FT_UInt )
1386 tt_cmap10_char_index( TT_CMap cmap,
1387 FT_UInt32 char_code )
1388 {
1389 FT_Byte* table = cmap->data;
1390 FT_UInt result = 0;
1391 FT_Byte* p = table + 12;
1392 FT_UInt32 start = TT_NEXT_ULONG( p );
1393 FT_UInt32 count = TT_NEXT_ULONG( p );
1394 FT_UInt32 idx = (FT_ULong)( char_code - start );
1395
1396
1397 if ( idx < count )
1398 {
1399 p += 2 * idx;
1400 result = TT_PEEK_USHORT( p );
1401 }
1402 return result;
1403 }
1404
1405
1406 FT_CALLBACK_DEF( FT_UInt )
1407 tt_cmap10_char_next( TT_CMap cmap,
1408 FT_UInt32 *pchar_code )
1409 {
1410 FT_Byte* table = cmap->data;
1411 FT_UInt32 result = 0;
1412 FT_UInt32 char_code = *pchar_code + 1;
1413 FT_UInt gindex = 0;
1414 FT_Byte* p = table + 12;
1415 FT_UInt32 start = TT_NEXT_ULONG( p );
1416 FT_UInt32 count = TT_NEXT_ULONG( p );
1417 FT_UInt32 idx;
1418
1419
1420 if ( char_code < start )
1421 char_code = start;
1422
1423 idx = (FT_UInt32)( char_code - start );
1424 p += 2 * idx;
1425
1426 for ( ; idx < count; idx++ )
1427 {
1428 gindex = TT_NEXT_USHORT( p );
1429 if ( gindex != 0 )
1430 {
1431 result = char_code;
1432 break;
1433 }
1434 char_code++;
1435 }
1436
1437 *pchar_code = char_code;
1438 return gindex;
1439 }
1440
1441
1442 FT_CALLBACK_TABLE_DEF
1443 const TT_CMap_ClassRec tt_cmap10_class_rec =
1444 {
1445 {
1446 sizeof ( TT_CMapRec ),
1447
1448 (FT_CMap_InitFunc) tt_cmap_init,
1449 (FT_CMap_DoneFunc) NULL,
1450 (FT_CMap_CharIndexFunc)tt_cmap10_char_index,
1451 (FT_CMap_CharNextFunc) tt_cmap10_char_next
1452 },
1453 10,
1454 (TT_CMap_ValidateFunc) tt_cmap10_validate
1455 };
1456
1457 #endif /* TT_CONFIG_CMAP_FORMAT_10 */
1458
1459
1460 /*************************************************************************/
1461 /*************************************************************************/
1462 /***** *****/
1463 /***** FORMAT 12 *****/
1464 /***** *****/
1465 /*************************************************************************/
1466 /*************************************************************************/
1467
1468 /*************************************************************************/
1469 /* */
1470 /* TABLE OVERVIEW */
1471 /* -------------- */
1472 /* */
1473 /* NAME OFFSET TYPE DESCRIPTION */
1474 /* */
1475 /* format 0 USHORT must be 12 */
1476 /* reserved 2 USHORT reserved */
1477 /* length 4 ULONG length in bytes */
1478 /* language 8 ULONG Mac language code */
1479 /* count 12 ULONG number of groups */
1480 /* 16 */
1481 /* */
1482 /* This header is followed by `count' groups of the following format: */
1483 /* */
1484 /* start 0 ULONG first charcode */
1485 /* end 4 ULONG last charcode */
1486 /* startId 8 ULONG start glyph id for the group */
1487 /* */
1488
1489 #ifdef TT_CONFIG_CMAP_FORMAT_12
1490
1491 FT_CALLBACK_DEF( void )
1492 tt_cmap12_validate( FT_Byte* table,
1493 FT_Validator valid )
1494 {
1495 FT_Byte* p;
1496 FT_ULong length;
1497 FT_ULong num_groups;
1498
1499
1500 if ( table + 16 > valid->limit )
1501 FT_INVALID_TOO_SHORT;
1502
1503 p = table + 4;
1504 length = TT_NEXT_ULONG( p );
1505
1506 p = table + 12;
1507 num_groups = TT_NEXT_ULONG( p );
1508
1509 if ( table + length > valid->limit || length < 16 + 12 * num_groups )
1510 FT_INVALID_TOO_SHORT;
1511
1512 /* check groups, they must be in increasing order */
1513 {
1514 FT_ULong n, start, end, start_id, last = 0;
1515
1516
1517 for ( n = 0; n < num_groups; n++ )
1518 {
1519 start = TT_NEXT_ULONG( p );
1520 end = TT_NEXT_ULONG( p );
1521 start_id = TT_NEXT_ULONG( p );
1522
1523 if ( start > end )
1524 FT_INVALID_DATA;
1525
1526 if ( n > 0 && start <= last )
1527 FT_INVALID_DATA;
1528
1529 if ( valid->level >= FT_VALIDATE_TIGHT )
1530 {
1531 if ( start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) )
1532 FT_INVALID_GLYPH_ID;
1533 }
1534
1535 last = end;
1536 }
1537 }
1538 }
1539
1540
1541 FT_CALLBACK_DEF( FT_UInt )
1542 tt_cmap12_char_index( TT_CMap cmap,
1543 FT_UInt32 char_code )
1544 {
1545 FT_UInt result = 0;
1546 FT_Byte* table = cmap->data;
1547 FT_Byte* p = table + 12;
1548 FT_UInt32 num_groups = TT_NEXT_ULONG( p );
1549 FT_UInt32 start, end, start_id;
1550
1551
1552 for ( ; num_groups > 0; num_groups-- )
1553 {
1554 start = TT_NEXT_ULONG( p );
1555 end = TT_NEXT_ULONG( p );
1556 start_id = TT_NEXT_ULONG( p );
1557
1558 if ( char_code < start )
1559 break;
1560
1561 if ( char_code <= end )
1562 {
1563 result = start_id + char_code - start;
1564 break;
1565 }
1566 }
1567 return result;
1568 }
1569
1570
1571 FT_CALLBACK_DEF( FT_UInt )
1572 tt_cmap12_char_next( TT_CMap cmap,
1573 FT_UInt32 *pchar_code )
1574 {
1575 FT_Byte* table = cmap->data;
1576 FT_UInt32 result = 0;
1577 FT_UInt32 char_code = *pchar_code + 1;
1578 FT_UInt gindex = 0;
1579 FT_Byte* p = table + 12;
1580 FT_UInt32 num_groups = TT_NEXT_ULONG( p );
1581 FT_UInt32 n, start, end, start_id;
1582
1583
1584 p = table + 16;
1585
1586 for ( n = 0; n < num_groups++; n++ )
1587 {
1588 start = TT_NEXT_ULONG( p );
1589 end = TT_NEXT_ULONG( p );
1590 start_id = TT_NEXT_ULONG( p );
1591
1592 if ( char_code < start )
1593 char_code = start;
1594
1595 if ( char_code <= end )
1596 {
1597 gindex = (FT_UInt)(char_code - start + start_id);
1598 if ( gindex != 0 )
1599 {
1600 result = char_code;
1601 goto Exit;
1602 }
1603 }
1604 }
1605
1606 Exit:
1607 *pchar_code = result;
1608 return gindex;
1609 }
1610
1611
1612 FT_CALLBACK_TABLE_DEF
1613 const TT_CMap_ClassRec tt_cmap12_class_rec =
1614 {
1615 {
1616 sizeof ( TT_CMapRec ),
1617
1618 (FT_CMap_InitFunc) tt_cmap_init,
1619 (FT_CMap_DoneFunc) NULL,
1620 (FT_CMap_CharIndexFunc)tt_cmap12_char_index,
1621 (FT_CMap_CharNextFunc) tt_cmap12_char_next
1622 },
1623 12,
1624 (TT_CMap_ValidateFunc) tt_cmap12_validate
1625 };
1626
1627
1628 #endif /* TT_CONFIG_CMAP_FORMAT_12 */
1629
1630
1631 #ifdef FT_CONFIG_OPTION_USE_CMAPS
1632
1633 static const TT_CMap_Class tt_cmap_classes[] =
1634 {
1635 #ifdef TT_CONFIG_CMAP_FORMAT_0
1636 &tt_cmap0_class_rec,
1637 #endif
1638
1639 #ifdef TT_CONFIG_CMAP_FORMAT_2
1640 &tt_cmap2_class_rec,
1641 #endif
1642
1643 #ifdef TT_CONFIG_CMAP_FORMAT_4
1644 &tt_cmap4_class_rec,
1645 #endif
1646
1647 #ifdef TT_CONFIG_CMAP_FORMAT_6
1648 &tt_cmap6_class_rec,
1649 #endif
1650
1651 #ifdef TT_CONFIG_CMAP_FORMAT_8
1652 &tt_cmap8_class_rec,
1653 #endif
1654
1655 #ifdef TT_CONFIG_CMAP_FORMAT_10
1656 &tt_cmap10_class_rec,
1657 #endif
1658
1659 #ifdef TT_CONFIG_CMAP_FORMAT_12
1660 &tt_cmap12_class_rec,
1661 #endif
1662
1663 NULL,
1664 };
1665
1666
1667 /* parse the `cmap' table and build the corresponding TT_CMap objects */
1668 /* in the current face */
1669 /* */
1670 FT_LOCAL_DEF( FT_Error )
1671 TT_Build_CMaps( TT_Face face )
1672 {
1673 FT_Byte* table = face->cmap_table;
1674 FT_Byte* limit = table + face->cmap_size;
1675 volatile FT_UInt num_cmaps;
1676 volatile FT_Byte* p = table;
1677
1678
1679 if ( p + 4 > limit )
1680 return FT_Err_Invalid_Table;
1681
1682 /* only recognize format 0 */
1683 if ( TT_NEXT_USHORT( p ) != 0 )
1684 {
1685 p -= 2;
1686 FT_ERROR(( "TT_Build_CMaps: unsupported `cmap' table format = %d\n",
1687 TT_PEEK_USHORT( p ) ));
1688 return FT_Err_Invalid_Table;
1689 }
1690
1691 num_cmaps = TT_NEXT_USHORT( p );
1692
1693 for ( ; num_cmaps > 0 && p + 8 <= limit; num_cmaps-- )
1694 {
1695 FT_CharMapRec charmap;
1696 FT_UInt32 offset;
1697
1698
1699 charmap.platform_id = TT_NEXT_USHORT( p );
1700 charmap.encoding_id = TT_NEXT_USHORT( p );
1701 charmap.face = FT_FACE( face );
1702 charmap.encoding = ft_encoding_none; /* will be filled later */
1703 offset = TT_NEXT_ULONG( p );
1704
1705 if ( offset && table + offset + 2 < limit )
1706 {
1707 FT_Byte* cmap = table + offset;
1708 FT_UInt format = TT_PEEK_USHORT( cmap );
1709 volatile const TT_CMap_Class* pclazz = tt_cmap_classes;
1710 TT_CMap_Class clazz;
1711
1712
1713 for ( ; *pclazz; pclazz++ )
1714 {
1715 clazz = *pclazz;
1716 if ( clazz->format == format )
1717 {
1718 volatile TT_ValidatorRec valid;
1719
1720
1721 ft_validator_init( FT_VALIDATOR( &valid ), cmap, limit,
1722 FT_VALIDATE_DEFAULT );
1723
1724 valid.num_glyphs = face->root.num_glyphs;
1725
1726 if ( ft_setjmp( FT_VALIDATOR( &valid )->jump_buffer ) == 0 )
1727 {
1728 /* validate this cmap sub-table */
1729 clazz->validate( cmap, FT_VALIDATOR( &valid ) );
1730 }
1731
1732 if ( valid.validator.error == 0 )
1733 (void)FT_CMap_New( (FT_CMap_Class)clazz, cmap, &charmap, NULL );
1734 else
1735 {
1736 FT_ERROR(( "TT_Build_CMaps:" ));
1737 FT_ERROR(( " broken cmap sub-table ignored!\n" ));
1738 }
1739 }
1740 }
1741 }
1742 }
1743
1744 return 0;
1745 }
1746
1747 #endif /* FT_CONFIG_OPTION_USE_CMAPS */
1748
1749
1750 /* END */
Mirror of AROS' Contrib svn.