Home | History | Annotate | Download | only in cache
      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 */
    358