shithub: freetype+ttf2subf

Download patch

ref: eacb9306c03ad97053865eadb07fb9ae709951c0
parent: c4c373cee51dd2b81cc3a2fcf923e2a029197b5a
author: Werner Lemberg <[email protected]>
date: Mon Oct 7 06:12:43 EDT 2002

Formatting; adding file headers.

git/fs: mount .git/fs: mount/attach disallowed
--- a/ChangeLog
+++ b/ChangeLog
@@ -7,21 +7,38 @@
 
 2002-10-05  David Turner  <[email protected]>
 
-        * src/pfr/pfrsbit.h, src/pfr/pfrsbit.c, src/pfr/pfrload.c,
-        src/pfr/pfrgload.c, src/pfr/pfrobjs.c, src/pfr/pfrtypes.h,
-        Jamfile, src/base/ftobjs.c: adding support for embedded bitmaps to
-        the PFR driver, and rewriting its kerning loader / handler to use all
-        kerning pairs in a physical font (and not just the first item).
+	Adding support for embedded bitmaps to the PFR driver, and rewriting
+	its kerning loader/handler to use all kerning pairs in a physical
+	font (and not just the first item).
 
-        * src/tools/docmaker/content.py, src/tools/docmaker/sources.py,
-        src/tools/docmaker/tohtml.py: fixing a few nasty bugs
+	* src/pfr/pfr.c: Include `pfrsbit.c'.
+	* src/pfr/pfrgload.c: Include `pfrsbit.h'.
+	* src/pfr/pfrload.c (pfr_extra_item_load_kerning_pairs): Rewritten.
+	(pfr_phy_font_done, pfr_phy_font_load): Updated.
+	* src/pfr/pfrobks.c: Include `pfrsbit.h'.
+	(pfr_face_init): Handle kerning and embedded bitmaps.
+	(pfr_slot_load): Load embedded bitmaps.
+	(PFR_KERN_INDEX): Removed.
+	(pfr_face_get_kerning): Rewritten.
+	* src/pfr/pfrsbit.c, src/pfr/pfrsbit.h: New files.
+	* src/pfr/pfrtypes.h (PFR_KernItemRec): New structure.
+	(PFR_KERN_INDEX): New macro.
+	(PFR_PhyFontRec): Add items for kerning and embedded bitmaps.
+	* src/pfr/Jamfile (_sources) [FT2_MULTI]: Add `pfrsbit'.
 
-        * src/sfnt/ttcmap0.c: the validator for format 4 sub-tables is
-        now capable of dealing with invalid "length" fields at the start
-        of the sub-table. This allows fonts like "mg______.ttf" (i.e.
-        Marriage) to return accurate charmaps.
+	* src/base/ftobjs.c (FT_Load_Glyph): Don't load bitmap fonts if
+	FT_LOAD_NO_RECURSE is set.
+	Load embedded bitmaps only if FT_LOAD_NO_BITMAP isn't set.
 
-        * docs/CHANGES: updating
+	* src/tools/docmaker/content.py, src/tools/docmaker/sources.py,
+	src/tools/docmaker/tohtml.py: Fixing a few nasty bugs.
+
+	* src/sfnt/ttcmap0.c (tt_cmap4_validate): The validator for format 4
+	sub-tables is now capable of dealing with invalid "length" fields at
+	the start of the sub-table.  This allows fonts like "mg______.ttf"
+	(i.e.  Marriage) to return accurate charmaps.
+
+	* docs/CHANGES: Updated.
 
 2002-10-05  Werner Lemberg  <[email protected]>
 
--- a/docs/CHANGES
+++ b/docs/CHANGES
@@ -72,9 +72,9 @@
       has been updated to support LCD-optimized display on non-paletted
       displays (under Win32 and X11)
 
-    - the PFR driver now supports embedded bitmaps (all formats supported)
+    - The PFR driver now supports embedded bitmaps (all formats supported).
 
