ReactOS 0.4.15-dev-5666-gc548b97
ftmemory.h
Go to the documentation of this file.
1/***************************************************************************/
2/* */
3/* ftmemory.h */
4/* */
5/* The FreeType memory management macros (specification). */
6/* */
7/* Copyright 1996-2018 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
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
68extern "C++"
69{
70 template <typename T> inline T*
71 cplusplus_typeof( T*,
72 void *v )
73 {
74 return static_cast <T*> ( v );
75 }
76}
77
78#define FT_ASSIGNP( p, val ) (p) = cplusplus_typeof( (p), (val) )
79
80#else
81
82#define FT_ASSIGNP( p, val ) (p) = (val)
83
84#endif
85
86
87
88#ifdef FT_DEBUG_MEMORY
89
90 FT_BASE( const char* ) _ft_debug_file;
91 FT_BASE( long ) _ft_debug_lineno;
92
93#define FT_DEBUG_INNER( exp ) ( _ft_debug_file = __FILE__, \
94 _ft_debug_lineno = __LINE__, \
95 (exp) )
96
97#define FT_ASSIGNP_INNER( p, exp ) ( _ft_debug_file = __FILE__, \
98 _ft_debug_lineno = __LINE__, \
99 FT_ASSIGNP( p, exp ) )
100
101#else /* !FT_DEBUG_MEMORY */
102
103#define FT_DEBUG_INNER( exp ) (exp)
104#define FT_ASSIGNP_INNER( p, exp ) FT_ASSIGNP( p, exp )
105
106#endif /* !FT_DEBUG_MEMORY */
107
108
109 /*
110 * The allocation functions return a pointer, and the error code
111 * is written to through the `p_error' parameter.
112 */
113
114 /* The `q' variants of the functions below (`q' for `quick') don't fill */
115 /* the allocated or reallocated memory with zero bytes. */
116
120 FT_Error *p_error );
121
125 FT_Error *p_error );
126
129 FT_Long item_size,
130 FT_Long cur_count,
131 FT_Long new_count,
132 void* block,
133 FT_Error *p_error );
134
137 FT_Long item_size,
138 FT_Long cur_count,
139 FT_Long new_count,
140 void* block,
141 FT_Error *p_error );
142
143 FT_BASE( void )
145 const void* P );
146
147
148 /* The `Q' variants of the macros below (`Q' for `quick') don't fill */
149 /* the allocated or reallocated memory with zero bytes. */
150
151#define FT_MEM_ALLOC( ptr, size ) \
152 FT_ASSIGNP_INNER( ptr, ft_mem_alloc( memory, \
153 (FT_Long)(size), \
154 &error ) )
155
156#define FT_MEM_FREE( ptr ) \
157 FT_BEGIN_STMNT \
158 ft_mem_free( memory, (ptr) ); \
159 (ptr) = NULL; \
160 FT_END_STMNT
161
162#define FT_MEM_NEW( ptr ) \
163 FT_MEM_ALLOC( ptr, sizeof ( *(ptr) ) )
164
165#define FT_MEM_REALLOC( ptr, cursz, newsz ) \
166 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \
167 1, \
168 (FT_Long)(cursz), \
169 (FT_Long)(newsz), \
170 (ptr), \
171 &error ) )
172
173#define FT_MEM_QALLOC( ptr, size ) \
174 FT_ASSIGNP_INNER( ptr, ft_mem_qalloc( memory, \
175 (FT_Long)(size), \
176 &error ) )
177
178#define FT_MEM_QNEW( ptr ) \
179 FT_MEM_QALLOC( ptr, sizeof ( *(ptr) ) )
180
181#define FT_MEM_QREALLOC( ptr, cursz, newsz ) \
182 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \
183 1, \
184 (FT_Long)(cursz), \
185 (FT_Long)(newsz), \
186 (ptr), \
187 &error ) )
188
189#define FT_MEM_ALLOC_MULT( ptr, count, item_size ) \
190 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \
191 (FT_Long)(item_size), \
192 0, \
193 (FT_Long)(count), \
194 NULL, \
195 &error ) )
196
197#define FT_MEM_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
198 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \
199 (FT_Long)(itmsz), \
200 (FT_Long)(oldcnt), \
201 (FT_Long)(newcnt), \
202 (ptr), \
203 &error ) )
204
205#define FT_MEM_QALLOC_MULT( ptr, count, item_size ) \
206 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \
207 (FT_Long)(item_size), \
208 0, \
209 (FT_Long)(count), \
210 NULL, \
211 &error ) )
212
213#define FT_MEM_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
214 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \
215 (FT_Long)(itmsz), \
216 (FT_Long)(oldcnt), \
217 (FT_Long)(newcnt), \
218 (ptr), \
219 &error ) )
220
221
222#define FT_MEM_SET_ERROR( cond ) ( (cond), error != 0 )
223
224
225#define FT_MEM_SET( dest, byte, count ) \
226 ft_memset( dest, byte, (FT_Offset)(count) )
227
228#define FT_MEM_COPY( dest, source, count ) \
229 ft_memcpy( dest, source, (FT_Offset)(count) )
230
231#define FT_MEM_MOVE( dest, source, count ) \
232 ft_memmove( dest, source, (FT_Offset)(count) )
233
234
235#define FT_MEM_ZERO( dest, count ) FT_MEM_SET( dest, 0, count )
236
237#define FT_ZERO( p ) FT_MEM_ZERO( p, sizeof ( *(p) ) )
238
239
240#define FT_ARRAY_ZERO( dest, count ) \
241 FT_MEM_ZERO( dest, \
242 (FT_Offset)(count) * sizeof ( *(dest) ) )
243
244#define FT_ARRAY_COPY( dest, source, count ) \
245 FT_MEM_COPY( dest, \
246 source, \
247 (FT_Offset)(count) * sizeof ( *(dest) ) )
248
249#define FT_ARRAY_MOVE( dest, source, count ) \
250 FT_MEM_MOVE( dest, \
251 source, \
252 (FT_Offset)(count) * sizeof ( *(dest) ) )
253
254
255 /*
256 * Return the maximum number of addressable elements in an array.
257 * We limit ourselves to INT_MAX, rather than UINT_MAX, to avoid
258 * any problems.
259 */
260#define FT_ARRAY_MAX( ptr ) ( FT_INT_MAX / sizeof ( *(ptr) ) )
261
262#define FT_ARRAY_CHECK( ptr, count ) ( (count) <= FT_ARRAY_MAX( ptr ) )
263
264
265 /*************************************************************************/
266 /* */
267 /* The following functions macros expect that their pointer argument is */
268 /* _typed_ in order to automatically compute array element sizes. */
269 /* */
270
271#define FT_MEM_NEW_ARRAY( ptr, count ) \
272 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \
273 sizeof ( *(ptr) ), \
274 0, \
275 (FT_Long)(count), \
276 NULL, \
277 &error ) )
278
279#define FT_MEM_RENEW_ARRAY( ptr, cursz, newsz ) \
280 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \
281 sizeof ( *(ptr) ), \
282 (FT_Long)(cursz), \
283 (FT_Long)(newsz), \
284 (ptr), \
285 &error ) )
286
287#define FT_MEM_QNEW_ARRAY( ptr, count ) \
288 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \
289 sizeof ( *(ptr) ), \
290 0, \
291 (FT_Long)(count), \
292 NULL, \
293 &error ) )
294
295#define FT_MEM_QRENEW_ARRAY( ptr, cursz, newsz ) \
296 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \
297 sizeof ( *(ptr) ), \
298 (FT_Long)(cursz), \
299 (FT_Long)(newsz), \
300 (ptr), \
301 &error ) )
302
303#define FT_ALLOC( ptr, size ) \
304 FT_MEM_SET_ERROR( FT_MEM_ALLOC( ptr, size ) )
305
306#define FT_REALLOC( ptr, cursz, newsz ) \
307 FT_MEM_SET_ERROR( FT_MEM_REALLOC( ptr, cursz, newsz ) )
308
309#define FT_ALLOC_MULT( ptr, count, item_size ) \
310 FT_MEM_SET_ERROR( FT_MEM_ALLOC_MULT( ptr, count, item_size ) )
311
312#define FT_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
313 FT_MEM_SET_ERROR( FT_MEM_REALLOC_MULT( ptr, oldcnt, \
314 newcnt, itmsz ) )
315
316#define FT_QALLOC( ptr, size ) \
317 FT_MEM_SET_ERROR( FT_MEM_QALLOC( ptr, size ) )
318
319#define FT_QREALLOC( ptr, cursz, newsz ) \
320 FT_MEM_SET_ERROR( FT_MEM_QREALLOC( ptr, cursz, newsz ) )
321
322#define FT_QALLOC_MULT( ptr, count, item_size ) \
323 FT_MEM_SET_ERROR( FT_MEM_QALLOC_MULT( ptr, count, item_size ) )
324
325#define FT_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
326 FT_MEM_SET_ERROR( FT_MEM_QREALLOC_MULT( ptr, oldcnt, \
327 newcnt, itmsz ) )
328
329#define FT_FREE( ptr ) FT_MEM_FREE( ptr )
330
331#define FT_NEW( ptr ) FT_MEM_SET_ERROR( FT_MEM_NEW( ptr ) )
332
333#define FT_NEW_ARRAY( ptr, count ) \
334 FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
335
336#define FT_RENEW_ARRAY( ptr, curcnt, newcnt ) \
337 FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
338
339#define FT_QNEW( ptr ) \
340 FT_MEM_SET_ERROR( FT_MEM_QNEW( ptr ) )
341
342#define FT_QNEW_ARRAY( ptr, count ) \
343 FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
344
345#define FT_QRENEW_ARRAY( ptr, curcnt, newcnt ) \
346 FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
347
348
351 const char* str,
352 FT_Error *p_error );
353
356 const void* address,
358 FT_Error *p_error );
359
360
361#define FT_MEM_STRDUP( dst, str ) \
362 (dst) = (char*)ft_mem_strdup( memory, (const char*)(str), &error )
363
364#define FT_STRDUP( dst, str ) \
365 FT_MEM_SET_ERROR( FT_MEM_STRDUP( dst, str ) )
366
367#define FT_MEM_DUP( dst, address, size ) \
368 (dst) = ft_mem_dup( memory, (address), (FT_ULong)(size), &error )
369
370#define FT_DUP( dst, address, size ) \
371 FT_MEM_SET_ERROR( FT_MEM_DUP( dst, address, size ) )
372
373
374 /* Return >= 1 if a truncation occurs. */
375 /* Return 0 if the source string fits the buffer. */
376 /* This is *not* the same as strlcpy(). */
377 FT_BASE( FT_Int )
378 ft_mem_strcpyn( char* dst,
379 const char* src,
380 FT_ULong size );
381
382#define FT_STRCPYN( dst, src, size ) \
383 ft_mem_strcpyn( (char*)dst, (const char*)(src), (FT_ULong)(size) )
384
385 /* */
386
387
389
390#endif /* FTMEMORY_H_ */
391
392
393/* END */
#define P(row, col)
#define FT_BASE(x)
Definition: ftconfig.h:408
#define FT_END_HEADER
Definition: ftheader.h:54
#define FT_BEGIN_HEADER
Definition: ftheader.h:36
ft_mem_qalloc(FT_Memory memory, FT_Long size, FT_Error *p_error)
Definition: ftutil.c:66
ft_mem_dup(FT_Memory memory, const void *address, FT_ULong size, FT_Error *p_error)
Definition: ftutil.c:179
ft_mem_strdup(FT_Memory memory, const char *str, FT_Error *p_error)
Definition: ftutil.c:197
ft_mem_alloc(FT_Memory memory, FT_Long size, FT_Error *p_error)
Definition: ftutil.c:50
ft_mem_free(FT_Memory memory, const void *P)
Definition: ftutil.c:170
ft_mem_strcpyn(char *dst, const char *src, FT_ULong size)
Definition: ftutil.c:210
ft_mem_realloc(FT_Memory memory, FT_Long item_size, FT_Long cur_count, FT_Long new_count, void *block, FT_Error *p_error)
Definition: ftutil.c:92
ft_mem_qrealloc(FT_Memory memory, FT_Long item_size, FT_Long cur_count, FT_Long new_count, void *block, FT_Error *p_error)
Definition: ftutil.c:114
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
unsigned long FT_ULong
Definition: fttypes.h:253
int FT_Error
Definition: fttypes.h:300
signed long FT_Long
Definition: fttypes.h:242
signed int FT_Int
Definition: fttypes.h:220
const GLdouble * v
Definition: gl.h:2040
GLsizeiptr size
Definition: glext.h:5919
GLuint address
Definition: glext.h:9393
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
#define T
Definition: mbstring.h:31
static char memory[1024 *256]
Definition: process.c:116
const WCHAR * str
static unsigned int block
Definition: xmlmemory.c:101