ReactOS 0.4.16-dev-1146-gc477928
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 (C) 1996-2019 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, with `p' a
62 * typed pointer. Since we don't have a `typeof' operator in standard C++,
63 * 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 is written
111 * 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
117 FT_BASE( FT_Pointer )
118 ft_mem_alloc( FT_Memory memory,
119 FT_Long size,
120 FT_Error *p_error );
121
122 FT_BASE( FT_Pointer )
123 ft_mem_qalloc( FT_Memory memory,
124 FT_Long size,
125 FT_Error *p_error );
126
127 FT_BASE( FT_Pointer )
128 ft_mem_realloc( FT_Memory memory,
129 FT_Long item_size,
130 FT_Long cur_count,
131 FT_Long new_count,
132 void* block,
133 FT_Error *p_error );
134
135 FT_BASE( FT_Pointer )
136 ft_mem_qrealloc( FT_Memory memory,
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 )
144 ft_mem_free( FT_Memory memory,
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. We limit
257 * ourselves to INT_MAX, rather than UINT_MAX, to avoid any problems.
258 */
259#define FT_ARRAY_MAX( ptr ) ( FT_INT_MAX / sizeof ( *(ptr) ) )
260
261#define FT_ARRAY_CHECK( ptr, count ) ( (count) <= FT_ARRAY_MAX( ptr ) )
262
263
264 /**************************************************************************
265 *
266 * The following functions macros expect that their pointer argument is
267 * _typed_ in order to automatically compute array element sizes.
268 */
269
270#define FT_MEM_NEW_ARRAY( ptr, count ) \
271 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \
272 sizeof ( *(ptr) ), \
273 0, \
274 (FT_Long)(count), \
275 NULL, \
276 &error ) )
277
278#define FT_MEM_RENEW_ARRAY( ptr, cursz, newsz ) \
279 FT_ASSIGNP_INNER( ptr, ft_mem_realloc( memory, \
280 sizeof ( *(ptr) ), \
281 (FT_Long)(cursz), \
282 (FT_Long)(newsz), \
283 (ptr), \
284 &error ) )
285
286#define FT_MEM_QNEW_ARRAY( ptr, count ) \
287 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \
288 sizeof ( *(ptr) ), \
289 0, \
290 (FT_Long)(count), \
291 NULL, \
292 &error ) )
293
294#define FT_MEM_QRENEW_ARRAY( ptr, cursz, newsz ) \
295 FT_ASSIGNP_INNER( ptr, ft_mem_qrealloc( memory, \
296 sizeof ( *(ptr) ), \
297 (FT_Long)(cursz), \
298 (FT_Long)(newsz), \
299 (ptr), \
300 &error ) )
301
302#define FT_ALLOC( ptr, size ) \
303 FT_MEM_SET_ERROR( FT_MEM_ALLOC( ptr, size ) )
304
305#define FT_REALLOC( ptr, cursz, newsz ) \
306 FT_MEM_SET_ERROR( FT_MEM_REALLOC( ptr, cursz, newsz ) )
307
308#define FT_ALLOC_MULT( ptr, count, item_size ) \
309 FT_MEM_SET_ERROR( FT_MEM_ALLOC_MULT( ptr, count, item_size ) )
310
311#define FT_REALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
312 FT_MEM_SET_ERROR( FT_MEM_REALLOC_MULT( ptr, oldcnt, \
313 newcnt, itmsz ) )
314
315#define FT_QALLOC( ptr, size ) \
316 FT_MEM_SET_ERROR( FT_MEM_QALLOC( ptr, size ) )
317
318#define FT_QREALLOC( ptr, cursz, newsz ) \
319 FT_MEM_SET_ERROR( FT_MEM_QREALLOC( ptr, cursz, newsz ) )
320
321#define FT_QALLOC_MULT( ptr, count, item_size ) \
322 FT_MEM_SET_ERROR( FT_MEM_QALLOC_MULT( ptr, count, item_size ) )
323
324#define FT_QREALLOC_MULT( ptr, oldcnt, newcnt, itmsz ) \
325 FT_MEM_SET_ERROR( FT_MEM_QREALLOC_MULT( ptr, oldcnt, \
326 newcnt, itmsz ) )
327
328#define FT_FREE( ptr ) FT_MEM_FREE( ptr )
329
330#define FT_NEW( ptr ) FT_MEM_SET_ERROR( FT_MEM_NEW( ptr ) )
331
332#define FT_NEW_ARRAY( ptr, count ) \
333 FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
334
335#define FT_RENEW_ARRAY( ptr, curcnt, newcnt ) \
336 FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
337
338#define FT_QNEW( ptr ) \
339 FT_MEM_SET_ERROR( FT_MEM_QNEW( ptr ) )
340
341#define FT_QNEW_ARRAY( ptr, count ) \
342 FT_MEM_SET_ERROR( FT_MEM_NEW_ARRAY( ptr, count ) )
343
344#define FT_QRENEW_ARRAY( ptr, curcnt, newcnt ) \
345 FT_MEM_SET_ERROR( FT_MEM_RENEW_ARRAY( ptr, curcnt, newcnt ) )
346
347
348 FT_BASE( FT_Pointer )
349 ft_mem_strdup( FT_Memory memory,
350 const char* str,
351 FT_Error *p_error );
352
353 FT_BASE( FT_Pointer )
354 ft_mem_dup( FT_Memory memory,
355 const void* address,
356 FT_ULong size,
357 FT_Error *p_error );
358
359
360#define FT_MEM_STRDUP( dst, str ) \
361 (dst) = (char*)ft_mem_strdup( memory, (const char*)(str), &error )
362
363#define FT_STRDUP( dst, str ) \
364 FT_MEM_SET_ERROR( FT_MEM_STRDUP( dst, str ) )
365
366#define FT_MEM_DUP( dst, address, size ) \
367 (dst) = ft_mem_dup( memory, (address), (FT_ULong)(size), &error )
368
369#define FT_DUP( dst, address, size ) \
370 FT_MEM_SET_ERROR( FT_MEM_DUP( dst, address, size ) )
371
372
373 /* Return >= 1 if a truncation occurs. */
374 /* Return 0 if the source string fits the buffer. */
375 /* This is *not* the same as strlcpy(). */
376 FT_BASE( FT_Int )
377 ft_mem_strcpyn( char* dst,
378 const char* src,
379 FT_ULong size );
380
381#define FT_STRCPYN( dst, src, size ) \
382 ft_mem_strcpyn( (char*)dst, (const char*)(src), (FT_ULong)(size) )
383
384 /* */
385
386
387FT_END_HEADER
388
389#endif /* FTMEMORY_H_ */
390
391
392/* END */
P
#define P(row, col)
FT_BASE
#define FT_BASE(x)
Definition: ftconfig.h:407
FT_END_HEADER
#define FT_END_HEADER
Definition: ftheader.h:54
FT_BEGIN_HEADER
#define FT_BEGIN_HEADER
Definition: ftheader.h:36
ft_mem_qalloc
ft_mem_qalloc(FT_Memory memory, FT_Long size, FT_Error *p_error)
Definition: ftutil.c:66
ft_mem_dup
ft_mem_dup(FT_Memory memory, const void *address, FT_ULong size, FT_Error *p_error)
Definition: ftutil.c:179
ft_mem_strdup
ft_mem_strdup(FT_Memory memory, const char *str, FT_Error *p_error)
Definition: ftutil.c:197
ft_mem_alloc
ft_mem_alloc(FT_Memory memory, FT_Long size, FT_Error *p_error)
Definition: ftutil.c:50
ft_mem_free
ft_mem_free(FT_Memory memory, const void *P)
Definition: ftutil.c:170
ft_mem_strcpyn
ft_mem_strcpyn(char *dst, const char *src, FT_ULong size)
Definition: ftutil.c:210
ft_mem_realloc
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_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
FT_Memory
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:65
FT_ULong
unsigned long FT_ULong
Definition: fttypes.h:253
FT_Error
int FT_Error
Definition: fttypes.h:299
FT_Long
signed long FT_Long
Definition: fttypes.h:242
FT_Int
signed int FT_Int
Definition: fttypes.h:220
v
const GLdouble * v
Definition: gl.h:2040
address
GLuint address
Definition: glext.h:9393
src
GLenum src
Definition: glext.h:6340
size
GLsizeiptr size
Definition: glext.h:5919
dst
GLenum GLenum dst
Definition: glext.h:6340
T
#define T
Definition: mbstring.h:31
memory
static char memory[1024 *256]
Definition: process.c:116
str
const WCHAR * str
Definition: rpc_transport.c:2724
block
static unsigned int block
Definition: xmlmemory.c:101