Update bundled freetype to 2.6.1

third_party/freetype/src/psaux/psobjs.c

 /***************************************************************************/
 /*                                                                         */
 /*  psobjs.c                                                               */
 /*                                                                         */
 /*    Auxiliary functions for PostScript fonts (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 56 matching lines @@
 
 
     table->memory = memory;
     if ( FT_NEW_ARRAY( table->elements, count ) ||
          FT_NEW_ARRAY( table->lengths,  count ) )
       goto Exit;
 
     table->max_elems = count;
     table->init      = 0xDEADBEEFUL;
     table->num_elems = 0;
-    table->block     = 0;
+    table->block     = NULL;
     table->capacity  = 0;
     table->cursor    = 0;
 
     *(PS_Table_FuncsRec*)&table->funcs = ps_table_funcs;
 
   Exit:
     if ( error )
       FT_FREE( table->elements );
 
     return error;
@@ skipping 63 matching lines @@
   /*                                                                       */
   /*    object :: The address of the object to copy in memory.             */
   /*                                                                       */
   /*    length :: The length in bytes of the source object.                */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.  An error is returned if a  */
   /*    reallocation fails.                                                */
   /*                                                                       */
   FT_LOCAL_DEF( FT_Error )
-  ps_table_add( PS_Table    table,
-                FT_Int      idx,
-                void*       object,
-                FT_PtrDist  length )
+  ps_table_add( PS_Table  table,
+                FT_Int    idx,
+                void*     object,
+                FT_UInt   length )
   {
     if ( idx < 0 || idx >= table->max_elems )
     {
       FT_ERROR(( "ps_table_add: invalid index\n" ));
       return FT_THROW( Invalid_Argument );
     }
 
-    if ( length < 0 )
-    {
-      FT_ERROR(( "ps_table_add: invalid length\n" ));
-      return FT_THROW( Invalid_Argument );
-    }
-
     /* grow the base block if needed */
     if ( table->cursor + length > table->capacity )
     {
       FT_Error    error;
       FT_Offset   new_size = table->capacity;
       FT_PtrDist  in_offset;
 
 
       in_offset = (FT_Byte*)object - table->block;
       if ( in_offset < 0 || (FT_Offset)in_offset >= table->capacity )
@@ skipping 398 matching lines @@
     {
       FT_ERROR(( "ps_parser_skip_PS_token:"
                  " current token is `%c' which is self-delimiting\n"
                  "                        "
                  " but invalid at this point\n",
                  *cur ));
 
       error = FT_THROW( Invalid_File_Format );
     }
 
+    if ( cur > limit )
+      cur = limit;
+
     parser->error  = error;
     parser->cursor = cur;
   }
 
 
   FT_LOCAL_DEF( void )
   ps_parser_skip_spaces( PS_Parser  parser )
   {
     skip_spaces( &parser->cursor, parser->limit );
   }
 
 
   /* `token' here means either something between balanced delimiters */
   /* or the next token; the delimiters are not removed.              */
 
   FT_LOCAL_DEF( void )
   ps_parser_to_token( PS_Parser  parser,
                       T1_Token   token )
   {
     FT_Byte*  cur;
     FT_Byte*  limit;
     FT_Int    embed;
 
 
     token->type  = T1_TOKEN_TYPE_NONE;
-    token->start = 0;
-    token->limit = 0;
+    token->start = NULL;
+    token->limit = NULL;
 
     /* first of all, skip leading whitespace */
     ps_parser_skip_spaces( parser );
 
     cur   = parser->cursor;
     limit = parser->limit;
 
     if ( cur >= limit )
       return;
 
@@ skipping 60 matching lines @@
       token->start = cur;
       token->type  = ( *cur == '/' ? T1_TOKEN_TYPE_KEY : T1_TOKEN_TYPE_ANY );
       ps_parser_skip_PS_token( parser );
       cur = parser->cursor;
       if ( !parser->error )
         token->limit = cur;
     }
 
     if ( !token->limit )
     {
-      token->start = 0;
+      token->start = NULL;
       token->type  = T1_TOKEN_TYPE_NONE;
     }
 
     parser->cursor = cur;
   }
 
 
   /* NB: `tokens' can be NULL if we only want to count */
   /* the number of array elements                      */
 
@@ skipping 204 matching lines @@
 
 
 #if 0
 
   static FT_String*
   ps_tostring( FT_Byte**  cursor,
                FT_Byte*   limit,
                FT_Memory  memory )
   {
     FT_Byte*    cur = *cursor;
-    FT_PtrDist  len = 0;
+    FT_UInt     len = 0;
     FT_Int      count;
     FT_String*  result;
     FT_Error    error;
 
 
     /* XXX: some stupid fonts have a `Notice' or `Copyright' string     */
     /*      that simply doesn't begin with an opening parenthesis, even */
     /*      though they have a closing one!  E.g. "amuncial.pfb"        */
     /*                                                                  */
     /*      We must deal with these ill-fated cases there.  Note that   */
@@ skipping 19 matching lines @@
         count++;
 
       else if ( *cur == ')' )
       {
         count--;
         if ( count < 0 )
           break;
       }
     }
 
