| /***************************************************************************/ | |
| /* */ | |
| /* 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 */ |