From 21e046e0c40e25bccf995314bae3dfd7b1e4ba02 Mon Sep 17 00:00:00 2001 From: Werner Lemberg Date: Thu, 20 Dec 2001 17:49:10 +0000 Subject: [PATCH] Formatting. * src/cache/ftccache.c (ftc_node_destroy, ftc_cache_lookup): Fix tracing strings. * src/cache/ftccmap.c (ftc_cmap_family_init): Ditto. * src/cache/ftcmanag.c (ftc_family_table_alloc, ftc_family_table_free, FTC_Manager_Check): Ditto. * src/cache/ftcsbits.c (ftc_sbit_node_load): Ditto. --- ChangeLog | 54 +++--- include/freetype/cache/ftccache.h | 180 +++++++++++-------- include/freetype/cache/ftccmap.h | 280 ++++++++++++++++-------------- include/freetype/cache/ftcglyph.h | 121 ++++++------- include/freetype/cache/ftcimage.h | 101 ++++++----- include/freetype/cache/ftcmanag.h | 39 +++-- include/freetype/cache/ftcsbits.h | 30 ++-- include/freetype/cache/ftlru.h | 71 ++++---- include/freetype/ftcache.h | 68 ++++---- src/cache/ftccache.c | 93 ++++++---- src/cache/ftccmap.c | 224 ++++++++++++------------ src/cache/ftcglyph.c | 31 ++-- src/cache/ftcimage.c | 84 ++++----- src/cache/ftcmanag.c | 68 ++++---- src/cache/ftcsbits.c | 179 +++++++++---------- src/cache/ftlru.c | 2 +- 16 files changed, 860 insertions(+), 765 deletions(-) diff --git a/ChangeLog b/ChangeLog index 4c307b1c8..cb1b2c2e4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,36 +1,44 @@ -2001-12-20 David Turner +2001-12-20 Werner Lemberg + + * src/cache/ftccache.c (ftc_node_destroy, ftc_cache_lookup): Fix + tracing strings. + * src/cache/ftccmap.c (ftc_cmap_family_init): Ditto. + * src/cache/ftcmanag.c (ftc_family_table_alloc, + ftc_family_table_free, FTC_Manager_Check): Ditto. + * src/cache/ftcsbits.c (ftc_sbit_node_load): Ditto. - * include/freetype/config/ftoption.h: disabling bytecode interpreter - for new release +2001-12-20 David Turner - * docs/CHANGES: updated for 2.0.6 release + * include/freetype/config/ftoption.h: Disabling bytecode interpreter + for new release. - * src/cff/cffload.h, src/cff/cffload.c, src/cff/cffgload.c: updated - to mode the definition of encoding tables within "cffload.c" instead - of making them part of a shared header (causing problems in "multi" - builds) + * docs/CHANGES: Updated for 2.0.6 release. - * docs/TODO: added "stem3 and counter hints support" to the TODO list - for the Postscript hinter + * src/cff/cffload.h, src/cff/cffload.c, src/cff/cffgload.c: Updated + to mode the definition of encoding tables within "cffload.c" instead + of making them part of a shared header (causing problems in "multi" + builds). - * docs/BUGS: closed the AUTOHINT-NO-SBITS bug. + * docs/TODO: Added "stem3 and counter hints support" to the TODO list + for the Postscript hinter. - * src/pshinter/pshrec.c (t2_hint_stems), src/cff/cffobjs.h, - src/cff/cffobjs.c, src/cff/cffload.c, src/cff/cffload.h, - src/cff/cffgload.c, src/cff/cffgload.h, src/cff/cffdriver.c, - include/freetype/internal/cfftypes.h: added Postscript hinter support - to the CFF driver + * docs/BUGS: Closed the AUTOHINT-NO-SBITS bug. - * src/base/ftobjs.c (FT_Done_Library): fixed a stupid bug that crashed - the library on exit + * src/pshinter/pshrec.c (t2_hint_stems), src/cff/cffobjs.h, + src/cff/cffobjs.c, src/cff/cffload.c, src/cff/cffload.h, + src/cff/cffgload.c, src/cff/cffgload.h, src/cff/cffdriver.c, + include/freetype/internal/cfftypes.h: added Postscript hinter support + to the CFF driver. - * src/type1/t1gload.c (T1_Load_Glyph): enable font matrix transform - on hinted glyphs.. + * src/base/ftobjs.c (FT_Done_Library): Fixed a stupid bug that crashed + the library on exit. - * src/cid/cidgload.c, src/cid/cidobjs.c, src/cid/cidobjs.h, - src/cid/cidriver.c, include/freetype/internal/t1types.h: added - Postscript hinter support to the CID font driver !! + * src/type1/t1gload.c (T1_Load_Glyph): Enable font matrix transform + on hinted glyphs. + * src/cid/cidgload.c, src/cid/cidobjs.c, src/cid/cidobjs.h, + src/cid/cidriver.c, include/freetype/internal/t1types.h: Added + Postscript hinter support to the CID font driver. 2001-12-19 David Turner diff --git a/include/freetype/cache/ftccache.h b/include/freetype/cache/ftccache.h index 94b6d7a32..97d8bc864 100644 --- a/include/freetype/cache/ftccache.h +++ b/include/freetype/cache/ftccache.h @@ -1,23 +1,39 @@ -#ifndef __FT_CACHE_CACHE_H__ -#define __FT_CACHE_CACHE_H__ +/***************************************************************************/ +/* */ +/* ftccache.h */ +/* */ +/* FreeType internal cache interface (specification). */ +/* */ +/* Copyright 2000-2001 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. */ +/* */ +/***************************************************************************/ + + +#ifndef __FTCCACHE_H__ +#define __FTCCACHE_H__ + FT_BEGIN_HEADER /* handle to cache object */ typedef struct FTC_CacheRec_* FTC_Cache; - /* handle to cache class */ typedef const struct FTC_Cache_ClassRec_* FTC_Cache_Class; + /* handle to cache node family */ + typedef struct FTC_FamilyRec_* FTC_Family; - /* handle to cache node family */ - typedef struct FTC_FamilyRec_* FTC_Family; - - - /* handle to cache root query */ + /* handle to cache root query */ typedef struct FTC_QueryRec_* FTC_Query; - + /*************************************************************************/ /*************************************************************************/ @@ -37,22 +53,24 @@ FT_BEGIN_HEADER /* the cache. It can be an individual glyph image, a set of bitmaps */ /* glyphs for a given size, some metrics, etc. */ /* */ + /*************************************************************************/ - - /* structure size should be 20 bytes on 32-bits machines */ + /* structure size should be 20 bytes on 32-bits machines */ typedef struct FTC_NodeRec_ { FTC_Node mru_next; /* circular mru list pointer */ FTC_Node mru_prev; /* circular mru list pointer */ - FTC_Node link; /* used for hashing.. */ - FT_UInt32 hash; /* used for hashing too.. */ + FTC_Node link; /* used for hashing */ + FT_UInt32 hash; /* used for hashing too */ FT_UShort fam_index; /* index of family the node belongs to */ - FT_Short ref_count; /* reference count for this node.. */ - + FT_Short ref_count; /* reference count for this node */ + } FTC_NodeRec; -#define FTC_NODE(x) ((FTC_Node)(x)) -#define FTC_NODE_P(x) ((FTC_Node*)(x)) + +#define FTC_NODE( x ) ( (FTC_Node)(x) ) +#define FTC_NODE_P( x ) ( (FTC_Node*)(x) ) + /*************************************************************************/ /* */ @@ -66,7 +84,6 @@ FT_BEGIN_HEADER ftc_node_done( FTC_Node node, FTC_Cache cache ); - /* reserved for manager's use */ FT_EXPORT( void ) ftc_node_destroy( FTC_Node node, @@ -81,11 +98,11 @@ FT_BEGIN_HEADER /*************************************************************************/ /*************************************************************************/ - /* structure modelling a cache node query. the following fields must */ - /* all be set by the @FTC_Family_CompareFunc method of a cache's family */ - /* list */ - /* */ - typedef struct FTC_QueryRec_ + /* A structure modelling a cache node query. The following fields must */ + /* all be set by the @FTC_Family_CompareFunc method of a cache's family */ + /* list. */ + /* */ + typedef struct FTC_QueryRec_ { FTC_Family family; FT_UFast hash; @@ -93,10 +110,8 @@ FT_BEGIN_HEADER } FTC_QueryRec; -#define FTC_QUERY(x) ((FTC_Query)(x)) -#define FTC_QUERY_P(x) ((FTC_Query*)(x)) - - +#define FTC_QUERY( x ) ( (FTC_Query)(x) ) +#define FTC_QUERY_P( x ) ( (FTC_Query*)(x) ) /*************************************************************************/ @@ -107,17 +122,18 @@ FT_BEGIN_HEADER /*************************************************************************/ /*************************************************************************/ - typedef struct FTC_FamilyRec_ + typedef struct FTC_FamilyRec_ { FT_LruNodeRec lru; FTC_Cache cache; FT_UInt num_nodes; FT_UInt fam_index; - + } FTC_FamilyRec; -#define FTC_FAMILY(x) ((FTC_Family)(x)) -#define FTC_FAMILY_P(x) ((FTC_Family*)(x)) + +#define FTC_FAMILY( x ) ( (FTC_Family)(x) ) +#define FTC_FAMILY_P( x ) ( (FTC_Family*)(x) ) /*************************************************************************/ @@ -127,16 +143,16 @@ FT_BEGIN_HEADER /* cache sub-system internals. */ /* */ - /* must be called by any FTC_Node_InitFunc routine */ - FT_EXPORT(FT_Error) + /* must be called by any FTC_Node_InitFunc routine */ + FT_EXPORT( FT_Error ) ftc_family_init( FTC_Family family, FTC_Query query, FTC_Cache cache ); - /* can be used as a FTC_Family_DoneFunc, otherwise, must be called */ - /* by any family finalizer function.. */ - FT_EXPORT(void) + /* can be used as a FTC_Family_DoneFunc; otherwise, must be called */ + /* by any family finalizer function */ + FT_EXPORT( void ) ftc_family_done( FTC_Family family ); @@ -148,7 +164,7 @@ FT_BEGIN_HEADER /*************************************************************************/ /*************************************************************************/ - /* each cache really implements a dynamic hash table to manage its nodes */ + /* each cache really implements a dynamic hash table to manage its nodes */ typedef struct FTC_CacheRec_ { FTC_Manager manager; @@ -168,47 +184,57 @@ FT_BEGIN_HEADER } FTC_CacheRec; -#define FTC_CACHE(x) ((FTC_Cache)(x)) -#define FTC_CACHE_P(x) ((FTC_Cache*)(x)) +#define FTC_CACHE( x ) ( (FTC_Cache)(x) ) +#define FTC_CACHE_P( x ) ( (FTC_Cache*)(x) ) /* initialize a given cache */ - typedef FT_Error (*FTC_Cache_InitFunc)( FTC_Cache cache ); + typedef FT_Error + (*FTC_Cache_InitFunc)( FTC_Cache cache ); /* clear a cache */ - typedef void (*FTC_Cache_ClearFunc)( FTC_Cache cache ); - - /* finalize a given cache */ - typedef void (*FTC_Cache_DoneFunc)( FTC_Cache cache ); + typedef void + (*FTC_Cache_ClearFunc)( FTC_Cache cache ); + + /* finalize a given cache */ + typedef void + (*FTC_Cache_DoneFunc)( FTC_Cache cache ); + + typedef FT_Error + (*FTC_Family_InitFunc)( FTC_Family family, + FTC_Query query, + FTC_Cache cache ); - typedef FT_Error (*FTC_Family_InitFunc)( FTC_Family family, - FTC_Query query, - FTC_Cache cache ); + typedef FT_Int + (*FTC_Family_CompareFunc)( FTC_Family family, + FTC_Query query ); - typedef FT_Int (*FTC_Family_CompareFunc)( FTC_Family family, - FTC_Query query ); + typedef void + (*FTC_Family_DoneFunc)( FTC_Family family, + FTC_Cache cache ); - typedef void (*FTC_Family_DoneFunc)( FTC_Family family, - FTC_Cache cache ); - - /* initialize a new cache node */ - typedef FT_Error (*FTC_Node_InitFunc)( FTC_Node node, - FT_Pointer type, - FTC_Cache cache ); + /* initialize a new cache node */ + typedef FT_Error + (*FTC_Node_InitFunc)( FTC_Node node, + FT_Pointer type, + FTC_Cache cache ); /* compute the weight of a given cache node */ - typedef FT_ULong (*FTC_Node_WeightFunc)( FTC_Node node, - FTC_Cache cache ); + typedef FT_ULong + (*FTC_Node_WeightFunc)( FTC_Node node, + FTC_Cache cache ); /* compare a node to a given key pair */ - typedef FT_Bool (*FTC_Node_CompareFunc)( FTC_Node node, - FT_Pointer key, - FTC_Cache cache ); + typedef FT_Bool + (*FTC_Node_CompareFunc)( FTC_Node node, + FT_Pointer key, + FTC_Cache cache ); /* finalize a given cache node */ - typedef void (*FTC_Node_DoneFunc)( FTC_Node node, - FTC_Cache cache ); + typedef void + (*FTC_Node_DoneFunc)( FTC_Node node, + FTC_Cache cache ); typedef struct FTC_Cache_ClassRec_ @@ -222,17 +248,19 @@ FT_BEGIN_HEADER FTC_Family_InitFunc family_init; FTC_Family_CompareFunc family_compare; FTC_Family_DoneFunc family_done; - + FT_UInt node_size; FTC_Node_InitFunc node_init; FTC_Node_WeightFunc node_weight; FTC_Node_CompareFunc node_compare; FTC_Node_DoneFunc node_done; - + } FTC_Cache_ClassRec; + /* */ + /*************************************************************************/ /* */ /* These functions are exported so that they can be called from */ @@ -245,28 +273,28 @@ FT_BEGIN_HEADER FT_EXPORT( void ) ftc_cache_done( FTC_Cache cache ); - /* can be used directly as FTC_Cache_ClearFunc(), or called by custom */ - /* cache clear routines.. */ + /* cache clear routines */ FT_EXPORT( void ) ftc_cache_clear( FTC_Cache cache ); - /* initalize the hash table within the cache */ FT_EXPORT( FT_Error ) ftc_cache_init( FTC_Cache cache ); + /* can be called when the key's hash value has been computed */ + FT_EXPORT( FT_Error ) + ftc_cache_lookup( FTC_Cache cache, + FTC_Query query, + FTC_Node *anode ); + + /* */ - /* can be called when the key's hash value has been computed */ - FT_EXPORT(FT_Error) - ftc_cache_lookup( FTC_Cache cache, - FTC_Query query, - FTC_Node *anode ); +FT_END_HEADER - /* */ +#endif /* __FTCCACHE_H__ */ -FT_END_HEADER -#endif /* __FT_CACHE_CACHE_H__ */ +/* END */ diff --git a/include/freetype/cache/ftccmap.h b/include/freetype/cache/ftccmap.h index 3966016bb..03f44bb56 100644 --- a/include/freetype/cache/ftccmap.h +++ b/include/freetype/cache/ftccmap.h @@ -2,7 +2,7 @@ /* */ /* ftccmap.h */ /* */ -/* FreeType charmap cache */ +/* FreeType charmap cache (specification). */ /* */ /* Copyright 2000-2001 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -15,111 +15,119 @@ /* */ /***************************************************************************/ -#ifndef __FT_CACHE_CHARMAP_H__ -#define __FT_CACHE_CHARMAP_H__ + +#ifndef __FTCCMAP_H__ +#define __FTCCMAP_H__ #include #include FT_CACHE_H + FT_BEGIN_HEADER - /************************************************************************ - * - * @type: FTC_CmapCache - * - * @description: - * opaque handle used to manager a charmap cache. This cache is used - * to hold character codes -> glyph indices mappings - */ - typedef struct FTC_CMapCacheRec_* FTC_CMapCache; - - - /************************************************************************ - * - * @type: FTC_CMapDesc - * - * @description: - * handle to a @FTC_CMapDescRec structure used to describe a given charmap - * in a charmap cache. - * - * each @FTC_CMapDesc describes which charmap, of which @FTC_Face we - * want to use in @FTC_CMapCache_Lookup - */ - typedef struct FTC_CMapDescRec_* FTC_CMapDesc; - - - /************************************************************************ - * - * @enum: FTC_CMapType - * - * @description: - * the list of valid @FTC_CMap types, they indicate how we want to - * address a charmap within a @FTC_FaceID - * - * @values: - * FTC_CMAP_BY_INDEX :: - * used to indicate that we want to address a charmap by its index in - * the corresponding @FT_Face - * - * FTC_CMAP_BY_ENCODING :: - * used to indicate that we want to use a @FT_Face charmap that - * corresponds to a given encoding - * - * FTC_CMAP_BY_ID :: - * used to indicate that we want to use a @FT_Face charmap that - * corresponds to a given (platform,encoding) id. see @FTC_CMapIdRec - */ - typedef enum + + /*************************************************************************/ + /* */ + /* @type: */ + /* FTC_CmapCache */ + /* */ + /* @description: */ + /* An opaque handle used to manager a charmap cache. This cache is */ + /* to hold character codes -> glyph indices mappings. */ + /* */ + typedef struct FTC_CMapCacheRec_* FTC_CMapCache; + + + /*************************************************************************/ + /* */ + /* @type: */ + /* FTC_CMapDesc */ + /* */ + /* @description: */ + /* A handle to an @FTC_CMapDescRec structure used to describe a given */ + /* charmap in a charmap cache. */ + /* */ + /* Each @FTC_CMapDesc describes which charmap (of which @FTC_Face) we */ + /* want to use in @FTC_CMapCache_Lookup. */ + /* */ + typedef struct FTC_CMapDescRec_* FTC_CMapDesc; + + + /*************************************************************************/ + /* */ + /* @enum: */ + /* FTC_CMapType */ + /* */ + /* @description: */ + /* The list of valid @FTC_CMap types. They indicate how we want to */ + /* address a charmap within an @FTC_FaceID. */ + /* */ + /* @values: */ + /* FTC_CMAP_BY_INDEX :: */ + /* Address a charmap by its index in the corresponding @FT_Face. */ + /* */ + /* FTC_CMAP_BY_ENCODING :: */ + /* Use a @FT_Face charmap that corresponds to a given encoding. */ + /* */ + /* FTC_CMAP_BY_ID :: */ + /* Use an @FT_Face charmap that corresponds to a given */ + /* (platform,encoding) ID. See @FTC_CMapIdRec. */ + /* */ + typedef enum FTC_CMapType_ { FTC_CMAP_BY_INDEX = 0, FTC_CMAP_BY_ENCODING = 1, FTC_CMAP_BY_ID = 2 - + } FTC_CMapType; - /************************************************************************ - * - * @struct: FTC_CMapIdRec - * - * @description: - * a short structure used to identify a charmap by a (platform,encoding) - * pair of values - * - * @fields: - * platform :: platform ID - * encoding :: encoding ID - */ - typedef struct FTC_CMapIdRec_ + /*************************************************************************/ + /* */ + /* @struct: */ + /* FTC_CMapIdRec */ + /* */ + /* @description: */ + /* A short structure to identify a charmap by a (platform,encoding) */ + /* pair of values. */ + /* */ + /* @fields: */ + /* platform :: The platform ID. */ + /* */ + /* encoding :: The encoding ID. */ + /* */ + typedef struct FTC_CMapIdRec_ { FT_UInt platform; FT_UInt encoding; - + } FTC_CMapIdRec; - /************************************************************************ - * - * @struct: FTC_CMapDescRec - * - * @description: - * a structure used to describe a given charmap to the @FTC_CMapCache - * - * @fields: - * face_id :: @FTC_FaceID of the face this charmap belongs to - * type :: type of charmap, see @FTC_CMapType - * - * u.index :: for @FTC_CMAP_BY_INDEX types, this is the charmap index - * (within a @FT_Face) we want to use. - * - * u.encoding :: for @FTC_CMAP_BY_ENCODING types, this is the charmap - * encoding we want to use. see @FT_Encoding - * - * u.id :: for @FTC_CMAP_BY_ID types, this is the (platform,encoding) - * pair we want to use. see @FTC_CMapIdRec and - * @FT_CharMapRec - */ - typedef struct FTC_CMapDescRec_ + /*************************************************************************/ + /* */ + /* @struct: */ + /* FTC_CMapDescRec */ + /* */ + /* @description: */ + /* A structure to describe a given charmap to @FTC_CMapCache. */ + /* */ + /* @fields: */ + /* face_id :: @FTC_FaceID of the face this charmap belongs to. */ + /* */ + /* type :: The type of charmap, see @FTC_CMapType. */ + /* */ + /* u.index :: For @FTC_CMAP_BY_INDEX types, this is the charmap */ + /* index (within a @FT_Face) we want to use. */ + /* */ + /* u.encoding :: For @FTC_CMAP_BY_ENCODING types, this is the charmap */ + /* encoding we want to use. see @FT_Encoding. */ + /* */ + /* u.id :: For @FTC_CMAP_BY_ID types, this is the */ + /* (platform,encoding) pair we want to use. see */ + /* @FTC_CMapIdRec and @FT_CharMapRec. */ + /* */ + typedef struct FTC_CMapDescRec_ { FTC_FaceID face_id; FTC_CMapType type; @@ -129,67 +137,73 @@ FT_BEGIN_HEADER FT_UInt index; FT_Encoding encoding; FTC_CMapIdRec id; - + } u; - - } FTC_CMapDescRec; + } FTC_CMapDescRec; - /************************************************************************ - * - * @function: FTC_CMapCache_New - * - * @description: - * create a new charmap cache - * - * @input: - * manager :: handle to cache manager - * - * @output: - * acache :: new cache handle. NULL in case of error - * - * @return: - * FreeType error code. 0 means success - * - * @note: - * like all other caches, this one will be destroyed with the - * cache manager - */ + /*************************************************************************/ + /* */ + /* @function: */ + /* FTC_CMapCache_New */ + /* */ + /* @description: */ + /* Creates a new charmap cache. */ + /* */ + /* @input: */ + /* manager :: A handle to the cache manager. */ + /* */ + /* @output: */ + /* acache :: A new cache handle. NULL in case of error. */ + /* */ + /* @return: */ + /* FreeType error code. 0 means success. */ + /* */ + /* @note: */ + /* Like all other caches, this one will be destroyed with the cache */ + /* manager. */ + /* */ FT_EXPORT( FT_Error ) FTC_CMapCache_New( FTC_Manager manager, FTC_CMapCache *acache ); - - /************************************************************************ - * - * @function: FTC_CMapCache_Lookup - * - * @description: - * translate a character code into a glyph index, using the charmap - * cache. - * - * @input: - * cache :: charmap cache handle - * cmap_desc :: charmap descriptor handle - * char_code :: character code (in the corresponding charmap) - * - * @return: - * glyph index. 0 means "no glyph" !! - * - * @note: - * this function doesn't return @FTC_Node handles, since there is - * no real use for them with typical uses of charmaps - */ + /*************************************************************************/ + /* */ + /* @function: */ + /* FTC_CMapCache_Lookup */ + /* */ + /* @description: */ + /* Translates a character code into a glyph index, using the charmap */ + /* cache. */ + /* */ + /* @input: */ + /* cache :: A charmap cache handle. */ + /* */ + /* cmap_desc :: A charmap descriptor handle. */ + /* */ + /* char_code :: The character code (in the corresponding charmap). */ + /* */ + /* @return: */ + /* Glyph index. 0 means "no glyph". */ + /* */ + /* @note: */ + /* This function doesn't return @FTC_Node handles, since there is no */ + /* real use for them with typical uses of charmaps. */ + /* */ FT_EXPORT( FT_UInt ) FTC_CMapCache_Lookup( FTC_CMapCache cache, FTC_CMapDesc cmap_desc, FT_UInt32 char_code ); + /* */ - /* */ FT_END_HEADER -#endif /* __FT_CACHE_CHARMAP_H__ */ + +#endif /* __FTCCMAP_H__ */ + + +/* END */ diff --git a/include/freetype/cache/ftcglyph.h b/include/freetype/cache/ftcglyph.h index bf9108b57..ab88edbb6 100644 --- a/include/freetype/cache/ftcglyph.h +++ b/include/freetype/cache/ftcglyph.h @@ -64,18 +64,18 @@ FT_BEGIN_HEADER - /* each glyph set is caracterized by a "glyph set type" which must be */ - /* defined by sub-classes.. */ - typedef struct FTC_GlyphFamilyRec_* FTC_GlyphFamily; + /* each glyph set is characterized by a "glyph set type" which must be */ + /* defined by sub-classes */ + typedef struct FTC_GlyphFamilyRec_* FTC_GlyphFamily; - /* handle to a glyph cache node */ - typedef struct FTC_GlyphNodeRec_* FTC_GlyphNode; + /* handle to a glyph cache node */ + typedef struct FTC_GlyphNodeRec_* FTC_GlyphNode; - /* size should be 24 + chunk size on 32-bit machines */ - /* note that the node's hash is ((gfam->hash << 16) | glyph_index) */ - /* this _must_ be set properly by the glyph node initializer.. */ - /* */ + /* size should be 24 + chunk size on 32-bit machines; */ + /* note that the node's hash is ((gfam->hash << 16) | glyph_index) -- */ + /* this _must_ be set properly by the glyph node initializer */ + /* */ typedef struct FTC_GlyphNodeRec_ { FTC_NodeRec node; @@ -84,9 +84,9 @@ FT_BEGIN_HEADER } FTC_GlyphNodeRec; -#define FTC_GLYPH_NODE(x) ((FTC_GlyphNode)(x)) -#define FTC_GLYPH_NODE_P(x) ((FTC_GlyphNode*)(x)) +#define FTC_GLYPH_NODE( x ) ( (FTC_GlyphNode)(x) ) +#define FTC_GLYPH_NODE_P( x ) ( (FTC_GlyphNode*)(x) ) typedef struct FTC_GlyphQueryRec_ @@ -96,13 +96,12 @@ FT_BEGIN_HEADER } FTC_GlyphQueryRec, *FTC_GlyphQuery; -#define FTC_GLYPH_QUERY(x) ((FTC_GlyphQuery)(x)) +#define FTC_GLYPH_QUERY( x ) ( (FTC_GlyphQuery)(x) ) - - /* a glyph set is used to categorize glyphs of a given type */ - typedef struct FTC_GlyphFamilyRec_ + /* a glyph set is used to categorize glyphs of a given type */ + typedef struct FTC_GlyphFamilyRec_ { FTC_FamilyRec family; FT_UInt32 hash; @@ -112,42 +111,43 @@ FT_BEGIN_HEADER } FTC_GlyphFamilyRec; -#define FTC_GLYPH_FAMILY(x) ((FTC_GlyphFamily)(x)) -#define FTC_GLYPH_FAMILY_P(x) ((FTC_GlyphFamily*)(x)) +#define FTC_GLYPH_FAMILY( x ) ( (FTC_GlyphFamily)(x) ) +#define FTC_GLYPH_FAMILY_P( x ) ( (FTC_GlyphFamily*)(x) ) -#define FTC_GLYPH_FAMILY_MEMORY(x) FTC_FAMILY(x)->cache->memory +#define FTC_GLYPH_FAMILY_MEMORY( x ) FTC_FAMILY(x)->cache->memory -/* each glyph node contains a 'chunk' of glyph items */ -/* translate a glyph index into a chunk index */ -#define FTC_GLYPH_FAMILY_CHUNK(gfam,gindex) \ - ( (gindex) / FTC_GLYPH_FAMILY(gfam)->item_count ) -/* find a glyph index's chunk, and return its start index */ -/* */ -#define FTC_GLYPH_FAMILY_START(gfam,gindex) \ - ( FTC_GLYPH_FAMILY_CHUNK(gfam,gindex) * FTC_GLYPH_FAMILY(gfam)->item_count ) + /* each glyph node contains a 'chunk' of glyph items; */ + /* translate a glyph index into a chunk index */ +#define FTC_GLYPH_FAMILY_CHUNK( gfam, gindex ) \ + ( ( gindex ) / FTC_GLYPH_FAMILY( gfam )->item_count ) -/* compute a glyph request's hash value */ -/* */ -#define FTC_GLYPH_FAMILY_HASH(gfam,gindex) \ - ((FT_UFast)( (FTC_GLYPH_FAMILY(gfam)->hash << 16) | \ - (FTC_GLYPH_FAMILY_CHUNK(gfam,gindex) & 0xFFFF) )) + /* find a glyph index's chunk, and return its start index */ +#define FTC_GLYPH_FAMILY_START( gfam, gindex ) \ + ( FTC_GLYPH_FAMILY_CHUNK( gfam, gindex ) * \ + FTC_GLYPH_FAMILY( gfam )->item_count ) -/* must be called in a FTC_Family_CompareFunc to update the query */ -/* whenever a glyph set is matched in the lookup.. or when it */ -/* is created */ -/* */ -#define FTC_GLYPH_FAMILY_FOUND(gfam,gquery) \ - do { \ - FTC_QUERY(gquery)->family = FTC_FAMILY(gfam); \ - FTC_QUERY(gquery)->hash = \ - FTC_GLYPH_FAMILY_HASH(gfam,FTC_GLYPH_QUERY(gquery)->gindex); \ - } while (0) + /* compute a glyph request's hash value */ +#define FTC_GLYPH_FAMILY_HASH( gfam, gindex ) \ + ( (FT_UFast)( \ + ( FTC_GLYPH_FAMILY( gfam )->hash << 16 ) | \ + ( FTC_GLYPH_FAMILY_CHUNK( gfam, gindex ) & 0xFFFF ) ) ) + /* must be called in an FTC_Family_CompareFunc to update the query */ + /* whenever a glyph set is matched in the lookup, or when it */ + /* is created */ +#define FTC_GLYPH_FAMILY_FOUND( gfam, gquery ) \ + do \ + { \ + FTC_QUERY( gquery )->family = FTC_FAMILY( gfam ); \ + FTC_QUERY( gquery )->hash = \ + FTC_GLYPH_FAMILY_HASH( gfam, \ + FTC_GLYPH_QUERY( gquery )->gindex ); \ + } while ( 0 ) -/* retrieve glyph index of glyph node */ -#define FTC_GLYPH_NODE_GINDEX(x) \ - ((FT_UInt)(FTC_GLYPH_NODE(x)->node.hash & 0xFFFF)) + /* retrieve glyph index of glyph node */ +#define FTC_GLYPH_NODE_GINDEX( x ) \ + ( (FT_UInt)( FTC_GLYPH_NODE( x )->node.hash & 0xFFFF ) ) /*************************************************************************/ @@ -159,18 +159,16 @@ FT_BEGIN_HEADER /* must be called by derived FTC_Node_InitFunc routines */ FT_EXPORT( void ) - ftc_glyph_node_init( FTC_GlyphNode node, - FT_UInt gindex, /* glyph index for node */ - FTC_GlyphFamily gfam ); - - /* returns TRUE iff the query's glyph index correspond to the node */ - /* this assume that the "family" and "hash" fields of the query are */ - /* already correctly set.. */ - /* */ - FT_EXPORT( FT_Bool ) - ftc_glyph_node_compare( FTC_GlyphNode gnode, - FTC_GlyphQuery gquery ); + ftc_glyph_node_init( FTC_GlyphNode node, + FT_UInt gindex, /* glyph index for node */ + FTC_GlyphFamily gfam ); + /* returns TRUE iff the query's glyph index correspond to the node; */ + /* this assumes that the "family" and "hash" fields of the query are */ + /* already correctly set */ + FT_EXPORT( FT_Bool ) + ftc_glyph_node_compare( FTC_GlyphNode gnode, + FTC_GlyphQuery gquery ); /* must be called by derived FTC_Node_DoneFunc routines */ FT_EXPORT( void ) @@ -178,7 +176,8 @@ FT_BEGIN_HEADER FTC_Cache cache ); - /* must be called by derived FTC_Family_InitFunc, calls "ftc_family_init" */ + /* must be called by derived FTC_Family_InitFunc; */ + /* calls "ftc_family_init" */ FT_EXPORT( FT_Error ) ftc_glyph_family_init( FTC_GlyphFamily gfam, FT_UInt32 hash, @@ -187,14 +186,16 @@ FT_BEGIN_HEADER FTC_GlyphQuery gquery, FTC_Cache cache ); - FT_EXPORT( void ) ftc_glyph_family_done( FTC_GlyphFamily gfam ); - - /* */ + /* */ FT_END_HEADER -#endif /* __FTC_GLYPH_H__ */ + +#endif /* __FTCGLYPH_H__ */ + + +/* END */ diff --git a/include/freetype/cache/ftcimage.h b/include/freetype/cache/ftcimage.h index 7614c1ba1..a8a4508a5 100644 --- a/include/freetype/cache/ftcimage.h +++ b/include/freetype/cache/ftcimage.h @@ -2,7 +2,7 @@ /* */ /* ftcimage.h */ /* */ -/* FreeType Image cache (body). */ +/* FreeType Image cache (specification). */ /* */ /* Copyright 2000-2001 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -56,16 +56,16 @@ FT_BEGIN_HEADER #define FTC_IMAGE_FORMAT( x ) ( (x) & 7 ) -#define ftc_image_format_bitmap 0x0000 -#define ftc_image_format_outline 0x0001 +#define ftc_image_format_bitmap 0x0000 +#define ftc_image_format_outline 0x0001 -#define ftc_image_format_mask 0x000F +#define ftc_image_format_mask 0x000F -#define ftc_image_flag_monochrome 0x0010 -#define ftc_image_flag_unhinted 0x0020 -#define ftc_image_flag_autohinted 0x0040 -#define ftc_image_flag_unscaled 0x0080 -#define ftc_image_flag_no_sbits 0x0100 +#define ftc_image_flag_monochrome 0x0010 +#define ftc_image_flag_unhinted 0x0020 +#define ftc_image_flag_autohinted 0x0040 +#define ftc_image_flag_unscaled 0x0080 +#define ftc_image_flag_no_sbits 0x0100 /* monochrome bitmap */ #define ftc_image_mono ftc_image_format_bitmap | \ @@ -85,16 +85,16 @@ FT_BEGIN_HEADER /* */ /* */ /* A simple structure used to describe a given glyph image category. */ - /* note that this is different from @FTC_Image_Desc */ + /* Note that this is different from @FTC_Image_Desc. */ /* */ /* */ - /* size :: An FTC_SizeRec used to describe the glyph's face & */ + /* size :: An @FTC_SizeRec used to describe the glyph's face and */ /* size. */ /* */ - /* type :: The glyph image's type. note that it's a 32-bit uint */ + /* type :: The glyph image's type. Note that it is a 32-bit uint. */ /* */ /* */ - /* this type deprecates @FTC_Image_Desc */ + /* This type deprecates @FTC_Image_Desc. */ /* */ typedef struct FTC_ImageDesc_ { @@ -104,13 +104,15 @@ FT_BEGIN_HEADER } FTC_ImageDesc; /* */ -#define FTC_IMAGE_DESC_COMPARE( d1, d2 ) \ - ( FTC_FONT_COMPARE( &(d1)->font, &(d2)->font ) && \ - (d1)->type == (d2)->type ) -#define FTC_IMAGE_DESC_HASH(d) \ - (FT_UFast)( FTC_FONT_HASH(&(d)->font) ^ \ - ((d)->type << 4) ) +#define FTC_IMAGE_DESC_COMPARE( d1, d2 ) \ + ( FTC_FONT_COMPARE( &(d1)->font, &(d2)->font ) && \ + (d1)->type == (d2)->type ) + +#define FTC_IMAGE_DESC_HASH( d ) \ + (FT_UFast)( FTC_FONT_HASH( &(d)->font ) ^ \ + ( (d)->type << 4 ) ) + /*************************************************************************/ /* */ @@ -119,7 +121,7 @@ FT_BEGIN_HEADER /* */ /* */ /* A handle to an glyph image cache object. They are designed to */ - /* hold many distinct glyph images, while not exceeding a certain */ + /* hold many distinct glyph images while not exceeding a certain */ /* memory threshold. */ /* */ typedef struct FTC_ImageCacheRec_* FTC_ImageCache; @@ -153,10 +155,9 @@ FT_BEGIN_HEADER /* FTC_ImageCache_Lookup */ /* */ /* */ - /* Retrieves a given glyph image from a glyph image cache */ - /* and 'acquire' it. This prevents the glyph image from being */ - /* flushed out of the cache, until @FTC_Image_Cache_Release is */ - /* called */ + /* Retrieves a given glyph image from a glyph image cache and */ + /* `acquires' it. This prevents the glyph image from being flushed */ + /* out of the cache, until @FTC_Image_Cache_Release is called. */ /* */ /* */ /* cache :: A handle to the source glyph image cache. */ @@ -166,13 +167,13 @@ FT_BEGIN_HEADER /* gindex :: The glyph index to retrieve. */ /* */ /* */ - /* aglyph :: The corresponding FT_Glyph object. 0 in case of */ + /* aglyph :: The corresponding @FT_Glyph object. 0 in case of */ /* failure. */ /* */ - /* anode :: an opaque cache node pointer that will be used */ - /* to release the glyph once it becomes unuseful. */ - /* can be NULL, in which case this function will */ - /* have the same effect than @FTC_Image_Cache_Lookup */ + /* anode :: An opaque cache node pointer that will be used to */ + /* release the glyph once it becomes unuseful. Can be */ + /* NULL, in which case this function will have the same */ + /* effect as @FTC_Image_Cache_Release. XXX */ /* */ /* */ /* FreeType error code. 0 means success. */ @@ -180,20 +181,19 @@ FT_BEGIN_HEADER /* */ /* The returned glyph is owned and managed by the glyph image cache. */ /* Never try to transform or discard it manually! You can however */ - /* create a copy with FT_Glyph_Copy() and modify the new one. */ - /* */ - /* if 'anode' is NULL */ + /* create a copy with @FT_Glyph_Copy and modify the new one. */ /* */ /* Because the glyph image cache limits the total amount of memory */ /* taken by the glyphs it holds, the returned glyph might disappear */ - /* on a later invocation of this function! It's a cache after all... */ + /* on a later invocation of this function! It is a cache after */ + /* all... */ /* */ FT_EXPORT( FT_Error ) FTC_ImageCache_Lookup( FTC_ImageCache cache, FTC_ImageDesc* desc, - FT_UInt gindex, - FT_Glyph *aglyph, - FTC_Node *anode ); + FT_UInt gindex, + FT_Glyph *aglyph, + FTC_Node *anode ); /* */ @@ -204,18 +204,16 @@ FT_BEGIN_HEADER /* FTC_Image_Desc */ /* */ /* */ - /* THIS TYPE IS DEPRECATED. USE @FTC_ImageDesc instead.. */ + /* THIS TYPE IS DEPRECATED. Use @FTC_ImageDesc instead. */ + /* */ /* A simple structure used to describe a given glyph image category. */ /* */ /* */ - /* size :: An FTC_SizeRec used to describe the glyph's face & */ - /* size. */ + /* size :: An @FTC_SizeRec used to describe the glyph's face */ + /* and size. */ /* */ /* image_type :: The glyph image's type. */ /* */ - /* */ - /* */ - /* */ typedef struct FTC_Image_Desc_ { FTC_FontRec font; @@ -230,19 +228,19 @@ FT_BEGIN_HEADER /* FTC_Image_Cache */ /* */ /* */ - /* THIS TYPE IS DEPRECATED, USE @FTC_ImageCache instead */ + /* THIS TYPE IS DEPRECATED. Use @FTC_ImageCache instead. */ /* */ typedef FTC_ImageCache FTC_Image_Cache; - /*************************************************************************/ /* */ /* */ /* FTC_Image_Cache_New */ /* */ /* */ - /* THIS FUNCTION IS DEPRECATED, USE @FTC_ImageCache_New instead */ + /* THIS FUNCTION IS DEPRECATED. Use @FTC_ImageCache_New instead. */ + /* */ /* Creates a new glyph image cache. */ /* */ /* */ @@ -265,7 +263,7 @@ FT_BEGIN_HEADER /* FTC_Image_Cache_Lookup */ /* */ /* */ - /* THIS FUNCTION IS DEPRECATED. USE @FTC_ImageCache_Lookup instead */ + /* THIS FUNCTION IS DEPRECATED. Use @FTC_ImageCache_Lookup instead. */ /* */ /* */ /* cache :: A handle to the source glyph image cache. */ @@ -275,7 +273,7 @@ FT_BEGIN_HEADER /* gindex :: The glyph index to retrieve. */ /* */ /* */ - /* aglyph :: The corresponding FT_Glyph object. 0 in case of */ + /* aglyph :: The corresponding @FT_Glyph object. 0 in case of */ /* failure. */ /* */ /* */ @@ -284,14 +282,14 @@ FT_BEGIN_HEADER /* */ /* The returned glyph is owned and managed by the glyph image cache. */ /* Never try to transform or discard it manually! You can however */ - /* create a copy with FT_Glyph_Copy() and modify the new one. */ + /* create a copy with @FT_Glyph_Copy and modify the new one. */ /* */ /* Because the glyph image cache limits the total amount of memory */ /* taken by the glyphs it holds, the returned glyph might disappear */ - /* on a later invocation of this function! It's a cache after all... */ + /* on a later invocation of this function! It is a cache after */ + /* all... */ /* */ - /* use @FTC_ImageCache_Lookup to "lock" the glyph as long as you */ - /* need it.. */ + /* Use this function to "lock" the glyph as long as it is needed. */ /* */ FT_EXPORT( FT_Error ) FTC_Image_Cache_Lookup( FTC_Image_Cache cache, @@ -303,6 +301,7 @@ FT_BEGIN_HEADER FT_END_HEADER + #endif /* __FTCIMAGE_H__ */ diff --git a/include/freetype/cache/ftcmanag.h b/include/freetype/cache/ftcmanag.h index 712101fea..44e2dab85 100644 --- a/include/freetype/cache/ftcmanag.h +++ b/include/freetype/cache/ftcmanag.h @@ -23,7 +23,7 @@ /* - Maintain a mapping between generic FTC_FaceIDs and live FT_Face */ /* objects. The mapping itself is performed through a user-provided */ /* callback. However, the manager maintains a small cache of FT_Face */ - /* & FT_Size objects in order to speed up things considerably. */ + /* and FT_Size objects in order to speed up things considerably. */ /* */ /* - Manage one or more cache objects. Each cache is in charge of */ /* holding a varying number of `cache nodes'. Each cache node */ @@ -68,6 +68,7 @@ #include FT_CACHE_INTERNAL_LRU_H #include FT_CACHE_INTERNAL_CACHE_H + FT_BEGIN_HEADER @@ -81,24 +82,26 @@ FT_BEGIN_HEADER #define FTC_MAX_FACES_DEFAULT 2 #define FTC_MAX_SIZES_DEFAULT 4 -#define FTC_MAX_BYTES_DEFAULT 200000L /* ~200 KB bytes by default */ +#define FTC_MAX_BYTES_DEFAULT 200000L /* ~200kByte by default */ /* maximum number of caches registered in a single manager */ #define FTC_MAX_CACHES 16 - typedef struct FTC_FamilyEntryRec_ + typedef struct FTC_FamilyEntryRec_ { - FTC_Family family; - FTC_Cache cache; - FT_UInt index; - FT_UInt link; + FTC_Family family; + FTC_Cache cache; + FT_UInt index; + FT_UInt link; } FTC_FamilyEntryRec, *FTC_FamilyEntry; -#define FTC_FAMILY_ENTRY_NONE ((FT_UInt)-1) - typedef struct FTC_FamilyTableRec_ +#define FTC_FAMILY_ENTRY_NONE ( (FT_UInt)-1 ) + + + typedef struct FTC_FamilyTableRec_ { FT_UInt count; FT_UInt size; @@ -113,7 +116,6 @@ FT_BEGIN_HEADER FT_Memory memory, FTC_FamilyEntry *aentry ); - FT_EXPORT( void ) ftc_family_table_free( FTC_FamilyTable table, FT_UInt index ); @@ -130,9 +132,9 @@ FT_BEGIN_HEADER /* */ /* library :: A handle to a FreeType library instance. */ /* */ - /* faces_list :: The lru list of FT_Face objects in the cache. */ + /* faces_list :: The lru list of @FT_Face objects in the cache. */ /* */ - /* sizes_list :: The lru list of FT_Size objects in the cache. */ + /* sizes_list :: The lru list of @FT_Size objects in the cache. */ /* */ /* max_weight :: The maximum cache pool weight. */ /* */ @@ -147,8 +149,10 @@ FT_BEGIN_HEADER /* request_data :: User-provided data passed to the requester. */ /* */ /* request_face :: User-provided function used to implement a mapping */ - /* between abstract FTC_FaceIDs and real FT_Face */ - /* objects. */ + /* between abstract @FTC_FaceID values and real */ + /* @FT_Face objects. */ + /* */ + /* families :: XXX */ /* */ typedef struct FTC_ManagerRec_ { @@ -167,7 +171,7 @@ FT_BEGIN_HEADER FT_Pointer request_data; FTC_Face_Requester request_face; - FTC_FamilyTableRec families; + FTC_FamilyTableRec families; } FTC_ManagerRec; @@ -204,8 +208,8 @@ FT_BEGIN_HEADER FTC_Cache *acache ); - /* can be called to increment a node's reference count */ - FT_EXPORT(void) + /* can be called to increment a node's reference count */ + FT_EXPORT( void ) FTC_Node_Ref( FTC_Node node, FTC_Manager manager ); @@ -233,6 +237,7 @@ FT_BEGIN_HEADER FT_END_HEADER + #endif /* __FTCMANAG_H__ */ diff --git a/include/freetype/cache/ftcsbits.h b/include/freetype/cache/ftcsbits.h index d051b7c71..8e04c8946 100644 --- a/include/freetype/cache/ftcsbits.h +++ b/include/freetype/cache/ftcsbits.h @@ -42,7 +42,7 @@ FT_BEGIN_HEADER /* FTC_SBit */ /* */ /* */ - /* A handle to a small bitmap descriptor. See the FTC_SBitRec */ + /* A handle to a small bitmap descriptor. See the @FTC_SBitRec */ /* structure for details. */ /* */ typedef struct FTC_SBitRec_* FTC_SBit; @@ -98,31 +98,29 @@ FT_BEGIN_HEADER } FTC_SBitRec; - /*************************************************************************/ /* */ /* */ - /* FTC_SBit_Cache */ + /* FTC_SBitCache */ /* */ /* */ /* A handle to a small bitmap cache. These are special cache objects */ /* used to store small glyph bitmaps (and anti-aliased pixmaps) in a */ /* much more efficient way than the traditional glyph image cache */ - /* implemented by FTC_Image_Cache. */ + /* implemented by @FTC_ImageCache. */ /* */ - typedef struct FTC_SBitCacheRec_* FTC_SBitCache; + typedef struct FTC_SBitCacheRec_* FTC_SBitCache; + /*************************************************************************/ /* */ /* */ /* FTC_SBit_Cache */ /* */ /* */ - /* deprecated. please use @FTC_SBitCache instead */ + /* DEPRECATED. Use @FTC_SBitCache instead. */ /* */ - typedef FTC_SBitCache FTC_SBit_Cache; - - + typedef FTC_SBitCache FTC_SBit_Cache; /*************************************************************************/ @@ -158,16 +156,18 @@ FT_BEGIN_HEADER /* */ /* */ /* cache :: A handle to the source sbit cache. */ + /* */ /* desc :: A pointer to the glyph image descriptor. */ + /* */ /* gindex :: The glyph index. */ /* */ /* */ /* sbit :: A handle to a small bitmap descriptor. */ /* */ - /* anode :: an opaque cache node pointer that will be used */ + /* anode :: An opaque cache node pointer that will be used */ /* to release the sbit once it becomes unuseful. */ - /* can be NULL, in which case this function will */ - /* have the same effect than @FTC_SBit_Cache_Lookup */ + /* Can be NULL, in which case this function will */ + /* have the same effect as @FTC_SBitCache_Lookup. XXX */ /* */ /* */ /* FreeType error code. 0 means success. */ @@ -198,6 +198,8 @@ FT_BEGIN_HEADER /* FTC_SBit_Cache_New */ /* */ /* */ + /* DEPRECATED. Use @FTC_SBitCache_New instead. */ + /* */ /* Creates a new cache to store small glyph bitmaps. */ /* */ /* */ @@ -220,11 +222,15 @@ FT_BEGIN_HEADER /* FTC_SBit_Cache_Lookup */ /* */ /* */ + /* DEPRECATED. Use @FTC_SBitCache_Lookup instead. */ + /* */ /* Looks up a given small glyph bitmap in a given sbit cache. */ /* */ /* */ /* cache :: A handle to the source sbit cache. */ + /* */ /* desc :: A pointer to the glyph image descriptor. */ + /* */ /* gindex :: The glyph index. */ /* */ /* */ diff --git a/include/freetype/cache/ftlru.h b/include/freetype/cache/ftlru.h index 9d51e571a..9e4507efa 100644 --- a/include/freetype/cache/ftlru.h +++ b/include/freetype/cache/ftlru.h @@ -19,7 +19,7 @@ /*************************************************************************/ /* */ /* An LRU is a list that cannot hold more than a certain number of */ - /* elements (`max_elements'). All elements on the list are sorted in */ + /* elements (`max_elements'). All elements in the list are sorted in */ /* least-recently-used order, i.e., the `oldest' element is at the tail */ /* of the list. */ /* */ @@ -58,22 +58,25 @@ #ifndef __FTLRU_H__ #define __FTLRU_H__ + #include #include FT_FREETYPE_H + FT_BEGIN_HEADER + /* generic list key type */ typedef FT_Pointer FT_LruKey; /* a list list handle */ typedef struct FT_LruListRec_* FT_LruList; - /* list class handle */ + /* a list class handle */ typedef const struct FT_LruList_ClassRec_* FT_LruList_Class; - /* an list node handle */ - typedef struct FT_LruNodeRec_* FT_LruNode; + /* a list node handle */ + typedef struct FT_LruNodeRec_* FT_LruNode; /* the list node structure */ typedef struct FT_LruNodeRec_ @@ -87,53 +90,60 @@ FT_BEGIN_HEADER /* the list structure */ typedef struct FT_LruListRec_ { - FT_Memory memory; - FT_LruList_Class clazz; - FT_LruNode nodes; - FT_UInt max_nodes; - FT_UInt num_nodes; - FT_Pointer data; + FT_Memory memory; + FT_LruList_Class clazz; + FT_LruNode nodes; + FT_UInt max_nodes; + FT_UInt num_nodes; + FT_Pointer data; } FT_LruListRec; /* initialize a list list */ - typedef FT_Error (*FT_LruList_InitFunc)( FT_LruList list ); + typedef FT_Error + (*FT_LruList_InitFunc)( FT_LruList list ); - /* finalize a list list */ - typedef void (*FT_LruList_DoneFunc)( FT_LruList list ); + /* finalize a list list */ + typedef void + (*FT_LruList_DoneFunc)( FT_LruList list ); /* this method is used to initialize a new list element node */ - typedef FT_Error (*FT_LruNode_InitFunc)( FT_LruNode node, - FT_LruKey key, - FT_Pointer data ); + typedef FT_Error + (*FT_LruNode_InitFunc)( FT_LruNode node, + FT_LruKey key, + FT_Pointer data ); /* this method is used to finalize a given list element node */ - typedef void (*FT_LruNode_DoneFunc)( FT_LruNode node, - FT_Pointer data ); + typedef void + (*FT_LruNode_DoneFunc)( FT_LruNode node, + FT_Pointer data ); /* If defined, this method is called when the list if full */ /* during the lookup process -- it is used to change the contents */ - /* of a list element node, instead of calling `done_element()', */ + /* of a list element node instead of calling `done_element()', */ /* then `init_element()'. Set it to 0 for default behaviour. */ - typedef FT_Error (*FT_LruNode_FlushFunc)( FT_LruNode node, - FT_LruKey new_key, - FT_Pointer data ); + typedef FT_Error + (*FT_LruNode_FlushFunc)( FT_LruNode node, + FT_LruKey new_key, + FT_Pointer data ); /* If defined, this method is used to compare a list element node */ /* with a given key during a lookup. If set to 0, the `key' */ /* fields will be directly compared instead. */ - typedef FT_Bool (*FT_LruNode_CompareFunc)( FT_LruNode node, - FT_LruKey key, - FT_Pointer data ); + typedef FT_Bool + (*FT_LruNode_CompareFunc)( FT_LruNode node, + FT_LruKey key, + FT_Pointer data ); /* A selector is used to indicate whether a given list element node */ /* is part of a selection for FT_LruList_Remove_Selection(). The */ /* functrion must return true (i.e., non-null) to indicate that the */ /* node is part of it. */ - typedef FT_Bool (*FT_LruNode_SelectFunc)( FT_LruNode node, - FT_Pointer data, - FT_Pointer list_data ); + typedef FT_Bool + (*FT_LruNode_SelectFunc)( FT_LruNode node, + FT_Pointer data, + FT_Pointer list_data ); /* LRU class */ typedef struct FT_LruList_ClassRec_ @@ -164,22 +174,18 @@ FT_BEGIN_HEADER FT_EXPORT( void ) FT_LruList_Reset( FT_LruList list ); - FT_EXPORT( void ) FT_LruList_Destroy ( FT_LruList list ); - FT_EXPORT( FT_Error ) FT_LruList_Lookup( FT_LruList list, FT_LruKey key, FT_LruNode *anode ); - FT_EXPORT( void ) FT_LruList_Remove( FT_LruList list, FT_LruNode node ); - FT_EXPORT( void ) FT_LruList_Remove_Selection( FT_LruList list, FT_LruNode_SelectFunc select_func, @@ -189,6 +195,7 @@ FT_BEGIN_HEADER FT_END_HEADER + #endif /* __FTLRU_H__ */ diff --git a/include/freetype/ftcache.h b/include/freetype/ftcache.h index 0e4974648..97962753e 100644 --- a/include/freetype/ftcache.h +++ b/include/freetype/ftcache.h @@ -2,7 +2,7 @@ /* */ /* ftcache.h */ /* */ -/* FreeType Cache subsystem. */ +/* FreeType Cache subsystem (specification). */ /* */ /* Copyright 1996-2001 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -122,7 +122,7 @@ FT_BEGIN_HEADER /* */ /* */ /* A callback function provided by client applications. It is used */ - /* to translate a given FTC_FaceID into a new valid FT_Face object. */ + /* to translate a given @FTC_FaceID into a new valid @FT_Face object. */ /* */ /* */ /* face_id :: The face ID to resolve. */ @@ -132,15 +132,15 @@ FT_BEGIN_HEADER /* data :: Application-provided request data. */ /* */ /* */ - /* aface :: A new FT_Face handle. */ + /* aface :: A new @FT_Face handle. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* The face requester should not perform funny things on the returned */ - /* face object, like creating a new FT_Size for it, or setting a */ - /* transformation through FT_Set_Transform()! */ + /* face object, like creating a new @FT_Size for it, or setting a */ + /* transformation through @FT_Set_Transform! */ /* */ typedef FT_Error (*FTC_Face_Requester)( FTC_FaceID face_id, @@ -175,7 +175,8 @@ FT_BEGIN_HEADER } FTC_FontRec; - /* */ + /* */ + #define FTC_FONT_COMPARE( f1, f2 ) \ ( (f1)->face_id == (f2)->face_id && \ @@ -189,13 +190,14 @@ FT_BEGIN_HEADER ((f)->pix_width << 8) ^ \ ((f)->pix_height) ) + /*************************************************************************/ /* */ /* */ /* FTC_Font */ /* */ /* */ - /* A simple handle to a FTC_FontRec structure. */ + /* A simple handle to an @FTC_FontRec structure. */ /* */ typedef FTC_FontRec* FTC_Font; @@ -217,8 +219,8 @@ FT_BEGIN_HEADER /* FTC_Manager */ /* */ /* */ - /* This object is used to cache one or more FT_Face objects, along */ - /* with corresponding FT_Size objects. */ + /* This object is used to cache one or more @FT_Face objects, along */ + /* with corresponding @FT_Size objects. */ /* */ typedef struct FTC_ManagerRec_* FTC_Manager; @@ -229,18 +231,18 @@ FT_BEGIN_HEADER /* FTC_Node */ /* */ /* */ - /* an opaque handle to a cache node object. Each cache node is */ - /* reference-counted. A node with a count of 0 might be flushed */ - /* out of a full cache whenever a lookup request is performed */ + /* An opaque handle to a cache node object. Each cache node is */ + /* reference-counted. A node with a count of 0 might be flushed */ + /* out of a full cache whenever a lookup request is performed. */ /* */ - /* when you lookup nodes, you have the ability to "acquire" them, */ - /* i.e. increment their reference count. This will prevent the node */ - /* from being flushed out of the cache until you explicitely */ - /* "release" it (see @FTC_Node_Release) */ + /* If you lookup nodes, you have the ability to "acquire" them, i.e., */ + /* to increment their reference count. This will prevent the node */ + /* from being flushed out of the cache until you explicitly "release" */ + /* it (see @FTC_Node_Release). */ /* */ - /* see @FTC_BitsetCache_Lookup and @FTC_ImageCache_Lookup */ + /* See also @FTC_BitsetCache_Lookup and @FTC_ImageCache_Lookup. */ /* */ - typedef struct FTC_NodeRec_* FTC_Node; + typedef struct FTC_NodeRec_* FTC_Node; /*************************************************************************/ @@ -264,10 +266,10 @@ FT_BEGIN_HEADER /* Use 0 for defaults. */ /* */ /* requester :: An application-provided callback used to translate */ - /* face IDs into real FT_Face objects. */ + /* face IDs into real @FT_Face objects. */ /* */ /* req_data :: A generic pointer that is passed to the requester */ - /* each time it is called (see FTC_Face_Requester) */ + /* each time it is called (see @FTC_Face_Requester). */ /* */ /* */ /* amanager :: A handle to a new manager object. 0 in case of */ @@ -293,7 +295,7 @@ FT_BEGIN_HEADER /* */ /* */ /* Empties a given cache manager. This simply gets rid of all the */ - /* currently cached FT_Face & FT_Size objects within the manager. */ + /* currently cached @FT_Face and @FT_Size objects within the manager. */ /* */ /* */ /* manager :: A handle to the manager. */ @@ -323,7 +325,7 @@ FT_BEGIN_HEADER /* FTC_Manager_Lookup_Face */ /* */ /* */ - /* Retrieves the FT_Face object that corresponds to a given face ID */ + /* Retrieves the @FT_Face object that corresponds to a given face ID */ /* through a cache manager. */ /* */ /* */ @@ -338,15 +340,15 @@ FT_BEGIN_HEADER /* FreeType error code. 0 means success. */ /* */ /* */ - /* The returned FT_Face object is always owned by the manager. You */ + /* The returned @FT_Face object is always owned by the manager. You */ /* should never try to discard it yourself. */ /* */ - /* The FT_Face object doesn't necessarily have a current size object */ + /* The @FT_Face object doesn't necessarily have a current size object */ /* (i.e., face->size can be 0). If you need a specific `font size', */ - /* use FTC_Manager_Lookup_Size() instead. */ + /* use @FTC_Manager_Lookup_Size instead. */ /* */ /* Never change the face's transformation matrix (i.e., never call */ - /* the FT_Set_Transform() function) on a returned face! If you need */ + /* the @FT_Set_Transform function) on a returned face! If you need */ /* to transform glyphs, do it yourself after glyph loading. */ /* */ FT_EXPORT( FT_Error ) @@ -361,8 +363,8 @@ FT_BEGIN_HEADER /* FTC_Manager_Lookup_Size */ /* */ /* */ - /* Retrieves the FT_Face & FT_Size objects that correspond to a given */ - /* FTC_SizeID. */ + /* Retrieves the @FT_Face and @FT_Size objects that correspond to a */ + /* given @FTC_SizeID. */ /* */ /* */ /* manager :: A handle to the cache manager. */ @@ -380,19 +382,19 @@ FT_BEGIN_HEADER /* FreeType error code. 0 means success. */ /* */ /* */ - /* The returned FT_Face object is always owned by the manager. You */ + /* The returned @FT_Face object is always owned by the manager. You */ /* should never try to discard it yourself. */ /* */ /* Never change the face's transformation matrix (i.e., never call */ - /* the FT_Set_Transform() function) on a returned face! If you need */ + /* the @FT_Set_Transform function) on a returned face! If you need */ /* to transform glyphs, do it yourself after glyph loading. */ /* */ - /* Similarly, the returned FT_Size object is always owned by the */ + /* Similarly, the returned @FT_Size object is always owned by the */ /* manager. You should never try to discard it, and never change its */ - /* settings with FT_Set_Pixel_Sizes() or FT_Set_Char_Size()! */ + /* settings with @FT_Set_Pixel_Sizes or @FT_Set_Char_Size! */ /* */ /* The returned size object is the face's current size, which means */ - /* that you can call FT_Load_Glyph() with the face if you need to. */ + /* that you can call @FT_Load_Glyph with the face if you need to. */ /* */ FT_EXPORT( FT_Error ) FTC_Manager_Lookup_Size( FTC_Manager manager, diff --git a/src/cache/ftccache.c b/src/cache/ftccache.c index 5eefb0372..f32f7d421 100644 --- a/src/cache/ftccache.c +++ b/src/cache/ftccache.c @@ -1,3 +1,21 @@ +/***************************************************************************/ +/* */ +/* ftccache.c */ +/* */ +/* The FreeType internal cache interface (body). */ +/* */ +/* Copyright 2000-2001 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 #include FT_CACHE_MANAGER_H #include FT_INTERNAL_OBJECTS_H @@ -5,6 +23,7 @@ #include "ftcerror.h" + /*************************************************************************/ /*************************************************************************/ /***** *****/ @@ -13,13 +32,14 @@ /*************************************************************************/ /*************************************************************************/ - FT_EXPORT_DEF(void) + FT_EXPORT_DEF( void ) ftc_node_done( FTC_Node node, FTC_Cache cache ) { FTC_Family family; FTC_FamilyEntry entry; + entry = cache->manager->families.entries + node->fam_index; family = entry->family; @@ -29,9 +49,7 @@ } - - - /* add a new node to the head of the manager's circular MRU list */ + /* add a new node to the head of the manager's circular MRU list */ static void ftc_node_mru_link( FTC_Node node, FTC_Manager manager ) @@ -162,7 +180,7 @@ /* find node's cache */ if ( node->fam_index >= manager->families.count ) { - FT_ERROR(( "FreeType.cache.node_destroy: invalid node handle\n" )); + FT_ERROR(( "ftc_node_destroy: invalid node handle\n" )); return; } #endif @@ -173,7 +191,7 @@ #ifdef FT_DEBUG_ERROR if ( cache == NULL ) { - FT_ERROR(( "FreeType.cache.node_destroy: invalid node handle\n" )); + FT_ERROR(( "ftc_node_destroy: invalid node handle\n" )); return; } #endif @@ -196,7 +214,7 @@ /* check, just in case of general corruption :-) */ if ( manager->num_nodes <= 0 ) - FT_ERROR(( "FTC_Manager_Compress: Invalid cache node count! = %d\n", + FT_ERROR(( "ftc_node_destroy: invalid cache node count! = %d\n", manager->num_nodes )); } @@ -210,7 +228,7 @@ /*************************************************************************/ - FT_EXPORT_DEF(FT_Error) + FT_EXPORT_DEF( FT_Error ) ftc_family_init( FTC_Family family, FTC_Query query, FTC_Cache cache ) @@ -220,12 +238,13 @@ FT_Memory memory = manager->library->memory; FTC_FamilyEntry entry; + family->cache = cache; family->num_nodes = 0; /* now add to manager's family table */ error = ftc_family_table_alloc( &manager->families, memory, &entry ); - if (!error) + if ( !error ) { entry->cache = cache; entry->family = family; @@ -233,16 +252,17 @@ query->family = family; /* save family in query */ } + return error; } - - FT_EXPORT_DEF(void) + FT_EXPORT_DEF( void ) ftc_family_done( FTC_Family family ) { FTC_Manager manager = family->cache->manager; + /* remove from manager's family table */ ftc_family_table_free( &manager->families, family->fam_index ); } @@ -318,7 +338,6 @@ (c)->size*3 < (c)->nodes ) - static void ftc_cache_resize( FTC_Cache cache ) { @@ -333,7 +352,8 @@ FTC_Node* new_buckets ; FT_ULong i; - /* no need to report an error, we'll simply keep using the same */ + + /* no need to report an error; we'll simply keep using the same */ /* buckets number / size */ if ( ALLOC_ARRAY( new_buckets, new_size, FTC_Node ) ) return; @@ -386,22 +406,23 @@ { FT_LruList_ClassRec* lru_class = &cache->family_class; + lru_class->list_size = sizeof( FT_LruListRec ); lru_class->list_init = NULL; lru_class->list_done = NULL; lru_class->node_size = clazz->family_size; - lru_class->node_init = (FT_LruNode_InitFunc) clazz->family_init; - lru_class->node_done = (FT_LruNode_DoneFunc) clazz->family_done; - lru_class->node_flush = (FT_LruNode_FlushFunc) NULL; - lru_class->node_compare = (FT_LruNode_CompareFunc) clazz->family_compare; + lru_class->node_init = (FT_LruNode_InitFunc) clazz->family_init; + lru_class->node_done = (FT_LruNode_DoneFunc) clazz->family_done; + lru_class->node_flush = (FT_LruNode_FlushFunc) NULL; + lru_class->node_compare = (FT_LruNode_CompareFunc)clazz->family_compare; error = FT_LruList_New( (FT_LruList_Class) lru_class, - 0, /* max items == 0 => unbounded list */ + 0, /* max items == 0 => unbounded list */ cache, memory, &cache->families ); - if (error) + if ( error ) FREE( cache->buckets ); } @@ -410,7 +431,7 @@ } - FT_EXPORT_DEF(void) + FT_EXPORT_DEF( void ) ftc_cache_clear( FTC_Cache cache ) { if ( cache ) @@ -425,6 +446,7 @@ { FTC_Node *pnode = cache->buckets + i, next, node = *pnode; + while ( node ) { next = node->link; @@ -453,6 +475,7 @@ } } + FT_EXPORT_DEF( void ) ftc_cache_done( FTC_Cache cache ) { @@ -460,6 +483,7 @@ { FT_Memory memory = cache->memory; + ftc_cache_clear( cache ); FREE( cache->buckets ); @@ -474,11 +498,10 @@ } - /* Look up a node in "top" of its cache's hash table. */ /* If not found, create a new node. */ /* */ - FT_EXPORT_DEF(FT_Error) + FT_EXPORT_DEF( FT_Error ) ftc_cache_lookup( FTC_Cache cache, FTC_Query query, FTC_Node *anode ) @@ -497,35 +520,38 @@ query->family = NULL; error = FT_LruList_Lookup( cache->families, query, &lru ); - if (!error) + if ( !error ) { FTC_Family family = (FTC_Family) lru; FT_UFast hash = query->hash; FTC_Node* bucket = cache->buckets + (hash % cache->size); - if ( query->family != family || - family->fam_index >= cache->manager->families.size ) - { - FT_ERROR(( "%s: invalid query (bad 'family' field)\n", - "FreeType.cache.lookup" )); - return FT_Err_Invalid_Argument; - } + + if ( query->family != family || + family->fam_index >= cache->manager->families.size ) + { + FT_ERROR(( + "ftc_cache_lookup: invalid query (bad 'family' field)\n" )); + return FT_Err_Invalid_Argument; + } if ( *bucket ) { FTC_Node* pnode = bucket; FTC_Node_CompareFunc compare = cache->clazz->node_compare; + for ( ;; ) { FTC_Node node; + node = *pnode; if ( node == NULL ) break; if ( (FT_UInt)node->fam_index == family->fam_index && - compare( node, query, cache ) ) + compare( node, query, cache ) ) { /* move to head of bucket list */ if ( pnode != bucket ) @@ -582,8 +608,8 @@ node->ref_count--; } - /* try to resize the hash table when appropriate */ - if ( FTC_CACHE_RESIZE_TEST(cache) ) + /* try to resize the hash table if appropriate */ + if ( FTC_CACHE_RESIZE_TEST( cache ) ) ftc_cache_resize( cache ); *anode = node; @@ -595,3 +621,4 @@ } +/* END */ diff --git a/src/cache/ftccmap.c b/src/cache/ftccmap.c index 3badfba32..d3c92407e 100644 --- a/src/cache/ftccmap.c +++ b/src/cache/ftccmap.c @@ -2,7 +2,7 @@ /* */ /* ftccmap.c */ /* */ -/* FreeType CharMap cache */ +/* FreeType CharMap cache (body) */ /* */ /* Copyright 2000-2001 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -26,46 +26,47 @@ #include "ftcerror.h" + /*************************************************************************/ + /* */ + /* Each FTC_CMapNode contains a simple array to map a range of character */ + /* codes to equivalent glyph indices. */ + /* */ + /* For now, the implementation is very basic: Each node maps a range of */ + /* 128 consecutive character codes to their correspondingglyph indices. */ + /* */ + /* We could do more complex things, but I don't think it is really very */ + /* useful. */ + /* */ + /*************************************************************************/ - /* each FTC_CMapNode contains a simple array used to map a */ - /* range of character codes to equivalent glyph indices */ - /* */ - /* for now, the implementation is very basic: each node */ - /* maps a range of 128 consecutive character codes to their */ - /* correspondingglyph indices.. */ - /* */ - /* we could do more complex things, but I don't think it's */ - /* really very useful.. */ - /* */ - - /* number of glyph indices / character code per node */ -#define FTC_CMAP_INDICES_MAX 128 + /* number of glyph indices / character code per node */ +#define FTC_CMAP_INDICES_MAX 128 - typedef struct FTC_CMapNodeRec_ + typedef struct FTC_CMapNodeRec_ { FTC_NodeRec node; - FT_UInt32 first; /* first character in node */ - FT_UInt16 indices[ FTC_CMAP_INDICES_MAX ]; /* array of glyph indices */ + FT_UInt32 first; /* first character in node */ + FT_UInt16 indices[FTC_CMAP_INDICES_MAX]; /* array of glyph indices */ } FTC_CMapNodeRec, *FTC_CMapNode; -#define FTC_CMAP_NODE( x ) ((FTC_CMapNode)( x )) - /* compute node hash value from cmap family and "requested" glyph index */ -#define FTC_CMAP_HASH(cfam,cquery) \ - ((cfam)->hash + ((cquery)->char_code/FTC_CMAP_INDICES_MAX)) +#define FTC_CMAP_NODE( x ) ( (FTC_CMapNode)( x ) ) - /* if (indices[n] == FTC_CMAP_UNKNOWN), we assume that the corresponding */ - /* glyph indices hasn't been queried through @FT_Get_Glyph_Index yet.. */ - /* */ -#define FTC_CMAP_UNKNOWN ((FT_UInt16)-1) + /* compute node hash value from cmap family and "requested" glyph index */ +#define FTC_CMAP_HASH( cfam, cquery ) \ + ( (cfam)->hash + ( (cquery)->char_code / FTC_CMAP_INDICES_MAX ) ) + + /* if (indices[n] == FTC_CMAP_UNKNOWN), we assume that the corresponding */ + /* glyph indices haven't been queried through FT_Get_Glyph_Index() yet */ +#define FTC_CMAP_UNKNOWN ( (FT_UInt16)-1 ) /* the charmap query */ - typedef struct FTC_CMapQueryRec_ + typedef struct FTC_CMapQueryRec_ { FTC_QueryRec query; FTC_CMapDesc desc; @@ -73,7 +74,8 @@ } FTC_CMapQueryRec, *FTC_CMapQuery; -#define FTC_CMAP_QUERY( x ) ((FTC_CMapQuery)( x )) + +#define FTC_CMAP_QUERY( x ) ( (FTC_CMapQuery)( x ) ) /* the charmap family */ @@ -86,8 +88,9 @@ } FTC_CMapFamilyRec, *FTC_CMapFamily; -#define FTC_CMAP_FAMILY( x ) ((FTC_CMapFamily)( x )) -#define FTC_CMAP_FAMILY_MEMORY( x ) FTC_FAMILY(x)->memory + +#define FTC_CMAP_FAMILY( x ) ( (FTC_CMapFamily)( x ) ) +#define FTC_CMAP_FAMILY_MEMORY( x ) FTC_FAMILY( x )->memory /*************************************************************************/ @@ -99,7 +102,7 @@ /*************************************************************************/ - /* no need for specific finalizer, we'll use "ftc_node_done" directly */ + /* no need for specific finalizer; we use "ftc_node_done" directly */ /* initialize a new cmap node */ FT_CALLBACK_DEF( FT_Error ) @@ -112,7 +115,8 @@ FT_UNUSED( cache ); - first = (cquery->char_code / FTC_CMAP_INDICES_MAX) * FTC_CMAP_INDICES_MAX; + first = ( cquery->char_code / FTC_CMAP_INDICES_MAX ) * + FTC_CMAP_INDICES_MAX; cnode->first = first; for ( n = 0; n < FTC_CMAP_INDICES_MAX; n++ ) @@ -122,15 +126,15 @@ } - /* compute the weight of a given cmap node */ + /* compute the weight of a given cmap node */ FT_CALLBACK_DEF( FT_ULong ) ftc_cmap_node_weight( FTC_CMapNode cnode ) { - return sizeof(*cnode); + return sizeof ( *cnode ); } - /* compare a cmap node to a given query */ + /* compare a cmap node to a given query */ FT_CALLBACK_DEF( FT_Bool ) ftc_cmap_node_compare( FTC_CMapNode cnode, FTC_CMapQuery cquery ) @@ -166,74 +170,66 @@ /* setup charmap descriptor */ cfam->desc = *desc; - /* let's see if the rest is correct too */ + /* let's see whether the rest is correct too */ error = FTC_Manager_Lookup_Face( manager, desc->face_id, &face ); if ( !error ) { FT_UInt count = face->num_charmaps; FT_UInt index = count; FT_CharMap* cur = face->charmaps; - + + switch ( desc->type ) { - case FTC_CMAP_BY_INDEX: - { - index = desc->u.index; - hash = index*33; - break; - } - + case FTC_CMAP_BY_INDEX: + index = desc->u.index; + hash = index * 33; + break; - case FTC_CMAP_BY_ENCODING: - { - for ( index = 0; index < count; index++, cur++ ) - if ( cur[0]->encoding == desc->u.encoding ) - break; - - hash = index*67; + case FTC_CMAP_BY_ENCODING: + for ( index = 0; index < count; index++, cur++ ) + if ( cur[0]->encoding == desc->u.encoding ) break; - } + hash = index * 67; + break; - case FTC_CMAP_BY_ID: + case FTC_CMAP_BY_ID: + for ( index = 0; index < count; index++, cur++ ) + { + if ( (FT_UInt)cur[0]->platform_id == desc->u.id.platform && + (FT_UInt)cur[0]->encoding_id == desc->u.id.encoding ) { - for ( index = 0; index < count; index++, cur++ ) - { - if ( (FT_UInt) cur[0]->platform_id == desc->u.id.platform && - (FT_UInt) cur[0]->encoding_id == desc->u.id.encoding ) - { - hash = ((desc->u.id.platform << 8) | desc->u.id.encoding)*7; - break; - } - } + hash = ( ( desc->u.id.platform << 8 ) | desc->u.id.encoding ) * 7; break; } + } + break; - default: - ; + default: + ; } if ( index >= count ) goto Bad_Descriptor; /* compute hash value, both in family and query */ - cfam->index = index; - cfam->hash = hash ^ FTC_FACE_ID_HASH(desc->face_id); - FTC_QUERY(cquery)->hash = FTC_CMAP_HASH(cfam,cquery); + cfam->index = index; + cfam->hash = hash ^ FTC_FACE_ID_HASH( desc->face_id ); + FTC_QUERY( cquery )->hash = FTC_CMAP_HASH( cfam, cquery ); - error = ftc_family_init( FTC_FAMILY(cfam), FTC_QUERY(cquery), cache ); + error = ftc_family_init( FTC_FAMILY( cfam ), + FTC_QUERY( cquery ), cache ); } - - return error; + return error; Bad_Descriptor: - FT_ERROR(( "FreeType.cache.cmap.lookup: invalid charmap descriptor\n" )); + FT_ERROR(( "ftp_cmap_family_init: invalid charmap descriptor\n" )); return FT_Err_Invalid_Argument; } - FT_CALLBACK_DEF( FT_Bool ) ftc_cmap_family_compare( FTC_CMapFamily cfam, FTC_CMapQuery cquery ) @@ -248,32 +244,32 @@ switch ( cfam->desc.type ) { - case FTC_CMAP_BY_INDEX: - result = ( cfam->desc.u.index == cquery->desc->u.index ); - break; + case FTC_CMAP_BY_INDEX: + result = ( cfam->desc.u.index == cquery->desc->u.index ); + break; - case FTC_CMAP_BY_ENCODING: - result = ( cfam->desc.u.encoding == cquery->desc->u.encoding ); - break; + case FTC_CMAP_BY_ENCODING: + result = ( cfam->desc.u.encoding == cquery->desc->u.encoding ); + break; - case FTC_CMAP_BY_ID: - result = ( cfam->desc.u.id.platform == cquery->desc->u.id.platform && - cfam->desc.u.id.encoding == cquery->desc->u.id.encoding ); - break; + case FTC_CMAP_BY_ID: + result = ( cfam->desc.u.id.platform == cquery->desc->u.id.platform && + cfam->desc.u.id.encoding == cquery->desc->u.id.encoding ); + break; - default: - ; + default: + ; } - if (result) + if ( result ) { /* when found, update the 'family' and 'hash' field of the query */ - FTC_QUERY(cquery)->family = FTC_FAMILY(cfam); - FTC_QUERY(cquery)->hash = FTC_CMAP_HASH(cfam,cquery); + FTC_QUERY( cquery )->family = FTC_FAMILY( cfam ); + FTC_QUERY( cquery )->hash = FTC_CMAP_HASH( cfam, cquery ); } Exit: - return FT_BOOL(result); + return FT_BOOL( result ); } @@ -286,25 +282,24 @@ /*************************************************************************/ - FT_CALLBACK_TABLE_DEF const FTC_Cache_ClassRec ftc_cmap_cache_class = { - sizeof( FTC_CacheRec ), - (FTC_Cache_InitFunc) ftc_cache_init, - (FTC_Cache_ClearFunc) ftc_cache_clear, - (FTC_Cache_DoneFunc) ftc_cache_done, - - sizeof( FTC_CMapFamilyRec ), - (FTC_Family_InitFunc) ftc_cmap_family_init, - (FTC_Family_CompareFunc) ftc_cmap_family_compare, - (FTC_Family_DoneFunc) ftc_family_done, - - sizeof( FTC_CMapNodeRec ), - (FTC_Node_InitFunc) ftc_cmap_node_init, - (FTC_Node_WeightFunc) ftc_cmap_node_weight, - (FTC_Node_CompareFunc) ftc_cmap_node_compare, - (FTC_Node_DoneFunc) ftc_node_done + sizeof ( FTC_CacheRec ), + (FTC_Cache_InitFunc) ftc_cache_init, + (FTC_Cache_ClearFunc)ftc_cache_clear, + (FTC_Cache_DoneFunc) ftc_cache_done, + + sizeof ( FTC_CMapFamilyRec ), + (FTC_Family_InitFunc) ftc_cmap_family_init, + (FTC_Family_CompareFunc)ftc_cmap_family_compare, + (FTC_Family_DoneFunc) ftc_family_done, + + sizeof ( FTC_CMapNodeRec ), + (FTC_Node_InitFunc) ftc_cmap_node_init, + (FTC_Node_WeightFunc) ftc_cmap_node_weight, + (FTC_Node_CompareFunc)ftc_cmap_node_compare, + (FTC_Node_DoneFunc) ftc_node_done }; @@ -333,42 +328,45 @@ FT_Error error; FT_UInt gindex = 0; + if ( !cache || !desc ) { - FT_ERROR(( "FTC_CMapCache_Lookup: bad arguments, returning 0 !!\n" )); + FT_ERROR(( "FTC_CMapCache_Lookup: bad arguments, returning 0!\n" )); return 0; } cquery.desc = desc; cquery.char_code = char_code; - error = ftc_cache_lookup( FTC_CACHE(cache), - FTC_QUERY(&cquery), - (FTC_Node*) &node ); + error = ftc_cache_lookup( FTC_CACHE( cache ), + FTC_QUERY( &cquery ), + (FTC_Node*)&node ); if ( !error ) { FT_UInt offset = (FT_UInt)( char_code - node->first ); + gindex = node->indices[offset]; if ( gindex == FTC_CMAP_UNKNOWN ) { - FT_Face face; + FT_Face face; - /* we need to use @FT_Get_Char_Index */ + /* we need to use FT_Get_Char_Index */ gindex = 0; error = FTC_Manager_Lookup_Face( FTC_CACHE(cache)->manager, desc->face_id, &face ); - if (!error) + if ( !error ) { - FT_CharMap old, cmap = NULL; - FT_UInt cmap_index; + FT_CharMap old, cmap = NULL; + FT_UInt cmap_index; + /* save old charmap, select new one */ old = face->charmap; - cmap_index = FTC_CMAP_FAMILY( FTC_QUERY(&cquery)->family )->index; + cmap_index = FTC_CMAP_FAMILY( FTC_QUERY( &cquery )->family )->index; cmap = face->charmaps[cmap_index]; FT_Set_Charmap( face, cmap ); diff --git a/src/cache/ftcglyph.c b/src/cache/ftcglyph.c index d1b5d49ff..aa21228a7 100644 --- a/src/cache/ftcglyph.c +++ b/src/cache/ftcglyph.c @@ -27,25 +27,23 @@ #include "ftcerror.h" - - /* create a new chunk node, setting its cache index and ref count */ FT_EXPORT_DEF( void ) ftc_glyph_node_init( FTC_GlyphNode gnode, FT_UInt gindex, FTC_GlyphFamily gfam ) { - FT_UInt len; - FT_UInt start = FTC_GLYPH_FAMILY_START(gfam,gindex); + FT_UInt len; + FT_UInt start = FTC_GLYPH_FAMILY_START( gfam, gindex ); - gnode->item_start = (FT_UShort) start; + gnode->item_start = (FT_UShort)start; len = gfam->item_total - start; if ( len > gfam->item_count ) len = gfam->item_count; - gnode->item_count = (FT_UShort) len; + gnode->item_count = (FT_UShort)len; gfam->family.num_nodes++; } @@ -58,18 +56,18 @@ gnode->item_count = 0; gnode->item_start = 0; - ftc_node_done( FTC_NODE(gnode), cache ); + ftc_node_done( FTC_NODE( gnode ), cache ); } FT_EXPORT_DEF( FT_Bool ) - ftc_glyph_node_compare( FTC_GlyphNode gnode, - FTC_GlyphQuery gquery ) + ftc_glyph_node_compare( FTC_GlyphNode gnode, + FTC_GlyphQuery gquery ) { - FT_UInt start = (FT_UInt) gnode->item_start; - FT_UInt count = (FT_UInt) gnode->item_count; + FT_UInt start = (FT_UInt)gnode->item_start; + FT_UInt count = (FT_UInt)gnode->item_count; - return FT_BOOL( (FT_UInt)(gquery->gindex - start) < count ); + return FT_BOOL( (FT_UInt)( gquery->gindex - start ) < count ); } @@ -93,14 +91,14 @@ FT_Error error; - error = ftc_family_init( FTC_FAMILY(gfam), FTC_QUERY(gquery), cache ); - if (!error) + error = ftc_family_init( FTC_FAMILY( gfam ), FTC_QUERY( gquery ), cache ); + if ( !error ) { gfam->hash = hash; gfam->item_total = item_total; gfam->item_count = item_count; - FTC_GLYPH_FAMILY_FOUND(gfam,gquery); + FTC_GLYPH_FAMILY_FOUND( gfam, gquery ); } return error; @@ -110,9 +108,8 @@ FT_EXPORT_DEF( void ) ftc_glyph_family_done( FTC_GlyphFamily gfam ) { - ftc_family_done( FTC_FAMILY(gfam) ); + ftc_family_done( FTC_FAMILY( gfam ) ); } - /* END */ diff --git a/src/cache/ftcimage.c b/src/cache/ftcimage.c index 291b1cc13..39f0aa082 100644 --- a/src/cache/ftcimage.c +++ b/src/cache/ftcimage.c @@ -37,7 +37,7 @@ } FTC_ImageNodeRec, *FTC_ImageNode; -#define FTC_IMAGE_NODE( x ) ((FTC_ImageNode)( x )) +#define FTC_IMAGE_NODE( x ) ( (FTC_ImageNode)( x ) ) #define FTC_IMAGE_NODE_GINDEX( x ) FTC_GLYPH_NODE_GINDEX( x ) @@ -49,8 +49,8 @@ } FTC_ImageQueryRec, *FTC_ImageQuery; -#define FTC_IMAGE_QUERY(x) ((FTC_ImageQuery)(x)) +#define FTC_IMAGE_QUERY( x ) ( (FTC_ImageQuery)( x ) ) /* the glyph image set type */ @@ -62,8 +62,8 @@ } FTC_ImageFamilyRec, *FTC_ImageFamily; -#define FTC_IMAGE_FAMILY( x ) ((FTC_ImageFamily)( x )) -#define FTC_IMAGE_FAMILY_MEMORY( x ) FTC_GLYPH_FAMILY_MEMORY( &(x)->gfam ) +#define FTC_IMAGE_FAMILY( x ) ( (FTC_ImageFamily)( x ) ) +#define FTC_IMAGE_FAMILY_MEMORY( x ) FTC_GLYPH_FAMILY_MEMORY( &(x)->gfam ) /*************************************************************************/ @@ -85,9 +85,9 @@ FT_Done_Glyph( inode->glyph ); inode->glyph = NULL; } - ftc_glyph_node_done( FTC_GLYPH_NODE(inode), cache ); - } + ftc_glyph_node_done( FTC_GLYPH_NODE( inode ), cache ); + } /* initialize a new glyph image node */ @@ -96,26 +96,26 @@ FTC_GlyphQuery gquery, FTC_Cache cache ) { - FTC_ImageFamily ifam = FTC_IMAGE_FAMILY( gquery->query.family ); - FT_Error error; - FT_Face face; - FT_Size size; + FTC_ImageFamily ifam = FTC_IMAGE_FAMILY( gquery->query.family ); + FT_Error error; + FT_Face face; + FT_Size size; /* initialize its inner fields */ - ftc_glyph_node_init( FTC_GLYPH_NODE(inode), + ftc_glyph_node_init( FTC_GLYPH_NODE( inode ), gquery->gindex, - FTC_GLYPH_FAMILY(ifam) ); + FTC_GLYPH_FAMILY( ifam ) ); /* we will now load the glyph image */ - error = FTC_Manager_Lookup_Size( FTC_FAMILY(ifam)->cache->manager, + error = FTC_Manager_Lookup_Size( FTC_FAMILY( ifam )->cache->manager, &ifam->desc.font, &face, &size ); if ( !error ) { - FT_UInt gindex = FTC_GLYPH_NODE_GINDEX(inode); - FT_UInt load_flags = FT_LOAD_DEFAULT; - FT_UInt type = ifam->desc.type; + FT_UInt gindex = FTC_GLYPH_NODE_GINDEX( inode ); + FT_UInt load_flags = FT_LOAD_DEFAULT; + FT_UInt type = ifam->desc.type; if ( FTC_IMAGE_FORMAT( type ) == ftc_image_format_bitmap ) @@ -242,11 +242,11 @@ &face ); if ( !error ) { - error = ftc_glyph_family_init( FTC_GLYPH_FAMILY(ifam), + error = ftc_glyph_family_init( FTC_GLYPH_FAMILY( ifam ), FTC_IMAGE_DESC_HASH( &ifam->desc ), 1, face->num_glyphs, - FTC_GLYPH_QUERY(iquery), + FTC_GLYPH_QUERY( iquery ), cache ); } @@ -263,7 +263,7 @@ result = FT_BOOL( FTC_IMAGE_DESC_COMPARE( &ifam->desc, &iquery->desc ) ); if ( result ) - FTC_GLYPH_FAMILY_FOUND(ifam,iquery); + FTC_GLYPH_FAMILY_FOUND( ifam, iquery ); return result; } @@ -282,21 +282,21 @@ FT_CALLBACK_TABLE_DEF const FTC_Cache_ClassRec ftc_image_cache_class = { - sizeof( FTC_CacheRec ), - (FTC_Cache_InitFunc) ftc_cache_init, - (FTC_Cache_ClearFunc) ftc_cache_clear, - (FTC_Cache_DoneFunc) ftc_cache_done, - - sizeof( FTC_ImageFamilyRec ), - (FTC_Family_InitFunc) ftc_image_family_init, - (FTC_Family_CompareFunc) ftc_image_family_compare, - (FTC_Family_DoneFunc) ftc_glyph_family_done, - - sizeof( FTC_ImageNodeRec ), - (FTC_Node_InitFunc) ftc_image_node_init, - (FTC_Node_WeightFunc) ftc_image_node_weight, - (FTC_Node_CompareFunc) ftc_glyph_node_compare, - (FTC_Node_DoneFunc) ftc_image_node_done + sizeof ( FTC_CacheRec ), + (FTC_Cache_InitFunc) ftc_cache_init, + (FTC_Cache_ClearFunc)ftc_cache_clear, + (FTC_Cache_DoneFunc) ftc_cache_done, + + sizeof ( FTC_ImageFamilyRec ), + (FTC_Family_InitFunc) ftc_image_family_init, + (FTC_Family_CompareFunc)ftc_image_family_compare, + (FTC_Family_DoneFunc) ftc_glyph_family_done, + + sizeof ( FTC_ImageNodeRec ), + (FTC_Node_InitFunc) ftc_image_node_init, + (FTC_Node_WeightFunc) ftc_image_node_weight, + (FTC_Node_CompareFunc)ftc_glyph_node_compare, + (FTC_Node_DoneFunc) ftc_image_node_done }; @@ -339,17 +339,17 @@ iquery.gquery.gindex = gindex; iquery.desc = *desc; - error = ftc_cache_lookup( FTC_CACHE(cache), - FTC_QUERY(&iquery), - (FTC_Node*) &node ); + error = ftc_cache_lookup( FTC_CACHE( cache ), + FTC_QUERY( &iquery ), + (FTC_Node*)&node ); if ( !error ) { *aglyph = node->glyph; - if (anode) + if ( anode ) { *anode = (FTC_Node)node; - FTC_NODE(node)->ref_count++; + FTC_NODE( node )->ref_count++; } } @@ -357,8 +357,7 @@ } - - /* backwards-compatibility functions */ + /* backwards-compatibility functions */ FT_EXPORT_DEF( FT_Error ) FTC_Image_Cache_New( FTC_Manager manager, @@ -376,11 +375,12 @@ { FTC_ImageDesc desc0; + if ( !desc ) return FT_Err_Invalid_Argument; desc0.font = desc->font; - desc0.type = (FT_UInt32) desc->image_type; + desc0.type = (FT_UInt32)desc->image_type; return FTC_ImageCache_Lookup( (FTC_ImageCache)icache, &desc0, diff --git a/src/cache/ftcmanag.c b/src/cache/ftcmanag.c index 50941eaf0..efc74c8b9 100644 --- a/src/cache/ftcmanag.c +++ b/src/cache/ftcmanag.c @@ -62,9 +62,9 @@ FT_CALLBACK_DEF( FT_Error ) - ftc_face_node_init( FTC_FaceNode node, - FTC_FaceID face_id, - FTC_Manager manager ) + ftc_face_node_init( FTC_FaceNode node, + FTC_FaceID face_id, + FTC_Manager manager ) { FT_Error error; @@ -84,7 +84,7 @@ } - /* helper function for ftc_manager_done_face() */ + /* helper function for ftc_face_node_done() */ FT_CALLBACK_DEF( FT_Bool ) ftc_size_node_select( FTC_SizeNode node, FT_Face face ) @@ -116,8 +116,8 @@ const FT_LruList_ClassRec ftc_face_list_class = { sizeof ( FT_LruListRec ), - (FT_LruList_InitFunc) 0, - (FT_LruList_DoneFunc) 0, + (FT_LruList_InitFunc)0, + (FT_LruList_DoneFunc)0, sizeof ( FTC_FaceNodeRec ), (FT_LruNode_InitFunc) ftc_face_node_init, @@ -156,7 +156,6 @@ } - /*************************************************************************/ /*************************************************************************/ /***** *****/ @@ -258,8 +257,8 @@ const FT_LruList_ClassRec ftc_size_list_class = { sizeof ( FT_LruListRec ), - (FT_LruList_InitFunc) 0, - (FT_LruList_DoneFunc) 0, + (FT_LruList_InitFunc)0, + (FT_LruList_DoneFunc)0, sizeof ( FTC_SizeNodeRec ), (FT_LruNode_InitFunc) ftc_size_node_init, @@ -269,7 +268,6 @@ }; - /* documentation is in ftcache.h */ FT_EXPORT_DEF( FT_Error ) @@ -353,24 +351,27 @@ FTC_FamilyEntry entry; FT_Error error = 0; - /* re-allocate table size when needed */ + + /* re-allocate table size when needed */ if ( table->free == FTC_FAMILY_ENTRY_NONE && table->count >= table->size ) { FT_UInt old_size = table->size; FT_UInt new_size, index; + if ( old_size == 0 ) new_size = 8; else { - new_size = old_size*2; + new_size = old_size * 2; /* check for (unlikely) overflow */ if ( new_size < old_size ) new_size = 65534; } - if ( REALLOC_ARRAY( table->entries, old_size, new_size, FTC_FamilyEntryRec ) ) + if ( REALLOC_ARRAY( table->entries, old_size, new_size, + FTC_FamilyEntryRec ) ) return error; table->size = new_size; @@ -378,9 +379,9 @@ entry = table->entries + old_size; table->free = old_size; - for ( index = old_size; index+1 < new_size; index++, entry++ ) + for ( index = old_size; index + 1 < new_size; index++, entry++ ) { - entry->link = index+1; + entry->link = index + 1; entry->index = index; } @@ -399,7 +400,7 @@ } else { - FT_ERROR(( "FreeType.cache.alloc_set: internal bug !!" )); + FT_ERROR(( "ftc_family_table_alloc: internal bug!" )); return FT_Err_Invalid_Argument; } @@ -420,8 +421,9 @@ { FTC_FamilyEntry entry = table->entries + index; + if ( entry->link != FTC_FAMILY_ENTRY_NONE ) - FT_ERROR(( "FreeType.cache.set_free: internal bug !!\n" )); + FT_ERROR(( "ftc_family_table_free: internal bug!\n" )); else { entry->link = table->free; @@ -569,10 +571,9 @@ } - - #ifdef FT_DEBUG_ERROR - FT_EXPORT_DEF(void) + + FT_EXPORT_DEF( void ) FTC_Manager_Check( FTC_Manager manager ) { FTC_Node node, first; @@ -595,7 +596,7 @@ if ( (FT_UInt)node->fam_index >= manager->families.count || entry->link != FTC_FAMILY_ENTRY_NONE ) - FT_ERROR(( "FTC_Manager_Compress: invalid node (family index = %ld\n", + FT_ERROR(( "FTC_Manager_Check: invalid node (family index = %ld\n", node->fam_index )); else { @@ -604,13 +605,12 @@ } node = node->mru_next; - } - while (node != first); + + } while ( node != first ); if ( weight != manager->cur_weight ) - FT_ERROR(( - "FTC_Manager_Compress: invalid weight %ld instead of %ld\n", - manager->cur_weight, weight )); + FT_ERROR(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n", + manager->cur_weight, weight )); } /* check circular list */ @@ -624,15 +624,16 @@ { count++; node = node->mru_next; - } - while (node != first); + + } while ( node != first ); if ( count != manager->num_nodes ) FT_ERROR(( - "FTC_Manager_Compress: invalid cache node count %d instead of %d\n", + "FTC_Manager_Check: invalid cache node count %d instead of %d\n", manager->num_nodes, count )); } } + #endif /* FT_DEBUG_ERROR */ @@ -682,6 +683,8 @@ } + /* documentation is in ftcmanag.h */ + FT_EXPORT_DEF( FT_Error ) FTC_Manager_Register_Cache( FTC_Manager manager, FTC_Cache_Class clazz, @@ -746,12 +749,9 @@ } + /* documentation is in ftcmanag.h */ - - - - - FT_EXPORT_DEF(void) + FT_EXPORT_DEF( void ) FTC_Node_Unref( FTC_Node node, FTC_Manager manager ) { diff --git a/src/cache/ftcsbits.c b/src/cache/ftcsbits.c index 571155728..70ed44b27 100644 --- a/src/cache/ftcsbits.c +++ b/src/cache/ftcsbits.c @@ -32,17 +32,17 @@ #define FTC_SBIT_ITEMS_PER_NODE 16 - typedef struct FTC_SBitNodeRec_* FTC_SBitNode; + typedef struct FTC_SBitNodeRec_* FTC_SBitNode; - typedef struct FTC_SBitNodeRec_ + typedef struct FTC_SBitNodeRec_ { - FTC_GlyphNodeRec gnode; - FTC_SBitRec sbits[ FTC_SBIT_ITEMS_PER_NODE ]; + FTC_GlyphNodeRec gnode; + FTC_SBitRec sbits[FTC_SBIT_ITEMS_PER_NODE]; } FTC_SBitNodeRec; -#define FTC_SBIT_NODE(x) ((FTC_SBitNode)(x)) +#define FTC_SBIT_NODE( x ) ( (FTC_SBitNode)( x ) ) typedef struct FTC_SBitQueryRec_ @@ -52,23 +52,23 @@ } FTC_SBitQueryRec, *FTC_SBitQuery; -#define FTC_SBIT_QUERY(x) ((FTC_SBitQuery)(x)) +#define FTC_SBIT_QUERY( x ) ( (FTC_SBitQuery)( x ) ) typedef struct FTC_SBitFamilyRec_* FTC_SBitFamily; - /* sbit family structure */ + /* sbit family structure */ typedef struct FTC_SBitFamilyRec_ { FTC_GlyphFamilyRec gfam; FTC_ImageDesc desc; } FTC_SBitFamilyRec; + -#define FTC_SBIT_FAMILY( x ) ( (FTC_SBitFamily)(x) ) -#define FTC_SBIT_FAMILY_MEMORY( x ) FTC_GLYPH_FAMILY_MEMORY( &(x)->cset ) - +#define FTC_SBIT_FAMILY( x ) ( (FTC_SBitFamily)( x ) ) +#define FTC_SBIT_FAMILY_MEMORY( x ) FTC_GLYPH_FAMILY_MEMORY( &( x )->cset ) /*************************************************************************/ @@ -102,54 +102,54 @@ } - FT_CALLBACK_DEF( void ) ftc_sbit_node_done( FTC_SBitNode snode, FTC_Cache cache ) { FTC_SBit sbit = snode->sbits; - FT_UInt count = FTC_GLYPH_NODE(snode)->item_count; + FT_UInt count = FTC_GLYPH_NODE( snode )->item_count; FT_Memory memory = cache->memory; for ( ; count > 0; sbit++, count-- ) FREE( sbit->buffer ); - ftc_glyph_node_done( FTC_GLYPH_NODE(snode), cache ); + ftc_glyph_node_done( FTC_GLYPH_NODE( snode ), cache ); } static FT_Error - ftc_sbit_node_load( FTC_SBitNode snode, - FTC_Manager manager, - FTC_SBitFamily sfam, - FT_UInt gindex, - FT_ULong *asize ) + ftc_sbit_node_load( FTC_SBitNode snode, + FTC_Manager manager, + FTC_SBitFamily sfam, + FT_UInt gindex, + FT_ULong *asize ) { - FT_Error error; - FTC_GlyphNode gnode = FTC_GLYPH_NODE(snode); - FT_Memory memory; - FT_Face face; - FT_Size size; - FTC_SBit sbit; + FT_Error error; + FTC_GlyphNode gnode = FTC_GLYPH_NODE( snode ); + FT_Memory memory; + FT_Face face; + FT_Size size; + FTC_SBit sbit; + if ( gindex < (FT_UInt)gnode->item_start || gindex >= (FT_UInt)gnode->item_start + gnode->item_count ) { - FT_ERROR(( "FreeType.cache.sbit_load: invalid glyph index" )); + FT_ERROR(( "ftc_sbit_node_load: invalid glyph index" )); return FTC_Err_Invalid_Argument; } memory = manager->library->memory; - sbit = snode->sbits + (gindex - gnode->item_start); + sbit = snode->sbits + ( gindex - gnode->item_start ); error = FTC_Manager_Lookup_Size( manager, &sfam->desc.font, &face, &size ); if ( !error ) { - FT_UInt load_flags = FT_LOAD_DEFAULT; - FT_UInt type = sfam->desc.type; + FT_UInt load_flags = FT_LOAD_DEFAULT; + FT_UInt type = sfam->desc.type; /* determine load flags, depending on the font description's */ @@ -167,7 +167,7 @@ else { FT_ERROR(( - "FreeType.cache.sbit_load: cannot load scalable glyphs in an" + "ftc_sbit_node_load: cannot load scalable glyphs in an" " sbit cache, please check your arguments!\n" )); error = FTC_Err_Invalid_Argument; goto Exit; @@ -215,14 +215,14 @@ CHECK_CHAR( xadvance ) && CHECK_CHAR( yadvance ) ) { - sbit->width = (FT_Byte) bitmap->width; - sbit->height = (FT_Byte) bitmap->rows; - sbit->pitch = (FT_Char) bitmap->pitch; - sbit->left = (FT_Char) slot->bitmap_left; - sbit->top = (FT_Char) slot->bitmap_top; - sbit->xadvance = (FT_Char) xadvance; - sbit->yadvance = (FT_Char) yadvance; - sbit->format = (FT_Byte) bitmap->pixel_mode; + sbit->width = (FT_Byte)bitmap->width; + sbit->height = (FT_Byte)bitmap->rows; + sbit->pitch = (FT_Char)bitmap->pitch; + sbit->left = (FT_Char)slot->bitmap_left; + sbit->top = (FT_Char)slot->bitmap_top; + sbit->xadvance = (FT_Char)xadvance; + sbit->yadvance = (FT_Char)yadvance; + sbit->format = (FT_Byte)bitmap->pixel_mode; /* grab the bitmap when possible - this is a hack !! */ if ( slot->flags & ft_glyph_own_bitmap ) @@ -238,16 +238,16 @@ /* now, compute size */ if ( asize ) - *asize = ABS(sbit->pitch) * sbit->height; + *asize = ABS( sbit->pitch ) * sbit->height; } /* glyph dimensions ok */ } /* glyph loading successful */ - /* ignore the errors that might have occurred -- */ - /* we recognize unloaded glyphs with `sbit.buffer == 0' */ - /* and 'width == 255', 'height == 0' */ - /* */ + /* ignore the errors that might have occurred -- */ + /* we mark unloaded glyphs with `sbit.buffer == 0' */ + /* and 'width == 255', 'height == 0' */ + /* */ if ( error ) { sbit->width = 255; @@ -268,17 +268,18 @@ { FT_Error error; - ftc_glyph_node_init( FTC_GLYPH_NODE(snode), + + ftc_glyph_node_init( FTC_GLYPH_NODE( snode ), gquery->gindex, - FTC_GLYPH_FAMILY(gquery->query.family) ); + FTC_GLYPH_FAMILY( gquery->query.family ) ); error = ftc_sbit_node_load( snode, cache->manager, - FTC_SBIT_FAMILY( FTC_QUERY(gquery)->family ), + FTC_SBIT_FAMILY( FTC_QUERY( gquery )->family ), gquery->gindex, NULL ); if ( error ) - ftc_glyph_node_done( FTC_GLYPH_NODE(snode), cache ); + ftc_glyph_node_done( FTC_GLYPH_NODE( snode ), cache ); return error; } @@ -287,7 +288,7 @@ FT_CALLBACK_DEF( FT_ULong ) ftc_sbit_node_weight( FTC_SBitNode snode ) { - FTC_GlyphNode gnode = FTC_GLYPH_NODE(snode); + FTC_GlyphNode gnode = FTC_GLYPH_NODE( snode ); FT_UInt count = gnode->item_count; FTC_SBit sbit = snode->sbits; FT_Int pitch; @@ -295,10 +296,10 @@ /* the node itself */ - size = sizeof ( *snode ); + size = sizeof ( *snode ); /* the sbit records */ - size += FTC_GLYPH_NODE(snode)->item_count * sizeof ( FTC_SBitRec ); + size += FTC_GLYPH_NODE( snode )->item_count * sizeof ( FTC_SBitRec ); for ( ; count > 0; count--, sbit++ ) { @@ -322,25 +323,28 @@ FTC_SBitQuery squery, FTC_Cache cache ) { - FTC_GlyphQuery gquery = FTC_GLYPH_QUERY(squery); - FTC_GlyphNode gnode = FTC_GLYPH_NODE(snode); + FTC_GlyphQuery gquery = FTC_GLYPH_QUERY( squery ); + FTC_GlyphNode gnode = FTC_GLYPH_NODE( snode ); FT_Bool result; + result = ftc_glyph_node_compare( gnode, gquery ); if ( result ) { /* check if we need to load the glyph bitmap now */ FT_UInt gindex = gquery->gindex; - FTC_SBit sbit = snode->sbits + (gindex - gnode->item_start); + FTC_SBit sbit = snode->sbits + ( gindex - gnode->item_start ); + if ( sbit->buffer == NULL && sbit->width != 255 ) { FT_ULong size; + /* yes, it's safe to ignore errors here */ ftc_sbit_node_load( snode, cache->manager, - FTC_SBIT_FAMILY( FTC_QUERY(squery)->family ), + FTC_SBIT_FAMILY( FTC_QUERY( squery )->family ), gindex, &size ); @@ -370,6 +374,7 @@ FT_Error error; FT_Face face; + sfam->desc = squery->desc; /* we need to compute "cquery.item_total" now */ @@ -378,11 +383,11 @@ &face ); if ( !error ) { - error = ftc_glyph_family_init( FTC_GLYPH_FAMILY(sfam), + error = ftc_glyph_family_init( FTC_GLYPH_FAMILY( sfam ), FTC_IMAGE_DESC_HASH( &sfam->desc ), FTC_SBIT_ITEMS_PER_NODE, face->num_glyphs, - FTC_GLYPH_QUERY(squery), + FTC_GLYPH_QUERY( squery ), cache ); } @@ -391,24 +396,23 @@ FT_CALLBACK_DEF( FT_Bool ) - ftc_sbit_family_compare( FTC_SBitFamily sfam, - FTC_SBitQuery squery ) + ftc_sbit_family_compare( FTC_SBitFamily sfam, + FTC_SBitQuery squery ) { FT_Bool result; /* we need to set the "cquery.cset" field or our query for */ - /* faster glyph comparisons in ftc_sbit_node_compare.. */ - /* */ + /* faster glyph comparisons in ftc_sbit_node_compare */ + /* */ result = FT_BOOL( FTC_IMAGE_DESC_COMPARE( &sfam->desc, &squery->desc ) ); if ( result ) - FTC_GLYPH_FAMILY_FOUND(sfam,squery); + FTC_GLYPH_FAMILY_FOUND( sfam, squery ); return result; } - /*************************************************************************/ /*************************************************************************/ /***** *****/ @@ -418,25 +422,24 @@ /*************************************************************************/ - FT_CALLBACK_TABLE_DEF const FTC_Cache_ClassRec ftc_sbit_cache_class = { - sizeof( FTC_CacheRec ), - (FTC_Cache_InitFunc) ftc_cache_init, - (FTC_Cache_ClearFunc) ftc_cache_clear, - (FTC_Cache_DoneFunc) ftc_cache_done, - - sizeof( FTC_SBitFamilyRec ), - (FTC_Family_InitFunc) ftc_sbit_family_init, - (FTC_Family_CompareFunc) ftc_sbit_family_compare, - (FTC_Family_DoneFunc) ftc_glyph_family_done, - - sizeof( FTC_SBitNodeRec ), - (FTC_Node_InitFunc) ftc_sbit_node_init, - (FTC_Node_WeightFunc) ftc_sbit_node_weight, - (FTC_Node_CompareFunc) ftc_sbit_node_compare, - (FTC_Node_DoneFunc) ftc_sbit_node_done + sizeof ( FTC_CacheRec ), + (FTC_Cache_InitFunc) ftc_cache_init, + (FTC_Cache_ClearFunc)ftc_cache_clear, + (FTC_Cache_DoneFunc) ftc_cache_done, + + sizeof ( FTC_SBitFamilyRec ), + (FTC_Family_InitFunc) ftc_sbit_family_init, + (FTC_Family_CompareFunc)ftc_sbit_family_compare, + (FTC_Family_DoneFunc) ftc_glyph_family_done, + + sizeof ( FTC_SBitNodeRec ), + (FTC_Node_InitFunc) ftc_sbit_node_init, + (FTC_Node_WeightFunc) ftc_sbit_node_weight, + (FTC_Node_CompareFunc)ftc_sbit_node_compare, + (FTC_Node_DoneFunc) ftc_sbit_node_done }; @@ -465,7 +468,8 @@ FTC_SBitQueryRec squery; FTC_SBitNode node; - /* argument checks delayed to ftc_cache_lookup */ + + /* other argument checks delayed to ftc_cache_lookup */ if ( !ansbit ) return FTC_Err_Invalid_Argument; @@ -477,25 +481,24 @@ squery.gquery.gindex = gindex; squery.desc = *desc; - error = ftc_cache_lookup( FTC_CACHE(cache), - FTC_QUERY(&squery), - (FTC_Node*) &node ); + error = ftc_cache_lookup( FTC_CACHE( cache ), + FTC_QUERY( &squery ), + (FTC_Node*)&node ); if ( !error ) { - *ansbit = node->sbits + (gindex - FTC_GLYPH_NODE(node)->item_start); + *ansbit = node->sbits + ( gindex - FTC_GLYPH_NODE( node )->item_start ); if ( anode ) { - *anode = FTC_NODE(node); - FTC_NODE(node)->ref_count ++; + *anode = FTC_NODE( node ); + FTC_NODE( node )->ref_count++; } } return error; } - - /* backwards-compatibility functions */ + /* backwards-compatibility functions */ FT_EXPORT_DEF( FT_Error ) FTC_SBit_Cache_New( FTC_Manager manager, @@ -513,11 +516,12 @@ { FTC_ImageDesc desc0; + if ( !desc ) return FT_Err_Invalid_Argument; desc0.font = desc->font; - desc0.type = (FT_UInt32) desc->image_type; + desc0.type = (FT_UInt32)desc->image_type; return FTC_SBitCache_Lookup( (FTC_SBitCache)cache, &desc0, @@ -527,5 +531,4 @@ } - /* END */ diff --git a/src/cache/ftlru.c b/src/cache/ftlru.c index 6d2c897c6..c2bae6720 100644 --- a/src/cache/ftlru.c +++ b/src/cache/ftlru.c @@ -46,7 +46,7 @@ list->clazz = clazz; list->memory = memory; list->max_nodes = max_nodes; - list->data = user_data; + list->data = user_data; if ( clazz->list_init ) {