kc3-lang/freetype

diff --git a/builds/ansi/ansi.mk b/builds/ansi/ansi.mk
index 4c9266e..d326f83 100644
--- a/builds/ansi/ansi.mk
+++ b/builds/ansi/ansi.mk
@@ -44,15 +44,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := o
+O  := o
+SO := o
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := a
+A  := a
+SA := a
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
@@ -119,7 +121,7 @@ ifdef BUILD_FREETYPE
 
   # This final rule is used to link all object files into a single library.
   # It is part of the system-specific sub-Makefile because not all
-  # librarians accept a simple syntax like:
+  # librarians accept a simple syntax like
   #
   #   librarian library_file {list of object files}
   #
diff --git a/builds/dos/dos-gcc.mk b/builds/dos/dos-gcc.mk
index 0599e57..b9f55a2 100644
--- a/builds/dos/dos-gcc.mk
+++ b/builds/dos/dos-gcc.mk
@@ -36,7 +36,7 @@ PLATFORM := dos
 OBJ_DIR := obj
 
 
-# The directory where all library files are placed
+# The directory where all library files are placed.
 #
 # By default, this is the same as $(OBJ_DIR), however, this can be changed
 # to suit particular needs.
@@ -44,15 +44,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := o
+O  := o
+SO := o
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := a
+A  := a
+SA := a
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
@@ -121,7 +123,7 @@ ifdef BUILD_FREETYPE
   # It is part of the system-specific sub-Makefile because not all
   # librarians accept a simple syntax like:
   #
-  #    librarian library_file {list of object files}
+  #   librarian library_file {list of object files}
   #
   $(FT_LIBRARY): $(OBJECTS_LIST)
 	  -$(DELETE) $@
diff --git a/builds/os2/os2-dev.mk b/builds/os2/os2-dev.mk
index fcd80b1..93939d2 100644
--- a/builds/os2/os2-dev.mk
+++ b/builds/os2/os2-dev.mk
@@ -47,15 +47,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := o
+O  := o
+SO := o
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := a
+A  := a
+SA := a
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
@@ -127,7 +129,7 @@ ifdef BUILD_FREETYPE
   #   librarian library_file {list of object files} 
   #
   $(FT_LIBRARY): $(OBJECTS_LIST)
-	  -$(DELETE) $@
+	  -$(DELETE) $(subst $(SEP),$(HOSTSEP),$(FT_LIBRARY)) 2> nul
 	  $(FT_LIBRARIAN) $@ $(OBJECTS_LIST)
 
 endif
diff --git a/builds/os2/os2-gcc.mk b/builds/os2/os2-gcc.mk
index 38c1322..14992e6 100644
--- a/builds/os2/os2-gcc.mk
+++ b/builds/os2/os2-gcc.mk
@@ -45,15 +45,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := o
+O  := o
+SO := o
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := a
+A  := a
+SA := a
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
diff --git a/builds/unix/unix.in b/builds/unix/unix.in
index 9b874c2..a35153e 100644
--- a/builds/unix/unix.in
+++ b/builds/unix/unix.in
@@ -61,15 +61,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := lo
+O  := lo
+SO := o
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := la
+A  := la
+SA := a
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
@@ -141,7 +143,8 @@ ifdef BUILD_FREETYPE
   #
   clean_freetype_unix:
 	  -$(DELETE) $(BASE_OBJECTS) $(OBJ_M) $(OBJ_S)
