* include/freetype/fttrigon.h, src/base/fttrigon.c, src/base/ftbase.c,

    src/base/Jamfile, src/base/rules.mk: adding trigonometric functions
    to the core API (using Cordic algorithms).

    * builds/top_level.mk, builds/newline, builds/detect.mk: fixed problems
    with Make on Windows 2000, as well as problems when "make distclean" is
    invoked on a non-Unix platform when there is no "config.mk" in the
    current directory..

    * builds/freetype.mk: fixed a problem with object deletions under
    Dos/Windows/OS/2 systems

    * src/tools: added new directory to hold tools and test programs
    moved docmaker.py, glnames.py to it..

    * src/tools/docmaker.py: improved the script to add the current date
    at the footer of each web page (useful to distinguish between versions)

    * Jamfile: fixed incorrect HDRMACRO argument.

    * TODO: removed the cubic arc bbox computation note, since it has been
    fixed recently..

    * include/freetype/t1tables.h, include/freetype/config/ftoption.h:
    formatting

23 files changed, 1254 insertions, 47 deletions

diff --git a/ChangeLog b/ChangeLog
index cd3305442..6d9497961 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,36 @@
+2001-05-11  David Turner  <david@freetype.org>
+
+    * include/freetype/fttrigon.h, src/base/fttrigon.c, src/base/ftbase.c,
+    src/base/Jamfile, src/base/rules.mk: adding trigonometric functions
+    to the core API (using Cordic algorithms).
+
+    * builds/top_level.mk, builds/newline, builds/detect.mk: fixed problems
+    with Make on Windows 2000, as well as problems when "make distclean" is
+    invoked on a non-Unix platform when there is no "config.mk" in the
+    current directory..
+
+    * builds/freetype.mk: fixed a problem with object deletions under
+    Dos/Windows/OS/2 systems
+
+    * src/tools: added new directory to hold tools and test programs
+    moved docmaker.py, glnames.py to it..
+
+    * src/tools/docmaker.py: improved the script to add the current date
+    at the footer of each web page (useful to distinguish between versions)
+
+    * Jamfile: fixed incorrect HDRMACRO argument.
+
+    * TODO: removed the cubic arc bbox computation note, since it has been
+    fixed recently..
+
+    * include/freetype/t1tables.h, include/freetype/config/ftoption.h:
+    formatting
+
+2001-05-10  David Turner  <david@freetype.org>
+
+        * src/base/ftobjs.c (FT_Open_Face): fixed a small memory leaked
+        which happened when trying to open 0-size font files !!
+
 2001-05-09  Werner Lemberg  <wl@gnu.org>
 
 	* include/freetype/internal/ftcalc.h: Move declaration of
@@ -21,8 +54,8 @@
 
 2001-04-27  David Turner  <david@freetype.org>
 
-	* src/base/ftbbox.c (BBox_Cubic_Check): Fixed the coefficient     
-	normalization algorithm (invalid final bit position, and invalid 
+	* src/base/ftbbox.c (BBox_Cubic_Check): Fixed the coefficient
+	normalization algorithm (invalid final bit position, and invalid
 	shift computation).
 
 2001-04-26  Werner Lemberg  <wl@gnu.org>
@@ -66,7 +99,7 @@
 	types on platforms where Autoconf is not available).  Also removed
 	FTCALC_USE_LONG_LONG and replaced it with
 	FT_CONFIG_OPTION_FORCE_INT64.
-	
+
 	* builds/win32/freetype.dsp: Updated the Visual C++ project file.
 	Doesn't create a DLL yet.
 
diff --git a/builds/detect.mk b/builds/detect.mk
index eaf1ddec5..fbd85d5c5 100644
--- a/builds/detect.mk
+++ b/builds/detect.mk
@@ -131,22 +131,25 @@ std_setup:
 	@echo ""
 	@$(COPY) $(CONFIG_RULES) $(CONFIG_MK)
 
+
+# special case for Dos, Windows, OS/2, where echo "" doesn't work correctly !!
+#
 dos_setup:
-	@echo ˙
+	@type builds\newline
 	@echo $(PROJECT_TITLE) build system -- automatic system detection
-	@echo ˙
+	@type builds\newline
 	@echo The following settings are used:
-	@echo ˙
-	@echo ˙˙platform˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙$(PLATFORM)
-	@echo ˙˙compiler˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙$(CC)
-	@echo ˙˙configuration directory˙˙˙˙˙˙$(BUILD)
-	@echo ˙˙configuration rules˙˙˙˙˙˙˙˙˙˙$(CONFIG_RULES)
-	@echo ˙
+	@type builds\newline
+	@echo   platform˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙$(PLATFORM)
+	@echo   compiler˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙˙$(CC)
+	@echo   configuration directory˙˙˙˙˙˙$(BUILD)
+	@echo   configuration rules˙˙˙˙˙˙˙˙˙˙$(CONFIG_RULES)
+	@type builds\newline
 	@echo If this does not correspond to your system or settings please remove the file
 	@echo '$(CONFIG_MK)' from this directory then read the INSTALL file for help.
-	@echo ˙
+	@type builds\newline
 	@echo Otherwise, simply type 'make' again to build the library.
-	@echo ˙
+	@type builds\newline
 	@$(COPY) $(subst /,\,$(CONFIG_RULES) $(CONFIG_MK)) > nul
 
 # EOF
diff --git a/builds/freetype.mk b/builds/freetype.mk
index 532de0f4b..a25ed2a27 100644
--- a/builds/freetype.mk
+++ b/builds/freetype.mk
@@ -273,13 +273,14 @@ distclean_project_std: clean_project_std
 # The Dos command shell does not support very long list of arguments, so
 # we are stuck with wildcards.
 #
+# don't break the command lines with, this prevents the "del" command from
+# working correctly on Win9x
+#
 clean_project_dos:
-	-$(DELETE) $(subst $(SEP),$(HOSTSEP),$(OBJ_))*.$O \
-                   $(CLEAN) $(NO_OUTPUT)
+	-$(DELETE) $(subst $(SEP),$(HOSTSEP),$(OBJ_))*.$O $(CLEAN) $(NO_OUTPUT)
 
 distclean_project_dos: clean_project_dos
-	-$(DELETE) $(subst $(SEP),$(HOSTSEP),$(PROJECT_LIBRARY)) \
-                   $(DISTCLEAN) $(NO_OUTPUT)
+	-$(DELETE) $(subst $(SEP),$(HOSTSEP),$(PROJECT_LIBRARY)) $(DISTCLEAN) $(NO_OUTPUT)
 
 
 .PHONY: remove_config_mk
