shithub: freetype+ttf2subf

Download patch

ref: ab8552321c70e947fedfd31709c43c4cb27d496f
parent: e4b32a5dc5517285dbecf9e058185a9d36712fbe
author: Werner Lemberg <[email protected]>
date: Tue Oct 31 17:13:54 EST 2000

Fixing include header for a `make multi' build.

Finishing formatting of cache stuff.

Fixed getDriverClass stuff -- added it to winfnt.c also.  Note that this
still has to be documented.

git/fs: mount .git/fs: mount/attach disallowed
--- a/include/freetype/cache/ftcsbits.h
+++ b/include/freetype/cache/ftcsbits.h
@@ -21,6 +21,7 @@
 
 
 #include <freetype/cache/ftcchunk.h>
+#include <freetype/cache/ftcimage.h>
 
 
 #ifdef __cplusplus
--- a/src/cache/ftcchunk.c
+++ b/src/cache/ftcchunk.c
@@ -22,6 +22,7 @@
 #include <freetype/internal/ftlist.h>
 #include <freetype/fterrors.h>
 
+
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
@@ -31,13 +32,11 @@
   /*************************************************************************/
 
 
-
   /* create a new chunk node, setting its cache index and ref count */
-  FT_EXPORT_FUNC( FT_Error )
-  FTC_ChunkNode_Init( FTC_ChunkNode  node,
-                      FTC_ChunkSet   cset,
-                      FT_UInt        index,
-                      FT_Bool        alloc )
+  FT_EXPORT_FUNC( FT_Error )  FTC_ChunkNode_Init( FTC_ChunkNode  node,
+                                                  FTC_ChunkSet   cset,
+                                                  FT_UInt        index,
+                                                  FT_Bool        alloc )
   {
     FTC_Chunk_Cache      cache = cset->cache;
     FTC_CacheNode_Data*  data  = FTC_CACHENODE_TO_DATA_P( &node->root );
@@ -44,14 +43,14 @@
     FT_Error             error = 0;
 
 
-    data->cache_index  = (FT_UShort) cache->root.cache_index;
-    data->ref_count    = (FT_Short)  0;
+    data->cache_index  = (FT_UShort)cache->root.cache_index;
+    data->ref_count    = (FT_Short) 0;
     node->cset         = cset;
-    node->cset_index   = (FT_UShort) index;
-    node->num_elements = (index+1 < cset->num_chunks)
-                       ? cset->element_count
-                       : cset->element_max   - cset->element_count*index;
-    if (alloc)
+    node->cset_index   = (FT_UShort)index;
+    node->num_elements = ( index + 1 < cset->num_chunks )
+                         ? cset->element_count
+                         : cset->element_max - cset->element_count*index;
+    if ( alloc )
     {
       /* allocate elements array */
       FT_Memory   memory;
@@ -58,19 +57,21 @@
 
 
       memory = cache->root.memory;
-      error  = MEM_Alloc( node->elements, cset->element_size *
-                                          cset->element_count );
+      error  = MEM_Alloc( node->elements,
+                          cset->element_size * cset->element_count );
     }
+
     return error;
   }
 
 
-  FT_EXPORT_FUNC( void )  FTC_ChunkNode_Destroy( FTC_ChunkNode    node )
+  FT_EXPORT_FUNC( void )  FTC_ChunkNode_Destroy( FTC_ChunkNode  node )
   {
-    FTC_ChunkSet  cset     = node->cset;
+    FTC_ChunkSet  cset = node->cset;
 
+
     /* remove from parent set table */
-    cset->chunks[ node->cset_index ] = 0;
+    cset->chunks[node->cset_index] = 0;
 
     /* destroy the node */
     cset->clazz->destroy_node( node );
@@ -77,9 +78,9 @@
   }
 
 
-  FT_EXPORT_FUNC( FT_ULong )  FTC_ChunkNode_Size( FTC_ChunkNode    node )
+  FT_EXPORT_FUNC( FT_ULong )  FTC_ChunkNode_Size( FTC_ChunkNode  node )
   {
-    FTC_ChunkSet  cset     = node->cset;
+    FTC_ChunkSet  cset = node->cset;
 
 
     return cset->clazz->size_node( node );
@@ -88,8 +89,8 @@
 
   FT_CPLUSPLUS( const FTC_CacheNode_Class )  ftc_chunk_cache_node_class =
   {
-    (FTC_CacheNode_SizeFunc)    FTC_ChunkNode_Size,
-    (FTC_CacheNode_DestroyFunc) FTC_ChunkNode_Destroy
+    (FTC_CacheNode_SizeFunc)   FTC_ChunkNode_Size,
+    (FTC_CacheNode_DestroyFunc)FTC_ChunkNode_Destroy
   };
 
 
@@ -102,10 +103,9 @@
   /*************************************************************************/
 
 
-  FT_EXPORT_FUNC( FT_Error )
-  FTC_ChunkSet_New( FTC_Chunk_Cache   cache,
-                    FT_Pointer        type,
-                    FTC_ChunkSet     *aset )
+  FT_EXPORT_FUNC( FT_Error )  FTC_ChunkSet_New( FTC_Chunk_Cache  cache,
+                                                FT_Pointer       type,
+                                                FTC_ChunkSet*    aset )
   {
     FT_Error      error;
     FT_Memory     memory  = cache->root.memory;
@@ -124,19 +124,19 @@
     if ( ALLOC( cset, clazz->cset_byte_size ) )
       goto Exit;
 
-    cset->cache         = cache;
-    cset->manager       = manager;
-    cset->memory        = memory;
-    cset->clazz         = clazz;
+    cset->cache   = cache;
+    cset->manager = manager;
+    cset->memory  = memory;
+    cset->clazz   = clazz;
 
     /* now compute element_max, element_count and element_size */
-    error = clazz->sizes( cset, type);
-    if (error)
+    error = clazz->sizes( cset, type );
+    if ( error )
       goto Exit;
 
     /* compute maximum number of nodes */
-    cset->num_chunks = (cset->element_max   +
-                        cset->element_count - 1) / cset->element_count;
+    cset->num_chunks = ( cset->element_max + cset->element_count - 1 ) /
+                       cset->element_count;
 
     /* allocate chunk pointers table */
     if ( ALLOC_ARRAY( cset->chunks, cset->num_chunks, FTC_ChunkNode ) )
@@ -165,26 +165,27 @@
 
   FT_EXPORT_FUNC( void )  FTC_ChunkSet_Destroy( FTC_ChunkSet  cset )
   {
-    FTC_Chunk_Cache         cache        = cset->cache;
-    FTC_Manager             manager      = cache->root.manager;
-    FT_List                 glyphs_lru   = &manager->global_lru;
-    FTC_ChunkNode*          bucket       = cset->chunks;
-    FTC_ChunkNode*          bucket_limit = bucket + cset->num_chunks;
-    FT_Memory               memory       = cache->root.memory;
+    FTC_Chunk_Cache      cache        = cset->cache;
+    FTC_Manager          manager      = cache->root.manager;
+    FT_List              glyphs_lru   = &manager->global_lru;
+    FTC_ChunkNode*       bucket       = cset->chunks;
+    FTC_ChunkNode*       bucket_limit = bucket + cset->num_chunks;
+    FT_Memory            memory       = cache->root.memory;
 
-    FTC_ChunkSet_Class*     clazz = cset->clazz;
+    FTC_ChunkSet_Class*  clazz = cset->clazz;
 
 
     /* for each bucket, free the list of glyph nodes */
     for ( ; bucket < bucket_limit; bucket++ )
     {
-      FTC_ChunkNode   node = bucket[0];
-      FT_ListNode     lrunode;
+      FTC_ChunkNode  node = bucket[0];
+      FT_ListNode    lrunode;
 
+
       lrunode = FTC_CHUNKNODE_TO_LRUNODE( node );
 
       manager->num_bytes -= clazz->size_node( node );
-      manager->num_nodes --;
+      manager->num_nodes--;
 
       FT_List_Remove( glyphs_lru, lrunode );
 
@@ -201,32 +202,33 @@
   }
 
 
-  FT_EXPORT_FUNC( FT_Error )
-  FTC_ChunkSet_Lookup_Node( FTC_ChunkSet    cset,
-                            FT_UInt         glyph_index,
-                            FTC_ChunkNode  *anode,
-                            FT_UInt        *aindex )
+  FT_EXPORT_FUNC( FT_Error )  FTC_ChunkSet_Lookup_Node(
+                                FTC_ChunkSet    cset,
+                                FT_UInt         glyph_index,
+                                FTC_ChunkNode*  anode,
+                                FT_UInt*        aindex )
   {
-    FTC_Chunk_Cache  cache   = cset->cache;
-    FTC_Manager      manager = cache->root.manager;
-    FT_Error         error   = 0;
+    FTC_Chunk_Cache      cache   = cset->cache;
+    FTC_Manager          manager = cache->root.manager;
+    FT_Error             error   = 0;
 
-    FTC_ChunkSet_Class*  clazz = cset->clazz;
+    FTC_ChunkSet_Class*  clazz   = cset->clazz;
 
 
     *anode = 0;
-    if (glyph_index >= cset->element_max)
+    if ( glyph_index >= cset->element_max )
       error = FT_Err_Invalid_Argument;
     else
     {
       FT_UInt         chunk_size  = cset->element_count;
-      FT_UInt         chunk_index = glyph_index/chunk_size;
+      FT_UInt         chunk_index = glyph_index / chunk_size;
       FTC_ChunkNode*  pnode       = cset->chunks + chunk_index;
       FTC_ChunkNode   node        = *pnode;
 
-      if (!node)
+
+      if ( !node )
       {
-        /* we didn't found the glyph image, we will now create a new one */
+        /* we didn't found the glyph image; we will now create a new one */
         error = clazz->new_node( cset, chunk_index, &node );
         if ( error )
           goto Exit;
@@ -235,12 +237,13 @@
         *pnode = node;
 
         /* insert the node at the start the global LRU glyph list */
-        FT_List_Insert( &manager->global_lru, FTC_CHUNKNODE_TO_LRUNODE( node ) );
+        FT_List_Insert( &manager->global_lru,
+                        FTC_CHUNKNODE_TO_LRUNODE( node ) );
 
         manager->num_bytes += clazz->size_node( node );
-        manager->num_nodes ++;
+        manager->num_nodes++;
 
-        if (manager->num_bytes > manager->max_bytes)
+        if ( manager->num_bytes > manager->max_bytes )
         {
           FTC_ChunkNode_Ref   ( node );
           FTC_Manager_Compress( manager );
@@ -249,7 +252,7 @@
       }
 
       *anode  = node;
-      *aindex = glyph_index - chunk_index*chunk_size;
+      *aindex = glyph_index - chunk_index * chunk_size;
     }
 
   Exit:
@@ -369,3 +372,4 @@
   }
 
 
+/* END */
--- a/src/cache/ftcglyph.c
+++ b/src/cache/ftcglyph.c
@@ -20,7 +20,7 @@
 #include <freetype/fterrors.h>
 #include <freetype/internal/ftobjs.h>
 #include <freetype/internal/ftlist.h>
-#include <freetype/fterrors.h>
+#include <freetype/internal/ftdebug.h>
 
 
   /*************************************************************************/
@@ -62,23 +62,25 @@
     FTC_GlyphSet  gset     = (FTC_GlyphSet)gset_lru->root.data;
     FT_UInt       hash     = node->glyph_index % gset->hash_size;
 
+
     /* remove the node from its gset's bucket list */
     {
       FTC_GlyphNode*  pnode = gset->buckets + hash;
       FTC_GlyphNode   cur;
 
+
       for (;;)
       {
         cur = *pnode;
-        if (!cur)
+        if ( !cur )
         {
-          /* that's very strange, this should not happen !! */
+          /* this should never happen */
           FT_ERROR(( "FTC_GlyphNode_Destroy:"
-                     " trying to delete an unlisted node !!!!" ));
+                     " trying to delete an unlisted node!" ));
           return;
         }
 
-        if (cur == node)
+        if ( cur == node )
         {
           *pnode = cur->gset_next;
           break;
@@ -112,8 +114,8 @@
 
   FT_CPLUSPLUS( const FTC_CacheNode_Class )  ftc_glyph_cache_node_class =
   {
-    (FTC_CacheNode_SizeFunc)    FTC_GlyphNode_Size,
-    (FTC_CacheNode_DestroyFunc) FTC_GlyphNode_Destroy
+    (FTC_CacheNode_SizeFunc)   FTC_GlyphNode_Size,
+    (FTC_CacheNode_DestroyFunc)FTC_GlyphNode_Destroy
   };
 
 
@@ -128,12 +130,12 @@
 
   FT_EXPORT_FUNC( FT_Error )  FTC_GlyphSet_New( FTC_Glyph_Cache  cache,
                                                 FT_Pointer       type,
-                                                FTC_GlyphSet    *aset )
+                                                FTC_GlyphSet*    aset )
   {
-    FT_Error        error;
-    FT_Memory       memory  = cache->root.memory;
-    FTC_Manager     manager = cache->root.manager;
-    FTC_GlyphSet    gset   = 0;
+    FT_Error                error;
+    FT_Memory               memory  = cache->root.memory;
+    FTC_Manager             manager = cache->root.manager;
+    FTC_GlyphSet            gset    = 0;
 
     FTC_Glyph_Cache_Class*  gcache_class;
     FTC_GlyphSet_Class*     clazz;
@@ -180,14 +182,14 @@
 
   FT_EXPORT_FUNC( void )  FTC_GlyphSet_Destroy( FTC_GlyphSet  gset )
   {
-    FTC_Glyph_Cache         cache        = gset->cache;
-    FTC_Manager             manager      = cache->root.manager;
-    FT_List                 glyphs_lru   = &manager->global_lru;
-    FTC_GlyphNode*          bucket       = gset->buckets;
-    FTC_GlyphNode*          bucket_limit = bucket + gset->hash_size;
-    FT_Memory               memory       = cache->root.memory;
+    FTC_Glyph_Cache      cache        = gset->cache;
+    FTC_Manager          manager      = cache->root.manager;
+    FT_List              glyphs_lru   = &manager->global_lru;
+    FTC_GlyphNode*       bucket       = gset->buckets;
+    FTC_GlyphNode*       bucket_limit = bucket + gset->hash_size;
+    FT_Memory            memory       = cache->root.memory;
 
-    FTC_GlyphSet_Class*  clazz = gset->clazz;
+    FTC_GlyphSet_Class*  clazz        = gset->clazz;
 
 
     /* for each bucket, free the list of glyph nodes */
@@ -204,7 +206,7 @@
         lrunode = FTC_GLYPHNODE_TO_LRUNODE( node );
 
         manager->num_bytes -= clazz->size_node( node, gset );
-        manager->num_nodes --;
+        manager->num_nodes--;
 
         FT_List_Remove( glyphs_lru, lrunode );
 
@@ -222,20 +224,20 @@
   }
 
 
-  FT_EXPORT_FUNC( FT_Error )
-  FTC_GlyphSet_Lookup_Node( FTC_GlyphSet    gset,
-                            FT_UInt         glyph_index,
-                            FTC_GlyphNode  *anode )
+  FT_EXPORT_FUNC( FT_Error )  FTC_GlyphSet_Lookup_Node(
+                                FTC_GlyphSet    gset,
+                                FT_UInt         glyph_index,
+                                FTC_GlyphNode*  anode )
   {
-    FTC_Glyph_Cache         cache      = gset->cache;
-    FTC_Manager             manager    = cache->root.manager;
-    FT_UInt                 hash_index = glyph_index % gset->hash_size;
-    FTC_GlyphNode*          bucket     = gset->buckets + hash_index;
-    FTC_GlyphNode*          pnode      = bucket;
-    FTC_GlyphNode           node;
-    FT_Error                error;
+    FTC_Glyph_Cache      cache      = gset->cache;
+    FTC_Manager          manager    = cache->root.manager;
+    FT_UInt              hash_index = glyph_index % gset->hash_size;
+    FTC_GlyphNode*       bucket     = gset->buckets + hash_index;
+    FTC_GlyphNode*       pnode      = bucket;
+    FTC_GlyphNode        node;
+    FT_Error             error;
 
-    FTC_GlyphSet_Class*  clazz = gset->clazz;
+    FTC_GlyphSet_Class*  clazz      = gset->clazz;
 
 
     *anode = 0;
@@ -243,7 +245,7 @@
     for ( ;; )
     {
       node = *pnode;
-      if (!node)
+      if ( !node )
         break;
 
       if ( node->glyph_index == glyph_index )
@@ -274,9 +276,9 @@
     FT_List_Insert( &manager->global_lru, FTC_GLYPHNODE_TO_LRUNODE( node ) );
 
     manager->num_bytes += clazz->size_node( node, gset );
-    manager->num_nodes ++;
+    manager->num_nodes++;
 
-    if (manager->num_bytes > manager->max_bytes)
+    if ( manager->num_bytes > manager->max_bytes )
     {
       FTC_GlyphNode_Ref   ( node );
       FTC_Manager_Compress( manager );
--- a/src/cache/ftcimage.c
+++ b/src/cache/ftcimage.c
@@ -19,14 +19,14 @@
 #include <freetype/cache/ftcimage.h>
 #include <freetype/internal/ftmemory.h>
 
-#include <string.h>
+#include <string.h>     /* memcmp() */
 
 
- /* the FT_Glyph image "glyph node" type */
+  /* the FT_Glyph image `glyph node' type */
   typedef struct  FTC_GlyphImageRec_
   {
-    FTC_GlyphNodeRec   root;
-    FT_Glyph           ft_glyph;
+    FTC_GlyphNodeRec  root;
+    FT_Glyph          ft_glyph;
 
   } FTC_GlyphImageRec, *FTC_GlyphImage;
 
