/***************************************************************************/ /* */ /* ftsystem.c */ /* */ /* ANSI-specific FreeType low-level system interface (body). */ /* */ /* Copyright 1996-2001, 2002 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* */ /* Modified for XFree86. */ /* */ /* 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. */ /* */ /***************************************************************************/ /* Modified for XFree86 */ /* $XFree86$ */ /*************************************************************************/ /* */ /* 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. */ /* */ /*************************************************************************/ #ifdef HAVE_CONFIG_H #include #endif #include #include FT_CONFIG_CONFIG_H #include FT_SYSTEM_H #include FT_ERRORS_H #include FT_TYPES_H #ifndef FONTMODULE #include #include #else #include "Xmd.h" #define _XTYPEDEF_BOOL #include "Xdefs.h" #define DONT_DEFINE_WRAPPERS #include "xf86_ansic.h" #undef DONT_DEFINE_WRAPPERS #define malloc(x) xf86malloc(x) #define realloc(x, y) xf86realloc(x, y) #define free(x) xf86free(x) #define FILE XF86FILE #define fopen(x, y) xf86fopen(x, y) #define fclose(x) xf86fclose(x) #define fseek(x, y, z) xf86fseek(x, y, z) #define ftell(x) xf86ftell(x) #define SEEK_SET XF86_SEEK_SET #define SEEK_END XF86_SEEK_END #define fread(x, y, z, t) xf86fread(x, y, z, t) #endif /*************************************************************************/ /* */ /* 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_Alloc() or FT_Realloc(). */ /* */ /*************************************************************************/ /*************************************************************************/ /* */ /* */ /* ft_alloc */ /* */ /* */ /* The memory allocation function. */ /* */ /* */ /* memory :: A pointer to the memory object. */ /* */ /* size :: The requested size in bytes. */ /* */ /* */ /* The address of newly allocated block. */ /* */ FT_CALLBACK_DEF( void* ) ft_alloc( FT_Memory memory, long size ) { FT_UNUSED( memory ); return malloc( size ); } /*************************************************************************/ /* */ /* */ /* ft_realloc */ /* */ /* */ /* The memory reallocation function. */ /* */ /* */ /* memory :: A pointer to the memory object. */ /* */ /* cur_size :: The current size of the allocated memory block. */ /* */ /* new_size :: The newly requested size in bytes. */ /* */ /* block :: The current address of the block in memory. */ /* */ /* */ /* The address of the reallocated memory block. */ /* */ FT_CALLBACK_DEF( void* ) ft_realloc( FT_Memory memory, long cur_size, long new_size, void* block ) { FT_UNUSED( memory ); FT_UNUSED( cur_size ); return realloc( block, new_size ); } /*************************************************************************/ /* */ /* */ /* ft_free */ /* */ /* */ /* The memory release function. */ /* */ /* */ /* 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 ); free( block ); } /*************************************************************************/ /* */ /* RESOURCE MANAGEMENT INTERFACE */ /* */ /*************************************************************************/ /*************************************************************************/ /* */ /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ /* messages during execution. */ /* */ #undef FT_COMPONENT #define FT_COMPONENT trace_io /* We use the macro STREAM_FILE for convenience to extract the */ /* system-specific stream handle from a given FreeType stream object */ #define STREAM_FILE( stream ) ( (FILE*)stream->descriptor.pointer ) /*************************************************************************/ /* */ /* */ /* ft_ansi_stream_close */ /* */ /* */ /* The function to close a stream. */ /* */ /* */ /* stream :: A pointer to the stream object. */ /* */ FT_CALLBACK_DEF( void ) ft_ansi_stream_close( FT_Stream stream ) { fclose( STREAM_FILE( stream ) ); stream->descriptor.pointer = NULL; stream->size = 0; stream->base = 0; } /*************************************************************************/ /* */ /* */ /* ft_ansi_stream_io */ /* */ /* */ /* The function to open a stream. */ /* */ /* */ /* stream :: A pointer to the stream object. */ /* */ /* offset :: The position in the data stream to start reading. */ /* */ /* buffer :: The address of buffer to store the read data. */ /* */ /* count :: The number of bytes to read from the stream. */ /* */ /* */ /* The number of bytes actually read. */ /* */ FT_CALLBACK_DEF( unsigned long ) ft_ansi_stream_io( FT_Stream stream, unsigned long offset, unsigned char* buffer, unsigned long count ) { FILE* file; file = STREAM_FILE( stream ); fseek( file, offset, SEEK_SET ); return (unsigned long)fread( buffer, 1, count, file ); } /* documentation is in ftobjs.h */ FT_EXPORT_DEF( FT_Error ) FT_Stream_Open( FT_Stream stream, const char* filepathname ) { FILE* file; if ( !stream ) return FT_Err_Invalid_Stream_Handle; file = fopen( filepathname, "rb" ); if ( !file ) { FT_ERROR(( "FT_Stream_Open:" )); FT_ERROR(( " could not open `%s'\n", filepathname )); return FT_Err_Cannot_Open_Resource; } fseek( file, 0, SEEK_END ); stream->size = ftell( file ); fseek( file, 0, SEEK_SET ); stream->descriptor.pointer = file; stream->pathname.pointer = (char*)filepathname; stream->pos = 0; 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 )); return FT_Err_Ok; } #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_EXPORT_DEF( 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; #ifdef FT_DEBUG_MEMORY ft_mem_debug_init( memory ); #endif } return memory; } /* documentation is in ftobjs.h */ FT_EXPORT_DEF( void ) FT_Done_Memory( FT_Memory memory ) { #ifdef FT_DEBUG_MEMORY ft_mem_debug_done( memory ); #endif #undef free memory->free( memory, memory ); } /* END */