-	  -$(DELETE) $(OBJ_DIR)/*.o $(CLEAN)
+	  -$(DELETE) $(subst $O,$(SO),$(BASE_OBJECTS) $(OBJ_M) $(OBJ_S))
+	  -$(DELETE) $(CLEAN)
 
   distclean_freetype_unix: clean_freetype_unix
 	  -$(DELETE) $(FT_LIBRARY)
@@ -149,14 +152,14 @@ ifdef BUILD_FREETYPE
 	  -$(DELDIR) $(OBJ_DIR)/.libs
 	  -$(DELETE) *.orig *~ core *.core $(DISTCLEAN)
 
-  # Librarian to use to build the static library
+  # Librarian to use to build the library
   #
   FT_LIBRARIAN := $(BUILD)/libtool --mode=link $(CCraw)
 
 
   # This final rule is used to link all object files into a single library.
   # It is part of the system-specific sub-Makefile because not all
-  # librarians accept a simple syntax like:
+  # librarians accept a simple syntax like
   #
   #   librarian library_file {list of object files}
   #
diff --git a/builds/unix/unix.mk b/builds/unix/unix.mk
index 7995709..792a9d7 100644
--- a/builds/unix/unix.mk
+++ b/builds/unix/unix.mk
@@ -61,15 +61,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := lo
+O  := lo
+SO := o
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := la
+A  := la
+SA := a
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
@@ -108,9 +110,7 @@ T := -o # Don't remove this comment line!  We need the space after `-o'.
 #   Use the ANSIFLAGS variable to define the compiler flags used to enfore
 #   ANSI compliance.
 #
-ifndef CFLAGS
-  CFLAGS := -c -g -O2 -Wall
-endif
+CFLAGS := -c -Wall -g -O2
 
 # ANSIFLAGS: Put there the flags used to make your compiler ANSI-compliant.
 #
@@ -119,7 +119,13 @@ ANSIFLAGS := -pedantic -ansi
 # C compiler to use -- we use libtool!
 #
 #
-CC := $(BUILD)/libtool --mode=compile $(CC)
+CCraw := $(CC)
+CC    := $(BUILD)/libtool --mode=compile $(CCraw)
+
+# linker flags
+#
+LDFLAGS := 
+
 
 ifdef BUILD_FREETYPE
 
@@ -137,7 +143,8 @@ ifdef BUILD_FREETYPE
   #
   clean_freetype_unix:
 	  -$(DELETE) $(BASE_OBJECTS) $(OBJ_M) $(OBJ_S)
-	  -$(DELETE) $(OBJ_DIR)/*.o $(CLEAN)
+	  -$(DELETE) $(subst $O,$(SO),$(BASE_OBJECTS) $(OBJ_M) $(OBJ_S))
+	  -$(DELETE) $(CLEAN)
 
   distclean_freetype_unix: clean_freetype_unix
 	  -$(DELETE) $(FT_LIBRARY)
@@ -145,14 +152,14 @@ ifdef BUILD_FREETYPE
 	  -$(DELDIR) $(OBJ_DIR)/.libs
 	  -$(DELETE) *.orig *~ core *.core $(DISTCLEAN)
 
-  # Librarian to use to build the static library
+  # Librarian to use to build the library
   #
-  FT_LIBRARIAN := $(BUILD)/libtool --mode=link $(CC)
+  FT_LIBRARIAN := $(BUILD)/libtool --mode=link $(CCraw)
 
 
   # This final rule is used to link all object files into a single library.
   # It is part of the system-specific sub-Makefile because not all
-  # librarians accept a simple syntax like:
+  # librarians accept a simple syntax like
   #
   #   librarian library_file {list of object files}
   #
diff --git a/builds/win32/w32-dev.mk b/builds/win32/w32-dev.mk
index 438e7f6..8eea55a 100644
--- a/builds/win32/w32-dev.mk
+++ b/builds/win32/w32-dev.mk
@@ -14,7 +14,7 @@
 # indicate that you have read the license and understand and accept it
 # fully.
 #
-# NOTE: This version requires that GNU Make be invoked from the Windows
+# NOTE: This version requires that GNU Make is invoked from the Windows
 #       Shell (_not_ Cygwin BASH)!
 #
 
@@ -50,15 +50,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := o
+O  := o
+SO := o
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := a
+A  := a
+SA := a
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
diff --git a/builds/win32/w32-gcc.mk b/builds/win32/w32-gcc.mk
index 6357098..3501a79 100644
--- a/builds/win32/w32-gcc.mk
+++ b/builds/win32/w32-gcc.mk
@@ -12,7 +12,7 @@
 # indicate that you have read the license and understand and accept it
 # fully.
 #
-# NOTE: This version requires that GNU Make be invoked from the Windows
+# NOTE: This version requires that GNU Make is invoked from the Windows
 #       Shell (_not_ Cygwin BASH)!
 #
 
@@ -48,15 +48,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := o
+O  := o
+SO := o
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := a
+A  := a
+SA := a
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
diff --git a/builds/win32/w32-icc.mk b/builds/win32/w32-icc.mk
index 2f66279..504579e 100644
--- a/builds/win32/w32-icc.mk
+++ b/builds/win32/w32-icc.mk
@@ -1,20 +1,17 @@
-#*******************************************************************
-#*
-#*  FreeType 2 Configuration rules for Win32 + IBM Visual Age C++
-#*
-#*  Copyright 1996-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.
-#*
-#*  Please read the file "freetype/docs/config.txt" to understand
-#*  what this file does..
-#*
-#*******************************************************************
+#
+# FreeType 2 Configuration rules for Win32 + IBM Visual Age C++
+#
+
+
+# Copyright 1996-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.
+#
 
 DELETE   := del
 SEP      := $(strip \ )
@@ -23,105 +20,103 @@ BUILD    := $(TOP)$(SEP)config$(SEP)win32
 PLATFORM := win32
 CC       := icc
 
-# the directory where all object files are placed
+# The directory where all object files are placed.
 #
-# Note that this is not $(TOP)/obj !!
-# This lets you build the library in your own directory
-# with something like :
-#
-#  set TOP=....../path/to/freetype2/top/dir...
-#  mkdir obj
-#  make -f %TOP%/Makefile setup  [options]
-#  make -f %TOP%/Makefile
+# Note that this is not $(TOP)/obj!
+# This lets you build the library in your own directory with something like
 #
+#   set TOP=.../path/to/freetype2/top/dir...
+#   mkdir obj
+#   make -f %TOP%/Makefile setup [options]
+#   make -f %TOP%/Makefile
 #
 OBJ_DIR := obj
 
 
-# the directory where all library files are placed
+# The directory where all library files are placed.
 #
-#  by default, this is the same as OBJ_DIR, however, this can be
-#  changed to suit particular needs..
+# By default, this is the same as $(OBJ_DIR), however, this can be changed
+# to suit particular needs.
 #
 LIB_DIR := $(OBJ_DIR)
 
 
-# the object file extension, this can be .o, .tco, .obj, etc..
-# depending on the platform
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := obj
+O  := obj
+SO := obj
 
-# the library file extension, this can be .a, .lib, etc..
-# depending on the platform
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := lib
+A  := lib
+SA := lib
 
 
-# The name of the final library file.
-# Note that the DOS-specific Makefile uses a shorter (8.3) name
+# The name of the final library file.  Note that the DOS-specific Makefile
+# uses a shorter (8.3) name.
 #
 LIBRARY := freetype
 
 
-# path inclusion flag.
-#
-#  Some compilers use a different flag than '-I' to specify an
-#  additional include path. Examples are "/i=" or "-J", etc...
+# Path inclusion flag.  Some compilers use a different flag than `-I' to
+# specify an additional include path.  Examples are `/i=' or `-J'.
 #
 I := /I
 
 
-# The link flag used to specify a given library file on link.
-# Note that this is only used to compile the demo programs, not
-# the library itself.
+# C flag used to define a macro before the compilation of a given source
+# object.  Usually is `-D' like in `-DDEBUG'.
 #
-L := /Fl
+D := /D
 
 
-# C flag used to define a macro before the compilation of a given
-# source object. Usually is '-D' like in "-DDEBUG"
+# The link flag used to specify a given library file on link.  Note that
+# this is only used to compile the demo programs, not the library itself.
 #
-D := /D
+L := /Fl
 
-# Target flag - LCC uses "-Fo" instead of "-o ", what a broken compiler
-#
+
+# Target flag.
 #
 T := /Fo
 
+
 # C flags
 #
-#   These should concern :
-#
-#     - debug output
-#     - optimization
-#     - warnings
-#     - ansi compliance..
+#   These should concern: debug output, optimization & warnings.
 #
 ifndef CFLAGS
-CFLAGS := /Q- /Gd+ /O2 /G5 /W3 /C
+  CFLAGS := /Q- /Gd+ /O2 /G5 /W3 /C
 endif
 
-# ANSI_FLAGS : put there the flags used to make your compiler ANSI-compliant
-#              nothing (if it already is by default like LCC).
+# ANSIFLAGS: Put there the flags used to make your compiler ANSI-compliant.
 #
 ANSI_FLAGS := /Sa
 
-ifdef BUILD_FREETYPE
 
-include $(TOP)/builds/freetype.mk
+ifdef BUILD_FREETYPE
 
-clean_freetype: clean_freetype_dos
-distclean_freetype: distclean_freetype_dos
-
-# This final rule is used to link all object files into a single
-# library. It is part of the system-specific sub-Makefile because not
-# all librarians accept a simple syntax like :
-#
-#    librarian library_file {list of object files} 
-#
-$(FT_LIBRARY): $(OBJECTS_LIST)
-	lib /nologo /out:$@ $(OBJECTS_LIST)
+  # Now include the main sub-makefile.  It contains all the rules used to
+  # build the library with the previous variables defined.
+  #
+  include $(TOP)/builds/freetype.mk
+
+  # The cleanup targets.
+  #
+  clean_freetype: clean_freetype_dos
+  distclean_freetype: distclean_freetype_dos
+
+  # This final rule is used to link all object files into a single library. 
+  # It is part of the system-specific sub-Makefile because not all
+  # librarians accept a simple syntax like
+  #
+  #   librarian library_file {list of object files} 
+  #
+  $(FT_LIBRARY): $(OBJECTS_LIST)
+	  lib /nologo /out:$@ $(OBJECTS_LIST)
 
 endif
 
-
+# EOF
diff --git a/builds/win32/w32-lcc.mk b/builds/win32/w32-lcc.mk
index 601348d..476de14 100644
--- a/builds/win32/w32-lcc.mk
+++ b/builds/win32/w32-lcc.mk
@@ -12,6 +12,7 @@
 # indicate that you have read the license and understand and accept it
 # fully.
 
+
 ifndef TOP
   TOP := .
 endif
@@ -44,15 +45,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := obj
+O  := obj
+SO := obj
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := lib
+A  := lib
+SA := lib
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
diff --git a/builds/win32/w32-vcc.mk b/builds/win32/w32-vcc.mk
index 4c5442f..d28d710 100644
--- a/builds/win32/w32-vcc.mk
+++ b/builds/win32/w32-vcc.mk
@@ -12,6 +12,7 @@
 # indicate that you have read the license and understand and accept it
 # fully.
 
+
 ifndef TOP
   TOP := .
 endif
@@ -44,15 +45,17 @@ OBJ_DIR := obj
 LIB_DIR := $(OBJ_DIR)
 
 
-# The object file extension.  This can be .o, .tco, .obj, etc., depending on
-# the platform.
+# The object file extension (for standard and static libraries).  This can be
+# .o, .tco, .obj, etc., depending on the platform.
 #
-O := obj
+O  := obj
+SO := ojc
 
-# The library file extension.  This can be .a, .lib, etc., depending on the
-# platform.
+# The library file extension (for standard and static libraries).  This can
+# be .a, .lib, etc., depending on the platform.
 #
-A := lib
+A  := lib
+SA := lib
 
 
 # The name of the final library file.  Note that the DOS-specific Makefile
diff --git a/src/autohint/ahangles.c b/src/autohint/ahangles.c
index 7b202f6..2f759ed 100644
--- a/src/autohint/ahangles.c
+++ b/src/autohint/ahangles.c
@@ -3,7 +3,7 @@
 /*  ahangles.h                                                             */
 /*                                                                         */
 /*    A routine used to compute vector angles with limited accuracy        */
