* src/cache/ftcbasic.c (ftc_basic_family_compare,

ChangeLog

@@ -1,6 +1,72 @@
+2004-05-14  Werner Lemberg  <wl@gnu.org>
+
+	* src/cache/ftcbasic.c (ftc_basic_family_compare,
+	ftc_basic_family_init, ftc_basic_family_get_count,
+	ftc_basic_family_load_bitmap, ftc_basic_family_load_glyph,
+	ftc_basic_gnode_compare_faceid): Adjust parameters and return types
+	to prototypes given in header files from include/freetype/cache.
+	Use casts to proper types locally.
+	(ftc_basic_image_family_class, ftc_basic_image_cache_class,
+	ftc_basic_sbit_family_class, ftc_basic_sbit_cache_class): Remove
+	casts.
+
+	* src/cache/ftccback.h: Adjust parameters and return types to
+	prototypes given in header files from include/freetype/cache.
+
+	* src/cache/ftcimage.c (ftc_inode_free, ftc_inode_new,
+	ftc_inode_weight): Adjust parameters and return types to prototypes
+	given in header files from include/freetype/cache.  Use casts to
+	proper types locally.
+
+	* src/cache/ftcsbits.c (ftc_snode_free, ftc_snode_new,
+	ftc_snode_weight, ftc_snode_compare): Adjust parameters and return
+	types to prototypes given in header files from
+	include/freetype/cache.  Use casts to proper types locally.
+
+	* src/cache/ftccmap.c (ftc_cmap_node_free, ftc_cmap_node_new,
+	ftc_cmap_node_weight, ftc_cmap_node_compare,
+	ftc_cmap_node_remove_faceid): Adjust parameters and return types to
+	prototypes given in header files from include/freetype/cache.  Use
+	casts to proper types locally.
+	(ftc_cmap_cache_class): Remove casts.
+
+	* src/cache/ftcglyph.c (ftc_gnode_compare, ftc_gcache_init,
+	ftc_gcache_done): Adjust parameters and return types to prototypes
+	given in header files from include/freetype/cache.  Use casts to
+	proper types locally.
+
+	* src/cache/ftcmanag.c (ftc_size_node_done, ftc_size_node_compare,
+	ftc_size_node_init, ftc_size_node_reset,
+	ftc_size_node_compare_faceid, ftc_face_node_init,
+	ftc_face_node_done, ftc_face_node_compare: Adjust parameters and
+	return types to prototypes given in header files from
+	include/freetype/cache.  Use casts to proper types locally.
+
+	(ftc_size_list_class, ftc_face_list_class): Remove casts.
+
+2004-05-13  Werner Lemberg  <wl@gnu.org>
+
+	* src/autohint/ahmodule.c (ft_autohinter_init, ft_autohinter_done):
+	Use FT_Module as parameter and do a cast to FT_AutoHinter locally.
+	(autohint_module_class): Remove casts.
+
+	* src/base/ftglyph.c (ft_bitmap_glyph_init, ft_bitmap_glyph_copy,
+	ft_bitmap_glyph_done, ft_bitmap_glyph_bbox, ft_outline_glyph_init,
+	ft_outline_glyph_done, ft_outline_glyph_copy,
+	ft_outline_glyph_transform, ft_outline_glyph_bbox,
+	ft_outline_glyph_prepare): Use FT_Glyph as parameter and do a cast
+	to FT_XXXGlyph locally.
+	Use FT_CALLBACK_DEF throughout.
+	(ft_bitmap_glyph_class, ft_outline_glyph_class): Remove casts.
+
+	* src/bdf/bdfdrivr.c (bdf_cmap_init, bdf_cmap_done,
+	bdf_cmap_char_index, bdf_cmap_char_next): Use FT_CMap as parameter
+	and do a cast to BDF_CMap locally.
+	(bdf_cmap_class): Remove casts.
+
 2004-05-12  Werner Lemberg  <wl@gnu.org>
 
-	* src/cff/cffgload.h (CFF_Builder): Remove `error'
+	* src/cff/cffgload.h (CFF_Builder): Remove `error'.
 	* src/cff/cffgload.c (cff_decoder_parse_charstrings): Replace
 	`Memory_Error' with `Fail' und update all users.
 

src/autohint/ahmodule.c

@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Auto-hinting module implementation (declaration).                    */
 /*                                                                         */
-/*  Copyright 2000-2001, 2002, 2003 Catharon Productions Inc.              */
+/*  Copyright 2000-2001, 2002, 2003, 2004 Catharon Productions Inc.        */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -39,24 +39,30 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  ft_autohinter_init( FT_AutoHinter  module )
+  ft_autohinter_init( FT_Module  module )       /* FT_AutoHinter */
   {
-    FT_Error  error;
+    FT_AutoHinter  autohinter = (FT_AutoHinter)module;
+    FT_Error       error;
 
 
-    error = ah_hinter_new( module->root.library, &module->hinter );
+    error = ah_hinter_new( module->library, &autohinter->hinter );
+
 #ifdef DEBUG_HINTER
     if ( !error )
-      ah_debug_hinter = module->hinter;
+      ah_debug_hinter = autohinter->hinter;
 #endif
+
     return error;
   }
 
 
   FT_CALLBACK_DEF( void )
-  ft_autohinter_done( FT_AutoHinter  module )
+  ft_autohinter_done( FT_Module  module )
   {
-    ah_hinter_done( module->hinter );
+    FT_AutoHinter  autohinter = (FT_AutoHinter)module;
+
+
+    ah_hinter_done( autohinter->hinter );
 
 #ifdef DEBUG_HINTER
     ah_debug_hinter = NULL;
@@ -128,9 +134,9 @@
 
     (const void*) &ft_autohinter_service,
 
-    (FT_Module_Constructor)ft_autohinter_init,
-    (FT_Module_Destructor) ft_autohinter_done,
-    (FT_Module_Requester)  0
+    ft_autohinter_init,
+    ft_autohinter_done,
+    0                       /* FT_Module_Requester */
   };
 
 

src/base/ftglyph.c

@@ -138,13 +138,14 @@
   }
 
 
-  static FT_Error
-  ft_bitmap_glyph_init( FT_BitmapGlyph  glyph,
-                        FT_GlyphSlot    slot )
+  FT_CALLBACK_DEF( FT_Error )
+  ft_bitmap_glyph_init( FT_Glyph      bitmap_glyph,
+                        FT_GlyphSlot  slot )
   {
-    FT_Error    error   = FT_Err_Ok;
-    FT_Library  library = FT_GLYPH(glyph)->library;
-    FT_Memory   memory  = library->memory;
+    FT_BitmapGlyph  glyph   = (FT_BitmapGlyph)bitmap_glyph;
+    FT_Error        error   = FT_Err_Ok;
+    FT_Library      library = FT_GLYPH( glyph )->library;
+    FT_Memory       memory  = library->memory;
 
 
     if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
@@ -171,11 +172,13 @@
   }
 
 
-  static FT_Error
-  ft_bitmap_glyph_copy( FT_BitmapGlyph  source,
-                        FT_BitmapGlyph  target )
+  FT_CALLBACK_DEF( FT_Error )
+  ft_bitmap_glyph_copy( FT_Glyph  bitmap_source,
+                        FT_Glyph  bitmap_target )
   {
-    FT_Memory  memory = source->root.library->memory;
+    FT_BitmapGlyph  source = (FT_BitmapGlyph)bitmap_source;
+    FT_BitmapGlyph  target = (FT_BitmapGlyph)bitmap_target;
+    FT_Memory       memory = bitmap_source->library->memory;
 
 
     target->left = source->left;
@@ -185,20 +188,24 @@
   }
 
 
-  static void
-  ft_bitmap_glyph_done( FT_BitmapGlyph  glyph )
+  FT_CALLBACK_DEF( void )
+  ft_bitmap_glyph_done( FT_Glyph  bitmap_glyph )
   {
-    FT_Memory  memory = FT_GLYPH(glyph)->library->memory;
+    FT_BitmapGlyph  glyph  = (FT_BitmapGlyph)bitmap_glyph;
+    FT_Memory       memory = FT_GLYPH( glyph )->library->memory;
 
 
     FT_FREE( glyph->bitmap.buffer );
   }
 
 
-  static void
-  ft_bitmap_glyph_bbox( FT_BitmapGlyph  glyph,
-                        FT_BBox*        cbox )
+  FT_CALLBACK_DEF( void )
+  ft_bitmap_glyph_bbox( FT_Glyph  bitmap_glyph,
+                        FT_BBox*  cbox )
   {
+    FT_BitmapGlyph  glyph = (FT_BitmapGlyph)bitmap_glyph;
+
+
     cbox->xMin = glyph->left << 6;
     cbox->xMax = cbox->xMin + ( glyph->bitmap.width << 6 );
     cbox->yMax = glyph->top << 6;
@@ -209,15 +216,15 @@
   FT_CALLBACK_TABLE_DEF
   const FT_Glyph_Class  ft_bitmap_glyph_class =
   {
-    sizeof( FT_BitmapGlyphRec ),
+    sizeof ( FT_BitmapGlyphRec ),
     FT_GLYPH_FORMAT_BITMAP,
 
-    (FT_Glyph_InitFunc)     ft_bitmap_glyph_init,
-    (FT_Glyph_DoneFunc)     ft_bitmap_glyph_done,
-    (FT_Glyph_CopyFunc)     ft_bitmap_glyph_copy,
-    (FT_Glyph_TransformFunc)0,
-    (FT_Glyph_GetBBoxFunc)  ft_bitmap_glyph_bbox,
-    (FT_Glyph_PrepareFunc)  0
+    ft_bitmap_glyph_init,
+    ft_bitmap_glyph_done,
+    ft_bitmap_glyph_copy,
+    0,                          /* FT_Glyph_TransformFunc */
+    ft_bitmap_glyph_bbox,
+    0                           /* FT_Glyph_PrepareFunc   */
   };
 
 
@@ -230,14 +237,15 @@
   /*************************************************************************/
 
 
-  static FT_Error
-  ft_outline_glyph_init( FT_OutlineGlyph  glyph,
-                         FT_GlyphSlot     slot )
+  FT_CALLBACK_DEF( FT_Error )
+  ft_outline_glyph_init( FT_Glyph      outline_glyph,
+                         FT_GlyphSlot  slot )
   {
-    FT_Error     error   = FT_Err_Ok;
-    FT_Library   library = FT_GLYPH(glyph)->library;
-    FT_Outline*  source  = &slot->outline;
-    FT_Outline*  target  = &glyph->outline;
+    FT_OutlineGlyph  glyph   = (FT_OutlineGlyph)outline_glyph;
+    FT_Error         error   = FT_Err_Ok;
+    FT_Library       library = FT_GLYPH( glyph )->library;
+    FT_Outline*      source  = &slot->outline;
+    FT_Outline*      target  = &glyph->outline;
 
 
     /* check format in glyph slot */
@@ -268,19 +276,24 @@
   }
 
 
-  static void
-  ft_outline_glyph_done( FT_OutlineGlyph  glyph )
+  FT_CALLBACK_DEF( void )
+  ft_outline_glyph_done( FT_Glyph  outline_glyph )
   {
+    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
+
+
     FT_Outline_Done( FT_GLYPH( glyph )->library, &glyph->outline );
   }
 
 
-  static FT_Error
-  ft_outline_glyph_copy( FT_OutlineGlyph  source,
-                         FT_OutlineGlyph  target )
+  FT_CALLBACK_DEF( FT_Error )
+  ft_outline_glyph_copy( FT_Glyph  outline_source,
+                         FT_Glyph  outline_target )
   {
-    FT_Error    error;
-    FT_Library  library = FT_GLYPH( source )->library;
+    FT_OutlineGlyph  source  = (FT_OutlineGlyph)outline_source;
+    FT_OutlineGlyph  target  = (FT_OutlineGlyph)outline_target;
+    FT_Error         error;
+    FT_Library       library = FT_GLYPH( source )->library;
 
 
     error = FT_Outline_New( library, source->outline.n_points,
@@ -292,11 +305,14 @@
   }
 
 
-  static void
-  ft_outline_glyph_transform( FT_OutlineGlyph  glyph,
-                              FT_Matrix*       matrix,
-                              FT_Vector*       delta )
+  FT_CALLBACK_DEF( void )
+  ft_outline_glyph_transform( FT_Glyph    outline_glyph,
+                              FT_Matrix*  matrix,
+                              FT_Vector*  delta )
   {
+    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
+
+
     if ( matrix )
       FT_Outline_Transform( &glyph->outline, matrix );
 
@@ -305,18 +321,24 @@
   }
 
 
-  static void
-  ft_outline_glyph_bbox( FT_OutlineGlyph  glyph,
-                         FT_BBox*         bbox )
+  FT_CALLBACK_DEF( void )
+  ft_outline_glyph_bbox( FT_Glyph  outline_glyph,
+                         FT_BBox*  bbox )
   {
+    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
+
+
     FT_Outline_Get_CBox( &glyph->outline, bbox );
   }
 
 
-  static FT_Error
-  ft_outline_glyph_prepare( FT_OutlineGlyph  glyph,
-                            FT_GlyphSlot     slot )
+  FT_CALLBACK_DEF( FT_Error )
+  ft_outline_glyph_prepare( FT_Glyph      outline_glyph,
+                            FT_GlyphSlot  slot )
   {
+    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
+
+
     slot->format         = FT_GLYPH_FORMAT_OUTLINE;
     slot->outline        = glyph->outline;
     slot->outline.flags &= ~FT_OUTLINE_OWNER;
@@ -328,15 +350,15 @@
   FT_CALLBACK_TABLE_DEF
   const FT_Glyph_Class  ft_outline_glyph_class =
   {
-    sizeof( FT_OutlineGlyphRec ),
+    sizeof ( FT_OutlineGlyphRec ),
     FT_GLYPH_FORMAT_OUTLINE,
 
-    (FT_Glyph_InitFunc)     ft_outline_glyph_init,
-    (FT_Glyph_DoneFunc)     ft_outline_glyph_done,
-    (FT_Glyph_CopyFunc)     ft_outline_glyph_copy,
-    (FT_Glyph_TransformFunc)ft_outline_glyph_transform,
-    (FT_Glyph_GetBBoxFunc)  ft_outline_glyph_bbox,
-    (FT_Glyph_PrepareFunc)  ft_outline_glyph_prepare
+    ft_outline_glyph_init,
+    ft_outline_glyph_done,
+    ft_outline_glyph_copy,
+    ft_outline_glyph_transform,
+    ft_outline_glyph_bbox,
+    ft_outline_glyph_prepare
   };
 
 
@@ -644,7 +666,7 @@
       goto Exit;
 
     /* in case of success, copy the bitmap to the glyph bitmap */
-    error = ft_bitmap_glyph_init( bitmap, &dummy );
+    error = ft_bitmap_glyph_init( (FT_Glyph)bitmap, &dummy );
     if ( error )
       goto Exit;
 

src/bdf/bdfdrivr.c

@@ -60,9 +60,12 @@ THE SOFTWARE.
 
 
   FT_CALLBACK_DEF( FT_Error )
-  bdf_cmap_init( BDF_CMap  cmap )
+  bdf_cmap_init( FT_CMap     bdfcmap,
+                 FT_Pointer  init_data )
   {
+    BDF_CMap  cmap = (BDF_CMap)bdfcmap;
     BDF_Face  face = (BDF_Face)FT_CMAP_FACE( cmap );
+    FT_UNUSED( init_data );
 
 
     cmap->num_encodings = face->bdffont->glyphs_used;
@@ -73,20 +76,24 @@ THE SOFTWARE.
 
 
   FT_CALLBACK_DEF( void )
-  bdf_cmap_done( BDF_CMap  cmap )
+  bdf_cmap_done( FT_CMap  bdfcmap )
   {
+    BDF_CMap  cmap = (BDF_CMap)bdfcmap;
+
+
     cmap->encodings     = NULL;
     cmap->num_encodings = 0;
   }
 
 
   FT_CALLBACK_DEF( FT_UInt )
-  bdf_cmap_char_index( BDF_CMap   cmap,
+  bdf_cmap_char_index( FT_CMap    bdfcmap,
                        FT_UInt32  charcode )
   {
+    BDF_CMap          cmap      = (BDF_CMap)bdfcmap;
     BDF_encoding_el*  encodings = cmap->encodings;
     FT_UInt           min, max, mid;
-    FT_UInt           result = 0;
+    FT_UInt           result    = 0;
 
 
     min = 0;
@@ -117,9 +124,10 @@ THE SOFTWARE.
 
 
   FT_CALLBACK_DEF( FT_UInt )
-  bdf_cmap_char_next( BDF_CMap    cmap,
+  bdf_cmap_char_next( FT_CMap     bdfcmap,
                       FT_UInt32  *acharcode )
   {
+    BDF_CMap          cmap      = (BDF_CMap)bdfcmap;
     BDF_encoding_el*  encodings = cmap->encodings;
     FT_UInt           min, max, mid;
     FT_UInt32         charcode = *acharcode + 1;
@@ -162,13 +170,14 @@ THE SOFTWARE.
   }
 
 
-  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec  bdf_cmap_class =
+  FT_CALLBACK_TABLE_DEF
+  const FT_CMap_ClassRec  bdf_cmap_class =
   {
-    sizeof( BDF_CMapRec ),
-    (FT_CMap_InitFunc)     bdf_cmap_init,
-    (FT_CMap_DoneFunc)     bdf_cmap_done,
-    (FT_CMap_CharIndexFunc)bdf_cmap_char_index,
-    (FT_CMap_CharNextFunc) bdf_cmap_char_next
+    sizeof ( BDF_CMapRec ),
+    bdf_cmap_init,
+    bdf_cmap_done,
+    bdf_cmap_char_index,
+    bdf_cmap_char_next
   };
 
 

src/cache/ftcbasic.c

@@ -62,19 +62,28 @@
   } FTC_BasicFamilyRec, *FTC_BasicFamily;
 
 
-  FT_CALLBACK_DEF( FT_Bool )
-  ftc_basic_family_compare( FTC_BasicFamily  family,
-                            FTC_BasicQuery   query )
+  FT_CALLBACK_DEF( FT_Int )
+  ftc_basic_family_compare( FTC_MruNode  ftcfamily,
+                            FT_Pointer   ftcquery )
   {
-    return FT_BOOL( FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs ) );
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
+
+
+    return FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs );
   }
 
 
   FT_CALLBACK_DEF( FT_Error )
-  ftc_basic_family_init( FTC_BasicFamily  family,
-                         FTC_BasicQuery   query,
-                         FTC_Cache        cache )
+  ftc_basic_family_init( FTC_MruNode  ftcfamily,
+                         FT_Pointer   ftcquery,
+                         FT_Pointer   ftccache )
   {
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
+    FTC_Cache        cache  = (FTC_Cache)ftccache;
+
+
     FTC_Family_Init( FTC_FAMILY( family ), cache );
     family->attrs = query->attrs;
     return 0;
@@ -82,12 +91,13 @@
 
 
   FT_CALLBACK_DEF( FT_UInt )
-  ftc_basic_family_get_count( FTC_BasicFamily  family,
-                              FTC_Manager      manager )
+  ftc_basic_family_get_count( FTC_Family   ftcfamily,
+                              FTC_Manager  manager )
   {
-    FT_Error  error;
-    FT_Face   face;
-    FT_UInt   result = 0;
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FT_Error         error;
+    FT_Face          face;
+    FT_UInt          result = 0;
 
 
     error = FTC_Manager_LookupFace( manager, family->attrs.scaler.face_id,
@@ -100,13 +110,14 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  ftc_basic_family_load_bitmap( FTC_BasicFamily  family,
-                                FT_UInt          gindex,
-                                FTC_Manager      manager,
-                                FT_Face         *aface )
+  ftc_basic_family_load_bitmap( FTC_Family   ftcfamily,
+                                FT_UInt      gindex,
+                                FTC_Manager  manager,
+                                FT_Face     *aface )
   {
-    FT_Error  error;
-    FT_Size   size;
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FT_Error         error;
+    FT_Size          size;
 
 
     error = FTC_Manager_LookupSize( manager, &family->attrs.scaler, &size );
@@ -126,15 +137,16 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  ftc_basic_family_load_glyph( FTC_BasicFamily  family,
-                               FT_UInt          gindex,
-                               FTC_Cache        cache,
-                               FT_Glyph        *aglyph )
+  ftc_basic_family_load_glyph( FTC_Family  ftcfamily,
+                               FT_UInt     gindex,
+                               FTC_Cache   cache,
+                               FT_Glyph   *aglyph )
   {
-    FT_Error    error;
-    FTC_Scaler  scaler = &family->attrs.scaler;
-    FT_Face     face;
-    FT_Size     size;
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FT_Error         error;
+    FTC_Scaler       scaler = &family->attrs.scaler;
+    FT_Face          face;
+    FT_Size          size;
 
 
     /* we will now load the glyph image */
@@ -173,11 +185,13 @@
 
 
   FT_CALLBACK_DEF( FT_Bool )
-  ftc_basic_gnode_compare_faceid( FTC_GNode   gnode,
-                                  FTC_FaceID  face_id,
+  ftc_basic_gnode_compare_faceid( FTC_Node    ftcgnode,
+                                  FT_Pointer  ftcface_id,
                                   FTC_Cache   cache )
   {
-    FTC_BasicFamily  family = (FTC_BasicFamily)gnode->family;
+    FTC_GNode        gnode   = (FTC_GNode)ftcgnode;
+    FTC_FaceID       face_id = (FTC_FaceID)ftcface_id;
+    FTC_BasicFamily  family  = (FTC_BasicFamily)gnode->family;
     FT_Bool          result;
 
 
@@ -203,13 +217,13 @@
   const FTC_IFamilyClassRec  ftc_basic_image_family_class =
   {
     {
-      sizeof( FTC_BasicFamilyRec ),
-      (FTC_MruNode_CompareFunc)ftc_basic_family_compare,
-      (FTC_MruNode_InitFunc)   ftc_basic_family_init,
-      (FTC_MruNode_ResetFunc)  NULL,
-      (FTC_MruNode_DoneFunc)   NULL
+      sizeof ( FTC_BasicFamilyRec ),
+      ftc_basic_family_compare,
+      ftc_basic_family_init,
+      0,                        /* FTC_MruNode_ResetFunc */
+      0                         /* FTC_MruNode_DoneFunc  */
     },
-    (FTC_IFamily_LoadGlyphFunc)ftc_basic_family_load_glyph
+    ftc_basic_family_load_glyph
   };
 
 
@@ -217,15 +231,15 @@
   const FTC_GCacheClassRec  ftc_basic_image_cache_class =
   {
     {
-      (FTC_Node_NewFunc)    ftc_inode_new,
-      (FTC_Node_WeightFunc) ftc_inode_weight,
-      (FTC_Node_CompareFunc)ftc_gnode_compare,
-      (FTC_Node_CompareFunc)ftc_basic_gnode_compare_faceid,
-      (FTC_Node_FreeFunc)   ftc_inode_free,
-
-      sizeof( FTC_GCacheRec ),
-      (FTC_Cache_InitFunc)  ftc_gcache_init,
-      (FTC_Cache_DoneFunc)  ftc_gcache_done
+      ftc_inode_new,
+      ftc_inode_weight,
+      ftc_gnode_compare,
+      ftc_basic_gnode_compare_faceid,
+      ftc_inode_free,
+
+      sizeof ( FTC_GCacheRec ),
+      ftc_gcache_init,
+      ftc_gcache_done
     },
     (FTC_MruListClass)&ftc_basic_image_family_class
   };
@@ -321,13 +335,13 @@
   {
     {
       sizeof( FTC_BasicFamilyRec ),
-      (FTC_MruNode_CompareFunc)ftc_basic_family_compare,
-      (FTC_MruNode_InitFunc)   ftc_basic_family_init,
-      (FTC_MruNode_ResetFunc)  NULL,
-      (FTC_MruNode_DoneFunc)   NULL
+      ftc_basic_family_compare,
+      ftc_basic_family_init,
+      0,                            /* FTC_MruNode_ResetFunc */
+      0                             /* FTC_MruNode_DoneFunc  */
     },
-    (FTC_SFamily_GetCountFunc) ftc_basic_family_get_count,
-    (FTC_SFamily_LoadGlyphFunc)ftc_basic_family_load_bitmap
+    ftc_basic_family_get_count,
+    ftc_basic_family_load_bitmap
   };
 
 
@@ -335,15 +349,15 @@
   const FTC_GCacheClassRec  ftc_basic_sbit_cache_class =
   {
     {
-      (FTC_Node_NewFunc)    ftc_snode_new,
-      (FTC_Node_WeightFunc) ftc_snode_weight,
-      (FTC_Node_CompareFunc)ftc_snode_compare,
-      (FTC_Node_CompareFunc)ftc_basic_gnode_compare_faceid,
-      (FTC_Node_FreeFunc)   ftc_snode_free,
-
-      sizeof( FTC_GCacheRec ),
-      (FTC_Cache_InitFunc)  ftc_gcache_init,
-      (FTC_Cache_DoneFunc)  ftc_gcache_done
+      ftc_snode_new,
+      ftc_snode_weight,
+      ftc_snode_compare,
+      ftc_basic_gnode_compare_faceid,
+      ftc_snode_free,
+
+      sizeof ( FTC_GCacheRec ),
+      ftc_gcache_init,
+      ftc_gcache_done
     },
     (FTC_MruListClass)&ftc_basic_sbit_family_class
   };

src/cache/ftccback.h

@@ -28,46 +28,49 @@
 
 
   FT_LOCAL( void )
-  ftc_inode_free( FTC_INode  inode,
+  ftc_inode_free( FTC_Node   inode,
                   FTC_Cache  cache );
 
   FT_LOCAL( FT_Error )
-  ftc_inode_new( FTC_INode   *pinode,
-                 FTC_GQuery   gquery,
-                 FTC_Cache    cache );
+  ftc_inode_new( FTC_Node   *pinode,
+                 FT_Pointer  gquery,
+                 FTC_Cache   cache );
 
   FT_LOCAL( FT_ULong )
-  ftc_inode_weight( FTC_INode  inode );
+  ftc_inode_weight( FTC_Node   inode,
+                    FTC_Cache  cache );
 
 
   FT_LOCAL( void )
-  ftc_snode_free( FTC_SNode  snode,
+  ftc_snode_free( FTC_Node   snode,
                   FTC_Cache  cache );
 
   FT_LOCAL( FT_Error )
-  ftc_snode_new( FTC_SNode  *psnode,
-                 FTC_GQuery  gquery,
+  ftc_snode_new( FTC_Node   *psnode,
+                 FT_Pointer  gquery,
                  FTC_Cache   cache );
 
   FT_LOCAL( FT_ULong )
-  ftc_snode_weight( FTC_SNode  snode );
+  ftc_snode_weight( FTC_Node   snode,
+                    FTC_Cache  cache );
 
   FT_LOCAL( FT_Bool )
-  ftc_snode_compare( FTC_SNode   snode,
-                     FTC_GQuery  gquery,
+  ftc_snode_compare( FTC_Node    snode,
+                     FT_Pointer  gquery,
                      FTC_Cache   cache );
 
 
   FT_LOCAL( FT_Bool )
-  ftc_gnode_compare( FTC_GNode   gnode,
-                     FTC_GQuery  gquery );
+  ftc_gnode_compare( FTC_Node    gnode,
+                     FT_Pointer  gquery,
+                     FTC_Cache   cache );
 
 
   FT_LOCAL( FT_Error )
-  ftc_gcache_init( FTC_GCache  cache );
+  ftc_gcache_init( FTC_Cache  cache );
 
   FT_LOCAL( void )
-  ftc_gcache_done( FTC_GCache  cache );
+  ftc_gcache_done( FTC_Cache  cache );
 
 
   FT_LOCAL( FT_Error )

src/cache/ftccmap.c

@@ -98,10 +98,11 @@
   /* no need for specific finalizer; we use `ftc_node_done' directly */
 
   FT_CALLBACK_DEF( void )
-  ftc_cmap_node_free( FTC_CMapNode  node,
-                      FTC_Cache     cache )
+  ftc_cmap_node_free( FTC_Node   ftcnode,
+                      FTC_Cache  cache )
   {
-    FT_Memory  memory = cache->memory;
+    FTC_CMapNode  node   = (FTC_CMapNode)ftcnode;
+    FT_Memory     memory = cache->memory;
 
 
     FT_FREE( node );
@@ -110,14 +111,16 @@
 
   /* initialize a new cmap node */
   FT_CALLBACK_DEF( FT_Error )
-  ftc_cmap_node_new( FTC_CMapNode  *anode,
-                     FTC_CMapQuery  query,
-                     FTC_Cache      cache )
+  ftc_cmap_node_new( FTC_Node   *ftcanode,
+                     FT_Pointer  ftcquery,
+                     FTC_Cache   cache )
   {
-    FT_Error      error;
-    FT_Memory     memory  = cache->memory;
-    FTC_CMapNode  node;
-    FT_UInt       nn;
+    FTC_CMapNode  *anode  = (FTC_CMapNode*)ftcanode;
+    FTC_CMapQuery  query  = (FTC_CMapQuery)ftcquery;
+    FT_Error       error;
+    FT_Memory      memory = cache->memory;
+    FTC_CMapNode   node;
+    FT_UInt        nn;
 
 
     if ( !FT_NEW( node ) )
@@ -138,9 +141,11 @@
 
   /* compute the weight of a given cmap node */
   FT_CALLBACK_DEF( FT_ULong )
-  ftc_cmap_node_weight( FTC_CMapNode  cnode )
+  ftc_cmap_node_weight( FTC_Node   cnode,
+                        FTC_Cache  cache )
   {
     FT_UNUSED( cnode );
+    FT_UNUSED( cache );
 
     return sizeof ( *cnode );
   }
@@ -148,9 +153,15 @@
 
   /* compare a cmap node to a given query */
   FT_CALLBACK_DEF( FT_Bool )
-  ftc_cmap_node_compare( FTC_CMapNode   node,
-                         FTC_CMapQuery  query )
+  ftc_cmap_node_compare( FTC_Node    ftcnode,
+                         FT_Pointer  ftcquery,
+                         FTC_Cache   cache )
   {
+    FTC_CMapNode   node  = (FTC_CMapNode)ftcnode;
+    FTC_CMapQuery  query = (FTC_CMapQuery)ftcquery;
+    FT_UNUSED( cache );
+
+
     if ( node->face_id    == query->face_id    &&
          node->cmap_index == query->cmap_index )
     {
@@ -165,9 +176,14 @@
 
 
   FT_CALLBACK_DEF( FT_Bool )
-  ftc_cmap_node_remove_faceid( FTC_CMapNode  node,
-                               FTC_FaceID    face_id )
+  ftc_cmap_node_remove_faceid( FTC_Node    ftcnode,
+                               FT_Pointer  ftcface_id,
+                               FTC_Cache   cache )
   {
+    FTC_CMapNode  node    = (FTC_CMapNode)ftcnode;
+    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
+    FT_UNUSED( cache );
+
     return FT_BOOL( node->face_id == face_id );
   }
 
@@ -184,15 +200,15 @@
   FT_CALLBACK_TABLE_DEF
   const FTC_CacheClassRec  ftc_cmap_cache_class =
   {
-    (FTC_Node_NewFunc)    ftc_cmap_node_new,
-    (FTC_Node_WeightFunc) ftc_cmap_node_weight,
-    (FTC_Node_CompareFunc)ftc_cmap_node_compare,
-    (FTC_Node_CompareFunc)ftc_cmap_node_remove_faceid,
-    (FTC_Node_FreeFunc)   ftc_cmap_node_free,
+    ftc_cmap_node_new,
+    ftc_cmap_node_weight,
+    ftc_cmap_node_compare,
+    ftc_cmap_node_remove_faceid,
+    ftc_cmap_node_free,
 
     sizeof ( FTC_CacheRec ),
-    (FTC_Cache_InitFunc)  ftc_cache_init,
-    (FTC_Cache_DoneFunc)  ftc_cache_done,
+    ftc_cache_init,
+    ftc_cache_done,
   };
 
 

src/cache/ftcglyph.c

@@ -74,9 +74,15 @@
 
 
   FT_LOCAL_DEF( FT_Bool )
-  ftc_gnode_compare( FTC_GNode   gnode,
-                     FTC_GQuery  gquery )
+  ftc_gnode_compare( FTC_Node    ftcgnode,
+                     FT_Pointer  ftcgquery,
+                     FTC_Cache   cache )
   {
+    FTC_GNode   gnode  = (FTC_GNode)ftcgnode;
+    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
+    FT_UNUSED( cache );
+
+
     return FTC_GNode_Compare( gnode, gquery );
   }
 
@@ -124,8 +130,11 @@
 
 
   FT_LOCAL_DEF( FT_Error )
-  ftc_gcache_init( FTC_GCache  cache )
+  ftc_gcache_init( FTC_Cache  ftccache )
   {
+    FTC_GCache  cache = (FTC_GCache)ftccache;
+
+
     return FTC_GCache_Init( cache );
   }
 
@@ -139,8 +148,11 @@
 
 
   FT_LOCAL_DEF( void )
-  ftc_gcache_done( FTC_GCache  cache )
+  ftc_gcache_done( FTC_Cache  ftccache )
   {
+    FTC_GCache  cache = (FTC_GCache)ftccache;
+
+
     FTC_GCache_Done( cache );
   }
 

src/cache/ftcimage.c

@@ -45,9 +45,12 @@
 
 
   FT_LOCAL_DEF( void )
-  ftc_inode_free( FTC_INode  inode,
+  ftc_inode_free( FTC_Node   ftcinode,
                   FTC_Cache  cache )
   {
+    FTC_INode  inode = (FTC_INode)ftcinode;
+
+
     FTC_INode_Free( inode, cache );
   }
 
@@ -85,10 +88,14 @@
 
 
   FT_LOCAL_DEF( FT_Error )
-  ftc_inode_new( FTC_INode   *pinode,
-                 FTC_GQuery   gquery,
-                 FTC_Cache    cache )
+  ftc_inode_new( FTC_Node   *ftcpinode,
+                 FT_Pointer  ftcgquery,
+                 FTC_Cache   cache )
   {
+    FTC_INode  *pinode = (FTC_INode*)ftcpinode;
+    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
+
+
     return FTC_INode_New( pinode, gquery, cache );
   }
 
@@ -136,8 +143,13 @@
 
 
   FT_LOCAL_DEF( FT_ULong )
-  ftc_inode_weight( FTC_INode  inode )
+  ftc_inode_weight( FTC_Node   ftcinode,
+                    FTC_Cache  ftccache )
   {
+    FTC_INode  inode = (FTC_INode)ftcinode;
+    FT_UNUSED( ftccache );
+
+
     return FTC_INode_Weight( inode );
   }
 

src/cache/ftcmanag.c

@@ -79,9 +79,12 @@
 
 
   FT_CALLBACK_DEF( void )
-  ftc_size_node_done( FTC_SizeNode  node )
+  ftc_size_node_done( FTC_MruNode  ftcnode,
+                      FT_Pointer   data )
   {
-    FT_Size  size = node->size;
+    FTC_SizeNode  node = (FTC_SizeNode)ftcnode;
+    FT_Size       size = node->size;
+    FT_UNUSED( data );
 
 
     if ( size )
@@ -89,11 +92,13 @@
   }
 
 
-  FT_CALLBACK_DEF( FT_Bool )
-  ftc_size_node_compare( FTC_SizeNode  node,
-                         FTC_Scaler    scaler )
+  FT_CALLBACK_DEF( FT_Int )
+  ftc_size_node_compare( FTC_MruNode  ftcnode,
+                         FT_Pointer   ftcscaler )
   {
-    FTC_Scaler  scaler0 = &node->scaler;
+    FTC_SizeNode  node    = (FTC_SizeNode)ftcnode;
+    FTC_Scaler    scaler  = (FTC_Scaler)ftcscaler;
+    FTC_Scaler    scaler0 = &node->scaler;
 
 
     if ( FTC_SCALER_COMPARE( scaler0, scaler ) )
@@ -106,10 +111,15 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  ftc_size_node_init( FTC_SizeNode  node,
-                      FTC_Scaler    scaler,
-                      FTC_Manager   manager )
+  ftc_size_node_init( FTC_MruNode  ftcnode,
+                      FT_Pointer   ftcscaler,
+                      FT_Pointer   ftcmanager )
   {
+    FTC_SizeNode  node    = (FTC_SizeNode)ftcnode;
+    FTC_Scaler    scaler  = (FTC_Scaler)ftcscaler;
+    FTC_Manager   manager = (FTC_Manager)ftcmanager;
+
+
     node->scaler = scaler[0];
 
     return ftc_scaler_lookup_size( manager, scaler, &node->size );
@@ -117,10 +127,15 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  ftc_size_node_reset( FTC_SizeNode  node,
-                       FTC_Scaler    scaler,
-                       FTC_Manager   manager )
+  ftc_size_node_reset( FTC_MruNode  ftcnode,
+                       FT_Pointer   ftcscaler,
+                       FT_Pointer   ftcmanager )
   {
+    FTC_SizeNode  node    = (FTC_SizeNode)ftcnode;
+    FTC_Scaler    scaler  = (FTC_Scaler)ftcscaler;
+    FTC_Manager   manager = (FTC_Manager)ftcmanager;
+
+
     FT_Done_Size( node->size );
 
     node->scaler = scaler[0];
@@ -132,20 +147,24 @@
   FT_CALLBACK_TABLE_DEF
   const FTC_MruListClassRec  ftc_size_list_class =
   {
-    sizeof( FTC_SizeNodeRec ),
-    (FTC_MruNode_CompareFunc)ftc_size_node_compare,
-    (FTC_MruNode_InitFunc)   ftc_size_node_init,
-    (FTC_MruNode_ResetFunc)  ftc_size_node_reset,
-    (FTC_MruNode_DoneFunc)   ftc_size_node_done
+    sizeof ( FTC_SizeNodeRec ),
+    ftc_size_node_compare,
+    ftc_size_node_init,
+    ftc_size_node_reset,
+    ftc_size_node_done
   };
 
 
   /* helper function used by ftc_face_node_done */
-  static FT_Bool
-  ftc_size_node_compare_faceid( FTC_SizeNode  node,
-                                FTC_FaceID    face_id )
+  static FT_Int
+  ftc_size_node_compare_faceid( FTC_MruNode  ftcnode,
+                                FT_Pointer   ftcface_id )
   {
-    return FT_BOOL( node->scaler.face_id == face_id );
+    FTC_SizeNode  node    = (FTC_SizeNode)ftcnode;
+    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
+
+
+    return node->scaler.face_id == face_id;
   }
 
 
@@ -202,11 +221,14 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  ftc_face_node_init( FTC_FaceNode  node,
-                      FTC_FaceID    face_id,
-                      FTC_Manager   manager )
+  ftc_face_node_init( FTC_MruNode  ftcnode,
+                      FT_Pointer   ftcface_id,
+                      FT_Pointer   ftcmanager )
   {
-    FT_Error  error;
+    FTC_FaceNode  node    = (FTC_FaceNode)ftcnode;
+    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
+    FTC_Manager   manager = (FTC_Manager)ftcmanager;
+    FT_Error      error;
 
 
     node->face_id = face_id;
@@ -227,15 +249,18 @@
 
 
   FT_CALLBACK_DEF( void )
-  ftc_face_node_done( FTC_FaceNode  node,
-                      FTC_Manager   manager )
+  ftc_face_node_done( FTC_MruNode  ftcnode,
+                      FT_Pointer   ftcmanager )
   {
+    FTC_FaceNode  node    = (FTC_FaceNode)ftcnode;
+    FTC_Manager   manager = (FTC_Manager)ftcmanager;
+
+
     /* we must begin by removing all scalers for the target face */
     /* from the manager's list                                   */
-    FTC_MruList_RemoveSelection(
-      & manager->sizes,
-      (FTC_MruNode_CompareFunc)ftc_size_node_compare_faceid,
-      node->face_id );
+    FTC_MruList_RemoveSelection( &manager->sizes,
+                                 ftc_size_node_compare_faceid,
+                                 node->face_id );
 
     /* all right, we can discard the face now */
     FT_Done_Face( node->face );
@@ -244,10 +269,14 @@
   }
 
 
-  FT_CALLBACK_DEF( FT_Bool )
-  ftc_face_node_compare( FTC_FaceNode  node,
-                         FTC_FaceID    face_id )
+  FT_CALLBACK_DEF( FT_Int )
+  ftc_face_node_compare( FTC_MruNode  ftcnode,
+                         FT_Pointer   ftcface_id )
   {
+    FTC_FaceNode  node    = (FTC_FaceNode)ftcnode;
+    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
+
+
     return FT_BOOL( node->face_id == face_id );
   }
 
@@ -255,12 +284,12 @@
   FT_CALLBACK_TABLE_DEF
   const FTC_MruListClassRec  ftc_face_list_class =
   {
-    sizeof( FTC_FaceNodeRec),
+    sizeof ( FTC_FaceNodeRec),
 
-    (FTC_MruNode_CompareFunc)ftc_face_node_compare,
-    (FTC_MruNode_InitFunc)   ftc_face_node_init,
-    (FTC_MruNode_ResetFunc)  NULL,
-    (FTC_MruNode_DoneFunc)   ftc_face_node_done
+    ftc_face_node_compare,
+    ftc_face_node_init,
+    0,                          /* FTC_MruNode_ResetFunc */
+    ftc_face_node_done
   };
 
 

src/cache/ftcsbits.c

@@ -77,9 +77,12 @@
 
 
   FT_LOCAL_DEF( void )
-  ftc_snode_free( FTC_SNode  snode,
+  ftc_snode_free( FTC_Node   ftcsnode,
                   FTC_Cache  cache )
   {
+    FTC_SNode  snode = (FTC_SNode)ftcsnode;
+
+
     FTC_SNode_Free( snode, cache );
   }
 
@@ -240,10 +243,14 @@
 
 
   FT_LOCAL_DEF( FT_Error )
-  ftc_snode_new( FTC_SNode  *psnode,
-                 FTC_GQuery  gquery,
+  ftc_snode_new( FTC_Node   *ftcpsnode,
+                 FT_Pointer  ftcgquery,
                  FTC_Cache   cache )
   {
+    FTC_SNode  *psnode = (FTC_SNode*)ftcpsnode;
+    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
+
+
     return FTC_SNode_New( psnode, gquery, cache );
   }
 
@@ -280,8 +287,13 @@
 
 
   FT_LOCAL_DEF( FT_ULong )
-  ftc_snode_weight( FTC_SNode  snode )
+  ftc_snode_weight( FTC_Node   ftcsnode,
+                    FTC_Cache  cache )
   {
+    FTC_SNode  snode = (FTC_SNode)ftcsnode;
+    FT_UNUSED( cache );
+
+
     return FTC_SNode_Weight( snode );
   }
 
@@ -322,10 +334,14 @@
 
 
   FT_LOCAL_DEF( FT_Bool )
-  ftc_snode_compare( FTC_SNode   snode,
-                     FTC_GQuery  gquery,
+  ftc_snode_compare( FTC_Node    ftcsnode,
+                     FT_Pointer  ftcgquery,
                      FTC_Cache   cache )
   {
+    FTC_SNode   snode  = (FTC_SNode)ftcsnode;
+    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
+
+
     return FTC_SNode_Compare( snode, gquery, cache );
   }