@@ -70,16 +70,16 @@
 
 
   LOCAL_FUNC_X
-  FT_Error  ftc_glyph_image_node_new( FTC_GlyphSet    gset,
-                                      FT_UInt         glyph_index,
-                                      FTC_GlyphImage *anode )
+  FT_Error  ftc_glyph_image_node_new( FTC_GlyphSet     gset,
+                                      FT_UInt          glyph_index,
+                                      FTC_GlyphImage*  anode )
   {
-    FT_Memory        memory   = gset->memory;
-    FTC_ImageSet     imageset = (FTC_ImageSet)gset;
-    FT_Error         error;
-    FTC_GlyphImage   node = 0;
-    FT_Face          face;
-    FT_Size          size;
+    FT_Memory       memory   = gset->memory;
+    FTC_ImageSet    imageset = (FTC_ImageSet)gset;
+    FT_Error        error;
+    FTC_GlyphImage  node = 0;
+    FT_Face         face;
+    FT_Size         size;
 
 
     /* allocate node */
@@ -86,8 +86,8 @@
     if ( ALLOC( node, sizeof ( *node ) ) )
       goto Exit;
 
-    /* init its inner fields */
-    FTC_GlyphNode_Init( FTC_GLYPHNODE(node), gset, glyph_index );
+    /* initialize its inner fields */
+    FTC_GlyphNode_Init( FTC_GLYPHNODE( node ), gset, glyph_index );
 
     /* we will now load the glyph image */
     error = FTC_Manager_Lookup_Size( gset->manager,
@@ -154,7 +154,7 @@
 
 
   /* this function is important because it is both part of */
-  /* a FTC_GlyphSet_Class and a FTC_CacheNode_Class     */
+  /* an FTC_GlyphSet_Class and an FTC_CacheNode_Class      */
   /*                                                       */
   LOCAL_FUNC_X
   FT_ULong  ftc_glyph_image_node_size( FTC_GlyphImage  node )
@@ -262,17 +262,16 @@
                                                    FTC_Image_Cache*  acache )
   {
     return FTC_Manager_Register_Cache(
-              manager,
-              (FTC_Cache_Class*)&ftc_glyph_image_cache_class,
-              (FTC_Cache*)acache );
+             manager,
+             (FTC_Cache_Class*)&ftc_glyph_image_cache_class,
+             (FTC_Cache*)acache );
   }
 
 
