XFA: merge patch from CL 815103002
[pdfium.git] / third_party / freetype / src / cff / cffload.c
1 /***************************************************************************/
2 /*                                                                         */
3 /*  cffload.c                                                              */
4 /*                                                                         */
5 /*    OpenType and CFF data/program tables loader (body).                  */
6 /*                                                                         */
7 /*  Copyright 1996-2014 by                                                 */
8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9 /*                                                                         */
10 /*  This file is part of the FreeType project, and may only be used,       */
11 /*  modified, and distributed under the terms of the FreeType project      */
12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
13 /*  this file you indicate that you have read the license and              */
14 /*  understand and accept it fully.                                        */
15 /*                                                                         */
16 /***************************************************************************/
17
18
19 #include <ft2build.h>
20 #include FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_OBJECTS_H
22 #include FT_INTERNAL_STREAM_H
23 #include FT_TRUETYPE_TAGS_H
24 #include FT_TYPE1_TABLES_H
25
26 #include "cffload.h"
27 #include "cffparse.h"
28
29 #include "cfferrs.h"
30
31
32 #if 1
33
34   static const FT_UShort  cff_isoadobe_charset[229] =
35   {
36       0,   1,   2,   3,   4,   5,   6,   7,
37       8,   9,  10,  11,  12,  13,  14,  15,
38      16,  17,  18,  19,  20,  21,  22,  23,
39      24,  25,  26,  27,  28,  29,  30,  31,
40      32,  33,  34,  35,  36,  37,  38,  39,
41      40,  41,  42,  43,  44,  45,  46,  47,
42      48,  49,  50,  51,  52,  53,  54,  55,
43      56,  57,  58,  59,  60,  61,  62,  63,
44      64,  65,  66,  67,  68,  69,  70,  71,
45      72,  73,  74,  75,  76,  77,  78,  79,
46      80,  81,  82,  83,  84,  85,  86,  87,
47      88,  89,  90,  91,  92,  93,  94,  95,
48      96,  97,  98,  99, 100, 101, 102, 103,
49     104, 105, 106, 107, 108, 109, 110, 111,
50     112, 113, 114, 115, 116, 117, 118, 119,
51     120, 121, 122, 123, 124, 125, 126, 127,
52     128, 129, 130, 131, 132, 133, 134, 135,
53     136, 137, 138, 139, 140, 141, 142, 143,
54     144, 145, 146, 147, 148, 149, 150, 151,
55     152, 153, 154, 155, 156, 157, 158, 159,
56     160, 161, 162, 163, 164, 165, 166, 167,
57     168, 169, 170, 171, 172, 173, 174, 175,
58     176, 177, 178, 179, 180, 181, 182, 183,
59     184, 185, 186, 187, 188, 189, 190, 191,
60     192, 193, 194, 195, 196, 197, 198, 199,
61     200, 201, 202, 203, 204, 205, 206, 207,
62     208, 209, 210, 211, 212, 213, 214, 215,
63     216, 217, 218, 219, 220, 221, 222, 223,
64     224, 225, 226, 227, 228
65   };
66
67   static const FT_UShort  cff_expert_charset[166] =
68   {
69       0,   1, 229, 230, 231, 232, 233, 234,
70     235, 236, 237, 238,  13,  14,  15,  99,
71     239, 240, 241, 242, 243, 244, 245, 246,
72     247, 248,  27,  28, 249, 250, 251, 252,
73     253, 254, 255, 256, 257, 258, 259, 260,
74     261, 262, 263, 264, 265, 266, 109, 110,
75     267, 268, 269, 270, 271, 272, 273, 274,
76     275, 276, 277, 278, 279, 280, 281, 282,
77     283, 284, 285, 286, 287, 288, 289, 290,
78     291, 292, 293, 294, 295, 296, 297, 298,
79     299, 300, 301, 302, 303, 304, 305, 306,
80     307, 308, 309, 310, 311, 312, 313, 314,
81     315, 316, 317, 318, 158, 155, 163, 319,
82     320, 321, 322, 323, 324, 325, 326, 150,
83     164, 169, 327, 328, 329, 330, 331, 332,
84     333, 334, 335, 336, 337, 338, 339, 340,
85     341, 342, 343, 344, 345, 346, 347, 348,
86     349, 350, 351, 352, 353, 354, 355, 356,
87     357, 358, 359, 360, 361, 362, 363, 364,
88     365, 366, 367, 368, 369, 370, 371, 372,
89     373, 374, 375, 376, 377, 378
90   };
91
92   static const FT_UShort  cff_expertsubset_charset[87] =
93   {
94       0,   1, 231, 232, 235, 236, 237, 238,
95      13,  14,  15,  99, 239, 240, 241, 242,
96     243, 244, 245, 246, 247, 248,  27,  28,
97     249, 250, 251, 253, 254, 255, 256, 257,
98     258, 259, 260, 261, 262, 263, 264, 265,
99     266, 109, 110, 267, 268, 269, 270, 272,
100     300, 301, 302, 305, 314, 315, 158, 155,
101     163, 320, 321, 322, 323, 324, 325, 326,
102     150, 164, 169, 327, 328, 329, 330, 331,
103     332, 333, 334, 335, 336, 337, 338, 339,
104     340, 341, 342, 343, 344, 345, 346
105   };
106
107   static const FT_UShort  cff_standard_encoding[256] =
108   {
109       0,   0,   0,   0,   0,   0,   0,   0,
110       0,   0,   0,   0,   0,   0,   0,   0,
111       0,   0,   0,   0,   0,   0,   0,   0,
112       0,   0,   0,   0,   0,   0,   0,   0,
113       1,   2,   3,   4,   5,   6,   7,   8,
114       9,  10,  11,  12,  13,  14,  15,  16,
115      17,  18,  19,  20,  21,  22,  23,  24,
116      25,  26,  27,  28,  29,  30,  31,  32,
117      33,  34,  35,  36,  37,  38,  39,  40,
118      41,  42,  43,  44,  45,  46,  47,  48,
119      49,  50,  51,  52,  53,  54,  55,  56,
120      57,  58,  59,  60,  61,  62,  63,  64,
121      65,  66,  67,  68,  69,  70,  71,  72,
122      73,  74,  75,  76,  77,  78,  79,  80,
123      81,  82,  83,  84,  85,  86,  87,  88,
124      89,  90,  91,  92,  93,  94,  95,   0,
125       0,   0,   0,   0,   0,   0,   0,   0,
126       0,   0,   0,   0,   0,   0,   0,   0,
127       0,   0,   0,   0,   0,   0,   0,   0,
128       0,   0,   0,   0,   0,   0,   0,   0,
129       0,  96,  97,  98,  99, 100, 101, 102,
130     103, 104, 105, 106, 107, 108, 109, 110,
131       0, 111, 112, 113, 114,   0, 115, 116,
132     117, 118, 119, 120, 121, 122,   0, 123,
133       0, 124, 125, 126, 127, 128, 129, 130,
134     131,   0, 132, 133,   0, 134, 135, 136,
135     137,   0,   0,   0,   0,   0,   0,   0,
136       0,   0,   0,   0,   0,   0,   0,   0,
137       0, 138,   0, 139,   0,   0,   0,   0,
138     140, 141, 142, 143,   0,   0,   0,   0,
139       0, 144,   0,   0,   0, 145,   0,   0,
140     146, 147, 148, 149,   0,   0,   0,   0
141   };
142
143   static const FT_UShort  cff_expert_encoding[256] =
144   {
145       0,   0,   0,   0,   0,   0,   0,   0,
146       0,   0,   0,   0,   0,   0,   0,   0,
147       0,   0,   0,   0,   0,   0,   0,   0,
148       0,   0,   0,   0,   0,   0,   0,   0,
149       1, 229, 230,   0, 231, 232, 233, 234,
150     235, 236, 237, 238,  13,  14,  15,  99,
151     239, 240, 241, 242, 243, 244, 245, 246,
152     247, 248,  27,  28, 249, 250, 251, 252,
153       0, 253, 254, 255, 256, 257,   0,   0,
154       0, 258,   0,   0, 259, 260, 261, 262,
155       0,   0, 263, 264, 265,   0, 266, 109,
156     110, 267, 268, 269,   0, 270, 271, 272,
157     273, 274, 275, 276, 277, 278, 279, 280,
158     281, 282, 283, 284, 285, 286, 287, 288,
159     289, 290, 291, 292, 293, 294, 295, 296,
160     297, 298, 299, 300, 301, 302, 303,   0,
161       0,   0,   0,   0,   0,   0,   0,   0,
162       0,   0,   0,   0,   0,   0,   0,   0,
163       0,   0,   0,   0,   0,   0,   0,   0,
164       0,   0,   0,   0,   0,   0,   0,   0,
165       0, 304, 305, 306,   0,   0, 307, 308,
166     309, 310, 311,   0, 312,   0,   0, 312,
167       0,   0, 314, 315,   0,   0, 316, 317,
168     318,   0,   0,   0, 158, 155, 163, 319,
169     320, 321, 322, 323, 324, 325,   0,   0,
170     326, 150, 164, 169, 327, 328, 329, 330,
171     331, 332, 333, 334, 335, 336, 337, 338,
172     339, 340, 341, 342, 343, 344, 345, 346,
173     347, 348, 349, 350, 351, 352, 353, 354,
174     355, 356, 357, 358, 359, 360, 361, 362,
175     363, 364, 365, 366, 367, 368, 369, 370,
176     371, 372, 373, 374, 375, 376, 377, 378
177   };
178
179 #endif /* 1 */
180
181
182   FT_LOCAL_DEF( FT_UShort )
183   cff_get_standard_encoding( FT_UInt  charcode )
184   {
185     return (FT_UShort)( charcode < 256 ? cff_standard_encoding[charcode]
186                                        : 0 );
187   }
188
189
190   /*************************************************************************/
191   /*                                                                       */
192   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
193   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
194   /* messages during execution.                                            */
195   /*                                                                       */
196 #undef  FT_COMPONENT
197 #define FT_COMPONENT  trace_cffload
198
199
200   /* read an offset from the index's stream current position */
201   static FT_ULong
202   cff_index_read_offset( CFF_Index  idx,
203                          FT_Error  *errorp )
204   {
205     FT_Error   error;
206     FT_Stream  stream = idx->stream;
207     FT_Byte    tmp[4];
208     FT_ULong   result = 0;
209
210
211     if ( !FT_STREAM_READ( tmp, idx->off_size ) )
212     {
213       FT_Int  nn;
214
215
216       for ( nn = 0; nn < idx->off_size; nn++ )
217         result = ( result << 8 ) | tmp[nn];
218     }
219
220     *errorp = error;
221     return result;
222   }
223
224
225   static FT_Error
226   cff_index_init( CFF_Index  idx,
227                   FT_Stream  stream,
228                   FT_Bool    load )
229   {
230     FT_Error   error;
231     FT_Memory  memory = stream->memory;
232     FT_UShort  count;
233
234
235     FT_MEM_ZERO( idx, sizeof ( *idx ) );
236
237     idx->stream = stream;
238     idx->start  = FT_STREAM_POS();
239     if ( !FT_READ_USHORT( count ) &&
240          count > 0                )
241     {
242       FT_Byte   offsize;
243       FT_ULong  size;
244
245
246       /* there is at least one element; read the offset size,           */
247       /* then access the offset table to compute the index's total size */
248       if ( FT_READ_BYTE( offsize ) )
249         goto Exit;
250
251       if ( offsize < 1 || offsize > 4 )
252       {
253         error = FT_THROW( Invalid_Table );
254         goto Exit;
255       }
256
257       idx->count    = count;
258       idx->off_size = offsize;
259       size          = (FT_ULong)( count + 1 ) * offsize;
260
261       idx->data_offset = idx->start + 3 + size;
262
263       if ( FT_STREAM_SKIP( size - offsize ) )
264         goto Exit;
265
266       size = cff_index_read_offset( idx, &error );
267       if ( error )
268         goto Exit;
269
270       if ( size == 0 )
271       {
272         error = FT_THROW( Invalid_Table );
273         goto Exit;
274       }
275
276       idx->data_size = --size;
277
278       if ( load )
279       {
280         /* load the data */
281         if ( FT_FRAME_EXTRACT( size, idx->bytes ) )
282           goto Exit;
283       }
284       else
285       {
286         /* skip the data */
287         if ( FT_STREAM_SKIP( size ) )
288           goto Exit;
289       }
290     }
291
292   Exit:
293     if ( error )
294       FT_FREE( idx->offsets );
295
296     return error;
297   }
298
299
300   static void
301   cff_index_done( CFF_Index  idx )
302   {
303     if ( idx->stream )
304     {
305       FT_Stream  stream = idx->stream;
306       FT_Memory  memory = stream->memory;
307
308
309       if ( idx->bytes )
310         FT_FRAME_RELEASE( idx->bytes );
311
312       FT_FREE( idx->offsets );
313       FT_MEM_ZERO( idx, sizeof ( *idx ) );
314     }
315   }
316
317
318   static FT_Error
319   cff_index_load_offsets( CFF_Index  idx )
320   {
321     FT_Error   error  = FT_Err_Ok;
322     FT_Stream  stream = idx->stream;
323     FT_Memory  memory = stream->memory;
324
325
326     if ( idx->count > 0 && idx->offsets == NULL )
327     {
328       FT_Byte    offsize = idx->off_size;
329       FT_ULong   data_size;
330       FT_Byte*   p;
331       FT_Byte*   p_end;
332       FT_ULong*  poff;
333
334
335       data_size = (FT_ULong)( idx->count + 1 ) * offsize;
336
337       if ( FT_NEW_ARRAY( idx->offsets, idx->count + 1 ) ||
338            FT_STREAM_SEEK( idx->start + 3 )             ||
339            FT_FRAME_ENTER( data_size )                  )
340         goto Exit;
341
342       poff   = idx->offsets;
343       p      = (FT_Byte*)stream->cursor;
344       p_end  = p + data_size;
345
346       switch ( offsize )
347       {
348       case 1:
349         for ( ; p < p_end; p++, poff++ )
350           poff[0] = p[0];
351         break;
352
353       case 2:
354         for ( ; p < p_end; p += 2, poff++ )
355           poff[0] = FT_PEEK_USHORT( p );
356         break;
357
358       case 3:
359         for ( ; p < p_end; p += 3, poff++ )
360           poff[0] = FT_PEEK_OFF3( p );
361         break;
362
363       default:
364         for ( ; p < p_end; p += 4, poff++ )
365           poff[0] = FT_PEEK_ULONG( p );
366       }
367
368       FT_FRAME_EXIT();
369     }
370
371   Exit:
372     if ( error )
373       FT_FREE( idx->offsets );
374
375     return error;
376   }
377
378
379   /* Allocate a table containing pointers to an index's elements. */
380   /* The `pool' argument makes this function convert the index    */
381   /* entries to C-style strings (this is, NULL-terminated).       */
382   static FT_Error
383   cff_index_get_pointers( CFF_Index   idx,
384                           FT_Byte***  table,
385                           FT_Byte**   pool )
386   {
387     FT_Error   error     = FT_Err_Ok;
388     FT_Memory  memory    = idx->stream->memory;
389
390     FT_Byte**  t         = NULL;
391     FT_Byte*   new_bytes = NULL;
392
393
394     *table = NULL;
395
396     if ( idx->offsets == NULL )
397     {
398       error = cff_index_load_offsets( idx );
399       if ( error )
400         goto Exit;
401     }
402
403     if ( idx->count > 0                                        &&
404          !FT_NEW_ARRAY( t, idx->count + 1 )                    &&
405          ( !pool || !FT_ALLOC( new_bytes,
406                                idx->data_size + idx->count ) ) )
407     {
408       FT_ULong  n, cur_offset;
409       FT_ULong  extra = 0;
410       FT_Byte*  org_bytes = idx->bytes;
411
412
413       /* at this point, `idx->offsets' can't be NULL */
414       cur_offset = idx->offsets[0] - 1;
415
416       /* sanity check */
417       if ( cur_offset != 0 )
418       {
419         FT_TRACE0(( "cff_index_get_pointers:"
420                     " invalid first offset value %d set to zero\n",
421                     cur_offset ));
422         cur_offset = 0;
423       }
424
425       if ( !pool )
426         t[0] = org_bytes + cur_offset;
427       else
428         t[0] = new_bytes + cur_offset;
429
430       for ( n = 1; n <= idx->count; n++ )
431       {
432         FT_ULong  next_offset = idx->offsets[n] - 1;
433
434
435         /* two sanity checks for invalid offset tables */
436         if ( next_offset < cur_offset )
437           next_offset = cur_offset;
438         else if ( next_offset > idx->data_size )
439           next_offset = idx->data_size;
440
441         if ( !pool )
442           t[n] = org_bytes + next_offset;
443         else
444         {
445           t[n] = new_bytes + next_offset + extra;
446
447           if ( next_offset != cur_offset )
448           {
449             FT_MEM_COPY( t[n - 1], org_bytes + cur_offset, t[n] - t[n - 1] );
450             t[n][0] = '\0';
451             t[n]   += 1;
452             extra++;
453           }
454         }
455
456         cur_offset = next_offset;
457       }
458       *table = t;
459
460       if ( pool )
461         *pool = new_bytes;
462     }
463
464   Exit:
465     return error;
466   }
467
468
469   FT_LOCAL_DEF( FT_Error )
470   cff_index_access_element( CFF_Index  idx,
471                             FT_UInt    element,
472                             FT_Byte**  pbytes,
473                             FT_ULong*  pbyte_len )
474   {
475     FT_Error  error = FT_Err_Ok;
476
477
478     if ( idx && idx->count > element )
479     {
480       /* compute start and end offsets */
481       FT_Stream  stream = idx->stream;
482       FT_ULong   off1, off2 = 0;
483
484
485       /* load offsets from file or the offset table */
486       if ( !idx->offsets )
487       {
488         FT_ULong  pos = element * idx->off_size;
489
490
491         if ( FT_STREAM_SEEK( idx->start + 3 + pos ) )
492           goto Exit;
493
494         off1 = cff_index_read_offset( idx, &error );
495         if ( error )
496           goto Exit;
497
498         if ( off1 != 0 )
499         {
500           do
501           {
502             element++;
503             off2 = cff_index_read_offset( idx, &error );
504           }
505           while ( off2 == 0 && element < idx->count );
506         }
507       }
508       else   /* use offsets table */
509       {
510         off1 = idx->offsets[element];
511         if ( off1 )
512         {
513           do
514           {
515             element++;
516             off2 = idx->offsets[element];
517
518           } while ( off2 == 0 && element < idx->count );
519         }
520       }
521
522       /* XXX: should check off2 does not exceed the end of this entry; */
523       /*      at present, only truncate off2 at the end of this stream */
524       if ( off2 > stream->size + 1                    ||
525            idx->data_offset > stream->size - off2 + 1 )
526       {
527         FT_ERROR(( "cff_index_access_element:"
528                    " offset to next entry (%d)"
529                    " exceeds the end of stream (%d)\n",
530                    off2, stream->size - idx->data_offset + 1 ));
531         off2 = stream->size - idx->data_offset + 1;
532       }
533
534       /* access element */
535       if ( off1 && off2 > off1 )
536       {
537         *pbyte_len = off2 - off1;
538
539         if ( idx->bytes )
540         {
541           /* this index was completely loaded in memory, that's easy */
542           *pbytes = idx->bytes + off1 - 1;
543         }
544         else
545         {
546           /* this index is still on disk/file, access it through a frame */
547           if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) ||
548                FT_FRAME_EXTRACT( off2 - off1, *pbytes )      )
549             goto Exit;
550         }
551       }
552       else
553       {
554         /* empty index element */
555         *pbytes    = 0;
556         *pbyte_len = 0;
557       }
558     }
559     else
560       error = FT_THROW( Invalid_Argument );
561
562   Exit:
563     return error;
564   }
565
566
567   FT_LOCAL_DEF( void )
568   cff_index_forget_element( CFF_Index  idx,
569                             FT_Byte**  pbytes )
570   {
571     if ( idx->bytes == 0 )
572     {
573       FT_Stream  stream = idx->stream;
574
575
576       FT_FRAME_RELEASE( *pbytes );
577     }
578   }
579
580
581   /* get an entry from Name INDEX */
582   FT_LOCAL_DEF( FT_String* )
583   cff_index_get_name( CFF_Font  font,
584                       FT_UInt   element )
585   {
586     CFF_Index   idx = &font->name_index;
587     FT_Memory   memory = idx->stream->memory;
588     FT_Byte*    bytes;
589     FT_ULong    byte_len;
590     FT_Error    error;
591     FT_String*  name = 0;
592
593
594     error = cff_index_access_element( idx, element, &bytes, &byte_len );
595     if ( error )
596       goto Exit;
597
598     if ( !FT_ALLOC( name, byte_len + 1 ) )
599     {
600       FT_MEM_COPY( name, bytes, byte_len );
601       name[byte_len] = 0;
602     }
603     cff_index_forget_element( idx, &bytes );
604
605   Exit:
606     return name;
607   }
608
609
610   /* get an entry from String INDEX */
611   FT_LOCAL_DEF( FT_String* )
612   cff_index_get_string( CFF_Font  font,
613                         FT_UInt   element )
614   {
615     return ( element < font->num_strings )
616              ? (FT_String*)font->strings[element]
617              : NULL;
618   }
619
620
621   FT_LOCAL_DEF( FT_String* )
622   cff_index_get_sid_string( CFF_Font  font,
623                             FT_UInt   sid )
624   {
625     /* value 0xFFFFU indicates a missing dictionary entry */
626     if ( sid == 0xFFFFU )
627       return NULL;
628
629     /* if it is not a standard string, return it */
630     if ( sid > 390 )
631       return cff_index_get_string( font, sid - 391 );
632
633     /* CID-keyed CFF fonts don't have glyph names */
634     if ( !font->psnames )
635       return NULL;
636
637     /* this is a standard string */
638     return (FT_String *)font->psnames->adobe_std_strings( sid );
639   }
640
641
642   /*************************************************************************/
643   /*************************************************************************/
644   /***                                                                   ***/
645   /***   FD Select table support                                         ***/
646   /***                                                                   ***/
647   /*************************************************************************/
648   /*************************************************************************/
649
650
651   static void
652   CFF_Done_FD_Select( CFF_FDSelect  fdselect,
653                       FT_Stream     stream )
654   {
655     if ( fdselect->data )
656       FT_FRAME_RELEASE( fdselect->data );
657
658     fdselect->data_size   = 0;
659     fdselect->format      = 0;
660     fdselect->range_count = 0;
661   }
662
663
664   static FT_Error
665   CFF_Load_FD_Select( CFF_FDSelect  fdselect,
666                       FT_UInt       num_glyphs,
667                       FT_Stream     stream,
668                       FT_ULong      offset )
669   {
670     FT_Error  error;
671     FT_Byte   format;
672     FT_UInt   num_ranges;
673
674
675     /* read format */
676     if ( FT_STREAM_SEEK( offset ) || FT_READ_BYTE( format ) )
677       goto Exit;
678
679     fdselect->format      = format;
680     fdselect->cache_count = 0;   /* clear cache */
681
682     switch ( format )
683     {
684     case 0:     /* format 0, that's simple */
685       fdselect->data_size = num_glyphs;
686       goto Load_Data;
687
688     case 3:     /* format 3, a tad more complex */
689       if ( FT_READ_USHORT( num_ranges ) )
690         goto Exit;
691
692       if ( !num_ranges )
693       {
694         FT_TRACE0(( "CFF_Load_FD_Select: empty FDSelect array\n" ));
695         error = FT_THROW( Invalid_File_Format );
696         goto Exit;
697       }
698
699       fdselect->data_size = num_ranges * 3 + 2;
700
701     Load_Data:
702       if ( FT_FRAME_EXTRACT( fdselect->data_size, fdselect->data ) )
703         goto Exit;
704       break;
705
706     default:    /* hmm... that's wrong */
707       error = FT_THROW( Invalid_File_Format );
708     }
709
710   Exit:
711     return error;
712   }
713
714
715   FT_LOCAL_DEF( FT_Byte )
716   cff_fd_select_get( CFF_FDSelect  fdselect,
717                      FT_UInt       glyph_index )
718   {
719     FT_Byte  fd = 0;
720
721
722     switch ( fdselect->format )
723     {
724     case 0:
725       fd = fdselect->data[glyph_index];
726       break;
727
728     case 3:
729       /* first, compare to the cache */
730       if ( (FT_UInt)( glyph_index - fdselect->cache_first ) <
731                         fdselect->cache_count )
732       {
733         fd = fdselect->cache_fd;
734         break;
735       }
736
737       /* then, look up the ranges array */
738       {
739         FT_Byte*  p       = fdselect->data;
740         FT_Byte*  p_limit = p + fdselect->data_size;
741         FT_Byte   fd2;
742         FT_UInt   first, limit;
743
744
745         first = FT_NEXT_USHORT( p );
746         do
747         {
748           if ( glyph_index < first )
749             break;
750
751           fd2   = *p++;
752           limit = FT_NEXT_USHORT( p );
753
754           if ( glyph_index < limit )
755           {
756             fd = fd2;
757
758             /* update cache */
759             fdselect->cache_first = first;
760             fdselect->cache_count = limit - first;
761             fdselect->cache_fd    = fd2;
762             break;
763           }
764           first = limit;
765
766         } while ( p < p_limit );
767       }
768       break;
769
770     default:
771       ;
772     }
773
774     return fd;
775   }
776
777
778   /*************************************************************************/
779   /*************************************************************************/
780   /***                                                                   ***/
781   /***   CFF font support                                                ***/
782   /***                                                                   ***/
783   /*************************************************************************/
784   /*************************************************************************/
785
786   static FT_Error
787   cff_charset_compute_cids( CFF_Charset  charset,
788                             FT_UInt      num_glyphs,
789                             FT_Memory    memory )
790   {
791     FT_Error   error   = FT_Err_Ok;
792     FT_UInt    i;
793     FT_Long    j;
794     FT_UShort  max_cid = 0;
795
796
797     if ( charset->max_cid > 0 )
798       goto Exit;
799
800     for ( i = 0; i < num_glyphs; i++ )
801     {
802       if ( charset->sids[i] > max_cid )
803         max_cid = charset->sids[i];
804     }
805
806     if ( FT_NEW_ARRAY( charset->cids, (FT_ULong)max_cid + 1 ) )
807       goto Exit;
808
809     /* When multiple GIDs map to the same CID, we choose the lowest */
810     /* GID.  This is not described in any spec, but it matches the  */
811     /* behaviour of recent Acroread versions.                       */
812     for ( j = num_glyphs - 1; j >= 0 ; j-- )
813       charset->cids[charset->sids[j]] = (FT_UShort)j;
814
815     charset->max_cid    = max_cid;
816     charset->num_glyphs = num_glyphs;
817
818   Exit:
819     return error;
820   }
821
822
823   FT_LOCAL_DEF( FT_UInt )
824   cff_charset_cid_to_gindex( CFF_Charset  charset,
825                              FT_UInt      cid )
826   {
827     FT_UInt  result = 0;
828
829
830     if ( cid <= charset->max_cid )
831       result = charset->cids[cid];
832
833     return result;
834   }
835
836
837   static void
838   cff_charset_free_cids( CFF_Charset  charset,
839                          FT_Memory    memory )
840   {
841     FT_FREE( charset->cids );
842     charset->max_cid = 0;
843   }
844
845
846   static void
847   cff_charset_done( CFF_Charset  charset,
848                     FT_Stream    stream )
849   {
850     FT_Memory  memory = stream->memory;
851
852
853     cff_charset_free_cids( charset, memory );
854
855     FT_FREE( charset->sids );
856     charset->format = 0;
857     charset->offset = 0;
858   }
859
860
861   static FT_Error
862   cff_charset_load( CFF_Charset  charset,
863                     FT_UInt      num_glyphs,
864                     FT_Stream    stream,
865                     FT_ULong     base_offset,
866                     FT_ULong     offset,
867                     FT_Bool      invert )
868   {
869     FT_Memory  memory = stream->memory;
870     FT_Error   error  = FT_Err_Ok;
871     FT_UShort  glyph_sid;
872
873
874     /* If the the offset is greater than 2, we have to parse the */
875     /* charset table.                                            */
876     if ( offset > 2 )
877     {
878       FT_UInt  j;
879
880
881       charset->offset = base_offset + offset;
882
883       /* Get the format of the table. */
884       if ( FT_STREAM_SEEK( charset->offset ) ||
885            FT_READ_BYTE( charset->format )   )
886         goto Exit;
887
888       /* Allocate memory for sids. */
889       if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
890         goto Exit;
891
892       /* assign the .notdef glyph */
893       charset->sids[0] = 0;
894
895       switch ( charset->format )
896       {
897       case 0:
898         if ( num_glyphs > 0 )
899         {
900           if ( FT_FRAME_ENTER( ( num_glyphs - 1 ) * 2 ) )
901             goto Exit;
902
903           for ( j = 1; j < num_glyphs; j++ )
904             charset->sids[j] = FT_GET_USHORT();
905
906           FT_FRAME_EXIT();
907         }
908         break;
909
910       case 1:
911       case 2:
912         {
913           FT_UInt  nleft;
914           FT_UInt  i;
915
916
917           j = 1;
918
919           while ( j < num_glyphs )
920           {
921             /* Read the first glyph sid of the range. */
922             if ( FT_READ_USHORT( glyph_sid ) )
923               goto Exit;
924
925             /* Read the number of glyphs in the range.  */
926             if ( charset->format == 2 )
927             {
928               if ( FT_READ_USHORT( nleft ) )
929                 goto Exit;
930             }
931             else
932             {
933               if ( FT_READ_BYTE( nleft ) )
934                 goto Exit;
935             }
936
937             /* try to rescue some of the SIDs if `nleft' is too large */
938             if ( glyph_sid > 0xFFFFL - nleft )
939             {
940               FT_ERROR(( "cff_charset_load: invalid SID range trimmed"
941                          " nleft=%d -> %d\n", nleft, 0xFFFFL - glyph_sid ));
942               nleft = ( FT_UInt )( 0xFFFFL - glyph_sid );
943             }
944
945             /* Fill in the range of sids -- `nleft + 1' glyphs. */
946             for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
947               charset->sids[j] = glyph_sid;
948           }
949         }
950         break;
951
952       default:
953         FT_ERROR(( "cff_charset_load: invalid table format\n" ));
954         error = FT_THROW( Invalid_File_Format );
955         goto Exit;
956       }
957     }
958     else
959     {
960       /* Parse default tables corresponding to offset == 0, 1, or 2.  */
961       /* CFF specification intimates the following:                   */
962       /*                                                              */
963       /* In order to use a predefined charset, the following must be  */
964       /* true: The charset constructed for the glyphs in the font's   */
965       /* charstrings dictionary must match the predefined charset in  */
966       /* the first num_glyphs.                                        */
967
968       charset->offset = offset;  /* record charset type */
969
970       switch ( (FT_UInt)offset )
971       {
972       case 0:
973         if ( num_glyphs > 229 )
974         {
975           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
976                      "predefined charset (Adobe ISO-Latin)\n" ));
977           error = FT_THROW( Invalid_File_Format );
978           goto Exit;
979         }
980
981         /* Allocate memory for sids. */
982         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
983           goto Exit;
984
985         /* Copy the predefined charset into the allocated memory. */
986         FT_ARRAY_COPY( charset->sids, cff_isoadobe_charset, num_glyphs );
987
988         break;
989
990       case 1:
991         if ( num_glyphs > 166 )
992         {
993           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
994                      "predefined charset (Adobe Expert)\n" ));
995           error = FT_THROW( Invalid_File_Format );
996           goto Exit;
997         }
998
999         /* Allocate memory for sids. */
1000         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
1001           goto Exit;
1002
1003         /* Copy the predefined charset into the allocated memory.     */
1004         FT_ARRAY_COPY( charset->sids, cff_expert_charset, num_glyphs );
1005
1006         break;
1007
1008       case 2:
1009         if ( num_glyphs > 87 )
1010         {
1011           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
1012                      "predefined charset (Adobe Expert Subset)\n" ));
1013           error = FT_THROW( Invalid_File_Format );
1014           goto Exit;
1015         }
1016
1017         /* Allocate memory for sids. */
1018         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
1019           goto Exit;
1020
1021         /* Copy the predefined charset into the allocated memory.     */
1022         FT_ARRAY_COPY( charset->sids, cff_expertsubset_charset, num_glyphs );
1023
1024         break;
1025
1026       default:
1027         error = FT_THROW( Invalid_File_Format );
1028         goto Exit;
1029       }
1030     }
1031
1032     /* we have to invert the `sids' array for subsetted CID-keyed fonts */
1033     if ( invert )
1034       error = cff_charset_compute_cids( charset, num_glyphs, memory );
1035
1036   Exit:
1037     /* Clean up if there was an error. */
1038     if ( error )
1039     {
1040       FT_FREE( charset->sids );
1041       FT_FREE( charset->cids );
1042       charset->format = 0;
1043       charset->offset = 0;
1044       charset->sids   = 0;
1045     }
1046
1047     return error;
1048   }
1049
1050
1051   static void
1052   cff_encoding_done( CFF_Encoding  encoding )
1053   {
1054     encoding->format = 0;
1055     encoding->offset = 0;
1056     encoding->count  = 0;
1057   }
1058
1059
1060   static FT_Error
1061   cff_encoding_load( CFF_Encoding  encoding,
1062                      CFF_Charset   charset,
1063                      FT_UInt       num_glyphs,
1064                      FT_Stream     stream,
1065                      FT_ULong      base_offset,
1066                      FT_ULong      offset )
1067   {
1068     FT_Error   error = FT_Err_Ok;
1069     FT_UInt    count;
1070     FT_UInt    j;
1071     FT_UShort  glyph_sid;
1072     FT_UInt    glyph_code;
1073
1074
1075     /* Check for charset->sids.  If we do not have this, we fail. */
1076     if ( !charset->sids )
1077     {
1078       error = FT_THROW( Invalid_File_Format );
1079       goto Exit;
1080     }
1081
1082     /* Zero out the code to gid/sid mappings. */
1083     for ( j = 0; j < 256; j++ )
1084     {
1085       encoding->sids [j] = 0;
1086       encoding->codes[j] = 0;
1087     }
1088
1089     /* Note: The encoding table in a CFF font is indexed by glyph index;  */
1090     /* the first encoded glyph index is 1.  Hence, we read the character  */
1091     /* code (`glyph_code') at index j and make the assignment:            */
1092     /*                                                                    */
1093     /*    encoding->codes[glyph_code] = j + 1                             */
1094     /*                                                                    */
1095     /* We also make the assignment:                                       */
1096     /*                                                                    */
1097     /*    encoding->sids[glyph_code] = charset->sids[j + 1]               */
1098     /*                                                                    */
1099     /* This gives us both a code to GID and a code to SID mapping.        */
1100
1101     if ( offset > 1 )
1102     {
1103       encoding->offset = base_offset + offset;
1104
1105       /* we need to parse the table to determine its size */
1106       if ( FT_STREAM_SEEK( encoding->offset ) ||
1107            FT_READ_BYTE( encoding->format )   ||
1108            FT_READ_BYTE( count )              )
1109         goto Exit;
1110
1111       switch ( encoding->format & 0x7F )
1112       {
1113       case 0:
1114         {
1115           FT_Byte*  p;
1116
1117
1118           /* By convention, GID 0 is always ".notdef" and is never */
1119           /* coded in the font.  Hence, the number of codes found  */
1120           /* in the table is `count+1'.                            */
1121           /*                                                       */
1122           encoding->count = count + 1;
1123
1124           if ( FT_FRAME_ENTER( count ) )
1125             goto Exit;
1126
1127           p = (FT_Byte*)stream->cursor;
1128
1129           for ( j = 1; j <= count; j++ )
1130           {
1131             glyph_code = *p++;
1132
1133             /* Make sure j is not too big. */
1134             if ( j < num_glyphs )
1135             {
1136               /* Assign code to GID mapping. */
1137               encoding->codes[glyph_code] = (FT_UShort)j;
1138
1139               /* Assign code to SID mapping. */
1140               encoding->sids[glyph_code] = charset->sids[j];
1141             }
1142           }
1143
1144           FT_FRAME_EXIT();
1145         }
1146         break;
1147
1148       case 1:
1149         {
1150           FT_UInt  nleft;
1151           FT_UInt  i = 1;
1152           FT_UInt  k;
1153
1154
1155           encoding->count = 0;
1156
1157           /* Parse the Format1 ranges. */
1158           for ( j = 0;  j < count; j++, i += nleft )
1159           {
1160             /* Read the first glyph code of the range. */
1161             if ( FT_READ_BYTE( glyph_code ) )
1162               goto Exit;
1163
1164             /* Read the number of codes in the range. */
1165             if ( FT_READ_BYTE( nleft ) )
1166               goto Exit;
1167
1168             /* Increment nleft, so we read `nleft + 1' codes/sids. */
1169             nleft++;
1170
1171             /* compute max number of character codes */
1172             if ( (FT_UInt)nleft > encoding->count )
1173               encoding->count = nleft;
1174
1175             /* Fill in the range of codes/sids. */
1176             for ( k = i; k < nleft + i; k++, glyph_code++ )
1177             {
1178               /* Make sure k is not too big. */
1179               if ( k < num_glyphs && glyph_code < 256 )
1180               {
1181                 /* Assign code to GID mapping. */
1182                 encoding->codes[glyph_code] = (FT_UShort)k;
1183
1184                 /* Assign code to SID mapping. */
1185                 encoding->sids[glyph_code] = charset->sids[k];
1186               }
1187             }
1188           }
1189
1190           /* simple check; one never knows what can be found in a font */
1191           if ( encoding->count > 256 )
1192             encoding->count = 256;
1193         }
1194         break;
1195
1196       default:
1197         FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1198         error = FT_THROW( Invalid_File_Format );
1199         goto Exit;
1200       }
1201
1202       /* Parse supplemental encodings, if any. */
1203       if ( encoding->format & 0x80 )
1204       {
1205         FT_UInt  gindex;
1206
1207
1208         /* count supplements */
1209         if ( FT_READ_BYTE( count ) )
1210           goto Exit;
1211
1212         for ( j = 0; j < count; j++ )
1213         {
1214           /* Read supplemental glyph code. */
1215           if ( FT_READ_BYTE( glyph_code ) )
1216             goto Exit;
1217
1218           /* Read the SID associated with this glyph code. */
1219           if ( FT_READ_USHORT( glyph_sid ) )
1220             goto Exit;
1221
1222           /* Assign code to SID mapping. */
1223           encoding->sids[glyph_code] = glyph_sid;
1224
1225           /* First, look up GID which has been assigned to */
1226           /* SID glyph_sid.                                */
1227           for ( gindex = 0; gindex < num_glyphs; gindex++ )
1228           {
1229             if ( charset->sids[gindex] == glyph_sid )
1230             {
1231               encoding->codes[glyph_code] = (FT_UShort)gindex;
1232               break;
1233             }
1234           }
1235         }
1236       }
1237     }
1238     else
1239     {
1240       /* We take into account the fact a CFF font can use a predefined */
1241       /* encoding without containing all of the glyphs encoded by this */
1242       /* encoding (see the note at the end of section 12 in the CFF    */
1243       /* specification).                                               */
1244
1245       switch ( (FT_UInt)offset )
1246       {
1247       case 0:
1248         /* First, copy the code to SID mapping. */
1249         FT_ARRAY_COPY( encoding->sids, cff_standard_encoding, 256 );
1250         goto Populate;
1251
1252       case 1:
1253         /* First, copy the code to SID mapping. */
1254         FT_ARRAY_COPY( encoding->sids, cff_expert_encoding, 256 );
1255
1256       Populate:
1257         /* Construct code to GID mapping from code to SID mapping */
1258         /* and charset.                                           */
1259
1260         encoding->count = 0;
1261
1262         error = cff_charset_compute_cids( charset, num_glyphs,
1263                                           stream->memory );
1264         if ( error )
1265           goto Exit;
1266
1267         for ( j = 0; j < 256; j++ )
1268         {
1269           FT_UInt  sid = encoding->sids[j];
1270           FT_UInt  gid = 0;
1271
1272
1273           if ( sid )
1274             gid = cff_charset_cid_to_gindex( charset, sid );
1275
1276           if ( gid != 0 )
1277           {
1278             encoding->codes[j] = (FT_UShort)gid;
1279             encoding->count    = j + 1;
1280           }
1281           else
1282           {
1283             encoding->codes[j] = 0;
1284             encoding->sids [j] = 0;
1285           }
1286         }
1287         break;
1288
1289       default:
1290         FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1291         error = FT_THROW( Invalid_File_Format );
1292         goto Exit;
1293       }
1294     }
1295
1296   Exit:
1297
1298     /* Clean up if there was an error. */
1299     return error;
1300   }
1301
1302
1303   static FT_Error
1304   cff_subfont_load( CFF_SubFont  font,
1305                     CFF_Index    idx,
1306                     FT_UInt      font_index,
1307                     FT_Stream    stream,
1308                     FT_ULong     base_offset,
1309                     FT_Library   library )
1310   {
1311     FT_Error         error;
1312     CFF_ParserRec    parser;
1313     FT_Byte*         dict = NULL;
1314     FT_ULong         dict_len;
1315     CFF_FontRecDict  top  = &font->font_dict;
1316     CFF_Private      priv = &font->private_dict;
1317
1318
1319     cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict, library );
1320
1321     /* set defaults */
1322     FT_MEM_ZERO( top, sizeof ( *top ) );
1323
1324     top->underline_position  = -( 100L << 16 );
1325     top->underline_thickness = 50L << 16;
1326     top->charstring_type     = 2;
1327     top->font_matrix.xx      = 0x10000L;
1328     top->font_matrix.yy      = 0x10000L;
1329     top->cid_count           = 8720;
1330
1331     /* we use the implementation specific SID value 0xFFFF to indicate */
1332     /* missing entries                                                 */
1333     top->version             = 0xFFFFU;
1334     top->notice              = 0xFFFFU;
1335     top->copyright           = 0xFFFFU;
1336     top->full_name           = 0xFFFFU;
1337     top->family_name         = 0xFFFFU;
1338     top->weight              = 0xFFFFU;
1339     top->embedded_postscript = 0xFFFFU;
1340
1341     top->cid_registry        = 0xFFFFU;
1342     top->cid_ordering        = 0xFFFFU;
1343     top->cid_font_name       = 0xFFFFU;
1344
1345     error = cff_index_access_element( idx, font_index, &dict, &dict_len );
1346     if ( !error )
1347     {
1348       FT_TRACE4(( " top dictionary:\n" ));
1349       error = cff_parser_run( &parser, dict, dict + dict_len );
1350     }
1351
1352     cff_index_forget_element( idx, &dict );
1353
1354     if ( error )
1355       goto Exit;
1356
1357     /* if it is a CID font, we stop there */
1358     if ( top->cid_registry != 0xFFFFU )
1359       goto Exit;
1360
1361     /* parse the private dictionary, if any */
1362     if ( top->private_offset && top->private_size )
1363     {
1364       /* set defaults */
1365       FT_MEM_ZERO( priv, sizeof ( *priv ) );
1366
1367       priv->blue_shift       = 7;
1368       priv->blue_fuzz        = 1;
1369       priv->lenIV            = -1;
1370       priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
1371       priv->blue_scale       = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
1372
1373       cff_parser_init( &parser, CFF_CODE_PRIVATE, priv, library );
1374
1375       if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) ||
1376            FT_FRAME_ENTER( font->font_dict.private_size )                 )
1377         goto Exit;
1378
1379       FT_TRACE4(( " private dictionary:\n" ));
1380       error = cff_parser_run( &parser,
1381                               (FT_Byte*)stream->cursor,
1382                               (FT_Byte*)stream->limit );
1383       FT_FRAME_EXIT();
1384       if ( error )
1385         goto Exit;
1386
1387       /* ensure that `num_blue_values' is even */
1388       priv->num_blue_values &= ~1;
1389     }
1390
1391     /* read the local subrs, if any */
1392     if ( priv->local_subrs_offset )
1393     {
1394       if ( FT_STREAM_SEEK( base_offset + top->private_offset +
1395                            priv->local_subrs_offset ) )
1396         goto Exit;
1397
1398       error = cff_index_init( &font->local_subrs_index, stream, 1 );
1399       if ( error )
1400         goto Exit;
1401
1402       error = cff_index_get_pointers( &font->local_subrs_index,
1403                                       &font->local_subrs, NULL );
1404       if ( error )
1405         goto Exit;
1406     }
1407
1408   Exit:
1409     return error;
1410   }
1411
1412
1413   static void
1414   cff_subfont_done( FT_Memory    memory,
1415                     CFF_SubFont  subfont )
1416   {
1417     if ( subfont )
1418     {
1419       cff_index_done( &subfont->local_subrs_index );
1420       FT_FREE( subfont->local_subrs );
1421     }
1422   }
1423
1424
1425   FT_LOCAL_DEF( FT_Error )
1426   cff_font_load( FT_Library library,
1427                  FT_Stream  stream,
1428                  FT_Int     face_index,
1429                  CFF_Font   font,
1430                  FT_Bool    pure_cff )
1431   {
1432     static const FT_Frame_Field  cff_header_fields[] =
1433     {
1434 #undef  FT_STRUCTURE
1435 #define FT_STRUCTURE  CFF_FontRec
1436
1437       FT_FRAME_START( 4 ),
1438         FT_FRAME_BYTE( version_major ),
1439         FT_FRAME_BYTE( version_minor ),
1440         FT_FRAME_BYTE( header_size ),
1441         FT_FRAME_BYTE( absolute_offsize ),
1442       FT_FRAME_END
1443     };
1444
1445     FT_Error         error;
1446     FT_Memory        memory = stream->memory;
1447     FT_ULong         base_offset;
1448     CFF_FontRecDict  dict;
1449     CFF_IndexRec     string_index;
1450     FT_Int           subfont_index;
1451
1452
1453     FT_ZERO( font );
1454     FT_ZERO( &string_index );
1455
1456     font->stream = stream;
1457     font->memory = memory;
1458     dict         = &font->top_font.font_dict;
1459     base_offset  = FT_STREAM_POS();
1460
1461     /* read CFF font header */
1462     if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )
1463       goto Exit;
1464
1465     /* check format */
1466     if ( font->version_major   != 1 ||
1467          font->header_size      < 4 ||
1468          font->absolute_offsize > 4 )
1469     {
1470       FT_TRACE2(( "  not a CFF font header\n" ));
1471       error = FT_THROW( Unknown_File_Format );
1472       goto Exit;
1473     }
1474
1475     /* skip the rest of the header */
1476     if ( FT_STREAM_SKIP( font->header_size - 4 ) )
1477       goto Exit;
1478
1479     /* read the name, top dict, string and global subrs index */
1480     if ( FT_SET_ERROR( cff_index_init( &font->name_index,
1481                                        stream, 0 ) )                  ||
1482          FT_SET_ERROR( cff_index_init( &font->font_dict_index,
1483                                        stream, 0 ) )                  ||
1484          FT_SET_ERROR( cff_index_init( &string_index,
1485                                        stream, 1 ) )                  ||
1486          FT_SET_ERROR( cff_index_init( &font->global_subrs_index,
1487                                        stream, 1 ) )                  ||
1488          FT_SET_ERROR( cff_index_get_pointers( &string_index,
1489                                                &font->strings,
1490                                                &font->string_pool ) ) )
1491       goto Exit;
1492
1493     font->num_strings = string_index.count;
1494
1495     if ( pure_cff )
1496     {
1497       /* well, we don't really forget the `disabled' fonts... */
1498       subfont_index = face_index;
1499
1500       if ( subfont_index >= (FT_Int)font->name_index.count )
1501       {
1502         FT_ERROR(( "cff_font_load:"
1503                    " invalid subfont index for pure CFF font (%d)\n",
1504                    subfont_index ));
1505         error = FT_THROW( Invalid_Argument );
1506         goto Exit;
1507       }
1508
1509       font->num_faces = font->name_index.count;
1510     }
1511     else
1512     {
1513       subfont_index = 0;
1514
1515       if ( font->name_index.count > 1 )
1516       {
1517         FT_ERROR(( "cff_font_load:"
1518                    " invalid CFF font with multiple subfonts\n"
1519                    "              "
1520                    " in SFNT wrapper\n" ));
1521         error = FT_THROW( Invalid_File_Format );
1522         goto Exit;
1523       }
1524     }
1525
1526     /* in case of a font format check, simply exit now */
1527     if ( face_index < 0 )
1528       goto Exit;
1529
1530     /* now, parse the top-level font dictionary */
1531     FT_TRACE4(( "parsing top-level\n" ));
1532     error = cff_subfont_load( &font->top_font,
1533                               &font->font_dict_index,
1534                               subfont_index,
1535                               stream,
1536                               base_offset,
1537                               library );
1538     if ( error )
1539       goto Exit;
1540
1541     if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )
1542       goto Exit;
1543
1544     error = cff_index_init( &font->charstrings_index, stream, 0 );
1545     if ( error )
1546       goto Exit;
1547
1548     /* now, check for a CID font */
1549     if ( dict->cid_registry != 0xFFFFU )
1550     {
1551       CFF_IndexRec  fd_index;
1552       CFF_SubFont   sub = NULL;
1553       FT_UInt       idx;
1554
1555
1556       /* this is a CID-keyed font, we must now allocate a table of */
1557       /* sub-fonts, then load each of them separately              */
1558       if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) )
1559         goto Exit;
1560
1561       error = cff_index_init( &fd_index, stream, 0 );
1562       if ( error )
1563         goto Exit;
1564
1565       if ( fd_index.count > CFF_MAX_CID_FONTS )
1566       {
1567         FT_TRACE0(( "cff_font_load: FD array too large in CID font\n" ));
1568         goto Fail_CID;
1569       }
1570
1571       /* allocate & read each font dict independently */
1572       font->num_subfonts = fd_index.count;
1573       if ( FT_NEW_ARRAY( sub, fd_index.count ) )
1574         goto Fail_CID;
1575
1576       /* set up pointer table */
1577       for ( idx = 0; idx < fd_index.count; idx++ )
1578         font->subfonts[idx] = sub + idx;
1579
1580       /* now load each subfont independently */
1581       for ( idx = 0; idx < fd_index.count; idx++ )
1582       {
1583         sub = font->subfonts[idx];
1584         FT_TRACE4(( "parsing subfont %u\n", idx ));
1585         error = cff_subfont_load( sub, &fd_index, idx,
1586                                   stream, base_offset, library );
1587         if ( error )
1588           goto Fail_CID;
1589       }
1590
1591       /* now load the FD Select array */
1592       error = CFF_Load_FD_Select( &font->fd_select,
1593                                   font->charstrings_index.count,
1594                                   stream,
1595                                   base_offset + dict->cid_fd_select_offset );
1596
1597     Fail_CID:
1598       cff_index_done( &fd_index );
1599
1600       if ( error )
1601         goto Exit;
1602     }
1603     else
1604       font->num_subfonts = 0;
1605
1606     /* read the charstrings index now */
1607     if ( dict->charstrings_offset == 0 )
1608     {
1609       FT_ERROR(( "cff_font_load: no charstrings offset\n" ));
1610       error = FT_THROW( Invalid_File_Format );
1611       goto Exit;
1612     }
1613
1614     font->num_glyphs = font->charstrings_index.count;
1615
1616     error = cff_index_get_pointers( &font->global_subrs_index,
1617                                     &font->global_subrs, NULL );
1618
1619     if ( error )
1620       goto Exit;
1621
1622     /* read the Charset and Encoding tables if available */
1623     if ( font->num_glyphs > 0 )
1624     {
1625       FT_Bool  invert = FT_BOOL( dict->cid_registry != 0xFFFFU && pure_cff );
1626
1627
1628       error = cff_charset_load( &font->charset, font->num_glyphs, stream,
1629                                 base_offset, dict->charset_offset, invert );
1630       if ( error )
1631         goto Exit;
1632
1633       /* CID-keyed CFFs don't have an encoding */
1634       if ( dict->cid_registry == 0xFFFFU )
1635       {
1636         error = cff_encoding_load( &font->encoding,
1637                                    &font->charset,
1638                                    font->num_glyphs,
1639                                    stream,
1640                                    base_offset,
1641                                    dict->encoding_offset );
1642         if ( error )
1643           goto Exit;
1644       }
1645     }
1646
1647     /* get the font name (/CIDFontName for CID-keyed fonts, */
1648     /* /FontName otherwise)                                 */
1649     font->font_name = cff_index_get_name( font, subfont_index );
1650
1651   Exit:
1652     cff_index_done( &string_index );
1653
1654     return error;
1655   }
1656
1657
1658   FT_LOCAL_DEF( void )
1659   cff_font_done( CFF_Font  font )
1660   {
1661     FT_Memory  memory = font->memory;
1662     FT_UInt    idx;
1663
1664
1665     cff_index_done( &font->global_subrs_index );
1666     cff_index_done( &font->font_dict_index );
1667     cff_index_done( &font->name_index );
1668     cff_index_done( &font->charstrings_index );
1669
1670     /* release font dictionaries, but only if working with */
1671     /* a CID keyed CFF font                                */
1672     if ( font->num_subfonts > 0 )
1673     {
1674       for ( idx = 0; idx < font->num_subfonts; idx++ )
1675         cff_subfont_done( memory, font->subfonts[idx] );
1676
1677       /* the subfonts array has been allocated as a single block */
1678       FT_FREE( font->subfonts[0] );
1679     }
1680
1681     cff_encoding_done( &font->encoding );
1682     cff_charset_done( &font->charset, font->stream );
1683
1684     cff_subfont_done( memory, &font->top_font );
1685
1686     CFF_Done_FD_Select( &font->fd_select, font->stream );
1687
1688     FT_FREE( font->font_info );
1689
1690     FT_FREE( font->font_name );
1691     FT_FREE( font->global_subrs );
1692     FT_FREE( font->strings );
1693     FT_FREE( font->string_pool );
1694
1695     if ( font->cf2_instance.finalizer )
1696     {
1697       font->cf2_instance.finalizer( font->cf2_instance.data );
1698       FT_FREE( font->cf2_instance.data );
1699     }
1700   }
1701
1702
1703 /* END */