/************************************************************************** * * 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 #include #include #include /* Memory-mapping includes and definitions.. */ /* */ #ifdef HAVE_UNISTD_H #include #endif #include #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 #ifdef HAVE_FCNTL_H #include #endif #include #include #include /*********************************************************************/ /* */ /* MEMORY MANAGEMENT INTERFACE */ /* */ /************************************************************************ * * * FT_Alloc_Func * * * The memory allocator function type * * * system :: pointer to the system object * size :: requested size in bytes * * * block :: address of newly allocated block * * * Error code. 0 means success. * * * 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); } /************************************************************************ * * * FT_Realloc_Func * * * The memory reallocator function type * * * system :: pointer to the system object * new_size :: new requested size in bytes * * * block :: address of block in memory * * * Error code. 0 means success. * * * 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 ); } /************************************************************************ * * * FT_Free_Func * * * The memory release function type * * * system :: pointer to the system object * block :: address of block in memory * * * 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; }