Update freetype to latest version of ASOP.

src/cff/cffload.c

 /***************************************************************************/
 /*                                                                         */
 /*  cffload.c                                                              */
 /*                                                                         */
 /*    OpenType and CFF data/program tables loader (body).                  */
 /*                                                                         */
-/*  Copyright 1996-2011 by                                                 */
+/*  Copyright 1996-2013 by                                                 */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
 /*  modified, and distributed under the terms of the FreeType project      */
 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 /*  this file you indicate that you have read the license and              */
 /*  understand and accept it fully.                                        */
 /*                                                                         */
 /***************************************************************************/
 
@@ skipping 225 matching lines @@
       FT_ULong  size;
 
 
       /* there is at least one element; read the offset size,           */
       /* then access the offset table to compute the index's total size */
       if ( FT_READ_BYTE( offsize ) )
         goto Exit;
 
       if ( offsize < 1 || offsize > 4 )
       {
-        error = CFF_Err_Invalid_Table;
+        error = FT_THROW( Invalid_Table );
         goto Exit;
       }
 
       idx->count    = count;
       idx->off_size = offsize;
       size          = (FT_ULong)( count + 1 ) * offsize;
 
       idx->data_offset = idx->start + 3 + size;
 
       if ( FT_STREAM_SKIP( size - offsize ) )
         goto Exit;
 
       size = cff_index_read_offset( idx, &error );
       if ( error )
         goto Exit;
 
       if ( size == 0 )
       {
-        error = CFF_Err_Invalid_Table;
+        error = FT_THROW( Invalid_Table );
         goto Exit;
       }
 
       idx->data_size = --size;
 
       if ( load )
       {
         /* load the data */
         if ( FT_FRAME_EXTRACT( size, idx->bytes ) )
           goto Exit;
@@ skipping 28 matching lines @@
 
       FT_FREE( idx->offsets );
       FT_MEM_ZERO( idx, sizeof ( *idx ) );
     }
   }
 
 
   static FT_Error
   cff_index_load_offsets( CFF_Index  idx )
   {
-    FT_Error   error  = CFF_Err_Ok;
+    FT_Error   error  = FT_Err_Ok;
     FT_Stream  stream = idx->stream;
     FT_Memory  memory = stream->memory;
 
 
     if ( idx->count > 0 && idx->offsets == NULL )
     {
       FT_Byte    offsize = idx->off_size;
       FT_ULong   data_size;
       FT_Byte*   p;
       FT_Byte*   p_end;
@@ skipping 45 matching lines @@
 
 
   /* Allocate a table containing pointers to an index's elements. */
   /* The `pool' argument makes this function convert the index    */
   /* entries to C-style strings (this is, NULL-terminated).       */
   static FT_Error
   cff_index_get_pointers( CFF_Index   idx,
                           FT_Byte***  table,
                           FT_Byte**   pool )
   {
-    FT_Error   error     = CFF_Err_Ok;
+    FT_Error   error     = FT_Err_Ok;
     FT_Memory  memory    = idx->stream->memory;
-    FT_Byte**  t = NULL;
+
+    FT_Byte**  t         = NULL;
     FT_Byte*   new_bytes = NULL;
 
 
     *table = NULL;
 
     if ( idx->offsets == NULL )
     {
       error = cff_index_load_offsets( idx );
       if ( error )
         goto Exit;
@@ skipping 64 matching lines @@
     return error;
   }
 
 
   FT_LOCAL_DEF( FT_Error )
   cff_index_access_element( CFF_Index  idx,
                             FT_UInt    element,
                             FT_Byte**  pbytes,
                             FT_ULong*  pbyte_len )
   {
-    FT_Error  error = CFF_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     if ( idx && idx->count > element )
     {
       /* compute start and end offsets */
       FT_Stream  stream = idx->stream;
       FT_ULong   off1, off2 = 0;
 
 
       /* load offsets from file or the offset table */
@@ skipping 64 matching lines @@
         }
       }
       else
       {
         /* empty index element */
         *pbytes    = 0;
         *pbyte_len = 0;
       }
     }
     else
-      error = CFF_Err_Invalid_Argument;
+      error = FT_THROW( Invalid_Argument );
 
   Exit:
     return error;
   }
 
 
   FT_LOCAL_DEF( void )
   cff_index_forget_element( CFF_Index  idx,
                             FT_Byte**  pbytes )
   {
@@ skipping 119 matching lines @@
         goto Exit;
 
       fdselect->data_size = num_ranges * 3 + 2;
 
     Load_Data:
       if ( FT_FRAME_EXTRACT( fdselect->data_size, fdselect->data ) )
         goto Exit;
       break;
 
     default:    /* hmm... that's wrong */
-      error = CFF_Err_Invalid_File_Format;
+      error = FT_THROW( Invalid_File_Format );
     }
 
   Exit:
     return error;
   }
 
 
   FT_LOCAL_DEF( FT_Byte )
   cff_fd_select_get( CFF_FDSelect  fdselect,
                      FT_UInt       glyph_index )
