#include <freetype/ftglyph.h>

Include dependency graph for ftcache.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	FTC_ScalerRec_

struct	FTC_ImageTypeRec_

struct	FTC_SBitRec_

Macros
#define	FTC_IMAGE_TYPE_COMPARE(d1, d2)

Typedefs
typedef FT_Error(*	FTC_Face_Requester) (FTC_FaceID face_id, FT_Library library, FT_Pointer req_data, FT_Face *aface)

typedef struct FTC_ManagerRec_ *	FTC_Manager

typedef struct FTC_NodeRec_ *	FTC_Node

typedef struct FTC_ScalerRec_	FTC_ScalerRec

typedef struct FTC_ScalerRec_ *	FTC_Scaler

typedef struct FTC_CMapCacheRec_ *	FTC_CMapCache

typedef struct FTC_ImageTypeRec_	FTC_ImageTypeRec

typedef struct FTC_ImageTypeRec_ *	FTC_ImageType

typedef struct FTC_ImageCacheRec_ *	FTC_ImageCache

typedef struct FTC_SBitRec_ *	FTC_SBit

typedef struct FTC_SBitRec_	FTC_SBitRec

typedef struct FTC_SBitCacheRec_ *	FTC_SBitCache

Functions
	FTC_Manager_New (FT_Library library, FT_UInt max_faces, FT_UInt max_sizes, FT_ULong max_bytes, FTC_Face_Requester requester, FT_Pointer req_data, FTC_Manager *amanager)

	FTC_Manager_Reset (FTC_Manager manager)

	FTC_Manager_Done (FTC_Manager manager)

	FTC_Manager_LookupFace (FTC_Manager manager, FTC_FaceID face_id, FT_Face *aface)

	FTC_Manager_LookupSize (FTC_Manager manager, FTC_Scaler scaler, FT_Size *asize)

	FTC_Node_Unref (FTC_Node node, FTC_Manager manager)

	FTC_Manager_RemoveFaceID (FTC_Manager manager, FTC_FaceID face_id)

	FTC_CMapCache_New (FTC_Manager manager, FTC_CMapCache *acache)

	FTC_CMapCache_Lookup (FTC_CMapCache cache, FTC_FaceID face_id, FT_Int cmap_index, FT_UInt32 char_code)

	FTC_ImageCache_New (FTC_Manager manager, FTC_ImageCache *acache)

	FTC_ImageCache_Lookup (FTC_ImageCache cache, FTC_ImageType type, FT_UInt gindex, FT_Glyph aglyph, FTC_Node anode)

	FTC_ImageCache_LookupScaler (FTC_ImageCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FT_Glyph aglyph, FTC_Node anode)

	FTC_SBitCache_New (FTC_Manager manager, FTC_SBitCache *acache)

	FTC_SBitCache_Lookup (FTC_SBitCache cache, FTC_ImageType type, FT_UInt gindex, FTC_SBit sbit, FTC_Node anode)

	FTC_SBitCache_LookupScaler (FTC_SBitCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FTC_SBit sbit, FTC_Node anode)

Variables
FT_BEGIN_HEADER typedef FT_Pointer	FTC_FaceID

Macro Definition Documentation

◆ FTC_IMAGE_TYPE_COMPARE

#define FTC_IMAGE_TYPE_COMPARE	(	d1,
		d2
	)

Value:

          ( (d1)->face_id == (d2)->face_id && \
            (d1)->width   == (d2)->width   && \
            (d1)->flags   == (d2)->flags   )

Definition at line 697 of file ftcache.h.

Typedef Documentation

◆ FTC_CMapCache

typedef struct FTC_CMapCacheRec_* FTC_CMapCache

Definition at line 573 of file ftcache.h.

◆ FTC_Face_Requester

typedef FT_Error(* FTC_Face_Requester) (FTC_FaceID face_id, FT_Library library, FT_Pointer req_data, FT_Face *aface)

Definition at line 209 of file ftcache.h.

◆ FTC_ImageCache

typedef struct FTC_ImageCacheRec_* FTC_ImageCache

Definition at line 713 of file ftcache.h.

◆ FTC_ImageType