-/*    and very high speed.                                                 */
+/*    and very high speed (body).                                          */
 /*                                                                         */
 /*  Copyright 2000 Catharon Productions Inc.                               */
 /*  Author: David Turner                                                   */
diff --git a/src/autohint/ahangles.h b/src/autohint/ahangles.h
index cb37f6c..d88d02a 100644
--- a/src/autohint/ahangles.h
+++ b/src/autohint/ahangles.h
@@ -3,7 +3,7 @@
 /*  ahangles.h                                                             */
 /*                                                                         */
 /*    A routine used to compute vector angles with limited accuracy        */
-/*    and very high speed.                                                 */
+/*    and very high speed (specification).                                 */
 /*                                                                         */
 /*  Copyright 2000 Catharon Productions Inc.                               */
 /*  Author: David Turner                                                   */
diff --git a/src/autohint/ahglobal.c b/src/autohint/ahglobal.c
index b0cc00a..999fc16 100644
--- a/src/autohint/ahglobal.c
+++ b/src/autohint/ahglobal.c
@@ -2,7 +2,7 @@
 /*                                                                         */
 /*  ahglobal.c                                                             */
 /*                                                                         */
-/*    Routines used to compute global metrics automatically.               */
+/*    Routines used to compute global metrics automatically (body).        */
 /*                                                                         */
 /*  Copyright 2000 Catharon Productions Inc.                               */
 /*  Author: David Turner                                                   */
diff --git a/src/autohint/ahglobal.h b/src/autohint/ahglobal.h
index 3126d58..43e3c01 100644
--- a/src/autohint/ahglobal.h
+++ b/src/autohint/ahglobal.h
@@ -2,7 +2,8 @@
 /*                                                                         */
 /*  ahglobal.h                                                             */
 /*                                                                         */
-/*    Routines used to compute global metrics automatically.               */
+/*    Routines used to compute global metrics automatically                */
+/*    (specification).                                                     */
 /*                                                                         */
 /*  Copyright 2000 Catharon Productions Inc.                               */
 /*  Author: David Turner                                                   */
diff --git a/src/autohint/ahglyph.c b/src/autohint/ahglyph.c
index 428b607..1dcf3fb 100644
--- a/src/autohint/ahglyph.c
+++ b/src/autohint/ahglyph.c
@@ -2,9 +2,10 @@
 /*                                                                         */
 /*  ahglyph.c                                                              */
 /*                                                                         */
-/*    routines used to load and analyze a given glyph before hinting       */
+/*    Routines used to load and analyze a given glyph before hinting       */
+/*    (body).                                                              */
 /*                                                                         */
-/*  Copyright 2000: Catharon Productions Inc.                              */
+/*  Copyright 2000 Catharon Productions Inc.                               */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -14,115 +15,117 @@
 /*  this file you indicate that you have read the license and              */
 /*  understand and accept it fully.                                        */
 /*                                                                         */
-/*  Note that this license is compatible with the FreeType license         */
+/*  Note that this license is compatible with the FreeType license.        */
 /*                                                                         */
 /***************************************************************************/
 
+
 #ifdef FT_FLAT_COMPILE
+
 #include "ahglyph.h"
 #include "ahangles.h"
 #include "ahglobal.h"
+
 #else
+
 #include <autohint/ahglyph.h>
 #include <autohint/ahangles.h>
 #include <autohint/ahglobal.h>
+
 #endif
 
+
 #include <stdio.h>
 
+
 #define xxxAH_DEBUG_GLYPH
 
- /* compute the direction value of a given vector.. */
+
+  /* compute the direction value of a given vector.. */
   static
-  AH_Direction  ah_compute_direction( FT_Pos  dx, FT_Pos  dy )
+  AH_Direction  ah_compute_direction( FT_Pos  dx,
+                                      FT_Pos  dy )
   {
     AH_Direction  dir;
-    FT_Pos        ax = ABS(dx);
-    FT_Pos        ay = ABS(dy);
+    FT_Pos        ax = ABS( dx );
+    FT_Pos        ay = ABS( dy );
+
 
     dir = ah_dir_none;
 
     /* test for vertical direction */
-    if ( ax*12 < ay )
+    if ( ax * 12 < ay )
     {
-      dir = ( dy > 0 ? ah_dir_up : ah_dir_down );
+      dir = dy > 0 ? ah_dir_up : ah_dir_down;
     }
     /* test for horizontal direction */
-    else if ( ay*12 < ax )
+    else if ( ay * 12 < ax )
     {
-      dir = ( dx > 0 ? ah_dir_right : ah_dir_left );
+      dir = dx > 0 ? ah_dir_right : ah_dir_left;
     }
 
     return dir;
   }
 
- /************************************************************************
-  *
-  * <Function>
-  *    ah_outline_new
-  *
-  * <Description>
-  *    Create a new empty AH_Outline
-  *
-  ************************************************************************/
 
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_new                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new and empty AH_Outline object.                         */
+  /*                                                                       */
   LOCAL_FUNC
-  FT_Error  ah_outline_new( FT_Memory    memory,
-                            AH_Outline* *aoutline )
+  FT_Error  ah_outline_new( FT_Memory     memory,
+                            AH_Outline**  aoutline )
   {
     FT_Error     error;
     AH_Outline*  outline;
 
-    if ( !ALLOC( outline, sizeof(*outline) ) )
+
+    if ( !ALLOC( outline, sizeof ( *outline ) ) )
     {
       outline->memory = memory;
       *aoutline = outline;
     }
+
     return error;
   }
 
 
- /************************************************************************
-  *
-  * <Function>
-  *    ah_outline_done
-  *
-  * <Description>
-  *    Destroys a given AH_Outline
-  *
-  ************************************************************************/
-
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_done                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a given AH_Outline object.                                */
+  /*                                                                       */
   LOCAL_FUNC
   void  ah_outline_done( AH_Outline*  outline )
   {
     FT_Memory memory = outline->memory;
 
+
     FREE( outline->horz_edges );
     FREE( outline->horz_segments );
     FREE( outline->contours );
     FREE( outline->points );
-    outline->vert_edges    = 0;
-    outline->vert_segments = 0;
 
-    outline->num_points   = 0;
-    outline->max_points   = 0;
-    outline->num_contours = 0;
-    outline->max_contours = 0;
     FREE( outline );
   }
 
 
-
- /************************************************************************
-  *
-  * <Function>
-  *    ah_outline_save
-  *
-  * <Description>
-  *    Save the content of a given AH_Outline into a face's glyph slot
-  *
-  ************************************************************************/
-
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_save                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Saves the content of a given AH_Outline object into a face's glyph */
+  /*    slot.                                                              */
+  /*                                                                       */
   LOCAL_FUNC
   void  ah_outline_save( AH_Outline*  outline,
                          AH_Loader*   gloader )
@@ -132,15 +135,16 @@
     FT_Vector*  vec   = gloader->current.outline.points;
     char*       tag   = gloader->current.outline.tags;
 
