src/cff/cffload.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  cffload.c                                                              */
   4 /*                                                                         */
   5 /*    OpenType and CFF data/program tables loader (body).                  */
   6 /*                                                                         */
   7 /*  Copyright 1996-2011 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 = CFF_Err_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 = CFF_Err_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  = CFF_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     = CFF_Err_Ok;
 388     FT_Memory  memory    = idx->stream->memory;
 389     FT_Byte**  t = NULL;
 390     FT_Byte*   new_bytes = NULL;
 391
 392
 393     *table = NULL;
 394
 395     if ( idx->offsets == NULL )
 396     {
 397       error = cff_index_load_offsets( idx );
 398       if ( error )
 399         goto Exit;
 400     }
 401
 402     if ( idx->count > 0                                        &&
 403          !FT_NEW_ARRAY( t, idx->count + 1 )                    &&
 404          ( !pool || !FT_ALLOC( new_bytes,
 405                                idx->data_size + idx->count ) ) )
 406     {
 407       FT_ULong  n, cur_offset;
 408       FT_ULong  extra = 0;
 409       FT_Byte*  org_bytes = idx->bytes;
 410
 411
 412       /* at this point, `idx->offsets' can't be NULL */
 413       cur_offset = idx->offsets[0] - 1;
 414
 415       /* sanity check */
 416       if ( cur_offset >= idx->data_size )
 417       {
 418         FT_TRACE0(( "cff_index_get_pointers:"
 419                     " invalid first offset value %d set to zero\n",
 420                     cur_offset ));
 421         cur_offset = 0;
 422       }
 423
 424       if ( !pool )
 425         t[0] = org_bytes + cur_offset;
 426       else
 427         t[0] = new_bytes + cur_offset;
 428
 429       for ( n = 1; n <= idx->count; n++ )
 430       {
 431         FT_ULong  next_offset = idx->offsets[n] - 1;
 432
 433
 434         /* empty slot + two sanity checks for invalid offset tables */
 435         if ( next_offset == 0                                    ||
 436              next_offset < cur_offset                            ||
 437              ( next_offset >= idx->data_size && n < idx->count ) )
 438           next_offset = cur_offset;
 439
 440         if ( !pool )
 441           t[n] = org_bytes + next_offset;
 442         else
 443         {
 444           t[n] = new_bytes + next_offset + extra;
 445
 446           if ( next_offset != cur_offset )
 447           {
 448             FT_MEM_COPY( t[n - 1], org_bytes + cur_offset, t[n] - t[n - 1] );
 449             t[n][0] = '\0';
 450             t[n]   += 1;
 451             extra++;
 452           }
 453         }
 454
 455         cur_offset = next_offset;
 456       }
 457       *table = t;
 458
 459       if ( pool )
 460         *pool = new_bytes;
 461     }
 462
 463   Exit:
 464     return error;
 465   }
 466
 467
 468   FT_LOCAL_DEF( FT_Error )
 469   cff_index_access_element( CFF_Index  idx,
 470                             FT_UInt    element,
 471                             FT_Byte**  pbytes,
 472                             FT_ULong*  pbyte_len )
 473   {
 474     FT_Error  error = CFF_Err_Ok;
 475
 476
 477     if ( idx && idx->count > element )
 478     {
 479       /* compute start and end offsets */
 480       FT_Stream  stream = idx->stream;
 481       FT_ULong   off1, off2 = 0;
 482
 483
 484       /* load offsets from file or the offset table */
 485       if ( !idx->offsets )
 486       {
 487         FT_ULong  pos = element * idx->off_size;
 488
 489
 490         if ( FT_STREAM_SEEK( idx->start + 3 + pos ) )
 491           goto Exit;
 492
 493         off1 = cff_index_read_offset( idx, &error );
 494         if ( error )
 495           goto Exit;
 496
 497         if ( off1 != 0 )
 498         {
 499           do
 500           {
 501             element++;
 502             off2 = cff_index_read_offset( idx, &error );
 503           }
 504           while ( off2 == 0 && element < idx->count );
 505         }
 506       }
 507       else   /* use offsets table */
 508       {
 509         off1 = idx->offsets[element];
 510         if ( off1 )
 511         {
 512           do
 513           {
 514             element++;
 515             off2 = idx->offsets[element];
 516
 517           } while ( off2 == 0 && element < idx->count );
 518         }
 519       }
 520
 521       /* XXX: should check off2 does not exceed the end of this entry; */
 522       /*      at present, only truncate off2 at the end of this stream */
 523       if ( off2 > stream->size + 1                    ||
 524            idx->data_offset > stream->size - off2 + 1 )
 525       {
 526         FT_ERROR(( "cff_index_access_element:"
 527                    " offset to next entry (%d)"
 528                    " exceeds the end of stream (%d)\n",
 529                    off2, stream->size - idx->data_offset + 1 ));
 530         off2 = stream->size - idx->data_offset + 1;
 531       }
 532
 533       /* access element */
 534       if ( off1 && off2 > off1 )
 535       {
 536         *pbyte_len = off2 - off1;
 537
 538         if ( idx->bytes )
 539         {
 540           /* this index was completely loaded in memory, that's easy */
 541           *pbytes = idx->bytes + off1 - 1;
 542         }
 543         else
 544         {
 545           /* this index is still on disk/file, access it through a frame */
 546           if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) ||
 547                FT_FRAME_EXTRACT( off2 - off1, *pbytes )      )
 548             goto Exit;
 549         }
 550       }
 551       else
 552       {
 553         /* empty index element */
 554         *pbytes    = 0;
 555         *pbyte_len = 0;
 556       }
 557     }
 558     else
 559       error = CFF_Err_Invalid_Argument;
 560
 561   Exit:
 562     return error;
 563   }
 564
 565
 566   FT_LOCAL_DEF( void )
 567   cff_index_forget_element( CFF_Index  idx,
 568                             FT_Byte**  pbytes )
 569   {
 570     if ( idx->bytes == 0 )
 571     {
 572       FT_Stream  stream = idx->stream;
 573
 574
 575       FT_FRAME_RELEASE( *pbytes );
 576     }
 577   }
 578
 579
 580   /* get an entry from Name INDEX */
 581   FT_LOCAL_DEF( FT_String* )
 582   cff_index_get_name( CFF_Font  font,
 583                       FT_UInt   element )
 584   {
 585     CFF_Index   idx = &font->name_index;
 586     FT_Memory   memory = idx->stream->memory;
 587     FT_Byte*    bytes;
 588     FT_ULong    byte_len;
 589     FT_Error    error;
 590     FT_String*  name = 0;
 591
 592
 593     error = cff_index_access_element( idx, element, &bytes, &byte_len );
 594     if ( error )
 595       goto Exit;
 596
 597     if ( !FT_ALLOC( name, byte_len + 1 ) )
 598     {
 599       FT_MEM_COPY( name, bytes, byte_len );
 600       name[byte_len] = 0;
 601     }
 602     cff_index_forget_element( idx, &bytes );
 603
 604   Exit:
 605     return name;
 606   }
 607
 608
 609   /* get an entry from String INDEX */
 610   FT_LOCAL_DEF( FT_String* )
 611   cff_index_get_string( CFF_Font  font,
 612                         FT_UInt   element )
 613   {
 614     return ( element < font->num_strings )
 615              ? (FT_String*)font->strings[element]
 616              : NULL;
 617   }
 618
 619
 620   FT_LOCAL_DEF( FT_String* )
 621   cff_index_get_sid_string( CFF_Font  font,
 622                             FT_UInt   sid )
 623   {
 624     /* value 0xFFFFU indicates a missing dictionary entry */
 625     if ( sid == 0xFFFFU )
 626       return NULL;
 627
 628     /* if it is not a standard string, return it */
 629     if ( sid > 390 )
 630       return cff_index_get_string( font, sid - 391 );
 631
 632     /* CID-keyed CFF fonts don't have glyph names */
 633     if ( !font->psnames )
 634       return NULL;
 635
 636     /* this is a standard string */
 637     return (FT_String *)font->psnames->adobe_std_strings( sid );
 638   }
 639
 640
 641   /*************************************************************************/
 642   /*************************************************************************/
 643   /***                                                                   ***/
 644   /***   FD Select table support                                         ***/
 645   /***                                                                   ***/
 646   /*************************************************************************/
 647   /*************************************************************************/
 648
 649
 650   static void
 651   CFF_Done_FD_Select( CFF_FDSelect  fdselect,
 652                       FT_Stream     stream )
 653   {
 654     if ( fdselect->data )
 655       FT_FRAME_RELEASE( fdselect->data );
 656
 657     fdselect->data_size   = 0;
 658     fdselect->format      = 0;
 659     fdselect->range_count = 0;
 660   }
 661
 662
 663   static FT_Error
 664   CFF_Load_FD_Select( CFF_FDSelect  fdselect,
 665                       FT_UInt       num_glyphs,
 666                       FT_Stream     stream,
 667                       FT_ULong      offset )
 668   {
 669     FT_Error  error;
 670     FT_Byte   format;
 671     FT_UInt   num_ranges;
 672
 673
 674     /* read format */
 675     if ( FT_STREAM_SEEK( offset ) || FT_READ_BYTE( format ) )
 676       goto Exit;
 677
 678     fdselect->format      = format;
 679     fdselect->cache_count = 0;   /* clear cache */
 680
 681     switch ( format )
 682     {
 683     case 0:     /* format 0, that's simple */
 684       fdselect->data_size = num_glyphs;
 685       goto Load_Data;
 686
 687     case 3:     /* format 3, a tad more complex */
 688       if ( FT_READ_USHORT( num_ranges ) )
 689         goto Exit;
 690
 691       fdselect->data_size = num_ranges * 3 + 2;
 692
 693     Load_Data:
 694       if ( FT_FRAME_EXTRACT( fdselect->data_size, fdselect->data ) )
 695         goto Exit;
 696       break;
 697
 698     default:    /* hmm... that's wrong */
 699       error = CFF_Err_Invalid_File_Format;
 700     }
 701
 702   Exit:
 703     return error;
 704   }
 705
 706
 707   FT_LOCAL_DEF( FT_Byte )
 708   cff_fd_select_get( CFF_FDSelect  fdselect,
 709                      FT_UInt       glyph_index )
 710   {
 711     FT_Byte  fd = 0;
 712
 713
 714     switch ( fdselect->format )
 715     {
 716     case 0:
 717       fd = fdselect->data[glyph_index];
 718       break;
 719
 720     case 3:
 721       /* first, compare to cache */
 722       if ( (FT_UInt)( glyph_index - fdselect->cache_first ) <
 723                         fdselect->cache_count )
 724       {
 725         fd = fdselect->cache_fd;
 726         break;
 727       }
 728
 729       /* then, lookup the ranges array */
 730       {
 731         FT_Byte*  p       = fdselect->data;
 732         FT_Byte*  p_limit = p + fdselect->data_size;
 733         FT_Byte   fd2;
 734         FT_UInt   first, limit;
 735
 736
 737         first = FT_NEXT_USHORT( p );
 738         do
 739         {
 740           if ( glyph_index < first )
 741             break;
 742
 743           fd2   = *p++;
 744           limit = FT_NEXT_USHORT( p );
 745
 746           if ( glyph_index < limit )
 747           {
 748             fd = fd2;
 749
 750             /* update cache */
 751             fdselect->cache_first = first;
 752             fdselect->cache_count = limit-first;
 753             fdselect->cache_fd    = fd2;
 754             break;
 755           }
 756           first = limit;
 757
 758         } while ( p < p_limit );
 759       }
 760       break;
 761
 762     default:
 763       ;
 764     }
 765
 766     return fd;
 767   }
 768
 769
 770   /*************************************************************************/
 771   /*************************************************************************/
 772   /***                                                                   ***/
 773   /***   CFF font support                                                ***/
 774   /***                                                                   ***/
 775   /*************************************************************************/
 776   /*************************************************************************/
 777
 778   static FT_Error
 779   cff_charset_compute_cids( CFF_Charset  charset,
 780                             FT_UInt      num_glyphs,
 781                             FT_Memory    memory )
 782   {
 783     FT_Error   error   = CFF_Err_Ok;
 784     FT_UInt    i;
 785     FT_Long    j;
 786     FT_UShort  max_cid = 0;
 787
 788
 789     if ( charset->max_cid > 0 )
 790       goto Exit;
 791
 792     for ( i = 0; i < num_glyphs; i++ )
 793     {
 794       if ( charset->sids[i] > max_cid )
 795         max_cid = charset->sids[i];
 796     }
 797
 798     if ( FT_NEW_ARRAY( charset->cids, (FT_ULong)max_cid + 1 ) )
 799       goto Exit;
 800
 801     /* When multiple GIDs map to the same CID, we choose the lowest */
 802     /* GID.  This is not described in any spec, but it matches the  */
 803     /* behaviour of recent Acroread versions.                       */
 804     for ( j = num_glyphs - 1; j >= 0 ; j-- )
 805       charset->cids[charset->sids[j]] = (FT_UShort)j;
 806
 807     charset->max_cid    = max_cid;
 808     charset->num_glyphs = num_glyphs;
 809
 810   Exit:
 811     return error;
 812   }
 813
 814
 815   FT_LOCAL_DEF( FT_UInt )
 816   cff_charset_cid_to_gindex( CFF_Charset  charset,
 817                              FT_UInt      cid )
 818   {
 819     FT_UInt  result = 0;
 820
 821
 822     if ( cid <= charset->max_cid )
 823       result = charset->cids[cid];
 824
 825     return result;
 826   }
 827
 828
 829   static void
 830   cff_charset_free_cids( CFF_Charset  charset,
 831                          FT_Memory    memory )
 832   {
 833     FT_FREE( charset->cids );
 834     charset->max_cid = 0;
 835   }
 836
 837
 838   static void
 839   cff_charset_done( CFF_Charset  charset,
 840                     FT_Stream    stream )
 841   {
 842     FT_Memory  memory = stream->memory;
 843
 844
 845     cff_charset_free_cids( charset, memory );
 846
 847     FT_FREE( charset->sids );
 848     charset->format = 0;
 849     charset->offset = 0;
 850   }
 851
 852
 853   static FT_Error
 854   cff_charset_load( CFF_Charset  charset,
 855                     FT_UInt      num_glyphs,
 856                     FT_Stream    stream,
 857                     FT_ULong     base_offset,
 858                     FT_ULong     offset,
 859                     FT_Bool      invert )
 860   {
 861     FT_Memory  memory = stream->memory;
 862     FT_Error   error  = CFF_Err_Ok;
 863     FT_UShort  glyph_sid;
 864
 865
 866     /* If the the offset is greater than 2, we have to parse the */
 867     /* charset table.                                            */
 868     if ( offset > 2 )
 869     {
 870       FT_UInt  j;
 871
 872
 873       charset->offset = base_offset + offset;
 874
 875       /* Get the format of the table. */
 876       if ( FT_STREAM_SEEK( charset->offset ) ||
 877            FT_READ_BYTE( charset->format )   )
 878         goto Exit;
 879
 880       /* Allocate memory for sids. */
 881       if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
 882         goto Exit;
 883
 884       /* assign the .notdef glyph */
 885       charset->sids[0] = 0;
 886
 887       switch ( charset->format )
 888       {
 889       case 0:
 890         if ( num_glyphs > 0 )
 891         {
 892           if ( FT_FRAME_ENTER( ( num_glyphs - 1 ) * 2 ) )
 893             goto Exit;
 894
 895           for ( j = 1; j < num_glyphs; j++ )
 896             charset->sids[j] = FT_GET_USHORT();
 897
 898           FT_FRAME_EXIT();
 899         }
 900         break;
 901
 902       case 1:
 903       case 2:
 904         {
 905           FT_UInt  nleft;
 906           FT_UInt  i;
 907
 908
 909           j = 1;
 910
 911           while ( j < num_glyphs )
 912           {
 913             /* Read the first glyph sid of the range. */
 914             if ( FT_READ_USHORT( glyph_sid ) )
 915               goto Exit;
 916
 917             /* Read the number of glyphs in the range.  */
 918             if ( charset->format == 2 )
 919             {
 920               if ( FT_READ_USHORT( nleft ) )
 921                 goto Exit;
 922             }
 923             else
 924             {
 925               if ( FT_READ_BYTE( nleft ) )
 926                 goto Exit;
 927             }
 928
 929             /* try to rescue some of the SIDs if `nleft' is too large */
 930             if ( glyph_sid > 0xFFFFL - nleft )
 931             {
 932               FT_ERROR(( "cff_charset_load: invalid SID range trimmed"
 933                          " nleft=%d -> %d\n", nleft, 0xFFFFL - glyph_sid ));
 934               nleft = ( FT_UInt )( 0xFFFFL - glyph_sid );
 935             }
 936
 937             /* Fill in the range of sids -- `nleft + 1' glyphs. */
 938             for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
 939               charset->sids[j] = glyph_sid;
 940           }
 941         }
 942         break;
 943
 944       default:
 945         FT_ERROR(( "cff_charset_load: invalid table format\n" ));
 946         error = CFF_Err_Invalid_File_Format;
 947         goto Exit;
 948       }
 949     }
 950     else
 951     {
 952       /* Parse default tables corresponding to offset == 0, 1, or 2.  */
 953       /* CFF specification intimates the following:                   */
 954       /*                                                              */
 955       /* In order to use a predefined charset, the following must be  */
 956       /* true: The charset constructed for the glyphs in the font's   */
 957       /* charstrings dictionary must match the predefined charset in  */
 958       /* the first num_glyphs.                                        */
 959
 960       charset->offset = offset;  /* record charset type */
 961
 962       switch ( (FT_UInt)offset )
 963       {
 964       case 0:
 965         if ( num_glyphs > 229 )
 966         {
 967           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
 968                      "predefined charset (Adobe ISO-Latin)\n" ));
 969           error = CFF_Err_Invalid_File_Format;
 970           goto Exit;
 971         }
 972
 973         /* Allocate memory for sids. */
 974         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
 975           goto Exit;
 976
 977         /* Copy the predefined charset into the allocated memory. */
 978         FT_ARRAY_COPY( charset->sids, cff_isoadobe_charset, num_glyphs );
 979
 980         break;
 981
 982       case 1:
 983         if ( num_glyphs > 166 )
 984         {
 985           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
 986                      "predefined charset (Adobe Expert)\n" ));
 987           error = CFF_Err_Invalid_File_Format;
 988           goto Exit;
 989         }
 990
 991         /* Allocate memory for sids. */
 992         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
 993           goto Exit;
 994
 995         /* Copy the predefined charset into the allocated memory.     */
 996         FT_ARRAY_COPY( charset->sids, cff_expert_charset, num_glyphs );
 997
 998         break;
 999
