Update bundled freetype to 2.6.1

third_party/freetype/src/cid/cidload.c

 /***************************************************************************/
 /*                                                                         */
 /*  cidload.c                                                              */
 /*                                                                         */
 /*    CID-keyed Type1 font loader (body).                                  */
 /*                                                                         */
-/*  Copyright 1996-2006, 2009, 2011-2014 by                                */
+/*  Copyright 1996-2015 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 13 matching lines @@
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
   /* messages during execution.                                            */
   /*                                                                       */
 #undef  FT_COMPONENT
 #define FT_COMPONENT  trace_cidload
 
 
   /* read a single offset */
-  FT_LOCAL_DEF( FT_Long )
+  FT_LOCAL_DEF( FT_ULong )
   cid_get_offset( FT_Byte*  *start,
                   FT_Byte    offsize )
   {
     FT_ULong  result;
     FT_Byte*  p = *start;
 
 
     for ( result = 0; offsize > 0; offsize-- )
     {
       result <<= 8;
       result  |= *p++;
     }
 
     *start = p;
-    return (FT_Long)result;
+    return result;
   }
 
 
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
   /*****                    TYPE 1 SYMBOL PARSING                      *****/
   /*****                                                               *****/
   /*************************************************************************/
   /*************************************************************************/
@@ skipping 93 matching lines @@
     {
       FT_Matrix*  matrix;
       FT_Vector*  offset;
       FT_Int      result;
 
 
       dict   = face->cid.font_dicts + parser->num_dict;
       matrix = &dict->font_matrix;
       offset = &dict->font_offset;
 
+      /* input is scaled by 1000 to accommodate default FontMatrix */
       result = cid_parser_to_fixed_array( parser, 6, temp, 3 );
 
       if ( result < 6 )
         return FT_THROW( Invalid_File_Format );
 
       temp_scale = FT_ABS( temp[3] );
 
       if ( temp_scale == 0 )
       {
         FT_ERROR(( "cid_parse_font_matrix: invalid font matrix\n" ));
         return FT_THROW( Invalid_File_Format );
       }
 
-      /* Set Units per EM based on FontMatrix values.  We set the value to */
-      /* 1000 / temp_scale, because temp_scale was already multiplied by   */
-      /* 1000 (in t1_tofixed, from psobjs.c).                              */
-
-      root->units_per_EM = (FT_UShort)FT_DivFix( 1000, temp_scale );
-
-      /* we need to scale the values by 1.0/temp[3] */
+      /* atypical case */
       if ( temp_scale != 0x10000L )
       {
+        /* set units per EM based on FontMatrix values */
+        root->units_per_EM = (FT_UShort)FT_DivFix( 1000, temp_scale );
+
         temp[0] = FT_DivFix( temp[0], temp_scale );
         temp[1] = FT_DivFix( temp[1], temp_scale );
         temp[2] = FT_DivFix( temp[2], temp_scale );
         temp[4] = FT_DivFix( temp[4], temp_scale );
         temp[5] = FT_DivFix( temp[5], temp_scale );
         temp[3] = temp[3] < 0 ? -0x10000L : 0x10000L;
       }
 
       matrix->xx = temp[0];
       matrix->yx = temp[1];
@@ skipping 13 matching lines @@
   parse_fd_array( CID_Face     face,
                   CID_Parser*  parser )
   {
     CID_FaceInfo  cid    = &face->cid;
     FT_Memory     memory = face->root.memory;
     FT_Error      error  = FT_Err_Ok;
     FT_Long       num_dicts;
 
 
     num_dicts = cid_parser_to_int( parser );
+    if ( num_dicts < 0 )
+    {
+      FT_ERROR(( "parse_fd_array: invalid number of dictionaries\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
 
     if ( !cid->font_dicts )
     {
       FT_Int  n;
 
 
       if ( FT_NEW_ARRAY( cid->font_dicts, num_dicts ) )
         goto Exit;
 
-      cid->num_dicts = (FT_UInt)num_dicts;
+      cid->num_dicts = num_dicts;
 
       /* don't forget to set a few defaults */
       for ( n = 0; n < cid->num_dicts; n++ )
       {
         CID_FaceDict  dict = cid->font_dicts + n;
 
 
         /* default value for lenIV */
         dict->private_dict.lenIV = 4;
       }
@@ skipping 38 matching lines @@
     T1_FIELD_CALLBACK( "ExpansionFactor", parse_expansion_factor, 0 )
 
     { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0, 0 }
   };
 
 
   static FT_Error
   cid_parse_dict( CID_Face     face,
                   CID_Loader*  loader,
                   FT_Byte*     base,
-                  FT_Long      size )
+                  FT_ULong     size )
   {
     CID_Parser*  parser = &loader->parser;
 
 
     parser->root.cursor = base;
     parser->root.limit  = base + size;
     parser->root.error  = FT_Err_Ok;
 
     {
       FT_Byte*  cur   = base;
@@ skipping 31 matching lines @@
         if ( cur >= limit )
           break;
 
         cid_parser_skip_PS_token( parser );
         if ( parser->root.cursor >= limit || parser->root.error )
           break;
 
         /* look for immediates */
         if ( *cur == '/' && cur + 2 < limit )
         {
-          FT_PtrDist  len;
+          FT_UInt  len;
 
 
           cur++;
-          len = parser->root.cursor - cur;
+          len = (FT_UInt)( parser->root.cursor - cur );
 
           if ( len > 0 && len < 22 )
           {
             /* now compare the immediate name to the keyword table */
             T1_Field  keyword = (T1_Field)cid_field_records;
 
 
             for (;;)
             {
               FT_Byte*  name;
 
 
               name = (FT_Byte*)keyword->ident;
               if ( !name )
                 break;
 
-              if ( cur[0] == name[0]                                 &&
-                   len == (FT_PtrDist)ft_strlen( (const char*)name ) )
+              if ( cur[0] == name[0]                     &&
+                   len == ft_strlen( (const char*)name ) )
               {
-                FT_PtrDist  n;
+                FT_UInt  n;
 
 
                 for ( n = 1; n < len; n++ )
                   if ( cur[n] != name[n] )
                     break;
 
                 if ( n >= len )
                 {
                   /* we found it - run the parsing callback */
                   parser->root.error = cid_load_keyword( face,
@@ skipping 20 matching lines @@
   static FT_Error
   cid_read_subrs( CID_Face  face )
   {
     CID_FaceInfo   cid    = &face->cid;
     FT_Memory      memory = face->root.memory;
     FT_Stream      stream = face->cid_stream;
     FT_Error       error;
     FT_Int         n;
     CID_Subrs      subr;
     FT_UInt        max_offsets = 0;
-    FT_ULong*      offsets = 0;
+    FT_ULong*      offsets = NULL;
     PSAux_Service  psaux = (PSAux_Service)face->psaux;
 
 
     if ( FT_NEW_ARRAY( face->subrs, cid->num_dicts ) )
       goto Exit;
 
     subr = face->subrs;
     for ( n = 0; n < cid->num_dicts; n++, subr++ )
     {
       CID_FaceDict  dict  = cid->font_dicts + n;
@@ skipping 22 matching lines @@
           goto Fail;
         }
 
         if ( FT_RENEW_ARRAY( offsets, max_offsets, new_max ) )
           goto Fail;
 
         max_offsets = new_max;
       }
 
       /* read the subrmap's offsets */
-      if ( FT_STREAM_SEEK( cid->data_offset + dict->subrmap_offset ) ||
-           FT_FRAME_ENTER( ( num_subrs + 1 ) * dict->sd_bytes )      )
+      if ( FT_STREAM_SEEK( cid->data_offset + dict->subrmap_offset )     ||
+           FT_FRAME_ENTER( ( num_subrs + 1 ) * (FT_UInt)dict->sd_bytes ) )
         goto Fail;
 
       p = (FT_Byte*)stream->cursor;
       for ( count = 0; count <= num_subrs; count++ )
         offsets[count] = cid_get_offset( &p, (FT_Byte)dict->sd_bytes );
 
       FT_FRAME_EXIT();
 
       /* offsets must be ordered */
       for ( count = 1; count <= num_subrs; count++ )
@@ skipping 28 matching lines @@
         for ( count = 0; count < num_subrs; count++ )
         {
           FT_ULong  len;
 
 
           len = offsets[count + 1] - offsets[count];
           psaux->t1_decrypt( subr->code[count], len, 4330 );
         }
       }
 
-      subr->num_subrs = num_subrs;
+      subr->num_subrs = (FT_Int)num_subrs;
     }
 
   Exit:
     FT_FREE( offsets );
     return error;
 
   Fail:
     if ( face->subrs )
     {
       for ( n = 0; n < cid->num_dicts; n++ )
@@ skipping 25 matching lines @@
     CID_Parser*  parser = &loader->parser;
 
 
     /* finalize parser */
     cid_parser_done( parser );
   }
 
 
   static FT_Error
   cid_hex_to_binary( FT_Byte*  data,
-                     FT_Long   data_len,
+                     FT_ULong  data_len,
                      FT_ULong  offset,
                      CID_Face  face )
   {
     FT_Stream  stream = face->root.stream;
     FT_Error   error;
 
     FT_Byte    buffer[256];
     FT_Byte   *p, *plimit;
     FT_Byte   *d, *dlimit;
     FT_Byte    val;
@@ skipping 132 matching lines @@
 
     error = cid_read_subrs( face );
 
   Exit:
     cid_done_loader( &loader );
     return error;
   }
 
 
 /* END */