| /***************************************************************************/ |
| /* */ |
| /* ftmemory.h */ |
| /* */ |
| /* The FreeType memory management macros (specification). */ |
| /* */ |
| /* Copyright 1996-2015 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. */ |
| /* */ |
| /***************************************************************************/ |
| |
| |
| #ifndef __FTMEMORY_H__ |
| #define __FTMEMORY_H__ |
| |
| |
| #include <ft2build.h> |
| #include FT_CONFIG_CONFIG_H |
| #include FT_TYPES_H |
| |
| |
| FT_BEGIN_HEADER |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Macro> */ |
| /* FT_SET_ERROR */ |
| /* */ |
| /* <Description> */ |
| /* This macro is used to set an implicit `error' variable to a given */ |
| /* expression's value (usually a function call), and convert it to a */ |
| /* boolean which is set whenever the value is != 0. */ |
| /* */ |
| #undef FT_SET_ERROR |
| #define FT_SET_ERROR( expression ) \ |
| ( ( error = (expression) ) != 0 ) |
| |
| |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /**** ****/ |
| /**** ****/ |
| /**** M E M O R Y ****/ |
| /**** ****/ |
| /**** ****/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| |
| /* |
| * C++ refuses to handle statements like p = (void*)anything, with `p' a |
| * typed pointer. Since we don't have a `typeof' operator in standard |
| * C++, we have to use a template to emulate it. |
| */ |
| |
| #ifdef __cplusplus |
| |
| extern "C++" |
| template <typename T> inline T* |
| cplusplus_typeof( T*, |
| void *v ) |
| { |
| return static_cast <T*> ( v ); |
| } |
| |
| #define FT_ASSIGNP( p, val ) (p) = cplusplus_typeof( (p), (val) ) |
| |
| #else |
| |
| #define FT_ASSIGNP( p, val ) (p) = (val) |
| |
| #endif |
| |
| |
| |
| #ifdef FT_DEBUG_MEMORY |
| |
| FT_BASE( const char* ) _ft_debug_file; |
| FT_BASE( long ) _ft_debug_lineno; |
| |
| #define FT_DEBUG_INNER( exp ) ( _ft_debug_file = __FILE__, \ |
| _ft_debug_lineno = __LINE__, \ |
| (exp) ) |
| |
| #define FT_ASSIGNP_INNER( p, exp ) ( _ft_debug_file = __FILE__, \ |
| _ft_debug_lineno = __LINE__, \ |
| FT_ASSIGNP( p, exp ) ) |
| |
| #else /* !FT_DEBUG_MEMORY */ |
| |
| #define FT_DEBUG_INNER( exp ) (exp) |
| #define FT_ASSIGNP_INNER( p, exp ) FT_ASSIGNP( p, exp ) |
| |
| #endif /* !FT_DEBUG_MEMORY */ |
| |
| |
| /* |
| * The allocation functions return a pointer, and the error code |
| * is written to through the `p_error' parameter. See below for |
| * for documentation. |
| */ |
| |
| FT_BASE( FT_Pointer ) |
| ft_mem_alloc( FT_Memory memory, |
| FT_Long size, |
| FT_Error *p_error ); |
| |
| FT_BASE( FT_Pointer ) |
| ft_mem_qalloc( FT_Memory memory, |
| FT_Long size, |
| FT_Error *p_error ); |
| |
| FT_BASE( FT_Pointer ) |
| ft_mem_realloc( FT_Memory memory, |
| FT_Long item_size, |
| FT_Long cur_count, |
| FT_Long new_count, |
| void* block, |
| FT_Error *p_error ); |
| |
| FT_BASE( FT_Pointer ) |
| ft_mem_qrealloc( FT_Memory memory, |
| FT_Long item_size, |
| FT_Long cur_count, |
| FT_Long new_count, |
| void* block, |
| FT_Error *p_error ); |
| |
| FT_BASE( void ) |
| ft_mem_free( FT_Memory memory, |
| const void* P ); |
| |
| |
| #define FT_MEM_ALLOC( ptr, size ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_alloc( memory, \ |
| (FT_Long)(size), \ |
| &error ) ) |
| |
| #define FT_MEM_FREE( ptr ) \ |
| FT_BEGIN_STMNT \ |
| ft_mem_free( memory, (ptr) ); \ |
| (ptr) = NULL; \ |
| FT_END_STMNT |
| |
| #define FT_MEM_NEW( ptr ) \ |
| FT_MEM_ALLOC( ptr, sizeof ( *(ptr) ) ) |
| |
| #define FT_MEM_REALLOC( ptr, cursz, newsz ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \ |
| 1, \ |
| (FT_Long)(cursz), \ |
| (FT_Long)(newsz), \ |
| (ptr), \ |
| &error ) ) |
| |
| #define FT_MEM_QALLOC( ptr, size ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_qalloc( memory, \ |
| (FT_Long)(size), \ |
| &error ) ) |
| |
| #define FT_MEM_QNEW( ptr ) \ |
| FT_MEM_QALLOC( ptr, sizeof ( *(ptr) ) ) |
| |
| #define FT_MEM_QREALLOC( ptr, cursz, newsz ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \ |
| 1, \ |
| (FT_Long)(cursz), \ |
| (FT_Long)(newsz), \ |
| (ptr), \ |
| &error ) ) |
| |
| #define FT_MEM_ALLOC_MULT( ptr, count, item_size ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \ |
| (FT_Long)(item_size), \ |
| 0, \ |
| (FT_Long)(count), \ |
| NULL, \ |
| &error ) ) |
| |
| #define FT_MEM_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \ |
| (FT_Long)(itmsz), \ |
| (FT_Long)(oldcnt), \ |
| (FT_Long)(newcnt), \ |
| (ptr), \ |
| &error ) ) |
| |
| #define FT_MEM_QALLOC_MULT( ptr, count, item_size ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \ |
| (FT_Long)(item_size), \ |
| 0, \ |
| (FT_Long)(count), \ |
| NULL, \ |
| &error ) ) |
| |
| #define FT_MEM_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \ |
| (FT_Long)(itmsz), \ |
| (FT_Long)(oldcnt), \ |
| (FT_Long)(newcnt), \ |
| (ptr), \ |
| &error ) ) |
| |
| |
| #define FT_MEM_SET_ERROR( cond ) ( (cond), error != 0 ) |
| |
| |
| #define FT_MEM_SET( dest, byte, count ) \ |
| ft_memset( dest, byte, (FT_Offset)(count) ) |
| |
| #define FT_MEM_COPY( dest, source, count ) \ |
| ft_memcpy( dest, source, (FT_Offset)(count) ) |
| |
| #define FT_MEM_MOVE( dest, source, count ) \ |
| ft_memmove( dest, source, (FT_Offset)(count) ) |
| |
| |
| #define FT_MEM_ZERO( dest, count ) FT_MEM_SET( dest, 0, count ) |
| |
| #define FT_ZERO( p ) FT_MEM_ZERO( p, sizeof ( *(p) ) ) |
| |
| |
| #define FT_ARRAY_ZERO( dest, count ) \ |
| FT_MEM_ZERO( dest, \ |
| (FT_Offset)(count) * sizeof ( *(dest) ) ) |
| |
| #define FT_ARRAY_COPY( dest, source, count ) \ |
| FT_MEM_COPY( dest, \ |
| source, \ |
| (FT_Offset)(count) * sizeof ( *(dest) ) ) |
| |
| #define FT_ARRAY_MOVE( dest, source, count ) \ |
| FT_MEM_MOVE( dest, \ |
| source, \ |
| (FT_Offset)(count) * sizeof ( *(dest) ) ) |
| |
| |
| /* |
| * Return the maximum number of addressable elements in an array. |
| * We limit ourselves to INT_MAX, rather than UINT_MAX, to avoid |
| * any problems. |
| */ |
| #define FT_ARRAY_MAX( ptr ) ( FT_INT_MAX / sizeof ( *(ptr) ) ) |
| |
| #define FT_ARRAY_CHECK( ptr, count ) ( (count) <= FT_ARRAY_MAX( ptr ) ) |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* The following functions macros expect that their pointer argument is */ |
| /* _typed_ in order to automatically compute array element sizes. */ |
| /* */ |
| |
| #define FT_MEM_NEW_ARRAY( ptr, count ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \ |
| sizeof ( *(ptr) ), \ |
| 0, \ |
| (FT_Long)(count), \ |
| NULL, \ |
| &error ) ) |
| |
| #define FT_MEM_RENEW_ARRAY( ptr, cursz, newsz ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \ |
| sizeof ( *(ptr) ), \ |
| (FT_Long)(cursz), \ |
| (FT_Long)(newsz), \ |
| (ptr), \ |
| &error ) ) |
| |
| #define FT_MEM_QNEW_ARRAY( ptr, count ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \ |
| sizeof ( *(ptr) ), \ |
| 0, \ |
| (FT_Long)(count), \ |
| NULL, \ |
| &error ) ) |
| |
| #define FT_MEM_QRENEW_ARRAY( ptr, cursz, newsz ) \ |
| FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \ |
| sizeof ( *(ptr) ), \ |
| (FT_Long)(cursz), \ |
| (FT_Long)(newsz), \ |
| (ptr), \ |
| &error ) ) |
| |
| #define FT_ALLOC( ptr, size ) \ |
| FT_MEM_SET_ERROR( FT_MEM_ALLOC( ptr, size ) ) |
| |
| #define FT_REALLOC( ptr, cursz, newsz ) \ |
| FT_MEM_SET_ERROR( FT_MEM_REALLOC( ptr, cursz, newsz ) ) |
| |
| #define FT_ALLOC_MULT( ptr, count, item_size ) \ |
| FT_MEM_SET_ERROR( FT_MEM_ALLOC_MULT( ptr, count, item_size ) ) |
| |
| #define FT_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \ |
| FT_MEM_SET_ERROR( FT_MEM_REALLOC_MULT( ptr, oldcnt, \ |
| newcnt, itmsz ) ) |
| |
| #define FT_QALLOC( ptr, size ) \ |
| FT_MEM_SET_ERROR( FT_MEM_QALLOC( ptr, size ) ) |
| |
| #define FT_QREALLOC( ptr, cursz, newsz ) \ |
| FT_MEM_SET_ERROR( FT_MEM_QREALLOC( ptr, cursz, newsz ) ) |
| |
| #define FT_QALLOC_MULT( ptr, count, item_size ) \ |
| FT_MEM_SET_ERROR( FT_MEM_QALLOC_MULT( ptr, count, item_size ) ) |
| |
| #define FT_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \ |
| FT_MEM_SET_ERROR( FT_MEM_QREALLOC_MULT( ptr, oldcnt, \ |
| newcnt, itmsz ) ) |
| |
| #define FT_FREE( ptr ) FT_MEM_FREE( ptr ) |
| |
| #define FT_NEW( ptr ) FT_MEM_SET_ERROR( FT_MEM_NEW( ptr ) ) |
| |
| #define FT_NEW_ARRAY( ptr, count ) \ |
| FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) ) |
| |
| #define FT_RENEW_ARRAY( ptr, curcnt, newcnt ) \ |
| FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) ) |
| |
| #define FT_QNEW( ptr ) \ |
| FT_MEM_SET_ERROR( FT_MEM_QNEW( ptr ) ) |
| |
| #define FT_QNEW_ARRAY( ptr, count ) \ |
| FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) ) |
| |
| #define FT_QRENEW_ARRAY( ptr, curcnt, newcnt ) \ |
| FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) ) |
| |
| |
| FT_BASE( FT_Pointer ) |
| ft_mem_strdup( FT_Memory memory, |
| const char* str, |
| FT_Error *p_error ); |
| |
| FT_BASE( FT_Pointer ) |
| ft_mem_dup( FT_Memory memory, |
| const void* address, |
| FT_ULong size, |
| FT_Error *p_error ); |
| |
| |
| #define FT_MEM_STRDUP( dst, str ) \ |
| (dst) = (char*)ft_mem_strdup( memory, (const char*)(str), &error ) |
| |
| #define FT_STRDUP( dst, str ) \ |
| FT_MEM_SET_ERROR( FT_MEM_STRDUP( dst, str ) ) |
| |
| #define FT_MEM_DUP( dst, address, size ) \ |
| (dst) = ft_mem_dup( memory, (address), (FT_ULong)(size), &error ) |
| |
| #define FT_DUP( dst, address, size ) \ |
| FT_MEM_SET_ERROR( FT_MEM_DUP( dst, address, size ) ) |
| |
| |
| /* Return >= 1 if a truncation occurs. */ |
| /* Return 0 if the source string fits the buffer. */ |
| /* This is *not* the same as strlcpy(). */ |
| FT_BASE( FT_Int ) |
| ft_mem_strcpyn( char* dst, |
| const char* src, |
| FT_ULong size ); |
| |
| #define FT_STRCPYN( dst, src, size ) \ |
| ft_mem_strcpyn( (char*)dst, (const char*)(src), (FT_ULong)(size) ) |
| |
| /* */ |
| |
| |
| FT_END_HEADER |
| |
| #endif /* __FTMEMORY_H__ */ |
| |
| |
| /* END */ |
