kc3-lang/freetype/src/base/ftutil.c

• Show log

  Commit

• Hash : 53b3fa1d
  Author :
  Date : 2002-02-24T05:26:57
  

  * renaming stream functions to the FT_Subject_Action scheme: FT_Seek_Stream => FT_Stream_Seek FT_Skip_Stream => FT_Stream_Skip FT_Read_Stream => FT_Stream_Read FT_Read_Stream_At => FT_Stream_Read_At FT_Access_Frame => FT_Stream_Enter_Frame FT_Forget_Frame => FT_Stream_Exit_Frame FT_Extract_Frame => FT_Stream_Extract_Frame FT_Release_Frame => FT_Stream_Release_Frame FT_Get_XXXX => FT_Stream_Get_XXXX FT_Read_XXXX => FT_Stream_Read_XXXX note also that: FT_New_Stream( filename, stream ) => FT_Stream_Open( stream, filename ) (the function doesn't create the FT_Stream structure, it simply initializes it for reading) FT_New_Memory_Stream( library, FT_Byte* base, size, stream ) => FT_Stream_Open_Memory( stream, const FT_Byte* base, size ) FT_Done_Stream => FT_Stream_Close note that the name of the stream methods, defined in "include/freetype/ftsystem.h" have also been changed without problems: FT_Stream_IO => FT_Stream_IOFunc FT_Stream_Close => FT_Stream_CloseFunc

Download

• src/base/ftutil.c

• #include <ft2build.h>
  #include FT_INTERNAL_DEBUG_H
  #include FT_INTERNAL_MEMORY_H
  #include FT_LIST_H
  
  
    /*************************************************************************/
    /*                                                                       */
    /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
    /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
    /* messages during execution.                                            */
    /*                                                                       */
  #undef  FT_COMPONENT
  #define FT_COMPONENT  trace_memory
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                                                               *****/
    /*****               M E M O R Y   M A N A G E M E N T               *****/
    /*****                                                               *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
    /*************************************************************************/
  
    /* documentation is in ftmemory.h */
  
    FT_BASE_DEF( FT_Error )
    FT_Alloc( FT_Memory  memory,
              FT_Long    size,
              void*     *P )
    {
      FT_ASSERT( P != 0 );
  
      if ( size > 0 )
      {
        *P = memory->alloc( memory, size );
        if ( !*P )
        {
          FT_ERROR(( "FT_Alloc:" ));
          FT_ERROR(( " Out of memory? (%ld requested)\n",
                     size ));
  
          return FT_Err_Out_Of_Memory;
        }
        MEM_Set( *P, 0, size );
      }
      else
        *P = NULL;
  
      FT_TRACE7(( "FT_Alloc:" ));
      FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
                  size, *P, P ));
  
      return FT_Err_Ok;
    }
  
  
    /* documentation is in ftmemory.h */
  
    FT_BASE_DEF( FT_Error )
    FT_Realloc( FT_Memory  memory,
                FT_Long    current,
                FT_Long    size,
                void**     P )
    {
      void*  Q;
  
  
      FT_ASSERT( P != 0 );
  
      /* if the original pointer is NULL, call FT_Alloc() */
      if ( !*P )
        return FT_Alloc( memory, size, P );
  
      /* if the new block if zero-sized, clear the current one */
      if ( size <= 0 )
      {
        FT_Free( memory, P );
        return FT_Err_Ok;
      }
  
      Q = memory->realloc( memory, current, size, *P );
      if ( !Q )
        goto Fail;
  
      if ( size > current )
        memset( (char*)Q + current, 0, size - current );
  
      *P = Q;
      return FT_Err_Ok;
  
    Fail:
      FT_ERROR(( "FT_Realloc:" ));
      FT_ERROR(( " Failed (current %ld, requested %ld)\n",
                 current, size ));
      return FT_Err_Out_Of_Memory;
    }
  
  
    /* documentation is in ftmemory.h */
  
    FT_BASE_DEF( void )
    FT_Free( FT_Memory  memory,
             void**     P )
    {
      FT_TRACE7(( "FT_Free:" ));
      FT_TRACE7(( " Freeing block 0x%08p, ref 0x%08p\n",
                  P, P ? *P : (void*)0 ));
  
      if ( P && *P )
      {
        memory->free( memory, *P );
        *P = 0;
      }
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                                                               *****/
    /*****            D O U B L Y   L I N K E D   L I S T S              *****/
    /*****                                                               *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
    /*************************************************************************/
  
  #undef  FT_COMPONENT
  #define FT_COMPONENT  trace_list
  
    /* documentation is in ftlist.h */
  
    FT_EXPORT_DEF( FT_ListNode )
    FT_List_Find( FT_List  list,
                  void*    data )
    {
      FT_ListNode  cur;
  
  
      cur = list->head;
      while ( cur )
      {
        if ( cur->data == data )
          return cur;
  
        cur = cur->next;
      }
  
      return (FT_ListNode)0;
    }
  
  
    /* documentation is in ftlist.h */
  
    FT_EXPORT_DEF( void )
    FT_List_Add( FT_List      list,
                 FT_ListNode  node )
    {
      FT_ListNode  before = list->tail;
  
  
      node->next = 0;
      node->prev = before;
  
      if ( before )
        before->next = node;
      else
        list->head = node;
  
      list->tail = node;
    }
  
  
    /* documentation is in ftlist.h */
  
    FT_EXPORT_DEF( void )
    FT_List_Insert( FT_List      list,
                    FT_ListNode  node )
    {
      FT_ListNode  after = list->head;
  
  
      node->next = after;
      node->prev = 0;
  
      if ( !after )
        list->tail = node;
      else
        after->prev = node;
  
      list->head = node;
    }
  
  
    /* documentation is in ftlist.h */
  
    FT_EXPORT_DEF( void )
    FT_List_Remove( FT_List      list,
                    FT_ListNode  node )
    {
      FT_ListNode  before, after;
  
  
      before = node->prev;
      after  = node->next;
  
      if ( before )
        before->next = after;
      else
        list->head = after;
  
      if ( after )
        after->prev = before;
      else
        list->tail = before;
    }
  
  
    /* documentation is in ftlist.h */
  
    FT_EXPORT_DEF( void )
    FT_List_Up( FT_List      list,
                FT_ListNode  node )
    {
      FT_ListNode  before, after;
  
  
      before = node->prev;
      after  = node->next;
  
      /* check whether we are already on top of the list */
      if ( !before )
        return;
  
      before->next = after;
  
      if ( after )
        after->prev = before;
      else
        list->tail = before;
  
      node->prev       = 0;
      node->next       = list->head;
      list->head->prev = node;
      list->head       = node;
    }
  
  
    /* documentation is in ftlist.h */
  
    FT_EXPORT_DEF( FT_Error )
    FT_List_Iterate( FT_List            list,
                     FT_List_Iterator   iterator,
                     void*              user )
    {
      FT_ListNode  cur   = list->head;
      FT_Error     error = FT_Err_Ok;
  
  
      while ( cur )
      {
        FT_ListNode  next = cur->next;
  
  
        error = iterator( cur, user );
        if ( error )
          break;
  
        cur = next;
      }
  
      return error;
    }
  
  
    /* documentation is in ftlist.h */
  
    FT_EXPORT_DEF( void )
    FT_List_Finalize( FT_List             list,
                      FT_List_Destructor  destroy,
                      FT_Memory           memory,
                      void*               user )
    {
      FT_ListNode  cur;
  
  
      cur = list->head;
      while ( cur )
      {
        FT_ListNode  next = cur->next;
        void*        data = cur->data;
  
  
        if ( destroy )
          destroy( memory, data, user );
  
        FREE( cur );
        cur = next;
      }
  
      list->head = 0;
      list->tail = 0;
    }
  
  
  

Download