-    - the TrueType charmap loader now supports certain "broken" fonts that
+    - The TrueType charmap loader now supports certain "broken" fonts that
       load under Windows without problems.
 
     - The cache API has been slightly modified (it's still a beta!):
--- a/src/base/ftobjs.c
+++ b/src/base/ftobjs.c
@@ -467,7 +467,7 @@
       /* XXX: This is really a temporary hack that should disappear */
       /*      promptly with FreeType 2.1!                           */
       /*                                                            */
-      if ( FT_HAS_FIXED_SIZES( face ) &&
+      if ( FT_HAS_FIXED_SIZES( face )             &&
           ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
       {
         error = driver->clazz->load_glyph( slot, face->size,
--- a/src/pfr/pfrgload.h
+++ b/src/pfr/pfrgload.h
@@ -44,3 +44,6 @@
 
 
 #endif /* __PFRGLOAD_H__ */
+
+
+/* END */
--- a/src/pfr/pfrload.c
+++ b/src/pfr/pfrload.c
@@ -501,8 +501,8 @@
   }
 
 
-
 #if 0
+
   /* load kerning pair data */
   FT_CALLBACK_DEF( FT_Error )
   pfr_extra_item_load_kerning_pairs( FT_Byte*     p,
@@ -582,7 +582,9 @@
                "invalid kerning pairs table\n" ));
     goto Exit;
   }
-#else
+
+#else /* 0 */
+
   /* load kerning pair data */
   FT_CALLBACK_DEF( FT_Error )
   pfr_extra_item_load_kerning_pairs( FT_Byte*     p,
@@ -593,6 +595,7 @@
     FT_Error      error  = 0;
     FT_Memory     memory = phy_font->memory;
 
+
     FT_TRACE2(( "pfr_extra_item_load_kerning_pairs()\n" ));
 
     if ( FT_NEW( item ) )
@@ -624,33 +627,34 @@
       FT_UInt   char1, char2;
       FT_Byte*  q;
 
+
       if ( item->flags & PFR_KERN_2BYTE_CHAR )
       {
         q     = p;
-        char1 = PFR_NEXT_USHORT(q);
-        char2 = PFR_NEXT_USHORT(q);
+        char1 = PFR_NEXT_USHORT( q );
+        char2 = PFR_NEXT_USHORT( q );
 
-        item->pair1 = PFR_KERN_INDEX(char1,char2);
+        item->pair1 = PFR_KERN_INDEX( char1, char2 );
 
-        q = p + item->pair_size*(item->pair_count-1);
-        char1 = PFR_NEXT_USHORT(q);
-        char2 = PFR_NEXT_USHORT(q);
+        q = p + item->pair_size * ( item->pair_count - 1 );
+        char1 = PFR_NEXT_USHORT( q );
+        char2 = PFR_NEXT_USHORT( q );
 
-        item->pair2 = PFR_KERN_INDEX(char1,char2);
+        item->pair2 = PFR_KERN_INDEX( char1, char2 );
       }
       else
       {
         q     = p;
-        char1 = PFR_NEXT_BYTE(q);
-        char2 = PFR_NEXT_BYTE(q);
+        char1 = PFR_NEXT_BYTE( q );
+        char2 = PFR_NEXT_BYTE( q );
 
-        item->pair1 = PFR_KERN_INDEX(char1,char2);
+        item->pair1 = PFR_KERN_INDEX( char1, char2 );
 
-        q = p + item->pair_size*(item->pair_count-1);
-        char1 = PFR_NEXT_BYTE(q);
-        char2 = PFR_NEXT_BYTE(q);
+        q = p + item->pair_size * ( item->pair_count - 1 );
+        char1 = PFR_NEXT_BYTE( q );
+        char2 = PFR_NEXT_BYTE( q );
 
-        item->pair2 = PFR_KERN_INDEX(char1,char2);
+        item->pair2 = PFR_KERN_INDEX( char1, char2 );
       }
 
       /* add new item to the current list */
@@ -661,7 +665,7 @@
     }
     else
     {
-      /* empty item !! */
+      /* empty item! */
       FT_FREE( item );
     }
 
@@ -676,8 +680,9 @@
                "invalid kerning pairs table\n" ));
     goto Exit;
   }
-#endif
+#endif /* 0 */
 