diff --git a/builds/link_std.mk b/builds/link_std.mk
index 2a7b26df7..9cd6dba80 100644
--- a/builds/link_std.mk
+++ b/builds/link_std.mk
@@ -32,7 +32,7 @@ ifdef BUILD_PROJECT
   #
   $(PROJECT_LIBRARY): $(OBJECTS_LIST)
     ifdef CLEAN_LIBRARY
-	  -$(CLEAN_LIBRARY) $(NO_OUTPUT)
+	-$(CLEAN_LIBRARY) xx $(NO_OUTPUT)
     endif
 	$(LINK_LIBRARY)
 
diff --git a/builds/newline b/builds/newline
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/builds/newline
@@ -0,0 +1 @@
+
diff --git a/builds/toplevel.mk b/builds/toplevel.mk
index f05ca0dad..086f918e3 100644
--- a/builds/toplevel.mk
+++ b/builds/toplevel.mk
@@ -97,7 +97,12 @@ ifdef check_platform
   # GNU make.  Similarly, `nul' is created if e.g. `make setup win32' has
   # been erroneously used.
   #
-  distclean:
+  # note: this test is duplicated in "builds/toplevel.mk"
+  is_unix := $(strip $(wildcard /sbin/init) $(wildcard /hurd/auth))
+  ifneq ($(is_unix),)
+
+
+    distclean:
 	  $(RM) builds/unix/config.cache
 	  $(RM) builds/unix/config.log
 	  $(RM) builds/unix/config.status
@@ -105,6 +110,8 @@ ifdef check_platform
 	  $(RM) builds/unix/unix-cc.mk
 	  $(RM) nul
 
+  endif # test is_unix
+
   # IMPORTANT:
   #
   # `setup' must be defined by the host platform detection rules to create
diff --git a/builds/unix/detect.mk b/builds/unix/detect.mk
index 32de899f1..52e0075db 100644
--- a/builds/unix/detect.mk
+++ b/builds/unix/detect.mk
@@ -16,6 +16,7 @@
 
 ifeq ($(PLATFORM),ansi)
 
+  # note: this test is duplicated in "builds/toplevel.mk"
   is_unix := $(strip $(wildcard /sbin/init) $(wildcard /hurd/auth))
   ifneq ($(is_unix),)
 
diff --git a/include/freetype/config/ftconfig.h b/include/freetype/config/ftconfig.h
index 225bae5f5..1335587e0 100644
--- a/include/freetype/config/ftconfig.h
+++ b/include/freetype/config/ftconfig.h
@@ -127,6 +127,20 @@ FT_BEGIN_HEADER
 #error "no 32bit type found -- please check your configuration files"
 #endif
 
+/* now, lookup for an integer type that is at least 32 bits */
+#if FT_SIZEOF_INT >= 4
+
+  typedef int           FT_Fast;
+  typedef unsigned int  FT_UFast;
+
+#elif FT_SIZEOF_LONG >= 4
+
+  typedef long          FT_Fast
+  typedef unsigned long FT_UFast
+  
+#endif
+
+
 
   /* determine whether we have a 64-bit int type for platforms without */
   /* Autoconf                                                          */
diff --git a/include/freetype/config/ftheader.h b/include/freetype/config/ftheader.h
index c11d82e55..e39c3cd3c 100644
--- a/include/freetype/config/ftheader.h
+++ b/include/freetype/config/ftheader.h
@@ -436,7 +436,7 @@
 
   /* */
 
- 
+#define FT_TRIGONOMETRY_H          <freetype/fttrigon.h>
 #define FT_SYNTHESIS_H             <freetype/ftsynth.h>
 
 #define FT_CACHE_MANAGER_H         <freetype/cache/ftcmanag.h>
