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