@@ skipping 63 matching lines @@
   /***   CFF font support                                                ***/
   /***                                                                   ***/
   /*************************************************************************/
   /*************************************************************************/
 
   static FT_Error
   cff_charset_compute_cids( CFF_Charset  charset,
                             FT_UInt      num_glyphs,
                             FT_Memory    memory )
   {
-    FT_Error   error   = CFF_Err_Ok;
+    FT_Error   error   = FT_Err_Ok;
     FT_UInt    i;
     FT_Long    j;
     FT_UShort  max_cid = 0;
 
 
     if ( charset->max_cid > 0 )
       goto Exit;
 
     for ( i = 0; i < num_glyphs; i++ )
     {
@@ skipping 58 matching lines @@
 
   static FT_Error
   cff_charset_load( CFF_Charset  charset,
                     FT_UInt      num_glyphs,
                     FT_Stream    stream,
                     FT_ULong     base_offset,
                     FT_ULong     offset,
                     FT_Bool      invert )
   {
     FT_Memory  memory = stream->memory;
-    FT_Error   error  = CFF_Err_Ok;
+    FT_Error   error  = FT_Err_Ok;
     FT_UShort  glyph_sid;
 
 
     /* If the the offset is greater than 2, we have to parse the */
     /* charset table.                                            */
     if ( offset > 2 )
     {
       FT_UInt  j;
 
 
@@ skipping 63 matching lines @@
 
             /* Fill in the range of sids -- `nleft + 1' glyphs. */
             for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
               charset->sids[j] = glyph_sid;
           }
         }
         break;
 
       default:
         FT_ERROR(( "cff_charset_load: invalid table format\n" ));
-        error = CFF_Err_Invalid_File_Format;
+        error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
     }
     else
     {
       /* Parse default tables corresponding to offset == 0, 1, or 2.  */
       /* CFF specification intimates the following:                   */
       /*                                                              */
       /* In order to use a predefined charset, the following must be  */
       /* true: The charset constructed for the glyphs in the font's   */
       /* charstrings dictionary must match the predefined charset in  */
       /* the first num_glyphs.                                        */
 
       charset->offset = offset;  /* record charset type */
 
       switch ( (FT_UInt)offset )
       {
       case 0:
         if ( num_glyphs > 229 )
         {
           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
                      "predefined charset (Adobe ISO-Latin)\n" ));
-          error = CFF_Err_Invalid_File_Format;
+          error = FT_THROW( Invalid_File_Format );
           goto Exit;
         }
 
         /* Allocate memory for sids. */
         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
           goto Exit;
 
         /* Copy the predefined charset into the allocated memory. */
         FT_ARRAY_COPY( charset->sids, cff_isoadobe_charset, num_glyphs );
 
         break;
 
       case 1:
         if ( num_glyphs > 166 )
         {
           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
                      "predefined charset (Adobe Expert)\n" ));
-          error = CFF_Err_Invalid_File_Format;
+          error = FT_THROW( Invalid_File_Format );
           goto Exit;
         }
 
         /* Allocate memory for sids. */
         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
           goto Exit;
 
         /* Copy the predefined charset into the allocated memory.     */
         FT_ARRAY_COPY( charset->sids, cff_expert_charset, num_glyphs );
 
         break;
 
       case 2:
         if ( num_glyphs > 87 )
         {
           FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
                      "predefined charset (Adobe Expert Subset)\n" ));
-          error = CFF_Err_Invalid_File_Format;
+          error = FT_THROW( Invalid_File_Format );
           goto Exit;
         }
 
         /* Allocate memory for sids. */
         if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
           goto Exit;
 
         /* Copy the predefined charset into the allocated memory.     */
         FT_ARRAY_COPY( charset->sids, cff_expertsubset_charset, num_glyphs );
 
         break;
 
       default:
