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