topical media & game development
[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

talk show tell print

lib-of-vs-libs-free-type-2.1.4-include-freetype2-freetype-internal-ftcore.h / h



  ifndef __FT_CORE_H__
  define __FT_CORE_H__
  
  include <ft2build.h>
  include FT_TYPES_H
  include FT_SYSTEM_MEMORY_H
  
  FT_BEGIN_HEADER
***********************************************************************
***********************************************************************
*** ****
*** C L E A N U P S T A C K ****
*** ****
***********************************************************************
***********************************************************************
********************************************************************** @functype: FT_CleanupFunc @description: a function used to cleanup a given item on the cleanup stack @input: item :: target item pointer item_data :: optional argument to cleanup routine 

  
    typedef void  (*FT_CleanupFunc)( FT_Pointer  item,
                                     FT_Pointer  item_data );
********************************************************************** @type: FT_XHandler @description: handle to an exception-handler structure for the FreeType exception sub-system @note: exception handlers are allocated on the stack within a @FT_XTRY macro. Do not try to access them directly. 

  
    typedef struct FT_XHandlerRec_*  FT_XHandler;
  
  /* the size of a cleanup chunk in bytes is FT_CLEANUP_CHUNK_SIZE*12 + 4 */
  /* this must be a small power of 2 whenever possible..                  */
  /*                                                                      */
  /* with a value of 5, we have a byte size of 64 bytes per chunk..       */
  /*                                                                      */
  define  FT_CLEANUP_CHUNK_SIZE   5
  
    typedef struct FT_CleanupItemRec_
    {
      FT_Pointer      item;
      FT_CleanupFunc  item_func;
      FT_Pointer      item_data;
  
    } FT_CleanupItemRec;
  
    typedef struct FT_CleanupChunkRec_*   FT_CleanupChunk;
  
    typedef struct FT_CleanupChunkRec_
    {
      FT_CleanupChunk    link;
      FT_CleanupItemRec  items[ FT_CLEANUP_CHUNK_SIZE ];
  
    } FT_CleanupChunkRec;
  
    typedef struct FT_CleanupStackRec_
    {
      FT_CleanupItem     top;
      FT_CleanupItem     limit;
      FT_CleanupChunk    chunk;
      FT_CleanupChunkRec chunk_0;  /* avoids stupid dynamic allocation */
      FT_Memory          memory;
  
    } FT_CleanupStackRec, *FT_CleanupStack;
  
    FT_BASE( void )
    ft_cleanup_stack_push( FT_CleanupStack  stack,
                           FT_Pointer       item,
                           FT_CleanupFunc   item_func,
                           FT_Pointer       item_data );
  
    FT_BASE( void )
    ft_cleanup_stack_pop( FT_CleanupStack   stack,
                          FT_Int            destroy );
  
    FT_BASE( FT_CleanupItem )
    ft_cleanup_stack_peek( FT_CleanupStack  stack );
  
    FT_BASE( void )
    ft_cleanup_throw( FT_CleanupStack  stack,
                      FT_Error         error );
***********************************************************************
***********************************************************************
*** ****
*** M E M O R Y M A N A G E R ****
*** ****
***********************************************************************
***********************************************************************

  
  
    typedef struct FT_MemoryRec_
    {
      FT_Memory_AllocFunc     mem_alloc;   /* shortcut to funcs->mem_alloc */
      FT_Memory_FreeFunc      mem_free;    /* shortcut to funcs->mem_free  */
      FT_Pointer              mem_data;
      const FT_Memory_Funcs   mem_funcs;
  
      FT_CleanupStackRec      cleanup_stack;
      FT_Pointer              meta_class;
  
    } FT_MemoryRec;
  
  define  FT_MEMORY(x)  ((FT_Memory)(x))
  define  FT_MEMORY__ALLOC(x)       FT_MEMORY(x)->mem_alloc
  define  FT_MEMORY__FREE(x)        FT_MEMORY(x)->mem_free
  define  FT_MEMORY__REALLOC(x)     FT_MEMORY(x)->mem_funcs->mem_realloc
  define  FT_MEMORY__CLEANUP(x)     (&FT_MEMORY(x)->cleanup_stack)
  define  FT_MEMORY__META_CLASS(x)  ((FT_MetaClass)(FT_MEMORY(x)->meta_class))
***********************************************************************
***********************************************************************
*** ****
*** E X C E P T I O N H A N D L I N G ****
*** ****
***********************************************************************
***********************************************************************
********************************************************************** @struct: FT_XHandlerRec @description: exception handler structure @fields: previous :: previous handler in chain. jum_buffer :: processor state used by setjmp/longjmp to implement exception control transfer error :: exception error code mark :: top of cleanup stack when @FT_XTRY is used 

  
    typedef struct FT_XHandlerRec_
    {
      FT_XHandler        previous;
      ft_jmp_buf         jump_buffer;
      volatile FT_Error  error;
      FT_Pointer         mark;
  
    } FT_XHandlerRec;
  
    FT_BASE( void )
    ft_xhandler_enter( FT_XHandler  xhandler,
                       FT_Memory    memory );
  
    FT_BASE( void )
    ft_xhandler_exit( FT_XHandler  xhandler );
  
  FT_END_HEADER
  
  endif /* __FT_CORE_H__ */
[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

(C) Æliens 04/09/2009

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.