-        error = CFF_Err_Invalid_File_Format;
+        error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
     }
 
     /* we have to invert the `sids' array for subsetted CID-keyed fonts */
     if ( invert )
       error = cff_charset_compute_cids( charset, num_glyphs, memory );
 
   Exit:
     /* Clean up if there was an error. */
@@ skipping 20 matching lines @@
 
 
   static FT_Error
   cff_encoding_load( CFF_Encoding  encoding,
                      CFF_Charset   charset,
                      FT_UInt       num_glyphs,
                      FT_Stream     stream,
                      FT_ULong      base_offset,
                      FT_ULong      offset )
   {
-    FT_Error   error = CFF_Err_Ok;
+    FT_Error   error = FT_Err_Ok;
     FT_UInt    count;
     FT_UInt    j;
     FT_UShort  glyph_sid;
     FT_UInt    glyph_code;
 
 
     /* Check for charset->sids.  If we do not have this, we fail. */
     if ( !charset->sids )
     {
-      error = CFF_Err_Invalid_File_Format;
+      error = FT_THROW( Invalid_File_Format );
       goto Exit;
     }
 
     /* Zero out the code to gid/sid mappings. */
     for ( j = 0; j < 256; j++ )
     {
       encoding->sids [j] = 0;
       encoding->codes[j] = 0;
     }
 
@@ skipping 99 matching lines @@
           }
 
           /* simple check; one never knows what can be found in a font */
           if ( encoding->count > 256 )
             encoding->count = 256;
         }
         break;
 
       default:
         FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
-        error = CFF_Err_Invalid_File_Format;
+        error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
 
       /* Parse supplemental encodings, if any. */
       if ( encoding->format & 0x80 )
       {
         FT_UInt  gindex;
 
 
         /* count supplements */
@@ skipping 72 matching lines @@
           else
           {
             encoding->codes[j] = 0;
             encoding->sids [j] = 0;
           }
         }
         break;
 
       default:
         FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
-        error = CFF_Err_Invalid_File_Format;
+        error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
     }
 
   Exit:
 
     /* Clean up if there was an error. */
     return error;
   }
 
@@ skipping 12 matching lines @@
     FT_ULong         dict_len;
     CFF_FontRecDict  top  = &font->font_dict;
     CFF_Private      priv = &font->private_dict;
 
 
     cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict, library );
 
     /* set defaults */
     FT_MEM_ZERO( top, sizeof ( *top ) );
 
-    top->underline_position  = -100L << 16;
+    top->underline_position  = -( 100L << 16 );
     top->underline_thickness = 50L << 16;
     top->charstring_type     = 2;
     top->font_matrix.xx      = 0x10000L;
     top->font_matrix.yy      = 0x10000L;
     top->cid_count           = 8720;
 
     /* we use the implementation specific SID value 0xFFFF to indicate */
     /* missing entries                                                 */
     top->version             = 0xFFFFU;
     top->notice              = 0xFFFFU;
@@ skipping 105 matching lines @@
         FT_FRAME_BYTE( header_size ),
         FT_FRAME_BYTE( absolute_offsize ),
       FT_FRAME_END
     };
 
     FT_Error         error;
     FT_Memory        memory = stream->memory;
     FT_ULong         base_offset;
     CFF_FontRecDict  dict;
     CFF_IndexRec     string_index;
+    FT_Int           subfont_index;
 
 
     FT_ZERO( font );
     FT_ZERO( &string_index );
 
     font->stream = stream;
     font->memory = memory;
     dict         = &font->top_font.font_dict;
     base_offset  = FT_STREAM_POS();
 
     /* read CFF font header */
     if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )
       goto Exit;
 
     /* check format */
     if ( font->version_major   != 1 ||
          font->header_size      < 4 ||
          font->absolute_offsize > 4 )
     {
       FT_TRACE2(( "  not a CFF font header\n" ));
-      error = CFF_Err_Unknown_File_Format;
+      error = FT_THROW( Unknown_File_Format );
       goto Exit;
     }
 
     /* skip the rest of the header */
     if ( FT_STREAM_SKIP( font->header_size - 4 ) )
       goto Exit;
 
     /* read the name, top dict, string and global subrs index */
     if ( FT_SET_ERROR( cff_index_init( &font->name_index,
                                        stream, 0 ) )                  ||
          FT_SET_ERROR( cff_index_init( &font->font_dict_index,
                                        stream, 0 ) )                  ||
          FT_SET_ERROR( cff_index_init( &string_index,
                                        stream, 1 ) )                  ||
          FT_SET_ERROR( cff_index_init( &font->global_subrs_index,
                                        stream, 1 ) )                  ||
          FT_SET_ERROR( cff_index_get_pointers( &string_index,
                                                &font->strings,
                                                &font->string_pool ) ) )
       goto Exit;
 
     font->num_strings = string_index.count;
 
