freetype2/config/unix/ftsystem.c

/**************************************************************************
 *
 *  ftsystem.h                                                        1.0
 *
 *    Unix-specific FreeType low-level system interface
 *
 *    This file contains the definition of interface used by FreeType
 *    to access low-level, i.e. memory management, i/o access as well
 *    as thread synchronisation.              
 *
 *
 *  Copyright 1996-1999 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.                                          
 *                                                                           
 **************************************************************************/

#include <ftsystem.h>
#include <fterrors.h>
#include <ftconfig.h>
#include <ftdebug.h>

/* Memory-mapping includes and definitions..                            */
/*                                                                      */
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <sys/mman.h>
#ifndef MAP_FILE
#define MAP_FILE  0x00
#endif

/*
 * The prototype for munmap() is not provided on SunOS.  This needs to
 * have a check added later to see if the GNU C library is being used.
 * If so, then this prototype is not needed.
 */
#if defined(__sun__) && !defined(SVR4) && !defined(__SVR4)
  extern int  munmap( caddr_t  addr, int  len );
#endif

#include <sys/stat.h>
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif



#include <stdio.h>
#include <stdlib.h>
#include <string.h>

  /*********************************************************************/
  /*                                                                   */
  /*                       MEMORY MANAGEMENT INTERFACE                 */
  /*                                                                   */

/************************************************************************
 *
 * <FuncType>
 *    FT_Alloc_Func
 *
 * <Description>
 *    The memory allocator function type
 *
 * <Input>
 *    system    :: pointer to the system object
 *    size      :: requested size in bytes
 *
 * <Output>
 *    block     :: address of newly allocated block
 *
 * <Return>  
 *    Error code. 0 means success.
 *
 * <Note>
 *    If your allocation routine ALWAYS zeroes the new block, you
 *    should set the flag FT_SYSTEM_FLAG_ALLOC_ZEROES in your system
 *    object 'flags' field.
 *
 *    If you have set the flag FT_SYSTEM_FLAG_REPORT_CURRENT_ALLOC in
 *    your system's "system_flags" field, this function should update
 *    the "current_alloc" field of the system object.
 *
 ************************************************************************/

  static
  void*  ft_alloc( FT_Memory  memory,
                   long       size )
  {
    (void)memory;
    return malloc(size);
  }


/************************************************************************
 *
 * <FuncType>
 *    FT_Realloc_Func
 *
 * <Description>
 *    The memory reallocator function type
 *
 * <Input>
 *    system   :: pointer to the system object
 *    new_size :: new requested size in bytes
 *
 * <InOut>
 *    block    :: address of block in memory
 *
 * <Return>
 *    Error code. 0 means success.
 *
 * <Note>
 *    This function is _never_ called when the system flag 
 *    FT_SYSTEM_FLAG_NO_REALLOC is set. Instead, the engine will emulate
 *    realloc through "alloc" and "free".
 *
 *    Note that this is possible due to the fact that FreeType's
 *    "FT_Realloc" always requests the _current_ size of the reallocated
 *    block as a parameter, thus avoiding memory leaks.
 *
 *    If you have set the flag FT_SYSTEM_FLAG_REPORT_CURRENT_ALLOC in
 *    your system's "system_flags" field, this function should update
 *    the "current_alloc" field of the system object.
 *
 ************************************************************************/

  static
  void*  ft_realloc( FT_Memory  memory,
                     long       cur_size,
                     long       new_size,
                     void*      block )
  {
    (void)memory;
    (void)cur_size;

    return realloc( block, new_size );
  }


/************************************************************************
 *
 * <FuncType>
 *    FT_Free_Func
 *
 * <Description>
 *    The memory release function type
 *
 * <Input>
 *    system  :: pointer to the system object
 *    block   :: address of block in memory
 *
 * <Note>
 *    If you have set the flag FT_SYSTEM_FLAG_REPORT_CURRENT_ALLOC in
 *    your system's "system_flags" field, this function should update
 *    the "current_alloc" field of the system object.
 *
 ************************************************************************/

  static
  void  ft_free( FT_Memory  memory,
                 void*      block )
  {
    (void)memory;
    free( block );
  }

  /*********************************************************************/
  /*                                                                   */
  /*                     RESOURCE MANAGEMENT INTERFACE                 */
  /*                                                                   */

/* We use the macro STREAM_File as a convenience to extract the      */
/* system-specific stream handle from a given FreeType stream object */
#define STREAM_File(stream)  ((void*)stream->descriptor.pointer)


#undef  FT_COMPONENT
#define FT_COMPONENT  trace_io

  static
  void  ft_close_stream( FT_Stream  stream )
  {
    munmap ( stream->descriptor.pointer, stream->size );
        
    stream->descriptor.pointer = NULL;
    stream->size               = 0;
    stream->base               = 0;
  }


  extern
  int  FT_New_Stream( const char*  filepathname,
                      FT_Stream    stream )
  {
    int          file;
    struct stat  stat_buf;

    /* open the file */
    file = open( filepathname, O_RDONLY );
    if (file < 0)
    {
      FT_ERROR(( "FT.Unix.Open:" ));
      FT_ERROR(( " could not open '%s'\n", filepathname ));
      return FT_Err_Cannot_Open_Stream;
    }

    if (fstat( file, &stat_buf ) < 0)
    {
      FT_ERROR(( "FT.Unix.Open:" ));
      FT_ERROR(( " could not 'fstat' file '%s'\n", filepathname ));
      goto Fail_Map;
    }
      
    stream->size     = stat_buf.st_size;
    stream->pos      = 0;
    stream->base     = mmap( NULL,
                             stream->size,
                             PROT_READ,
                             MAP_FILE | MAP_PRIVATE,
                             file,
                             0 );

    if ( (long)stream->base == -1 )
    {
      FT_ERROR(( "FT.Unix.Open:" ));
      FT_ERROR(( " Could not map file '%s'\n", filepathname ));
      goto Fail_Map;
    }

    close(file);

    stream->descriptor.pointer = stream->base;
    stream->pathname.pointer   = (char*)filepathname;
    
    stream->close = ft_close_stream;
    stream->read  = 0;
    
    FT_TRACE1(( "FT.Unix.Open:" ));
    FT_TRACE1(( " opened '%s' (%d bytes) succesfully\n",
                filepathname, stream->size ));

    return FT_Err_Ok;
    
  Fail_Map:
    close(file);
    stream->base      = NULL;
    stream->size      = 0;
    stream->pos       = 0;
    
    return FT_Err_Cannot_Open_Stream;
  }


  extern
  FT_Memory  FT_New_Memory( void )
  {
    FT_Memory  memory;
    
    memory = (FT_Memory)malloc( sizeof(*memory) );
    if (memory)
    {
      memory->user    = 0;
      memory->alloc   = ft_alloc;
      memory->realloc = ft_realloc;
      memory->free    = ft_free;
    }
    return memory;
  }