-  FT_EXPORT_DEF( FT_Error )
-  FTC_Image_Cache_Lookup( FTC_Image_Cache  cache,
-                          FTC_Image_Desc*  desc,
-                          FT_UInt          gindex,
-                          FT_Glyph*        aglyph )
+  FT_EXPORT_DEF( FT_Error )  FTC_Image_Cache_Lookup( FTC_Image_Cache  cache,
+                                                     FTC_Image_Desc*  desc,
+                                                     FT_UInt          gindex,
+                                                     FT_Glyph*        aglyph )
   {
     FT_Error       error;
     FTC_GlyphSet   gset;
--- a/src/cache/ftcmanag.c
+++ b/src/cache/ftcmanag.c
@@ -54,7 +54,7 @@
     {
       /* destroy initial size object; it will be re-created later */
       face = (FT_Face)node->root.data;
-      if (face->size)
+      if ( face->size )
         FT_Done_Size( face->size );
     }
 
@@ -311,7 +311,7 @@
       FT_Lru_Reset( manager->sizes_lru );
       FT_Lru_Reset( manager->faces_lru );
     }
-    /* FIXME: flush the caches ?? */
+    /* XXX: FIXME: flush the caches? */
   }
 
 
@@ -413,10 +413,8 @@
         }
 
         /* check, just in case of general corruption :-) */
