First round in converting

  type foo ( ... )

to

  type
  foo ( ... )

Other minor formatting issues.

12 files changed, 250 insertions, 244 deletions

diff --git a/src/autohint/ahangles.c b/src/autohint/ahangles.c
index 3f1b43cd4..b16fa7756 100644
--- a/src/autohint/ahangles.c
+++ b/src/autohint/ahangles.c
@@ -64,8 +64,8 @@
   };
 
 
-  FT_LOCAL_DEF
-  AH_Angle  ah_angle( FT_Vector*  v )
+  FT_LOCAL_DEF AH_Angle
+  ah_angle( FT_Vector*  v )
   {
     FT_Pos    dx, dy;
     AH_Angle  angle;
diff --git a/src/autohint/ahangles.h b/src/autohint/ahangles.h
index f66ad1795..6cb69a28f 100644
--- a/src/autohint/ahangles.h
+++ b/src/autohint/ahangles.h
@@ -47,8 +47,8 @@ FT_BEGIN_HEADER
   const AH_Angle  ah_arctan[1L << AH_ATAN_BITS];
 
 
-  FT_LOCAL
-  AH_Angle  ah_angle( FT_Vector*  v );
+  FT_LOCAL AH_Angle
+  ah_angle( FT_Vector*  v );
 
 
 FT_END_HEADER
diff --git a/src/autohint/ahglobal.c b/src/autohint/ahglobal.c
index 7eaf9d34c..da9e97490 100644
--- a/src/autohint/ahglobal.c
+++ b/src/autohint/ahglobal.c
@@ -39,9 +39,9 @@
 
 
   /* simple insertion sort */
-  static
-  void  sort_values( FT_Int   count,
-                     FT_Pos*  table )
+  static void
+  sort_values( FT_Int   count,
+               FT_Pos*  table )
   {
     FT_Int  i, j, swap;
 
@@ -61,8 +61,8 @@
   }
 
 
-  static
-  FT_Error  ah_hinter_compute_blues( AH_Hinter*  hinter )
+  static FT_Error
+  ah_hinter_compute_blues( AH_Hinter*  hinter )
   {
     AH_Blue       blue;
     AH_Globals*   globals = &hinter->globals->design;
@@ -285,8 +285,8 @@
   }
 
 
-  static
-  FT_Error  ah_hinter_compute_widths( AH_Hinter*  hinter )
+  static FT_Error
+  ah_hinter_compute_widths( AH_Hinter*  hinter )
   {
     /* scan the array of segments in each direction */
     AH_Outline*  outline = hinter->glyph;
@@ -384,8 +384,8 @@
   }
 
 
-  FT_LOCAL_DEF
-  FT_Error  ah_hinter_compute_globals( AH_Hinter*  hinter )
+  FT_LOCAL_DEF FT_Error
+  ah_hinter_compute_globals( AH_Hinter*  hinter )
   {
     return ah_hinter_compute_widths( hinter ) ||
            ah_hinter_compute_blues ( hinter );
diff --git a/src/autohint/ahglyph.c b/src/autohint/ahglyph.c
index be0d09b5f..cb48ec44b 100644
--- a/src/autohint/ahglyph.c
+++ b/src/autohint/ahglyph.c
@@ -32,7 +32,8 @@
 
 #ifdef AH_DEBUG
 
-  void  ah_dump_edges( AH_Outline*  outline )
+  void
+  ah_dump_edges( AH_Outline*  outline )
   {
     AH_Edge*     edges;
     AH_Edge*     edge_limit;
@@ -83,7 +84,8 @@
 
 
   /* A function used to dump the array of linked segments */
-  void  ah_dump_segments( AH_Outline*  outline )
+  void
+  ah_dump_segments( AH_Outline*  outline )
   {
     AH_Segment*  segments;
     AH_Segment*  segment_limit;
@@ -135,9 +137,9 @@
 
 
   /* compute the direction value of a given vector.. */
-  static
-  AH_Direction  ah_compute_direction( FT_Pos  dx,
-                                      FT_Pos  dy )
+  static AH_Direction
+  ah_compute_direction( FT_Pos  dx,
+                        FT_Pos  dy )
   {
     AH_Direction  dir;
     FT_Pos        ax = ABS( dx );
@@ -163,9 +165,9 @@
 
   /* this function is used by ah_get_orientation (see below) to test */
   /* the fill direction of a given bbox extrema                      */
-  static
-  int  ah_test_extrema( FT_Outline*  outline,
-                        int          n )
+  static int
+  ah_test_extrema( FT_Outline*  outline,
+                   int          n )
   {
     FT_Vector  *prev, *cur, *next;
     FT_Pos      product;
@@ -217,8 +219,8 @@
   /*                                                                       */
   /* The function returns either 1 or -1.                                  */
   /*                                                                       */
-  static
-  int  ah_get_orientation( FT_Outline*  outline )
+  static int
+  ah_get_orientation( FT_Outline*  outline )
   {
     FT_BBox  box;
     FT_BBox  indices;
@@ -299,9 +301,9 @@
   /* <Description>                                                         */
   /*    Creates a new and empty AH_Outline object.                         */
   /*                                                                       */
-  FT_LOCAL_DEF
-  FT_Error  ah_outline_new( FT_Memory     memory,
-                            AH_Outline**  aoutline )
+  FT_LOCAL_DEF FT_Error
+  ah_outline_new( FT_Memory     memory,
+                  AH_Outline**  aoutline )
   {
     FT_Error     error;
     AH_Outline*  outline;
@@ -325,8 +327,8 @@
   /* <Description>                                                         */
   /*    Destroys a given AH_Outline object.                                */
   /*                                                                       */
-  FT_LOCAL_DEF
-  void  ah_outline_done( AH_Outline*  outline )
+  FT_LOCAL_DEF void
+  ah_outline_done( AH_Outline*  outline )
   {
     FT_Memory memory = outline->memory;
 
@@ -349,9 +351,9 @@
   /*    Saves the content of a given AH_Outline object into a face's glyph */
   /*    slot.                                                              */
   /*                                                                       */
-  FT_LOCAL_DEF
-  void  ah_outline_save( AH_Outline*  outline,
-                         AH_Loader*   gloader )
+  FT_LOCAL_DEF void
+  ah_outline_save( AH_Outline*  outline,
+                   AH_Loader*   gloader )
   {
     AH_Point*   point       = outline->points;
     AH_Point*   point_limit = point + outline->num_points;
@@ -384,9 +386,9 @@
   /*    Loads an unscaled outline from a glyph slot into an AH_Outline     */
   /*    object.                                                            */
   /*                                                                       */
-  FT_LOCAL_DEF
-  FT_Error  ah_outline_load( AH_Outline*  outline,
-                             FT_Face      face )
+  FT_LOCAL_DEF FT_Error
+  ah_outline_load( AH_Outline*  outline,
+                   FT_Face      face )
   {
     FT_Memory   memory       = outline->memory;
     FT_Error    error        = AH_Err_Ok;
@@ -619,9 +621,9 @@
   }
 
 
-  FT_LOCAL_DEF
-  void  ah_setup_uv( AH_Outline*  outline,
-                     AH_UV        source )
+  FT_LOCAL_DEF void
+  ah_setup_uv( AH_Outline*  outline,
+               AH_UV        source )
   {
     AH_Point*  point       = outline->points;
     AH_Point*  point_limit = point + outline->num_points;
@@ -673,8 +675,8 @@
   }
 
 
-  FT_LOCAL_DEF
-  void  ah_outline_compute_segments( AH_Outline*  outline )
+  FT_LOCAL_DEF void
+  ah_outline_compute_segments( AH_Outline*  outline )
   {
     int           dimension;
     AH_Segment*   segments;
@@ -916,8 +918,8 @@
   }
 
 
-  FT_LOCAL_DEF
-  void  ah_outline_link_segments( AH_Outline*  outline )
+  FT_LOCAL_DEF void
+  ah_outline_link_segments( AH_Outline*  outline )
   {
     AH_Segment*  segments;
     AH_Segment*  segment_limit;
@@ -1036,9 +1038,8 @@
   }
 
 
-
-  static
-  void  ah_outline_compute_edges( AH_Outline*  outline )
+  static void
+  ah_outline_compute_edges( AH_Outline*  outline )
   {
     AH_Edge*      edges;
     AH_Segment*   segments;
@@ -1290,8 +1291,8 @@
   /* <Description>                                                         */
   /*    Performs feature detection on a given AH_Outline object.           */
   /*                                                                       */
-  FT_LOCAL_DEF
-  void  ah_outline_detect_features( AH_Outline*  outline )
+  FT_LOCAL_DEF void
+  ah_outline_detect_features( AH_Outline*  outline )
   {
     ah_outline_compute_segments( outline );
     ah_outline_link_segments   ( outline );
@@ -1308,9 +1309,9 @@
   /*    Computes the `blue edges' in a given outline (i.e. those that must */
   /*    be snapped to a blue zone edge (top or bottom).                    */
   /*                                                                       */
-  FT_LOCAL_DEF
-  void  ah_outline_compute_blue_edges( AH_Outline*       outline,
-                                       AH_Face_Globals*  face_globals )
+  FT_LOCAL_DEF void
+  ah_outline_compute_blue_edges( AH_Outline*       outline,
+                                 AH_Face_Globals*  face_globals )
   {
     AH_Edge*     edge       = outline->horz_edges;
     AH_Edge*     edge_limit = edge + outline->num_hedges;
@@ -1442,9 +1443,9 @@
   /*    the contents of the detected edges (basically change the `blue     */
   /*    edge' pointer from `design units' to `scaled ones').               */
   /*                                                                       */
-  FT_LOCAL_DEF
-  void  ah_outline_scale_blue_edges( AH_Outline*       outline,
-                                     AH_Face_Globals*  globals )
+  FT_LOCAL_DEF void
+  ah_outline_scale_blue_edges( AH_Outline*       outline,
+                               AH_Face_Globals*  globals )
   {
     AH_Edge*  edge       = outline->horz_edges;
     AH_Edge*  edge_limit = edge + outline->num_hedges;
@@ -1461,6 +1462,4 @@
   }
 
 
-
-
 /* END */
diff --git a/src/autohint/ahglyph.h b/src/autohint/ahglyph.h
index d91065165..532a5bce2 100644
--- a/src/autohint/ahglyph.h
+++ b/src/autohint/ahglyph.h
@@ -45,43 +45,44 @@ FT_BEGIN_HEADER
   } AH_UV;
 
 
-  FT_LOCAL
-  void  ah_setup_uv( AH_Outline*  outline,
-                     AH_UV        source );
+  FT_LOCAL void
+  ah_setup_uv( AH_Outline*  outline,
+               AH_UV        source );
 
 
   /* AH_Outline functions - they should be typically called in this order */
 
-  FT_LOCAL
-  FT_Error  ah_outline_new( FT_Memory     memory,
-                            AH_Outline**  aoutline );
+  FT_LOCAL FT_Error
+  ah_outline_new( FT_Memory     memory,
+                  AH_Outline**  aoutline );
 
-  FT_LOCAL
-  FT_Error  ah_outline_load( AH_Outline*  outline,
-                             FT_Face      face );
+  FT_LOCAL FT_Error
+  ah_outline_load( AH_Outline*  outline,
+                   FT_Face      face );
 
-  FT_LOCAL
-  void  ah_outline_compute_segments( AH_Outline*  outline );
+  FT_LOCAL void
+  ah_outline_compute_segments( AH_Outline*  outline );
 
-  FT_LOCAL
-  void  ah_outline_link_segments( AH_Outline*  outline );
+  FT_LOCAL void
+  ah_outline_link_segments( AH_Outline*  outline );
 
-  FT_LOCAL
-  void  ah_outline_detect_features( AH_Outline*  outline );
+  FT_LOCAL void
+  ah_outline_detect_features( AH_Outline*  outline );
 
-  FT_LOCAL
-  void  ah_outline_compute_blue_edges( AH_Outline*       outline,
-                                       AH_Face_Globals*  globals );
+  FT_LOCAL void
+  ah_outline_compute_blue_edges( AH_Outline*       outline,
+                                 AH_Face_Globals*  globals );
 
-  FT_LOCAL
-  void  ah_outline_scale_blue_edges( AH_Outline*       outline,
-                                     AH_Face_Globals*  globals );
+  FT_LOCAL void
+  ah_outline_scale_blue_edges( AH_Outline*       outline,
+                               AH_Face_Globals*  globals );
 
-  FT_LOCAL
-  void  ah_outline_save( AH_Outline*  outline, AH_Loader*  loader );
+  FT_LOCAL void
+  ah_outline_save( AH_Outline*  outline,
+                   AH_Loader*   loader );
 
-  FT_LOCAL
-  void  ah_outline_done( AH_Outline*  outline );
+  FT_LOCAL void
+  ah_outline_done( AH_Outline*  outline );
 
 
 FT_END_HEADER
diff --git a/src/autohint/ahhint.c b/src/autohint/ahhint.c
index 505949be2..a8888a853 100644
--- a/src/autohint/ahhint.c
+++ b/src/autohint/ahhint.c
@@ -43,10 +43,10 @@
 
   /* snap a given width in scaled coordinates to one of the */
   /* current standard widths                                */
-  static
-  FT_Pos  ah_snap_width( FT_Pos*  widths,
-                         FT_Int   count,
-                         FT_Pos   width )
+  static FT_Pos
+  ah_snap_width( FT_Pos*  widths,
+                 FT_Int   count,
+                 FT_Pos   width )
   {
     int     n;
     FT_Pos  best      = 64 + 32 + 2;
@@ -88,11 +88,11 @@
 
 
   /* align one stem edge relative to the previous stem edge */
-  static
-  void  ah_align_linked_edge( AH_Hinter*  hinter,
-                              AH_Edge*    base_edge,
-                              AH_Edge*    stem_edge,
-                              int         vertical )
+  static void
+  ah_align_linked_edge( AH_Hinter*  hinter,
+                        AH_Edge*    base_edge,
+                        AH_Edge*    stem_edge,
+                        int         vertical )
   {
     FT_Pos       dist    = stem_edge->opos - base_edge->opos;
     AH_Globals*  globals = &hinter->globals->scaled;
@@ -146,10 +146,10 @@
   }
 
 
-  static
-  void  ah_align_serif_edge( AH_Hinter*  hinter,
-                             AH_Edge*    base,
-                             AH_Edge*    serif )
+  static void
+  ah_align_serif_edge( AH_Hinter*  hinter,
+                       AH_Edge*    base,
+                       AH_Edge*    serif )
   {
     FT_Pos  dist;
     FT_Pos  sign = 1;
@@ -190,8 +190,8 @@
 
 
   /* Another alternative edge hinting algorithm */
-  static
-  void  ah_hint_edges_3( AH_Hinter*  hinter )
+  static void
+  ah_hint_edges_3( AH_Hinter*  hinter )
   {
     AH_Edge*     edges;
     AH_Edge*     edge_limit;
@@ -372,10 +372,10 @@
   }
 
 
-  FT_LOCAL_DEF
-  void  ah_hinter_hint_edges( AH_Hinter*  hinter,
-                              FT_Bool     no_horz_edges,
-                              FT_Bool     no_vert_edges )
+  FT_LOCAL_DEF void
+  ah_hinter_hint_edges( AH_Hinter*  hinter,
+                        FT_Bool     no_horz_edges,
+                        FT_Bool     no_vert_edges )
   {
     hinter->disable_horz_edges = no_horz_edges;
     hinter->disable_vert_edges = no_vert_edges;
@@ -415,8 +415,8 @@
   /*************************************************************************/
   /*************************************************************************/
 
-  static
-  void  ah_hinter_align_edge_points( AH_Hinter*  hinter )
+  static void
+  ah_hinter_align_edge_points( AH_Hinter*  hinter )
   {
     AH_Outline*  outline = hinter->glyph;
     AH_Edge*     edges;
@@ -476,8 +476,8 @@
 
 
   /* hint the strong points -- this is equivalent to the TrueType `IP' */
-  static
-  void  ah_hinter_align_strong_points( AH_Hinter*  hinter )
+  static void
+  ah_hinter_align_strong_points( AH_Hinter*  hinter )
   {
     AH_Outline*  outline = hinter->glyph;
     FT_Int       dimension;
@@ -605,10 +605,10 @@
 
 #ifndef AH_OPTION_NO_WEAK_INTERPOLATION
 
-  static
-  void  ah_iup_shift( AH_Point*  p1,
-                      AH_Point*  p2,
-                      AH_Point*  ref )
+  static void
+  ah_iup_shift( AH_Point*  p1,
+                AH_Point*  p2,
+                AH_Point*  ref )
   {
     AH_Point*  p;
     FT_Pos     delta = ref->u - ref->v;
@@ -622,11 +622,11 @@
   }
 
 
-  static
-  void  ah_iup_interp( AH_Point*  p1,
-                       AH_Point*  p2,
-                       AH_Point*  ref1,
-                       AH_Point*  ref2 )
+  static void
+  ah_iup_interp( AH_Point*  p1,
+                 AH_Point*  p2,
+                 AH_Point*  ref1,
+                 AH_Point*  ref2 )
   {
     AH_Point*  p;
     FT_Pos     u;
@@ -691,8 +691,8 @@
 
 
   /* interpolate weak points -- this is equivalent to the TrueType `IUP' */
-  static
-  void  ah_hinter_align_weak_points( AH_Hinter*  hinter )
+  static void
+  ah_hinter_align_weak_points( AH_Hinter*  hinter )
   {
     AH_Outline*  outline = hinter->glyph;
     FT_Int       dimension;
@@ -799,8 +799,8 @@
 #endif /* !AH_OPTION_NO_WEAK_INTERPOLATION */
 
 
-  FT_LOCAL_DEF
-  void  ah_hinter_align_points( AH_Hinter*  hinter )
+  FT_LOCAL_DEF void
+  ah_hinter_align_points( AH_Hinter*  hinter )
   {
     ah_hinter_align_edge_points( hinter );
 
@@ -826,10 +826,10 @@
 
 
   /* scale and fit the global metrics */
-  static
-  void  ah_hinter_scale_globals( AH_Hinter*  hinter,
-                                 FT_Fixed    x_scale,
-                                 FT_Fixed    y_scale )
+  static void
+  ah_hinter_scale_globals( AH_Hinter*  hinter,
+                           FT_Fixed    x_scale,
+                           FT_Fixed    y_scale )
   {
     FT_Int            n;
     AH_Face_Globals*  globals = hinter->globals;
@@ -879,8 +879,8 @@
   }
 
 
-  static
-  void  ah_hinter_align( AH_Hinter*  hinter )
+  static void
+  ah_hinter_align( AH_Hinter*  hinter )
   {
     ah_hinter_align_edge_points( hinter );
     ah_hinter_align_points( hinter );
@@ -888,8 +888,8 @@
 
 
   /* finalize a hinter object */
-  FT_LOCAL_DEF
-  void ah_hinter_done( AH_Hinter*  hinter )
+  FT_LOCAL_DEF void
+  ah_hinter_done( AH_Hinter*  hinter )
   {
     if ( hinter )
     {
@@ -911,9 +911,9 @@
 
 
   /* create a new empty hinter object */
-  FT_LOCAL_DEF
-  FT_Error  ah_hinter_new( FT_Library   library,
-                           AH_Hinter**  ahinter )
+  FT_LOCAL_DEF FT_Error
+  ah_hinter_new( FT_Library   library,
+                 AH_Hinter**  ahinter )
   {
     AH_Hinter*  hinter = 0;
     FT_Memory   memory = library->memory;
@@ -947,10 +947,10 @@
 
 
   /* create a face's autohint globals */
-  FT_LOCAL_DEF
-  FT_Error  ah_hinter_new_face_globals( AH_Hinter*   hinter,
-                                        FT_Face      face,
-                                        AH_Globals*  globals )
+  FT_LOCAL_DEF FT_Error
+  ah_hinter_new_face_globals( AH_Hinter*   hinter,
+                              FT_Face      face,
+                              AH_Globals*  globals )
   {
     FT_Error          error;
     FT_Memory         memory = hinter->memory;
@@ -979,8 +979,8 @@
 
 
   /* discard a face's autohint globals */
-  FT_LOCAL_DEF
-  void  ah_hinter_done_face_globals( AH_Face_Globals*  globals )
+  FT_LOCAL_DEF void
+  ah_hinter_done_face_globals( AH_Face_Globals*  globals )
   {
     FT_Face    face   = globals->face;
     FT_Memory  memory = face->memory;
@@ -990,11 +990,11 @@
   }
 
 
-  static
-  FT_Error  ah_hinter_load( AH_Hinter*  hinter,
-                            FT_UInt     glyph_index,
-                            FT_UInt     load_flags,
-                            FT_UInt     depth )
+  static FT_Error
+  ah_hinter_load( AH_Hinter*  hinter,
+                  FT_UInt     glyph_index,
+                  FT_UInt     load_flags,
+                  FT_UInt     depth )
   {
     FT_Face           face     = hinter->face;
     FT_GlyphSlot      slot     = face->glyph;
@@ -1308,12 +1308,12 @@
 
 
   /* load and hint a given glyph */
-  FT_LOCAL_DEF
-  FT_Error  ah_hinter_load_glyph( AH_Hinter*    hinter,
-                                  FT_GlyphSlot  slot,
-                                  FT_Size       size,
-                                  FT_UInt       glyph_index,
-                                  FT_Int        load_flags )
+  FT_LOCAL_DEF FT_Error
+  ah_hinter_load_glyph( AH_Hinter*    hinter,
+                        FT_GlyphSlot  slot,
+                        FT_Size       size,
+                        FT_UInt       glyph_index,
+                        FT_Int        load_flags )
   {
     FT_Face           face         = slot->face;
     FT_Error          error;
@@ -1362,11 +1362,11 @@
 
 
   /* retrieve a face's autohint globals for client applications */
-  FT_LOCAL_DEF
-  void  ah_hinter_get_global_hints( AH_Hinter*  hinter,
-                                    FT_Face     face,
-                                    void**      global_hints,
-                                    long*       global_len )
+  FT_LOCAL_DEF void
+  ah_hinter_get_global_hints( AH_Hinter*  hinter,
+                              FT_Face     face,
+                              void**      global_hints,
+                              long*       global_len )
   {
     AH_Globals*  globals = 0;
     FT_Memory    memory  = hinter->memory;
@@ -1399,9 +1399,9 @@
   }
 
 
-  FT_LOCAL_DEF
-  void  ah_hinter_done_global_hints( AH_Hinter*  hinter,
-                                     void*       global_hints )
+  FT_LOCAL_DEF void
+  ah_hinter_done_global_hints( AH_Hinter*  hinter,
+                               void*       global_hints )
   {
     FT_Memory  memory = hinter->memory;
 
diff --git a/src/autohint/ahhint.h b/src/autohint/ahhint.h
index fbd7230cf..55d81cb9b 100644
--- a/src/autohint/ahhint.h
+++ b/src/autohint/ahhint.h
@@ -37,34 +37,34 @@ FT_BEGIN_HEADER
 
 
   /* create a new empty hinter object */
-  FT_LOCAL
-  FT_Error ah_hinter_new( FT_Library   library,
-                          AH_Hinter**  ahinter );
+  FT_LOCAL FT_Error
+  ah_hinter_new( FT_Library   library,
+                 AH_Hinter**  ahinter );
 
   /* Load a hinted glyph in the hinter */
-  FT_LOCAL
-  FT_Error  ah_hinter_load_glyph( AH_Hinter*    hinter,
-                                  FT_GlyphSlot  slot,
-                                  FT_Size       size,
-                                  FT_UInt       glyph_index,
-                                  FT_Int        load_flags );
+  FT_LOCAL FT_Error
+  ah_hinter_load_glyph( AH_Hinter*    hinter,
+                        FT_GlyphSlot  slot,
+                        FT_Size       size,
+                        FT_UInt       glyph_index,
+                        FT_Int        load_flags );
 
   /* finalize a hinter object */
-  FT_LOCAL
-  void  ah_hinter_done( AH_Hinter*  hinter );
+  FT_LOCAL void
+  ah_hinter_done( AH_Hinter*  hinter );
 
-  FT_LOCAL
-  void  ah_hinter_done_face_globals( AH_Face_Globals*  globals );
+  FT_LOCAL void
+  ah_hinter_done_face_globals( AH_Face_Globals*  globals );
 
-  FT_LOCAL
-  void  ah_hinter_get_global_hints( AH_Hinter*  hinter,
-                                    FT_Face     face,
-                                    void**      global_hints,
-                                    long*       global_len );
+  FT_LOCAL void
+  ah_hinter_get_global_hints( AH_Hinter*  hinter,
+                              FT_Face     face,
+                              void**      global_hints,
+                              long*       global_len );
 
-  FT_LOCAL
-  void  ah_hinter_done_global_hints( AH_Hinter*  hinter,
-                                     void*       global_hints );
+  FT_LOCAL void
+  ah_hinter_done_global_hints( AH_Hinter*  hinter,
+                               void*       global_hints );
 
 
 FT_END_HEADER
diff --git a/src/autohint/ahloader.h b/src/autohint/ahloader.h
index aea60c333..0f7b1731a 100644
--- a/src/autohint/ahloader.h
+++ b/src/autohint/ahloader.h
@@ -69,40 +69,40 @@ FT_BEGIN_HEADER
   };
 
 
-  FT_LOCAL
-  FT_Error  AH_GlyphLoader_New( FT_Memory         memory,
-                                AH_GlyphLoader**  aloader );
+  FT_LOCAL FT_Error
+  AH_GlyphLoader_New( FT_Memory         memory,
+                      AH_GlyphLoader**  aloader );
 
-  FT_LOCAL
-  FT_Error  AH_GlyphLoader_Create_Extra( AH_GlyphLoader*  loader );
+  FT_LOCAL FT_Error
+  AH_GlyphLoader_Create_Extra( AH_GlyphLoader*  loader );
 
-  FT_LOCAL
-  void  AH_GlyphLoader_Done( AH_GlyphLoader*  loader );
+  FT_LOCAL void
+  AH_GlyphLoader_Done( AH_GlyphLoader*  loader );
 
-  FT_LOCAL
-  void  AH_GlyphLoader_Reset( AH_GlyphLoader*  loader );
+  FT_LOCAL void
+  AH_GlyphLoader_Reset( AH_GlyphLoader*  loader );
 
-  FT_LOCAL
-  void  AH_GlyphLoader_Rewind( AH_GlyphLoader*  loader );
+  FT_LOCAL void
+  AH_GlyphLoader_Rewind( AH_GlyphLoader*  loader );
 
-  FT_LOCAL
-  FT_Error  AH_GlyphLoader_Check_Points( AH_GlyphLoader*  loader,
-                                         FT_UInt          n_points,
-                                         FT_UInt          n_contours );
+  FT_LOCAL FT_Error
+  AH_GlyphLoader_Check_Points( AH_GlyphLoader*  loader,
+                               FT_UInt          n_points,
+                               FT_UInt          n_contours );
 
-  FT_LOCAL
-  FT_Error  AH_GlyphLoader_Check_Subglyphs( AH_GlyphLoader*  loader,
-                                            FT_UInt          n_subs );
+  FT_LOCAL FT_Error
+  AH_GlyphLoader_Check_Subglyphs( AH_GlyphLoader*  loader,
+                                  FT_UInt          n_subs );
 
-  FT_LOCAL
-  void  AH_GlyphLoader_Prepare( AH_GlyphLoader*  loader );
+  FT_LOCAL void
+  AH_GlyphLoader_Prepare( AH_GlyphLoader*  loader );
 
-  FT_LOCAL
-  void  AH_GlyphLoader_Add( AH_GlyphLoader*  loader );
+  FT_LOCAL void
+  AH_GlyphLoader_Add( AH_GlyphLoader*  loader );
 
-  FT_LOCAL
-  FT_Error  AH_GlyphLoader_Copy_Points( AH_GlyphLoader*  target,
-                                        FT_GlyphLoader*  source );
+  FT_LOCAL FT_Error
+  AH_GlyphLoader_Copy_Points( AH_GlyphLoader*  target,
+                              FT_GlyphLoader*  source );
 
 #else /* _STANDALONE */
 
diff --git a/src/autohint/ahmodule.c b/src/autohint/ahmodule.c
index 7b726c76e..d16b260b4 100644
--- a/src/autohint/ahmodule.c
+++ b/src/autohint/ahmodule.c
@@ -32,21 +32,21 @@
   } FT_AutoHinterRec;
 
 
-  FT_CALLBACK_DEF(FT_Error)
+  FT_CALLBACK_DEF( FT_Error )
   ft_autohinter_init( FT_AutoHinter  module )
   {
     return ah_hinter_new( module->root.library, &module->hinter );
   }
 
 
-  FT_CALLBACK_DEF(void)
+  FT_CALLBACK_DEF( void )
   ft_autohinter_done( FT_AutoHinter  module )
   {
     ah_hinter_done( module->hinter );
   }
 
 
-  FT_CALLBACK_DEF(FT_Error)
+  FT_CALLBACK_DEF( FT_Error )
   ft_autohinter_load( FT_AutoHinter  module,
                       FT_GlyphSlot   slot,
                       FT_Size        size,
@@ -58,7 +58,7 @@
   }
 
 
-  FT_CALLBACK_DEF(void)
+  FT_CALLBACK_DEF( void )
   ft_autohinter_reset( FT_AutoHinter  module,
                        FT_Face        face )
   {
@@ -69,7 +69,7 @@
   }
 
 
-  FT_CALLBACK_DEF(void)
+  FT_CALLBACK_DEF( void )
   ft_autohinter_get_globals( FT_AutoHinter  module,
                              FT_Face        face,
                              void**         global_hints,
@@ -80,7 +80,7 @@
   }
 
 
-  FT_CALLBACK_DEF(void)
+  FT_CALLBACK_DEF( void )
   ft_autohinter_done_globals( FT_AutoHinter  module,
                               void*          global_hints )
   {
diff --git a/src/autohint/ahoptim.c b/src/autohint/ahoptim.c
index 848526c2b..e2992eab0 100644
--- a/src/autohint/ahoptim.c
+++ b/src/autohint/ahoptim.c
@@ -65,8 +65,8 @@
 
 #define FLOAT( x )  ( (float)( (x) / 64.0 ) )
 
-  static
-  void  optim_log( const char*  fmt, ... )
+  static void
+  optim_log( const char*  fmt, ... )
   {
     va_list  ap;
 
@@ -77,8 +77,8 @@
   }
 
 
-  static
-  void  AH_Dump_Stems( AH_Optimizer*  optimizer )
+  static void
+  AH_Dump_Stems( AH_Optimizer*  optimizer )
   {
     int       n;
     AH_Stem*  stem;
@@ -98,8 +98,8 @@
   }
 
 
-  static
-  void  AH_Dump_Stems2( AH_Optimizer*  optimizer )
+  static void
+  AH_Dump_Stems2( AH_Optimizer*  optimizer )
   {
     int       n;
     AH_Stem*  stem;
@@ -117,8 +117,8 @@
   }
 
 
-  static
-  void  AH_Dump_Springs( AH_Optimizer*  optimizer )
+  static void
+  AH_Dump_Springs( AH_Optimizer*  optimizer )
   {
     int  n;
     AH_Spring*  spring;
@@ -156,9 +156,9 @@
   /*************************************************************************/
 
 
-  static
-  int  valid_stem_segments( AH_Segment*  seg1,
-                            AH_Segment*  seg2 )
+  static int
+  valid_stem_segments( AH_Segment*  seg1,
+                       AH_Segment*  seg2 )
   {
     return seg1->serif == 0                   &&
            seg2                               &&
@@ -170,8 +170,8 @@
 
 
   /* compute all stems in an outline */
-  static
-  int  optim_compute_stems( AH_Optimizer*  optimizer )
+  static int
+  optim_compute_stems( AH_Optimizer*  optimizer )
   {
     AH_Outline*  outline = optimizer->outline;
     FT_Fixed     scale;
@@ -332,9 +332,9 @@
 
 
   /* returns the spring area between two stems, 0 if none */
-  static
-  FT_Pos  stem_spring_area( AH_Stem*  stem1,
-                            AH_Stem*  stem2 )
+  static FT_Pos
+  stem_spring_area( AH_Stem*  stem1,
+                    AH_Stem*  stem2 )
   {
     FT_Pos  area1 = stem1->max_coord - stem1->min_coord;
     FT_Pos  area2 = stem2->max_coord - stem2->min_coord;
@@ -362,8 +362,8 @@
 
 
   /* compute all springs in an outline */
-  static
-  int  optim_compute_springs( AH_Optimizer*  optimizer )
+  static int
+  optim_compute_springs( AH_Optimizer*  optimizer )
   {
     /* basically, a spring exists between two stems if most of their */
     /* surface is aligned                                            */
@@ -469,8 +469,8 @@
 #ifndef AH_BRUTE_FORCE
 
   /* compute all spring tensions */
-  static
-  void  optim_compute_tensions( AH_Optimizer*  optimizer )
+  static void
+  optim_compute_tensions( AH_Optimizer*  optimizer )
   {
     AH_Spring*  spring = optimizer->springs;
     AH_Spring*  limit  = spring + optimizer->num_springs;
@@ -527,8 +527,8 @@
 
 
   /* compute all stem movements -- returns 0 if nothing moved */
-  static
-  int  optim_compute_stem_movements( AH_Optimizer*  optimizer )
+  static int
+  optim_compute_stem_movements( AH_Optimizer*  optimizer )
   {
     AH_Stem*  stems = optimizer->stems;
     AH_Stem*  limit = stems + optimizer->num_stems;
@@ -588,8 +588,8 @@
 
 
   /* compute current global distortion from springs */
-  static
-  FT_Pos  optim_compute_distortion( AH_Optimizer*  optimizer )
+  static FT_Pos
+  optim_compute_distortion( AH_Optimizer*  optimizer )
   {
     AH_Spring*  spring = optimizer->springs;
     AH_Spring*  limit  = spring + optimizer->num_springs;
@@ -615,8 +615,8 @@
 
 
   /* record stems configuration in `best of' history */
-  static
-  void  optim_record_configuration( AH_Optimizer*  optimizer )
+  static void
+  optim_record_configuration( AH_Optimizer*  optimizer )
   {
     FT_Pos             distortion;
     AH_Configuration*  configs = optimizer->configs;
@@ -671,8 +671,8 @@
 #ifdef AH_BRUTE_FORCE
 
   /* optimize outline in a single direction */
-  static
-  void  optim_compute( AH_Optimizer*  optimizer )
+  static void
+  optim_compute( AH_Optimizer*  optimizer )
   {
     int       n;
     FT_Bool   moved;
@@ -729,8 +729,8 @@
 #else /* AH_BRUTE_FORCE */
 
   /* optimize outline in a single direction */
-  static
-  void  optim_compute( AH_Optimizer*  optimizer )
+  static void
+  optim_compute( AH_Optimizer*  optimizer )
   {
     int  n, counter, counter2;
 
@@ -788,7 +788,8 @@
 
 
   /* releases the optimization data */
-  void AH_Optimizer_Done( AH_Optimizer*  optimizer )
+  void
+  AH_Optimizer_Done( AH_Optimizer*  optimizer )
   {
     if ( optimizer )
     {
@@ -805,9 +806,10 @@
 
 
   /* loads the outline into the optimizer */
-  int  AH_Optimizer_Init( AH_Optimizer*  optimizer,
-                          AH_Outline*    outline,
-                          FT_Memory      memory )
+  int
+  AH_Optimizer_Init( AH_Optimizer*  optimizer,
+                     AH_Outline*    outline,
+                     FT_Memory      memory )
   {
     FT_Error  error;
 
@@ -851,7 +853,8 @@
 
 
   /* compute optimal outline */
-  void  AH_Optimizer_Compute( AH_Optimizer*  optimizer )
+  void
+  AH_Optimizer_Compute( AH_Optimizer*  optimizer )
   {
     optimizer->num_stems   = optimizer->num_hstems;
     optimizer->stems       = optimizer->horz_stems;
diff --git a/src/autohint/ahoptim.h b/src/autohint/ahoptim.h
index 29b9c38c9..610522f48 100644
--- a/src/autohint/ahoptim.h
+++ b/src/autohint/ahoptim.h
@@ -113,17 +113,20 @@ FT_BEGIN_HEADER
 
 
   /* loads the outline into the optimizer */
-  int  AH_Optimizer_Init( AH_Optimizer*  optimizer,
-                          AH_Outline*    outline,
-                          FT_Memory      memory );
+  int
+  AH_Optimizer_Init( AH_Optimizer*  optimizer,
+                     AH_Outline*    outline,
+                     FT_Memory      memory );
 
 
   /* compute optimal outline */
-  void  AH_Optimizer_Compute( AH_Optimizer*  optimizer );
+  void
+  AH_Optimizer_Compute( AH_Optimizer*  optimizer );
 
 
   /* release the optimization data */
-  void AH_Optimizer_Done( AH_Optimizer*  optimizer );
+  void
+  AH_Optimizer_Done( AH_Optimizer*  optimizer );
 
 
 FT_END_HEADER
diff --git a/src/autohint/ahtypes.h b/src/autohint/ahtypes.h
index 11b7519f7..5ef6a895a 100644
--- a/src/autohint/ahtypes.h
+++ b/src/autohint/ahtypes.h
@@ -413,7 +413,7 @@ FT_BEGIN_HEADER
   /*                                                                       */
   /*    blue_shoots :: The overshoot positions of blue zones.              */
   /*                                                                       */
-  typedef struct AH_Globals_
+  typedef struct  AH_Globals_
   {
     FT_Int    num_widths;
     FT_Int    num_heights;