Update freetype to 2.5.4.

third_party/freetype/src/base/ftsystem.c

-#if !defined(_FXFT_VERSION_) || _FXFT_VERSION_ == 2501
 /***************************************************************************/
 /*                                                                         */
 /*  ftsystem.c                                                             */
 /*                                                                         */
 /*    ANSI-specific FreeType low-level system interface (body).            */
 /*                                                                         */
 /*  Copyright 1996-2002, 2006, 2008-2011, 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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
   /*************************************************************************/
   /*                                                                       */
   /* This file contains the default interface used by FreeType to access   */
   /* low-level, i.e. memory management, i/o access as well as thread       */
   /* synchronisation.  It can be replaced by user-specific routines if     */
   /* necessary.                                                            */
   /*                                                                       */
   /*************************************************************************/
 
-#define FT2_BUILD_LIBRARY
-#include "../../include/ft2build.h"
-#include "../../include/freetype/config/ftconfig.h"
-#include "../../include/freetype/internal/ftdebug.h"
-#include "../../include/freetype/internal/ftstream.h"
-#include "../../include/freetype/ftsystem.h"
-#include "../../include/freetype/fterrors.h"
-#include "../../include/freetype/fttypes.h"
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_SYSTEM_H
+#include FT_ERRORS_H
+#include FT_TYPES_H
 
 
   /*************************************************************************/
   /*                                                                       */
   /*                       MEMORY MANAGEMENT INTERFACE                     */
   /*                                                                       */
   /*************************************************************************/
 
   /*************************************************************************/
   /*                                                                       */
   /* It is not necessary to do any error checking for the                  */
   /* allocation-related functions.  This will be done by the higher level  */
   /* routines like ft_mem_alloc() or ft_mem_realloc().                     */
   /*                                                                       */
   /*************************************************************************/
 
-#define _FOXIT_MEM_MANAGER_
 
-#if defined(_FX_MANAGED_CODE_) && defined(__cplusplus)
-extern "C" {
-#endif
-
-/** Allocate number of bytes */
-void*   FXMEM_DefaultAlloc(int byte_size, int flags);
-
-/** Allocate with debug information */
-void*   FXMEM_DefaultAllocDebug(int size, int flags, const char* file, int line);
-
-void*   FXMEM_DefaultRealloc(void* pointer, int new_size, int flags);
-
-/** Free previously allocated memory */
-void    FXMEM_DefaultFree(void* pointer, int flags);
-
-#if defined(_FX_MANAGED_CODE_) && defined(__cplusplus)
-}
-#endif
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    ft_alloc                                                           */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The memory allocation function.                                    */
   /*                                                                       */
   /* <Input>                                                               */
   /*    memory :: A pointer to the memory object.                          */
   /*                                                                       */
   /*    size   :: The requested size in bytes.                             */
   /*                                                                       */
   /* <Return>                                                              */
   /*    The address of newly allocated block.                              */
   /*                                                                       */
   FT_CALLBACK_DEF( void* )
   ft_alloc( FT_Memory  memory,
             long       size )
   {
     FT_UNUSED( memory );
-  #ifdef _FOXIT_MEM_MANAGER_
-        return FXMEM_DefaultAlloc(size, 0);
-#else
+
     return ft_smalloc( size );
-#endif
   }
-  
-  /* XYQ 2006-10-12 */
-#ifdef _XYQ_MEM_DEBUG
-  FT_CALLBACK_DEF( void* )
-          ft_allocdebug( FT_Memory  memory,
-          long       size, const char* filename, int line)
-  {
-          FT_UNUSED( memory );
-          
-          return FXMEM_DefaultAllocDebug( size, 0, filename, line );
-  }
-#endif
+
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    ft_realloc                                                         */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The memory reallocation function.                                  */
   /*                                                                       */
   /* <Input>                                                               */
