← Back to branch summary

~ubuntu-branches/ubuntu/wily/hedgewars/wily

« back to all changes in this revision

Viewing changes to misc/libfreetype/include/freetype/internal/ftmemory.h

  • Committer: Package Import Robot
  • Author(s): Dmitry E. Oboukhov
  • Date: 2011-09-23 10:16:55 UTC
  • mfrom: (1.2.11 upstream)
  • Revision ID: package-import@ubuntu.com-20110923101655-3977th2gc5n0a3pv
Tags: 0.9.16-1
* New upstream version.
 + Downloadable content! Simply click to install any content.
   New voices, hats, maps, themes, translations, music, scripts...
   Hedgewars is now more customisable than ever before! As time goes
   by we will be soliciting community content to feature on this page,
   so remember to check it from time to time. If you decide you want
   to go back to standard Hedgewars, just remove the Data directory
   from your Hedgewars config directory.
 + 3-D rendering! Diorama-like rendering of the game in a variety
   of 3D modes. Let us know which ones work best for you, we didn't
   really have the equipment to test them all.
 + Resizable game window.
 + New utilities! The Time Box will remove one of your hedgehogs
   from the game for a while, protecting from attack until it returns,
   somewhere else on the map. Land spray will allow you to build bridges,
   seal up holes, or just make life unpleasant for your enemies.
 + New single player: Bamboo Thicket, That Sinking Feeling, Newton and
   the Tree and multi-player: The Specialists, Space Invaders,
   Racer - scripts! And a ton more script hooks for scripters
 + New twists on old weapons. Drill strike, seduction and fire have
   been adjusted. Defective mines have been added, rope can attach to
   hogs/crates/barrels again, grenades now have variable bounce (use
   precise key + 1-5). Portal gun is now more usable in flight and
   all game actions are a lot faster.
 + New theme - Golf, dozens of new community hats and a new
   localised Default voice, Ukranian.

Show diffs side-by-side

added added

removed removed

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