diff --git a/include/freetype/fttrigon.h b/include/freetype/fttrigon.h
new file mode 100644
index 000000000..311040f29
--- /dev/null
+++ b/include/freetype/fttrigon.h
@@ -0,0 +1,213 @@
+#ifndef __FT_TRIGONOMETRY_H__
+#define __FT_TRIGONOMETRY_H__
+
+FT_BEGIN_HEADER
+
+ /***************************************************************************
+  *
+  * @section: computations
+  *
+  */
+
+ /***************************************************************************
+  *
+  * @type: FT_Angle
+  *
+  * @description:
+  *   this type is used to model angle values in FreeType. Note that
+  *   the angle is a 16.16 fixed float value expressed in _degrees_
+  */
+  typedef FT_Fixed   FT_Angle;
+
+ /***************************************************************************
+  *
+  * @macro: FT_ANGLE_PI
+  *
+  * @description:
+  *   the angle pi expressed in @FT_Angle units
+  */
+#define  FT_ANGLE_PI   (180L << 16)
+
+ /***************************************************************************
+  *
+  * @macro: FT_ANGLE_2PI
+  *
+  * @description:
+  *   the angle 2pi expressed in @FT_Angle units
+  */
+#define  FT_ANGLE_2PI  (FT_ANGLE_PI*2)
+
+ /***************************************************************************
+  *
+  * @macro: FT_ANGLE_PI2
+  *
+  * @description:
+  *   the angle pi/2 expressed in @FT_Angle units
+  */
+#define  FT_ANGLE_PI2  (FT_ANGLE_PI/2)
+
+ /***************************************************************************
+  *
+  * @macro: FT_ANGLE_PI4
+  *
+  * @description:
+  *   the angle pi/4 expressed in @FT_Angle units
+  */
+#define  FT_ANGLE_PI4  (FT_ANGLE_PI/4)
+
+
+ /***************************************************************************
+  *
+  * @function: FT_Sin
+  *
+  * @description:
+  *   return the sinus of a given angle in fixed point format
+  *
+  * @input:
+  *    angle :: input angle
+  *
+  * @return:
+  *    sinus value
+  *
+  * @note:
+  *   if you need both the sinus and cosinus for a given angle, you'd
+  *   better use the function @FT_Vector_Unit
+  */
+  FT_EXPORT(FT_Fixed)    FT_Sin( FT_Angle  angle );
+
+ /***************************************************************************
+  *
+  * @function: FT_Cos
+  *
+  * @description:
+  *   return the cosinus of a given angle in fixed point format
+  *
+  * @input:
+  *    angle :: input angle
+  *
+  * @return:
+  *    cosinus value
+  *
+  * @note:
+  *   if you need both the sinus and cosinus for a given angle, you'd
+  *   better use the function @FT_Vector_Unit
+  */
+  FT_EXPORT(FT_Fixed)    FT_Cos( FT_Angle  angle );  
+
+ /***************************************************************************
+  *
+  * @function: FT_Tan
+  *
+  * @description:
+  *   return the tangent of a given angle in fixed point format
+  *
+  * @input:
+  *   angle :: input angle
+  *
+  * @return:
+  *   tangent value
+  */
+  FT_EXPORT(FT_Fixed)    FT_Tan( FT_Angle  angle );
+
+
+ /***************************************************************************
+  *
+  * @function: FT_Atan2
+  *
+  * @description:
+  *   return the arc-tangent corresponding to a given vector (x,y) in
+  *   the 2d plane
+  *
+  * @input:
+  *   x :: horizontal vector coordinate
+  *   y :: vertical vector coordinate
+  *
+  * @return:
+  *   arc-tangent value (i.e. angle)
+  */
+  FT_EXPORT(FT_Angle)    FT_Atan2( FT_Fixed  x, FT_Fixed  y );
+
+
+ /***************************************************************************
+  *
+  * @function: FT_Vector_Unit
+  *
+  * @description:
+  *   return the unit vector corresponding to a given angle. After the call,
+  *   the value of "vec.x" will be "sin(theta)", and the value of "vec.y"
+  *   will be "cos(angle)"
+  *
+  *   this function is useful to retrieve both the sinus and cosinus
+  *   of a given angle quickly
+  *
+  * @input:
+  *   vec   :: address of target vector
+  *   angle :: address of angle
+  */
+  FT_EXPORT(void)        FT_Vector_Unit( FT_Vector*  vec,
+                                         FT_Angle    angle );
+
+ /***************************************************************************
+  *
+  * @function: FT_Vector_Rotate
+  *
+  * @description:
+  *   rotate a given vector by a given angle
+  *
+  * @input:
+  *   vec   :: address of target vector
+  *   angle :: address of angle
+  */
+  FT_EXPORT(void)        FT_Vector_Rotate( FT_Vector*    vec,
+                                           FT_Angle      angle );
+
+ /***************************************************************************
+  *
+  * @function: FT_Vector_Length
+  *
+  * @description:
+  *   returns the length of a given vector
+  *
+  * @input:
+  *   vec   :: address of target vector
+  *
+  * @return:
+  *   vector length, expressed in the same units that the original
+  *   vector coordinates !!
+  */
+  FT_EXPORT(FT_Fixed)    FT_Vector_Length( FT_Vector*  vec );
+
+ /***************************************************************************
+  *
+  * @function: FT_Vector_Normalize
+  *
+  * @description:
+  *   normalize a given vector (i.e. compute the equivalent unit vector)
+  *
+  * @input:
+  *   vec   :: address of target vector
+  */
+  FT_EXPORT(void)        FT_Vector_Normalize( FT_Vector*  vec );
+
+ /***************************************************************************
+  *
+  * @function: FT_Vector_Polarize
+  *
+  * @description:
+  *   compute both the length and angle of a given vector
+  *
+  * @input:
+  *   vec    :: address of source vector
+  *
+  * @output:
+  *   length :: vector length
+  *   angle  :: vector angle
+  */
+  FT_EXPORT(void)        FT_Vector_Polarize( FT_Vector*  vec,
+                                             FT_Fixed   *length,
+                                             FT_Angle   *angle );
+  /* */
+  
+FT_END_HEADER
+
+#endif /* __FT_TRIGONOMETRY_H__ */
diff --git a/include/freetype/t1tables.h b/include/freetype/t1tables.h
index cc23ddeb5..2785fead1 100644
--- a/include/freetype/t1tables.h
+++ b/include/freetype/t1tables.h
@@ -113,8 +113,8 @@ FT_BEGIN_HEADER
     FT_Bool    force_bold;
     FT_Bool    round_stem_up;
 
-    FT_Short   snap_widths [13];  /* reserve one place for the std */
-    FT_Short   snap_heights[13];  /* reserve one place for the std */
+    FT_Short   snap_widths [13];  /* including std width  */
+    FT_Short   snap_heights[13];  /* including std height */
 
     FT_Long    language_group;
     FT_Long    password;
@@ -136,12 +136,12 @@ FT_BEGIN_HEADER
   /*                                                                       */
   typedef enum
   {
-    /* required fields in a FontInfo blend dictionary */
+    /*# required fields in a FontInfo blend dictionary */
     t1_blend_underline_position = 0,
     t1_blend_underline_thickness,
     t1_blend_italic_angle,
 
-    /* required fields in a Private blend dictionary */
+    /*# required fields in a Private blend dictionary */
     t1_blend_blue_values,
     t1_blend_other_blues,
     t1_blend_standard_width,
@@ -154,7 +154,7 @@ FT_BEGIN_HEADER
     t1_blend_family_other_blues,
     t1_blend_force_bold,
 
-    /* never remove */
+    /*# never remove */
     t1_blend_max
 
   } T1_Blend_Flags;
diff --git a/src/autohint/ahglyph.c b/src/autohint/ahglyph.c
index 23c26ed59..252572dfc 100644
--- a/src/autohint/ahglyph.c
+++ b/src/autohint/ahglyph.c
@@ -359,7 +359,7 @@
       outline->horz_major_dir = ah_dir_right;
     }
 
-#else
+#else  /* !1 */
 
     /* Compute the vertical and horizontal major directions; this is     */
     /* currently done by inspecting the `ft_outline_reverse_fill' flag.  */
@@ -374,7 +374,7 @@
       outline->horz_major_dir = ah_dir_right;
     }
 
-#endif /* 1 */
+#endif /* !1 */
 
     outline->x_scale = face->size->metrics.x_scale;
     outline->y_scale = face->size->metrics.y_scale;
