Update bundled freetype to 2.6.1

third_party/freetype/src/psaux/afmparse.c

 /***************************************************************************/
 /*                                                                         */
 /*  afmparse.c                                                             */
 /*                                                                         */
 /*    AFM parser (body).                                                   */
 /*                                                                         */
-/*  Copyright 2006-2010, 2012, 2013 by                                     */
+/*  Copyright 2006-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 50 matching lines @@
   /* column separator; there is no `column' in the spec actually */
 #define AFM_IS_SEP( ch )      ( (ch) == ';' )
 
 #define AFM_GETC()                                                       \
           ( ( (stream)->cursor < (stream)->limit ) ? *(stream)->cursor++ \
                                                    : EOF )
 
 #define AFM_STREAM_KEY_BEGIN( stream )    \
           (char*)( (stream)->cursor - 1 )
 
-#define AFM_STREAM_KEY_LEN( stream, key )       \
-          ( (char*)(stream)->cursor - key - 1 )
+#define AFM_STREAM_KEY_LEN( stream, key )           \
+          (FT_Offset)( (char*)(stream)->cursor - key - 1 )
 
 #define AFM_STATUS_EOC( stream ) \
           ( (stream)->status >= AFM_STREAM_STATUS_EOC )
 
 #define AFM_STATUS_EOL( stream ) \
           ( (stream)->status >= AFM_STREAM_STATUS_EOL )
 
 #define AFM_STATUS_EOF( stream ) \
           ( (stream)->status >= AFM_STREAM_STATUS_EOF )
 