+
     /* we assume that the glyph loader has already been checked for storage */
     for ( ; point < limit; point++, vec++, tag++ )
     {
       vec->x = point->x;
       vec->y = point->y;
 
-      if (point->flags & ah_flah_conic)
+      if ( point->flags & ah_flah_conic )
         tag[0] = FT_Curve_Tag_Conic;
-      else if (point->flags & ah_flah_cubic)
+      else if ( point->flags & ah_flah_cubic )
         tag[0] = FT_Curve_Tag_Cubic;
       else
         tag[0] = FT_Curve_Tag_On;
@@ -148,16 +152,15 @@
   }
 
 
- /************************************************************************
-  *
-  * <Function>
-  *    ah_outline_load
-  *
-  * <Description>
-  *    Loads an unscaled outline from a glyph slot into an AH_Outline
-  *
-  ************************************************************************/
-
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_load                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads an unscaled outline from a glyph slot into an AH_Outline     */
+  /*    object.                                                            */
+  /*                                                                       */
   LOCAL_FUNC
   FT_Error  ah_outline_load( AH_Outline*  outline,
                              FT_Face      face )
@@ -169,15 +172,18 @@
     FT_Int      num_contours = source->n_contours;
     AH_Point*   points;
 
+
     /* check arguments */
-    if (!face || !face->size || face->glyph->format != ft_glyph_format_outline)
+    if ( !face                                          ||
+         !face->size                                    ||
+         face->glyph->format != ft_glyph_format_outline )
       return FT_Err_Invalid_Argument;
 