diff --git a/src/base/Jamfile b/src/base/Jamfile
index 8bacddb04..c6c13b315 100644
--- a/src/base/Jamfile
+++ b/src/base/Jamfile
@@ -10,7 +10,7 @@ SubDirHdrs  [ FT2_SubDir  src base ] ;
 
   if $(FT2_MULTI)
   {
-    _sources = ftcalc ftextend ftlist ftobjs ftstream ftoutln ftnames ;
+    _sources = ftcalc ftextend ftlist ftobjs ftstream ftoutln ftnames fttrigon ;
   }
   else
   {
diff --git a/src/base/ftbase.c b/src/base/ftbase.c
index 1d61b5aa8..f4b561832 100644
--- a/src/base/ftbase.c
+++ b/src/base/ftbase.c
@@ -21,6 +21,7 @@
 #define  FT_MAKE_OPTION_SINGLE_OBJECT
 
 #include "ftcalc.c"
+#include "fttrigon.c"
 #include "ftobjs.c"
 #include "ftstream.c"
 #include "ftlist.c"
diff --git a/src/base/ftbbox.c b/src/base/ftbbox.c
index 07700e500..67fcbdeab 100644
--- a/src/base/ftbbox.c
+++ b/src/base/ftbbox.c
@@ -278,13 +278,13 @@
 #else
 
   static void
-  test_cubic_zero( FT_Pos    y1,
-                   FT_Pos    y2,
-                   FT_Pos    y3,
-                   FT_Pos    y4,
-                   FT_Fixed  u,
-                   FT_Pos*   min,
-                   FT_Pos*   max )
+  test_cubic_extrema( FT_Pos    y1,
+                      FT_Pos    y2,
+                      FT_Pos    y3,
+                      FT_Pos    y4,
+                      FT_Fixed  u,
+                      FT_Pos*   min,
+                      FT_Pos*   max )
   {
  /* FT_Pos    a = y4 - 3*y3 + 3*y2 - y1; */
     FT_Pos    b = y3 - 2*y2 + y1;
@@ -373,34 +373,81 @@
         int       shift = 0;
 
 
+        /* technical explanation of what's happening there             */
+        /*                                                             */
+        /*   the following computation is based on the fact that for   */
+        /*   any value "y", if "n" is the position of the most         */
+        /*   significant bit of "abs(y)" (starting from 0 for the      */
+        /*   least significant bit), then y is in the range            */
+        /*                                                             */
+        /*                  "-2^n..2^n-1"                              */
+        /*                                                             */
+        /*   we want to shift "a", "b" and "c" concurrently in order   */
+        /*   to ensure that they all fit in 8.16 values, which maps    */
+        /*   to the integer range "-2^23..2^23-1"                      */
+        /*                                                             */
+        /*   necessarily, we need to shift "a", "b" and "c" so that    */
+        /*   the most significant bit of their absolute values is at   */
+        /*   _most_ at position 23                                     */
+        /*                                                             */
+        /*   we begin by computing "t1" as the bitwise "or" of the     */
+        /*   absolute values of "a", "b", "c"                          */
+        /*                                                             */
         t1  = (FT_ULong)((a >= 0) ? a : -a );
         t2  = (FT_ULong)((b >= 0) ? b : -b );
         t1 |= t2;
         t2  = (FT_ULong)((c >= 0) ? c : -c );
         t1 |= t2;
 
+        /*   now, the most significant bit of "t1" is sure to be the   */
+        /*   msb of one of "a", "b", "c", depending on which one is    */
+        /*   expressed in the greatest integer range..                 */
+        /*                                                             */
+        /*   we will now compute the "shift", by shifting "t1" as many */
+        /*   times as necessary to move its msb to position 23.        */
+        /*                                                             */
+        /*   this corresponds to a value of t1 that is in the range    */
+        /*   0x40_0000..0x7F_FFFF                                      */
+        /*                                                             */
+        /*   finally, we shift "a", "b" and "c" by the same amount.    */
+        /*   this ensure that all values are now in the range          */
+        /*   -2^23..2^23, i.e. that they're now expressed as 8.16      */
+        /*   fixed float numbers..                                     */
+        /*                                                             */
+        /*   this also means that we're using 24 bits of precision     */
+        /*   to compute the zeros, independently of the range of       */
+        /*   the original polynom coefficients.                        */
+        /*                                                             */
+        /*   this should ensure reasonably accurate values for the     */
+        /*   zeros. Note that the latter are only expressed with       */
+        /*   16 bits when computing the extrema (the zeros need to     */
+        /*   be in 0..1 exclusive to be considered part of the arc)    */
+        /*                                                             */
+
         if ( t1 == 0 )  /* all coefficients are 0! */
           return;
 
-        if ( t1 > 0x7FFFFFL )
+        if ( t1 > 0x7FFFFFUL )
         {
           do
           {
             shift++;
             t1 >>= 1;
-          } while ( t1 > 0x7FFFFFL );
+          } while ( t1 > 0x7FFFFFUL );
 
+          /* losing some bits of precision, but we'll use 24 of them */
+          /* for the computation anyway..                            */
           a >>= shift;
           b >>= shift;
           c >>= shift;
         }
-        else if ( t1 < 0x400000L )
+        else if ( t1 < 0x400000UL )
         {
           do
           {
             shift++;
             t1 <<= 1;
-          } while ( t1 < 0x400000L );
+          } while ( t1 < 0x400000UL );
 
           a <<= shift;
           b <<= shift;
@@ -414,7 +461,7 @@
         if ( b != 0 )
         {
           t = - FT_DivFix( c, b ) / 2;
-          test_cubic_zero( y1, y2, y3, y4, t, min, max );
+          test_cubic_extrema( y1, y2, y3, y4, t, min, max );
         }
       }
       else
@@ -428,17 +475,17 @@
         {
           /* there is a single split point at -b/a */
           t = - FT_DivFix( b, a );
-          test_cubic_zero( y1, y2, y3, y4, t, min, max );
+          test_cubic_extrema( y1, y2, y3, y4, t, min, max );
         }
         else
         {
           /* there are two solutions; we need to filter them though */
           d = FT_SqrtFixed( (FT_Int32)d );
           t = - FT_DivFix( b - d, a );
-          test_cubic_zero( y1, y2, y3, y4, t, min, max );
+          test_cubic_extrema( y1, y2, y3, y4, t, min, max );
 
           t = - FT_DivFix( b + d, a );
-          test_cubic_zero( y1, y2, y3, y4, t, min, max );
+          test_cubic_extrema( y1, y2, y3, y4, t, min, max );
         }
       }
     }
diff --git a/src/base/ftobjs.c b/src/base/ftobjs.c
index ecd99af01..64bc0beee 100644
--- a/src/base/ftobjs.c
+++ b/src/base/ftobjs.c
@@ -1240,14 +1240,15 @@
             goto Success;
 
           if ( error != FT_Err_Unknown_File_Format )
-            goto Fail;
+            goto Fail2;
         }
       }
 
-      ft_done_stream( &stream, external_stream );
-
       /* no driver is able to handle this format */
       error = FT_Err_Unknown_File_Format;
+
+  Fail2:
+      ft_done_stream( &stream, external_stream );
       goto Fail;
     }
 