-    len = cur - *cursor;
+    len = (FT_UInt)( cur - *cursor );
     if ( cur >= limit || FT_ALLOC( result, len + 1 ) )
       return 0;
 
     /* now copy the string */
     FT_MEM_COPY( result, *cursor, len );
     result[len] = '\0';
     *cursor = cur;
     return result;
   }
 
@@ skipping 237 matching lines @@
           FT_Fixed*  temp;
           FT_Int     result;
           FT_UInt    i;
 
 
           if ( FT_NEW_ARRAY( temp, max_objects * 4 ) )
             goto Exit;
 
           for ( i = 0; i < 4; i++ )
           {
-            result = ps_tofixedarray( &cur, limit, max_objects,
+            result = ps_tofixedarray( &cur, limit, (FT_Int)max_objects,
                                       temp + i * max_objects, 0 );
             if ( result < 0 || (FT_UInt)result < max_objects )
             {
               FT_ERROR(( "ps_parser_load_field:"
-                         " expected %d integers in the %s subarray\n"
+                         " expected %d integer%s in the %s subarray\n"
                          "                     "
                          " of /FontBBox in the /Blend dictionary\n",
-                         max_objects,
+                         max_objects, max_objects > 1 ? "s" : "",
                          i == 0 ? "first"
                                 : ( i == 1 ? "second"
                                            : ( i == 2 ? "third"
                                                       : "fourth" ) ) ));
               error = FT_THROW( Invalid_File_Format );
+
+              FT_FREE( temp );
               goto Exit;
             }
 
             skip_spaces( &cur, limit );
           }
 
           for ( i = 0; i < max_objects; i++ )
           {
             FT_BBox*  bbox = (FT_BBox*)objects[i];
 
@@ skipping 57 matching lines @@
       fieldrec.type = T1_FIELD_TYPE_FIXED;
 
     ps_parser_to_token_array( parser, elements,
                               T1_MAX_TABLE_ELEMENTS, &num_elements );
     if ( num_elements < 0 )
     {
       error = FT_ERR( Ignore );
       goto Exit;
     }
     if ( (FT_UInt)num_elements > field->array_max )
-      num_elements = field->array_max;
+      num_elements = (FT_Int)field->array_max;
 
     old_cursor = parser->cursor;
     old_limit  = parser->limit;
 
     /* we store the elements count if necessary;           */
     /* we further assume that `count_offset' can't be zero */
     if ( field->type != T1_FIELD_TYPE_BBOX && field->count_offset != 0 )
       *(FT_Byte*)( (FT_Byte*)objects[0] + field->count_offset ) =
         (FT_Byte)num_elements;
 
@@ skipping 37 matching lines @@
     return PS_Conv_ToInt( &parser->cursor, parser->limit );
   }
 
 
   /* first character must be `<' if `delimiters' is non-zero */
 
   FT_LOCAL_DEF( FT_Error )
   ps_parser_to_bytes( PS_Parser  parser,
                       FT_Byte*   bytes,
                       FT_Offset  max_bytes,
-                      FT_Long*   pnum_bytes,
+                      FT_ULong*  pnum_bytes,
                       FT_Bool    delimiters )
   {
     FT_Error  error = FT_Err_Ok;
     FT_Byte*  cur;
 
 
     ps_parser_skip_spaces( parser );
     cur = parser->cursor;
 
     if ( cur >= parser->limit )
@@ skipping 153 matching lines @@
     {
       FT_GlyphLoader  loader = glyph->internal->loader;
 
 
       builder->loader  = loader;
       builder->base    = &loader->base.outline;
       builder->current = &loader->current.outline;
       FT_GlyphLoader_Rewind( loader );
 
       builder->hints_globals = size->internal;
-      builder->hints_funcs   = 0;
+      builder->hints_funcs   = NULL;
 
       if ( hinting )
         builder->hints_funcs = glyph->internal->glyph_hints;
     }
 
     builder->pos_x = 0;
     builder->pos_y = 0;
 
     builder->left_bearing.x = 0;
     builder->left_bearing.y = 0;
@@ skipping 199 matching lines @@
   {
     PS_Conv_EexecDecode( &buffer,
                          buffer + length,
                          buffer,
                          length,
                          &seed );
   }
 
 
 /* END */