vrshoot

annotate libs/ft2static/freetype/internal/ftmemory.h @ 0:b2f14e535253

find changesets by author, revision, files, or words in the commit message
initial commit
author John Tsiombikas <nuclear@member.fsf.org>
date Sat, 01 Feb 2014 19:58:19 +0200
parents
children
rev   line source
nuclear@0 1 /***************************************************************************/
nuclear@0 2 /* */
nuclear@0 3 /* ftmemory.h */
nuclear@0 4 /* */
nuclear@0 5 /* The FreeType memory management macros (specification). */
nuclear@0 6 /* */
nuclear@0 7 /* Copyright 1996-2001, 2002, 2004, 2005, 2006, 2007, 2010 by */
nuclear@0 8 /* David Turner, Robert Wilhelm, and Werner Lemberg */
nuclear@0 9 /* */
nuclear@0 10 /* This file is part of the FreeType project, and may only be used, */
nuclear@0 11 /* modified, and distributed under the terms of the FreeType project */
nuclear@0 12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
nuclear@0 13 /* this file you indicate that you have read the license and */
nuclear@0 14 /* understand and accept it fully. */
nuclear@0 15 /* */
nuclear@0 16 /***************************************************************************/
nuclear@0 17
nuclear@0 18
nuclear@0 19 #ifndef __FTMEMORY_H__
nuclear@0 20 #define __FTMEMORY_H__
nuclear@0 21
nuclear@0 22
nuclear@0 23 #include <ft2build.h>
nuclear@0 24 #include FT_CONFIG_CONFIG_H
nuclear@0 25 #include FT_TYPES_H
nuclear@0 26
nuclear@0 27
nuclear@0 28 FT_BEGIN_HEADER
nuclear@0 29
nuclear@0 30
nuclear@0 31 /*************************************************************************/
nuclear@0 32 /* */
nuclear@0 33 /* <Macro> */
nuclear@0 34 /* FT_SET_ERROR */
nuclear@0 35 /* */
nuclear@0 36 /* <Description> */
nuclear@0 37 /* This macro is used to set an implicit `error' variable to a given */
nuclear@0 38 /* expression's value (usually a function call), and convert it to a */
nuclear@0 39 /* boolean which is set whenever the value is != 0. */
nuclear@0 40 /* */
nuclear@0 41 #undef FT_SET_ERROR
nuclear@0 42 #define FT_SET_ERROR( expression ) \
nuclear@0 43 ( ( error = (expression) ) != 0 )
nuclear@0 44
nuclear@0 45
nuclear@0 46
nuclear@0 47 /*************************************************************************/
nuclear@0 48 /*************************************************************************/
nuclear@0 49 /*************************************************************************/
nuclear@0 50 /**** ****/
nuclear@0 51 /**** ****/
nuclear@0 52 /**** M E M O R Y ****/
nuclear@0 53 /**** ****/
nuclear@0 54 /**** ****/
nuclear@0 55 /*************************************************************************/
nuclear@0 56 /*************************************************************************/
nuclear@0 57 /*************************************************************************/
nuclear@0 58
nuclear@0 59
nuclear@0 60 /*
nuclear@0 61 * C++ refuses to handle statements like p = (void*)anything, with `p' a
nuclear@0 62 * typed pointer. Since we don't have a `typeof' operator in standard
nuclear@0 63 * C++, we have to use a template to emulate it.
nuclear@0 64 */
nuclear@0 65
nuclear@0 66 #ifdef __cplusplus
nuclear@0 67
nuclear@0 68 extern "C++"
nuclear@0 69 template <typename T> inline T*
nuclear@0 70 cplusplus_typeof( T*,
nuclear@0 71 void *v )
nuclear@0 72 {
nuclear@0 73 return static_cast <T*> ( v );
nuclear@0 74 }
nuclear@0 75
nuclear@0 76 #define FT_ASSIGNP( p, val ) (p) = cplusplus_typeof( (p), (val) )
nuclear@0 77
nuclear@0 78 #else
nuclear@0 79
nuclear@0 80 #define FT_ASSIGNP( p, val ) (p) = (val)
nuclear@0 81
nuclear@0 82 #endif
nuclear@0 83
nuclear@0 84
nuclear@0 85
nuclear@0 86 #ifdef FT_DEBUG_MEMORY
nuclear@0 87
nuclear@0 88 FT_BASE( const char* ) _ft_debug_file;
nuclear@0 89 FT_BASE( long ) _ft_debug_lineno;
nuclear@0 90
nuclear@0 91 #define FT_DEBUG_INNER( exp ) ( _ft_debug_file = __FILE__, \
nuclear@0 92 _ft_debug_lineno = __LINE__, \
nuclear@0 93 (exp) )
nuclear@0 94
nuclear@0 95 #define FT_ASSIGNP_INNER( p, exp ) ( _ft_debug_file = __FILE__, \
nuclear@0 96 _ft_debug_lineno = __LINE__, \
nuclear@0 97 FT_ASSIGNP( p, exp ) )
nuclear@0 98
nuclear@0 99 #else /* !FT_DEBUG_MEMORY */
nuclear@0 100
nuclear@0 101 #define FT_DEBUG_INNER( exp ) (exp)
nuclear@0 102 #define FT_ASSIGNP_INNER( p, exp ) FT_ASSIGNP( p, exp )
nuclear@0 103
nuclear@0 104 #endif /* !FT_DEBUG_MEMORY */
nuclear@0 105
nuclear@0 106
nuclear@0 107 /*
nuclear@0 108 * The allocation functions return a pointer, and the error code
nuclear@0 109 * is written to through the `p_error' parameter. See below for
nuclear@0 110 * for documentation.
nuclear@0 111 */
nuclear@0 112
nuclear@0 113 FT_BASE( FT_Pointer )
nuclear@0 114 ft_mem_alloc( FT_Memory memory,
nuclear@0 115 FT_Long size,
nuclear@0 116 FT_Error *p_error );
nuclear@0 117
nuclear@0 118 FT_BASE( FT_Pointer )
nuclear@0 119 ft_mem_qalloc( FT_Memory memory,
nuclear@0 120 FT_Long size,
nuclear@0 121 FT_Error *p_error );
nuclear@0 122
nuclear@0 123 FT_BASE( FT_Pointer )
nuclear@0 124 ft_mem_realloc( FT_Memory memory,
nuclear@0 125 FT_Long item_size,
nuclear@0 126 FT_Long cur_count,
nuclear@0 127 FT_Long new_count,
nuclear@0 128 void* block,
nuclear@0 129 FT_Error *p_error );
nuclear@0 130
nuclear@0 131 FT_BASE( FT_Pointer )
nuclear@0 132 ft_mem_qrealloc( FT_Memory memory,
nuclear@0 133 FT_Long item_size,
nuclear@0 134 FT_Long cur_count,
nuclear@0 135 FT_Long new_count,
nuclear@0 136 void* block,
nuclear@0 137 FT_Error *p_error );
nuclear@0 138
nuclear@0 139 FT_BASE( void )
nuclear@0 140 ft_mem_free( FT_Memory memory,
nuclear@0 141 const void* P );
nuclear@0 142
nuclear@0 143
nuclear@0 144 #define FT_MEM_ALLOC( ptr, size ) \
nuclear@0 145 FT_ASSIGNP_INNER( ptr, ft_mem_alloc( memory, (size), &error ) )
nuclear@0 146
nuclear@0 147 #define FT_MEM_FREE( ptr ) \
nuclear@0 148 FT_BEGIN_STMNT \
nuclear@0 149 ft_mem_free( memory, (ptr) ); \
nuclear@0 150 (ptr) = NULL; \
nuclear@0 151 FT_END_STMNT
nuclear@0 152
nuclear@0 153 #define FT_MEM_NEW( ptr ) \
nuclear@0 154 FT_MEM_ALLOC( ptr, sizeof ( *(ptr) ) )
nuclear@0 155
nuclear@0 156 #define FT_MEM_REALLOC( ptr, cursz, newsz ) \
nuclear@0 157 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, 1, \
nuclear@0 158 (cursz), (newsz), \
nuclear@0 159 (ptr), &error ) )
nuclear@0 160
nuclear@0 161 #define FT_MEM_QALLOC( ptr, size ) \
nuclear@0 162 FT_ASSIGNP_INNER( ptr, ft_mem_qalloc( memory, (size), &error ) )
nuclear@0 163
nuclear@0 164 #define FT_MEM_QNEW( ptr ) \
nuclear@0 165 FT_MEM_QALLOC( ptr, sizeof ( *(ptr) ) )
nuclear@0 166
nuclear@0 167 #define FT_MEM_QREALLOC( ptr, cursz, newsz ) \
nuclear@0 168 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, 1, \
nuclear@0 169 (cursz), (newsz), \
nuclear@0 170 (ptr), &error ) )
nuclear@0 171
nuclear@0 172 #define FT_MEM_QRENEW_ARRAY( ptr, cursz, newsz ) \
nuclear@0 173 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, sizeof ( *(ptr) ), \
nuclear@0 174 (cursz), (newsz), \
nuclear@0 175 (ptr), &error ) )
nuclear@0 176
nuclear@0 177 #define FT_MEM_ALLOC_MULT( ptr, count, item_size ) \
nuclear@0 178 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, (item_size), \
nuclear@0 179 0, (count), \
nuclear@0 180 NULL, &error ) )
nuclear@0 181
nuclear@0 182 #define FT_MEM_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
nuclear@0 183 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, (itmsz), \
nuclear@0 184 (oldcnt), (newcnt), \
nuclear@0 185 (ptr), &error ) )
nuclear@0 186
nuclear@0 187 #define FT_MEM_QALLOC_MULT( ptr, count, item_size ) \
nuclear@0 188 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, (item_size), \
nuclear@0 189 0, (count), \
nuclear@0 190 NULL, &error ) )
nuclear@0 191
nuclear@0 192 #define FT_MEM_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz) \
nuclear@0 193 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, (itmsz), \
nuclear@0 194 (oldcnt), (newcnt), \
nuclear@0 195 (ptr), &error ) )
nuclear@0 196
nuclear@0 197
nuclear@0 198 #define FT_MEM_SET_ERROR( cond ) ( (cond), error != 0 )
nuclear@0 199
nuclear@0 200
nuclear@0 201 #define FT_MEM_SET( dest, byte, count ) ft_memset( dest, byte, count )
nuclear@0 202
nuclear@0 203 #define FT_MEM_COPY( dest, source, count ) ft_memcpy( dest, source, count )
nuclear@0 204
nuclear@0 205 #define FT_MEM_MOVE( dest, source, count ) ft_memmove( dest, source, count )
nuclear@0 206
nuclear@0 207
nuclear@0 208 #define FT_MEM_ZERO( dest, count ) FT_MEM_SET( dest, 0, count )
nuclear@0 209
nuclear@0 210 #define FT_ZERO( p ) FT_MEM_ZERO( p, sizeof ( *(p) ) )
nuclear@0 211
nuclear@0 212
nuclear@0 213 #define FT_ARRAY_ZERO( dest, count ) \
nuclear@0 214 FT_MEM_ZERO( dest, (count) * sizeof ( *(dest) ) )
nuclear@0 215
nuclear@0 216 #define FT_ARRAY_COPY( dest, source, count ) \
nuclear@0 217 FT_MEM_COPY( dest, source, (count) * sizeof ( *(dest) ) )
nuclear@0 218
nuclear@0 219 #define FT_ARRAY_MOVE( dest, source, count ) \
nuclear@0 220 FT_MEM_MOVE( dest, source, (count) * sizeof ( *(dest) ) )
nuclear@0 221
nuclear@0 222
nuclear@0 223 /*
nuclear@0 224 * Return the maximum number of addressable elements in an array.
nuclear@0 225 * We limit ourselves to INT_MAX, rather than UINT_MAX, to avoid
nuclear@0 226 * any problems.
nuclear@0 227 */
nuclear@0 228 #define FT_ARRAY_MAX( ptr ) ( FT_INT_MAX / sizeof ( *(ptr) ) )
nuclear@0 229
nuclear@0 230 #define FT_ARRAY_CHECK( ptr, count ) ( (count) <= FT_ARRAY_MAX( ptr ) )
nuclear@0 231
nuclear@0 232
nuclear@0 233 /*************************************************************************/
nuclear@0 234 /* */
nuclear@0 235 /* The following functions macros expect that their pointer argument is */
nuclear@0 236 /* _typed_ in order to automatically compute array element sizes. */
nuclear@0 237 /* */
nuclear@0 238
nuclear@0 239 #define FT_MEM_NEW_ARRAY( ptr, count ) \
nuclear@0 240 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, sizeof ( *(ptr) ), \
nuclear@0 241 0, (count), \
nuclear@0 242 NULL, &error ) )
nuclear@0 243
nuclear@0 244 #define FT_MEM_RENEW_ARRAY( ptr, cursz, newsz ) \
nuclear@0 245 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, sizeof ( *(ptr) ), \
nuclear@0 246 (cursz), (newsz), \
nuclear@0 247 (ptr), &error ) )
nuclear@0 248
nuclear@0 249 #define FT_MEM_QNEW_ARRAY( ptr, count ) \
nuclear@0 250 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, sizeof ( *(ptr) ), \
nuclear@0 251 0, (count), \
nuclear@0 252 NULL, &error ) )
nuclear@0 253
nuclear@0 254 #define FT_MEM_QRENEW_ARRAY( ptr, cursz, newsz ) \
nuclear@0 255 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, sizeof ( *(ptr) ), \
nuclear@0 256 (cursz), (newsz), \
nuclear@0 257 (ptr), &error ) )
nuclear@0 258
nuclear@0 259
nuclear@0 260 #define FT_ALLOC( ptr, size ) \
nuclear@0 261 FT_MEM_SET_ERROR( FT_MEM_ALLOC( ptr, size ) )
nuclear@0 262
nuclear@0 263 #define FT_REALLOC( ptr, cursz, newsz ) \
nuclear@0 264 FT_MEM_SET_ERROR( FT_MEM_REALLOC( ptr, cursz, newsz ) )
nuclear@0 265
nuclear@0 266 #define FT_ALLOC_MULT( ptr, count, item_size ) \
nuclear@0 267 FT_MEM_SET_ERROR( FT_MEM_ALLOC_MULT( ptr, count, item_size ) )
nuclear@0 268
nuclear@0 269 #define FT_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
nuclear@0 270 FT_MEM_SET_ERROR( FT_MEM_REALLOC_MULT( ptr, oldcnt, \
nuclear@0 271 newcnt, itmsz ) )
nuclear@0 272
nuclear@0 273 #define FT_QALLOC( ptr, size ) \
nuclear@0 274 FT_MEM_SET_ERROR( FT_MEM_QALLOC( ptr, size ) )
nuclear@0 275
nuclear@0 276 #define FT_QREALLOC( ptr, cursz, newsz ) \
nuclear@0 277 FT_MEM_SET_ERROR( FT_MEM_QREALLOC( ptr, cursz, newsz ) )
nuclear@0 278
nuclear@0 279 #define FT_QALLOC_MULT( ptr, count, item_size ) \
nuclear@0 280 FT_MEM_SET_ERROR( FT_MEM_QALLOC_MULT( ptr, count, item_size ) )
nuclear@0 281
nuclear@0 282 #define FT_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
nuclear@0 283 FT_MEM_SET_ERROR( FT_MEM_QREALLOC_MULT( ptr, oldcnt, \
nuclear@0 284 newcnt, itmsz ) )
nuclear@0 285
nuclear@0 286 #define FT_FREE( ptr ) FT_MEM_FREE( ptr )
nuclear@0 287
nuclear@0 288 #define FT_NEW( ptr ) FT_MEM_SET_ERROR( FT_MEM_NEW( ptr ) )
nuclear@0 289
nuclear@0 290 #define FT_NEW_ARRAY( ptr, count ) \
nuclear@0 291 FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
nuclear@0 292
nuclear@0 293 #define FT_RENEW_ARRAY( ptr, curcnt, newcnt ) \
nuclear@0 294 FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
nuclear@0 295
nuclear@0 296 #define FT_QNEW( ptr ) \
nuclear@0 297 FT_MEM_SET_ERROR( FT_MEM_QNEW( ptr ) )
nuclear@0 298
nuclear@0 299 #define FT_QNEW_ARRAY( ptr, count ) \
nuclear@0 300 FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
nuclear@0 301
nuclear@0 302 #define FT_QRENEW_ARRAY( ptr, curcnt, newcnt ) \
nuclear@0 303 FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
nuclear@0 304
nuclear@0 305
nuclear@0 306 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
nuclear@0 307
nuclear@0 308 FT_BASE( FT_Error )
nuclear@0 309 FT_Alloc( FT_Memory memory,
nuclear@0 310 FT_Long size,
nuclear@0 311 void* *P );
nuclear@0 312
nuclear@0 313 FT_BASE( FT_Error )
nuclear@0 314 FT_QAlloc( FT_Memory memory,
nuclear@0 315 FT_Long size,
nuclear@0 316 void* *p );
nuclear@0 317
nuclear@0 318 FT_BASE( FT_Error )
nuclear@0 319 FT_Realloc( FT_Memory memory,
nuclear@0 320 FT_Long current,
nuclear@0 321 FT_Long size,
nuclear@0 322 void* *P );
nuclear@0 323
nuclear@0 324 FT_BASE( FT_Error )
nuclear@0 325 FT_QRealloc( FT_Memory memory,
nuclear@0 326 FT_Long current,
nuclear@0 327 FT_Long size,
nuclear@0 328 void* *p );
nuclear@0 329
nuclear@0 330 FT_BASE( void )
nuclear@0 331 FT_Free( FT_Memory memory,
nuclear@0 332 void* *P );
nuclear@0 333
nuclear@0 334 #endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
nuclear@0 335
nuclear@0 336
nuclear@0 337 FT_BASE( FT_Pointer )
nuclear@0 338 ft_mem_strdup( FT_Memory memory,
nuclear@0 339 const char* str,
nuclear@0 340 FT_Error *p_error );
nuclear@0 341
nuclear@0 342 FT_BASE( FT_Pointer )
nuclear@0 343 ft_mem_dup( FT_Memory memory,
nuclear@0 344 const void* address,
nuclear@0 345 FT_ULong size,
nuclear@0 346 FT_Error *p_error );
nuclear@0 347
nuclear@0 348 #define FT_MEM_STRDUP( dst, str ) \
nuclear@0 349 (dst) = (char*)ft_mem_strdup( memory, (const char*)(str), &error )
nuclear@0 350
nuclear@0 351 #define FT_STRDUP( dst, str ) \
nuclear@0 352 FT_MEM_SET_ERROR( FT_MEM_STRDUP( dst, str ) )
nuclear@0 353
nuclear@0 354 #define FT_MEM_DUP( dst, address, size ) \
nuclear@0 355 (dst) = ft_mem_dup( memory, (address), (FT_ULong)(size), &error )
nuclear@0 356
nuclear@0 357 #define FT_DUP( dst, address, size ) \
nuclear@0 358 FT_MEM_SET_ERROR( FT_MEM_DUP( dst, address, size ) )
nuclear@0 359
nuclear@0 360
nuclear@0 361 /* Return >= 1 if a truncation occurs. */
nuclear@0 362 /* Return 0 if the source string fits the buffer. */
nuclear@0 363 /* This is *not* the same as strlcpy(). */
nuclear@0 364 FT_BASE( FT_Int )
nuclear@0 365 ft_mem_strcpyn( char* dst,
nuclear@0 366 const char* src,
nuclear@0 367 FT_ULong size );
nuclear@0 368
nuclear@0 369 #define FT_STRCPYN( dst, src, size ) \
nuclear@0 370 ft_mem_strcpyn( (char*)dst, (const char*)(src), (FT_ULong)(size) )
nuclear@0 371
nuclear@0 372 /* */
nuclear@0 373
nuclear@0 374
nuclear@0 375 FT_END_HEADER
nuclear@0 376
nuclear@0 377 #endif /* __FTMEMORY_H__ */
nuclear@0 378
nuclear@0 379
nuclear@0 380 /* END */