diff --git a/src/base/fttrigon.c b/src/base/fttrigon.c
new file mode 100644
index 000000000..693551853
--- /dev/null
+++ b/src/base/fttrigon.c
@@ -0,0 +1,404 @@
+#include <ft2build.h>
+#include FT_TRIGONOMETRY_H
+
+/* the following is 0.2715717684432231 * 2^30 */
+#define  FT_TRIG_COSCALE   0x11616E8E	/* 291597966 = 0.2715717684432241 * 2^30, valid for j>13 */
+
+  /* this table was generated for FT_PI = 180L << 16, i.e. degrees */
+#define  FT_TRIG_MAX_ITERS  23
+
+  static const FT_Fixed
+  ft_trig_arctan_table[ 24 ] =
+  {
+    4157273, 2949120, 1740967, 919879, 466945, 234379, 117304, 58666,
+    29335, 14668, 7334, 3667, 1833, 917, 458, 229, 115, 57, 29, 14, 7,
+    4, 2, 1
+  };
+
+
+/* the Cordic shrink factor, multiplied by 2^32 */
+#define  FT_TRIG_SCALE    1166391785  /* 0x4585BA38U */
+
+#ifdef FT_CONFIG_HAS_INT64
+
+ /* multiply a given value by the CORDIC shrink factor */
+  static FT_Fixed
+  ft_trig_downscale( FT_Fixed  val )
+  {
+    FT_Fixed  s;
+    FT_Int64  v;
+
+    s   = val;
+    val = (val >= 0) ? val : -val;
+    
+    v   = (val * (FT_Int64)FT_TRIG_SCALE) + 0x100000000L;
+    val = (FT_Fixed)(v >> 32);
+
+    return ( s >= 0 ) ? val : -val;
+  }
+
+#else /* !FT_CONFIG_HAS_INT64 */
+
+ /* multiply a given value by the CORDIC shrink factor */
+  static FT_Fixed
+  ft_trig_downscale( FT_Fixed  val )
+  {
+    FT_Fixed   s;
+    FT_UInt32  v1, v2, k1, k2, hi, lo1, lo2, lo3;
+    
+    s   = val;
+    val = ( val >= 0 ) ? val : -val;
+
+    v1 = (FT_UInt32)val >> 16;
+    v2 = (FT_UInt32)val & 0xFFFF;
+    
+    k1 = FT_TRIG_SCALE >> 16;      /* constant */
+    k2 = FT_TRIG_SCALE & 0xFFFF;   /* constant */
+
+    hi   = k1*v1;
+    lo1  = k1*v2 + k2*v1;   /* can't overflow */
+    
+    lo2  = k2*v2 >> 16;
+    lo3  = ( lo1 >= lo2 ) ? lo1 : lo2;
+    lo1 += lo2;
+
+    hi  += lo1 >> 16;
+    if (lo1 < lo3)
+      hi += 0x10000U;
+
+    val  = (FT_Fixed)hi;
+
+    return ( s >= 0 ) ? val : -val;
+  }
+
+#endif /* !FT_CONFIG_HAS_INT64 */
+
+
+  static FT_Int
+  ft_trig_prenorm( FT_Vector*  vec )
+  {
+    FT_Fixed  x, y, z;
+    FT_Int    shift;
+
+    x = vec->x;
+    y = vec->y;
+    
+    z     = (( x >= 0 ) ? x : - x) | ((y >= 0) ? y : -y);
+    shift = 0;
+    
+    if ( z < (1L << 27) )
+    {
+      do
+      {
+        shift++;
+        z <<= 1;
+      }
+      while ( z < (1L << 27) );
+      
+      vec->x = (x << shift);
+      vec->y = (y << shift);
+    }
+    else if ( z > (1L << 28 ) )
+    {
+      do
+      {
+        shift++;
+        z >>= 1;
+      }
+      while ( z > (1L << 28) );
+
+      vec->x = (x >> shift);
+      vec->y = (y >> shift);
+      shift  = -shift;
+    }
+    return shift;
+  }
+    
+  
+
+
+  static void
+  ft_trig_pseudo_rotate( FT_Vector*  vec, FT_Angle  theta )
+  {
+    FT_Int          i;
+    FT_Fixed        x, y, xtemp;
+    const FT_Fixed *arctanptr;
+
+    x = vec->x;
+    y = vec->y;
+
+    /* Get angle between -90 and 90 degrees */
+    while (theta <= -FT_ANGLE_PI2)
+    {
+      x = -x;
+      y = -y;
+      theta += FT_ANGLE_PI;
+    }
+    while (theta > FT_ANGLE_PI2)
+    {
+      x = -x;
+      y = -y;                   
+      theta -= FT_ANGLE_PI;
+    }
+
+    /* Initial pseudorotation, with left shift */
+    arctanptr = ft_trig_arctan_table;
+    if (theta < 0)
+    {
+      xtemp  = x + (y << 1);
+      y      = y - (x << 1);
+      x      = xtemp;
+      theta += *arctanptr++;
+    }
+    else
+    {
+      xtemp  = x - (y << 1);
+      y      = y + (x << 1);
+      x      = xtemp;
+      theta -= *arctanptr++;
+    }
+
+    /* Subsequent pseudorotations, with right shifts */
+    i = 0;
+    do
+    {
+      if (theta < 0)
+      {
+        xtemp = x + (y >> i);
+        y     = y - (x >> i);
+        x     = xtemp;
+        theta += *arctanptr++;
+      }
+      else
+      {
+        xtemp  = x - (y >> i);
+        y      = y + (x >> i);
+        x      = xtemp;
+        theta -= *arctanptr++;
+      }
+    }
+    while ( ++i < FT_TRIG_MAX_ITERS );
+
+    vec->x = x;
+    vec->y = y;
+  }
+
+
+  static void
+  ft_trig_pseudo_polarize( FT_Vector*  vec )
+  {
+    FT_Fixed theta;
+    FT_Fixed yi, i;
+    FT_Fixed x, y;
+    const FT_Fixed *arctanptr;
+
+    x = vec->x;
+    y = vec->y;
+
+    /* Get the vector into the right half plane */
+    theta = 0;
+    if (x < 0)
+    {
+      x = -x;
+      y = -y;
+      theta = 2 * FT_ANGLE_PI2;
+    }
+
+    if (y > 0)
+      theta = - theta;
+
+    arctanptr = ft_trig_arctan_table;
+    if (y < 0)
+    {
+      /* Rotate positive */
+      yi = y + (x << 1);
+      x  = x - (y << 1);
+      y  = yi;
+      theta -= *arctanptr++;  /* Subtract angle */
+    }
+    else
+    {
+      /* Rotate negative */
+      yi = y - (x << 1);
+      x  = x + (y << 1);
+      y  = yi;
+      theta += *arctanptr++;  /* Add angle */
+    }
+
+    i = 0;
+    do
+    {
+      if (y < 0)
+      {
+        /* Rotate positive */
+        yi = y + (x >> i);
+        x  = x - (y >> i);
+        y  = yi;
+        theta -= *arctanptr++;
+      }
+      else
+      {
+        /* Rotate negative */
+        yi = y - (x >> i);
+        x  = x + (y >> i);
+        y  = yi;
+        theta += *arctanptr++;
+      }
+    }
+    while (++i < FT_TRIG_MAX_ITERS);
+
+    /* round theta */
+    if ( theta >= 0 )
+      theta = ( theta + 16 ) & -32;
+    else
+      theta = - (( -theta + 16 ) & -32);
+
+    vec->x = x;
+    vec->y = theta;
+  }
+
+
+  FT_EXPORT_DEF(FT_Fixed)
+  FT_Cos( FT_Angle  angle )
+  {
+    FT_Vector  v;
+    
+    v.x = FT_TRIG_COSCALE >> 2;
+    v.y = 0;
+    ft_trig_pseudo_rotate( &v, angle );
+    
+    return v.x >> 12;
+  }
+
+
+  FT_EXPORT_DEF(FT_Fixed)
+  FT_Sin( FT_Angle  angle )
+  {
+    return FT_Cos( FT_ANGLE_PI2-angle );
+  }
+
+
+  FT_EXPORT_DEF(FT_Fixed)
+  FT_Tan( FT_Angle  angle )
+  {
+    FT_Vector  v;
+    
+    v.x = FT_TRIG_COSCALE >> 2;
+    v.y = 0;
+    ft_trig_pseudo_rotate( &v, angle );
+    
+    return FT_DivFix( v.y, v.x );
+  }
+
+
+
+  FT_EXPORT_DEF(FT_Angle)
+  FT_Atan2( FT_Fixed  dx,
+            FT_Fixed  dy )
+  {
+    FT_Vector  v;
+    
+    if ( dx == 0 && dy == 0 )
+      return 0;
+
+    v.x = dx;
+    v.y = dy;      
+    ft_trig_prenorm( &v );
+    ft_trig_pseudo_polarize( &v );
+    return v.y;
+  }
+
+
+  FT_EXPORT_DEF(void)
+  FT_Vector_Unit( FT_Vector*  vec,
+                  FT_Angle    angle )
+  {
+	vec->x = FT_TRIG_COSCALE >> 2;
+	vec->y = 0;
+	ft_trig_pseudo_rotate( vec, angle );
+	vec->x >>= 12;
+	vec->y >>= 12;
+  }
+
+
+  FT_EXPORT_DEF(void)
+  FT_Vector_Rotate( FT_Vector*  vec,
+                    FT_Angle  angle )
+  {
+    FT_Int     shift;
+    FT_Vector  v;
+    
+    v.x   = vec->x;
+    v.y   = vec->y;
+    if ( angle && ( v.x != 0 || v.y != 0 ) )
+    {
+      shift = ft_trig_prenorm( &v );
+      ft_trig_pseudo_rotate( &v, angle );
+      v.x = ft_trig_downscale( v.x );
+      v.y = ft_trig_downscale( v.y );
+      
+      if ( shift >= 0 )
+      {
+        vec->x = v.x >> shift;
+        vec->y = v.y >> shift;
+      }
+      else
+      {
+        shift  = -shift;
+        vec->x = v.x << shift;
+        vec->y = v.y << shift;
+      }
+    }
+  }
+
+
+  FT_EXPORT_DEF(FT_Fixed)
+  FT_Vector_Length( FT_Vector*  vec )
+  {
+    FT_Int    shift;
+    FT_Vector v;
+    
+    v = *vec;
+
+    /* handle trivial cases */    
+    if ( v.x == 0 )
+    {
+      return ( v.y >= 0 ) ? v.y : -v.y;
+    }
+    else if ( v.y == 0 )
+    {
+      return ( v.x >= 0 ) ? v.x : -v.x;
+    }
+
+    /* general case */
+    shift = ft_trig_prenorm( &v );
+    ft_trig_pseudo_polarize( &v );
+    
+    v.x = ft_trig_downscale( v.x );
+    return ( shift >= 0 ) ? (v.x >> shift) : (v.x << -shift);
+  }  
+
+
+  FT_EXPORT_DEF(void)
+  FT_Vector_Polarize( FT_Vector*  vec,
+                      FT_Fixed   *length,
+                      FT_Angle   *angle )
+  {
+    FT_Int    shift;
+    FT_Vector v;
+    
+    v = *vec;
+    
+    if ( v.x == 0 && v.y == 0 )
+      return;
+      
+    shift = ft_trig_prenorm( &v );
+    ft_trig_pseudo_polarize( &v );
+    
+    v.x = ft_trig_downscale( v.x );
+
+    *length = ( shift >= 0 ) ? (v.x >> shift) : (v.x << -shift);
+    *angle  = v.y;
+  }                    
+
+
diff --git a/src/base/rules.mk b/src/base/rules.mk
index 7698c411c..440a2ffd3 100644
--- a/src/base/rules.mk
+++ b/src/base/rules.mk
@@ -33,6 +33,7 @@ BASE_COMPILE := $(FT_COMPILE) $I$(SRC_)base
 #   ftsystem, ftinit, and ftdebug are handled by freetype.mk
 #
 BASE_SRC := $(BASE_)ftcalc.c   \