typedef struct FTC_ImageTypeRec_* FTC_ImageType

Definition at line 691 of file ftcache.h.

◆ FTC_ImageTypeRec

typedef struct FTC_ImageTypeRec_ FTC_ImageTypeRec

◆ FTC_Manager

typedef struct FTC_ManagerRec_* FTC_Manager

Definition at line 250 of file ftcache.h.

◆ FTC_Node

typedef struct FTC_NodeRec_* FTC_Node

Definition at line 270 of file ftcache.h.

◆ FTC_SBit

typedef struct FTC_SBitRec_* FTC_SBit

Definition at line 861 of file ftcache.h.

◆ FTC_SBitCache

typedef struct FTC_SBitCacheRec_* FTC_SBitCache

Definition at line 935 of file ftcache.h.

◆ FTC_SBitRec

typedef struct FTC_SBitRec_ FTC_SBitRec

◆ FTC_Scaler

typedef struct FTC_ScalerRec_* FTC_Scaler

Definition at line 461 of file ftcache.h.

◆ FTC_ScalerRec

typedef struct FTC_ScalerRec_ FTC_ScalerRec

Function Documentation

◆ FTC_CMapCache_Lookup()

FTC_CMapCache_Lookup	(	FTC_CMapCache	cache,
		FTC_FaceID	face_id,
		FT_Int	cmap_index,
		FT_UInt32	char_code
	)

Definition at line 230 of file ftccmap.c.

  {
    FTC_Cache         cache = FTC_CACHE( cmap_cache );
    FTC_CMapQueryRec  query;
    FTC_Node          node;
    FT_Error          error;
    FT_UInt           gindex = 0;
    FT_Offset         hash;
    FT_Int            no_cmap_change = 0;
 
 
    if ( cmap_index < 0 )
    {
      /* Treat a negative cmap index as a special value, meaning that you */
      /* don't want to change the FT_Face's character map through this    */
      /* call.  This can be useful if the face requester callback already */
      /* sets the face's charmap to the appropriate value.                */
 
      no_cmap_change = 1;
      cmap_index     = 0;
    }
 
    if ( !cache )
    {
      FT_TRACE0(( "FTC_CMapCache_Lookup: bad arguments, returning 0\n" ));
      return 0;
    }
 
    query.face_id    = face_id;
    query.cmap_index = (FT_UInt)cmap_index;
    query.char_code  = char_code;
 
    hash = FTC_CMAP_HASH( face_id, (FT_UInt)cmap_index, char_code );
 
#if 1
    FTC_CACHE_LOOKUP_CMP( cache, ftc_cmap_node_compare, hash, &query,
                          node, error );
#else
    error = FTC_Cache_Lookup( cache, hash, &query, &node );
#endif
    if ( error )
      goto Exit;
 
    FT_ASSERT( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first ) <
                FTC_CMAP_INDICES_MAX );
 
    /* something rotten can happen with rogue clients */
    if ( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first >=
                    FTC_CMAP_INDICES_MAX ) )
      return 0; /* XXX: should return appropriate error */
 
    gindex = FTC_CMAP_NODE( node )->indices[char_code -
                                            FTC_CMAP_NODE( node )->first];
    if ( gindex == FTC_CMAP_UNKNOWN )
    {
      FT_Face  face;
 
 
      gindex = 0;
 
      error = FTC_Manager_LookupFace( cache->manager,
                                      FTC_CMAP_NODE( node )->face_id,
                                      &face );
      if ( error )
        goto Exit;
 
      if ( (FT_UInt)cmap_index < (FT_UInt)face->num_charmaps )
      {
        FT_CharMap  old, cmap  = NULL;
 
 
        old  = face->charmap;
        cmap = face->charmaps[cmap_index];
 
        if ( old != cmap && !no_cmap_change )
          FT_Set_Charmap( face, cmap );
 
        gindex = FT_Get_Char_Index( face, char_code );
 
        if ( old != cmap && !no_cmap_change )
          FT_Set_Charmap( face, old );
      }
 
      FTC_CMAP_NODE( node )->indices[char_code -
                                     FTC_CMAP_NODE( node )->first]
        = (FT_UShort)gindex;
    }
 
  Exit:
    return gindex;
  }

