kc3-lang/freetype/src/cache/ftlru.c

• Show log

  Commit

• Hash : 66cbc209
  Author :
  Date : 2003-03-20T07:04:40
  

  * docs/*: serious rewriting of the documentation * include/freetype/internal/ftobjs.h, src/base/ftobjs.c, src/bdf/bdfdrivr.c, src/pcf/pcfdriver.c, src/pfr/pfrsbit.c, src/sfnt/ttsbit.c, src/type42/t42objs.c, src/winfonts/winfnt.c: introduced three new functions to deal with glyph bitmaps within FT_GlyphSlot objects. these are: ft_glyphslot_free_bitmap ft_glyphslot_alloc_bitmap ft_glyphslot_set_bitmap these are much more convenient to use than managing the FT_GLYPH_OWN_BITMAP flag manually. the font drivers have been modified to use them as well. * src/cache/ftlru.c: fixed an invalid assertion check

Download

• src/cache/ftlru.c

• /***************************************************************************/
  /*                                                                         */
  /*  ftlru.c                                                                */
  /*                                                                         */
  /*    Simple LRU list-cache (body).                                        */
  /*                                                                         */
  /*  Copyright 2000-2001, 2002 by                                           */
  /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  /*                                                                         */
  /*  This file is part of the FreeType project, and may only be used,       */
  /*  modified, and distributed under the terms of the FreeType project      */
  /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  /*  this file you indicate that you have read the license and              */
  /*  understand and accept it fully.                                        */
  /*                                                                         */
  /***************************************************************************/
  
  
  #include <ft2build.h>
  #include FT_CACHE_H
  #include FT_CACHE_INTERNAL_LRU_H
  #include FT_LIST_H
  #include FT_INTERNAL_OBJECTS_H
  #include FT_INTERNAL_DEBUG_H
  
  #include "ftcerror.h"
  
  
    FT_EXPORT_DEF( FT_Error )
    FT_LruList_New( FT_LruList_Class  clazz,
                    FT_UInt           max_nodes,
                    FT_Pointer        user_data,
                    FT_Memory         memory,
                    FT_LruList       *alist )
    {
      FT_Error    error;
      FT_LruList  list;
  
  
      if ( !alist || !clazz )
        return FTC_Err_Invalid_Argument;
  
      *alist = NULL;
      if ( !FT_ALLOC( list, clazz->list_size ) )
      {
        /* initialize common fields */
        list->clazz      = clazz;
        list->memory     = memory;
        list->max_nodes  = max_nodes;
        list->data       = user_data;
  
        if ( clazz->list_init )
        {
          error = clazz->list_init( list );
          if ( error )
          {
            if ( clazz->list_done )
              clazz->list_done( list );
  
            FT_FREE( list );
          }
        }
  
        *alist = list;
      }
  
      return error;
    }
  
  
    FT_EXPORT_DEF( void )
    FT_LruList_Destroy( FT_LruList  list )
    {
      FT_Memory         memory;
      FT_LruList_Class  clazz;
  
  
      if ( !list )
        return;
  
      memory = list->memory;
      clazz  = list->clazz;
  
      FT_LruList_Reset( list );
  
      if ( clazz->list_done )
        clazz->list_done( list );
  
      FT_FREE( list );
    }
  
  
    FT_EXPORT_DEF( void )
    FT_LruList_Reset( FT_LruList  list )
    {
      FT_LruNode        node;
      FT_LruList_Class  clazz;
      FT_Memory         memory;
  
  
      if ( !list )
        return;
  
      node   = list->nodes;
      clazz  = list->clazz;
      memory = list->memory;
  
      while ( node )
      {
        FT_LruNode  next = node->next;
  
  
        if ( clazz->node_done )
          clazz->node_done( node, list->data );
  
        FT_FREE( node );
        node = next;
      }
  
      list->nodes     = NULL;
      list->num_nodes = 0;
    }
  
  
    FT_EXPORT_DEF( FT_Error )
    FT_LruList_Lookup( FT_LruList   list,
                       FT_LruKey    key,
                       FT_LruNode  *anode )
    {
      FT_Error          error = 0;
      FT_LruNode        node, *pnode;
      FT_LruList_Class  clazz;
      FT_LruNode*       plast;
      FT_LruNode        result = NULL;
      FT_Memory         memory;
  
  
      if ( !list || !key || !anode )
        return FTC_Err_Invalid_Argument;
  
      pnode  = &list->nodes;
      plast  = pnode;
      node   = NULL;
      clazz  = list->clazz;
      memory = list->memory;
  
      if ( clazz->node_compare )
      {
        for (;;)
        {
          node = *pnode;
          if ( node == NULL )
            break;
  
          if ( clazz->node_compare( node, key, list->data ) )
            break;
  
          plast = pnode;
          pnode = &(*pnode)->next;
        }
      }
      else
      {
        for (;;)
        {
          node = *pnode;
          if ( node == NULL )
            break;
  
          if ( node->key == key )
            break;
  
          plast = pnode;
          pnode = &(*pnode)->next;
        }
      }
  
      if ( node )
      {
        /* move element to top of list */
        if ( list->nodes != node )
        {
          *pnode      = node->next;
          node->next  = list->nodes;
          list->nodes = node;
        }
        result = node;
        goto Exit;
      }
  
     /* since we haven't found the relevant element in our LRU list,
      * we're going to "create" a new one.
      *
      * the following code is a bit special, because it tries to handle
      * out-of-memory conditions (OOM) in an intelligent way.
      *
      * more precisely, if not enough memory is available to create a
      * new node or "flush" an old one, we need to remove the oldest
      * elements from our list, and try again. since several tries may
      * be necessary, a loop is needed
      *
      * this loop will only exit when:
      *
      *   - a new node was succesfully created, or an old node flushed
      *   - an error other than FT_Err_Out_Of_Memory is detected
      *   - the list of nodes is empty, and it isn't possible to create
      *     new nodes
      *
      * on each unsucesful attempt, one node will be removed from the list
      *
      */
      
      {
        FT_Int   drop_last = ( list->max_nodes > 0 && 
                               list->num_nodes >= list->max_nodes );
  
        for (;;)
        {
          node = NULL;
  
         /* when "drop_last" is true, we should free the last node in
          * the list to make room for a new one. note that we re-use
          * its memory block to save allocation calls.
          */
          if ( drop_last )
          {
           /* find the last node in the list
            */
            pnode = &list->nodes;
            node  = *pnode;
    
            if ( node == NULL )
            {
              FT_ASSERT( list->nodes == 0 );
              error = FT_Err_Out_Of_Memory;
              goto Exit;
            }
  
            FT_ASSERT( list->num_nodes > 0 );
  
            while ( node->next )
            {
              pnode = &node->next;
              node  = *pnode;
            }
    
           /* remove it from the list, and try to "flush" it. doing this will
            * save a significant number of dynamic allocations compared to
            * a classic destroy/create cycle
            */
            *pnode = NULL;
            list->num_nodes -= 1;
    
            if ( clazz->node_flush )
            {
              error = clazz->node_flush( node, key, list->data );
              if ( !error )
                goto Success;
  
             /* note that if an error occured during the flush, we need to
              * finalize it since it is potentially in incomplete state.
              */
            }
  
           /* we finalize, but do not destroy the last node, we
            * simply re-use its memory block !
            */
            if ( clazz->node_done )
              clazz->node_done( node, list->data );
              
            FT_MEM_ZERO( node, clazz->node_size );
          }
          else
          {
           /* try to allocate a new node when "drop_last" is not TRUE
            * this usually happens on the first pass, when the LRU list
            * is not already full.
            */
            if ( FT_ALLOC( node, clazz->node_size ) )
              goto Fail;
          }
    
          FT_ASSERT( node != NULL );
  
          node->key = key;
          error = clazz->node_init( node, key, list->data );
          if ( error )
          {
            if ( clazz->node_done )
              clazz->node_done( node, list->data );
  
            FT_FREE( node );
            goto Fail;
          }
  
        Success:
          result = node;
  
          node->next  = list->nodes;
          list->nodes = node;
          list->num_nodes++;
          goto Exit;
    
        Fail:
          if ( error != FT_Err_Out_Of_Memory )
            goto Exit;
          
          drop_last = 1;
          continue;
        }
      }
  
    Exit:
      *anode = result;
      return error;
    }
  
  
  
    FT_EXPORT_DEF( void )
    FT_LruList_Remove( FT_LruList  list,
                       FT_LruNode  node )
    {
      FT_LruNode  *pnode;
  
  
      if ( !list || !node )
        return;
  
      pnode = &list->nodes;
      for (;;)
      {
        if ( *pnode == node )
        {
          FT_Memory         memory = list->memory;
          FT_LruList_Class  clazz  = list->clazz;
  
  
          *pnode     = node->next;
          node->next = NULL;
  
          if ( clazz->node_done )
            clazz->node_done( node, list->data );
  
          FT_FREE( node );
          list->num_nodes--;
          break;
        }
  
        pnode = &(*pnode)->next;
      }
    }
  
  
    FT_EXPORT_DEF( void )
    FT_LruList_Remove_Selection( FT_LruList             list,
                                 FT_LruNode_SelectFunc  select_func,
                                 FT_Pointer             select_data )
    {
      FT_LruNode       *pnode, node;
      FT_LruList_Class  clazz;
      FT_Memory         memory;
  
  
      if ( !list || !select_func )
        return;
  
      memory = list->memory;
      clazz  = list->clazz;
      pnode  = &list->nodes;
  
      for (;;)
      {
        node = *pnode;
        if ( node == NULL )
          break;
  
        if ( select_func( node, select_data, list->data ) )
        {
          *pnode     = node->next;
          node->next = NULL;
  
          if ( clazz->node_done )
            clazz->node_done( node, list );
  
          FT_FREE( node );
        }
        else
          pnode = &(*pnode)->next;
      }
    }
  
  
  /* END */
  

Download