-
-    /* first of all, realloc the contours array if necessary */
+    /* first of all, reallocate the contours array if necessary */
     if ( num_contours > outline->max_contours )
     {
-      FT_Int  new_contours = (num_contours+3) & -4;
+      FT_Int  new_contours = ( num_contours + 3 ) & -4;
+
 
       if ( REALLOC_ARRAY( outline->contours, outline->max_contours,
                           new_contours, AH_Point* ) )
@@ -189,17 +195,18 @@
     /* then, realloc the points, segments & edges arrays if needed */
     if ( num_points > outline->max_points )
     {
-      FT_Int  news = (num_points+7) & -8;
+      FT_Int  news = ( num_points + 7 ) & -8;
       FT_Int  max  = outline->max_points;
 
+
       if ( REALLOC_ARRAY( outline->points, max, news, AH_Point )          ||
-           REALLOC_ARRAY( outline->horz_edges,  max, news, AH_Edge )      ||
+           REALLOC_ARRAY( outline->horz_edges, max, news, AH_Edge )       ||
            REALLOC_ARRAY( outline->horz_segments, max, news, AH_Segment ) )
         goto Exit;
 
       /* readjust some pointers */
-      outline->vert_edges    = outline->horz_edges + (news >> 1);
-      outline->vert_segments = outline->horz_segments + (news >> 1);
+      outline->vert_edges    = outline->horz_edges + ( news >> 1 );
+      outline->vert_segments = outline->horz_segments + ( news >> 1 );
       outline->max_points    = news;
     }
 
@@ -211,19 +218,17 @@
     outline->num_hsegments = 0;
     outline->num_vsegments = 0;
 
-    /* compute the vertical and horizontal major directions, this is     */
-    /* currently done by inspecting the 'ft_outline_reverse_fill' flag   */
+    /* Compute the vertical and horizontal major directions; this is     */
+    /* currently done by inspecting the `ft_outline_reverse_fill' flag.  */
     /* However, some fonts have improper glyphs, and it'd be a good idea */
-    /* to be able to re-compute these values on the fly..                */
-    {
-      outline->vert_major_dir = ah_dir_up;
-      outline->horz_major_dir = ah_dir_left;
+    /* to be able to re-compute these values on the fly.                 */
+    outline->vert_major_dir = ah_dir_up;
+    outline->horz_major_dir = ah_dir_left;
 
-      if (source->flags & ft_outline_reverse_fill)
-      {
-        outline->vert_major_dir = ah_dir_down;
-        outline->horz_major_dir = ah_dir_right;
-      }
+    if ( source->flags & ft_outline_reverse_fill )
+    {
+      outline->vert_major_dir = ah_dir_down;
+      outline->horz_major_dir = ah_dir_right;
     }
 
     outline->x_scale = face->size->metrics.x_scale;
@@ -232,48 +237,56 @@
     points = outline->points;
 
     {
-      /* do one thing at a time - it is easier to understand, and */
-      /* the code is clearer..                                    */
+      /* do one thing at a time -- it is easier to understand, and */
+      /* the code is clearer                                       */
       AH_Point*  point = points;
       AH_Point*  limit = point + outline->num_points;
 
+
       /* compute coordinates */
       {
         FT_Vector*  vec     = source->points;
         FT_Fixed    x_scale = outline->x_scale;
         FT_Fixed    y_scale = outline->y_scale;
 
+
         for (; point < limit; vec++, point++ )
         {
           point->fx = vec->x;
           point->fy = vec->y;
           point->ox = point->x = FT_MulFix( vec->x, x_scale );
           point->oy = point->y = FT_MulFix( vec->y, y_scale );
+
           point->flags = 0;
         }
       }
 
-      /* compute bezier flags */
+      /* compute Bezier flags */
       {
         char*  tag = source->tags;
+
+
         for ( point = points; point < limit; point++, tag++ )
         {
           switch ( FT_CURVE_TAG( *tag ) )
           {
-            case FT_Curve_Tag_Conic: point->flags = ah_flah_conic; break;
-            case FT_Curve_Tag_Cubic: point->flags = ah_flah_cubic; break;
-            default:
-              ;
+          case FT_Curve_Tag_Conic:
+            point->flags = ah_flah_conic; break;
+          case FT_Curve_Tag_Cubic:
+            point->flags = ah_flah_cubic; break;
+          default:
+            ;
           }
         }
       }
 
-      /* compute "next" and "prev" */
+      /* compute `next' and `prev' */
       {
-        FT_Int    contour_index;
-        AH_Point* prev;
-        AH_Point* first;
-        AH_Point* end;
+        FT_Int     contour_index;
+        AH_Point*  prev;
+        AH_Point*  first;
+        AH_Point*  end;
+
 
         contour_index = 0;
 
@@ -284,33 +297,34 @@
         for ( point = points; point < limit; point++ )
         {
           point->prev = prev;
-          if (point < end)
+          if ( point < end )
           {
-            point->next = point+1;
+            point->next = point + 1;
             prev        = point;
           }
           else
           {
             point->next = first;
             contour_index++;
-	    if (point+1 < limit)
-	    {
+            if ( point + 1 < limit )
+            {
               end   = points + source->contours[contour_index];
-              first = point+1;
+              first = point + 1;
               prev  = end;
-	    }
+            }
           }
         }
       }
 
       /* set-up the contours array */
       {
-        AH_Point** contour  = outline->contours;
-        AH_Point** limit    = contour + outline->num_contours;
-        short*     end      = source->contours;
-        short      index    = 0;
+        AH_Point**  contour  = outline->contours;
+        AH_Point**  limit    = contour + outline->num_contours;
+        short*      end      = source->contours;
+        short       index    = 0;
 
-        for (; contour < limit; contour++, end++ )
+
+        for ( ; contour < limit; contour++, end++ )
         {
           contour[0] = points + index;
           index      = end[0] + 1;
@@ -325,48 +339,55 @@
           AH_Point*  next;
           FT_Vector  vec;
 
+
           prev  = point->prev;
           vec.x = point->fx - prev->fx;
           vec.y = point->fy - prev->fy;
-          point->in_dir   = ah_compute_direction( vec.x, vec.y );
+
+          point->in_dir = ah_compute_direction( vec.x, vec.y );
 
 #ifndef AH_OPTION_NO_WEAK_INTERPOLATION
           point->in_angle = ah_angle( &vec );
 #endif
+
           next  = point->next;
           vec.x = next->fx - point->fx;
           vec.y = next->fy - point->fy;
-          point->out_dir   = ah_compute_direction( vec.x, vec.y );
+
+          point->out_dir = ah_compute_direction( vec.x, vec.y );
 
 #ifndef AH_OPTION_NO_WEAK_INTERPOLATION
           point->out_angle = ah_angle( &vec );
 
           {
             AH_Angle  delta = point->in_angle - point->out_angle;
-            if (delta < 0) delta = -delta;
 
-            if (delta < 2)
+
+            if ( delta < 0 )
+              delta = -delta;
+            if ( delta < 2 )
               point->flags |= ah_flah_weak_interpolation;
           }
 
-          /*
-          if (point->flags & (ah_flah_conic|ah_flah_cubic))
+#if 0
+          if ( point->flags & ( ah_flah_conic | ah_flah_cubic ) )
             point->flags |= ah_flah_weak_interpolation;
-          */
 #endif
 
+#endif /* !AH_OPTION_NO_WEAK_INTERPOLATION */
+
 #ifdef AH_OPTION_NO_STRONG_INTERPOLATION
           point->flags |= ah_flah_weak_interpolation;
 #endif
         }
       }
     }
+
   Exit:
     return error;
   }
 
 
-
   LOCAL_FUNC
   void  ah_setup_uv( AH_Outline*  outline,
                      AH_UV        source )
@@ -374,20 +395,46 @@
     AH_Point*  point = outline->points;
     AH_Point*  limit = point + outline->num_points;
 
+
     for ( ; point < limit; point++ )
     {
       FT_Pos  u, v;
 
-      switch (source)
+
+      switch ( source )
       {
-        case ah_uv_fxy:  u = point->fx; v = point->fy; break;
-        case ah_uv_fyx:  u = point->fy; v = point->fx; break;
-        case ah_uv_oxy:  u = point->ox; v = point->oy; break;
-        case ah_uv_oyx:  u = point->oy; v = point->ox; break;
-        case ah_uv_yx:   u = point->y;  v = point->x;  break;
-        case ah_uv_ox:   u = point->x;  v = point->ox; break;
-        case ah_uv_oy:   u = point->y;  v = point->oy; break;
-        default: u = point->x;  v = point->y;  break;
+      case ah_uv_fxy:
+        u = point->fx;
+        v = point->fy;
+        break;
+      case ah_uv_fyx:
+        u = point->fy;
+        v = point->fx;
+        break;
+      case ah_uv_oxy:
+        u = point->ox;
+        v = point->oy;
+        break;
+      case ah_uv_oyx:
+        u = point->oy;
+        v = point->ox;
+        break;
+      case ah_uv_yx:
+        u = point->y;
+        v = point->x;
+        break;
+      case ah_uv_ox:
+        u = point->x;
+        v = point->ox;
+        break;
+      case ah_uv_oy:
+        u = point->y;
+        v = point->oy;
+        break;
+      default:
+        u = point->x;
+        v = point->y;
+        break;
       }
       point->u = u;
       point->v = v;
@@ -404,9 +451,10 @@
     AH_Direction  segment_dir;
     AH_Direction  major_dir;
 
+
     segments       = outline->horz_segments;
     p_num_segments = &outline->num_hsegments;
-    major_dir      = ah_dir_right;  /* !!! This value must be positive */
+    major_dir      = ah_dir_right;      /* This value must be positive! */
     segment_dir    = major_dir;
 
     /* set up (u,v) in each point */
@@ -414,17 +462,19 @@
 
     for ( dimension = 1; dimension >= 0; dimension-- )
     {
-      AH_Point**  contour       = outline->contours;
-      AH_Point**  contour_limit = contour + outline->num_contours;
-      AH_Segment* segment       = segments;
-      FT_Int      num_segments  = 0;
+      AH_Point**   contour       = outline->contours;
+      AH_Point**   contour_limit = contour + outline->num_contours;
+      AH_Segment*  segment       = segments;
+      FT_Int       num_segments  = 0;
 
 #ifdef AH_HINT_METRICS
-      AH_Point*  min_point = 0;
-      AH_Point*  max_point = 0;
-      FT_Pos     min_coord = 32000;
-      FT_Pos     max_coord = -32000;
+      AH_Point*    min_point = 0;
+      AH_Point*    max_point = 0;
+      FT_Pos       min_coord = 32000;
+      FT_Pos       max_coord = -32000;
 #endif
+
+
       /* do each contour separately */
       for ( ; contour < contour_limit; contour++ )
       {
@@ -435,31 +485,33 @@
         FT_Pos     max_pos = -32000;  /* maximum segment pos != max_coord */
         FT_Bool    passed;
 
+
 #ifdef AH_HINT_METRICS
-        if (point->u < min_coord)
+        if ( point->u < min_coord )
         {
           min_coord = point->u;
           min_point = point;
         }
-        if (point->u > max_coord)
+        if ( point->u > max_coord )
         {
           max_coord = point->u;
           max_point = point;
         }
 #endif
 
-        if (point == last)  /* skip singletons - just in case ?? */
+        if ( point == last )  /* skip singletons -- just in case? */
           continue;
 
-        if ( ABS(last->out_dir)  == major_dir &&
-             ABS(point->out_dir) == major_dir)
+        if ( ABS( last->out_dir )  == major_dir &&
+             ABS( point->out_dir ) == major_dir )
         {
           /* we are already on an edge, try to locate its start */
-          last  = point;
+          last = point;
+
           for (;;)
           {
             point = point->prev;
-            if ( ABS(point->out_dir) != major_dir )
+            if ( ABS( point->out_dir ) != major_dir )
             {
               point = point->next;
               break;
@@ -472,32 +524,41 @@
 
         last   = point;
         passed = 0;
+
         for (;;)
         {
           FT_Pos  u, v;
 
-          if (on_edge)
+
+          if ( on_edge )
           {
             u = point->u;
-            if ( u < min_pos ) min_pos = u;
-            if ( u > max_pos ) max_pos = u;
+            if ( u < min_pos )
+              min_pos = u;
+            if ( u > max_pos )
+              max_pos = u;
 
-            if ( point->out_dir != segment_dir || point == last)
+            if ( point->out_dir != segment_dir || point == last )
             {
-              /* we're just leaving an edge, record a new segment !! */
+              /* we are just leaving an edge; record a new segment! */
               segment->last = point;
-              segment->pos  = (min_pos + max_pos) >> 1;
+              segment->pos  = ( min_pos + max_pos ) >> 1;
 
               /* a segment is round if either its first or last point */
-              /* is a control point..                                 */
-              if ( (segment->first->flags | point->flags) & ah_flah_control )
+              /* is a control point                                   */
+              if ( ( segment->first->flags | point->flags ) &
+                   ah_flah_control                          )
                 segment->flags |= ah_edge_round;
 
               /* compute segment size */
-              min_pos  = max_pos = point->v;
+              min_pos = max_pos = point->v;
+
               v = segment->first->v;
-              if (v < min_pos) min_pos = v;
-              if (v > max_pos) max_pos = v;
+              if ( v < min_pos )
+                min_pos = v;
+              if ( v > max_pos )
+                max_pos = v;
+
               segment->min_coord = min_pos;
               segment->max_coord = max_pos;
 
@@ -508,21 +569,21 @@
             }
           }
 
-          /* now exit if we're at the start/end point */
-          if (point == last)
+          /* now exit if we are at the start/end point */
+          if ( point == last )
           {
-            if (passed)
+            if ( passed )
               break;
             passed = 1;
           }
 
-          if ( !on_edge && ABS(point->out_dir) == major_dir )
+          if ( !on_edge && ABS( point->out_dir ) == major_dir )
           {
-            /* this is the start of a new segment ! */
-            segment_dir       = point->out_dir;
+            /* this is the start of a new segment! */
+            segment_dir = point->out_dir;
 
             /* clear all segment fields */
-            memset( segment, 0, sizeof(*segment) );
+            memset( segment, 0, sizeof ( *segment ) );
 
             segment->dir      = segment_dir;
             segment->flags    = ah_edge_normal;
@@ -532,10 +593,10 @@
             segment->contour  = contour;
             on_edge           = 1;
 
-            if (point == max_point)
+            if ( point == max_point )
               max_point = 0;
 
-            if (point == min_point)
+            if ( point == min_point )
               min_point = 0;
           }
 
@@ -544,12 +605,11 @@
 
       } /* contours */
 
-
 #ifdef AH_HINT_METRICS
       /* we need to ensure that there are edges on the left-most and  */
-      /* right-most points of the glyph in order to hint the metrics  */
-      /* we do this by inserting fake segments when needed..          */
-      if (dimension == 0)
+      /* right-most points of the glyph in order to hint the metrics; */
+      /* we do this by inserting fake segments when needed            */
+      if ( dimension == 0 )
       {
         AH_Point*  point = outline->points;
         AH_Point*  limit = point + outline->num_points;
@@ -559,11 +619,13 @@
         FT_Pos     min_pos = 32000;
         FT_Pos     max_pos = -32000;
 
+
         /* compute minimum and maximum points */
         for ( ; point < limit; point++ )
         {
           FT_Pos  x = point->fx;
 
+
           if ( x < min_pos )
           {
             min_pos   = x;
@@ -577,10 +639,10 @@
         }
 
         /* insert minimum segment */
-        if (min_point)
+        if ( min_point )
         {
           /* clear all segment fields */
-          memset( segment, 0, sizeof(*segment) );
+          memset( segment, 0, sizeof ( *segment ) );
 
           segment->dir   = segment_dir;
           segment->flags = ah_edge_normal;
@@ -593,10 +655,10 @@
         }
 
         /* insert maximum segment */
-        if (max_point)
+        if ( max_point )
         {
           /* clear all segment fields */
-          memset( segment, 0, sizeof(*segment) );
+          memset( segment, 0, sizeof ( *segment ) );
 
           segment->dir   = segment_dir;
           segment->flags = ah_edge_normal;
@@ -608,8 +670,7 @@
           segment++;
         }
       }
-#endif
-
+#endif /* AH_HINT_METRICS */
 
       *p_num_segments = num_segments;
 
@@ -621,7 +682,6 @@
   }
 
 
-
   LOCAL_FUNC
   void  ah_outline_link_segments( AH_Outline*  outline )
   {
@@ -629,36 +689,41 @@
     AH_Segment*  limit;
     int          dimension;
 
+
     ah_setup_uv( outline, ah_uv_fyx );
 
     segments = outline->horz_segments;
     limit    = segments + outline->num_hsegments;
+
     for ( dimension = 1; dimension >= 0; dimension-- )
     {
       AH_Segment*  seg1;
       AH_Segment*  seg2;
 
+
       /* now compare each segment to the others */
       for ( seg1 = segments; seg1 < limit; seg1++ )
       {
         FT_Pos       best_score   = 32000;
         AH_Segment*  best_segment = 0;
 
-        /* the fake segments are introduced to hint the metrics */
-        /* we must never link them to anything..                */
-        if (seg1->first == seg1->last)
+
+        /* the fake segments are introduced to hint the metrics -- */
+        /* we must never link them to anything                     */
+        if ( seg1->first == seg1->last )
           continue;
 
         for ( seg2 = segments; seg2 < limit; seg2++ )
           if ( seg1 != seg2 && seg1->dir + seg2->dir == 0 )
           {
-            FT_Pos     pos1 = seg1->pos;
-            FT_Pos     pos2 = seg2->pos;
-            FT_Bool    is_dir;
-            FT_Bool    is_pos;
+            FT_Pos   pos1 = seg1->pos;
+            FT_Pos   pos2 = seg2->pos;
+            FT_Bool  is_dir;
+            FT_Bool  is_pos;
+
 
-            /* check that the segments are correctly oriented and positioned */
-            /* to form a black distance..                                    */
+            /* check that the segments are correctly oriented and */
+            /* positioned to form a black distance                */
 
             is_dir = ( seg1->dir == outline->horz_major_dir ||
                        seg1->dir == outline->vert_major_dir );
@@ -667,19 +732,20 @@
             if ( pos1 == pos2 || !(is_dir ^ is_pos) )
               continue;
 
-            /* check the two segments, we now have a better algorithm */
-            /* that doesn't rely on the segment points themselves but */
-            /* on their relative position. This gets rids of many     */
-            /* unpleasant artefacts and incorrect stem/serifs         */
-            /* computations..                                         */
+            /* Check the two segments.  We now have a better algorithm */
+            /* that doesn't rely on the segment points themselves but  */
+            /* on their relative position.  This gets rids of many     */
+            /* unpleasant artefacts and incorrect stem/serifs          */
+            /* computations.                                           */
 
-            /* first of all, compute the size of the "common" height */
+            /* first of all, compute the size of the `common' height */
             {
               FT_Pos  min = seg1->min_coord;
               FT_Pos  max = seg1->max_coord;
               FT_Pos  len, score;
               FT_Pos  size1, size2;
 
+
               size1 = max - min;
               size2 = seg2->max_coord - seg2->min_coord;
 
@@ -691,13 +757,13 @@
 
               len   = max - min;
               score = seg2->pos - seg1->pos;
-              if (score < 0)
+              if ( score < 0 )
                 score = -score;
 
               /* before comparing the scores, take care that the segments */
               /* are really facing each other (often not for italics..)   */
-              if ( 4*len >= size1 && 4*len >= size2 )
-                if (score < best_score)
+              if ( 4 * len >= size1 && 4 * len >= size2 )
+                if ( score < best_score )
                 {
                   best_score   = score;
                   best_segment = seg2;
@@ -705,21 +771,23 @@
             }
           }
 
-        if (best_segment)
+        if ( best_segment )
         {
           seg1->link  = best_segment;
           seg1->score = best_score;
+
           best_segment->num_linked++;
         }
 
 
       } /* edges 1 */
 
-      /* now, compute the "serif" segments */
+      /* now, compute the `serif' segments */
       for ( seg1 = segments; seg1 < limit; seg1++ )
       {
         seg2 = seg1->link;
-        if (seg2 && seg2->link != seg1)
+
+        if ( seg2 && seg2->link != seg1 )
         {
           seg1->link  = 0;
           seg1->serif = seg2->link;
@@ -735,8 +803,8 @@
 
 
 #ifdef AH_DEBUG_GLYPH
+
   /* A function used to dump the array of linked segments */
-  extern
   void  ah_dump_segments( AH_Outline*  outline )
   {
     AH_Segment*  segments;
@@ -744,53 +812,62 @@
     AH_Point*    points;
     FT_Int       dimension;
 
+
     points   = outline->points;
     segments = outline->horz_segments;
     limit    = segments + outline->num_hsegments;
 
-    for (dimension = 1; dimension >= 0; dimension-- )
+    for ( dimension = 1; dimension >= 0; dimension-- )
     {
       AH_Segment*  seg;
 
-      printf ( "Table of %s segments:\n", !dimension ? "vertical" : "horizontal" );
-      printf ( "  [ index |  pos |  dir  | link | serif | numl | first | start ]\n" );
+
+      printf ( "Table of %s segments:\n",
+               !dimension ? "vertical" : "horizontal" );
+      printf ( "  [ index |  pos |  dir  | link | serif |"
+               " numl | first | start ]\n" );
 
       for ( seg = segments; seg < limit; seg++ )
       {
         printf ( "  [ %5d | %4d | %5s | %4d | %5d | %4d | %5d | %5d ]\n",
                  seg - segments,
                  (int)seg->pos,
-                 seg->dir == ah_dir_up ? "up" :
-                 (seg->dir == ah_dir_down ? "down" :
-                  (seg->dir == ah_dir_left ? "left" :
-                   (seg->dir == ah_dir_right ? "right" : "none")
-                  )
-                 ),
+                 seg->dir == ah_dir_up
+                   ? "up"
+                   : ( seg->dir == ah_dir_down
+                         ? "down"
+                         : ( seg->dir == ah_dir_left
+                               ? "left"
+                               : ( seg->dir == ah_dir_right
+                                     ? "right"
+                                     : "none" ) ) ),
                  seg->link ? (seg->link-segments) : -1,
                  seg->serif ? (seg->serif-segments) : -1,
                  (int)seg->num_linked,
                  seg->first - points,
                  seg->last - points );
       }
+
       segments = outline->vert_segments;
       limit    = segments + outline->num_vsegments;
     }
   }
-#endif
 
+#endif /* AH_DEBUG_GLYPH */
 
 
   static
-  void ah_outline_compute_edges( AH_Outline*  outline )
+  void  ah_outline_compute_edges( AH_Outline*  outline )
   {
-    AH_Edge*     edges;
-    AH_Segment*  segments;
-    AH_Segment*  segment_limit;
-    AH_Direction up_dir;
-    FT_Int*      p_num_edges;
-    FT_Int       dimension;
-    FT_Fixed     scale;
-    FT_Pos       edge_distance_threshold;
+    AH_Edge*      edges;
+    AH_Segment*   segments;
+    AH_Segment*   segment_limit;
+    AH_Direction  up_dir;
+    FT_Int*       p_num_edges;
+    FT_Int        dimension;
+    FT_Fixed      scale;
+    FT_Pos        edge_distance_threshold;
+
 
     edges         = outline->horz_edges;
     segments      = outline->horz_segments;
@@ -805,38 +882,43 @@
       AH_Edge*     edge_limit;  /* really == edge + num_edges */
       AH_Segment*  seg;
 
-      /**********************************************************************/
-      /*                                                                    */
-      /* We will begin by generating a sorted table of edges for the        */
-      /* current direction. To do so, we simply scan each segment and       */
-      /* try to find an edge in our table that corresponds to its position  */
-      /*                                                                    */
-      /* If no edge is found, we create and insert a new edge in the        */
-      /* sorted table. Otherwise, we simply add the segment to the          */
-      /* edge's list which will be processed in the second step to          */
-      /* compute the edge's properties..                                    */
-      /*                                                                    */
-      /* Note that the edges table is sorted along the segment/edge         */
-      /* position.                                                          */
-      /*                                                                    */
+
+      /*********************************************************************/
+      /*                                                                   */
+      /* We will begin by generating a sorted table of edges for the       */
+      /* current direction.  To do so, we simply scan each segment and try */
+      /* to find an edge in our table that corresponds to its position.    */
+      /*                                                                   */
+      /* If no edge is found, we create and insert a new edge in the       */
+      /* sorted table.  Otherwise, we simply add the segment to the edge's */
+      /* list which will be processed in the second step to compute the    */
+      /* edge's properties.                                                */
+      /*                                                                   */
+      /* Note that the edges table is sorted along the segment/edge        */
+      /* position.                                                         */
+      /*                                                                   */
+      /*********************************************************************/
 
       edge_distance_threshold = FT_MulFix( outline->edge_distance_threshold,
                                            scale );
-      if (edge_distance_threshold > 64/4)
-        edge_distance_threshold = 64/4;
+      if ( edge_distance_threshold > 64 / 4 )
+        edge_distance_threshold = 64 / 4;
 
       edge_limit = edges;
       for ( seg = segments; seg < segment_limit; seg++ )
       {
         AH_Edge*  found = 0;
 
+
         /* look for an edge corresponding to the segment */
         for ( edge = edges; edge < edge_limit; edge++ )
         {
           FT_Pos  dist;
 
+
           dist = seg->pos - edge->fpos;
-          if (dist < 0) dist = -dist;
+          if ( dist < 0 )
+            dist = -dist;
 
           dist = FT_MulFix( dist, scale );
           if ( dist < edge_distance_threshold )
@@ -846,9 +928,10 @@
           }
         }
 
-        if (!found)
+        if ( !found )
         {
-          /* insert a new edge in the list. Sort according to the position */
+          /* insert a new edge in the list and */
+          /* sort according to the position    */
           while ( edge > edges && edge[-1].fpos > seg->pos )
           {
             edge[0] = edge[-1];
@@ -857,7 +940,7 @@
           edge_limit++;
 
           /* clear all edge fields */
-          memset( edge, 0, sizeof(*edge) );
+          memset( edge, 0, sizeof ( *edge ) );
 
           /* add the segment to the new edge's list */
           edge->first    = seg;
@@ -879,23 +962,24 @@
       *p_num_edges = edge_limit - edges;
 
 
-      /**********************************************************************/
-      /*                                                                    */
-      /* Good, we will now compute each edge's properties according to      */
-      /* segments found on its position. Basically, these are:              */
-      /*                                                                    */
-      /*  - edge's main direction                                           */
-      /*  - stem edge, serif edge or both (which defaults to stem then)     */
-      /*  - rounded edge, straigth or both (which defaults to straight)     */
-      /*  - link for edge..                                                 */
-      /*                                                                    */
-
-      /* first of all, set the "edge" field in each segment - this is */
-      /* required in order to compute edge links..                    */
+      /*********************************************************************/
+      /*                                                                   */
+      /* Good, we will now compute each edge's properties according to     */
+      /* segments found on its position.  Basically, these are:            */
+      /*                                                                   */
+      /*  - edge's main direction                                          */
+      /*  - stem edge, serif edge or both (which defaults to stem then)    */
+      /*  - rounded edge, straigth or both (which defaults to straight)    */
+      /*  - link for edge                                                  */
+      /*                                                                   */
+      /*********************************************************************/
+
+      /* first of all, set the `edge' field in each segment -- this is */
+      /* required in order to compute edge links                       */
       for ( edge = edges; edge < edge_limit; edge++ )
       {
         seg = edge->first;
-        if (seg)
+        if ( seg )
           do
           {
             seg->edge = edge;
@@ -907,26 +991,33 @@
       /* now, compute each edge properties */
       for ( edge = edges; edge < edge_limit; edge++ )
       {
-        int  is_round    = 0;  /* does it contain round segments ?    */
-        int  is_straight = 0;  /* does it contain straight segments ? */
-        int  ups         = 0;  /* number of upwards segments          */
-        int  downs       = 0;  /* number of downwards segments        */
+        int  is_round    = 0;  /* does it contain round segments?    */
+        int  is_straight = 0;  /* does it contain straight segments? */
+        int  ups         = 0;  /* number of upwards segments         */
+        int  downs       = 0;  /* number of downwards segments       */
+
 
         seg = edge->first;
+
         do
         {
-          FT_Bool is_serif;
+          FT_Bool  is_serif;
+
 
           /* check for roundness of segment */
-          if ( seg->flags & ah_edge_round ) is_round++;
-                                      else  is_straight++;
+          if ( seg->flags & ah_edge_round )
+            is_round++;
+          else
+            is_straight++;
 
           /* check for segment direction */
-          if ( seg->dir == up_dir ) ups  += (seg->max_coord-seg->min_coord);
-                              else downs += (seg->max_coord-seg->min_coord);
+          if ( seg->dir == up_dir )
+            ups   += seg->max_coord-seg->min_coord;
+          else
+            downs += seg->max_coord-seg->min_coord;
 
-          /* check for links - if seg->serif is set, then seg->link must be */
-          /* ignored..                                                      */
+          /* check for links -- if seg->serif is set, then seg->link must */
+          /* be ignored                                                   */
           is_serif = seg->serif && seg->serif->edge != edge;
 
           if ( seg->link || is_serif )
@@ -934,33 +1025,37 @@
             AH_Edge*     edge2;
             AH_Segment*  seg2;
 
+
             edge2 = edge->link;
             seg2  = seg->link;
 
-            if (is_serif)
+            if ( is_serif )
             {
               seg2  = seg->serif;
               edge2 = edge->serif;
             }
 
-            if (edge2)
+            if ( edge2 )
             {
               FT_Pos  edge_delta;
               FT_Pos  seg_delta;
 
+
               edge_delta = edge->fpos - edge2->fpos;
-              if (edge_delta < 0) edge_delta = -edge_delta;
+              if ( edge_delta < 0 )
+                edge_delta = -edge_delta;
 
               seg_delta = seg->pos - seg2->pos;
-              if (seg_delta < 0) seg_delta = -seg_delta;
+              if ( seg_delta < 0 )
+                seg_delta = -seg_delta;
 
-              if (seg_delta < edge_delta)
+              if ( seg_delta < edge_delta )
                 edge2 = seg2->edge;
             }
             else
               edge2 = seg2->edge;
 
-            if (is_serif)
+            if ( is_serif )
               edge->serif = edge2;
             else
               edge->link  = edge2;
@@ -988,11 +1083,11 @@
         else if ( ups == downs )
           edge->dir = 0;  /* both up and down !! */
 
-        /* gets rid of serifs if link is set                    */
-        /* ZZZZ: this gets rid of many unpleasant artefacts !!  */
-        /*       example : the "c" in cour.pfa at size 13       */
+        /* gets rid of serifs if link is set                */
+        /* XXX: This gets rid of many unpleasant artefacts! */
+        /*      Example: the `c' in cour.pfa at size 13     */
 
-        if (edge->serif && edge->link)
+        if ( edge->serif && edge->link )
           edge->serif = 0;
       }
 
@@ -1006,16 +1101,14 @@
   }
 
 
- /************************************************************************
-  *
-  * <Function>
-  *    ah_outline_detect_features
-  *
-  * <Description>
-  *    Performs feature detection on a given AH_Outline
-  *
-  ************************************************************************/
-
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_detect_features                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Performs feature detection on a given AH_Outline object.           */
+  /*                                                                       */
   LOCAL_FUNC
   void  ah_outline_detect_features( AH_Outline*  outline )
   {
@@ -1025,18 +1118,15 @@
   }
 
 
-
- /************************************************************************
-  *
-  * <Function>
-  *    ah_outline_compute_blue_edges
-  *
-  * <Description>
-  *    Computes the "blue edges" in a given outline (i.e. those that
-  *    must be snapped to a blue zone edge (top or bottom)
-  *
-  ************************************************************************/
-
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_compute_blue_edges                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the `blue edges' in a given outline (i.e. those that must */
+  /*    be snapped to a blue zone edge (top or bottom).                    */
+  /*                                                                       */
   LOCAL_FUNC
   void  ah_outline_compute_blue_edges( AH_Outline*       outline,
                                        AH_Face_Globals*  face_globals )
@@ -1046,59 +1136,68 @@
     AH_Globals*  globals = &face_globals->design;
     FT_Fixed     y_scale = outline->y_scale;
 
+
     /* compute for each horizontal edge, which blue zone is closer */
     for ( ; edge < limit; edge++ )
     {
-      AH_Blue        blue;
-      FT_Pos*        best_blue = 0;
-      FT_Pos         best_dist;  /* initial threshold */
+      AH_Blue  blue;
+      FT_Pos*  best_blue = 0;
+      FT_Pos   best_dist;  /* initial threshold */
+
 
       /* compute the initial threshold as a fraction of the EM size */
       best_dist = FT_MulFix( face_globals->face->units_per_EM / 40, y_scale );
-      if (best_dist > 64/4)
-        best_dist = 64/4;
+      if ( best_dist > 64 / 4 )
+        best_dist = 64 / 4;
 
       for ( blue = (AH_Blue)0; blue < ah_blue_max; blue++ )
       {
-        /* if it is a top zone, check for right edges - if it is a bottom */
-        /* zone, check for left edges..                                   */
-        /* of course, that's for TrueType .. XXXX                         */
-        FT_Bool  is_top_blue  = AH_IS_TOP_BLUE(blue);
+        /* if it is a top zone, check for right edges -- if it is a bottom */
+        /* zone, check for left edges                                      */
+        /*                                                                 */
+        /* of course, that's for TrueType XXX                              */
+        FT_Bool  is_top_blue  = AH_IS_TOP_BLUE( blue );
         FT_Bool  is_major_dir = edge->dir == outline->horz_major_dir;
 
-        /* if it's a top zone, the edge must be against the major direction */
-        /* if it's a bottom zone, it must be in the major direction         */
+
+        /* if it is a top zone, the edge must be against the major    */
+        /* direction; if it is a bottom zone, it must be in the major */
+        /* direction                                                  */
         if ( is_top_blue ^ is_major_dir )
         {
-          FT_Pos  dist;
-          FT_Pos* blue_pos = globals->blue_refs + blue;
+          FT_Pos   dist;
+          FT_Pos*  blue_pos = globals->blue_refs + blue;
+
 
           /* first of all, compare it to the reference position */
           dist = edge->fpos - *blue_pos;
-          if (dist < 0) dist = -dist;
+          if ( dist < 0 )
+            dist = -dist;
 
           dist = FT_MulFix( dist, y_scale );
-          if (dist < best_dist)
+          if ( dist < best_dist )
           {
             best_dist = dist;
             best_blue = blue_pos;
           }
 
-          /* now, compare it to the overshoot position if the edge is rounded */
-          /* and when the edge is over the reference position of a top zone,  */
-          /* or under the reference position of a bottom zone                 */
+          /* now, compare it to the overshoot position if the edge is     */
+          /* rounded, and if the edge is over the reference position of a */
+          /* top zone, or under the reference position of a bottom zone   */
           if ( edge->flags & ah_edge_round && dist != 0 )
           {
             FT_Bool  is_under_ref = edge->fpos < *blue_pos;
 
+
             if ( is_top_blue ^ is_under_ref )
             {
               blue_pos = globals->blue_shoots + blue;
               dist = edge->fpos - *blue_pos;
-              if (dist < 0) dist = -dist;
+              if ( dist < 0 )
+                dist = -dist;
 
               dist = FT_MulFix( dist, y_scale );
-              if (dist < best_dist)
+              if ( dist < best_dist )
               {
                 best_dist = dist;
                 best_blue = blue_pos;
@@ -1108,7 +1207,7 @@
         }
       }
 
-      if (best_blue)
+      if ( best_blue )
         edge->blue_edge = best_blue;
     }
   }
diff --git a/src/cid/cidgload.c b/src/cid/cidgload.c
index 4169f26..97c9252 100644
--- a/src/cid/cidgload.c
+++ b/src/cid/cidgload.c
@@ -1445,7 +1445,7 @@
     hinting = ( load_flags & FT_LOAD_NO_SCALE   ) == 0 &&
               ( load_flags & FT_LOAD_NO_HINTING ) == 0;
 
-    glyph->root.format = ft_glyph_format_none;
+    glyph->root.format = ft_glyph_format_outline;
 
     {
       CID_Init_Decoder( &decoder );