◆ FTC_CMapCache_New()

FTC_CMapCache_New	(	FTC_Manager	manager,
		FTC_CMapCache *	acache
	)

Definition at line 218 of file ftccmap.c.

  {
    return FTC_Manager_RegisterCache( manager,
                                      &ftc_cmap_cache_class,
                                      FTC_CACHE_P( acache ) );
  }

◆ FTC_ImageCache_Lookup()

FTC_ImageCache_Lookup	(	FTC_ImageCache	cache,
		FTC_ImageType	type,
		FT_UInt	gindex,
		FT_Glyph *	aglyph,
		FTC_Node *	anode
	)

Definition at line 285 of file ftcbasic.c.

  {
    FTC_BasicQueryRec  query;
    FTC_Node           node = 0; /* make compiler happy */
    FT_Error           error;
    FT_Offset          hash;
 
 
    /* some argument checks are delayed to `FTC_Cache_Lookup' */
    if ( !aglyph )
    {
      error = FT_THROW( Invalid_Argument );
      goto Exit;
    }
 
    *aglyph = NULL;
    if ( anode )
      *anode  = NULL;
 
    /*
     * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
     * but public `FT_ImageType->flags' is of type `FT_Int32'.
     *
     * On 16bit systems, higher bits of type->flags cannot be handled.
     */
#if 0xFFFFFFFFUL > FT_UINT_MAX
    if ( (type->flags & (FT_ULong)FT_UINT_MAX) )
      FT_TRACE1(( "FTC_ImageCache_Lookup:"
                  " higher bits in load_flags 0x%x are dropped\n",
                  (FT_ULong)type->flags & ~((FT_ULong)FT_UINT_MAX) ));
#endif
 
    query.attrs.scaler.face_id = type->face_id;
    query.attrs.scaler.width   = type->width;
    query.attrs.scaler.height  = type->height;
    query.attrs.load_flags     = (FT_UInt)type->flags;
 
    query.attrs.scaler.pixel = 1;
    query.attrs.scaler.x_res = 0;  /* make compilers happy */
    query.attrs.scaler.y_res = 0;
 
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
 
#if 1  /* inlining is about 50% faster! */
    FTC_GCACHE_LOOKUP_CMP( cache,
                           ftc_basic_family_compare,
                           FTC_GNode_Compare,
                           hash, gindex,
                           &query,
                           node,
                           error );
#else
    error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
                               hash, gindex,
                               FTC_GQUERY( &query ),
                               &node );
#endif
    if ( !error )
    {
      *aglyph = FTC_INODE( node )->glyph;
 
      if ( anode )
      {
        *anode = node;
        node->ref_count++;
      }
    }
 
  Exit:
    return error;
  }

◆ FTC_ImageCache_LookupScaler()

FTC_ImageCache_LookupScaler	(	FTC_ImageCache	cache,
		FTC_Scaler	scaler,
		FT_ULong	load_flags,
		FT_UInt	gindex,
		FT_Glyph *	aglyph,
		FTC_Node *	anode
	)

Definition at line 365 of file ftcbasic.c.

  {
    FTC_BasicQueryRec  query;
    FTC_Node           node = 0; /* make compiler happy */
    FT_Error           error;
    FT_Offset          hash;
 
 
    /* some argument checks are delayed to `FTC_Cache_Lookup' */
    if ( !aglyph || !scaler )
    {
      error = FT_THROW( Invalid_Argument );
      goto Exit;
    }
 
    *aglyph = NULL;
    if ( anode )
      *anode  = NULL;
 
    /*
     * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
     * but public `FT_Face->face_flags' is of type `FT_Long'.
     *
     * On long > int systems, higher bits of load_flags cannot be handled.
     */
#if FT_ULONG_MAX > FT_UINT_MAX
    if ( load_flags > FT_UINT_MAX )
      FT_TRACE1(( "FTC_ImageCache_LookupScaler:"
                  " higher bits in load_flags 0x%lx are dropped\n",
                  load_flags & ~((FT_ULong)FT_UINT_MAX) ));
#endif
 
    query.attrs.scaler     = scaler[0];
    query.attrs.load_flags = (FT_UInt)load_flags;
 
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
 
    FTC_GCACHE_LOOKUP_CMP( cache,
                           ftc_basic_family_compare,
                           FTC_GNode_Compare,
                           hash, gindex,
                           &query,
                           node,
                           error );
    if ( !error )
    {
      *aglyph = FTC_INODE( node )->glyph;
 
      if ( anode )
      {
        *anode = node;
        node->ref_count++;
      }
    }
 
  Exit:
    return error;
  }