@@ skipping 10 matching lines @@
   /*                                                                       */
   FT_CALLBACK_DEF( void* )
   ft_realloc( FT_Memory  memory,
               long       cur_size,
               long       new_size,
               void*      block )
   {
     FT_UNUSED( memory );
     FT_UNUSED( cur_size );
 
-#ifdef _FOXIT_MEM_MANAGER_
-        return FXMEM_DefaultRealloc(block, new_size, 0);
-#else
     return ft_srealloc( block, new_size );
-#endif
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    ft_free                                                            */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The memory release function.                                       */
   /*                                                                       */
   /* <Input>                                                               */
   /*    memory  :: A pointer to the memory object.                         */
   /*                                                                       */
   /*    block   :: The address of block in memory to be freed.             */
   /*                                                                       */
   FT_CALLBACK_DEF( void )
   ft_free( FT_Memory  memory,
            void*      block )
   {
     FT_UNUSED( memory );
 
-#ifdef _FOXIT_MEM_MANAGER_
-        FXMEM_DefaultFree(block, 0);
-#else
     ft_sfree( block );
-#endif
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /*                     RESOURCE MANAGEMENT INTERFACE                     */
   /*                                                                       */
   /*************************************************************************/
 
 #ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT
@@ skipping 19 matching lines @@
   /*                                                                       */
   /* <Description>                                                         */
   /*    The function to close a stream.                                    */
   /*                                                                       */
   /* <Input>                                                               */
   /*    stream :: A pointer to the stream object.                          */
   /*                                                                       */
   FT_CALLBACK_DEF( void )
   ft_ansi_stream_close( FT_Stream  stream )
   {
-//#if _FX_COMPILER_ != _FX_IARCC_ && _FX_OS_ != _FX_PALMOS_
     ft_fclose( STREAM_FILE( stream ) );
 
     stream->descriptor.pointer = NULL;
     stream->size               = 0;
     stream->base               = 0;
-//#endif
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    ft_ansi_stream_io                                                  */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The function to open a stream.                                     */
@@ skipping 11 matching lines @@
   /*    The number of bytes actually read.  If `count' is zero (this is,   */
   /*    the function is used for seeking), a non-zero return value         */
   /*    indicates an error.                                                */
   /*                                                                       */
   FT_CALLBACK_DEF( unsigned long )
   ft_ansi_stream_io( FT_Stream       stream,
                      unsigned long   offset,
                      unsigned char*  buffer,
                      unsigned long   count )
   {
-//#if _FX_COMPILER_ != _FX_IARCC_ && _FX_OS_ != _FX_PALMOS_
     FT_FILE*  file;
 
 
     if ( !count && offset > stream->size )
       return 1;
 
     file = STREAM_FILE( stream );
 
     if ( stream->pos != offset )
       ft_fseek( file, offset, SEEK_SET );
 
     return (unsigned long)ft_fread( buffer, 1, count, file );
-//#else
-//    return 0;
-//#endif
   }
 
 
   /* documentation is in ftstream.h */
 
   FT_BASE_DEF( FT_Error )
   FT_Stream_Open( FT_Stream    stream,
                   const char*  filepathname )
   {
-//#if _FX_COMPILER_ != _FX_IARCC_ && _FX_OS_ != _FX_PALMOS_
     FT_FILE*  file;
 
 
     if ( !stream )
       return FT_THROW( Invalid_Stream_Handle );
 
     stream->descriptor.pointer = NULL;
     stream->pathname.pointer   = (char*)filepathname;
     stream->base               = 0;
     stream->pos                = 0;
     stream->read               = NULL;
     stream->close              = NULL;
 
     file = ft_fopen( filepathname, "rb" );
     if ( !file )
     {
       FT_ERROR(( "FT_Stream_Open:"
                  " could not open `%s'\n", filepathname ));
 
       return FT_THROW( Cannot_Open_Resource );
     }
 
-    ft_fseek( file, 0, FXSYS_SEEK_END );
+    ft_fseek( file, 0, SEEK_END );
     stream->size = ft_ftell( file );
     if ( !stream->size )
     {
       FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " opened `%s' but zero-sized\n", filepathname ));
       ft_fclose( file );
       return FT_THROW( Cannot_Open_Stream );
     }
-    ft_fseek( file, 0, FXSYS_SEEK_SET );
+    ft_fseek( file, 0, SEEK_SET );
 
     stream->descriptor.pointer = file;
     stream->read  = ft_ansi_stream_io;
     stream->close = ft_ansi_stream_close;
 
     FT_TRACE1(( "FT_Stream_Open:" ));
     FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
                 filepathname, stream->size ));
-//#endif
 
     return FT_Err_Ok;
   }
 
 #endif /* !FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT */
 
 #ifdef FT_DEBUG_MEMORY
 
   extern FT_Int
   ft_mem_debug_init( FT_Memory  memory );
 
   extern void
   ft_mem_debug_done( FT_Memory  memory );
 
 #endif
 
 
   /* documentation is in ftobjs.h */
 
   FT_BASE_DEF( FT_Memory )
   FT_New_Memory( void )
   {
     FT_Memory  memory;
 
 
-    memory = (FT_Memory)FXMEM_DefaultAlloc( sizeof ( *memory ), 0 );
+    memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) );
     if ( memory )
     {
       memory->user    = 0;
       memory->alloc   = ft_alloc;
-#ifdef _XYQ_MEM_DEBUG
-          memory->allocdebug = ft_allocdebug;
-#endif
       memory->realloc = ft_realloc;
       memory->free    = ft_free;
 #ifdef FT_DEBUG_MEMORY
       ft_mem_debug_init( memory );
 #endif
     }
 
     return memory;
   }
 
 
   /* documentation is in ftobjs.h */
 
   FT_BASE_DEF( void )
   FT_Done_Memory( FT_Memory  memory )
   {
 #ifdef FT_DEBUG_MEMORY
     ft_mem_debug_done( memory );
 #endif
-    FXMEM_DefaultFree( memory, 0 );
+    ft_sfree( memory );
   }
 
 
 /* END */
-#endif
-