Update bundled freetype to 2.6.1

third_party/freetype/src/cff/cffgload.c

 /***************************************************************************/
 /*                                                                         */
 /*  cffgload.c                                                             */
 /*                                                                         */
 /*    OpenType Glyph Loader (body).                                        */
 /*                                                                         */
-/*  Copyright 1996-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 248 matching lines @@
     if ( glyph )
     {
       FT_GlyphLoader  loader = glyph->root.internal->loader;
 
 
       builder->loader  = loader;
       builder->base    = &loader->base.outline;
       builder->current = &loader->current.outline;
       FT_GlyphLoader_Rewind( loader );
 
-      builder->hints_globals = 0;
-      builder->hints_funcs   = 0;
+      builder->hints_globals = NULL;
+      builder->hints_funcs   = NULL;
 
       if ( hinting && size )
       {
         CFF_Internal  internal = (CFF_Internal)size->root.internal;
 
 
         builder->hints_globals = (void *)internal->topfont;
         builder->hints_funcs   = glyph->root.internal->glyph_hints;
       }
     }
@@ skipping 351 matching lines @@
     /* check range of standard char code */
     if ( charcode < 0 || charcode > 255 )
       return -1;
 
     /* Get code to SID mapping from `cff_standard_encoding'. */
     glyph_sid = cff_get_standard_encoding( (FT_UInt)charcode );
 
     for ( n = 0; n < cff->num_glyphs; n++ )
     {
       if ( cff->charset.sids[n] == glyph_sid )
-        return n;
+        return (FT_Int)n;
     }
 
     return -1;
   }
 
 
   FT_LOCAL_DEF( FT_Error )
   cff_get_glyph_data( TT_Face    face,
                       FT_UInt    glyph_index,
                       FT_Byte**  pointer,
                       FT_ULong*  length )
   {
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     /* For incremental fonts get the character data using the */
     /* callback function.                                     */
     if ( face->root.internal->incremental_interface )
     {
       FT_Data   data;
       FT_Error  error =
                   face->root.internal->incremental_interface->funcs->get_glyph_data(
                     face->root.internal->incremental_interface->object,
                     glyph_index, &data );
 
 
       *pointer = (FT_Byte*)data.pointer;
-      *length = data.length;
+      *length  = (FT_ULong)data.length;
 
       return error;
     }
     else
 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
 
     {
       CFF_Font  cff  = (CFF_Font)(face->extra.data);
 
 
@@ skipping 14 matching lines @@
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     /* For incremental fonts get the character data using the */
     /* callback function.                                     */
     if ( face->root.internal->incremental_interface )
     {
       FT_Data  data;
 
 
       data.pointer = *pointer;
-      data.length  = length;
+      data.length  = (FT_Int)length;
 
       face->root.internal->incremental_interface->funcs->free_glyph_data(
         face->root.internal->incremental_interface->object, &data );
     }
     else
 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
 
     {
       CFF_Font  cff = (CFF_Font)(face->extra.data);
 
@@ skipping 91 matching lines @@
       glyph->num_subglyphs = 2;
       glyph->subglyphs     = loader->base.subglyphs;
       glyph->format        = FT_GLYPH_FORMAT_COMPOSITE;
 
       loader->current.num_subglyphs = 2;
     }
 
     FT_GlyphLoader_Prepare( builder->loader );
 
     /* First load `bchar' in builder */
-    error = cff_get_glyph_data( face, bchar_index,
+    error = cff_get_glyph_data( face, (FT_UInt)bchar_index,
                                 &charstring, &charstring_len );
     if ( !error )
     {
       /* the seac operator must not be nested */
       decoder->seac = TRUE;
       error = cff_decoder_parse_charstrings( decoder, charstring,
                                              charstring_len );
       decoder->seac = FALSE;
 
       cff_free_glyph_data( face, &charstring, charstring_len );
 
       if ( error )
         goto Exit;
     }
 
     /* Save the left bearing, advance and glyph width of the base */
     /* character as they will be erased by the next load.         */
 
     left_bearing = builder->left_bearing;
     advance      = builder->advance;
     glyph_width  = decoder->glyph_width;
 
     builder->left_bearing.x = 0;
     builder->left_bearing.y = 0;
 
     builder->pos_x = adx - asb;
     builder->pos_y = ady;
 
     /* Now load `achar' on top of the base outline. */
-    error = cff_get_glyph_data( face, achar_index,
+    error = cff_get_glyph_data( face, (FT_UInt)achar_index,
                                 &charstring, &charstring_len );
     if ( !error )
     {
       /* the seac operator must not be nested */
       decoder->seac = TRUE;
       error = cff_decoder_parse_charstrings( decoder, charstring,
                                              charstring_len );
       decoder->seac = FALSE;
 
       cff_free_glyph_data( face, &charstring, charstring_len );
@@ skipping 52 matching lines @@
                          decoder->cff->top_font.font_dict.charstring_type;
 
     T2_Hints_Funcs     hinter;
 
 
     /* set default width */
     decoder->num_hints  = 0;
     decoder->read_width = 1;
 
     /* compute random seed from stack address of parameter */
-    seed = (FT_Fixed)( ( (FT_PtrDist)(char*)&seed              ^
-                         (FT_PtrDist)(char*)&decoder           ^
-                         (FT_PtrDist)(char*)&charstring_base ) &
-                         FT_ULONG_MAX ) ;
+    seed = (FT_Fixed)( ( (FT_Offset)(char*)&seed            ^
+                         (FT_Offset)(char*)&decoder         ^
+                         (FT_Offset)(char*)&charstring_base ) &
+                         FT_ULONG_MAX                         );
     seed = ( seed ^ ( seed >> 10 ) ^ ( seed >> 20 ) ) & 0xFFFFL;
     if ( seed == 0 )
       seed = 0x7384;
 
     /* initialize the decoder */
     decoder->top  = decoder->stack;
     decoder->zone = decoder->zones;
     zone          = decoder->zones;
     stack         = decoder->top;
 
@@ skipping 427 matching lines @@
           /* instruction).  Additionally, there must be space for  */
           /* `num_hints' bits.                                     */
 
           if ( ( ip + ( ( decoder->num_hints + 7 ) >> 3 ) ) >= limit )
             goto Syntax_Error;
 
           if ( hinter )
           {
             if ( op == cff_op_hintmask )
               hinter->hintmask( hinter->hints,
-                                builder->current->n_points,
-                                decoder->num_hints,
+                                (FT_UInt)builder->current->n_points,
+                                (FT_UInt)decoder->num_hints,
                                 ip );
             else
               hinter->counter( hinter->hints,
-                               decoder->num_hints,
+                               (FT_UInt)decoder->num_hints,
                                ip );
           }
 
 #ifdef FT_DEBUG_LEVEL_TRACE
           {
             FT_UInt maskbyte;
 
 
             FT_TRACE4(( " (maskbytes:" ));
 
@@ skipping 596 matching lines @@
             decoder->glyph_width = glyph_width;
           }
           else
           {
             cff_builder_close_contour( builder );
 
             /* close hints recording session */
             if ( hinter )
             {
               if ( hinter->close( hinter->hints,
-                                  builder->current->n_points ) )
+                                  (FT_UInt)builder->current->n_points ) )
                 goto Syntax_Error;
 
               /* apply hints to the loaded glyph outline now */
               error = hinter->apply( hinter->hints,
                                      builder->current,
                                      (PSH_Globals)builder->hints_globals,
                                      decoder->hint_mode );
               if ( error )
                 goto Fail;
             }
@@ skipping 373 matching lines @@
             args++;
           }
           break;
 
         case cff_op_callsubr:
           {
             FT_UInt  idx = (FT_UInt)( ( args[0] >> 16 ) +
                                       decoder->locals_bias );
 
 
-            FT_TRACE4(( " callsubr(%d)\n", idx ));
+            FT_TRACE4(( " callsubr (idx %d, entering level %d)\n",
+                        idx,
+                        zone - decoder->zones + 1 ));
 
             if ( idx >= decoder->num_locals )
             {
               FT_ERROR(( "cff_decoder_parse_charstrings:"
                          " invalid local subr index\n" ));
               goto Syntax_Error;
             }
 
             if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
             {
@@ skipping 21 matching lines @@
             limit         = zone->limit;
           }
           break;
 
         case cff_op_callgsubr:
           {
             FT_UInt  idx = (FT_UInt)( ( args[0] >> 16 ) +
                                       decoder->globals_bias );
 
 
-            FT_TRACE4(( " callgsubr(%d)\n", idx ));
+            FT_TRACE4(( " callgsubr (idx %d, entering level %d)\n",
+                        idx,
+                        zone - decoder->zones + 1 ));
 
             if ( idx >= decoder->num_globals )
             {
               FT_ERROR(( "cff_decoder_parse_charstrings:"
                          " invalid global subr index\n" ));
               goto Syntax_Error;
             }
 
             if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
             {
@@ skipping 16 matching lines @@
               goto Syntax_Error;
             }
 
             decoder->zone = zone;
             ip            = zone->base;
             limit         = zone->limit;
           }
           break;
 
         case cff_op_return:
-          FT_TRACE4(( " return\n" ));
+          FT_TRACE4(( " return (leaving level %d)\n",
+                      decoder->zone - decoder->zones ));
 
           if ( decoder->zone <= decoder->zones )
           {
             FT_ERROR(( "cff_decoder_parse_charstrings:"
                        " unexpected return\n" ));
             goto Syntax_Error;
           }
 
           decoder->zone--;
           zone  = decoder->zone;
@@ skipping 180 matching lines @@
       if ( size->strike_index != 0xFFFFFFFFUL      &&
            sfnt->load_eblc                         &&
            ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
       {
         TT_SBit_MetricsRec  metrics;
 
 
         error = sfnt->load_sbit_image( face,
                                        size->strike_index,
                                        glyph_index,
-                                       (FT_Int)load_flags,
+                                       (FT_UInt)load_flags,
                                        stream,
                                        &glyph->root.bitmap,
                                        &metrics );
 
         if ( !error )
         {
           FT_Bool    has_vertical_info;
           FT_UShort  advance;
           FT_Short   dummy;
 
@@ skipping 30 matching lines @@
           (void)( (SFNT_Service)face->sfnt )->get_metrics( face, 0,
                                                            glyph_index,
                                                            &dummy,
                                                            &advance );
           glyph->root.linearHoriAdvance = advance;
 
           has_vertical_info = FT_BOOL(
                                 face->vertical_info                   &&
                                 face->vertical.number_Of_VMetrics > 0 );
 
-          /* get the vertical metrics from the vtmx table if we have one */
+          /* get the vertical metrics from the vmtx table if we have one */
           if ( has_vertical_info )
           {
             (void)( (SFNT_Service)face->sfnt )->get_metrics( face, 1,
                                                              glyph_index,
                                                              &dummy,
                                                              &advance );
             glyph->root.linearVertAdvance = advance;
           }
           else
           {
@@ skipping 16 matching lines @@
     /* return immediately if we only want the embedded bitmaps */
     if ( load_flags & FT_LOAD_SBITS_ONLY )
       return FT_THROW( Invalid_Argument );
 
     /* if we have a CID subfont, use its matrix (which has already */
     /* been multiplied with the root matrix)                       */
 
     /* this scaling is only relevant if the PS hinter isn't active */
     if ( cff->num_subfonts )
     {
-      FT_ULong  top_upm, sub_upm;
-      FT_Byte   fd_index = cff_fd_select_get( &cff->fd_select,
-                                              glyph_index );
+      FT_Long  top_upm, sub_upm;
+      FT_Byte  fd_index = cff_fd_select_get( &cff->fd_select,
+                                             glyph_index );
 
 
       if ( fd_index >= cff->num_subfonts )
         fd_index = (FT_Byte)( cff->num_subfonts - 1 );
 
-      top_upm = cff->top_font.font_dict.units_per_em;
-      sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
+      top_upm = (FT_Long)cff->top_font.font_dict.units_per_em;
+      sub_upm = (FT_Long)cff->subfonts[fd_index]->font_dict.units_per_em;
 
 
       font_matrix = cff->subfonts[fd_index]->font_dict.font_matrix;
       font_offset = cff->subfonts[fd_index]->font_dict.font_offset;
 
       if ( top_upm != sub_upm )
       {
         glyph->x_scale = FT_MulDiv( glyph->x_scale, top_upm, sub_upm );
         glyph->y_scale = FT_MulDiv( glyph->y_scale, top_upm, sub_upm );
 
@@ skipping 80 matching lines @@
       cff_free_glyph_data( face, &charstring, charstring_len );
 
       if ( error )
         goto Glyph_Build_Finished;
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
       /* Control data and length may not be available for incremental */
       /* fonts.                                                       */
       if ( face->root.internal->incremental_interface )
       {
-        glyph->root.control_data = 0;
+        glyph->root.control_data = NULL;
         glyph->root.control_len = 0;
       }
       else
 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
 
       /* We set control_data and control_len if charstrings is loaded. */
       /* See how charstring loads at cff_index_access_element() in     */
       /* cffload.c.                                                    */
       {
         CFF_Index  csindex = &cff->charstrings_index;
 
 
         if ( csindex->offsets )
         {
           glyph->root.control_data = csindex->bytes +
                                      csindex->offsets[glyph_index] - 1;
-          glyph->root.control_len  = charstring_len;
+          glyph->root.control_len  = (FT_Long)charstring_len;
         }
       }
 
   Glyph_Build_Finished:
       /* save new glyph tables, if no error */
       if ( !error )
         cff_builder_done( &decoder.builder );
       /* XXX: anything to do for broken glyph entry? */
     }
 
@@ skipping 39 matching lines @@
         glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
         glyph->root.metrics.horiAdvance  = decoder.glyph_width;
         internal->glyph_matrix           = font_matrix;
         internal->glyph_delta            = font_offset;
         internal->glyph_transformed      = 1;
       }
       else
       {
         FT_BBox            cbox;
         FT_Glyph_Metrics*  metrics = &glyph->root.metrics;
-        FT_Vector          advance;
         FT_Bool            has_vertical_info;
 
 
-        /* copy the _unscaled_ advance width */
-        metrics->horiAdvance                    = decoder.glyph_width;
-        glyph->root.linearHoriAdvance           = decoder.glyph_width;
+        if ( face->horizontal.number_Of_HMetrics )
+        {
+          FT_Short   horiBearingX = 0;
+          FT_UShort  horiAdvance  = 0;
+
+
+          ( (SFNT_Service)face->sfnt )->get_metrics( face, 0,
+                                                     glyph_index,
+                                                     &horiBearingX,
+                                                     &horiAdvance );
+          metrics->horiAdvance          = horiAdvance;
+          metrics->horiBearingX         = horiBearingX;
+          glyph->root.linearHoriAdvance = horiAdvance;
+        }
+        else
+        {
+          /* copy the _unscaled_ advance width */
+          metrics->horiAdvance          = decoder.glyph_width;
+          glyph->root.linearHoriAdvance = decoder.glyph_width;
+        }
+
         glyph->root.internal->glyph_transformed = 0;
 
         has_vertical_info = FT_BOOL( face->vertical_info                   &&
                                      face->vertical.number_Of_VMetrics > 0 );
 
-        /* get the vertical metrics from the vtmx table if we have one */
+        /* get the vertical metrics from the vmtx table if we have one */
         if ( has_vertical_info )
         {
           FT_Short   vertBearingY = 0;
           FT_UShort  vertAdvance  = 0;
 
 
-          (void)( (SFNT_Service)face->sfnt )->get_metrics( face, 1,
-                                                           glyph_index,
-                                                           &vertBearingY,
-                                                           &vertAdvance );
+          ( (SFNT_Service)face->sfnt )->get_metrics( face, 1,
+                                                     glyph_index,
+                                                     &vertBearingY,
+                                                     &vertAdvance );
           metrics->vertBearingY = vertBearingY;
           metrics->vertAdvance  = vertAdvance;
         }
         else
         {
           /* make up vertical ones */
           if ( face->os2.version != 0xFFFFU )
             metrics->vertAdvance = (FT_Pos)( face->os2.sTypoAscender -
                                              face->os2.sTypoDescender );
           else
             metrics->vertAdvance = (FT_Pos)( face->horizontal.Ascender -
                                              face->horizontal.Descender );
         }
 
         glyph->root.linearVertAdvance = metrics->vertAdvance;
 
         glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;
 
         glyph->root.outline.flags = 0;
         if ( size && size->root.metrics.y_ppem < 24 )
           glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;
 
         glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;
 
-        if ( !( font_matrix.xx == 0x10000L &&
-                font_matrix.yy == 0x10000L &&
-                font_matrix.xy == 0        &&
-                font_matrix.yx == 0        ) )
+        /* apply the font matrix, if any */
+        if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||
+             font_matrix.xy != 0        || font_matrix.yx != 0        )
+        {
           FT_Outline_Transform( &glyph->root.outline, &font_matrix );
 
-        if ( !( font_offset.x == 0 &&
-                font_offset.y == 0 ) )
+          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,
+                                            font_matrix.xx );
+          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,
+                                            font_matrix.yy );
+        }
+
+        if ( font_offset.x || font_offset.y )
+        {
           FT_Outline_Translate( &glyph->root.outline,
-                                font_offset.x, font_offset.y );
+                                font_offset.x,
+                                font_offset.y );
 
-        advance.x = metrics->horiAdvance;
-        advance.y = 0;
-        FT_Vector_Transform( &advance, &font_matrix );
-        metrics->horiAdvance = advance.x + font_offset.x;
-
-        advance.x = 0;
-        advance.y = metrics->vertAdvance;
-        FT_Vector_Transform( &advance, &font_matrix );
-        metrics->vertAdvance = advance.y + font_offset.y;
+          metrics->horiAdvance += font_offset.x;
+          metrics->vertAdvance += font_offset.y;
+        }
 
         if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || force_scaling )
         {
           /* scale the outline and the metrics */
           FT_Int       n;
           FT_Outline*  cur     = &glyph->root.outline;
           FT_Vector*   vec     = cur->points;
           FT_Fixed     x_scale = glyph->x_scale;
           FT_Fixed     y_scale = glyph->y_scale;
 
@@ skipping 30 matching lines @@
                                             metrics->vertAdvance );
         }
       }
     }
 
     return error;
   }
 
 
 /* END */