◆ FTC_ImageCache_New()

FTC_ImageCache_New	(	FTC_Manager	manager,
		FTC_ImageCache *	acache
	)

Definition at line 274 of file ftcbasic.c.

  {
    return FTC_GCache_New( manager, &ftc_basic_image_cache_class,
                           (FTC_GCache*)acache );
  }

◆ FTC_Manager_Done()

FTC_Manager_Done ( FTC_Manager manager )

Definition at line 412 of file ftcmanag.c.

  {
    FT_Memory  memory;
    FT_UInt    idx;
 
 
    if ( !manager || !manager->library )
      return;
 
    memory = manager->memory;
 
    /* now discard all caches */
    for (idx = manager->num_caches; idx-- > 0; )
    {
      FTC_Cache  cache = manager->caches[idx];
 
 
      if ( cache )
      {
        cache->clazz.cache_done( cache );
        FT_FREE( cache );
        manager->caches[idx] = NULL;
      }
    }
    manager->num_caches = 0;
 
    /* discard faces and sizes */
    FTC_MruList_Done( &manager->sizes );
    FTC_MruList_Done( &manager->faces );
 
    manager->library = NULL;
    manager->memory  = NULL;
 
    FT_FREE( manager );
  }

◆ FTC_Manager_LookupFace()

FTC_Manager_LookupFace	(	FTC_Manager	manager,
		FTC_FaceID	face_id,
		FT_Face *	aface
	)

Definition at line 305 of file ftcmanag.c.

  {
    FT_Error     error;
    FTC_MruNode  mrunode;
 
 
    if ( !aface )
      return FT_THROW( Invalid_Argument );
 
    *aface = NULL;
 
    if ( !manager )
      return FT_THROW( Invalid_Cache_Handle );
 
    /* we break encapsulation for the sake of speed */
#ifdef FTC_INLINE
 
    FTC_MRULIST_LOOKUP_CMP( &manager->faces, face_id, ftc_face_node_compare,
                            mrunode, error );
 
#else
    error = FTC_MruList_Lookup( &manager->faces, face_id, &mrunode );
#endif
 
    if ( !error )
      *aface = FTC_FACE_NODE( mrunode )->face;
 
    return error;
  }

Referenced by ftc_basic_family_get_count(), FTC_CMapCache_Lookup(), and ftc_scaler_lookup_size().

◆ FTC_Manager_LookupSize()

FTC_Manager_LookupSize	(	FTC_Manager	manager,
		FTC_Scaler	scaler,
		FT_Size *	asize
	)

Definition at line 178 of file ftcmanag.c.

  {
    FT_Error     error;
    FTC_MruNode  mrunode;
 
 
    if ( !asize || !scaler )
      return FT_THROW( Invalid_Argument );
 
    *asize = NULL;
 
    if ( !manager )
      return FT_THROW( Invalid_Cache_Handle );
 
#ifdef FTC_INLINE
 
    FTC_MRULIST_LOOKUP_CMP( &manager->sizes, scaler, ftc_size_node_compare,
                            mrunode, error );
 
#else
    error = FTC_MruList_Lookup( &manager->sizes, scaler, &mrunode );
#endif
 
    if ( !error )
      *asize = FTC_SIZE_NODE( mrunode )->size;
 
    return error;
  }

Referenced by ftc_basic_family_load_bitmap(), and ftc_basic_family_load_glyph().

◆ FTC_Manager_New()