-        if (manager->num_nodes <= 0)
-        {
-          FT_ERROR(( "FTC_Manager_Compress: invalid cache node count !!\n" ));
-        }
+        if ( manager->num_nodes <= 0 )
+          FT_ERROR(( "FTC_Manager_Compress: Invalid cache node count!\n" ));
         else
           manager->num_nodes--;
       }
@@ -465,8 +463,8 @@
         cache->memory  = memory;
         cache->clazz   = clazz;
 
-        /* THIS IS VERY IMPORTANT, THIS WILL WRECH THE MANAGER */
-        /* IF IT IS NOT SET CORRECTLY..                        */
+        /* THIS IS VERY IMPORTANT! IT WILL WRETCH THE MANAGER */
+        /* IF IT IS NOT SET CORRECTLY                         */
         cache->cache_index = index;
 
         if ( clazz->init_cache )
--- a/src/cache/ftcsbits.c
+++ b/src/cache/ftcsbits.c
@@ -1,20 +1,43 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcsbits.c                                                             */
+/*                                                                         */
+/*    FreeType sbits manager (body).                                       */
+/*                                                                         */
+/*  Copyright 2000 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 <freetype/cache/ftcsbits.h>
+#include <freetype/internal/ftobjs.h>
+#include <freetype/internal/ftdebug.h>
 #include <freetype/fterrors.h>
 
+#include <string.h>         /* memcmp() */
+
+
 #define  FTC_SBITSET_ELEMENT_COUNT  16
 
 
