src/third_party/freetype2/src/include/freetype/internal/ftmemory.h

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