FTC_Manager_New	(	FT_Library	library,
		FT_UInt	max_faces,
		FT_UInt	max_sizes,
		FT_ULong	max_bytes,
		FTC_Face_Requester	requester,
		FT_Pointer	req_data,
		FTC_Manager *	amanager
	)

Definition at line 350 of file ftcmanag.c.

  {
    FT_Error     error;
    FT_Memory    memory;
    FTC_Manager  manager = 0;
 
 
    if ( !library )
      return FT_THROW( Invalid_Library_Handle );
 
    if ( !amanager || !requester )
      return FT_THROW( Invalid_Argument );
 
    memory = library->memory;
 
    if ( FT_NEW( manager ) )
      goto Exit;
 
    if ( max_faces == 0 )
      max_faces = FTC_MAX_FACES_DEFAULT;
 
    if ( max_sizes == 0 )
      max_sizes = FTC_MAX_SIZES_DEFAULT;
 
    if ( max_bytes == 0 )
      max_bytes = FTC_MAX_BYTES_DEFAULT;
 
    manager->library      = library;
    manager->memory       = memory;
    manager->max_weight   = max_bytes;
 
    manager->request_face = requester;
    manager->request_data = req_data;
 
    FTC_MruList_Init( &manager->faces,
                      &ftc_face_list_class,
                      max_faces,
                      manager,
                      memory );
 
    FTC_MruList_Init( &manager->sizes,
                      &ftc_size_list_class,
                      max_sizes,
                      manager,
                      memory );
 
    *amanager = manager;
 
  Exit:
    return error;
  }

◆ FTC_Manager_RemoveFaceID()

FTC_Manager_RemoveFaceID	(	FTC_Manager	manager,
		FTC_FaceID	face_id
	)

Definition at line 665 of file ftcmanag.c.

  {
    FT_UInt  nn;
 
 
    if ( !manager )
      return;
 
    /* this will remove all FTC_SizeNode that correspond to
     * the face_id as well
     */
    FTC_MruList_RemoveSelection( &manager->faces,
                                 ftc_face_node_compare,
                                 face_id );
 
    for ( nn = 0; nn < manager->num_caches; nn++ )
      FTC_Cache_RemoveFaceID( manager->caches[nn], face_id );
  }

◆ FTC_Manager_Reset()

FTC_Manager_Reset ( FTC_Manager manager )

Definition at line 452 of file ftcmanag.c.

  {
    if ( !manager )
      return;
 
    FTC_MruList_Reset( &manager->sizes );
    FTC_MruList_Reset( &manager->faces );
 
    FTC_Manager_FlushN( manager, manager->num_nodes );
  }

◆ FTC_Node_Unref()

FTC_Node_Unref	(	FTC_Node	node,
		FTC_Manager	manager
	)

Definition at line 689 of file ftcmanag.c.

  {
    if ( node                                             &&
         manager                                          &&
         (FT_UInt)node->cache_index < manager->num_caches )
      node->ref_count--;
  }

◆ FTC_SBitCache_Lookup()

FTC_SBitCache_Lookup	(	FTC_SBitCache	cache,
		FTC_ImageType	type,
		FT_UInt	gindex,
		FTC_SBit *	sbit,
		FTC_Node *	anode
	)

Definition at line 485 of file ftcbasic.c.

  {
    FT_Error           error;
    FTC_BasicQueryRec  query;
    FTC_Node           node = 0; /* make compiler happy */
    FT_Offset          hash;
 
 
    if ( anode )
      *anode = NULL;
 
    /* other argument checks delayed to `FTC_Cache_Lookup' */
    if ( !ansbit )
      return FT_THROW( Invalid_Argument );
 
    *ansbit = NULL;
 
    /*
     * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
     * but public `FT_ImageType->flags' is of type `FT_Int32'.
     *
     * On 16bit systems, higher bits of type->flags cannot be handled.
     */
#if 0xFFFFFFFFUL > FT_UINT_MAX
    if ( (type->flags & (FT_ULong)FT_UINT_MAX) )
      FT_TRACE1(( "FTC_ImageCache_Lookup:"
                  " higher bits in load_flags 0x%x are dropped\n",
                  (FT_ULong)type->flags & ~((FT_ULong)FT_UINT_MAX) ));
#endif
 
    query.attrs.scaler.face_id = type->face_id;
    query.attrs.scaler.width   = type->width;
    query.attrs.scaler.height  = type->height;
    query.attrs.load_flags     = (FT_UInt)type->flags;
 
    query.attrs.scaler.pixel = 1;
    query.attrs.scaler.x_res = 0;  /* make compilers happy */
    query.attrs.scaler.y_res = 0;
 
    /* beware, the hash must be the same for all glyph ranges! */
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
           gindex / FTC_SBIT_ITEMS_PER_NODE;
 
#if 1  /* inlining is about 50% faster! */
    FTC_GCACHE_LOOKUP_CMP( cache,
                           ftc_basic_family_compare,
                           FTC_SNode_Compare,
                           hash, gindex,
                           &query,
                           node,
                           error );
#else
    error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
                               hash,
                               gindex,
                               FTC_GQUERY( &query ),
                               &node );