+
   static const PFR_ExtraItemRec  pfr_phy_font_extra_items[] =
   {
     { 1, (PFR_ExtraItem_ParseFunc) pfr_extra_item_load_bitmap_info },
@@ -715,8 +720,9 @@
     {
       PFR_KernItem  item, next;
 
+
       item = phy_font->kern_items;
-      while (item)
+      while ( item )
       {
         next = item->next;
         FT_FREE( item );
@@ -725,6 +731,7 @@
       phy_font->kern_items      = NULL;
       phy_font->kern_items_tail = NULL;
     }
+
     phy_font->num_kern_pairs = 0;
   }
 
--- a/src/pfr/pfrobjs.c
+++ b/src/pfr/pfrobjs.c
@@ -248,7 +248,7 @@
     FT_ASSERT( gindex < face->phy_font.num_chars );
 
     /* try to load an embedded bitmap */
-    if ( (load_flags & (FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP)) == 0 )
+    if ( ( load_flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP ) ) == 0 )
     {
       error = pfr_slot_load_bitmap( slot, size, gindex );
       if ( error == 0 )
@@ -356,6 +356,7 @@
           sure */
 
 #if 0
+
   /* find the kerning for a given glyph pair */
   FT_LOCAL_DEF( FT_Error )
   pfr_face_get_kerning( PFR_Face    face,
@@ -398,7 +399,9 @@
   Exit:
     return 0;
   }
-#else
+
+#else /* 0 */
+
   /* find the kerning for a given glyph pair */
   FT_LOCAL_DEF( FT_Error )
   pfr_face_get_kerning( PFR_Face    face,
@@ -411,6 +414,7 @@
     PFR_KernItem  item     = phy_font->kern_items;
     FT_UInt32     idx      = PFR_KERN_INDEX( glyph1, glyph2 );
 
+
     kerning->x = 0;
     kerning->y = 0;
 
@@ -433,6 +437,7 @@
       FT_Stream  stream = face->root.stream;
       FT_Byte*   p;
 
+
       if ( FT_STREAM_SEEK( item->offset )                       ||
            FT_FRAME_ENTER( item->pair_count * item->pair_size ) )
         goto Exit;
@@ -443,32 +448,33 @@
       {
         FT_UInt  char1, char2, charcode;
 
-        mid = (min + max) >> 1;
+
+        mid = ( min + max ) >> 1;
         p   = stream->cursor + mid*item->pair_size;
 
         if ( item->flags & PFR_KERN_2BYTE_CHAR )
         {
-          char1 = FT_NEXT_USHORT(p);
-          char2 = FT_NEXT_USHORT(p);
+          char1 = FT_NEXT_USHORT( p );
+          char2 = FT_NEXT_USHORT( p );
         }
         else
         {
-          char1 = FT_NEXT_USHORT(p);
-          char2 = FT_NEXT_USHORT(p);
+          char1 = FT_NEXT_USHORT( p );
+          char2 = FT_NEXT_USHORT( p );
         }
-        charcode = PFR_KERN_INDEX(char1,char2);
+        charcode = PFR_KERN_INDEX( char1, char2 );
 
         if ( idx == charcode )
         {
           if ( item->flags & PFR_KERN_2BYTE_ADJ )
-            kerning->x = item->base_adj + FT_NEXT_SHORT(p);
+            kerning->x = item->base_adj + FT_NEXT_SHORT( p );
           else
-            kerning->x = item->base_adj + FT_NEXT_CHAR(p);
+            kerning->x = item->base_adj + FT_NEXT_CHAR( p );
 
           break;
         }
         if ( idx > charcode )
-          min = mid+1;
+          min = mid + 1;
         else
           max = mid;
       }
--- a/src/pfr/pfrobjs.h
+++ b/src/pfr/pfrobjs.h
@@ -91,3 +91,6 @@
 FT_END_HEADER
 
 #endif /* __PFROBJS_H__ */
+
+
+/* END */
--- a/src/pfr/pfrsbit.c
+++ b/src/pfr/pfrsbit.c
@@ -1,3 +1,21 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrsbit.c                                                              */
+/*                                                                         */
+/*    FreeType PFR bitmap loader (body).                                   */
+/*                                                                         */
+/*  Copyright 2002 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 "pfrsbit.h"
 #include "pfrload.h"
 #include FT_INTERNAL_DEBUG_H
@@ -8,6 +26,7 @@
 #undef  FT_COMPONENT
 #define FT_COMPONENT  trace_pfr
 
+
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
@@ -16,7 +35,7 @@
   /*************************************************************************/
   /*************************************************************************/
 
-  typedef  struct PFR_BitWriter_
+  typedef struct  PFR_BitWriter_
   {
     FT_Byte*  line;      /* current line start                    */
     FT_Int    pitch;     /* line size in bytes                    */
@@ -58,7 +77,8 @@
     FT_UInt   val  = 0;
     FT_UInt   c    = 0;
 
-    n = (FT_Int)(limit - p)*8;
+
+    n = (FT_Int)( limit - p ) * 8;
     if ( n > writer->total )
       n = writer->total;
 
@@ -66,7 +86,7 @@
 
     for ( ; n > 0; n-- )
     {
-      if ( (n & 7) == reload )
+      if ( ( n & 7 ) == reload )
         val = *p++;
 
       if ( val & 0x80 )
@@ -77,7 +97,7 @@
 
       if ( --left <= 0 )
       {
-        cur[0] = (FT_Byte) c;
+        cur[0] = (FT_Byte)c;
         left   = writer->width;
         mask   = 0x80;
 
@@ -110,6 +130,7 @@
     FT_UInt   mask = 0x80;
     FT_UInt   c    = 0;
 
+
     n = writer->total;
 
     phase     = 1;
@@ -128,12 +149,13 @@
           {
             FT_Int  v;
 
+
             if ( p >= limit )
               break;
 
             v         = *p++;
-            counts[0] = (v >> 4);
-            counts[1] = (v & 15);
+            counts[0] = v >> 4;
+            counts[1] = v & 15;
             phase     = 0;
             count     = counts[0];
           }
@@ -142,8 +164,8 @@
             phase = 1;
             count = counts[1];
           }
-        }
-        while ( count == 0 );
+
+        } while ( count == 0 );
       }
 
       if ( phase )
@@ -188,11 +210,12 @@
     FT_UInt   mask = 0x80;
     FT_UInt   c    = 0;
 
+
     n = writer->total;
 
-    phase     = 1;
-    count     = 0;
-    reload    = 1;
+    phase  = 1;
+    count  = 0;
+    reload = 1;
 
     for ( ; n > 0; n-- )
     {
@@ -205,8 +228,8 @@
 
           count = *p++;
           phase = phase ^ 1;
-        }
-        while ( count == 0 );
+
+        } while ( count == 0 );
       }
 
       if ( phase )