@@ skipping 272 matching lines @@
   /*
    * `afm_parser_read_vals' and `afm_parser_next_key' provide
    * high-level operations to an AFM_Stream.  The rest of the
    * parser functions should use them without accessing the
    * AFM_Stream directly.
    */
 
   FT_LOCAL_DEF( FT_Int )
   afm_parser_read_vals( AFM_Parser  parser,
                         AFM_Value   vals,
-                        FT_UInt     n )
+                        FT_Int      n )
   {
     AFM_Stream  stream = parser->stream;
     char*       str;
-    FT_UInt     i;
+    FT_Int      i;
 
 
     if ( n > AFM_MAX_ARGUMENTS )
       return 0;
 
     for ( i = 0; i < n; i++ )
     {
       FT_Offset  len;
       AFM_Value  val = vals + i;
 
@@ skipping 52 matching lines @@
     return i;
   }
 
 
   FT_LOCAL_DEF( char* )
   afm_parser_next_key( AFM_Parser  parser,
                        FT_Bool     line,
                        FT_Offset*  len )
   {
     AFM_Stream  stream = parser->stream;
-    char*       key    = 0;  /* make stupid compiler happy */
+    char*       key    = NULL;  /* make stupid compiler happy */
 
 
     if ( line )
     {
       while ( 1 )
       {
         /* skip current line */
         if ( !AFM_STATUS_EOL( stream ) )
           afm_stream_read_string( stream );
 
@@ skipping 95 matching lines @@
   FT_LOCAL( void )
   afm_parser_done( AFM_Parser  parser )
   {
     FT_Memory  memory = parser->memory;
 
 
     FT_FREE( parser->stream );
   }
 
 
-  FT_LOCAL_DEF( FT_Error )
+  static FT_Error
   afm_parser_read_int( AFM_Parser  parser,
                        FT_Int*     aint )
   {
     AFM_ValueRec  val;
 
 
     val.type = AFM_VALUE_TYPE_INTEGER;
 
     if ( afm_parser_read_vals( parser, &val, 1 ) == 1 )
     {
       *aint = val.u.i;
 
       return FT_Err_Ok;
     }
     else
       return FT_THROW( Syntax_Error );
   }
 
 
   static FT_Error
   afm_parse_track_kern( AFM_Parser  parser )
   {
     AFM_FontInfo   fi = parser->FontInfo;
     AFM_TrackKern  tk;
     char*          key;
     FT_Offset      len;
     int            n = -1;
+    FT_Int         tmp;
 
 
-    if ( afm_parser_read_int( parser, &fi->NumTrackKern ) )
+    if ( afm_parser_read_int( parser, &tmp ) )
         goto Fail;
 
+    if ( tmp < 0 )
+      goto Fail;
+
+    fi->NumTrackKern = (FT_UInt)tmp;
+
     if ( fi->NumTrackKern )
     {
       FT_Memory  memory = parser->memory;
       FT_Error   error;
 
 
       if ( FT_QNEW_ARRAY( fi->TrackKerns, fi->NumTrackKern ) )
         return error;
     }
 
     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
     {
       AFM_ValueRec  shared_vals[5];
 
 
       switch ( afm_tokenize( key, len ) )
       {
       case AFM_TOKEN_TRACKKERN:
         n++;
 
-        if ( n >= fi->NumTrackKern )
+        if ( n >= (int)fi->NumTrackKern )
           goto Fail;
 
         tk = fi->TrackKerns + n;
 
         shared_vals[0].type = AFM_VALUE_TYPE_INTEGER;
         shared_vals[1].type = AFM_VALUE_TYPE_FIXED;
         shared_vals[2].type = AFM_VALUE_TYPE_FIXED;
         shared_vals[3].type = AFM_VALUE_TYPE_FIXED;
         shared_vals[4].type = AFM_VALUE_TYPE_FIXED;
         if ( afm_parser_read_vals( parser, shared_vals, 5 ) != 5 )
           goto Fail;
 
         tk->degree     = shared_vals[0].u.i;
         tk->min_ptsize = shared_vals[1].u.f;
         tk->min_kern   = shared_vals[2].u.f;
         tk->max_ptsize = shared_vals[3].u.f;
         tk->max_kern   = shared_vals[4].u.f;
 
         break;
 
       case AFM_TOKEN_ENDTRACKKERN:
       case AFM_TOKEN_ENDKERNDATA:
       case AFM_TOKEN_ENDFONTMETRICS:
-        fi->NumTrackKern = n + 1;
+        fi->NumTrackKern = (FT_UInt)( n + 1 );
         return FT_Err_Ok;
 
       case AFM_TOKEN_UNKNOWN:
         break;
 
       default:
         goto Fail;
       }
     }
 
@@ skipping 28 matching lines @@
 
 
   static FT_Error
   afm_parse_kern_pairs( AFM_Parser  parser )
   {
     AFM_FontInfo  fi = parser->FontInfo;
     AFM_KernPair  kp;
     char*         key;
     FT_Offset     len;
     int           n = -1;
+    FT_Int        tmp;
 
 
-    if ( afm_parser_read_int( parser, &fi->NumKernPair ) )
+    if ( afm_parser_read_int( parser, &tmp ) )
       goto Fail;
 
+    if ( tmp < 0 )
+      goto Fail;
+
+    fi->NumKernPair = (FT_UInt)tmp;
+
     if ( fi->NumKernPair )
     {
       FT_Memory  memory = parser->memory;
       FT_Error   error;
 
 
       if ( FT_QNEW_ARRAY( fi->KernPairs, fi->NumKernPair ) )
         return error;
     }
 
     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
     {
       AFM_Token  token = afm_tokenize( key, len );
 
 
       switch ( token )
       {
       case AFM_TOKEN_KP:
       case AFM_TOKEN_KPX:
       case AFM_TOKEN_KPY:
         {
           FT_Int        r;
           AFM_ValueRec  shared_vals[4];
 
 
           n++;
 
-          if ( n >= fi->NumKernPair )
+          if ( n >= (int)fi->NumKernPair )
             goto Fail;
 
           kp = fi->KernPairs + n;
 
           shared_vals[0].type = AFM_VALUE_TYPE_INDEX;
           shared_vals[1].type = AFM_VALUE_TYPE_INDEX;
           shared_vals[2].type = AFM_VALUE_TYPE_INTEGER;
           shared_vals[3].type = AFM_VALUE_TYPE_INTEGER;
           r = afm_parser_read_vals( parser, shared_vals, 4 );
           if ( r < 3 )
             goto Fail;
 
-          kp->index1 = shared_vals[0].u.i;
-          kp->index2 = shared_vals[1].u.i;
+          /* index values can't be negative */
+          kp->index1 = shared_vals[0].u.u;
+          kp->index2 = shared_vals[1].u.u;
           if ( token == AFM_TOKEN_KPY )
           {
             kp->x = 0;
             kp->y = shared_vals[2].u.i;
           }
           else
           {
             kp->x = shared_vals[2].u.i;
             kp->y = ( token == AFM_TOKEN_KP && r == 4 )
                       ? shared_vals[3].u.i : 0;
           }
         }
         break;
 
       case AFM_TOKEN_ENDKERNPAIRS:
       case AFM_TOKEN_ENDKERNDATA:
       case AFM_TOKEN_ENDFONTMETRICS:
-        fi->NumKernPair = n + 1;
+        fi->NumKernPair = (FT_UInt)( n + 1 );
         ft_qsort( fi->KernPairs, fi->NumKernPair,
                   sizeof ( AFM_KernPairRec ),
                   afm_compare_kern_pairs );
         return FT_Err_Ok;
 
       case AFM_TOKEN_UNKNOWN:
         break;
 
       default:
         goto Fail;
@@ skipping 42 matching lines @@
       }
     }
 
   Fail:
     return FT_THROW( Syntax_Error );
   }
 
 
   static FT_Error
   afm_parser_skip_section( AFM_Parser  parser,
-                           FT_UInt     n,
+                           FT_Int      n,
                            AFM_Token   end_section )
   {
     char*      key;
     FT_Offset  len;
 
 
     while ( n-- > 0 )
     {
       key = afm_parser_next_key( parser, 1, NULL );
       if ( !key )
@@ skipping 126 matching lines @@
     FT_FREE( fi->KernPairs );
     fi->NumKernPair = 0;
 
     fi->IsCIDFont = 0;
 
     return error;
   }
 
 
 /* END */