-    /* well, we don't really forget the `disabled' fonts... */
-    font->num_faces = font->name_index.count;
-    if ( face_index >= (FT_Int)font->num_faces )
+    if ( pure_cff )
     {
-      FT_ERROR(( "cff_font_load: incorrect face index = %d\n",
-                 face_index ));
-      error = CFF_Err_Invalid_Argument;
+      /* well, we don't really forget the `disabled' fonts... */
+      subfont_index = face_index;
+
+      if ( subfont_index >= (FT_Int)font->name_index.count )
+      {
+        FT_ERROR(( "cff_font_load:"
+                   " invalid subfont index for pure CFF font (%d)\n",
+                   subfont_index ));
+        error = FT_THROW( Invalid_Argument );
+        goto Exit;
+      }
+
+      font->num_faces = font->name_index.count;
+    }
+    else
+    {
+      subfont_index = 0;
+
+      if ( font->name_index.count > 1 )
+      {
+        FT_ERROR(( "cff_font_load:"
+                   " invalid CFF font with multiple subfonts\n"
+                   "              "
+                   " in SFNT wrapper\n" ));
+        error = FT_THROW( Invalid_File_Format );
+        goto Exit;
+      }
     }
 
     /* in case of a font format check, simply exit now */
     if ( face_index < 0 )
       goto Exit;
 
     /* now, parse the top-level font dictionary */
     FT_TRACE4(( "parsing top-level\n" ));
     error = cff_subfont_load( &font->top_font,
                               &font->font_dict_index,
-                              face_index,
+                              subfont_index,
                               stream,
                               base_offset,
                               library );
     if ( error )
       goto Exit;
 
     if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )
       goto Exit;
 
     error = cff_index_init( &font->charstrings_index, stream, 0 );
@@ skipping 55 matching lines @@
       if ( error )
         goto Exit;
     }
     else
       font->num_subfonts = 0;
 
     /* read the charstrings index now */
     if ( dict->charstrings_offset == 0 )
     {
       FT_ERROR(( "cff_font_load: no charstrings offset\n" ));
-      error = CFF_Err_Invalid_File_Format;
+      error = FT_THROW( Invalid_File_Format );
       goto Exit;
     }
 
     font->num_glyphs = font->charstrings_index.count;
 
     error = cff_index_get_pointers( &font->global_subrs_index,
                                     &font->global_subrs, NULL );
 
     if ( error )
       goto Exit;
@@ skipping 18 matching lines @@
                                    stream,
                                    base_offset,
                                    dict->encoding_offset );
         if ( error )
           goto Exit;
       }
     }
 
     /* get the font name (/CIDFontName for CID-keyed fonts, */
     /* /FontName otherwise)                                 */
-    font->font_name = cff_index_get_name( font, face_index );
+    font->font_name = cff_index_get_name( font, subfont_index );
 
   Exit:
     cff_index_done( &string_index );
 
     return error;
   }
 
 
   FT_LOCAL_DEF( void )
   cff_font_done( CFF_Font  font )
@@ skipping 24 matching lines @@
     cff_subfont_done( memory, &font->top_font );
 
     CFF_Done_FD_Select( &font->fd_select, font->stream );
 
     FT_FREE( font->font_info );
 
     FT_FREE( font->font_name );
     FT_FREE( font->global_subrs );
     FT_FREE( font->strings );
     FT_FREE( font->string_pool );
+
+    if ( font->cf2_instance.finalizer )
+    {
+      font->cf2_instance.finalizer( font->cf2_instance.data );
+      FT_FREE( font->cf2_instance.data );
+    }
   }
 
 
 /* END */