+            $(BASE_)fttrigon.c \
             $(BASE_)ftextend.c \
             $(BASE_)ftlist.c   \
             $(BASE_)ftobjs.c   \
diff --git a/src/tools/cordic.py b/src/tools/cordic.py
new file mode 100644
index 000000000..515fbcc5d
--- /dev/null
+++ b/src/tools/cordic.py
@@ -0,0 +1,78 @@
+# compute arctangent table for CORDIC computations in fttrigon.c
+import sys, math
+
+units  = 180*65536   # don't change !!
+scale  = units/math.pi
+shrink = 1.0
+comma  = ""
+
+def calc_val( x ):
+    global units, shrink
+    angle  = math.atan(x)
+    shrink = shrink * math.cos(angle)
+    return angle/math.pi * units
+
+def  print_val( n, x ):
+    global comma
+
+    lo  = int(x)
+    hi  = lo + 1
+    alo = math.atan(lo)
+    ahi = math.atan(hi)
+    ax  = math.atan(2.0**n)
+
+    errlo = abs( alo - ax )
+    errhi = abs( ahi - ax )
+    
+    if ( errlo < errhi ):
+      hi = lo
+
+    sys.stdout.write( comma + repr( int(hi) ) )
+    comma = ", "
+
+
+print ""
+print "table of arctan( 1/2^n ) for PI = " + repr(units/65536.0) + " units"
+
+# compute range of "i"
+r = [-1]
+r = r + range(32)
+
+for n in r:
+
+    if n >= 0:
+        x = 1.0/(2.0**n)    # tangent value
+    else:
+        x = 2.0**(-n)
+      
+    angle  = math.atan(x)    # arctangent 
+    angle2 = angle*scale     # arctangent in FT_Angle units
+
+    # determine which integer value for angle gives the best tangent
+    lo  = int(angle2)
+    hi  = lo + 1
+    tlo = math.tan(lo/scale)
+    thi = math.tan(hi/scale)
+
+    errlo = abs( tlo - x )
+    errhi = abs( thi - x )
+
+    angle2 = hi
+    if errlo < errhi:
+        angle2 = lo
+
+    if angle2 <= 0:
+        break
+    
+    sys.stdout.write( comma + repr( int(angle2) ) )
+    comma = ", "
+    
+    shrink = shrink * math.cos( angle2/scale)
+      
+
+print
+print "shrink factor    = " + repr( shrink )
+print "shrink factor 2  = " + repr( shrink * (2.0**32) )
+print "expansion factor = " + repr(1/shrink)
+print ""
+   
\ No newline at end of file
diff --git a/docs/docmaker.py b/src/tools/docmaker.py
index 17288f31f..a20f22b5b 100644
--- a/docs/docmaker.py
+++ b/src/tools/docmaker.py
@@ -25,7 +25,7 @@
 #   - David
 #
 
