modules/freetype2/src/cache/ftcmru.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftcmru.c                                                               */
   4 /*                                                                         */
   5 /*    FreeType MRU support (body).                                         */
   6 /*                                                                         */
   7 /*  Copyright 2003, 2004, 2006, 2009 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_CACHE_H
  21 #include "ftcmru.h"
  22 #include FT_INTERNAL_OBJECTS_H
  23 #include FT_INTERNAL_DEBUG_H
  24
  25 #include "ftcerror.h"
  26
  27
  28   FT_LOCAL_DEF( void )
  29   FTC_MruNode_Prepend( FTC_MruNode  *plist,
  30                        FTC_MruNode   node )
  31   {
  32     FTC_MruNode  first = *plist;
  33
  34
  35     if ( first )
  36     {
  37       FTC_MruNode  last = first->prev;
  38
  39
  40 #ifdef FT_DEBUG_ERROR
  41       {
  42         FTC_MruNode  cnode = first;
  43
  44
  45         do
  46         {
  47           if ( cnode == node )
  48           {
  49             fprintf( stderr, "FTC_MruNode_Prepend: invalid action\n" );
  50             exit( 2 );
  51           }
  52           cnode = cnode->next;
  53
  54         } while ( cnode != first );
  55       }
  56 #endif
  57
  58       first->prev = node;
  59       last->next  = node;
  60       node->next  = first;
  61       node->prev  = last;
  62     }
  63     else
  64     {
  65       node->next = node;
  66       node->prev = node;
  67     }
  68     *plist = node;
  69   }
  70
  71
  72   FT_LOCAL_DEF( void )
  73   FTC_MruNode_Up( FTC_MruNode  *plist,
  74                   FTC_MruNode   node )
  75   {
  76     FTC_MruNode  first = *plist;
  77
  78
  79     FT_ASSERT( first != NULL );
  80
  81     if ( first != node )
  82     {
  83       FTC_MruNode  prev, next, last;
  84
  85
  86 #ifdef FT_DEBUG_ERROR
  87       {
  88         FTC_MruNode  cnode = first;
  89         do
  90         {
  91           if ( cnode == node )
  92             goto Ok;
  93           cnode = cnode->next;
  94
  95         } while ( cnode != first );
  96
  97         fprintf( stderr, "FTC_MruNode_Up: invalid action\n" );
  98         exit( 2 );
  99       Ok:
 100       }
 101 #endif
 102       prev = node->prev;
 103       next = node->next;
 104
 105       prev->next = next;
 106       next->prev = prev;
 107
 108       last = first->prev;
 109
 110       last->next  = node;
 111       first->prev = node;
 112
 113       node->next = first;
 114       node->prev = last;
 115
 116       *plist = node;
 117     }
 118   }
 119
 120
 121   FT_LOCAL_DEF( void )
 122   FTC_MruNode_Remove( FTC_MruNode  *plist,
 123                       FTC_MruNode   node )
 124   {
 125     FTC_MruNode  first = *plist;
 126     FTC_MruNode  prev, next;
 127
 128
 129     FT_ASSERT( first != NULL );
 130
 131 #ifdef FT_DEBUG_ERROR
 132       {
 133         FTC_MruNode  cnode = first;
 134
 135
 136         do
 137         {
 138           if ( cnode == node )
 139             goto Ok;
 140           cnode = cnode->next;
 141
 142         } while ( cnode != first );
 143
 144         fprintf( stderr, "FTC_MruNode_Remove: invalid action\n" );
 145         exit( 2 );
 146       Ok:
 147       }
 148 #endif
 149
 150     prev = node->prev;
 151     next = node->next;
 152
 153     prev->next = next;
 154     next->prev = prev;
 155
 156     if ( node == next )
 157     {
 158       FT_ASSERT( first == node );
 159       FT_ASSERT( prev  == node );
 160
 161       *plist = NULL;
 162     }
 163     else if ( node == first )
 164       *plist = next;
 165   }
 166
 167
 168   FT_LOCAL_DEF( void )
 169   FTC_MruList_Init( FTC_MruList       list,
 170                     FTC_MruListClass  clazz,
 171                     FT_UInt           max_nodes,
 172                     FT_Pointer        data,
 173                     FT_Memory         memory )
 174   {
 175     list->num_nodes = 0;
 176     list->max_nodes = max_nodes;
 177     list->nodes     = NULL;
 178     list->clazz     = *clazz;
 179     list->data      = data;
 180     list->memory    = memory;
 181   }
 182
 183
 184   FT_LOCAL_DEF( void )
 185   FTC_MruList_Reset( FTC_MruList  list )
 186   {
 187     while ( list->nodes )
 188       FTC_MruList_Remove( list, list->nodes );
 189
 190     FT_ASSERT( list->num_nodes == 0 );
 191   }
 192
 193
 194   FT_LOCAL_DEF( void )
 195   FTC_MruList_Done( FTC_MruList  list )
 196   {
 197     FTC_MruList_Reset( list );
 198   }
 199
 200
 201 #ifndef FTC_INLINE
 202   FT_LOCAL_DEF( FTC_MruNode )
 203   FTC_MruList_Find( FTC_MruList  list,
 204                     FT_Pointer   key )
 205   {
 206     FTC_MruNode_CompareFunc  compare = list->clazz.node_compare;
 207     FTC_MruNode              first, node;
 208
 209
 210     first = list->nodes;
 211     node  = NULL;
 212
 213     if ( first )
 214     {
 215       node = first;
 216       do
 217       {
 218         if ( compare( node, key ) )
 219         {
 220           if ( node != first )
 221             FTC_MruNode_Up( &list->nodes, node );
 222
 223           return node;
 224         }
 225
 226         node = node->next;
 227
 228       } while ( node != first);
 229     }
 230
 231     return NULL;
 232   }
 233 #endif
 234
 235   FT_LOCAL_DEF( FT_Error )
 236   FTC_MruList_New( FTC_MruList   list,
 237                    FT_Pointer    key,
 238                    FTC_MruNode  *anode )
 239   {
 240     FT_Error     error;
 241     FTC_MruNode  node = NULL;
 242     FT_Memory    memory = list->memory;
 243
 244
 245     if ( list->num_nodes >= list->max_nodes && list->max_nodes > 0 )
 246     {
 247       node = list->nodes->prev;
 248
 249       FT_ASSERT( node );
 250
 251       if ( list->clazz.node_reset )
 252       {
 253         FTC_MruNode_Up( &list->nodes, node );
 254
 255         error = list->clazz.node_reset( node, key, list->data );
 256         if ( !error )
 257           goto Exit;
 258       }
 259
 260       FTC_MruNode_Remove( &list->nodes, node );
 261       list->num_nodes--;
 262
 263       if ( list->clazz.node_done )
 264         list->clazz.node_done( node, list->data );
 265     }
 266     else if ( FT_ALLOC( node, list->clazz.node_size ) )
 267       goto Exit;
 268
 269     error = list->clazz.node_init( node, key, list->data );
 270     if ( error )
 271       goto Fail;
 272
 273     FTC_MruNode_Prepend( &list->nodes, node );
 274     list->num_nodes++;
 275
 276   Exit:
 277     *anode = node;
 278     return error;
 279
 280   Fail:
 281     if ( list->clazz.node_done )
 282       list->clazz.node_done( node, list->data );
 283
 284     FT_FREE( node );
 285     goto Exit;
 286   }
 287
 288
 289 #ifndef FTC_INLINE
 290   FT_LOCAL_DEF( FT_Error )
 291   FTC_MruList_Lookup( FTC_MruList   list,
 292                       FT_Pointer    key,
 293                       FTC_MruNode  *anode )
 294   {
 295     FTC_MruNode  node;
 296
 297
 298     node = FTC_MruList_Find( list, key );
 299     if ( node == NULL )
 300       return FTC_MruList_New( list, key, anode );
 301
 302     *anode = node;
 303     return 0;
 304   }
 305 #endif /* FTC_INLINE */
 306
 307   FT_LOCAL_DEF( void )
 308   FTC_MruList_Remove( FTC_MruList  list,
 309                       FTC_MruNode  node )
 310   {
 311     FTC_MruNode_Remove( &list->nodes, node );
 312     list->num_nodes--;
 313
 314     {
 315       FT_Memory  memory = list->memory;
 316
 317
 318       if ( list->clazz.node_done )
 319         list->clazz.node_done( node, list->data );
 320
 321       FT_FREE( node );
 322     }
 323   }
 324
 325
 326   FT_LOCAL_DEF( void )
 327   FTC_MruList_RemoveSelection( FTC_MruList              list,
 328                                FTC_MruNode_CompareFunc  selection,
 329                                FT_Pointer               key )
 330   {
 331     FTC_MruNode  first, node, next;
 332
 333
 334     first = list->nodes;
 335     while ( first && ( selection == NULL || selection( first, key ) ) )
 336     {
 337       FTC_MruList_Remove( list, first );
 338       first = list->nodes;
 339     }
 340
 341     if ( first )
 342     {
 343       node = first->next;
 344       while ( node != first )
 345       {
 346         next = node->next;
 347
 348         if ( selection( node, key ) )
 349           FTC_MruList_Remove( list, node );
 350
 351         node = next;
 352       }
 353     }
 354   }
 355
 356
 357 /* END */