-  typedef struct FTC_SBitSetRec_
+  typedef struct  FTC_SBitSetRec_
   {
-    FTC_ChunkSetRec   root;
-    FTC_Image_Desc    desc;
+    FTC_ChunkSetRec  root;
+    FTC_Image_Desc   desc;
 
   } FTC_SBitSetRec, *FTC_SBitSet;
 
 
-  typedef struct FTC_SBit_CacheRec_
+  typedef struct  FTC_SBit_CacheRec_
   {
-    FTC_Chunk_CacheRec    root;
+    FTC_Chunk_CacheRec  root;
 
   } FTC_SBit_CacheRec;
 
@@ -32,11 +55,12 @@
   LOCAL_FUNC_X
   void  ftc_sbit_chunk_node_destroy( FTC_ChunkNode  node )
   {
-    FTC_ChunkSet   cset   = node->cset;
-    FT_Memory      memory = cset->memory;
-    FT_UInt        count  = node->num_elements;
-    FTC_SBit       sbit   = (FTC_SBit)node->elements;
+    FTC_ChunkSet  cset   = node->cset;
+    FT_Memory     memory = cset->memory;
+    FT_UInt       count  = node->num_elements;
+    FTC_SBit      sbit   = (FTC_SBit)node->elements;
 
+
     for ( ; count > 0; sbit++, count-- )
       FREE( sbit->buffer );
 
@@ -45,9 +69,7 @@
   }
 
 
-
-
-  static
+  LOCAL_FUNC_X
   FT_Error  ftc_bitmap_copy( FT_Memory   memory,
                              FT_Bitmap*  source,
                              FTC_SBit    target )
@@ -56,6 +78,7 @@
     FT_Int    pitch = source->pitch;
     FT_ULong  size;
 
+
     if ( pitch < 0 )
       pitch = -pitch;
 
@@ -69,16 +92,16 @@
 
 
   LOCAL_FUNC_X
