Update bundled freetype to 2.6.1

third_party/freetype/src/type1/t1load.c

 /***************************************************************************/
 /*                                                                         */
 /*  t1load.c                                                               */
 /*                                                                         */
 /*    Type 1 font 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 201 matching lines @@
 
     return error;
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* Given a normalized (blend) coordinate, figure out the design          */
   /* coordinate appropriate for that value.                                */
   /*                                                                       */
-  FT_LOCAL_DEF( FT_Fixed )
+  static FT_Fixed
   mm_axis_unmap( PS_DesignMap  axismap,
                  FT_Fixed      ncv )
   {
     int  j;
 
 
     if ( ncv <= axismap->blend_points[0] )
       return INT_TO_FIXED( axismap->design_points[0] );
 
     for ( j = 1; j < axismap->num_points; ++j )
     {
       if ( ncv <= axismap->blend_points[j] )
         return INT_TO_FIXED( axismap->design_points[j - 1] ) +
                ( axismap->design_points[j] - axismap->design_points[j - 1] ) *
                FT_DivFix( ncv - axismap->blend_points[j - 1],
                           axismap->blend_points[j] -
                             axismap->blend_points[j - 1] );
     }
 
     return INT_TO_FIXED( axismap->design_points[axismap->num_points - 1] );
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* Given a vector of weights, one for each design, figure out the        */
   /* normalized axis coordinates which gave rise to those weights.         */
   /*                                                                       */
-  FT_LOCAL_DEF( void )
+  static void
   mm_weights_unmap( FT_Fixed*  weights,
                     FT_Fixed*  axiscoords,
                     FT_UInt    axis_count )
   {
     FT_ASSERT( axis_count <= T1_MAX_MM_AXIS );
 
     if ( axis_count == 1 )
       axiscoords[0] = weights[1];
 
     else if ( axis_count == 2 )
@@ skipping 92 matching lines @@
     return error;
   }
 
 
   FT_LOCAL_DEF( FT_Error )
   T1_Set_MM_Blend( T1_Face    face,
                    FT_UInt    num_coords,
                    FT_Fixed*  coords )
   {
     PS_Blend  blend = face->blend;
-    FT_Error  error;
     FT_UInt   n, m;
 
 
-    error = FT_ERR( Invalid_Argument );
+    if ( !blend )
+      return FT_THROW( Invalid_Argument );
 
-    if ( blend && blend->num_axis == num_coords )
+    if ( num_coords > blend->num_axis )
+      num_coords = blend->num_axis;
+
+    /* recompute the weight vector from the blend coordinates */
+    for ( n = 0; n < blend->num_designs; n++ )
     {
-      /* recompute the weight vector from the blend coordinates */
-      for ( n = 0; n < blend->num_designs; n++ )
-      {
-        FT_Fixed  result = 0x10000L;  /* 1.0 fixed */
+      FT_Fixed  result = 0x10000L;  /* 1.0 fixed */
 
 
-        for ( m = 0; m < blend->num_axis; m++ )
-        {
-          FT_Fixed  factor;
+      for ( m = 0; m < blend->num_axis; m++ )
+      {
+        FT_Fixed  factor;
 
 
-          /* get current blend axis position */
-          factor = coords[m];
-          if ( factor < 0 )
-            factor = 0;
-          if ( factor > 0x10000L )
-            factor = 0x10000L;
+        /* get current blend axis position;                  */
+        /* use a default value if we don't have a coordinate */
+        factor = m < num_coords ? coords[m] : 0x8000;
+        if ( factor < 0 )
+          factor = 0;
+        if ( factor > 0x10000L )
+          factor = 0x10000L;
 
-          if ( ( n & ( 1 << m ) ) == 0 )
-            factor = 0x10000L - factor;
+        if ( ( n & ( 1 << m ) ) == 0 )
+          factor = 0x10000L - factor;
 
-          result = FT_MulFix( result, factor );
-        }
-        blend->weight_vector[n] = result;
+        result = FT_MulFix( result, factor );
       }
-
-      error = FT_Err_Ok;
+      blend->weight_vector[n] = result;
     }
 
-    return error;
+    return FT_Err_Ok;
   }
 
 
   FT_LOCAL_DEF( FT_Error )
   T1_Set_MM_Design( T1_Face   face,
                     FT_UInt   num_coords,
                     FT_Long*  coords )
   {
     PS_Blend  blend = face->blend;
-    FT_Error  error;
     FT_UInt   n, p;
+    FT_Fixed  final_blends[T1_MAX_MM_DESIGNS];
 
 
-    error = FT_ERR( Invalid_Argument );
-    if ( blend && blend->num_axis == num_coords )
+    if ( !blend )
+      return FT_THROW( Invalid_Argument );
+
+    if ( num_coords > blend->num_axis )
+      num_coords = blend->num_axis;
+
+    /* compute the blend coordinates through the blend design map */
+
+    for ( n = 0; n < blend->num_axis; n++ )
     {
-      /* compute the blend coordinates through the blend design map */
-      FT_Fixed  final_blends[T1_MAX_MM_DESIGNS];
+      FT_Long       design;
+      FT_Fixed      the_blend;
+      PS_DesignMap  map     = blend->design_map + n;
+      FT_Long*      designs = map->design_points;
+      FT_Fixed*     blends  = map->blend_points;
+      FT_Int        before  = -1, after = -1;
 
 
-      for ( n = 0; n < blend->num_axis; n++ )
+      /* use a default value if we don't have a coordinate */
+      if ( n < num_coords )
+        design = coords[n];
+      else
+        design = ( designs[map->num_points - 1] - designs[0] ) / 2;
+
+      for ( p = 0; p < (FT_UInt)map->num_points; p++ )
       {
-        FT_Long       design  = coords[n];
-        FT_Fixed      the_blend;
-        PS_DesignMap  map     = blend->design_map + n;
-        FT_Long*      designs = map->design_points;
-        FT_Fixed*     blends  = map->blend_points;
-        FT_Int        before  = -1, after = -1;
+        FT_Long  p_design = designs[p];
 
 
-        for ( p = 0; p < (FT_UInt)map->num_points; p++ )
+        /* exact match? */
+        if ( design == p_design )
         {
-          FT_Long  p_design = designs[p];
-
-
-          /* exact match? */
-          if ( design == p_design )
-          {
-            the_blend = blends[p];
-            goto Found;
-          }
-
-          if ( design < p_design )
-          {
-            after = p;
-            break;
-          }
-
-          before = p;
+          the_blend = blends[p];
+          goto Found;
         }
 
-        /* now interpolate if necessary */
-        if ( before < 0 )
-          the_blend = blends[0];
+        if ( design < p_design )
+        {
+          after = (FT_Int)p;
+          break;
+        }
 
-        else if ( after < 0 )
-          the_blend = blends[map->num_points - 1];
-
-        else
-          the_blend = FT_MulDiv( design         - designs[before],
-                                 blends [after] - blends [before],
-                                 designs[after] - designs[before] );
-
-      Found:
-        final_blends[n] = the_blend;
+        before = (FT_Int)p;
       }
 
-      error = T1_Set_MM_Blend( face, num_coords, final_blends );
+      /* now interpolate if necessary */
+      if ( before < 0 )
+        the_blend = blends[0];
+
+      else if ( after < 0 )
+        the_blend = blends[map->num_points - 1];
+
+      else
+        the_blend = FT_MulDiv( design         - designs[before],
+                               blends [after] - blends [before],
+                               designs[after] - designs[before] );
+
+    Found:
+      final_blends[n] = the_blend;
     }
 
-    return error;
+    return T1_Set_MM_Blend( face, blend->num_axis, final_blends );
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* Just a wrapper around T1_Set_MM_Design to support the different       */
   /* arguments needed by the GX var distortable fonts.                     */
   /*                                                                       */
   FT_LOCAL_DEF( FT_Error )
   T1_Set_Var_Design( T1_Face    face,
                      FT_UInt    num_coords,
                      FT_Fixed*  coords )
   {
-     FT_Long   lcoords[4];          /* maximum axis count is 4 */
-     FT_UInt   i;
-     FT_Error  error;
+     FT_Long  lcoords[T1_MAX_MM_AXIS];
+     FT_UInt  i;
 
 
-     error = FT_ERR( Invalid_Argument );
-     if ( num_coords <= 4 && num_coords > 0 )
-     {
-       for ( i = 0; i < num_coords; ++i )
-         lcoords[i] = FIXED_TO_INT( coords[i] );
-       error = T1_Set_MM_Design( face, num_coords, lcoords );
-     }
+     if ( num_coords > T1_MAX_MM_AXIS )
+       num_coords = T1_MAX_MM_AXIS;
 
-     return error;
+     for ( i = 0; i < num_coords; ++i )
+       lcoords[i] = FIXED_TO_INT( coords[i] );
+
+     return T1_Set_MM_Design( face, num_coords, lcoords );
   }
 
 
   FT_LOCAL_DEF( void )
   T1_Done_Blend( T1_Face  face )
   {
     FT_Memory  memory = face->root.memory;
     PS_Blend   blend  = face->blend;
 
 
@@ skipping 75 matching lines @@
     error = t1_allocate_blend( face, 0, (FT_UInt)num_axis );
     if ( error )
       goto Exit;
 
     blend  = face->blend;
     memory = face->root.memory;
 
     /* each token is an immediate containing the name of the axis */
     for ( n = 0; n < num_axis; n++ )
     {
-      T1_Token    token = axis_tokens + n;
-      FT_Byte*    name;
-      FT_PtrDist  len;
+      T1_Token  token = axis_tokens + n;
+      FT_Byte*  name;
+      FT_UInt   len;
 
 
       /* skip first slash, if any */
       if ( token->start[0] == '/' )
         token->start++;
 
-      len = token->limit - token->start;
+      len = (FT_UInt)( token->limit - token->start );
       if ( len == 0 )
       {
         error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
 
-      if ( FT_ALLOC( blend->axis_names[n], (FT_Long)( len + 1 ) ) )
+      name = (FT_Byte*)blend->axis_names[n];
+      if ( name )
+      {
+        FT_TRACE0(( "parse_blend_axis_types:"
+                    " overwriting axis name `%s' with `%*.s'\n",
+                    name, len, token->start ));
+        FT_FREE( name );
+      }
+
+      if ( FT_ALLOC( blend->axis_names[n], len + 1 ) )
         goto Exit;
 
       name = (FT_Byte*)blend->axis_names[n];
       FT_MEM_COPY( name, token->start, len );
       name[len] = '\0';
     }
 
   Exit:
     loader->parser.root.error = error;
   }
@@ skipping 56 matching lines @@
           if ( n_axis <= 0 || n_axis > T1_MAX_MM_AXIS )
           {
             FT_ERROR(( "parse_blend_design_positions:"
                        " invalid number of axes: %d\n",
                        n_axis ));
             error = FT_THROW( Invalid_File_Format );
             goto Exit;
           }
 
           num_axis = n_axis;
-          error = t1_allocate_blend( face, num_designs, num_axis );
+          error = t1_allocate_blend( face,
+                                     (FT_UInt)num_designs,
+                                     (FT_UInt)num_axis );
           if ( error )
             goto Exit;
           blend = face->blend;
         }
         else if ( n_axis != num_axis )
         {
           FT_ERROR(( "parse_blend_design_positions: incorrect table\n" ));
           error = FT_THROW( Invalid_File_Format );
           goto Exit;
         }
@@ skipping 44 matching lines @@
     {
       FT_ERROR(( "parse_blend_design_map: incorrect number of axes: %d\n",
                  num_axis ));
       error = FT_THROW( Invalid_File_Format );
       goto Exit;
     }
 
     old_cursor = parser->root.cursor;
     old_limit  = parser->root.limit;
 
-    error = t1_allocate_blend( face, 0, num_axis );
+    error = t1_allocate_blend( face, 0, (FT_UInt)num_axis );
     if ( error )
       goto Exit;
     blend = face->blend;
 
     /* now read each axis design map */
     for ( n = 0; n < num_axis; n++ )
     {
       PS_DesignMap  map = blend->design_map + n;
       T1_Token      axis_token;
       T1_TokenRec   point_tokens[T1_MAX_MM_MAP_POINTS];
       FT_Int        p, num_points;
 
 
       axis_token = axis_tokens + n;
 
       parser->root.cursor = axis_token->start;
       parser->root.limit  = axis_token->limit;
       T1_ToTokenArray( parser, point_tokens,
                        T1_MAX_MM_MAP_POINTS, &num_points );
 
       if ( num_points <= 0 || num_points > T1_MAX_MM_MAP_POINTS )
       {
         FT_ERROR(( "parse_blend_design_map: incorrect table\n" ));
         error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
 
+      if ( map->design_points )
+      {
+        FT_ERROR(( "parse_blend_design_map: duplicate table\n" ));
+        error = FT_THROW( Invalid_File_Format );
+        goto Exit;
+      }
+
       /* allocate design map data */
       if ( FT_NEW_ARRAY( map->design_points, num_points * 2 ) )
         goto Exit;
       map->blend_points = map->design_points + num_points;
       map->num_points   = (FT_Byte)num_points;
 
       for ( p = 0; p < num_points; p++ )
       {
         T1_Token  point_token;
 
@@ skipping 43 matching lines @@
     {
       FT_ERROR(( "parse_weight_vector:"
                  " incorrect number of designs: %d\n",
                  num_designs ));
       error = FT_THROW( Invalid_File_Format );
       goto Exit;
     }
 
     if ( !blend || !blend->num_designs )
     {
-      error = t1_allocate_blend( face, num_designs, 0 );
+      error = t1_allocate_blend( face, (FT_UInt)num_designs, 0 );
       if ( error )
         goto Exit;
       blend = face->blend;
     }
     else if ( blend->num_designs != (FT_UInt)num_designs )
     {
       FT_ERROR(( "parse_weight_vector:"
                  " /BlendDesignPosition and /WeightVector have\n"
                  "                    "
                  " different number of elements\n" ));
@@ skipping 21 matching lines @@
     parser->root.error = error;
   }
 
 
   /* e.g., /BuildCharArray [0 0 0 0 0 0 0 0] def           */
   /* we're only interested in the number of array elements */
   static void
   parse_buildchar( T1_Face    face,
                    T1_Loader  loader )
   {
-    face->len_buildchar = T1_ToFixedArray( &loader->parser, 0, NULL, 0 );
-
+    face->len_buildchar = (FT_UInt)T1_ToFixedArray( &loader->parser,
+                                                    0, NULL, 0 );
     return;
   }
 
 
 #endif /* !T1_CONFIG_OPTION_NO_MM_SUPPORT */
 
 
 
 
   /*************************************************************************/
@@ skipping 126 matching lines @@
   static void
   parse_private( T1_Face    face,
                  T1_Loader  loader )
   {
     FT_UNUSED( face );
 
     loader->keywords_encountered |= T1_PRIVATE;
   }
 
 
+  /* return 1 in case of success */
+
   static int
   read_binary_data( T1_Parser  parser,
-                    FT_Long*   size,
+                    FT_ULong*  size,
                     FT_Byte**  base,
                     FT_Bool    incremental )
   {
     FT_Byte*  cur;
     FT_Byte*  limit = parser->root.limit;
 
 
     /* the binary data has one of the following formats */
     /*                                                  */
     /*   `size' [white*] RD white ....... ND            */
@@ skipping 11 matching lines @@
 
       T1_Skip_PS_Token( parser );   /* `RD' or `-|' or something else */
 
       /* there is only one whitespace char after the */
       /* `RD' or `-|' token                          */
       *base = parser->root.cursor + 1;
 
       if ( s >= 0 && s < limit - *base )
       {
         parser->root.cursor += s + 1;
-        *size = s;
+        *size = (FT_ULong)s;
         return !parser->root.error;
       }
     }
 
     if( !incremental )
     {
       FT_ERROR(( "read_binary_data: invalid size field\n" ));
       parser->root.error = FT_THROW( Invalid_File_Format );
     }
 
@@ skipping 10 matching lines @@
   {
     T1_Parser   parser = &loader->parser;
     FT_Matrix*  matrix = &face->type1.font_matrix;
     FT_Vector*  offset = &face->type1.font_offset;
     FT_Face     root   = (FT_Face)&face->root;
     FT_Fixed    temp[6];
     FT_Fixed    temp_scale;
     FT_Int      result;
 
 
+    /* input is scaled by 1000 to accommodate default FontMatrix */
     result = T1_ToFixedArray( parser, 6, temp, 3 );
 
     if ( result < 6 )
     {
       parser->root.error = FT_THROW( Invalid_File_Format );
       return;
     }
 
     temp_scale = FT_ABS( temp[3] );
 
     if ( temp_scale == 0 )
     {
       FT_ERROR(( "t1_parse_font_matrix: invalid font matrix\n" ));
       parser->root.error = FT_THROW( Invalid_File_Format );
       return;
     }
 
-    /* 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_scale */
+    /* 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 41 matching lines @@
       /* read the number of entries in the encoding; should be 256 */
       if ( *cur == '[' )
       {
         count           = 256;
         only_immediates = 1;
         parser->root.cursor++;
       }
       else
         count = (FT_Int)T1_ToInt( parser );
 
+      /* only composite fonts (which we don't support) */
+      /* can have larger values                        */
+      if ( count > 256 )
+      {
+        FT_ERROR(( "parse_encoding: invalid encoding array size\n" ));
+        parser->root.error = FT_THROW( Invalid_File_Format );
+        return;
+      }
+
       T1_Skip_Spaces( parser );
       if ( parser->root.cursor >= limit )
         return;
 
+      /* PostScript happily allows overwriting of encoding arrays */
+      if ( encode->char_index )
+      {
+        FT_FREE( encode->char_index );
+        FT_FREE( encode->char_name );
+        T1_Release_Table( char_table );
+      }
+
       /* we use a T1_Table to store our charnames */
       loader->num_chars = encode->num_chars = count;
       if ( FT_NEW_ARRAY( encode->char_index, count )     ||
            FT_NEW_ARRAY( encode->char_name,  count )     ||
            FT_SET_ERROR( psaux->ps_table_funcs->init(
                            char_table, count, memory ) ) )
       {
         parser->root.error = error;
         return;
       }
@@ skipping 71 matching lines @@
             {
               parser->root.error = FT_THROW( Unknown_File_Format );
               return;
             }
           }
 
           cur = parser->root.cursor;
 
           if ( cur + 2 < limit && *cur == '/' && n < count )
           {
-            FT_PtrDist  len;
+            FT_UInt  len;
 
 
             cur++;
 
             parser->root.cursor = cur;
             T1_Skip_PS_Token( parser );
             if ( parser->root.cursor >= limit )
               return;
             if ( parser->root.error )
               return;
 
-            len = parser->root.cursor - cur;
+            len = (FT_UInt)( parser->root.cursor - cur );
 
             parser->root.error = T1_Add_Table( char_table, charcode,
                                                cur, len + 1 );
             if ( parser->root.error )
               return;
             char_table->elements[charcode][len] = '\0';
 
             n++;
           }
           else if ( only_immediates )
@@ skipping 89 matching lines @@
       if ( error )
         goto Fail;
     }
 
     /* the format is simple:   */
     /*                         */
     /*   `index' + binary data */
     /*                         */
     for (;;)
     {
-      FT_Long   idx, size;
+      FT_Long   idx;
+      FT_ULong  size;
       FT_Byte*  base;
 
 
       /* If we are out of data, or if the next token isn't `dup', */
       /* we are done.                                             */
       if ( parser->root.cursor + 4 >= parser->root.limit          ||
           ft_strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 )
         break;
 
       T1_Skip_PS_Token( parser );       /* `dup' */
@@ skipping 29 matching lines @@
       /* thanks to Tom Kacvinsky for pointing this out           */
       /*                                                         */
       if ( face->type1.private_dict.lenIV >= 0 )
       {
         FT_Byte*  temp;
 
 
         /* some fonts define empty subr records -- this is not totally */
         /* compliant to the specification (which says they should at   */
         /* least contain a `return'), but we support them anyway       */
-        if ( size < face->type1.private_dict.lenIV )
+        if ( size < (FT_ULong)face->type1.private_dict.lenIV )
         {
           error = FT_THROW( Invalid_File_Format );
           goto Fail;
         }
 
         /* t1_decrypt() shouldn't write to base -- make temporary copy */
         if ( FT_ALLOC( temp, size ) )
           goto Fail;
         FT_MEM_COPY( temp, base, size );
         psaux->t1_decrypt( temp, size, 4330 );
-        size -= face->type1.private_dict.lenIV;
+        size -= (FT_ULong)face->type1.private_dict.lenIV;
         error = T1_Add_Table( table, (FT_Int)idx,
                               temp + face->type1.private_dict.lenIV, size );
         FT_FREE( temp );
       }
       else
         error = T1_Add_Table( table, (FT_Int)idx, base, size );
       if ( error )
         goto Fail;
     }
 
@@ skipping 16 matching lines @@
   {
     T1_Parser      parser       = &loader->parser;
     PS_Table       code_table   = &loader->charstrings;
     PS_Table       name_table   = &loader->glyph_names;
     PS_Table       swap_table   = &loader->swap_table;
     FT_Memory      memory       = parser->root.memory;
     FT_Error       error;
 
     PSAux_Service  psaux        = (PSAux_Service)face->psaux;
 
-    FT_Byte*       cur;
+    FT_Byte*       cur          = parser->root.cursor;
     FT_Byte*       limit        = parser->root.limit;
     FT_Int         n, num_glyphs;
-    FT_UInt        notdef_index = 0;
+    FT_Int         notdef_index = 0;
     FT_Byte        notdef_found = 0;
 
 
     num_glyphs = (FT_Int)T1_ToInt( parser );
     if ( num_glyphs < 0 )
     {
       error = FT_THROW( Invalid_File_Format );
       goto Fail;
     }
 
+    /* we certainly need more than 8 bytes per glyph */
+    if ( num_glyphs > ( limit - cur ) >> 3 )
+    {
+      FT_TRACE0(( "parse_charstrings: adjusting number of glyphs"
+                  " (from %d to %d)\n",
+                  num_glyphs, ( limit - cur ) >> 3 ));
+      num_glyphs = ( limit - cur ) >> 3;
+    }
+
     /* some fonts like Optima-Oblique not only define the /CharStrings */
     /* array but access it also                                        */
     if ( num_glyphs == 0 || parser->root.error )
       return;
 
     /* initialize tables, leaving space for addition of .notdef, */
     /* if necessary, and a few other glyphs to handle buggy      */
     /* fonts which have more glyphs than specified.              */
 
     /* for some non-standard fonts like `Optima' which provides  */
@@ skipping 16 matching lines @@
 
       error = psaux->ps_table_funcs->init( swap_table, 4, memory );
       if ( error )
         goto Fail;
     }
 
     n = 0;
 
     for (;;)
     {
-      FT_Long   size;
+      FT_ULong  size;
       FT_Byte*  base;
 
 
       /* the format is simple:        */
       /*   `/glyphname' + binary data */
 
       T1_Skip_Spaces( parser );
 
       cur = parser->root.cursor;
       if ( cur >= limit )
@@ skipping 30 matching lines @@
       if ( parser->root.cursor >= limit )
       {
         error = FT_THROW( Invalid_File_Format );
         goto Fail;
       }
       if ( parser->root.error )
         return;
 
       if ( *cur == '/' )
       {
-        FT_PtrDist  len;
+        FT_UInt  len;
 
 
         if ( cur + 2 >= limit )
         {
           error = FT_THROW( Invalid_File_Format );
           goto Fail;
         }
 
         cur++;                              /* skip `/' */
-        len = parser->root.cursor - cur;
+        len = (FT_UInt)( parser->root.cursor - cur );
 
         if ( !read_binary_data( parser, &size, &base, IS_INCREMENTAL ) )
           return;
 
         /* for some non-standard fonts like `Optima' which provides */
         /* different outlines depending on the resolution it is     */
         /* possible to get here twice                               */
         if ( loader->num_glyphs )
           continue;
 
@@ skipping 12 matching lines @@
           notdef_index = n;
           notdef_found = 1;
         }
 
         if ( face->type1.private_dict.lenIV >= 0 &&
              n < num_glyphs + TABLE_EXTEND       )
         {
           FT_Byte*  temp;
 
 
-          if ( size <= face->type1.private_dict.lenIV )
+          if ( size <= (FT_ULong)face->type1.private_dict.lenIV )
           {
             error = FT_THROW( Invalid_File_Format );
             goto Fail;
           }
 
           /* t1_decrypt() shouldn't write to base -- make temporary copy */
           if ( FT_ALLOC( temp, size ) )
             goto Fail;
           FT_MEM_COPY( temp, base, size );
           psaux->t1_decrypt( temp, size, 4330 );
-          size -= face->type1.private_dict.lenIV;
+          size -= (FT_ULong)face->type1.private_dict.lenIV;
           error = T1_Add_Table( code_table, n,
                                 temp + face->type1.private_dict.lenIV, size );
           FT_FREE( temp );
         }
         else
           error = T1_Add_Table( code_table, n, base, size );
         if ( error )
           goto Fail;
 
         n++;
@@ skipping 157 matching lines @@
     T1_FIELD_CALLBACK( "WeightVector",         parse_weight_vector,
                        T1_FIELD_DICT_FONTDICT )
     T1_FIELD_CALLBACK( "BuildCharArray",       parse_buildchar,
                        T1_FIELD_DICT_PRIVATE )
 #endif
 
     { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0, 0 }
   };
 
 
-#define T1_FIELD_COUNT                                           \
-          ( sizeof ( t1_keywords ) / sizeof ( t1_keywords[0] ) )
-
-
   static FT_Error
   parse_dict( T1_Face    face,
               T1_Loader  loader,
               FT_Byte*   base,
-              FT_Long    size )
+              FT_ULong   size )
   {
     T1_Parser  parser = &loader->parser;
     FT_Byte   *limit, *start_binary = NULL;
     FT_Bool    have_integer = 0;
 
 
     parser->root.cursor = base;
     parser->root.limit  = base + size;
     parser->root.error  = FT_Err_Ok;
 
@@ skipping 35 matching lines @@
           goto Exit;
         have_integer = 1;
       }
 
       /* in valid Type 1 fonts we don't see `RD' or `-|' directly */
       /* since those tokens are handled by parse_subrs and        */
       /* parse_charstrings                                        */
       else if ( *cur == 'R' && cur + 6 < limit && *(cur + 1) == 'D' &&
                 have_integer )
       {
-        FT_Long   s;
+        FT_ULong  s;
         FT_Byte*  b;
 
 
         parser->root.cursor = start_binary;
         if ( !read_binary_data( parser, &s, &b, IS_INCREMENTAL ) )
           return FT_THROW( Invalid_File_Format );
         have_integer = 0;
       }
 
       else if ( *cur == '-' && cur + 6 < limit && *(cur + 1) == '|' &&
                 have_integer )
       {
-        FT_Long   s;
+        FT_ULong  s;
         FT_Byte*  b;
 
 
         parser->root.cursor = start_binary;
         if ( !read_binary_data( parser, &s, &b, IS_INCREMENTAL ) )
           return FT_THROW( Invalid_File_Format );
         have_integer = 0;
       }
 
       /* look for immediates */
       else if ( *cur == '/' && cur + 2 < limit )
       {
-        FT_PtrDist  len;
+        FT_UInt  len;
 
 
         cur++;
 
         parser->root.cursor = cur;
         T1_Skip_PS_Token( parser );
         if ( parser->root.error )
           goto Exit;
 
-        len = parser->root.cursor - cur;
+        len = (FT_UInt)( parser->root.cursor - cur );
 
         if ( len > 0 && len < 22 && parser->root.cursor < limit )
         {
           /* now compare the immediate name to the keyword table */
           T1_Field  keyword = (T1_Field)t1_keywords;
 
 
           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 ) &&
-                 ft_memcmp( cur, name, len ) == 0                   )
+            if ( cur[0] == name[0]                      &&
+                 len == ft_strlen( (const char *)name ) &&
+                 ft_memcmp( cur, name, len ) == 0       )
             {
               /* We found it -- run the parsing callback!     */
               /* We record every instance of every field      */
               /* (until we reach the base font of a           */
               /* synthetic font) to deal adequately with      */
               /* multiple master fonts; this is also          */
               /* necessary because later PostScript           */
               /* definitions override earlier ones.           */
 
               /* Once we encounter `FontDirectory' after      */
@@ skipping 234 matching lines @@
 
     loader.charstrings.init  = 0;
     type1->charstrings_block = loader.charstrings.block;
     type1->charstrings       = loader.charstrings.elements;
     type1->charstrings_len   = loader.charstrings.lengths;
 
     /* we copy the glyph names `block' and `elements' fields; */
     /* the `lengths' field must be released later             */
     type1->glyph_names_block    = loader.glyph_names.block;
     type1->glyph_names          = (FT_String**)loader.glyph_names.elements;
-    loader.glyph_names.block    = 0;
-    loader.glyph_names.elements = 0;
+    loader.glyph_names.block    = NULL;
+    loader.glyph_names.elements = NULL;
 
     /* we must now build type1.encoding when we have a custom array */
     if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY )
     {
       FT_Int    charcode, idx, min_char, max_char;
       FT_Byte*  glyph_name;
 
 
       /* OK, we do the following: for each element in the encoding  */
       /* table, look up the index of the glyph having the same name */
@@ skipping 43 matching lines @@
       type1->encoding.num_chars  = loader.num_chars;
     }
 
   Exit:
     t1_done_loader( &loader );
     return error;
   }
 
 
 /* END */