ftsystem.c (8149B)
1 /**************************************************************************** 2 * 3 * ftsystem.c 4 * 5 * ANSI-specific FreeType low-level system interface (body). 6 * 7 * Copyright (C) 1996-2025 by 8 * David Turner, Robert Wilhelm, and Werner Lemberg. 9 * 10 * This file is part of the FreeType project, and may only be used, 11 * modified, and distributed under the terms of the FreeType project 12 * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 * this file you indicate that you have read the license and 14 * understand and accept it fully. 15 * 16 */ 17 18 /************************************************************************** 19 * 20 * This file contains the default interface used by FreeType to access 21 * low-level, i.e. memory management, i/o access as well as thread 22 * synchronisation. It can be replaced by user-specific routines if 23 * necessary. 24 * 25 */ 26 27 28 #include <ft2build.h> 29 #include FT_CONFIG_CONFIG_H 30 #include <freetype/internal/ftdebug.h> 31 #include <freetype/internal/ftstream.h> 32 #include <freetype/ftsystem.h> 33 #include <freetype/fterrors.h> 34 #include <freetype/fttypes.h> 35 36 37 /************************************************************************** 38 * 39 * MEMORY MANAGEMENT INTERFACE 40 * 41 */ 42 43 /************************************************************************** 44 * 45 * It is not necessary to do any error checking for the 46 * allocation-related functions. This will be done by the higher level 47 * routines like ft_mem_alloc() or ft_mem_realloc(). 48 * 49 */ 50 51 52 /************************************************************************** 53 * 54 * @Function: 55 * ft_alloc 56 * 57 * @Description: 58 * The memory allocation function. 59 * 60 * @Input: 61 * memory :: 62 * A pointer to the memory object. 63 * 64 * size :: 65 * The requested size in bytes. 66 * 67 * @Return: 68 * The address of newly allocated block. 69 */ 70 FT_CALLBACK_DEF( void* ) 71 ft_alloc( FT_Memory memory, 72 long size ) 73 { 74 FT_UNUSED( memory ); 75 76 return ft_smalloc( (size_t)size ); 77 } 78 79 80 /************************************************************************** 81 * 82 * @Function: 83 * ft_realloc 84 * 85 * @Description: 86 * The memory reallocation function. 87 * 88 * @Input: 89 * memory :: 90 * A pointer to the memory object. 91 * 92 * cur_size :: 93 * The current size of the allocated memory block. 94 * 95 * new_size :: 96 * The newly requested size in bytes. 97 * 98 * block :: 99 * The current address of the block in memory. 100 * 101 * @Return: 102 * The address of the reallocated memory block. 103 */ 104 FT_CALLBACK_DEF( void* ) 105 ft_realloc( FT_Memory memory, 106 long cur_size, 107 long new_size, 108 void* block ) 109 { 110 FT_UNUSED( memory ); 111 FT_UNUSED( cur_size ); 112 113 return ft_srealloc( block, (size_t)new_size ); 114 } 115 116 117 /************************************************************************** 118 * 119 * @Function: 120 * ft_free 121 * 122 * @Description: 123 * The memory release function. 124 * 125 * @Input: 126 * memory :: 127 * A pointer to the memory object. 128 * 129 * block :: 130 * The address of block in memory to be freed. 131 */ 132 FT_CALLBACK_DEF( void ) 133 ft_free( FT_Memory memory, 134 void* block ) 135 { 136 FT_UNUSED( memory ); 137 138 ft_sfree( block ); 139 } 140 141 142 /************************************************************************** 143 * 144 * RESOURCE MANAGEMENT INTERFACE 145 * 146 */ 147 148 #ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT 149 150 /************************************************************************** 151 * 152 * The macro FT_COMPONENT is used in trace mode. It is an implicit 153 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log 154 * messages during execution. 155 */ 156 #undef FT_COMPONENT 157 #define FT_COMPONENT io 158 159 /* We use the macro STREAM_FILE for convenience to extract the */ 160 /* system-specific stream handle from a given FreeType stream object */ 161 #define STREAM_FILE( stream ) ( (FT_FILE*)stream->descriptor.pointer ) 162 163 164 /************************************************************************** 165 * 166 * @Function: 167 * ft_ansi_stream_close 168 * 169 * @Description: 170 * The function to close a stream. 171 * 172 * @Input: 173 * stream :: 174 * A pointer to the stream object. 175 */ 176 FT_CALLBACK_DEF( void ) 177 ft_ansi_stream_close( FT_Stream stream ) 178 { 179 ft_fclose( STREAM_FILE( stream ) ); 180 181 stream->descriptor.pointer = NULL; 182 stream->size = 0; 183 stream->base = NULL; 184 } 185 186 187 /************************************************************************** 188 * 189 * @Function: 190 * ft_ansi_stream_io 191 * 192 * @Description: 193 * The function to open a stream. 194 * 195 * @Input: 196 * stream :: 197 * A pointer to the stream object. 198 * 199 * offset :: 200 * The position in the data stream to start reading. 201 * 202 * buffer :: 203 * The address of buffer to store the read data. 204 * 205 * count :: 206 * The number of bytes to read from the stream. 207 * 208 * @Return: 209 * The number of bytes actually read. If `count' is zero (that is, 210 * the function is used for seeking), a non-zero return value 211 * indicates an error. 212 */ 213 FT_CALLBACK_DEF( unsigned long ) 214 ft_ansi_stream_io( FT_Stream stream, 215 unsigned long offset, 216 unsigned char* buffer, 217 unsigned long count ) 218 { 219 FT_FILE* file; 220 221 222 if ( offset > stream->size && !count ) 223 return 1; 224 225 file = STREAM_FILE( stream ); 226 227 if ( stream->pos != offset ) 228 ft_fseek( file, (long)offset, SEEK_SET ); 229 230 /* Avoid calling `fread` with `buffer=NULL` and `count=0`, */ 231 /* which is undefined behaviour. */ 232 if ( !count ) 233 return 0; 234 235 return (unsigned long)ft_fread( buffer, 1, count, file ); 236 } 237 238 239 /* documentation is in ftstream.h */ 240 241 FT_BASE_DEF( FT_Error ) 242 FT_Stream_Open( FT_Stream stream, 243 const char* filepathname ) 244 { 245 FT_FILE* file; 246 247 248 if ( !stream ) 249 return FT_THROW( Invalid_Stream_Handle ); 250 251 stream->descriptor.pointer = NULL; 252 stream->pathname.pointer = (char*)filepathname; 253 stream->base = NULL; 254 stream->pos = 0; 255 stream->read = NULL; 256 stream->close = NULL; 257 258 file = ft_fopen( filepathname, "rb" ); 259 if ( !file ) 260 { 261 FT_ERROR(( "FT_Stream_Open:" 262 " could not open `%s'\n", filepathname )); 263 264 return FT_THROW( Cannot_Open_Resource ); 265 } 266 267 ft_fseek( file, 0, SEEK_END ); 268 stream->size = (unsigned long)ft_ftell( file ); 269 if ( !stream->size ) 270 { 271 FT_ERROR(( "FT_Stream_Open:" )); 272 FT_ERROR(( " opened `%s' but zero-sized\n", filepathname )); 273 ft_fclose( file ); 274 return FT_THROW( Cannot_Open_Stream ); 275 } 276 ft_fseek( file, 0, SEEK_SET ); 277 278 stream->descriptor.pointer = file; 279 stream->read = ft_ansi_stream_io; 280 stream->close = ft_ansi_stream_close; 281 282 FT_TRACE1(( "FT_Stream_Open:" )); 283 FT_TRACE1(( " opened `%s' (%lu bytes) successfully\n", 284 filepathname, stream->size )); 285 286 return FT_Err_Ok; 287 } 288 289 #endif /* !FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT */ 290 291 #ifdef FT_DEBUG_MEMORY 292 293 extern FT_Int 294 ft_mem_debug_init( FT_Memory memory ); 295 296 extern void 297 ft_mem_debug_done( FT_Memory memory ); 298 299 #endif 300 301 302 /* documentation is in ftobjs.h */ 303 304 FT_BASE_DEF( FT_Memory ) 305 FT_New_Memory( void ) 306 { 307 FT_Memory memory; 308 309 310 memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) ); 311 if ( memory ) 312 { 313 memory->user = NULL; 314 memory->alloc = ft_alloc; 315 memory->realloc = ft_realloc; 316 memory->free = ft_free; 317 #ifdef FT_DEBUG_MEMORY 318 ft_mem_debug_init( memory ); 319 #endif 320 } 321 322 return memory; 323 } 324 325 326 /* documentation is in ftobjs.h */ 327 328 FT_BASE_DEF( void ) 329 FT_Done_Memory( FT_Memory memory ) 330 { 331 #ifdef FT_DEBUG_MEMORY 332 ft_mem_debug_done( memory ); 333 #endif 334 ft_sfree( memory ); 335 } 336 337 338 /* END */