-  FT_Error  ftc_sbit_chunk_node_new( FTC_ChunkSet   cset,
-                                     FT_UInt        index,
-                                     FTC_ChunkNode *anode )
+  FT_Error  ftc_sbit_chunk_node_new( FTC_ChunkSet    cset,
+                                     FT_UInt         index,
+                                     FTC_ChunkNode*  anode )
   {
-    FT_Error         error;
-    FT_Memory        memory  = cset->memory;
-    FTC_SBitSet      sbitset = (FTC_SBitSet)cset;
-    FTC_ChunkNode    node    = 0;
-    FT_Face          face;
-    FT_Size          size;
+    FT_Error       error;
+    FT_Memory      memory  = cset->memory;
+    FTC_SBitSet    sbitset = (FTC_SBitSet)cset;
+    FTC_ChunkNode  node    = 0;
+    FT_Face        face;
+    FT_Size        size;
 
 
     /* allocate node */
@@ -85,9 +108,9 @@
     if ( ALLOC( node, sizeof ( *node ) ) )
       goto Exit;
 
-    /* init its inner fields */
+    /* initialize its inner fields */
     error = FTC_ChunkNode_Init( node, cset, index, 1 );
-    if (error)
+    if ( error )
       goto Exit;
 
     /* we will now load all glyph images for this chunk */
@@ -96,51 +119,50 @@
                                      &face, &size );
     if ( !error )
     {
-      FT_UInt  glyph_index = index * cset->element_count;
-      FT_UInt  load_flags  = FT_LOAD_DEFAULT;
-      FT_UInt  image_type  = sbitset->desc.image_type;
-      FT_UInt  count       = node->num_elements;
-      FTC_SBit sbit        = (FTC_SBit)node->elements;
+      FT_UInt   glyph_index = index * cset->element_count;
+      FT_UInt   load_flags  = FT_LOAD_DEFAULT;
+      FT_UInt   image_type  = sbitset->desc.image_type;
+      FT_UInt   count       = node->num_elements;
+      FTC_SBit  sbit        = (FTC_SBit)node->elements;
 
+
       /* determine load flags, depending on the font description's */
-      /* image type..                                              */
+      /* image type                                                */
+
+      if ( FTC_IMAGE_FORMAT( image_type ) == ftc_image_format_bitmap )
       {
-        if ( FTC_IMAGE_FORMAT( image_type ) == ftc_image_format_bitmap )
-        {
-          if ( image_type & ftc_image_flag_monochrome )
-            load_flags |= FT_LOAD_MONOCHROME;
+        if ( image_type & ftc_image_flag_monochrome )
+          load_flags |= FT_LOAD_MONOCHROME;
 
-          /* disable embedded bitmaps loading if necessary */
-          if ( image_type & ftc_image_flag_no_sbits )
-            load_flags |= FT_LOAD_NO_BITMAP;
-        }
-        else
-        {
-          FT_ERROR(( "FTC_SBit_Cache: cannot load scalable glyphs in a"
-                     " sbit cache, please check your arguments !!\n" ));
-          error = FT_Err_Invalid_Argument;
-          goto Exit;
-        }
+        /* disable embedded bitmaps loading if necessary */
+        if ( image_type & ftc_image_flag_no_sbits )
+          load_flags |= FT_LOAD_NO_BITMAP;
+      }
+      else
+      {
+        FT_ERROR(( "FTC_SBit_Cache: cannot load scalable glyphs in an"
+                   " sbit cache, please check your arguments!\n" ));
+        error = FT_Err_Invalid_Argument;
+        goto Exit;
+      }
 
-        /* always render glyphs to bitmaps */
-        load_flags |= FT_LOAD_RENDER;
+      /* always render glyphs to bitmaps */
+      load_flags |= FT_LOAD_RENDER;
 
-        if ( image_type & ftc_image_flag_unhinted )
-          load_flags |= FT_LOAD_NO_HINTING;
+      if ( image_type & ftc_image_flag_unhinted )
+        load_flags |= FT_LOAD_NO_HINTING;
 
-        if ( image_type & ftc_image_flag_autohinted )
-          load_flags |= FT_LOAD_FORCE_AUTOHINT;
-      }
+      if ( image_type & ftc_image_flag_autohinted )
+        load_flags |= FT_LOAD_FORCE_AUTOHINT;
 
-
       /* load a chunk of small bitmaps in a row */
       for ( ; count > 0; count--, glyph_index++, sbit++ )
       {
-        /* by default, indicates a "missing" glyph */
+        /* by default, indicates a `missing' glyph */
         sbit->buffer = 0;
 
         error = FT_Load_Glyph( face, glyph_index, load_flags );
-        if (!error)
+        if ( !error )
         {
           FT_Int        temp;
           FT_GlyphSlot  slot   = face->glyph;
@@ -147,35 +169,36 @@
           FT_Bitmap*    bitmap = &slot->bitmap;
           FT_Int        xadvance, yadvance;
 
-          /* check that our values fit in 8-bit containers !!       */
-          /* if this is not the case, our bitmap is too large       */
-          /* and we will leave it as "missing" with sbit.buffer = 0 */
 
-#define  CHECK_CHAR(d)   ( temp = (FT_Char)d, temp == d )
-#define  CHECK_BYTE(d)   ( temp = (FT_Byte)d, temp == d )
+          /* check that our values fit into 8-bit containers!       */
+          /* If this is not the case, our bitmap is too large       */
+          /* and we will leave it as `missing' with sbit.buffer = 0 */
 
-          /* FIXME: add support for vertical layouts maybe.. */
+#define CHECK_CHAR( d )  ( temp = (FT_Char)d, temp == d )
+#define CHECK_BYTE( d )  ( temp = (FT_Byte)d, temp == d )
 
-          /* horizontal advance in pixels              */
-          xadvance = (slot->metrics.horiAdvance+32) >> 6;
-          yadvance = (slot->metrics.vertAdvance+32) >> 6;
+          /* XXX: FIXME: add support for vertical layouts maybe */
 
-          if ( CHECK_BYTE ( bitmap->rows  )     &&
-               CHECK_BYTE ( bitmap->width )     &&
-               CHECK_CHAR ( bitmap->pitch )     &&
-               CHECK_CHAR ( slot->bitmap_left ) &&
-               CHECK_CHAR ( slot->bitmap_top  ) &&
-               CHECK_CHAR ( xadvance )          &&
-               CHECK_CHAR ( yadvance )          )
+          /* horizontal advance in pixels */
+          xadvance = ( slot->metrics.horiAdvance + 32 ) >> 6;
+          yadvance = ( slot->metrics.vertAdvance + 32 ) >> 6;
+
+          if ( CHECK_BYTE( bitmap->rows  )     &&
+               CHECK_BYTE( bitmap->width )     &&
+               CHECK_CHAR( bitmap->pitch )     &&
+               CHECK_CHAR( slot->bitmap_left ) &&
+               CHECK_CHAR( slot->bitmap_top  ) &&
+               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 */
             if ( slot->flags & ft_glyph_own_bitmap )
@@ -185,7 +208,7 @@
             }
             else
             {
-              /* copy the bitmap into a new buffer - ignore error */
+              /* copy the bitmap into a new buffer -- ignore error */
               ftc_bitmap_copy( memory, bitmap, sbit );
             }
           }
@@ -192,8 +215,8 @@
         }
       }
 
