PageRenderTime 346ms CodeModel.GetById 181ms app.highlight 11ms RepoModel.GetById 150ms app.codeStats 0ms

/src/compiler/android-ndk/jni/freetype/include/freetype/internal/ftmemory.h

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