Update freetype to latest version of ASOP.

src/base/ftutil.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftutil.c                                                               */
 /*                                                                         */
 /*    FreeType utility file for memory and list management (body).         */
 /*                                                                         */
-/*  Copyright 2002, 2004, 2005, 2006, 2007 by                              */
+/*  Copyright 2002, 2004-2007, 2013 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 @@
                  FT_Error  *p_error )
   {
     FT_Error    error = FT_Err_Ok;
     FT_Pointer  block = NULL;
 
 
     if ( size > 0 )
     {
       block = memory->alloc( memory, size );
       if ( block == NULL )
-        error = FT_Err_Out_Of_Memory;
+        error = FT_THROW( Out_Of_Memory );
     }
     else if ( size < 0 )
     {
       /* may help catch/prevent security issues */
-      error = FT_Err_Invalid_Argument;
+      error = FT_THROW( Invalid_Argument );
     }
 
     *p_error = error;
     return block;
   }
 
 
   FT_BASE_DEF( FT_Pointer )
   ft_mem_realloc( FT_Memory  memory,
                   FT_Long    item_size,
                   FT_Long    cur_count,
                   FT_Long    new_count,
                   void*      block,
                   FT_Error  *p_error )
   {
     FT_Error  error = FT_Err_Ok;
 
+
     block = ft_mem_qrealloc( memory, item_size,
                              cur_count, new_count, block, &error );
     if ( !error && new_count > cur_count )
       FT_MEM_ZERO( (char*)block + cur_count * item_size,
                    ( new_count - cur_count ) * item_size );
 
     *p_error = error;
     return block;
   }
 
 
   FT_BASE_DEF( FT_Pointer )
   ft_mem_qrealloc( FT_Memory  memory,
                    FT_Long    item_size,
                    FT_Long    cur_count,
                    FT_Long    new_count,
                    void*      block,
                    FT_Error  *p_error )
   {
     FT_Error  error = FT_Err_Ok;
 
 
     /* Note that we now accept `item_size == 0' as a valid parameter, in
      * order to cover very weird cases where an ALLOC_MULT macro would be
      * called.
      */
     if ( cur_count < 0 || new_count < 0 || item_size < 0 )
     {
       /* may help catch/prevent nasty security issues */
-      error = FT_Err_Invalid_Argument;
+      error = FT_THROW( Invalid_Argument );
     }
     else if ( new_count == 0 || item_size == 0 )
     {
       ft_mem_free( memory, block );
       block = NULL;
     }
     else if ( new_count > FT_INT_MAX/item_size )
     {
-      error = FT_Err_Array_Too_Large;
+      error = FT_THROW( Array_Too_Large );
     }
     else if ( cur_count == 0 )
     {
       FT_ASSERT( block == NULL );
 
       block = ft_mem_alloc( memory, new_count*item_size, &error );
     }
     else
     {
       FT_Pointer  block2;
       FT_Long     cur_size = cur_count*item_size;
       FT_Long     new_size = new_count*item_size;
 
 
       block2 = memory->realloc( memory, cur_size, new_size, block );
       if ( block2 == NULL )
-        error = FT_Err_Out_Of_Memory;
+        error = FT_THROW( Out_Of_Memory );
       else
         block = block2;
     }
 
     *p_error = error;
     return block;
   }
 
 
   FT_BASE_DEF( void )
@@ skipping 258 matching lines @@
       value2 = value & (value - 1);  /* clear lowest bit */
       if ( value2 == 0 )
         break;
 
       value = value2;
     }
     return value;
   }
 
 
-#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
-
-  FT_BASE_DEF( FT_Error )
-  FT_Alloc( FT_Memory  memory,
-            FT_Long    size,
-            void*     *P )
-  {
-    FT_Error  error;
-
-
-    (void)FT_ALLOC( *P, size );
-    return error;
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_QAlloc( FT_Memory  memory,
-             FT_Long    size,
-             void*     *p )
-  {
-    FT_Error  error;
-
-
-    (void)FT_QALLOC( *p, size );
-    return error;
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_Realloc( FT_Memory  memory,
-              FT_Long    current,
-              FT_Long    size,
-              void*     *P )
-  {
-    FT_Error  error;
-
-
-    (void)FT_REALLOC( *P, current, size );
-    return error;
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_QRealloc( FT_Memory  memory,
-               FT_Long    current,
-               FT_Long    size,
-               void*     *p )
-  {
-    FT_Error  error;
-
-
-    (void)FT_QREALLOC( *p, current, size );
-    return error;
-  }
-
-
-  FT_BASE_DEF( void )
-  FT_Free( FT_Memory  memory,
-           void*     *P )
-  {
-    if ( *P )
-      FT_MEM_FREE( *P );
-  }
-
-#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
-
 /* END */