1000       case 2:
1001         if ( num_glyphs > 87 )
1002         {
1003           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
1004                      "predefined charset (Adobe Expert Subset)\n" ));
1005           error = CFF_Err_Invalid_File_Format;
1006           goto Exit;
1007         }
1008
1009         /* Allocate memory for sids. */
1010         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
1011           goto Exit;
1012
1013         /* Copy the predefined charset into the allocated memory.     */
1014         FT_ARRAY_COPY( charset->sids, cff_expertsubset_charset, num_glyphs );
1015
1016         break;
1017
1018       default:
1019         error = CFF_Err_Invalid_File_Format;
1020         goto Exit;
1021       }
1022     }
1023
1024     /* we have to invert the `sids' array for subsetted CID-keyed fonts */
1025     if ( invert )
1026       error = cff_charset_compute_cids( charset, num_glyphs, memory );
1027
1028   Exit:
1029     /* Clean up if there was an error. */
1030     if ( error )
1031     {
1032       FT_FREE( charset->sids );
1033       FT_FREE( charset->cids );
1034       charset->format = 0;
1035       charset->offset = 0;
1036       charset->sids   = 0;
1037     }
1038
1039     return error;
1040   }
1041
1042
1043   static void
1044   cff_encoding_done( CFF_Encoding  encoding )
1045   {
1046     encoding->format = 0;
1047     encoding->offset = 0;
1048     encoding->count  = 0;
1049   }
1050
1051
1052   static FT_Error
1053   cff_encoding_load( CFF_Encoding  encoding,
1054                      CFF_Charset   charset,
1055                      FT_UInt       num_glyphs,
1056                      FT_Stream     stream,
1057                      FT_ULong      base_offset,
1058                      FT_ULong      offset )
1059   {
1060     FT_Error   error = CFF_Err_Ok;
1061     FT_UInt    count;
1062     FT_UInt    j;
1063     FT_UShort  glyph_sid;
1064     FT_UInt    glyph_code;
1065
1066
1067     /* Check for charset->sids.  If we do not have this, we fail. */
1068     if ( !charset->sids )
1069     {
1070       error = CFF_Err_Invalid_File_Format;
1071       goto Exit;
1072     }
1073
1074     /* Zero out the code to gid/sid mappings. */
1075     for ( j = 0; j < 256; j++ )
1076     {
1077       encoding->sids [j] = 0;
1078       encoding->codes[j] = 0;
1079     }
1080
1081     /* Note: The encoding table in a CFF font is indexed by glyph index;  */
1082     /* the first encoded glyph index is 1.  Hence, we read the character  */
1083     /* code (`glyph_code') at index j and make the assignment:            */
1084     /*                                                                    */
1085     /*    encoding->codes[glyph_code] = j + 1                             */
1086     /*                                                                    */
1087     /* We also make the assignment:                                       */
1088     /*                                                                    */
1089     /*    encoding->sids[glyph_code] = charset->sids[j + 1]               */
1090     /*                                                                    */
1091     /* This gives us both a code to GID and a code to SID mapping.        */
1092
1093     if ( offset > 1 )
1094     {
1095       encoding->offset = base_offset + offset;
1096
1097       /* we need to parse the table to determine its size */
1098       if ( FT_STREAM_SEEK( encoding->offset ) ||
1099            FT_READ_BYTE( encoding->format )   ||
1100            FT_READ_BYTE( count )              )
1101         goto Exit;
1102
1103       switch ( encoding->format & 0x7F )
1104       {
1105       case 0:
1106         {
1107           FT_Byte*  p;
1108
1109
1110           /* By convention, GID 0 is always ".notdef" and is never */
1111           /* coded in the font.  Hence, the number of codes found  */
1112           /* in the table is `count+1'.                            */
1113           /*                                                       */
1114           encoding->count = count + 1;
1115
1116           if ( FT_FRAME_ENTER( count ) )
1117             goto Exit;
1118
1119           p = (FT_Byte*)stream->cursor;
1120
1121           for ( j = 1; j <= count; j++ )
1122           {
1123             glyph_code = *p++;
1124
1125             /* Make sure j is not too big. */
1126             if ( j < num_glyphs )
1127             {
1128               /* Assign code to GID mapping. */
1129               encoding->codes[glyph_code] = (FT_UShort)j;
1130
1131               /* Assign code to SID mapping. */
1132               encoding->sids[glyph_code] = charset->sids[j];
1133             }
1134           }
1135
1136           FT_FRAME_EXIT();
1137         }
1138         break;
1139
1140       case 1:
1141         {
1142           FT_UInt  nleft;
1143           FT_UInt  i = 1;
1144           FT_UInt  k;
1145
1146
1147           encoding->count = 0;
1148
1149           /* Parse the Format1 ranges. */
1150           for ( j = 0;  j < count; j++, i += nleft )
1151           {
1152             /* Read the first glyph code of the range. */
1153             if ( FT_READ_BYTE( glyph_code ) )
1154               goto Exit;
1155
1156             /* Read the number of codes in the range. */
1157             if ( FT_READ_BYTE( nleft ) )
1158               goto Exit;
1159
1160             /* Increment nleft, so we read `nleft + 1' codes/sids. */
1161             nleft++;
1162
1163             /* compute max number of character codes */
1164             if ( (FT_UInt)nleft > encoding->count )
1165               encoding->count = nleft;
1166
1167             /* Fill in the range of codes/sids. */
1168             for ( k = i; k < nleft + i; k++, glyph_code++ )
1169             {
1170               /* Make sure k is not too big. */
1171               if ( k < num_glyphs && glyph_code < 256 )
1172               {
1173                 /* Assign code to GID mapping. */
1174                 encoding->codes[glyph_code] = (FT_UShort)k;
1175
1176                 /* Assign code to SID mapping. */
1177                 encoding->sids[glyph_code] = charset->sids[k];
1178               }
1179             }
1180           }
1181
1182           /* simple check; one never knows what can be found in a font */
1183           if ( encoding->count > 256 )
1184             encoding->count = 256;
1185         }
1186         break;
1187
1188       default:
1189         FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1190         error = CFF_Err_Invalid_File_Format;
1191         goto Exit;
1192       }
1193
1194       /* Parse supplemental encodings, if any. */
1195       if ( encoding->format & 0x80 )
1196       {
1197         FT_UInt  gindex;
1198
1199
1200         /* count supplements */
1201         if ( FT_READ_BYTE( count ) )
1202           goto Exit;
1203
1204         for ( j = 0; j < count; j++ )
1205         {
1206           /* Read supplemental glyph code. */
1207           if ( FT_READ_BYTE( glyph_code ) )
1208             goto Exit;
1209
1210           /* Read the SID associated with this glyph code. */
1211           if ( FT_READ_USHORT( glyph_sid ) )
1212             goto Exit;
1213
1214           /* Assign code to SID mapping. */
1215           encoding->sids[glyph_code] = glyph_sid;
1216
1217           /* First, look up GID which has been assigned to */
1218           /* SID glyph_sid.                                */
1219           for ( gindex = 0; gindex < num_glyphs; gindex++ )
1220           {
1221             if ( charset->sids[gindex] == glyph_sid )
1222             {
1223               encoding->codes[glyph_code] = (FT_UShort)gindex;
1224               break;
1225             }
1226           }
1227         }
1228       }
1229     }
1230     else
1231     {
1232       /* We take into account the fact a CFF font can use a predefined */
1233       /* encoding without containing all of the glyphs encoded by this */
1234       /* encoding (see the note at the end of section 12 in the CFF    */
1235       /* specification).                                               */
1236
1237       switch ( (FT_UInt)offset )
1238       {
1239       case 0:
1240         /* First, copy the code to SID mapping. */
1241         FT_ARRAY_COPY( encoding->sids, cff_standard_encoding, 256 );
1242         goto Populate;
1243
1244       case 1:
1245         /* First, copy the code to SID mapping. */
1246         FT_ARRAY_COPY( encoding->sids, cff_expert_encoding, 256 );
1247
1248       Populate:
1249         /* Construct code to GID mapping from code to SID mapping */
1250         /* and charset.                                           */
1251
1252         encoding->count = 0;
1253
1254         error = cff_charset_compute_cids( charset, num_glyphs,
1255                                           stream->memory );
1256         if ( error )
1257           goto Exit;
1258
1259         for ( j = 0; j < 256; j++ )
1260         {
1261           FT_UInt  sid = encoding->sids[j];
1262           FT_UInt  gid = 0;
1263
1264
1265           if ( sid )
1266             gid = cff_charset_cid_to_gindex( charset, sid );
1267
1268           if ( gid != 0 )
1269           {
1270             encoding->codes[j] = (FT_UShort)gid;
1271             encoding->count    = j + 1;
1272           }
1273           else
1274           {
1275             encoding->codes[j] = 0;
1276             encoding->sids [j] = 0;
1277           }
1278         }
1279         break;
1280
1281       default:
1282         FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1283         error = CFF_Err_Invalid_File_Format;
1284         goto Exit;
1285       }
1286     }
1287
1288   Exit:
1289
1290     /* Clean up if there was an error. */
1291     return error;
1292   }
1293
1294
1295   static FT_Error
1296   cff_subfont_load( CFF_SubFont  font,
1297                     CFF_Index    idx,
1298                     FT_UInt      font_index,
1299                     FT_Stream    stream,
1300                     FT_ULong     base_offset,
1301                     FT_Library   library )
1302   {
1303     FT_Error         error;
1304     CFF_ParserRec    parser;
1305     FT_Byte*         dict = NULL;
1306     FT_ULong         dict_len;
1307     CFF_FontRecDict  top  = &font->font_dict;
1308     CFF_Private      priv = &font->private_dict;
1309
1310
1311     cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict, library );
1312
1313     /* set defaults */
1314     FT_MEM_ZERO( top, sizeof ( *top ) );
1315
1316     top->underline_position  = -100L << 16;
1317     top->underline_thickness = 50L << 16;
1318     top->charstring_type     = 2;
1319     top->font_matrix.xx      = 0x10000L;
1320     top->font_matrix.yy      = 0x10000L;
1321     top->cid_count           = 8720;
1322
1323     /* we use the implementation specific SID value 0xFFFF to indicate */
1324     /* missing entries                                                 */
1325     top->version             = 0xFFFFU;
1326     top->notice              = 0xFFFFU;
1327     top->copyright           = 0xFFFFU;
1328     top->full_name           = 0xFFFFU;
1329     top->family_name         = 0xFFFFU;
1330     top->weight              = 0xFFFFU;
1331     top->embedded_postscript = 0xFFFFU;
1332
1333     top->cid_registry        = 0xFFFFU;
1334     top->cid_ordering        = 0xFFFFU;
1335     top->cid_font_name       = 0xFFFFU;
1336
1337     error = cff_index_access_element( idx, font_index, &dict, &dict_len );
1338     if ( !error )
1339     {
1340       FT_TRACE4(( " top dictionary:\n" ));
1341       error = cff_parser_run( &parser, dict, dict + dict_len );
1342     }
1343
1344     cff_index_forget_element( idx, &dict );
1345
1346     if ( error )
1347       goto Exit;
1348
1349     /* if it is a CID font, we stop there */
1350     if ( top->cid_registry != 0xFFFFU )
1351       goto Exit;
1352
1353     /* parse the private dictionary, if any */
1354     if ( top->private_offset && top->private_size )
1355     {
1356       /* set defaults */
1357       FT_MEM_ZERO( priv, sizeof ( *priv ) );
1358
1359       priv->blue_shift       = 7;
1360       priv->blue_fuzz        = 1;
1361       priv->lenIV            = -1;
1362       priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
1363       priv->blue_scale       = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
1364
1365       cff_parser_init( &parser, CFF_CODE_PRIVATE, priv, library );
1366
1367       if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) ||
1368            FT_FRAME_ENTER( font->font_dict.private_size )                 )
1369         goto Exit;
1370
1371       FT_TRACE4(( " private dictionary:\n" ));
1372       error = cff_parser_run( &parser,
1373                               (FT_Byte*)stream->cursor,
1374                               (FT_Byte*)stream->limit );
1375       FT_FRAME_EXIT();
1376       if ( error )
1377         goto Exit;
1378
1379       /* ensure that `num_blue_values' is even */
1380       priv->num_blue_values &= ~1;
1381     }
1382
1383     /* read the local subrs, if any */
1384     if ( priv->local_subrs_offset )
1385     {
1386       if ( FT_STREAM_SEEK( base_offset + top->private_offset +
1387                            priv->local_subrs_offset ) )
1388         goto Exit;
1389
1390       error = cff_index_init( &font->local_subrs_index, stream, 1 );
1391       if ( error )
1392         goto Exit;
1393
1394       error = cff_index_get_pointers( &font->local_subrs_index,
1395                                       &font->local_subrs, NULL );
1396       if ( error )
1397         goto Exit;
1398     }
1399
1400   Exit:
1401     return error;
1402   }
1403
1404
1405   static void
1406   cff_subfont_done( FT_Memory    memory,
1407                     CFF_SubFont  subfont )
1408   {
1409     if ( subfont )
1410     {
1411       cff_index_done( &subfont->local_subrs_index );
1412       FT_FREE( subfont->local_subrs );
1413     }
1414   }
1415
1416
1417   FT_LOCAL_DEF( FT_Error )
1418   cff_font_load( FT_Library library,
1419                  FT_Stream  stream,
1420                  FT_Int     face_index,
1421                  CFF_Font   font,
1422                  FT_Bool    pure_cff )
1423   {
1424     static const FT_Frame_Field  cff_header_fields[] =
1425     {
1426 #undef  FT_STRUCTURE
1427 #define FT_STRUCTURE  CFF_FontRec
1428
1429       FT_FRAME_START( 4 ),
1430         FT_FRAME_BYTE( version_major ),
1431         FT_FRAME_BYTE( version_minor ),
1432         FT_FRAME_BYTE( header_size ),
1433         FT_FRAME_BYTE( absolute_offsize ),
1434       FT_FRAME_END
1435     };
1436
1437     FT_Error         error;
1438     FT_Memory        memory = stream->memory;
1439     FT_ULong         base_offset;
1440     CFF_FontRecDict  dict;
1441     CFF_IndexRec     string_index;
1442
1443
1444     FT_ZERO( font );
1445     FT_ZERO( &string_index );
1446
1447     font->stream = stream;
1448     font->memory = memory;
1449     dict         = &font->top_font.font_dict;
1450     base_offset  = FT_STREAM_POS();
1451
1452     /* read CFF font header */
1453     if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )
1454       goto Exit;
1455
1456     /* check format */
1457     if ( font->version_major   != 1 ||
1458          font->header_size      < 4 ||
1459          font->absolute_offsize > 4 )
1460     {
1461       FT_TRACE2(( "  not a CFF font header\n" ));
1462       error = CFF_Err_Unknown_File_Format;
1463       goto Exit;
1464     }
1465
1466     /* skip the rest of the header */
1467     if ( FT_STREAM_SKIP( font->header_size - 4 ) )
1468       goto Exit;
1469
1470     /* read the name, top dict, string and global subrs index */
1471     if ( FT_SET_ERROR( cff_index_init( &font->name_index,
1472                                        stream, 0 ) )                  ||
1473          FT_SET_ERROR( cff_index_init( &font->font_dict_index,
1474                                        stream, 0 ) )                  ||
1475          FT_SET_ERROR( cff_index_init( &string_index,
1476                                        stream, 1 ) )                  ||
1477          FT_SET_ERROR( cff_index_init( &font->global_subrs_index,
1478                                        stream, 1 ) )                  ||
1479          FT_SET_ERROR( cff_index_get_pointers( &string_index,
1480                                                &font->strings,
1481                                                &font->string_pool ) ) )
1482       goto Exit;
1483
1484     font->num_strings = string_index.count;
1485
1486     /* well, we don't really forget the `disabled' fonts... */
1487     font->num_faces = font->name_index.count;
1488     if ( face_index >= (FT_Int)font->num_faces )
1489     {
1490       FT_ERROR(( "cff_font_load: incorrect face index = %d\n",
1491                  face_index ));
1492       error = CFF_Err_Invalid_Argument;
1493     }
1494
1495     /* in case of a font format check, simply exit now */
1496     if ( face_index < 0 )
1497       goto Exit;
1498
1499     /* now, parse the top-level font dictionary */
1500     FT_TRACE4(( "parsing top-level\n" ));
1501     error = cff_subfont_load( &font->top_font,
1502                               &font->font_dict_index,
1503                               face_index,
1504                               stream,
1505                               base_offset,
1506                               library );
1507     if ( error )
1508       goto Exit;
1509
1510     if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )
1511       goto Exit;
1512
1513     error = cff_index_init( &font->charstrings_index, stream, 0 );
1514     if ( error )
1515       goto Exit;
1516
1517     /* now, check for a CID font */
1518     if ( dict->cid_registry != 0xFFFFU )
1519     {
1520       CFF_IndexRec  fd_index;
1521       CFF_SubFont   sub = NULL;
1522       FT_UInt       idx;
1523
1524
1525       /* this is a CID-keyed font, we must now allocate a table of */
1526       /* sub-fonts, then load each of them separately              */
1527       if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) )
1528         goto Exit;
1529
1530       error = cff_index_init( &fd_index, stream, 0 );
1531       if ( error )
1532         goto Exit;
1533
1534       if ( fd_index.count > CFF_MAX_CID_FONTS )
1535       {
1536         FT_TRACE0(( "cff_font_load: FD array too large in CID font\n" ));
1537         goto Fail_CID;
1538       }
1539
1540       /* allocate & read each font dict independently */
1541       font->num_subfonts = fd_index.count;
1542       if ( FT_NEW_ARRAY( sub, fd_index.count ) )
1543         goto Fail_CID;
1544
1545       /* set up pointer table */
1546       for ( idx = 0; idx < fd_index.count; idx++ )
1547         font->subfonts[idx] = sub + idx;
1548
1549       /* now load each subfont independently */
1550       for ( idx = 0; idx < fd_index.count; idx++ )
1551       {
1552         sub = font->subfonts[idx];
1553         FT_TRACE4(( "parsing subfont %u\n", idx ));
1554         error = cff_subfont_load( sub, &fd_index, idx,
1555                                   stream, base_offset, library );
1556         if ( error )
1557           goto Fail_CID;
1558       }
1559
1560       /* now load the FD Select array */
1561       error = CFF_Load_FD_Select( &font->fd_select,
1562                                   font->charstrings_index.count,
1563                                   stream,
1564                                   base_offset + dict->cid_fd_select_offset );
1565
1566     Fail_CID:
1567       cff_index_done( &fd_index );
1568
1569       if ( error )
1570         goto Exit;
1571     }
1572     else
1573       font->num_subfonts = 0;
1574
1575     /* read the charstrings index now */
1576     if ( dict->charstrings_offset == 0 )
1577     {
1578       FT_ERROR(( "cff_font_load: no charstrings offset\n" ));
1579       error = CFF_Err_Invalid_File_Format;
1580       goto Exit;
1581     }
1582
1583     font->num_glyphs = font->charstrings_index.count;
1584
1585     error = cff_index_get_pointers( &font->global_subrs_index,
1586                                     &font->global_subrs, NULL );
1587
1588     if ( error )
1589       goto Exit;
1590
1591     /* read the Charset and Encoding tables if available */
1592     if ( font->num_glyphs > 0 )
1593     {
1594       FT_Bool  invert = FT_BOOL( dict->cid_registry != 0xFFFFU && pure_cff );
1595
1596
1597       error = cff_charset_load( &font->charset, font->num_glyphs, stream,
1598                                 base_offset, dict->charset_offset, invert );
1599       if ( error )
1600         goto Exit;
1601
1602       /* CID-keyed CFFs don't have an encoding */
1603       if ( dict->cid_registry == 0xFFFFU )
1604       {
1605         error = cff_encoding_load( &font->encoding,
1606                                    &font->charset,
1607                                    font->num_glyphs,
1608                                    stream,
1609                                    base_offset,
1610                                    dict->encoding_offset );
1611         if ( error )
1612           goto Exit;
1613       }
1614     }
1615
1616     /* get the font name (/CIDFontName for CID-keyed fonts, */
1617     /* /FontName otherwise)                                 */
1618     font->font_name = cff_index_get_name( font, face_index );
1619
1620   Exit:
1621     cff_index_done( &string_index );
1622
1623     return error;
1624   }
1625
1626
1627   FT_LOCAL_DEF( void )
1628   cff_font_done( CFF_Font  font )
1629   {
1630     FT_Memory  memory = font->memory;
1631     FT_UInt    idx;
1632
1633
1634     cff_index_done( &font->global_subrs_index );
1635     cff_index_done( &font->font_dict_index );
1636     cff_index_done( &font->name_index );
1637     cff_index_done( &font->charstrings_index );
1638
1639     /* release font dictionaries, but only if working with */
1640     /* a CID keyed CFF font                                */
1641     if ( font->num_subfonts > 0 )
1642     {
1643       for ( idx = 0; idx < font->num_subfonts; idx++ )
1644         cff_subfont_done( memory, font->subfonts[idx] );
1645
1646       /* the subfonts array has been allocated as a single block */
1647       FT_FREE( font->subfonts[0] );
1648     }
1649
1650     cff_encoding_done( &font->encoding );
1651     cff_charset_done( &font->charset, font->stream );
1652
1653     cff_subfont_done( memory, &font->top_font );
1654
1655     CFF_Done_FD_Select( &font->fd_select, font->stream );
1656
1657     FT_FREE( font->font_info );
1658
1659     FT_FREE( font->font_name );
1660     FT_FREE( font->global_subrs );
1661     FT_FREE( font->strings );
1662     FT_FREE( font->string_pool );
1663   }
1664
1665
1666 /* END */