#endif
    if ( error )
      goto Exit;
 
    *ansbit = FTC_SNODE( node )->sbits +
              ( gindex - FTC_GNODE( node )->gindex );
 
    if ( anode )
    {
      *anode = node;
      node->ref_count++;
    }
 
  Exit:
    return error;
  }

◆ FTC_SBitCache_LookupScaler()

FTC_SBitCache_LookupScaler	(	FTC_SBitCache	cache,
		FTC_Scaler	scaler,
		FT_ULong	load_flags,
		FT_UInt	gindex,
		FTC_SBit *	sbit,
		FTC_Node *	anode
	)

Definition at line 567 of file ftcbasic.c.

  {
    FT_Error           error;
    FTC_BasicQueryRec  query;
    FTC_Node           node = 0; /* make compiler happy */
    FT_Offset          hash;
 
 
    if ( anode )
        *anode = NULL;
 
    /* other argument checks delayed to `FTC_Cache_Lookup' */
    if ( !ansbit || !scaler )
        return FT_THROW( Invalid_Argument );
 
    *ansbit = NULL;
 
    /*
     * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
     * but public `FT_Face->face_flags' is of type `FT_Long'.
     *
     * On long > int systems, higher bits of load_flags cannot be handled.
     */
#if FT_ULONG_MAX > FT_UINT_MAX
    if ( load_flags > FT_UINT_MAX )
      FT_TRACE1(( "FTC_ImageCache_LookupScaler:"
                  " higher bits in load_flags 0x%lx are dropped\n",
                  load_flags & ~((FT_ULong)FT_UINT_MAX) ));
#endif
 
    query.attrs.scaler     = scaler[0];
    query.attrs.load_flags = (FT_UInt)load_flags;
 
    /* beware, the hash must be the same for all glyph ranges! */
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
             gindex / FTC_SBIT_ITEMS_PER_NODE;
 
    FTC_GCACHE_LOOKUP_CMP( cache,
                           ftc_basic_family_compare,
                           FTC_SNode_Compare,
                           hash, gindex,
                           &query,
                           node,
                           error );
    if ( error )
      goto Exit;
 
    *ansbit = FTC_SNODE( node )->sbits +
              ( gindex - FTC_GNODE( node )->gindex );
 
    if ( anode )
    {
      *anode = node;
      node->ref_count++;
    }
 
  Exit:
    return error;
  }

◆ FTC_SBitCache_New()

FTC_SBitCache_New	(	FTC_Manager	manager,
		FTC_SBitCache *	acache
	)

Definition at line 474 of file ftcbasic.c.

  {
    return FTC_GCache_New( manager, &ftc_basic_sbit_cache_class,
                           (FTC_GCache*)acache );
  }

Variable Documentation

◆ FTC_FaceID

FT_BEGIN_HEADER typedef FT_Pointer FTC_FaceID

Definition at line 171 of file ftcache.h.

Referenced by ftc_basic_gnode_compare_faceid(), ftc_cmap_node_remove_faceid(), ftc_face_node_compare(), ftc_face_node_init(), and ftc_size_node_compare_faceid().

Classes

Macros

Typedefs

Functions

Variables