@@ -249,40 +272,44 @@
   /*************************************************************************/
 
   static void
-  pfr_lookup_bitmap_data( FT_Byte*    base,
-                          FT_Byte*    limit,
-                          FT_Int      count,
-                          FT_Byte     flags,
-                          FT_UInt     char_code,
-                          FT_ULong*   found_offset,
-                          FT_ULong*   found_size )
+  pfr_lookup_bitmap_data( FT_Byte*   base,
+                          FT_Byte*   limit,
+                          FT_Int     count,
+                          FT_Byte    flags,
+                          FT_UInt    char_code,
+                          FT_ULong*  found_offset,
+                          FT_ULong*  found_size )
   {
-    FT_UInt    left, right, char_len;
-    FT_Bool    two = (flags & 1);
-    FT_Byte*   buff;
+    FT_UInt   left, right, char_len;
+    FT_Bool   two = flags & 1;
+    FT_Byte*  buff;
 
+
     char_len = 4;
-    if ( two )      char_len += 1;
-    if ( flags & 2) char_len += 1;
-    if ( flags & 4) char_len += 1;
+    if ( two )       char_len += 1;
+    if ( flags & 2 ) char_len += 1;
+    if ( flags & 4 ) char_len += 1;
 
-    left      = 0;
-    right     = count;
+    left  = 0;
+    right = count;
 
     while ( left < right )
     {
       FT_UInt  middle, code;
 
-      middle = (left + right) >> 1;
-      buff   = base + middle*char_len;
 
-      /* check that we're not outside of the table */
-      /* this is possible with broken fonts...     */
+      middle = ( left + right ) >> 1;
+      buff   = base + middle * char_len;
+
+      /* check that we are not outside of the table -- */
+      /* this is possible with broken fonts...         */
       if ( buff + char_len > limit )
         goto Fail;
 
-      if (two) code = PFR_NEXT_USHORT(buff);
-         else  code = PFR_NEXT_BYTE(buff);
+      if ( two )
+        code = PFR_NEXT_USHORT( buff );
+      else
+        code = PFR_NEXT_BYTE( buff );
 
       if ( code == char_code )
         goto Found_It;
@@ -300,38 +327,43 @@
     return;
 
   Found_It:
-    if (flags & 2) *found_size = PFR_NEXT_USHORT(buff);
-              else *found_size = PFR_NEXT_BYTE(buff);
+    if ( flags & 2 )
+      *found_size = PFR_NEXT_USHORT( buff );
+    else
+      *found_size = PFR_NEXT_BYTE( buff );
 
-    if (flags & 4) *found_offset = PFR_NEXT_ULONG(buff);
-              else *found_offset = PFR_NEXT_USHORT(buff);
+    if ( flags & 4 )
+      *found_offset = PFR_NEXT_ULONG( buff );
+    else
+      *found_offset = PFR_NEXT_USHORT( buff );
   }
 
 
- /* load bitmap metrics. "*padvance" must be set to the default value */
- /* before calling this function...                                   */
- /*                                                                   */
+  /* load bitmap metrics.  "*padvance" must be set to the default value */
+  /* before calling this function...                                    */
+  /*                                                                    */
   static FT_Error
-  pfr_load_bitmap_metrics( FT_Byte** pdata,
-                           FT_Byte*  limit,
-                           FT_Long   scaled_advance,
-                           FT_Long  *axpos,
-                           FT_Long  *aypos,
-                           FT_UInt  *axsize,
-                           FT_UInt  *aysize,
-                           FT_Long  *aadvance,
-                           FT_UInt  *aformat )
+  pfr_load_bitmap_metrics( FT_Byte**  pdata,
+                           FT_Byte*   limit,
+                           FT_Long    scaled_advance,
+                           FT_Long   *axpos,
+                           FT_Long   *aypos,
+                           FT_UInt   *axsize,
+                           FT_UInt   *aysize,
+                           FT_Long   *aadvance,
+                           FT_UInt   *aformat )
   {
     FT_Error  error = 0;
-    FT_Byte    flags;
-    FT_Char    b;
-    FT_Byte*   p = *pdata;
-    FT_Long    xpos, ypos, advance;
-    FT_UInt    xsize, ysize;
+    FT_Byte   flags;
+    FT_Char   b;
+    FT_Byte*  p = *pdata;
+    FT_Long   xpos, ypos, advance;
+    FT_UInt   xsize, ysize;
 
-    PFR_CHECK(1);
-    flags = PFR_NEXT_BYTE(p);
 
+    PFR_CHECK( 1 );
+    flags = PFR_NEXT_BYTE( p );
+
     xpos    = 0;
     ypos    = 0;
     xsize   = 0;
@@ -338,93 +370,93 @@
     ysize   = 0;
     advance = 0;
 
-    switch (flags & 3)
+    switch ( flags & 3 )
     {
-      case 0:
-        PFR_CHECK(1);
-        b    = PFR_NEXT_INT8(p);
-        xpos = b >> 4;
-        ypos = ((FT_Char)(b << 4)) >> 4;
-        break;
+    case 0:
+      PFR_CHECK( 1 );
+      b    = PFR_NEXT_INT8( p );
+      xpos = b >> 4;
+      ypos = ( (FT_Char)( b << 4 ) ) >> 4;
+      break;
 
-      case 1:
-        PFR_CHECK(2);
-        xpos = PFR_NEXT_INT8(p);
-        ypos = PFR_NEXT_INT8(p);
-        break;
+    case 1:
+      PFR_CHECK( 2 );
+      xpos = PFR_NEXT_INT8( p );
+      ypos = PFR_NEXT_INT8( p );
+      break;
 
-      case 2:
-        PFR_CHECK(4);
-        xpos = PFR_NEXT_SHORT(p);
-        ypos = PFR_NEXT_SHORT(p);
-        break;
+    case 2:
+      PFR_CHECK( 4 );
+      xpos = PFR_NEXT_SHORT( p );
+      ypos = PFR_NEXT_SHORT( p );
+      break;
 
-      case 3:
-        PFR_CHECK(6);
-        xpos = PFR_NEXT_LONG(p);
-        ypos = PFR_NEXT_LONG(p);
-        break;
+    case 3:
+      PFR_CHECK( 6 );
+      xpos = PFR_NEXT_LONG( p );
+      ypos = PFR_NEXT_LONG( p );
+      break;
 
-      default:
-        ;
+    default:
+      ;
     }
 
     flags >>= 2;
-    switch (flags & 3)
+    switch ( flags & 3 )
     {
-      case 0:
-        /* blank image */
-        xsize = 0;
-        ysize = 0;
-        break;
+    case 0:
+      /* blank image */
+      xsize = 0;
+      ysize = 0;
+      break;
 
-      case 1:
-        PFR_CHECK(1);
-        b     = PFR_NEXT_BYTE(p);
-        xsize = (b >> 4) & 0xF;
-        ysize =  b & 0xF;
-        break;
+    case 1:
+      PFR_CHECK( 1 );
+      b     = PFR_NEXT_BYTE( p );
+      xsize = ( b >> 4 ) & 0xF;
+      ysize = b & 0xF;
+      break;
 
-      case 2:
-        PFR_CHECK(2);
-        xsize = PFR_NEXT_BYTE(p);
-        ysize = PFR_NEXT_BYTE(p);
-        break;
+    case 2:
+      PFR_CHECK( 2 );
+      xsize = PFR_NEXT_BYTE( p );
+      ysize = PFR_NEXT_BYTE( p );
+      break;
 
-      case 3:
-        PFR_CHECK(4);
-        xsize = PFR_NEXT_USHORT(p);
-        ysize = PFR_NEXT_USHORT(p);
-        break;
+    case 3:
+      PFR_CHECK( 4 );
+      xsize = PFR_NEXT_USHORT( p );
+      ysize = PFR_NEXT_USHORT( p );
+      break;
 
-      default:
-        ;
+    default:
+      ;
     }
 
     flags >>= 2;
-    switch (flags & 3)
+    switch ( flags & 3 )
     {
-      case 0:
-       advance = scaled_advance;
-       break;
+    case 0:
+      advance = scaled_advance;
+      break;
 
-      case 1:
-        PFR_CHECK(1);
-        advance = PFR_NEXT_INT8(p) << 8;
-        break;
+    case 1:
+      PFR_CHECK( 1 );
+      advance = PFR_NEXT_INT8( p ) << 8;
+      break;
 
-      case 2:
-        PFR_CHECK(2);
-        advance = PFR_NEXT_SHORT(p);
-        break;
+    case 2:
+      PFR_CHECK( 2 );
+      advance = PFR_NEXT_SHORT( p );
+      break;
 
-      case 3:
-        PFR_CHECK(3);
-        advance = PFR_NEXT_LONG(p);
-        break;
+    case 3:
+      PFR_CHECK( 3 );
+      advance = PFR_NEXT_LONG( p );
+      break;
 
-      default:
-        ;
+    default:
+      ;
     }
 
     *axpos    = xpos;
@@ -446,36 +478,37 @@
 
 
   static FT_Error
-  pfr_load_bitmap_bits( FT_Byte*        p,
-                        FT_Byte*        limit,
-                        FT_UInt         format,
-                        FT_UInt         decreasing,
-                        FT_Bitmap*      target )
+  pfr_load_bitmap_bits( FT_Byte*    p,
+                        FT_Byte*    limit,
+                        FT_UInt     format,
+                        FT_UInt     decreasing,
+                        FT_Bitmap*  target )
   {
     FT_Error          error = 0;
     PFR_BitWriterRec  writer;
 
+
     if ( target->rows > 0 && target->width > 0 )
     {
       pfr_bitwriter_init( &writer, target, decreasing );
 
-      switch (format)
+      switch ( format )
       {
-        case 0: /* packed bits */
-          pfr_bitwriter_decode_bytes( &writer, p, limit );
-          break;
+      case 0: /* packed bits */
+        pfr_bitwriter_decode_bytes( &writer, p, limit );
+        break;
 
-        case 1: /* RLE1 */
-          pfr_bitwriter_decode_rle1( &writer, p, limit );
-          break;
+      case 1: /* RLE1 */
+        pfr_bitwriter_decode_rle1( &writer, p, limit );
+        break;
 
-        case 2: /* RLE2 */
-          pfr_bitwriter_decode_rle2( &writer, p, limit );
-          break;
+      case 2: /* RLE2 */
+        pfr_bitwriter_decode_rle2( &writer, p, limit );
+        break;
 
-        default:
-          FT_ERROR(( "pfr_read_bitmap_data: invalid image type\n" ));
-          error = FT_Err_Invalid_File_Format;
+      default:
+        FT_ERROR(( "pfr_read_bitmap_data: invalid image type\n" ));
+        error = FT_Err_Invalid_File_Format;
       }
     }
 
@@ -505,22 +538,24 @@
     PFR_Char     character;
     PFR_Strike   strike;
 
+
     character = &phys->chars[glyph_index];
 
     /* Look-up a bitmap strike corresponding to the current */
     /* character dimensions                                 */
-
     {
-      FT_UInt     n;
+      FT_UInt  n;
 
+
       strike = phys->strikes;
       for ( n = 0; n < phys->num_strikes; n++ )
       {
-        if ( strike->x_ppm == (FT_UInt) size->root.metrics.x_ppem &&
-             strike->y_ppm == (FT_UInt) size->root.metrics.y_ppem )
+        if ( strike->x_ppm == (FT_UInt)size->root.metrics.x_ppem &&
+             strike->y_ppm == (FT_UInt)size->root.metrics.y_ppem )
         {
           goto Found_Strike;
         }
+
         strike++;
       }
 
@@ -532,8 +567,9 @@
 
     /* Now lookup the glyph's position within the file */
     {
-      FT_UInt   char_len;
+      FT_UInt  char_len;
 
+
       char_len = 4;
       if ( strike->flags & 1 ) char_len += 1;
       if ( strike->flags & 2 ) char_len += 1;
@@ -541,7 +577,7 @@
 
       /* Access data directly in the frame to speed lookups */
       if ( FT_STREAM_SEEK( phys->bct_offset + strike->bct_offset ) ||
-           FT_FRAME_ENTER( char_len * strike->num_bitmaps )       )
+           FT_FRAME_ENTER( char_len * strike->num_bitmaps )        )
         goto Exit;
 
       pfr_lookup_bitmap_data( stream->cursor,
@@ -554,7 +590,7 @@
 
       FT_FRAME_EXIT();
 
-      if (gps_size == 0)
+      if ( gps_size == 0 )
       {
         /* Could not find a bitmap program string for this glyph */
         error = FT_Err_Invalid_Argument;
@@ -568,14 +604,15 @@
       FT_UInt   xsize, ysize, format;
       FT_Byte*  p;
 
+
       advance = FT_MulDiv( size->root.metrics.x_ppem << 8,
                            character->advance,
                            phys->metrics_resolution );
 
-      /* XXX: handle linearHoriAdvance correctly !! */
+      /* XXX: handle linearHoriAdvance correctly! */
 
       if ( FT_STREAM_SEEK( face->header.gps_section_offset + gps_offset ) ||
-           FT_FRAME_ENTER( gps_size )                             )
+           FT_FRAME_ENTER( gps_size )                                     )
         goto Exit;
 
       p     = stream->cursor;
@@ -589,9 +626,9 @@
         glyph->root.format = FT_GLYPH_FORMAT_BITMAP;
       
         /* Set up glyph bitmap and metrics */
-        glyph->root.bitmap.width      = (FT_Int) xsize;
-        glyph->root.bitmap.rows       = (FT_Int) ysize;
-        glyph->root.bitmap.pitch      = (FT_Long)(xsize+7) >> 3;
+        glyph->root.bitmap.width      = (FT_Int)xsize;
+        glyph->root.bitmap.rows       = (FT_Int)ysize;
+        glyph->root.bitmap.pitch      = (FT_Long)( xsize + 7 ) >> 3;
         glyph->root.bitmap.pixel_mode = FT_PIXEL_MODE_MONO;
 
         glyph->root.metrics.width        = (FT_Long)xsize << 6;
@@ -598,7 +635,7 @@
         glyph->root.metrics.height       = (FT_Long)ysize << 6;
         glyph->root.metrics.horiBearingX = xpos << 6;
         glyph->root.metrics.horiBearingY = ypos << 6;
-        glyph->root.metrics.horiAdvance  = ((advance >> 2) + 32) & -64;
+        glyph->root.metrics.horiAdvance  = ( ( advance >> 2 ) + 32 ) & -64;
         glyph->root.metrics.vertBearingX = - glyph->root.metrics.width >> 1;
         glyph->root.metrics.vertBearingY = 0;
         glyph->root.metrics.vertAdvance  = size->root.metrics.height;
@@ -609,18 +646,20 @@
         /* Allocate and read bitmap data */
         {
           FT_Memory  memory = face->root.memory;
-          FT_Long    len    = glyph->root.bitmap.pitch*ysize;
+          FT_Long    len    = glyph->root.bitmap.pitch * ysize;
 
+
           if ( !FT_ALLOC( glyph->root.bitmap.buffer, len ) )
           {
             error = pfr_load_bitmap_bits( p,
                                           stream->limit,
                                           format,
-                                          (face->header.color_flags & 2),
+                                          face->header.color_flags & 2,
                                           &glyph->root.bitmap );
           }
         }
       }
+
       FT_FRAME_EXIT();
     }
 
@@ -627,3 +666,5 @@
   Exit:
     return error;
   }
+
+/* END */
--- a/src/pfr/pfrsbit.h
+++ b/src/pfr/pfrsbit.h
@@ -1,8 +1,8 @@
 /***************************************************************************/
 /*                                                                         */
-/*  pfrsbit.c                                                              */
+/*  pfrsbit.h                                                              */
 /*                                                                         */
-/*    FreeType PFR bitmap loader                                           */
+/*    FreeType PFR bitmap loader (specification).                          */
 /*                                                                         */
 /*  Copyright 2002 by                                                      */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
@@ -15,6 +15,7 @@
 /*                                                                         */
 /***************************************************************************/
 
+
 #ifndef __PFRSBIT_H__
 #define __PFRSBIT_H__
 
@@ -30,3 +31,6 @@
 FT_END_HEADER
 
 #endif /* __PFR_SBIT_H__ */
+
+
+/* END */
--- a/src/pfr/pfrtypes.h
+++ b/src/pfr/pfrtypes.h
@@ -192,7 +192,8 @@
   /************************************************************************/
 
   typedef struct PFR_KernItemRec_*  PFR_KernItem;
-  typedef struct PFR_KernItemRec_
+
+  typedef struct  PFR_KernItemRec_
   {
     PFR_KernItem  next;
     FT_UInt       pair_count;
@@ -205,7 +206,8 @@
 
   } PFR_KernItemRec;
 
-#define PFR_KERN_INDEX( g1, g2 )  ( ( (FT_UInt32)(g1) << 16 ) | (FT_UInt16)(g2) )
+#define PFR_KERN_INDEX( g1, g2 ) \
+  ( ( (FT_UInt32)(g1) << 16 ) | (FT_UInt16)(g2) )
 
   typedef struct  PFR_KernPairRec_
   {
--- a/src/sfnt/ttcmap0.c
+++ b/src/sfnt/ttcmap0.c
@@ -597,8 +597,9 @@
     FT_Byte   *ends, *starts, *offsets, *deltas, *glyph_ids;
     FT_UInt   num_segs;
 
-    /* in certain fonts, the 'length' field is invalid and goes */
-    /* out of bound. We try to correct this here...             */
+
+    /* in certain fonts, the `length' field is invalid and goes */
+    /* out of bound.  We try to correct this here...            */
     if ( length < 16 )
       FT_INVALID_TOO_SHORT;