source: trunk/poppler/freetype-2.1.10/src/base/ftutil.c @ 2

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

First import

File size: 10.1 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  ftutil.c                                                               */
4/*                                                                         */
5/*    FreeType utility file for memory and list management (body).         */
6/*                                                                         */
7/*  Copyright 2002, 2004, 2005 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#include <ft2build.h>
20#include FT_INTERNAL_DEBUG_H
21#include FT_INTERNAL_MEMORY_H
22#include FT_INTERNAL_OBJECTS_H
23#include FT_LIST_H
24
25
26  /*************************************************************************/
27  /*                                                                       */
28  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
29  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
30  /* messages during execution.                                            */
31  /*                                                                       */
32#undef  FT_COMPONENT
33#define FT_COMPONENT  trace_memory
34
35
36  /*************************************************************************/
37  /*************************************************************************/
38  /*************************************************************************/
39  /*****                                                               *****/
40  /*****                                                               *****/
41  /*****               M E M O R Y   M A N A G E M E N T               *****/
42  /*****                                                               *****/
43  /*****                                                               *****/
44  /*************************************************************************/
45  /*************************************************************************/
46  /*************************************************************************/
47
48  /* documentation is in ftmemory.h */
49
50  FT_BASE_DEF( FT_Error )
51  FT_Alloc( FT_Memory  memory,
52            FT_Long    size,
53            void*     *P )
54  {
55    FT_ASSERT( P != 0 );
56
57    if ( size > 0 )
58    {
59      *P = memory->alloc( memory, size );
60      if ( !*P )
61      {
62        FT_ERROR(( "FT_Alloc:" ));
63        FT_ERROR(( " Out of memory? (%ld requested)\n",
64                   size ));
65
66        return FT_Err_Out_Of_Memory;
67      }
68      FT_MEM_ZERO( *P, size );
69    }
70    else
71      *P = NULL;
72
73    FT_TRACE7(( "FT_Alloc:" ));
74    FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
75                size, *P, P ));
76
77    return FT_Err_Ok;
78  }
79
80
81  /* documentation is in ftmemory.h */
82
83  FT_BASE_DEF( FT_Error )
84  FT_QAlloc( FT_Memory  memory,
85             FT_Long    size,
86             void*     *P )
87  {
88    FT_ASSERT( P != 0 );
89
90    if ( size > 0 )
91    {
92      *P = memory->alloc( memory, size );
93      if ( !*P )
94      {
95        FT_ERROR(( "FT_QAlloc:" ));
96        FT_ERROR(( " Out of memory? (%ld requested)\n",
97                   size ));
98
99        return FT_Err_Out_Of_Memory;
100      }
101    }
102    else
103      *P = NULL;
104
105    FT_TRACE7(( "FT_QAlloc:" ));
106    FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
107                size, *P, P ));
108
109    return FT_Err_Ok;
110  }
111
112
113  /* documentation is in ftmemory.h */
114
115  FT_BASE_DEF( FT_Error )
116  FT_Realloc( FT_Memory  memory,
117              FT_Long    current,
118              FT_Long    size,
119              void**     P )
120  {
121    void*  Q;
122
123
124    FT_ASSERT( P != 0 );
125
126    /* if the original pointer is NULL, call FT_Alloc() */
127    if ( !*P )
128      return FT_Alloc( memory, size, P );
129
130    /* if the new block if zero-sized, clear the current one */
131    if ( size <= 0 )
132    {
133      FT_Free( memory, P );
134      return FT_Err_Ok;
135    }
136
137    Q = memory->realloc( memory, current, size, *P );
138    if ( !Q )
139      goto Fail;
140
141    if ( size > current )
142      FT_MEM_ZERO( (char*)Q + current, size - current );
143
144    *P = Q;
145    return FT_Err_Ok;
146
147  Fail:
148    FT_ERROR(( "FT_Realloc:" ));
149    FT_ERROR(( " Failed (current %ld, requested %ld)\n",
150               current, size ));
151    return FT_Err_Out_Of_Memory;
152  }
153
154
155  /* documentation is in ftmemory.h */
156
157  FT_BASE_DEF( FT_Error )
158  FT_QRealloc( FT_Memory  memory,
159               FT_Long    current,
160               FT_Long    size,
161               void**     P )
162  {
163    void*  Q;
164
165
166    FT_ASSERT( P != 0 );
167
168    /* if the original pointer is NULL, call FT_QAlloc() */
169    if ( !*P )
170      return FT_QAlloc( memory, size, P );
171
172    /* if the new block if zero-sized, clear the current one */
173    if ( size <= 0 )
174    {
175      FT_Free( memory, P );
176      return FT_Err_Ok;
177    }
178
179    Q = memory->realloc( memory, current, size, *P );
180    if ( !Q )
181      goto Fail;
182
183    *P = Q;
184    return FT_Err_Ok;
185
186  Fail:
187    FT_ERROR(( "FT_QRealloc:" ));
188    FT_ERROR(( " Failed (current %ld, requested %ld)\n",
189               current, size ));
190    return FT_Err_Out_Of_Memory;
191  }
192
193
194  /* documentation is in ftmemory.h */
195
196  FT_BASE_DEF( void )
197  FT_Free( FT_Memory  memory,
198           void**     P )
199  {
200    FT_TRACE7(( "FT_Free:" ));
201    FT_TRACE7(( " Freeing block 0x%08p, ref 0x%08p\n",
202                P, P ? *P : (void*)0 ));
203
204    if ( P && *P )
205    {
206      memory->free( memory, *P );
207      *P = 0;
208    }
209  }
210
211
212  /*************************************************************************/
213  /*************************************************************************/
214  /*************************************************************************/
215  /*****                                                               *****/
216  /*****                                                               *****/
217  /*****            D O U B L Y   L I N K E D   L I S T S              *****/
218  /*****                                                               *****/
219  /*****                                                               *****/
220  /*************************************************************************/
221  /*************************************************************************/
222  /*************************************************************************/
223
224#undef  FT_COMPONENT
225#define FT_COMPONENT  trace_list
226
227  /* documentation is in ftlist.h */
228
229  FT_EXPORT_DEF( FT_ListNode )
230  FT_List_Find( FT_List  list,
231                void*    data )
232  {
233    FT_ListNode  cur;
234
235
236    cur = list->head;
237    while ( cur )
238    {
239      if ( cur->data == data )
240        return cur;
241
242      cur = cur->next;
243    }
244
245    return (FT_ListNode)0;
246  }
247
248
249  /* documentation is in ftlist.h */
250
251  FT_EXPORT_DEF( void )
252  FT_List_Add( FT_List      list,
253               FT_ListNode  node )
254  {
255    FT_ListNode  before = list->tail;
256
257
258    node->next = 0;
259    node->prev = before;
260
261    if ( before )
262      before->next = node;
263    else
264      list->head = node;
265
266    list->tail = node;
267  }
268
269
270  /* documentation is in ftlist.h */
271
272  FT_EXPORT_DEF( void )
273  FT_List_Insert( FT_List      list,
274                  FT_ListNode  node )
275  {
276    FT_ListNode  after = list->head;
277
278
279    node->next = after;
280    node->prev = 0;
281
282    if ( !after )
283      list->tail = node;
284    else
285      after->prev = node;
286
287    list->head = node;
288  }
289
290
291  /* documentation is in ftlist.h */
292
293  FT_EXPORT_DEF( void )
294  FT_List_Remove( FT_List      list,
295                  FT_ListNode  node )
296  {
297    FT_ListNode  before, after;
298
299
300    before = node->prev;
301    after  = node->next;
302
303    if ( before )
304      before->next = after;
305    else
306      list->head = after;
307
308    if ( after )
309      after->prev = before;
310    else
311      list->tail = before;
312  }
313
314
315  /* documentation is in ftlist.h */
316
317  FT_EXPORT_DEF( void )
318  FT_List_Up( FT_List      list,
319              FT_ListNode  node )
320  {
321    FT_ListNode  before, after;
322
323
324    before = node->prev;
325    after  = node->next;
326
327    /* check whether we are already on top of the list */
328    if ( !before )
329      return;
330
331    before->next = after;
332
333    if ( after )
334      after->prev = before;
335    else
336      list->tail = before;
337
338    node->prev       = 0;
339    node->next       = list->head;
340    list->head->prev = node;
341    list->head       = node;
342  }
343
344
345  /* documentation is in ftlist.h */
346
347  FT_EXPORT_DEF( FT_Error )
348  FT_List_Iterate( FT_List            list,
349                   FT_List_Iterator   iterator,
350                   void*              user )
351  {
352    FT_ListNode  cur   = list->head;
353    FT_Error     error = FT_Err_Ok;
354
355
356    while ( cur )
357    {
358      FT_ListNode  next = cur->next;
359
360
361      error = iterator( cur, user );
362      if ( error )
363        break;
364
365      cur = next;
366    }
367
368    return error;
369  }
370
371
372  /* documentation is in ftlist.h */
373
374  FT_EXPORT_DEF( void )
375  FT_List_Finalize( FT_List             list,
376                    FT_List_Destructor  destroy,
377                    FT_Memory           memory,
378                    void*               user )
379  {
380    FT_ListNode  cur;
381
382
383    cur = list->head;
384    while ( cur )
385    {
386      FT_ListNode  next = cur->next;
387      void*        data = cur->data;
388
389
390      if ( destroy )
391        destroy( memory, data, user );
392
393      FT_FREE( cur );
394      cur = next;
395    }
396
397    list->head = 0;
398    list->tail = 0;
399  }
400
401
402  FT_BASE( FT_UInt32 )
403  ft_highpow2( FT_UInt32  value )
404  {
405    FT_UInt32  value2;
406
407
408    /*
409     *  We simply clear the lowest bit in each iteration.  When
410     *  we reach 0, we know that the previous value was our result.
411     */
412    for ( ;; )
413    {
414      value2 = value & (value - 1);  /* clear lowest bit */
415      if ( value2 == 0 )
416        break;
417
418      value = value2;
419    }
420    return value;
421  }
422
423
424/* END */
Note: See TracBrowser for help on using the repository browser.