XFA: merge patch from CL 815103002
[pdfium.git] / third_party / freetype / include / internal / ftmemory.h
1 /***************************************************************************/
2 /*                                                                         */
3 /*  ftmemory.h                                                             */
4 /*                                                                         */
5 /*    The FreeType memory management macros (specification).               */
6 /*                                                                         */
7 /*  Copyright 1996-2002, 2004-2007, 2010, 2013 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,          \
146                                                (FT_Long)(size), \
147                                                &error ) )
148
149 #define FT_MEM_FREE( ptr )                \
150           FT_BEGIN_STMNT                  \
151             ft_mem_free( memory, (ptr) ); \
152             (ptr) = NULL;                 \
153           FT_END_STMNT
154
155 #define FT_MEM_NEW( ptr )                        \
156           FT_MEM_ALLOC( ptr, sizeof ( *(ptr) ) )
157
158 #define FT_MEM_REALLOC( ptr, cursz, newsz )                        \
159           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,           \
160                                                  1,                \
161                                                  (FT_Long)(cursz), \
162                                                  (FT_Long)(newsz), \
163                                                  (ptr),            \
164                                                  &error ) )
165
166 #define FT_MEM_QALLOC( ptr, size )                               \
167           FT_ASSIGNP_INNER( ptr, ft_mem_qalloc( memory,          \
168                                                 (FT_Long)(size), \
169                                                 &error ) )
170
171 #define FT_MEM_QNEW( ptr )                        \
172           FT_MEM_QALLOC( ptr, sizeof ( *(ptr) ) )
173
174 #define FT_MEM_QREALLOC( ptr, cursz, newsz )                        \
175           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,           \
176                                                   1,                \
177                                                   (FT_Long)(cursz), \
178                                                   (FT_Long)(newsz), \
179                                                   (ptr),            \
180                                                   &error ) )
181
182 #define FT_MEM_ALLOC_MULT( ptr, count, item_size )                     \
183           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,               \
184                                                  (FT_Long)(item_size), \
185                                                  0,                    \
186                                                  (FT_Long)(count),     \
187                                                  NULL,                 \
188                                                  &error ) )
189
190 #define FT_MEM_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz )           \
191           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
192                                                  (FT_Long)(itmsz),  \
193                                                  (FT_Long)(oldcnt), \
194                                                  (FT_Long)(newcnt), \
195                                                  (ptr),             \
196                                                  &error ) )
197
198 #define FT_MEM_QALLOC_MULT( ptr, count, item_size )                     \
199           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,               \
200                                                   (FT_Long)(item_size), \
201                                                   0,                    \
202                                                   (FT_Long)(count),     \
203                                                   NULL,                 \
204                                                   &error ) )
205
206 #define FT_MEM_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz)            \
207           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
208                                                   (FT_Long)(itmsz),  \
209                                                   (FT_Long)(oldcnt), \
210                                                   (FT_Long)(newcnt), \
211                                                   (ptr),             \
212                                                   &error ) )
213
214
215 #define FT_MEM_SET_ERROR( cond )  ( (cond), error != 0 )
216
217
218 #define FT_MEM_SET( dest, byte, count )     ft_memset( dest, byte, count )
219
220 #define FT_MEM_COPY( dest, source, count )  ft_memcpy( dest, source, count )
221
222 #define FT_MEM_MOVE( dest, source, count )  ft_memmove( dest, source, count )
223
224
225 #define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
226
227 #define FT_ZERO( p )                FT_MEM_ZERO( p, sizeof ( *(p) ) )
228
229
230 #define FT_ARRAY_ZERO( dest, count )                        \
231           FT_MEM_ZERO( dest, (count) * sizeof ( *(dest) ) )
232
233 #define FT_ARRAY_COPY( dest, source, count )                        \
234           FT_MEM_COPY( dest, source, (count) * sizeof ( *(dest) ) )
235
236 #define FT_ARRAY_MOVE( dest, source, count )                        \
237           FT_MEM_MOVE( dest, source, (count) * sizeof ( *(dest) ) )
238
239
240   /*
241    *  Return the maximum number of addressable elements in an array.
242    *  We limit ourselves to INT_MAX, rather than UINT_MAX, to avoid
243    *  any problems.
244    */
245 #define FT_ARRAY_MAX( ptr )           ( FT_INT_MAX / sizeof ( *(ptr) ) )
246
247 #define FT_ARRAY_CHECK( ptr, count )  ( (count) <= FT_ARRAY_MAX( ptr ) )
248
249
250   /*************************************************************************/
251   /*                                                                       */
252   /* The following functions macros expect that their pointer argument is  */
253   /* _typed_ in order to automatically compute array element sizes.        */
254   /*                                                                       */
255
256 #define FT_MEM_NEW_ARRAY( ptr, count )                              \
257           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
258                                                  sizeof ( *(ptr) ), \
259                                                  0,                 \
260                                                  (FT_Long)(count),  \
261                                                  NULL,              \
262                                                  &error ) )
263
264 #define FT_MEM_RENEW_ARRAY( ptr, cursz, newsz )                     \
265           FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory,            \
266                                                  sizeof ( *(ptr) ), \
267                                                  (FT_Long)(cursz),  \
268                                                  (FT_Long)(newsz),  \
269                                                  (ptr),             \
270                                                  &error ) )
271
272 #define FT_MEM_QNEW_ARRAY( ptr, count )                              \
273           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
274                                                   sizeof ( *(ptr) ), \
275                                                   0,                 \
276                                                   (FT_Long)(count),  \
277                                                   NULL,              \
278                                                   &error ) )
279
280 #define FT_MEM_QRENEW_ARRAY( ptr, cursz, newsz )                     \
281           FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory,            \
282                                                   sizeof ( *(ptr) ), \
283                                                   (FT_Long)(cursz),  \
284                                                   (FT_Long)(newsz),  \
285                                                   (ptr),             \
286                                                   &error ) )
287
288 #define FT_ALLOC( ptr, size )                           \
289           FT_MEM_SET_ERROR( FT_MEM_ALLOC( ptr, size ) )
290
291 #define FT_REALLOC( ptr, cursz, newsz )                           \
292           FT_MEM_SET_ERROR( FT_MEM_REALLOC( ptr, cursz, newsz ) )
293
294 #define FT_ALLOC_MULT( ptr, count, item_size )                           \
295           FT_MEM_SET_ERROR( FT_MEM_ALLOC_MULT( ptr, count, item_size ) )
296
297 #define FT_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz )              \
298           FT_MEM_SET_ERROR( FT_MEM_REALLOC_MULT( ptr, oldcnt,      \
299                                                  newcnt, itmsz ) )
300
301 #define FT_QALLOC( ptr, size )                           \
302           FT_MEM_SET_ERROR( FT_MEM_QALLOC( ptr, size ) )
303
304 #define FT_QREALLOC( ptr, cursz, newsz )                           \
305           FT_MEM_SET_ERROR( FT_MEM_QREALLOC( ptr, cursz, newsz ) )
306
307 #define FT_QALLOC_MULT( ptr, count, item_size )                           \
308           FT_MEM_SET_ERROR( FT_MEM_QALLOC_MULT( ptr, count, item_size ) )
309
310 #define FT_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz )              \
311           FT_MEM_SET_ERROR( FT_MEM_QREALLOC_MULT( ptr, oldcnt,      \
312                                                   newcnt, itmsz ) )
313
314 #define FT_FREE( ptr )  FT_MEM_FREE( ptr )
315
316 #define FT_NEW( ptr )  FT_MEM_SET_ERROR( FT_MEM_NEW( ptr ) )
317
318 #define FT_NEW_ARRAY( ptr, count )                           \
319           FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
320
321 #define FT_RENEW_ARRAY( ptr, curcnt, newcnt )                           \
322           FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
323
324 #define FT_QNEW( ptr )                           \
325           FT_MEM_SET_ERROR( FT_MEM_QNEW( ptr ) )
326
327 #define FT_QNEW_ARRAY( ptr, count )                          \
328           FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
329
330 #define FT_QRENEW_ARRAY( ptr, curcnt, newcnt )                          \
331           FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
332
333
334   FT_BASE( FT_Pointer )
335   ft_mem_strdup( FT_Memory    memory,
336                  const char*  str,
337                  FT_Error    *p_error );
338
339   FT_BASE( FT_Pointer )
340   ft_mem_dup( FT_Memory    memory,
341               const void*  address,
342               FT_ULong     size,
343               FT_Error    *p_error );
344
345
346 #define FT_MEM_STRDUP( dst, str )                                            \
347           (dst) = (char*)ft_mem_strdup( memory, (const char*)(str), &error )
348
349 #define FT_STRDUP( dst, str )                           \
350           FT_MEM_SET_ERROR( FT_MEM_STRDUP( dst, str ) )
351
352 #define FT_MEM_DUP( dst, address, size )                                    \
353           (dst) = ft_mem_dup( memory, (address), (FT_ULong)(size), &error )
354
355 #define FT_DUP( dst, address, size )                           \
356           FT_MEM_SET_ERROR( FT_MEM_DUP( dst, address, size ) )
357
358
359   /* Return >= 1 if a truncation occurs.            */
360   /* Return 0 if the source string fits the buffer. */
361   /* This is *not* the same as strlcpy().           */
362   FT_BASE( FT_Int )
363   ft_mem_strcpyn( char*        dst,
364                   const char*  src,
365                   FT_ULong     size );
366
367 #define FT_STRCPYN( dst, src, size )                                         \
368           ft_mem_strcpyn( (char*)dst, (const char*)(src), (FT_ULong)(size) )
369
370  /* */
371
372
373 FT_END_HEADER
374
375 #endif /* __FTMEMORY_H__ */
376
377
378 /* END */