-      /* ignore the errors that might have occured there      */
-      /* we recognize unloaded glyphs with "sbit.buffer == 0" */
+      /* ignore the errors that might have occurred --        */
+      /* we recognize unloaded glyphs with `sbit.buffer == 0' */
       error = 0;
     }
 
@@ -205,12 +228,13 @@
     }
 
     *anode = node;
+
     return error;
   }
 
 
   /* this function is important because it is both part of */
-  /* a FTC_ChunkSet_Class and a FTC_CacheNode_Class        */
+  /* an FTC_ChunkSet_Class and an FTC_CacheNode_Class      */
   /*                                                       */
   LOCAL_FUNC_X
   FT_ULong  ftc_sbit_chunk_node_size( FTC_ChunkNode  node )
@@ -221,15 +245,18 @@
     FT_Int        pitch;
     FTC_SBit      sbit  = (FTC_SBit)node->elements;
 
-    size  = sizeof (*node);                            /* the node itself */
-    size += cset->element_count * sizeof(FTC_SBitRec); /* the sbit recors */
 
+    /* the node itself */
+    size  = sizeof ( *node );
+    /* the sbit records */
+    size += cset->element_count * sizeof ( FTC_SBitRec );
+
     for ( ; count > 0; count--, sbit++ )
     {
-      if (sbit->buffer)
+      if ( sbit->buffer )
       {
         pitch = sbit->pitch;
-        if (pitch < 0)
+        if ( pitch < 0 )
           pitch = -pitch;
 
         /* add the size of a given glyph image */
@@ -257,13 +284,14 @@
     FT_Error  error;
     FT_Face   face;
 
+
     cset->element_count = FTC_SBITSET_ELEMENT_COUNT;
-    cset->element_size  = sizeof(FTC_SBitRec);
+    cset->element_size  = sizeof ( FTC_SBitRec );
 
     /* lookup the FT_Face to obtain the number of glyphs */
     error = FTC_Manager_Lookup_Face( cset->manager,
                                      desc->font.face_id, &face );
-    if (!error)
+    if ( !error )
       cset->element_max = face->num_glyphs;
 
     return error;
@@ -270,12 +298,12 @@
   }
 
 
-
   LOCAL_FUNC_X
   FT_Error  ftc_sbit_chunk_set_init( FTC_SBitSet      sset,
                                      FTC_Image_Desc*  type )
   {
     sset->desc = *type;
+
     return 0;
   }
 
@@ -292,14 +320,14 @@
   {
     sizeof( FTC_SBitSetRec ),
 
-    (FTC_ChunkSet_InitFunc)        ftc_sbit_chunk_set_init,
-    (FTC_ChunkSet_DoneFunc)        0,
-    (FTC_ChunkSet_CompareFunc)     ftc_sbit_chunk_set_compare,
-    (FTC_ChunkSet_SizesFunc)       ftc_sbit_chunk_set_sizes,
+    (FTC_ChunkSet_InitFunc)       ftc_sbit_chunk_set_init,
+    (FTC_ChunkSet_DoneFunc)       0,
+    (FTC_ChunkSet_CompareFunc)    ftc_sbit_chunk_set_compare,
+    (FTC_ChunkSet_SizesFunc)      ftc_sbit_chunk_set_sizes,
 
-    (FTC_ChunkSet_NewNodeFunc)     ftc_sbit_chunk_node_new,
-    (FTC_ChunkSet_SizeNodeFunc)    ftc_sbit_chunk_node_size,
-    (FTC_ChunkSet_DestroyNodeFunc) ftc_sbit_chunk_node_destroy
+    (FTC_ChunkSet_NewNodeFunc)    ftc_sbit_chunk_node_new,
+    (FTC_ChunkSet_SizeNodeFunc)   ftc_sbit_chunk_node_size,
+    (FTC_ChunkSet_DestroyNodeFunc)ftc_sbit_chunk_node_destroy
   };
 
 
@@ -316,16 +344,15 @@
   {
     {
       sizeof( FTC_SBit_CacheRec ),
-      (FTC_Cache_InitFunc) FTC_Chunk_Cache_Init,
-      (FTC_Cache_DoneFunc) FTC_Chunk_Cache_Done
+      (FTC_Cache_InitFunc)FTC_Chunk_Cache_Init,
+      (FTC_Cache_DoneFunc)FTC_Chunk_Cache_Done
     },
-    (FTC_ChunkSet_Class*) &ftc_sbit_chunk_set_class
+    (FTC_ChunkSet_Class*)&ftc_sbit_chunk_set_class
   };
 
 
-  FT_EXPORT_FUNC( FT_Error )
-  FTC_SBit_Cache_New( FTC_Manager      manager,
-                      FTC_SBit_Cache*  acache )
+  FT_EXPORT_FUNC( FT_Error )  FTC_SBit_Cache_New( FTC_Manager      manager,
+                                                  FTC_SBit_Cache*  acache )
   {
     return FTC_Manager_Register_Cache(
               manager,
@@ -334,11 +361,10 @@
   }
 
 
-  FT_EXPORT_DEF( FT_Error )
-  FTC_SBit_Cache_Lookup( FTC_SBit_Cache   cache,
-                         FTC_Image_Desc*  desc,
-                         FT_UInt          gindex,
-                         FTC_SBit        *asbit )
+  FT_EXPORT_DEF( FT_Error )  FTC_SBit_Cache_Lookup( FTC_SBit_Cache   cache,
+                                                    FTC_Image_Desc*  desc,
+                                                    FT_UInt          gindex,
+                                                    FTC_SBit*        asbit )
   {
     FT_Error       error;
     FTC_ChunkSet   cset;
@@ -355,9 +381,10 @@
     if ( !cache || !asbit )
       return FT_Err_Invalid_Argument;
 
-    *asbit   = 0;
-    cset     = cache->root.last_cset;
-    sset     = (FTC_SBitSet)cset;
+    *asbit = 0;
+    cset   = cache->root.last_cset;
+    sset   = (FTC_SBitSet)cset;
+
     if ( !cset || memcmp( &sset->desc, desc, sizeof ( *desc ) ) )
     {
       error = FT_Lru_Lookup( cache->root.csets_lru,
@@ -388,3 +415,5 @@
     return error;
   }
 
+
+/* END */
--- a/src/cache/ftlru.c
+++ b/src/cache/ftlru.c
@@ -80,7 +80,6 @@
   }
 
 
-
   FT_EXPORT_DEF( void )  FT_Lru_Reset( FT_Lru  lru )
   {
     FT_ListNode    node;
@@ -220,8 +219,8 @@
         /* create a new lru list node, then the element for it */
         if ( lru->nodes )
         {
-          node     = lru->free_nodes.head;
-          lru_node = (FT_LruNode)node;
+          node          = lru->free_nodes.head;
+          lru_node      = (FT_LruNode)node;
           lru_node->key = key;
 
           error = clazz->init_element( lru, lru_node );
--- a/src/cff/t2driver.c
+++ b/src/cff/t2driver.c
@@ -365,7 +365,7 @@
   /*    format-specific interface can then be retrieved through the method */
   /*    interface->get_format_interface.                                   */
   /*                                                                       */
-  EXPORT_FUNC( FT_Driver_Class* )  getDriverClass( void )
+  FT_EXPORT_FUNC( const FT_Driver_Class* )  getDriverClass( void )
   {
     return &cff_driver_class;
   }
--- a/src/cid/cidriver.c
+++ b/src/cid/cidriver.c
@@ -247,7 +247,7 @@
   /*    format-specific interface can then be retrieved through the method */
   /*    interface->get_format_interface.                                   */
   /*                                                                       */
-  EXPORT_FUNC( FT_Driver_Class* )  getDriverClass( void )
+  FT_EXPORT_FUNC( const FT_Driver_Class* )  getDriverClass( void )
   {
     return &t1cid_driver_class;
   }
--- a/src/truetype/ttdriver.c
+++ b/src/truetype/ttdriver.c
@@ -483,7 +483,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    getDriverInterface                                                 */
+  /*    getDriverClass                                                     */
   /*                                                                       */
   /* <Description>                                                         */
   /*    This function is used when compiling the TrueType driver as a      */
@@ -499,7 +499,7 @@
   /*    format-specific interface can then be retrieved through the method */
   /*    interface->get_format_interface.                                   */
   /*                                                                       */
-  EXPORT_FUNC( const FT_Driver_Class* )  getDriverClass( void )
+  FT_EXPORT_FUNC( const FT_Driver_Class* )  getDriverClass( void )
   {
     return &tt_driver_class;
   }
--- a/src/type1/t1driver.c
+++ b/src/type1/t1driver.c
@@ -329,10 +329,31 @@
 
 #ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
 
-  EXPORT_FUNC( const FT_Driver_Class* )  getDriverClass( void )
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    getDriverClass                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used when compiling the TrueType driver as a      */
+  /*    shared library (`.DLL' or `.so').  It will be used by the          */
+  /*    high-level library of FreeType to retrieve the address of the      */
+  /*    driver's generic interface.                                        */
+  /*                                                                       */
+  /*    It shouldn't be implemented in a static build, as each driver must */
+  /*    have the same function as an exported entry point.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The address of the TrueType's driver generic interface.  The       */
+  /*    format-specific interface can then be retrieved through the method */
+  /*    interface->get_format_interface.                                   */
+  /*                                                                       */
+  FT_EXPORT_FUNC( const FT_Driver_Class* )  getDriverClass( void )
   {
     return &t1_driver_class;
   }
+
 
 #endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
 
--- a/src/winfonts/winfnt.c
+++ b/src/winfonts/winfnt.c
@@ -629,4 +629,35 @@
   };
 
 
+#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    getDriverClass                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used when compiling the TrueType driver as a      */
+  /*    shared library (`.DLL' or `.so').  It will be used by the          */
+  /*    high-level library of FreeType to retrieve the address of the      */
+  /*    driver's generic interface.                                        */
+  /*                                                                       */
+  /*    It shouldn't be implemented in a static build, as each driver must */
+  /*    have the same function as an exported entry point.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The address of the TrueType's driver generic interface.  The       */
+  /*    format-specific interface can then be retrieved through the method */
+  /*    interface->get_format_interface.                                   */
+  /*                                                                       */
+  FT_EXPORT_FUNC( const FT_Driver_Class* )  getDriverClass( void )
+  {
+    return &winfnt_driver_class;
+  }
+
+
+#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
+
+
 /* END */