source: trunk/poppler/freetype2/include/freetype/internal/ftmemory.h @ 200

Last change on this file since 200 was 200, checked in by Eugene Romanenko, 15 years ago

PDF plugin: update freetype to 2.3.1 release

File size: 13.4 KB
Line 
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 /* */
326
327
328FT_END_HEADER
329
330#endif /* __FTMEMORY_H__ */
331
332
333/* END */
Note: See TracBrowser for help on using the repository browser.