-import fileinput, sys, os, string, glob, getopt
+import fileinput, sys, os, time, string, glob, getopt
 
 # The Project's title.  This can be overridden from the command line with
 # the options "-t" or "--title".
@@ -216,6 +216,11 @@ def check_output( ):
             output_dir = None
 
 
+def compute_time_html( ):
+    global html_footer
+    time_string = time.asctime( time.localtime( time.time() ) )
+    html_footer = "<p><center><font size=""-2"">generated on " + time_string + "</font></p></center>" + html_footer
+
 # The FreeType 2 reference is extracted from the source files.  These
 # contain various comment blocks that follow one of the following formats:
 #
@@ -1628,6 +1633,7 @@ def main( argv ):
 
     html_header = html_header_1 + project_title + html_header_2 + project_title + html_header_3
     check_output( )
+    compute_time_html()
 
     # we begin by simply building a list of DocBlock elements
     #
diff --git a/docs/glnames.py b/src/tools/glnames.py
index 6179f0071..6179f0071 100644
--- a/docs/glnames.py
+++ b/src/tools/glnames.py
diff --git a/src/tools/test_bbox.c b/src/tools/test_bbox.c
new file mode 100644
index 000000000..ec97a3899
--- /dev/null
+++ b/src/tools/test_bbox.c
@@ -0,0 +1,160 @@
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_BBOX_H
+
+
+#include <time.h>    /* for clock() */
+
+/* SunOS 4.1.* does not define CLOCKS_PER_SEC, so include <sys/param.h> */
+/* to get the HZ macro which is the equivalent.                         */
+#if defined(__sun__) && !defined(SVR4) && !defined(__SVR4)
+#include <sys/param.h>
+#define CLOCKS_PER_SEC HZ
+#endif
+
+  static long
+  get_time( void )
+  {
+    return clock() * 10000L / CLOCKS_PER_SEC;
+  }
+
+
+
+
+  /* test bbox computations */
+  
+#define  XSCALE    65536
+#define  XX(x)     ((FT_Pos)(x*XSCALE))
+#define  XVEC(x,y)  { XX(x), XX(y) }
+#define  XVAL(x)   ((x)/(1.0*XSCALE))
+  
+  /* dummy outline #1 */
+  static FT_Vector  dummy_vec_1[4] =
+  {
+#if 1
+    XVEC( 408.9111, 535.3164 ),
+    XVEC( 455.8887, 634.396  ),
+    XVEC( -37.8765, 786.2207 ),
+    XVEC( 164.6074, 535.3164 )
+#else    
+    { (FT_Int32)0x0198E93DL , (FT_Int32)0x021750FFL },  /* 408.9111, 535.3164 */
+    { (FT_Int32)0x01C7E312L , (FT_Int32)0x027A6560L },  /* 455.8887, 634.3960 */
+    { (FT_Int32)0xFFDA1F9EL , (FT_Int32)0x0312387FL },  /* -37.8765, 786.2207 */
+    { (FT_Int32)0x00A49B7EL , (FT_Int32)0x021750FFL }   /* 164.6074, 535.3164 */
+#endif    
+   };
+  
+  static char  dummy_tag_1[4] =
+  {
+    FT_Curve_Tag_On,
+    FT_Curve_Tag_Cubic,
+    FT_Curve_Tag_Cubic,
+    FT_Curve_Tag_On
+  };
+
+  static short  dummy_contour_1[1] =
+  {
+    3
+  };
+  
+  static FT_Outline  dummy_outline_1 =
+  {
+    1,
+    4,
+    dummy_vec_1,
+    dummy_tag_1,
+    dummy_contour_1,
+    0
+  };
+
+
+  /* dummy outline #2 */
+  static FT_Vector  dummy_vec_2[4] =
+  {
+    XVEC( 100.0, 100.0 ),
+    XVEC( 100.0, 200.0 ),
+    XVEC( 200.0, 200.0 ),
+    XVEC( 200.0, 133.0 )
+  };
+  
+  static FT_Outline  dummy_outline_2 =
+  {
+    1,
+    4,
+    dummy_vec_2,
+    dummy_tag_1,
+    dummy_contour_1,
+    0
+  };
+
+
+  static void
+  dump_outline( FT_Outline*  outline )
+  {
+    FT_BBox  bbox;
+    
+    /* compute and display cbox */
+    FT_Outline_Get_CBox( outline, &bbox );
+    printf( "cbox = [%.2f %.2f %.2f %.2f]\n",
+             XVAL( bbox.xMin ),
+             XVAL( bbox.yMin ),
+             XVAL( bbox.xMax ),
+             XVAL( bbox.yMax ) );
+
+    /* compute and display bbox */
+    FT_Outline_Get_BBox( outline, &bbox );
+    printf( "bbox = [%.2f %.2f %.2f %.2f]\n",
+             XVAL( bbox.xMin ),
+             XVAL( bbox.yMin ),
+             XVAL( bbox.xMax ),
+             XVAL( bbox.yMax ) );
+  }
+
+
+
+  static void
+  profile_outline( FT_Outline*   outline,
+                   long          repeat )
+  {
+    FT_BBox  bbox;
+    long     count;
+    long     time0;
+    
+    time0 = get_time();
+    for ( count = repeat; count > 0; count-- )
+      FT_Outline_Get_CBox( outline, &bbox );
+      
+    time0 = get_time() - time0;      
+    printf( "time = %5.2f cbox = [%.2f %.2f %.2f %.2f]\n",
+             ((double)time0/10000.0),
+             XVAL( bbox.xMin ),
+             XVAL( bbox.yMin ),
+             XVAL( bbox.xMax ),
+             XVAL( bbox.yMax ) );
+
+
+    time0 = get_time();
+    for ( count = repeat; count > 0; count-- )
+      FT_Outline_Get_BBox( outline, &bbox );
+    
+    time0 = get_time() - time0;
+    printf( "time = %5.2f bbox = [%.2f %.2f %.2f %.2f]\n",
+             ((double)time0/10000.0),
+             XVAL( bbox.xMin ),
+             XVAL( bbox.yMin ),
+             XVAL( bbox.xMax ),
+             XVAL( bbox.yMax ) );
+  }
+
+#define REPEAT  100000L
+
+  int  main( int  argc, char**  argv )
+  {
+    printf( "outline #1\n" );
+    profile_outline( &dummy_outline_1, REPEAT );
+
+    printf( "outline #2\n" );
+    profile_outline( &dummy_outline_2, REPEAT );
+    return 0;
+  }
+
diff --git a/src/tools/test_trig.c b/src/tools/test_trig.c
new file mode 100644
index 000000000..e3399e7a6
--- /dev/null
+++ b/src/tools/test_trig.c
@@ -0,0 +1,236 @@
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TRIGONOMETRY_H
+
+#include <math.h>
+#include <stdio.h>
+
+#define  PI   3.14159265358979323846
+#define  SPI  (PI/FT_ANGLE_PI)
+
+/* the precision in 16.16 fixed float points of the checks. Expect */
+/* between 2 and 5 noise LSB bits during operations, due to        */
+/* rounding errors..                                               */
+#define  THRESHOLD  64
+
+  static  error = 0;
+
+  static void
+  test_cos( void )
+  {
+    FT_Fixed  f1, f2;
+    double    d1, d2;
+    int       i;
+    
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      f1 = FT_Cos(i);
+      d1 = f1/65536.0;
+      d2 = cos( i*SPI );
+      f2 = (FT_Fixed)(d2*65536.0);
+
+      if ( abs( f2-f1 ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Cos[%3d] = %.7f  cos[%3d] = %.7f\n",
+                (i >> 16), f1/65536.0, (i >> 16), d2 );
+      }
+    }
+  }
+
+
+
+  static void
+  test_sin( void )
+  {
+    FT_Fixed  f1, f2;
+    double    d1, d2;
+    int       i;
+    
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      f1 = FT_Sin(i);
+      d1 = f1/65536.0;
+      d2 = sin( i*SPI );
+      f2 = (FT_Fixed)(d2*65536.0);
+
+      if ( abs( f2-f1 ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Sin[%3d] = %.7f  sin[%3d] = %.7f\n",
+                (i >> 16), f1/65536.0, (i >> 16), d2 );
+      }
+    }
+  }
+
+
+  static void
+  test_tan( void )
+  {
+    FT_Fixed  f1, f2;
+    double    d1, d2;
+    int       i;
+    
+    for ( i = 0; i < FT_ANGLE_PI2-0x2000000; i += 0x10000 )
+    {
+      f1 = FT_Tan(i);
+      d1 = f1/65536.0;
+      d2 = tan( i*SPI );
+      f2 = (FT_Fixed)(d2*65536.0);
+
+      if ( abs( f2-f1 ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Tan[%3d] = %.7f  tan[%3d] = %.7f\n",
+                (i >> 16), f1/65536.0, (i >> 16), d2 );
+      }
+    }
+  }
+
+
+  static void
+  test_atan2( void )
+  {
+    FT_Fixed  c2, s2;
+    double    l, a, c1, s1;
+    int       i, j;
+    
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      l  = 5.0;
+      a  = i*SPI;
+      
+      c1 = l * cos(a);
+      s1 = l * sin(a);
+      
+      c2 = (FT_Fixed)(c1*65536.0);
+      s2 = (FT_Fixed)(s1*65536.0);
+      
+      j  = FT_Atan2( c2, s2 );
+      if ( j < 0 )
+        j += FT_ANGLE_2PI;
+      
+      if ( abs( i - j ) > 1 )
+      {
+        printf( "FT_Atan2( %.7f, %.7f ) = %.5f, atan = %.5f\n",
+                c2/65536.0, s2/65536.0, j/65536.0, i/65536.0 );
+      }
+    }
+  }
+  
+  static void
+  test_unit( void )
+  {
+    FT_Vector  v;
+    double     a, c1, s1;
+    FT_Fixed   c2, s2;
+    int        i;
+    
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      FT_Vector_Unit( &v, i );
+      a  = ( i*SPI );
+      c1 = cos(a);
+      s1 = sin(a);
+      c2 = (FT_Fixed)(c1*65536.0);
+      s2 = (FT_Fixed)(s1*65536.0);
+      
+      if ( abs( v.x-c2 ) > THRESHOLD ||
+           abs( v.y-s2 ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Vector_Unit[%3d] = ( %.7f, %.7f )  vec = ( %.7f, %.7f )\n",
+                (i >> 16),
+                v.x/65536.0, v.y/65536.0,
+                c1, s1 );
+      }
+    }
+  }
+  
+
+  static void
+  test_length( void )
+  {
+    FT_Vector  v;
+    FT_Fixed   l, l2;
+    int        i;
+    
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      l   = (FT_Fixed)(500.0*65536.0);
+      v.x = (FT_Fixed)( l * cos( i*SPI ) );
+      v.y = (FT_Fixed)( l * sin( i*SPI ) );
+      l2  = FT_Vector_Length( &v );
+      
+      if ( abs( l2-l ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Length( %.7f, %.7f ) = %.5f, length = %.5f\n",
+                v.x/65536.0, v.y/65536.0, l2/65536.0, l/65536.0 );
+      }
+    }
+  }
+
+
+  static void
+  test_rotate( void )
+  {
+    FT_Fixed  c2, s2, c4, s4;
+    FT_Vector v;
+    double    l, ra, a, c1, s1, cra, sra, c3, s3;
+    int       i, j, rotate;
+    
+    for ( rotate = 0; rotate < FT_ANGLE_2PI; rotate += 0x10000 )
+    {
+      ra  = rotate*SPI;
+      cra = cos( ra );
+      sra = sin( ra );
+      
+      for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+      {
+        l  = 500.0;
+        a  = i*SPI;
+        
+        c1 = l * cos(a);
+        s1 = l * sin(a);
+        
+        v.x = c2 = (FT_Fixed)(c1*65536.0);
+        v.y = s2 = (FT_Fixed)(s1*65536.0);
+        
+        FT_Vector_Rotate( &v, rotate );
+        
+        c3 = c1 * cra - s1 * sra;
+        s3 = c1 * sra + s1 * cra;
+        
+        c4 = (FT_Fixed)(c3*65536.0);
+        s4 = (FT_Fixed)(s3*65536.0);
+        
+        if ( abs( c4 - v.x ) > THRESHOLD ||
+             abs( s4 - v.y ) > THRESHOLD )
+        {
+          error = 1;
+          printf( "FT_Rotate( (%.7f,%.7f), %.5f ) = ( %.7f, %.7f ), rot = ( %.7f, %.7f )\n",
+                  c1, s1, ra,
+                  c2/65536.0, s2/65536.0,
+                  c4/65536.0, s4/65536.0 );
+        }
+      }
+    }
+  }
+
+  
+  int main( void )
+  {
+    test_cos();
+    test_sin();
+    test_tan();
+    test_atan2();
+    test_unit();
+    test_length();
+    test_rotate();
+        
+    if (!error)
+      printf( "trigonometry test ok !\n" );
+      
+    return !error;
+  }