kc3-lang/freetype

diff --git a/ChangeLog b/ChangeLog
index c99a258..1a3e29b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,49 @@
+2002-05-21  Roberto Alameda  <ojancano@geekmail.de>.
+
+	* src/type42/t42drivr.c: s/T42_ENCODING_TYPE_/T1_ENCODING_TYPE_/.
+	(parse_font_matrix): Remove unnecessary code.
+	(parse_sfnts): Initialize some variables.
+	(t42_driver_class) [TT_CONFIG_OPTION_BYTECODE_INTERPRETER]: Use
+	ft_module_driver_has_hinter conditionally.
+	Moved some type 42 specific structure definitions to...
+	* include/freetype/internal/t42types.h: New file.
+	* include/freetype/internal/internal.h (FT_INTERNAL_T42_TYPES_H):
+	New macro.
+
+2002-05-20  Werner Lemberg  <wl@gnu.org>
+
+	* include/freetype/cache/ftcsbits.h (FTC_SBit): Added a new field
+	`num_grays' for specifying the number of used gray levels.
+	* src/cache/ftcsbits.c (ftc_sbit_node_load): Initialize it.
+
+2002-05-19  Werner Lemberg  <wl@gnu.org>
+
+	Adding a driver for BDF fonts written by Francesco Zappa Nardelli
+	<Francesco.Zappa.Nardelli@ens.fr>.  Heavily modified by me to
+	better adapt it to FreeType, removing unneeded stuff.  Additionally,
+	it now supports Mark Leisher's BDF extension for anti-aliased
+	bitmap glyphs with 2 and 4 bpp.
+
+	* src/bdf/*: New driver.
+	* include/freetype/internal/bdftypes.h: New file.
+	* include/freetype/internal/fttrace.h: Added BDF driver components.
+	* include/freetype/fterrdef.h: Added error codes for BDF driver.
+	* include/freetype/config/ftmodule.h, src/Jamfile: Updated.
+	* include/freetype/internal/internal.h (FT_INTERNAL_BDF_TYPES_H):
+	New macro.
+
+	* include/freetype/config/ftstdlib.h (ft_sprintf): New alias for
+	sprintf.
+
+2002-05-18  Werner Lemberg  <wl@gnu.org>
+
+	* include/freetype/internal/fttrace.h: Added Type 42 driver
+	component.
+	* src/type42/t42drivr.c: Use it.
+
+	* include/freetype/internal/internal.h (FT_INTERNAL_PCF_TYPES_H):
+	New macro.
+
 2002-05-17  Werner Lemberg  <wl@gnu.org>
 
 	* src/type42/Jamfile: New file.
diff --git a/include/freetype/cache/ftcsbits.h b/include/freetype/cache/ftcsbits.h
index 7c774f9..4e5ab1d 100644
--- a/include/freetype/cache/ftcsbits.h
+++ b/include/freetype/cache/ftcsbits.h
@@ -57,27 +57,29 @@ FT_BEGIN_HEADER
   /*    A very compact structure used to describe a small glyph bitmap.    */
   /*                                                                       */
   /* <Fields>                                                              */
-  /*    width    :: The bitmap width in pixels.                            */
+  /*    width     :: The bitmap width in pixels.                           */
   /*                                                                       */
-  /*    height   :: The bitmap height in pixels.                           */
+  /*    height    :: The bitmap height in pixels.                          */
   /*                                                                       */
-  /*    left     :: The horizontal distance from the pen position to the   */
-  /*                left bitmap border (a.k.a. `left side bearing', or     */
-  /*                `lsb').                                                */
+  /*    left      :: The horizontal distance from the pen position to the  */
+  /*                 left bitmap border (a.k.a. `left side bearing', or    */
+  /*                 `lsb').                                               */
   /*                                                                       */
-  /*    top      :: The vertical distance from the pen position (on the    */
-  /*                baseline) to the upper bitmap border (a.k.a. `top side */
-  /*                bearing').  The distance is positive for upwards       */
-  /*                Y coordinates.                                         */
+  /*    top       :: The vertical distance from the pen position (on the   */
+  /*                 baseline) to the upper bitmap border (a.k.a. `top     */
+  /*                 side bearing').  The distance is positive for upwards */
+  /*                 Y coordinates.                                        */
   /*                                                                       */
-  /*    format   :: The format of the glyph bitmap (monochrome or gray).   */
+  /*    format    :: The format of the glyph bitmap (monochrome or gray).  */
   /*                                                                       */
-  /*    pitch    :: The number of bytes per bitmap line.  May be positive  */
-  /*                or negative.                                           */
+  /*    num_grays :: The number of gray levels.                            */
   /*                                                                       */
-  /*    xadvance :: The horizontal advance width in pixels.                */
+  /*    pitch     :: The number of bytes per bitmap line.  May be positive */
+  /*                 or negative.                                          */
   /*                                                                       */
-  /*    yadvance :: The vertical advance height in pixels.                 */
+  /*    xadvance  :: The horizontal advance width in pixels.               */
+  /*                                                                       */
+  /*    yadvance  :: The vertical advance height in pixels.                */
   /*                                                                       */
   /*    buffer   :: A pointer to the bitmap pixels.                        */
   /*                                                                       */
@@ -89,6 +91,7 @@ FT_BEGIN_HEADER
     FT_Char   top;
 
     FT_Byte   format;
+    FT_Short  num_grays;    /* XXX: Should be FT_Byte.  See ftcsbits.c */
     FT_Char   pitch;
     FT_Char   xadvance;
     FT_Char   yadvance;
diff --git a/include/freetype/config/ftmodule.h b/include/freetype/config/ftmodule.h
index d4b3b71..589e920 100644
--- a/include/freetype/config/ftmodule.h
+++ b/include/freetype/config/ftmodule.h
@@ -2,6 +2,7 @@ FT_USE_MODULE(autohint_module_class)
 FT_USE_MODULE(cff_driver_class)
 FT_USE_MODULE(t1cid_driver_class)
 FT_USE_MODULE(pcf_driver_class)
+FT_USE_MODULE(bdf_driver_class)
 FT_USE_MODULE(psaux_module_class)
 FT_USE_MODULE(psnames_module_class)
 FT_USE_MODULE(pshinter_module_class)
@@ -13,4 +14,3 @@ FT_USE_MODULE(t1_driver_class)
 FT_USE_MODULE(t42_driver_class)
 FT_USE_MODULE(pfr_driver_class)
 FT_USE_MODULE(winfnt_driver_class)
-
diff --git a/include/freetype/config/ftstdlib.h b/include/freetype/config/ftstdlib.h
index a2a678d..6c06091 100644
--- a/include/freetype/config/ftstdlib.h
+++ b/include/freetype/config/ftstdlib.h
@@ -91,6 +91,10 @@
 #define ft_memmove  memmove
 #define ft_memcmp   memcmp
 
+#include <stdio.h>
+
+#define ft_sprintf  sprintf
+
 
   /**********************************************************************/
   /*                                                                    */
diff --git a/include/freetype/fterrdef.h b/include/freetype/fterrdef.h
index ee126b9..4ef606d 100644
--- a/include/freetype/fterrdef.h
+++ b/include/freetype/fterrdef.h
@@ -35,19 +35,19 @@
                   "no error" )
 
   FT_ERRORDEF_( Cannot_Open_Resource,                        0x01, \
-               "cannot open resource" )
+                "cannot open resource" )
   FT_ERRORDEF_( Unknown_File_Format,                         0x02, \
-               "unknown file format" )
+                "unknown file format" )
   FT_ERRORDEF_( Invalid_File_Format,                         0x03, \
-               "broken file" )
+                "broken file" )
   FT_ERRORDEF_( Invalid_Version,                             0x04, \
-               "invalid FreeType version" )
+                "invalid FreeType version" )
   FT_ERRORDEF_( Lower_Module_Version,                        0x05, \
-               "module version is too low" )
+                "module version is too low" )
   FT_ERRORDEF_( Invalid_Argument,                            0x06, \
-               "invalid argument" )
+                "invalid argument" )
   FT_ERRORDEF_( Unimplemented_Feature,                       0x07, \
-               "unimplemented feature" )
+                "unimplemented feature" )
   FT_ERRORDEF_( Invalid_Table,                               0x08, \
                 "broken table" )
   FT_ERRORDEF_( Invalid_Offset,                              0x09, \
@@ -56,158 +56,174 @@
   /* glyph/character errors */
 
   FT_ERRORDEF_( Invalid_Glyph_Index,                         0x10, \
-               "invalid glyph index" )
+                "invalid glyph index" )
   FT_ERRORDEF_( Invalid_Character_Code,                      0x11, \
-               "invalid character code" )
+                "invalid character code" )
   FT_ERRORDEF_( Invalid_Glyph_Format,                        0x12, \
-               "unsupported glyph image format" )
+                "unsupported glyph image format" )
   FT_ERRORDEF_( Cannot_Render_Glyph,                         0x13, \
-               "cannot render this glyph format" )
+                "cannot render this glyph format" )
   FT_ERRORDEF_( Invalid_Outline,                             0x14, \
-               "invalid outline" )
+                "invalid outline" )
   FT_ERRORDEF_( Invalid_Composite,                           0x15, \
-               "invalid composite glyph" )
+                "invalid composite glyph" )
   FT_ERRORDEF_( Too_Many_Hints,                              0x16, \
-               "too many hints" )
+                "too many hints" )
   FT_ERRORDEF_( Invalid_Pixel_Size,                          0x17, \
-               "invalid pixel size" )
+                "invalid pixel size" )
 
   /* handle errors */
 
   FT_ERRORDEF_( Invalid_Handle,                              0x20, \
-               "invalid object handle" )
+                "invalid object handle" )
   FT_ERRORDEF_( Invalid_Library_Handle,                      0x21, \
-               "invalid library handle" )
+                "invalid library handle" )
   FT_ERRORDEF_( Invalid_Driver_Handle,                       0x22, \
-               "invalid module handle" )
+                "invalid module handle" )
   FT_ERRORDEF_( Invalid_Face_Handle,                         0x23, \
-               "invalid face handle" )
+                "invalid face handle" )
   FT_ERRORDEF_( Invalid_Size_Handle,                         0x24, \
-               "invalid size handle" )
+                "invalid size handle" )
   FT_ERRORDEF_( Invalid_Slot_Handle,                         0x25, \
-               "invalid glyph slot handle" )
+                "invalid glyph slot handle" )
   FT_ERRORDEF_( Invalid_CharMap_Handle,                      0x26, \
-               "invalid charmap handle" )
+                "invalid charmap handle" )
   FT_ERRORDEF_( Invalid_Cache_Handle,                        0x27, \
-               "invalid cache manager handle" )
+                "invalid cache manager handle" )
   FT_ERRORDEF_( Invalid_Stream_Handle,                       0x28, \
-               "invalid stream handle" )
+                "invalid stream handle" )
 
   /* driver errors */
 
   FT_ERRORDEF_( Too_Many_Drivers,                            0x30, \
-               "too many modules" )
+                "too many modules" )
   FT_ERRORDEF_( Too_Many_Extensions,                         0x31, \
-               "too many extensions" )
+                "too many extensions" )
 
   /* memory errors */
 
   FT_ERRORDEF_( Out_Of_Memory,                               0x40, \
-               "out of memory" )
+                "out of memory" )
   FT_ERRORDEF_( Unlisted_Object,                             0x41, \
-               "unlisted object" )
+                "unlisted object" )
 
   /* stream errors */
 
   FT_ERRORDEF_( Cannot_Open_Stream,                          0x51, \
-               "cannot open stream" )
+                "cannot open stream" )
   FT_ERRORDEF_( Invalid_Stream_Seek,                         0x52, \
-               "invalid stream seek" )
+                "invalid stream seek" )
   FT_ERRORDEF_( Invalid_Stream_Skip,                         0x53, \
-               "invalid stream skip" )
+                "invalid stream skip" )
   FT_ERRORDEF_( Invalid_Stream_Read,                         0x54, \
-               "invalid stream read" )
+                "invalid stream read" )
   FT_ERRORDEF_( Invalid_Stream_Operation,                    0x55, \
-               "invalid stream operation" )
+                "invalid stream operation" )
   FT_ERRORDEF_( Invalid_Frame_Operation,                     0x56, \
-               "invalid frame operation" )
+                "invalid frame operation" )
   FT_ERRORDEF_( Nested_Frame_Access,                         0x57, \
-               "nested frame access" )
+                "nested frame access" )
   FT_ERRORDEF_( Invalid_Frame_Read,                          0x58, \
-               "invalid frame read" )
+                "invalid frame read" )
 
   /* raster errors */
 
   FT_ERRORDEF_( Raster_Uninitialized,                        0x60, \
-               "raster uninitialized" )
+                "raster uninitialized" )
   FT_ERRORDEF_( Raster_Corrupted,                            0x61, \
-               "raster corrupted" )
+                "raster corrupted" )
   FT_ERRORDEF_( Raster_Overflow,                             0x62, \
-               "raster overflow" )
+                "raster overflow" )
   FT_ERRORDEF_( Raster_Negative_Height,                      0x63, \
-               "negative height while rastering" )
+                "negative height while rastering" )
 
   /* cache errors */
 
   FT_ERRORDEF_( Too_Many_Caches,                             0x70, \
-               "too many registered caches" )
+                "too many registered caches" )
 
   /* TrueType and SFNT errors */
 
   FT_ERRORDEF_( Invalid_Opcode,                              0x80, \
-               "invalid opcode" )
+                "invalid opcode" )
   FT_ERRORDEF_( Too_Few_Arguments,                           0x81, \
-               "too few arguments" )
+                "too few arguments" )
   FT_ERRORDEF_( Stack_Overflow,                              0x82, \
-               "stack overflow" )
+                "stack overflow" )
   FT_ERRORDEF_( Code_Overflow,                               0x83, \
-               "code overflow" )
+                "code overflow" )
   FT_ERRORDEF_( Bad_Argument,                                0x84, \
-               "bad argument" )
+                "bad argument" )
   FT_ERRORDEF_( Divide_By_Zero,                              0x85, \
-               "division by zero" )
+                "division by zero" )
   FT_ERRORDEF_( Invalid_Reference,                           0x86, \
-               "invalid reference" )
+                "invalid reference" )
   FT_ERRORDEF_( Debug_OpCode,                                0x87, \
-               "found debug opcode" )
+                "found debug opcode" )
   FT_ERRORDEF_( ENDF_In_Exec_Stream,                         0x88, \
-               "found ENDF opcode in execution stream" )
+                "found ENDF opcode in execution stream" )
   FT_ERRORDEF_( Nested_DEFS,                                 0x89, \
-               "nested DEFS" )
+                "nested DEFS" )
   FT_ERRORDEF_( Invalid_CodeRange,                           0x8A, \
-               "invalid code range" )
+                "invalid code range" )
   FT_ERRORDEF_( Execution_Too_Long,                          0x8B, \
-               "execution context too long" )
+                "execution context too long" )
   FT_ERRORDEF_( Too_Many_Function_Defs,                      0x8C, \
-               "too many function definitions" )
+                "too many function definitions" )
   FT_ERRORDEF_( Too_Many_Instruction_Defs,                   0x8D, \
-               "too many instruction definitions" )
+                "too many instruction definitions" )
   FT_ERRORDEF_( Table_Missing,                               0x8E, \
-               "SFNT font table missing" )
+                "SFNT font table missing" )
   FT_ERRORDEF_( Horiz_Header_Missing,                        0x8F, \
-               "horizontal header (hhea) table missing" )
+                "horizontal header (hhea) table missing" )
   FT_ERRORDEF_( Locations_Missing,                           0x90, \
-               "locations (loca) table missing" )
+                "locations (loca) table missing" )
   FT_ERRORDEF_( Name_Table_Missing,                          0x91, \
-               "name table missing" )
+                "name table missing" )
   FT_ERRORDEF_( CMap_Table_Missing,                          0x92, \
-               "character map (cmap) table missing" )
+                "character map (cmap) table missing" )
   FT_ERRORDEF_( Hmtx_Table_Missing,                          0x93, \
-               "horizontal metrics (hmtx) table missing" )
+                "horizontal metrics (hmtx) table missing" )
   FT_ERRORDEF_( Post_Table_Missing,                          0x94, \
-               "PostScript (post) table missing" )
+                "PostScript (post) table missing" )
   FT_ERRORDEF_( Invalid_Horiz_Metrics,                       0x95, \
-               "invalid horizontal metrics" )
+                "invalid horizontal metrics" )
   FT_ERRORDEF_( Invalid_CharMap_Format,                      0x96, \
-               "invalid character map (cmap) format" )
+                "invalid character map (cmap) format" )
   FT_ERRORDEF_( Invalid_PPem,                                0x97, \
-               "invalid ppem value" )
+                "invalid ppem value" )
   FT_ERRORDEF_( Invalid_Vert_Metrics,                        0x98, \
-               "invalid vertical metrics" )
+                "invalid vertical metrics" )
   FT_ERRORDEF_( Could_Not_Find_Context,                      0x99, \
-               "could not find context" )
+                "could not find context" )
   FT_ERRORDEF_( Invalid_Post_Table_Format,                   0x9A, \
-               "invalid PostScript (post) table format" )
+                "invalid PostScript (post) table format" )
   FT_ERRORDEF_( Invalid_Post_Table,                          0x9B, \
-               "invalid PostScript (post) table" )
+                "invalid PostScript (post) table" )
 
   /* CFF, CID, and Type 1 errors */
 
   FT_ERRORDEF_( Syntax_Error,                                0xA0, \
-               "opcode syntax error" )
+                "opcode syntax error" )
   FT_ERRORDEF_( Stack_Underflow,                             0xA1, \
-               "argument stack underflow" )
-
+                "argument stack underflow" )
+
+  /* BDF errors */
+
+  FT_ERRORDEF_( Missing_Startfont_Field,                     0xB0, \
+                "`STARTFONT' field missing" )
+  FT_ERRORDEF_( Missing_Font_Field,                          0xB1, \
+                "`FONT' field missing" )
+  FT_ERRORDEF_( Missing_Size_Field,                          0xB2, \
+                "`SIZE' field missing" )
+  FT_ERRORDEF_( Missing_Chars_Field,                         0xB3, \
+                "`CHARS' field missing" )
+  FT_ERRORDEF_( Missing_Startchar_Field,                     0xB4, \
+                "`STARTCHAR' field missing" )
+  FT_ERRORDEF_( Missing_Encoding_Field,                      0xB5, \
+                "`ENCODING' field missing" )
+  FT_ERRORDEF_( Missing_Bbx_Field,                           0xB6, \
+                "`BBX' field missing" )
 
 
 /* END */
diff --git a/include/freetype/internal/bdftypes.h b/include/freetype/internal/bdftypes.h
new file mode 100644
index 0000000..cd4dcab
--- /dev/null
+++ b/include/freetype/internal/bdftypes.h
@@ -0,0 +1,53 @@
+/*  bdftypes.h
+
+  FreeType font driver for bdf fonts
+
+  Copyright (C) 2001, 2002 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef __BDFTYPES_H__
+#define __BDFTYPES_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  BDF_Public_FaceRec_
+  {
+    FT_FaceRec  root;
+
+    char*       charset_encoding;
+    char*       charset_registry;
+
+  } BDF_Public_FaceRec, *BDF_Public_Face;
+
+
+FT_END_HEADER
+
+
+#endif  /* __BDFTYPES_H__ */
+
+
+/* END */
diff --git a/include/freetype/internal/fttrace.h b/include/freetype/internal/fttrace.h
index a0c9344..ffc0b14 100644
--- a/include/freetype/internal/fttrace.h
+++ b/include/freetype/internal/fttrace.h
@@ -77,6 +77,9 @@ FT_TRACE_DEF( cffload )
 FT_TRACE_DEF( cffobjs )
 FT_TRACE_DEF( cffparse )
 
+/* Type 42 driver component */
+FT_TRACE_DEF( t42 )
+
 /* CID driver components */
 FT_TRACE_DEF( cidafm )
 FT_TRACE_DEF( ciddriver )
@@ -88,14 +91,16 @@ FT_TRACE_DEF( cidparse )
 /* Windows fonts component */
 FT_TRACE_DEF( winfnt )
 
-/* PCF fonts component */
+/* PCF fonts components */
 FT_TRACE_DEF( pcfdriver )
 FT_TRACE_DEF( pcfread )
 
 /* BDF fonts component */
-FT_TRACE_DEF( bdf )
+FT_TRACE_DEF( bdfdriver )
+FT_TRACE_DEF( bdflib )
 
 /* PFR fonts component */
 FT_TRACE_DEF( pfr )
 
+
 /* END */
diff --git a/include/freetype/internal/internal.h b/include/freetype/internal/internal.h
index 3d42383..cfae960 100644
--- a/include/freetype/internal/internal.h
+++ b/include/freetype/internal/internal.h
@@ -38,8 +38,11 @@
 
 #define FT_INTERNAL_TRUETYPE_TYPES_H      <freetype/internal/tttypes.h>
 #define FT_INTERNAL_TYPE1_TYPES_H         <freetype/internal/t1types.h>
+#define FT_INTERNAL_TYPE42_TYPES_H        <freetype/internal/t42types.h>
 #define FT_INTERNAL_CFF_TYPES_H           <freetype/internal/cfftypes.h>
 #define FT_INTERNAL_FNT_TYPES_H           <freetype/internal/fnttypes.h>
+#define FT_INTERNAL_BDF_TYPES_H           <freetype/internal/bdftypes.h>
+#define FT_INTERNAL_PCF_TYPES_H           <freetype/internal/pcftypes.h>
 
 #define FT_INTERNAL_POSTSCRIPT_NAMES_H    <freetype/internal/psnames.h>
 #define FT_INTERNAL_POSTSCRIPT_AUX_H      <freetype/internal/psaux.h>
diff --git a/include/freetype/internal/t1types.h b/include/freetype/internal/t1types.h
index 6a14f30..2625394 100644
--- a/include/freetype/internal/t1types.h
+++ b/include/freetype/internal/t1types.h
@@ -21,7 +21,7 @@
 #define __T1TYPES_H__
 
 
-#include<ft2build.h>
+#include <ft2build.h>
 #include FT_TYPE1_TABLES_H
 #include FT_INTERNAL_POSTSCRIPT_NAMES_H
 #include FT_INTERNAL_POSTSCRIPT_HINTS_H
diff --git a/include/freetype/internal/t42types.h b/include/freetype/internal/t42types.h
new file mode 100644
index 0000000..aa728bf
--- /dev/null
+++ b/include/freetype/internal/t42types.h
@@ -0,0 +1,85 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42types.h                                                             */
+/*                                                                         */
+/*    Type 42 font data types (specification only).                        */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42TYPES_H__
+#define __T42TYPES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TYPE1_TABLES_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  T42_FontRec_ 
+  {
+    /* font info dictionary */
+    PS_FontInfoRec   font_info; 
+
+    /* top-level dictionary */
+    FT_String*       font_name;
+
+    T1_EncodingType  encoding_type; 
+    T1_EncodingRec   encoding;
+
+    FT_Byte*         charstrings_block;
+    FT_Byte*         glyph_names_block;
+
+    FT_Int           num_glyphs;
+    FT_String**      glyph_names;       /* array of glyph names       */
+    FT_Byte**        charstrings;       /* array of glyph charstrings */
+    FT_Int*          charstrings_len;
+
+    FT_Byte          paint_type;
+    FT_Byte          font_type;
+    FT_Matrix        font_matrix; /* From FontMatrix field: a, b, c, d */
+    FT_Vector        font_offset; /* From FontMatrix field: tx, ty */
+    FT_BBox          font_bbox;
+
+    FT_Int           stroke_width;  
+
+  } T42_FontRec, *T42_Font;
+
+
+  typedef struct  T42_FaceRec_
+  {
+    FT_FaceRec     root;
+    T42_FontRec    type42;
+    const void*    psnames;
+    const void*    psaux;
+    const void*    afm_data;
+    FT_Byte*       ttf_data;
+    FT_ULong       ttf_size;
+    FT_Face        ttf_face;
+    FT_CharMapRec  charmaprecs[2];
+    FT_CharMap     charmaps[2];
+    PS_Unicodes    unicode_map;
+
+  } T42_FaceRec, *T42_Face;
+
+
+FT_END_HEADER
+
+#endif /* __T1TYPES_H__ */
+
+
+/* END */
diff --git a/src/Jamfile b/src/Jamfile
index 9192c7e..f867695 100644
--- a/src/Jamfile
+++ b/src/Jamfile
@@ -14,7 +14,6 @@ SubDirHdrs  [ FT2_SubDir  src ] ;
 #
 HDRMACRO  [ FT2_SubDir  include internal internal.h ] ;
 
-SubInclude  FT2_TOP src pshinter ;
 SubInclude  FT2_TOP src autohint ;
 SubInclude  FT2_TOP src base ;
 SubInclude  FT2_TOP src bdf ;
@@ -24,6 +23,7 @@ SubInclude  FT2_TOP src cid ;
 SubInclude  FT2_TOP src pcf ;
 SubInclude  FT2_TOP src pfr ;
 SubInclude  FT2_TOP src psaux ;
+SubInclude  FT2_TOP src pshinter ;
 SubInclude  FT2_TOP src psnames ;
 SubInclude  FT2_TOP src raster ;
 SubInclude  FT2_TOP src sfnt ;
diff --git a/src/bdf/Jamfile b/src/bdf/Jamfile
new file mode 100644
index 0000000..6fe3a7e
--- /dev/null
+++ b/src/bdf/Jamfile
@@ -0,0 +1,23 @@
+# FreeType 2 src/bdf Jamfile (c) 2002 David Turner
+#
+
+SubDir  FT2_TOP src bdf ;
+
+SubDirHdrs  [ FT2_SubDir  src bdf ] ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = bdfdrivr bdflib ;
+  }
+  else
+  {
+    _sources = bdf ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/bdf Jamfile
diff --git a/src/bdf/README b/src/bdf/README
new file mode 100644
index 0000000..7f7c514
--- /dev/null
+++ b/src/bdf/README
@@ -0,0 +1,146 @@
+                  FreeType font driver for BDF fonts
+
+                       Francesco Zappa Nardelli
+                  <francesco.zappa.nardelli@ens.fr>
+
+
+Introduction
+************
+
+BDF (Bitmap Distribution Format) is a bitmap font format defined by Adobe,
+which is intended to be easily understood by both humans and computers. 
+This code implements a BDF driver for the FreeType library, following the
+Adobe Specification V 2.2.  The specification of the BDF font format is
+available from Adobe's web site:
+
+  http://partners.adobe.com/asn/developer/PDFS/TN/5005.BDF_Spec.pdf
+
+Many good bitmap fonts in bdf format come with XFree86 (www.XFree86.org). 
+They do not define vertical metrics, because the X Consortium BDF
+specification has removed them.
+
+
+Encodings
+*********
+
+The variety of encodings that accompanies bdf fonts appears to encompass the
+small set defined in freetype.h.  On the other hand, two properties that
+specify encoding and registry are usually defined in bdf fonts.
+
+I decided to make these two properties directly accessible, leaving to the
+client application the work of interpreting them.  For instance:
+
+
+  #include FT_INTERNAL_BDF_TYPES_H
+
+  FT_Face          face;
+  BDF_Public_Face  bdfface;
+
+
+  FT_New_Face( library, ..., &face );
+
+  bdfface = (BDF_Public_Face)face;
+  
+  if ( ( bdfface->charset_registry == "ISO10646" ) && 
+       ( bdfface->charset_encoding == "1" )        )
+    [..]
+
+
+Thus the driver always exports `ft_encoding_none' as face->charmap.encoding. 
+FT_Get_Char_Index's behavior is unmodified, that is, it converts the ULong
+value given as argument into the corresponding glyph number.
+
+If the two properties are not available, Adobe Standard Encoding should be
+assumed.
+
+
+Anti-Aliased Bitmaps
+********************
+
+The driver supports an extension to the BDF format as used in Mark Leisher's
+xmbdfed bitmap font editor.  It introduces a fourth field to the `SIZE'
+keyword which gives the bpp value (bits per pixel) of the glyph data in the
+font.  Possible values are 1 (the default), 2 (four gray levels), and 4 (16
+gray levels).  The driver returns either a bitmap with 1 bit per pixel or a
+pixmap with 8bits per pixel (using 4 and 16 gray levels, respectively).
+
+
+Known problems
+**************
+
+- A font is entirely loaded into memory.  Obviously, this is not the Right
+  Thing(TM).  If you have big fonts I suggest you convert them into PCF
+  format (using the bdftopcf utility): the PCF font drive of FreeType can
+  perform incremental glyph loading.
+
+When I have some time, I will implement on-demand glyph parsing.
+
+- Except for encodings properties, client applications have no visibility of
+  the PCF_Face object.  This means that applications cannot directly access
+  font tables and must trust FreeType.
+
+- Currently, glyph names are ignored.
+
+  I plan to give full visibility of the BDF_Face object in an upcoming
+  revision of the driver, thus implementing also glyph names.
+
+- As I have never seen a BDF font that defines vertical metrics, vertical
+  metrics are (parsed and) discarded.  If you own a BDF font that defines
+  vertical metrics, please let me know (I will implement them in 5-10
+  minutes).
+
+
+License
+*******
+
+Copyright (C) 2001-2002 by Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*** Portions of the driver (that is, bdflib.c and bdf.h):
+
+Copyright 2000 Computing Research Labs, New Mexico State University
+Copyright 2001-2002 Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Credits
+*******
+
+This driver is based on excellent Mark Leisher's bdf library.  If you
+find something good in this driver you should probably thank him, not
+me.
diff --git a/src/bdf/bdf.c b/src/bdf/bdf.c
index 6c308be..9c82885 100644
--- a/src/bdf/bdf.c
+++ b/src/bdf/bdf.c
@@ -2,7 +2,7 @@
 
     FreeType font driver for bdf files
 
-    Copyright (C) 2001 by
+    Copyright (C) 2001, 2002 by
     Francesco Zappa Nardelli 
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 #include <ft2build.h>
 #include "bdflib.c"
-#include "bdfdriver.c"
+#include "bdfdrivr.c"
+
 
 /* END */
diff --git a/src/bdf/bdf.h b/src/bdf/bdf.h
index 0ba587e..6a4bb82 100644
--- a/src/bdf/bdf.h
+++ b/src/bdf/bdf.h
@@ -1,6 +1,6 @@
 /*
  * Copyright 2000 Computing Research Labs, New Mexico State University
- * Copyright 2001 Francesco Zappa Nardelli
+ * Copyright 2001, 2002 Francesco Zappa Nardelli
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -20,348 +20,276 @@
  * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+
+
 #ifndef __BDF_H__
 #define __BDF_H__
 
+
 /*
- * $Id$
+ * Based on bdf.h,v 1.16 2000/03/16 20:08:51 mleisher
  */
 
-#include <string.h>
-
 #include <ft2build.h>
 #include FT_INTERNAL_OBJECTS_H
 #include FT_INTERNAL_STREAM_H
 
 
 FT_BEGIN_HEADER
-/* Imported from bdfP.h */
 
-#ifndef MYABS
-#define MYABS(xx) ((xx) < 0 ? -(xx) : (xx))
-#endif
 
-#define _bdf_glyph_modified(map, e) ((map)[(e) >> 5] & (1 << ((e) & 31)))
-#define _bdf_set_glyph_modified(map, e) (map)[(e) >> 5] |= (1 << ((e) & 31))
-#define _bdf_clear_glyph_modified(map, e) (map)[(e) >> 5] &= ~(1 << ((e) & 31))
+/* Imported from bdfP.h */
+
+#define _bdf_glyph_modified( map, e )                 \
+          ( (map)[(e) >> 5] & ( 1 << ( (e) & 31 ) ) )
+#define _bdf_set_glyph_modified( map, e )              \
+          ( (map)[(e) >> 5] |= ( 1 << ( (e) & 31 ) ) )
+#define _bdf_clear_glyph_modified( map, e )             \
+          ( (map)[(e) >> 5] &= ~( 1 << ( (e) & 31 ) ) )
 
 /* end of bdfP.h */
 
-/**************************************************************************
- *
- * BDF font options macros and types.
- *
- **************************************************************************/
-
-#define BDF_UNIX_EOL 1           /* Save fonts with Unix LF.              */
-#define BDF_DOS_EOL  2           /* Save fonts with DOS CRLF.             */
-#define BDF_MAC_EOL  3           /* Save fonts with Mac CR.               */
-
-#define BDF_CORRECT_METRICS 0x01 /* Correct invalid metrics when loading. */
-#define BDF_KEEP_COMMENTS   0x02 /* Preserve the font comments.           */
-#define BDF_KEEP_UNENCODED  0x04 /* Keep the unencoded glyphs.            */
-#define BDF_PROPORTIONAL    0x08 /* Font has proportional spacing.        */
-#define BDF_MONOWIDTH       0x10 /* Font has mono width.                  */
-#define BDF_CHARCELL        0x20 /* Font has charcell spacing.            */
-
-#define BDF_ALL_SPACING (BDF_PROPORTIONAL|BDF_MONOWIDTH|BDF_CHARCELL)
-
-#define BDF_DEFAULT_LOAD_OPTIONS \
-    (BDF_CORRECT_METRICS|BDF_KEEP_COMMENTS|BDF_KEEP_UNENCODED|BDF_PROPORTIONAL)
-
-typedef struct {
-    int ttf_hint;
-    int correct_metrics;
-    int keep_unencoded;
-    int keep_comments;
-    int pad_cells;
-    int font_spacing;
-    long point_size;
-    unsigned long resolution_x;
-    unsigned long resolution_y;
-    int bits_per_pixel;
-    int eol;
-} bdf_options_t;
 
-/*
- * Callback function type for unknown configuration options.
- */
-typedef int (*bdf_options_callback_t) (bdf_options_t *opts,
-                                          char **params,
-                                          unsigned long nparams,
-                                          void *client_data);
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font options macros and types.                                    */
+  /*                                                                       */
+  /*************************************************************************/
 
-/**************************************************************************
- *
- * BDF font property macros and types.
- *
- **************************************************************************/
 
-#define BDF_ATOM     1
-#define BDF_INTEGER  2
-#define BDF_CARDINAL 3
+#define BDF_CORRECT_METRICS  0x01 /* Correct invalid metrics when loading. */
+#define BDF_KEEP_COMMENTS    0x02 /* Preserve the font comments.           */
+#define BDF_KEEP_UNENCODED   0x04 /* Keep the unencoded glyphs.            */
+#define BDF_PROPORTIONAL     0x08 /* Font has proportional spacing.        */
+#define BDF_MONOWIDTH        0x10 /* Font has mono width.                  */
+#define BDF_CHARCELL         0x20 /* Font has charcell spacing.            */
 
-/*
- * This structure represents a particular property of a font.
- * There are a set of defaults and each font has their own.
- */
-typedef struct {
-    char *name;         /* Name of the property.                        */
-    int format;         /* Format of the property.                      */
-    int builtin;        /* A builtin property.                          */
-    union {
-        char *atom;
-        long int32;
-        unsigned long card32;
-    } value;            /* Value of the property.                       */
-} bdf_property_t;
-
-/**************************************************************************
- *
- * BDF font metric and glyph types.
- *
- **************************************************************************/
+#define BDF_ALL_SPACING  ( BDF_PROPORTIONAL | \
+                           BDF_MONOWIDTH    | \
+                           BDF_CHARCELL     )
 
-/*
- * A general bitmap type, mostly used when the glyph bitmap is being edited.
- */
-typedef struct {
-    short x;
-    short y;
-    unsigned short width;
-    unsigned short height;
-    unsigned short bpp;
-    unsigned short pad;
-    unsigned char *bitmap;
-    unsigned long bytes;
-} bdf_bitmap_t;
-
-typedef struct {
-    int font_spacing;
-    unsigned short swidth;
-    unsigned short dwidth;
-    unsigned short width;
-    unsigned short height;
-    short x_offset;
-    short y_offset;
-    short ascent;
-    short descent;
-} bdf_metrics_t;
-
-typedef struct {
-    unsigned short width;
-    unsigned short height;
-    short x_offset;
-    short y_offset;
-    short ascent;
-    short descent;
-} bdf_bbx_t;
-
-typedef struct {
-    char *name;                 /* Glyph name.                          */
-    long encoding;              /* Glyph encoding.                      */
-    unsigned short swidth;      /* Scalable width.                      */
-    unsigned short dwidth;      /* Device width.                        */
-    bdf_bbx_t bbx;              /* Glyph bounding box.                  */
-    unsigned char *bitmap;      /* Glyph bitmap.                        */
-    unsigned short bytes;       /* Number of bytes used for the bitmap. */
-} bdf_glyph_t;
-
-typedef struct {
-    char *key;
-    void *data;
-} _hashnode, *hashnode;
-
-typedef struct {
-    int limit;
-    int size;
-    int used;
-    hashnode *table;
-} hashtable;
-
-typedef struct {
-    unsigned short pad;         /* Pad to 4-byte boundary.              */
-    unsigned short bpp;         /* Bits per pixel.                      */
-    long start;                 /* Beginning encoding value of glyphs.  */
-    long end;                   /* Ending encoding value of glyphs.     */
-    bdf_glyph_t *glyphs;        /* Glyphs themselves.                   */
-    unsigned long glyphs_size;  /* Glyph structures allocated.          */
-    unsigned long glyphs_used;  /* Glyph structures used.               */
-    bdf_bbx_t bbx;              /* Overall bounding box of glyphs.      */
-} bdf_glyphlist_t;
-
-typedef struct {
-    char *name;                 /* Name of the font.                     */
-    bdf_bbx_t bbx;              /* Font bounding box.                    */
-
-    long point_size;            /* Point size of the font.               */
-    unsigned long resolution_x; /* Font horizontal resolution.           */
-    unsigned long resolution_y; /* Font vertical resolution.             */
-
-    int hbf;                    /* Font came from an HBF font.           */
-
-    int spacing;                /* Font spacing value.                   */
-
-    unsigned short monowidth;   /* Logical width for monowidth font.     */
-
-    long default_glyph;         /* Encoding of the default glyph.        */
-
-    long font_ascent;           /* Font ascent.                          */
-    long font_descent;          /* Font descent.                         */
-
-    long glyphs_size;           /* Glyph structures allocated.           */
-    long glyphs_used;           /* Glyph structures used.                */
-    bdf_glyph_t *glyphs;        /* Glyphs themselves.                    */
-
-    long unencoded_size;        /* Unencoded glyph structures allocated. */
-    long unencoded_used;        /* Unencoded glyph structures used.      */
-    bdf_glyph_t *unencoded;     /* Unencoded glyphs themselves.          */
-
-    unsigned long props_size;   /* Font properties allocated.            */
-    unsigned long props_used;   /* Font properties used.                 */
-    bdf_property_t *props;      /* Font properties themselves.           */
-
-    char *comments;             /* Font comments.                        */
-    unsigned long comments_len; /* Length of comment string.             */
-
-    char *acmsgs;               /* Auto-correction messages.             */
-    unsigned long acmsgs_len;   /* Length of auto-correction messages.   */
-
-    bdf_glyphlist_t overflow;   /* Storage used for glyph insertion.     */
-
-    void *internal;             /* Internal data for the font.           */
-
-    unsigned long nmod[2048];   /* Bitmap indicating modified glyphs.    */
-    unsigned long umod[2048];   /* Bitmap indicating modified unencoded. */
-
-    unsigned short modified;    /* Boolean indicating font modified.     */
-    unsigned short bpp;         /* Bits per pixel.                       */
-
-  FT_Memory memory;
-  bdf_property_t *user_props;
-  unsigned long nuser_props;
-  hashtable proptbl;
-
-} bdf_font_t;
+#define BDF_DEFAULT_LOAD_OPTIONS  ( BDF_CORRECT_METRICS | \
+                                    BDF_KEEP_COMMENTS   | \
+                                    BDF_KEEP_UNENCODED  | \
+                                    BDF_PROPORTIONAL    )
 
 
-/**************************************************************************
- *
- * Types for load/save callbacks.
- *
- **************************************************************************/
+  typedef struct  bdf_options_t_
+  {
+    int            correct_metrics;
+    int            keep_unencoded;
+    int            keep_comments;
+    int            font_spacing;
 
-/*
- * Callback reasons.
- */
-#define BDF_LOAD_START       1
-#define BDF_LOADING          2
-#define BDF_SAVE_START       3
-#define BDF_SAVING           4
-#define BDF_TRANSLATE_START  5
-#define BDF_TRANSLATING      6
-#define BDF_ROTATE_START     7
-#define BDF_ROTATING         8
-#define BDF_SHEAR_START      9
-#define BDF_SHEARING         10
-#define BDF_GLYPH_NAME_START 11
-#define BDF_GLYPH_NAME       12
-#define BDF_EXPORT_START     13
-#define BDF_EXPORTING        14
-#define BDF_EMBOLDEN_START   15
-#define BDF_EMBOLDENING      16
-#define BDF_WARNING          20
-#define BDF_ERROR            21
+  } bdf_options_t;
 
-/*
- * Error codes.
- */
-#define BDF_OK                 0
-#define BDF_MISSING_START     -1
-#define BDF_MISSING_FONTNAME  -2
-#define BDF_MISSING_SIZE      -3
-#define BDF_MISSING_FONTBBX   -4
-#define BDF_MISSING_CHARS     -5
-#define BDF_MISSING_STARTCHAR -6
-#define BDF_MISSING_ENCODING  -7
-#define BDF_MISSING_BBX       -8
-
-#define BDF_NOT_CONSOLE_FONT  -10
-#define BDF_NOT_MF_FONT       -11
-#define BDF_NOT_PSF_FONT      -12
-
-#define BDF_OUT_OF_MEMORY     -20
-
-#define BDF_EMPTY_FONT        -99
-#define BDF_INVALID_LINE      -100
 
-typedef struct {
-    unsigned long reason;
-    unsigned long current;
-    unsigned long total;
-    unsigned long errlineno;
-} bdf_callback_struct_t;
+  /* Callback function type for unknown configuration options. */
+  typedef int
+  (*bdf_options_callback_t)( bdf_options_t*  opts,
+                             char**          params,
+                             unsigned long   nparams,
+                             void*           client_data );
 
-typedef void (*bdf_callback_t) (bdf_callback_struct_t *call_data,
-                                   void *client_data);
 
-/**************************************************************************
- *
- * BDF font API.
- *
- **************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font property macros and types.                                   */
+  /*                                                                       */
+  /*************************************************************************/
 
-/*
- * Startup and shutdown functions are no more needed
- */
 
-/*
- * Font options functions.
- */
-/*extern void bdf_default_options (bdf_options_t *opts);*/
+#define BDF_ATOM      1
+#define BDF_INTEGER   2
+#define BDF_CARDINAL  3
 
-/*
- * Font load, create, save and free functions.
- */
 
-FT_LOCAL( bdf_font_t* )  bdf_load_font (FT_Stream stream, FT_Memory memory,
-                                        bdf_options_t *opts,
-                                        bdf_callback_t callback, void *data);
+  /* This structure represents a particular property of a font. */
+  /* There are a set of defaults and each font has their own.   */
+  typedef struct  bdf_property_t_
+  {
+    char*  name;         /* Name of the property.   */
+    int    format;       /* Format of the property. */
+    int    builtin;      /* A builtin property.     */
+    union
+    {
+      char*          atom;
+      long           int32;
+      unsigned long  card32;
 
+    } value;             /* Value of the property.  */
 
-FT_LOCAL( void )         bdf_free_font (bdf_font_t *font);
+  } bdf_property_t;
 
-/*
- * Font property functions.
- */
-/* extern void bdf_create_property (char *name, int type, bdf_font_t *font); */
-FT_LOCAL( bdf_property_t* )  bdf_get_property (char *name, bdf_font_t *font);
-FT_LOCAL( unsigned long )    bdf_property_list (bdf_property_t **props);
 
-FT_LOCAL( void )             bdf_add_font_property (bdf_font_t *font,
-                                                    bdf_property_t *property);
-                                                    
-FT_LOCAL( void )             bdf_delete_font_property (bdf_font_t *font, char *name);
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font metric and glyph types.                                      */
+  /*                                                                       */
+  /*************************************************************************/
 
-FT_LOCAL( bdf_property_t* )  bdf_get_font_property (bdf_font_t *font,
-                                                    char *name);
-                                                    
-FT_LOCAL( unsigned long )    bdf_font_property_list (bdf_font_t *font,
-                                                      bdf_property_t **props);
 
-/*
- * Font comment functions.
- */
-FT_LOCAL( int )              bdf_replace_comments (bdf_font_t *font, char *comments,
-                                                   unsigned long comments_len);
+  typedef struct  bdf_bbx_t_
+  {
+    unsigned short  width;
+    unsigned short  height;
+
+    short           x_offset;
+    short           y_offset;
+
+    short           ascent;
+    short           descent;
+
+  } bdf_bbx_t;
 
-/*
- * Other miscellaneous functions.
- */
-FT_LOCAL( void )             bdf_set_default_metrics (bdf_font_t *font);
 
-/* */
+  typedef struct  bdf_glyph_t_
+  {
+    char*           name;        /* Glyph name.                          */
+    long            encoding;    /* Glyph encoding.                      */
+    unsigned short  swidth;      /* Scalable width.                      */
+    unsigned short  dwidth;      /* Device width.                        */
+    bdf_bbx_t       bbx;         /* Glyph bounding box.                  */
+    unsigned char*  bitmap;      /* Glyph bitmap.                        */
+    unsigned long   bpr;         /* Number of bytes used per row.        */
+    unsigned short  bytes;       /* Number of bytes used for the bitmap. */
+
+  } bdf_glyph_t;
+
+
+  typedef struct  _hashnode_
+  {
+    char*  key;
+    void*  data;
+  
+  } _hashnode, *hashnode;
+
+
+  typedef struct  hashtable_
+  {
+    int        limit;
+    int        size;
+    int        used;
+    hashnode*  table;
+
+  } hashtable;
+
+
+  typedef struct  bdf_glyphlist_t_
+  {
+    unsigned short  pad;          /* Pad to 4-byte boundary.              */
+    unsigned short  bpp;          /* Bits per pixel.                      */
+    long            start;        /* Beginning encoding value of glyphs.  */
+    long            end;          /* Ending encoding value of glyphs.     */
+    bdf_glyph_t*    glyphs;       /* Glyphs themselves.                   */
+    unsigned long   glyphs_size;  /* Glyph structures allocated.          */
+    unsigned long   glyphs_used;  /* Glyph structures used.               */
+    bdf_bbx_t       bbx;          /* Overall bounding box of glyphs.      */
+
+  } bdf_glyphlist_t;
+
+
+  typedef struct  bdf_font_t_
+  {
+    char*            name;           /* Name of the font.                   */
+    bdf_bbx_t        bbx;            /* Font bounding box.                  */
+
+    long             point_size;     /* Point size of the font.             */
+    unsigned long    resolution_x;   /* Font horizontal resolution.         */
+    unsigned long    resolution_y;   /* Font vertical resolution.           */
+
+    int              spacing;        /* Font spacing value.                 */
+
+    unsigned short   monowidth;      /* Logical width for monowidth font.   */
+
+    long             default_glyph;  /* Encoding of the default glyph.      */
+
+    long             font_ascent;    /* Font ascent.                        */
+    long             font_descent;   /* Font descent.                       */
+
+    unsigned long    glyphs_size;    /* Glyph structures allocated.         */
+    unsigned long    glyphs_used;    /* Glyph structures used.              */
+    bdf_glyph_t*     glyphs;         /* Glyphs themselves.                  */
+
+    unsigned long    unencoded_size; /* Unencoded glyph struct. allocated.  */
+    unsigned long    unencoded_used; /* Unencoded glyph struct. used.       */
+    bdf_glyph_t*     unencoded;      /* Unencoded glyphs themselves.        */
+
+    unsigned long    props_size;     /* Font properties allocated.          */
+    unsigned long    props_used;     /* Font properties used.               */
+    bdf_property_t*  props;          /* Font properties themselves.         */
+
+    char*            comments;       /* Font comments.                      */
+    unsigned long    comments_len;   /* Length of comment string.           */
+
+    bdf_glyphlist_t  overflow;       /* Storage used for glyph insertion.   */
+
+    void*            internal;       /* Internal data for the font.         */
+
+    unsigned long    nmod[2048];     /* Bitmap indicating modified glyphs.  */
+    unsigned long    umod[2048];     /* Bitmap indicating modified          */
+                                     /* unencoded glyphs.                   */
+    unsigned short   modified;       /* Boolean indicating font modified.   */
+    unsigned short   bpp;            /* Bits per pixel.                     */
+
+    FT_Memory        memory;
+
+    bdf_property_t*  user_props;
+    unsigned long    nuser_props;
+    hashtable        proptbl;
+
+  } bdf_font_t;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Types for load/save callbacks.                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Error codes. */
+#define BDF_MISSING_START       -1
+#define BDF_MISSING_FONTNAME    -2
+#define BDF_MISSING_SIZE        -3
+#define BDF_MISSING_CHARS       -4
+#define BDF_MISSING_STARTCHAR   -5
+#define BDF_MISSING_ENCODING    -6
+#define BDF_MISSING_BBX         -7
+
+#define BDF_OUT_OF_MEMORY      -20
+
+#define BDF_INVALID_LINE      -100
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font API.                                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+  FT_LOCAL( FT_Error )
+  bdf_load_font( FT_Stream       stream,
+                 FT_Memory       memory,
+                 bdf_options_t*  opts,
+                 bdf_font_t*    *font );
+
+  FT_LOCAL( void )
+  bdf_free_font( bdf_font_t*  font );
+
+  FT_LOCAL( bdf_property_t * )
+  bdf_get_property( char*        name,
+                    bdf_font_t*  font );
+
+  FT_LOCAL( bdf_property_t * )
+  bdf_get_font_property( bdf_font_t*  font,
+                         char*        name );
+
 
 FT_END_HEADER
 
-#endif /* _h_bdf */
+
+#endif /* __BDF_H__ */
+
+
+/* END */
diff --git a/src/bdf/bdfdriver.c b/src/bdf/bdfdriver.c
deleted file mode 100644
index 3b0122b..0000000
--- a/src/bdf/bdfdriver.c
+++ /dev/null
@@ -1,463 +0,0 @@
-/*  bdfdriver.c
-
-    FreeType font driver for bdf files
-
-    Copyright (C) 2001-2002 by
-    Francesco Zappa Nardelli 
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-#include <ft2build.h>
-
-#include FT_INTERNAL_DEBUG_H
-#include FT_INTERNAL_STREAM_H
-#include FT_INTERNAL_OBJECTS_H
-
-#include "bdf.h"
-#include "bdfdriver.h"
-
-#include "bdferror.h"
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
-  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
-  /* messages during execution.                                            */
-  /*                                                                       */
-#undef  FT_COMPONENT
-#define FT_COMPONENT  trace_bdf
-
-
-FT_CALLBACK_DEF( FT_Error )
-BDF_Face_Done( BDF_Face  face )
-{
-  FT_Memory  memory = FT_FACE_MEMORY( face );
-
-  bdf_free_font(face->bdffont); 
-  
-  FT_FREE( face->en_table ); 
-
-  FT_FREE( face->charset_encoding);
-  FT_FREE( face->charset_registry);
-  FT_FREE( face->root.family_name );
-  
-  FT_FREE( face->root.available_sizes );
-  FT_FREE( face->bdffont );
-
-  FT_TRACE4(("bdf: done face\n"));
-  
-  return FT_Err_Ok;
-}
-
-
-FT_CALLBACK_DEF( FT_Error )
-BDF_Face_Init( FT_Stream      stream,
-               BDF_Face       face,
-               FT_Int         face_index,
-               FT_Int         num_params,
-               FT_Parameter*  params )
-{
-  FT_Error       error  = FT_Err_Ok;
-  FT_Memory      memory = FT_FACE_MEMORY( face );
-  bdf_font_t*    font;
-  bdf_options_t  options;
-
-  FT_UNUSED( num_params );
-  FT_UNUSED( params );
-  FT_UNUSED( face_index );
-
-  (void) FT_STREAM_SEEK( 0 );
-
-  options.correct_metrics = 1;   /* FZ XXX : options semantics */
-  options.keep_unencoded  = 1;
-  options.pad_cells       = 1;
-
-  font = bdf_load_font( stream, memory, &options, 0, 0 );
-  if ( font == NULL )
-  {
-    FT_TRACE2(("[not a valid BDF file]\n"));
-    goto Fail;
-  }
-
-  /* we have a bdf font: let's construct the face object */
-  face->bdffont = font;
-  {
-    FT_Face          root = FT_FACE( face );
-    bdf_property_t*  prop = NULL;
-
-    FT_TRACE4(("glyph %d - %d, unencoded %d %d\n",font->glyphs_size,
-               font->glyphs_used, font->unencoded_size, font->unencoded_used));
-
-
-    root->num_faces  = 1;
-    root->face_index = 0;
-    root->face_flags =  FT_FACE_FLAG_FIXED_SIZES |
-                        FT_FACE_FLAG_HORIZONTAL  |
-                        FT_FACE_FLAG_FAST_GLYPHS ;
-
-    prop = bdf_get_font_property (font,"SPACING");
-    
-    if ( prop && prop->format == BDF_ATOM )
-    { 
-      if ( (*(prop->value.atom) == 'M') ||
-           (*(prop->value.atom) == 'C') )
-        {
-          root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
-        }
-      }
-    }
-
-    /* FZ XXX : TO DO : FT_FACE_FLAGS_VERTICAL  */
-    /* FZ XXX : I need a font to implement this */
-
-    root->style_flags = 0;
-    
-    prop = bdf_get_font_property (font,"SLANT");
-    
-    if ( prop && prop->format == BDF_ATOM )
-    { 
-      if ( (*(prop->value.atom) == 'O' ) ||
-           (*(prop->value.atom) == 'I' ) )
-      {
-        root->style_flags |= FT_STYLE_FLAG_ITALIC;
-      }
-    }
-
-    prop = bdf_get_font_property (font,"WEIGHT_NAME");
-    
-    if ( prop && prop->format == BDF_ATOM )
-    {
-      if ( *(prop->value.atom) == 'B' )
-        root->style_flags |= FT_STYLE_FLAG_BOLD;
-    }
-
-
-    prop = bdf_get_font_property (font,"FAMILY_NAME");
-    if (prop != NULL) {
-      int l = strlen(prop->value.atom) + 1;
-      if ( FT_ALLOC( root->family_name, l * sizeof(char)) )
-        goto Fail;
-      strcpy(root->family_name, prop->value.atom);
-    } else root->family_name = 0;
-
-    root->style_name = (char *)"Regular";
-    if ( root->style_flags & FT_STYLE_FLAG_BOLD )
-      {
-        if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
-          root->style_name = (char *)"Bold Italic";
-        else
-          root->style_name = (char *)"Bold";
-      }
-    else if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
-      root->style_name = (char *)"Italic";
-
-    root->num_glyphs = font->glyphs_size ; /* unencoded included */
-    
-    root->num_fixed_sizes = 1;
-    if ( FT_ALLOC_ARRAY( root->available_sizes, 1,
-                      FT_Bitmap_Size ) )
-      goto Fail;
-    
-    prop = bdf_get_font_property(font,"PIXEL_SIZE");
-    if (prop != NULL) {
-      bdf_property_t *xres = 0, *yres = 0;
-
-      xres = bdf_get_font_property(font,"RESOLUTION_X");
-      yres = bdf_get_font_property(font,"RESOLUTION_Y");
-      if ((xres != NULL) && (yres != NULL)) {
-        FT_TRACE4(("prop %d %d %d\n",prop->value.int32, xres->value.int32, 
-                   yres->value.int32));
-        root->available_sizes->width = 
-          prop->value.int32 * 75 / xres->value.int32;
-        root->available_sizes->height = 
-          prop->value.int32 * 75 / yres->value.int32;
-      }
-    } else { 
-      /* some fonts have broken SIZE declaration (jiskan24.bdf) */
-      FT_ERROR(("BDF Warning: reading size\n"));
-      root->available_sizes->width = font->point_size ;
-      root->available_sizes->height = font->point_size ;
-    }      
- 
-    /* encoding table */
-    {
-      bdf_glyph_t *cur = font->glyphs;
-      int n;
-
-      if ( FT_ALLOC ( face->en_table , 
-                   font->glyphs_size * sizeof(BDF_encoding_el ) ) )
-        goto Fail;
-
-      for (n = 0; n<font->glyphs_size ; n++) {
-        (face->en_table[n]).enc = cur[n].encoding ;
-        FT_TRACE4(("enc n: %d, val %ld\n",n,cur[n].encoding));
-        (face->en_table[n]).glyph = n;
-      }
-    }
-    
-    /* charmaps */
-    {
-      bdf_property_t *charset_registry = 0, *charset_encoding = 0;
-      
-      charset_registry = bdf_get_font_property(font,"CHARSET_REGISTRY");
-      charset_encoding = bdf_get_font_property(font,"CHARSET_ENCODING");
-      if ((charset_registry != NULL) && (charset_encoding != NULL)) {
-        if ((charset_registry->format == BDF_ATOM) && 
-            (charset_encoding->format == BDF_ATOM)) {
-          if (FT_ALLOC(face->charset_encoding, 
-                    (strlen(charset_encoding->value.atom)+1) * sizeof(char))) 
-            goto Exit;
-          if (FT_ALLOC(face->charset_registry, 
-                    (strlen(charset_registry->value.atom)+1) * sizeof(char))) 
-            goto Exit;
-          strcpy(face->charset_registry,charset_registry->value.atom);
-          strcpy(face->charset_encoding,charset_encoding->value.atom);
-            
-          face->charmap.encoding = ft_encoding_none;
-          face->charmap.platform_id = 0;
-          face->charmap.encoding_id = 0;
-          face->charmap.face = root; 
-          face->charmap_handle = &face->charmap;
-          root->charmap = face->charmap_handle;
-          goto Exit;
-        }  
-      }
-
-      /* otherwise assume adobe standard encoding */
-      face->charmap.encoding = ft_encoding_adobe_standard;
-      face->charmap.platform_id = 7; /* taken from t1objs.c */
-      face->charmap.encoding_id = 0;
-      face->charmap.face = root; 
-      face->charmap_handle = &face->charmap;
-      root->charmap = face->charmap_handle;
-    }
-  }
- 
- Exit:
-  return FT_Err_Ok;
-  
- Fail:
-  BDF_Face_Done( face );
-  return FT_Err_Unknown_File_Format;
-}
-
-static
-FT_Error  BDF_Set_Pixel_Size( FT_Size  size )
-{
-  BDF_Face face = (BDF_Face)FT_SIZE_FACE( size );
-  FT_Face  root = FT_FACE( face );
-
-  FT_TRACE4(("rec %d - pres %d\n",size->metrics.y_ppem,
-      root->available_sizes->height));
-  if (size->metrics.y_ppem == root->available_sizes->height) {
-   
-    size->metrics.ascender = face->bdffont->bbx.ascent << 6; 
-    size->metrics.descender = face->bdffont->bbx.descent * (-64);
-    size->metrics.height = face->bdffont->bbx.height <<6;
-      
-    return FT_Err_Ok;
-  }
-  else {
-    return FT_Err_Invalid_Pixel_Size;
-  }
-}
-
-static
-FT_Error  BDF_Glyph_Load( FT_GlyphSlot  slot,
-                          FT_Size       size,
-                          FT_UInt       glyph_index,
-                          FT_Int        load_flags )
-{
-  BDF_Face face = (BDF_Face)FT_SIZE_FACE( size );
-  FT_Error error = FT_Err_Ok;
-  FT_Bitmap *bitmap = &slot->bitmap;
-  bdf_glyph_t glyph;
-  int i;
-  FT_Memory memory = face->bdffont->memory;
-  
-  if (!face) {
-    error = FT_Err_Invalid_Argument;
-    goto Exit;
-  }
-  
-  /* slot, bitmap => freetype, glyph => bdflib */
-  glyph = face->bdffont->glyphs[glyph_index];
-  
-  bitmap->pitch = (glyph.bbx.width + 7) >> 3;
-  bitmap->rows = glyph.bbx.height;
-  bitmap->width = glyph.bbx.width;
-  bitmap->num_grays = 1;              /* unused */
-  bitmap->pixel_mode = ft_pixel_mode_mono;
-  
-  if ( FT_ALLOC ( bitmap->buffer , glyph.bytes) )
-    return FT_Err_Out_Of_Memory;
-  FT_MEM_SET( bitmap->buffer , 0 , glyph.bytes );
-  for (i=0 ; i<glyph.bytes ; i++) {
-    bitmap->buffer[i] = glyph.bitmap[i];
-  }
-
-  slot->bitmap_left = 0;
-  slot->bitmap_top = glyph.bbx.ascent ; 
-
-  /*  FZ TO DO : vertical metrics  */
-  slot->metrics.horiAdvance = glyph.dwidth << 6;
-  slot->metrics.horiBearingX = glyph.bbx.x_offset << 6 ;
-  slot->metrics.horiBearingY = glyph.bbx.y_offset << 6 ;
-  slot->metrics.width = bitmap->width << 6 ;
-  slot->metrics.height = bitmap->rows << 6;
-  
-  slot->linearHoriAdvance = (FT_Fixed)glyph.dwidth << 16;
-  slot->format = ft_glyph_format_bitmap;
-  slot->flags = FT_GLYPH_OWN_BITMAP;
-    
- Exit:
-  return error; 
-}
-
-static
-FT_UInt  BDF_Get_Char_Index( FT_CharMap  charmap,
-                             FT_ULong    char_code )
-{
-  BDF_Face face = ((BDF_Face)charmap->face);
-  BDF_encoding_el *en_table = face->en_table;
-  int low, high, mid;
-
-  FT_TRACE4(("get_char_index %ld\n", char_code));
-  
-  low = 0;
-  high = face->bdffont->glyphs_used - 1;   
-  while (low <= high) {
-    mid = (low+high) / 2;
-    if (char_code < en_table[mid].enc)
-      high = mid - 1;
-    else if (char_code > en_table[mid].enc)
-      low = mid + 1;
-    else return en_table[mid].glyph;
-  }
-  
-  return face->bdffont->default_glyph;
-}
-
-FT_CALLBACK_TABLE_DEF
-const FT_Driver_ClassRec  bdf_driver_class =
-{
-  {
-    ft_module_font_driver,
-    sizeof ( FT_DriverRec ),
-    
-    "bdf",
-    0x10000L,
-    0x20000L,
-      
-    0,
-    
-    (FT_Module_Constructor)0,
-    (FT_Module_Destructor) 0,
-    (FT_Module_Requester)  0
-  },
-  
-  sizeof( BDF_FaceRec ),
-  sizeof( FT_SizeRec ),
-  sizeof( FT_GlyphSlotRec ),
- 
-    (FT_Face_InitFunc)        BDF_Face_Init,
-    (FT_Face_DoneFunc)        BDF_Face_Done,
-    (FT_Size_InitFunc)        0,
-    (FT_Size_DoneFunc)        0,
-    (FT_Slot_InitFunc)        0,
-    (FT_Slot_DoneFunc)        0,
-
-    (FT_Size_ResetPointsFunc) BDF_Set_Pixel_Size,
-    (FT_Size_ResetPixelsFunc) BDF_Set_Pixel_Size,
-
-    (FT_Slot_LoadFunc)        BDF_Glyph_Load,
-
-#ifndef FT_CONFIG_OPTION_USE_CMAPS    
-   (FT_CharMap_CharIndexFunc)0,
-#else
-    (FT_CharMap_CharIndexFunc)0,
-#endif
-
-    (FT_Face_GetKerningFunc)  0,
-    (FT_Face_AttachFunc)      0,
-    (FT_Face_GetAdvancesFunc) 0,
-
-#ifndef FT_CONFIG_OPTION_USE_CMAPS
-    (FT_CharMap_CharNextFunc) 0, /*PCF_Char_Get_Next,*/
-#else
-    (FT_CharMap_CharNextFunc) 0
-#endif    
-  };
-
- /*  
-  (FTDriver_initFace)     BDF_Init_Face,
-  (FTDriver_doneFace)     BDF_Done_Face,
-  (FTDriver_initSize)     0,
-  (FTDriver_doneSize)     0,
-  (FTDriver_initGlyphSlot)0,
-  (FTDriver_doneGlyphSlot)0,
-  
-  (FTDriver_setCharSizes) BDF_Set_Pixel_Size,
-  (FTDriver_setPixelSizes)BDF_Set_Pixel_Size,
-
-  (FTDriver_loadGlyph)    BDF_Load_Glyph,
-  (FTDriver_getCharIndex) BDF_Get_Char_Index,
-  
-  (FTDriver_getKerning)   0,
-  (FTDriver_attachFile)   0,
-  (FTDriver_getAdvances)  0
-  */
-
-
-
-#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    getDriverClass                                                     */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    This function is used when compiling the TrueType driver as a      */
-  /*    shared library (`.DLL' or `.so').  It will be used by the          */
-  /*    high-level library of FreeType to retrieve the address of the      */
-  /*    driver's generic interface.                                        */
-  /*                                                                       */
-  /*    It shouldn't be implemented in a static build, as each driver must */
-  /*    have the same function as an exported entry point.                 */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The address of the TrueType's driver generic interface.  The       */
-  /*    format-specific interface can then be retrieved through the method */
-  /*    interface->get_format_interface.                                   */
-  /*                                                                       */
-  FT_EXPORT_DEF( const FT_Driver_Class* )  
-  getDriverClass( void )
-  {
-    return &bdf_driver_class;
-  }
-
-
-#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
-
-
-/* END */
diff --git a/src/bdf/bdfdriver.h b/src/bdf/bdfdriver.h
deleted file mode 100644
index daa870c..0000000
--- a/src/bdf/bdfdriver.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*  bdfdriver.h  
-
-    FreeType font driver for bdf fonts
-
-  Copyright (C) 2001 by            
-  Francesco Zappa Nardelli     
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-
-#ifndef __BDF_DRIVER_H__
-#define __BDF_DRIVER_H__
-
-#include <ft2build.h>
-#include FT_INTERNAL_DRIVER_H
-
-#include "bdf.h"
-
-FT_BEGIN_HEADER
-
-    typedef struct {
-      FT_Long   enc;
-      FT_Short  glyph;
-    } BDF_encoding_el;
-
-    typedef struct  BDF_FaceRec_
-    {
-      FT_FaceRec       root;
-
-      char            *charset_encoding;
-      char            *charset_registry;
-
-      bdf_font_t      *bdffont;  
-
-      BDF_encoding_el *en_table;
-      
-      FT_CharMap       charmap_handle;
-      FT_CharMapRec    charmap;  /* a single charmap per face */
-    } BDF_FaceRec, *BDF_Face;
-
-
-    FT_EXPORT_VAR( const FT_Driver_ClassRec )  bdf_driver_class;
-
-FT_END_HEADER
-
-
-#endif /* __BDF_DRIVER_H__ */
-
-
-/* END */
-
diff --git a/src/bdf/bdfdrivr.c b/src/bdf/bdfdrivr.c
new file mode 100644
index 0000000..7c577f5
--- /dev/null
+++ b/src/bdf/bdfdrivr.c
@@ -0,0 +1,564 @@
+/*  bdfdrivr.c
+
+    FreeType font driver for bdf files
+
+    Copyright (C) 2001-2002 by
+    Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include <ft2build.h>
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+
+#include "bdf.h"
+#include "bdfdrivr.h"
+
+#include "bdferror.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_bdfdriver
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  BDF_Face_Done( BDF_Face  face )
+  {
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+
+    bdf_free_font( face->bdffont );
+
+    FT_FREE( face->en_table );
+
+    FT_FREE( face->charset_encoding );
+    FT_FREE( face->charset_registry );
+    FT_FREE( face->root.family_name );
+
+    FT_FREE( face->root.available_sizes );
+
+    FT_FREE( face->bdffont );
+
+    FT_TRACE4(( "BDF_Face_Done: done face\n" ));
+
+    return BDF_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  BDF_Face_Init( FT_Stream      stream,
+                 BDF_Face       face,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    FT_Error       error  = BDF_Err_Ok;
+    FT_Memory      memory = FT_FACE_MEMORY( face );
+
+    bdf_font_t*    font;
+    bdf_options_t  options;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( face_index );
+
+
+    if ( FT_STREAM_SEEK( 0 ) )
+      goto Exit;
+
+    options.correct_metrics = 1;   /* FZ XXX: options semantics */
+    options.keep_unencoded  = 1;
+    options.keep_comments   = 0;
+    options.font_spacing    = BDF_PROPORTIONAL;
+
+    error = bdf_load_font( stream, memory, &options, &font );
+    if ( error == BDF_Err_Missing_Startfont_Field )
+    {
+      FT_TRACE2(( "[not a valid BDF file]\n" ));
+      goto Fail;
+    }
+    else if ( error )
+      goto Exit;
+
+    /* we have a bdf font: let's construct the face object */
+    face->bdffont = font;
+    {
+      FT_Face          root = FT_FACE( face );
+      bdf_property_t*  prop = NULL;
+
+
+      FT_TRACE4(( "number of glyphs: %d (%d)\n",
+                  font->glyphs_size,
+                  font->glyphs_used ));
+      FT_TRACE4(( "number of unencoded glyphs: %d (%d)\n",
+                  font->unencoded_size,
+                  font->unencoded_used ));
+
+      root->num_faces  = 1;
+      root->face_index = 0;
+      root->face_flags = FT_FACE_FLAG_FIXED_SIZES |
+                         FT_FACE_FLAG_HORIZONTAL  |
+                         FT_FACE_FLAG_FAST_GLYPHS;
+
+      prop = bdf_get_font_property( font, (char *)"SPACING" );
+      if ( prop != NULL )
+        if ( prop->format == BDF_ATOM )
+          if ( ( *(prop->value.atom) == 'M' ) ||
+               ( *(prop->value.atom) == 'C' ) )
+            root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      /* FZ XXX: TO DO: FT_FACE_FLAGS_VERTICAL   */
+      /* FZ XXX: I need a font to implement this */
+
+      root->style_flags = 0;
+      prop = bdf_get_font_property( font, (char *)"SLANT" );
+      if ( prop != NULL )
+        if ( prop->format == BDF_ATOM )
+          if ( ( *(prop->value.atom) == 'O' ) ||
+               ( *(prop->value.atom) == 'I' ) )
+            root->style_flags |= FT_STYLE_FLAG_ITALIC;
+
+      prop = bdf_get_font_property( font, (char *)"WEIGHT_NAME" );
+      if ( prop != NULL )
+        if ( prop->format == BDF_ATOM )
+          if ( *(prop->value.atom) == 'B' )
+            root->style_flags |= FT_STYLE_FLAG_BOLD;
+
+      prop = bdf_get_font_property( font, (char *)"FAMILY_NAME" );
+      if ( prop != NULL )
+      {
+        int  l = ft_strlen( prop->value.atom ) + 1;
+
+
+        if ( FT_NEW_ARRAY( root->family_name, l ) )
+          goto Exit;
+        ft_strcpy( root->family_name, prop->value.atom );
+      }
+      else
+        root->family_name = 0;
+
+      root->style_name = (char *)"Regular";
+      if ( root->style_flags & FT_STYLE_FLAG_BOLD )
+      {
+        if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
+          root->style_name = (char *)"Bold Italic";
+        else
+          root->style_name = (char *)"Bold";
+      }
+      else if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
+        root->style_name = (char *)"Italic";
+
+      root->num_glyphs = font->glyphs_size;     /* unencoded included */
+
+      root->num_fixed_sizes = 1;
+      if ( FT_NEW_ARRAY( root->available_sizes, 1 ) )
+        goto Exit;
+
+      prop = bdf_get_font_property( font, (char *)"PIXEL_SIZE" );
+      if ( prop != NULL )
+      {
+        bdf_property_t  *xres = 0, *yres = 0;
+
+
+        xres = bdf_get_font_property( font, (char *)"RESOLUTION_X" );
+        yres = bdf_get_font_property( font, (char *)"RESOLUTION_Y" );
+        if ( ( xres != NULL ) && ( yres != NULL ) )
+        {
+          FT_TRACE4(( "PIXEL_SIZE: %d  RESOLUTION_X: %d  RESOLUTION_Y: %d\n",
+                      prop->value.int32,
+                      xres->value.int32,
+                      yres->value.int32 ));
+          root->available_sizes->width =
+            prop->value.int32 * 75 / xres->value.int32;
+          root->available_sizes->height =
+            prop->value.int32 * 75 / yres->value.int32;
+        }
+      }
+      else
+      {
+        /* some fonts have broken SIZE declaration (jiskan24.bdf) */
+        FT_ERROR(( "BDF_Face_Init: reading size\n" ));
+        root->available_sizes->width  = font->point_size ;
+        root->available_sizes->height = font->point_size ;
+      }
+
+      /* encoding table */
+      {
+        bdf_glyph_t*   cur = font->glyphs;
+        unsigned long  n;
+
+
+        if ( FT_NEW_ARRAY( face->en_table, font->glyphs_size ) )
+          goto Exit;
+
+        for ( n = 0; n < font->glyphs_size; n++ )
+        {
+          (face->en_table[n]).enc = cur[n].encoding;
+          FT_TRACE4(( "idx %d, val 0x%lX\n", n, cur[n].encoding ));
+          (face->en_table[n]).glyph = n;
+        }
+      }
+
+      /* charmaps */
+      {
+        bdf_property_t  *charset_registry = 0, *charset_encoding = 0;
+
+
+        charset_registry =
+          bdf_get_font_property( font, (char *)"CHARSET_REGISTRY" );
+        charset_encoding =
+          bdf_get_font_property( font, (char *)"CHARSET_ENCODING" );
+        if ( ( charset_registry != NULL ) && ( charset_encoding != NULL ) )
+        {
+          if ( ( charset_registry->format == BDF_ATOM ) &&
+               ( charset_encoding->format == BDF_ATOM ) )
+          {
+            if ( FT_NEW_ARRAY( face->charset_encoding,
+                               strlen( charset_encoding->value.atom ) + 1 ) )
+              goto Exit;
+            if (FT_NEW_ARRAY( face->charset_registry,
+                              strlen( charset_registry->value.atom ) + 1 ) )
+              goto Exit;
+            ft_strcpy( face->charset_registry, charset_registry->value.atom );
+            ft_strcpy( face->charset_encoding, charset_encoding->value.atom );
+
+            face->charmap.encoding    = ft_encoding_none;
+            face->charmap.platform_id = 0;
+            face->charmap.encoding_id = 0;
+            face->charmap.face        = root;
+            face->charmap_handle      = &face->charmap;
+
+            root->charmap = face->charmap_handle;
+
+            goto Exit;
+          }
+        }
+
+        /* otherwise assume adobe standard encoding */
+        face->charmap.encoding    = ft_encoding_adobe_standard;
+        face->charmap.platform_id = 7; /* taken from t1objs.c */
+        face->charmap.encoding_id = 0;
+        face->charmap.face        = root;
+        face->charmap_handle      = &face->charmap;
+
+        root->charmap = face->charmap_handle;
+      }
+    }
+
+  Exit:
+    return error;
+
+  Fail:
+    BDF_Face_Done( face );
+    return BDF_Err_Unknown_File_Format;
+  }
+
+
+  static
+  FT_Error  BDF_Set_Pixel_Size( FT_Size  size )
+  {
+    BDF_Face  face = (BDF_Face)FT_SIZE_FACE( size );
+    FT_Face   root = FT_FACE( face );
+
+
+    FT_TRACE4(( "rec %d - pres %d\n",
+                size->metrics.y_ppem, root->available_sizes->height ));
+
+    if ( size->metrics.y_ppem == root->available_sizes->height )
+    {
+      size->metrics.ascender  = face->bdffont->bbx.ascent << 6;
+      size->metrics.descender = face->bdffont->bbx.descent * ( -64 );
+      size->metrics.height    = face->bdffont->bbx.height << 6;
+
+      return BDF_Err_Ok;
+    }
+    else
+      return BDF_Err_Invalid_Pixel_Size;
+  }
+
+
+  static FT_Error
+  BDF_Glyph_Load( FT_GlyphSlot  slot,
+                  FT_Size       size,
+                  FT_UInt       glyph_index,
+                  FT_Int        load_flags )
+  {
+    BDF_Face        face   = (BDF_Face)FT_SIZE_FACE( size );
+    FT_Error        error  = BDF_Err_Ok;
+    FT_Bitmap*      bitmap = &slot->bitmap;
+    bdf_glyph_t     glyph;
+    int             bpp    = face->bdffont->bpp;
+    int             i, j, count;
+    unsigned char   *p, *pp;
+
+    FT_Memory       memory = face->bdffont->memory;
+
+    FT_UNUSED( load_flags );
+
+
+    if ( !face )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* slot, bitmap => freetype, glyph => bdflib */
+    glyph = face->bdffont->glyphs[glyph_index];
+
+    bitmap->rows      = glyph.bbx.height;
+    bitmap->width     = glyph.bbx.width;
+
+    if ( bpp == 1 )
+    {
+      bitmap->pixel_mode = ft_pixel_mode_mono;
+      bitmap->pitch      = glyph.bpr;
+
+      if ( FT_NEW_ARRAY( bitmap->buffer, glyph.bytes ) )
+        goto Exit;
+      FT_MEM_COPY( bitmap->buffer, glyph.bitmap, glyph.bytes );
+    }
+    else
+    {
+      /* blow up pixmap to have 8 bits per pixel */
+      bitmap->pixel_mode = ft_pixel_mode_grays;
+      bitmap->pitch      = bitmap->width;
+
+      if ( FT_NEW_ARRAY( bitmap->buffer, bitmap->rows * bitmap->pitch ) )
+        goto Exit;
+
+      switch ( bpp )
+      {
+      case 2:
+        bitmap->num_grays = 4;
+
+        count = 0;
+        p     = glyph.bitmap;
+
+        for ( i = 0; i < bitmap->rows; i++ )
+        {
+          pp = p;
+
+          /* get the full bytes */
+          for ( j = 0; j < ( bitmap->width >> 2 ); j++ )
+          {
+            bitmap->buffer[count++] = ( *pp & 0xC0 ) >> 6;
+            bitmap->buffer[count++] = ( *pp & 0x30 ) >> 4;
+            bitmap->buffer[count++] = ( *pp & 0x0C ) >> 2;
+            bitmap->buffer[count++] =   *pp & 0x03;
+
+            pp++;
+          }
+
+          /* get remaining pixels (if any) */
+          switch ( bitmap->width & 3 )
+          {
+          case 3:
+            bitmap->buffer[count++] = ( *pp & 0xC0 ) >> 6;
+            /* fall through */
+          case 2:
+            bitmap->buffer[count++] = ( *pp & 0x30 ) >> 4;
+            /* fall through */
+          case 1:
+            bitmap->buffer[count++] = ( *pp & 0x0C ) >> 2;
+            /* fall through */
+          case 0:
+            break;
+          }
+
+          p += glyph.bpr;
+        }
+        break;
+
+      case 4:
+        bitmap->num_grays = 16;
+
+        count = 0;
+        p     = glyph.bitmap;
+
+        for ( i = 0; i < bitmap->rows; i++ )
+        {
+          pp = p;
+
+          /* get the full bytes */
+          for ( j = 0; j < ( bitmap->width >> 1 ); j++ )
+          {
+            bitmap->buffer[count++] = ( *pp & 0xF0 ) >> 4;
+            bitmap->buffer[count++] =   *pp & 0x0F;
+
+            pp++;
+          }
+
+          /* get remaining pixel (if any) */
+          switch ( bitmap->width & 1 )
+          {
+          case 1:
+            bitmap->buffer[count++] = ( *pp & 0xF0 ) >> 4;
+            /* fall through */
+          case 0:
+            break;
+          }
+
+          p += glyph.bpr;
+        }
+        break;
+      }
+    }
+
+    slot->bitmap_left = 0;
+    slot->bitmap_top  = glyph.bbx.ascent;
+
+    /* FZ XXX: TODO: vertical metrics */
+    slot->metrics.horiAdvance  = glyph.dwidth << 6;
+    slot->metrics.horiBearingX = glyph.bbx.x_offset << 6;
+    slot->metrics.horiBearingY = glyph.bbx.y_offset << 6;
+    slot->metrics.width        = bitmap->width << 6;
+    slot->metrics.height       = bitmap->rows << 6;
+
+    slot->linearHoriAdvance = (FT_Fixed)glyph.dwidth << 16;
+    slot->format            = ft_glyph_format_bitmap;
+    slot->flags             = FT_GLYPH_OWN_BITMAP;
+
+  Exit:
+    return error;
+  }
+
+
+  static
+  FT_UInt  BDF_Get_Char_Index( FT_CharMap  charmap,
+                               FT_ULong    char_code )
+  {
+    BDF_Face          face     = (BDF_Face)charmap->face;
+    BDF_encoding_el*  en_table = face->en_table;
+    int               low, high, mid;
+
+
+    FT_TRACE4(( "BDF_Get_Char_Index %ld\n", char_code ));
+
+    low  = 0;
+    high = face->bdffont->glyphs_used - 1;
+
+    while ( low <= high )
+    {
+      mid = ( low + high ) / 2;
+      if ( char_code < en_table[mid].enc )
+        high = mid - 1;
+      else if ( char_code > en_table[mid].enc )
+        low = mid + 1;
+      else
+        return en_table[mid].glyph;
+    }
+
+    return face->bdffont->default_glyph;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  bdf_driver_class =
+  {
+    {
+      ft_module_font_driver,
+      sizeof ( FT_DriverRec ),
+
+      "bdf",
+      0x10000L,
+      0x20000L,
+
+      0,
+
+      (FT_Module_Constructor)0,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  0
+    },
+
+    sizeof( BDF_FaceRec ),
+    sizeof( FT_SizeRec ),
+    sizeof( FT_GlyphSlotRec ),
+
+    (FT_Face_InitFunc)        BDF_Face_Init,
+    (FT_Face_DoneFunc)        BDF_Face_Done,
+    (FT_Size_InitFunc)        0,
+    (FT_Size_DoneFunc)        0,
+    (FT_Slot_InitFunc)        0,
+    (FT_Slot_DoneFunc)        0,
+
+    (FT_Size_ResetPointsFunc) BDF_Set_Pixel_Size,
+    (FT_Size_ResetPixelsFunc) BDF_Set_Pixel_Size,
+
+    (FT_Slot_LoadFunc)        BDF_Glyph_Load,
+
+#ifndef FT_CONFIG_OPTION_USE_CMAPS
+    (FT_CharMap_CharIndexFunc)0,
+#else
+    (FT_CharMap_CharIndexFunc)BDF_Get_Char_Index,
+#endif
+
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+    (FT_Face_GetAdvancesFunc) 0,
+
+#ifndef FT_CONFIG_OPTION_USE_CMAPS
+    (FT_CharMap_CharNextFunc) 0, /* BDF_Char_Get_Next,*/
+#else
+    (FT_CharMap_CharNextFunc) 0
+#endif
+  };
+
+
+#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    getDriverClass                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used when compiling the TrueType driver as a      */
+  /*    shared library (`.DLL' or `.so').  It will be used by the          */
+  /*    high-level library of FreeType to retrieve the address of the      */
+  /*    driver's generic interface.                                        */
+  /*                                                                       */
+  /*    It shouldn't be implemented in a static build, as each driver must */
+  /*    have the same function as an exported entry point.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The address of the TrueType's driver generic interface.  The       */
+  /*    format-specific interface can then be retrieved through the method */
+  /*    interface->get_format_interface.                                   */
+  /*                                                                       */
+  FT_EXPORT_DEF( const FT_Driver_Class* )
+  getDriverClass( void )
+  {
+    return &bdf_driver_class;
+  }
+
+
+#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
+
+
+/* END */
diff --git a/src/bdf/bdfdrivr.h b/src/bdf/bdfdrivr.h
new file mode 100644
index 0000000..5c58964
--- /dev/null
+++ b/src/bdf/bdfdrivr.h
@@ -0,0 +1,74 @@
+/*  bdfdrivr.h
+
+    FreeType font driver for bdf fonts
+
+  Copyright (C) 2001, 2002 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#ifndef __BDFDRIVR_H__
+#define __BDFDRIVR_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+#include "bdf.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  BDF_encoding_el_
+  {
+    FT_ULong  enc;
+    FT_Short  glyph;
+
+  } BDF_encoding_el;
+
+
+  typedef struct  BDF_FaceRec_
+  {
+    FT_FaceRec        root;
+
+    char*             charset_encoding;
+    char*             charset_registry;
+
+    bdf_font_t*       bdffont;
+
+    BDF_encoding_el*  en_table;
+
+    FT_CharMap        charmap_handle;
+    FT_CharMapRec     charmap;  /* a single charmap per face */
+
+  } BDF_FaceRec, *BDF_Face;
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  bdf_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __BDFDRIVR_H__ */
+
+
+/* END */
diff --git a/src/bdf/bdferror.h b/src/bdf/bdferror.h
index 271ba82..b27fa33 100644
--- a/src/bdf/bdferror.h
+++ b/src/bdf/bdferror.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2001 Francesco Zappa Nardelli
+ * Copyright 2001, 2002 Francesco Zappa Nardelli
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,7 +22,7 @@
 
   /*************************************************************************/
   /*                                                                       */
-  /* This file is used to define the PCF error enumeration constants.      */
+  /* This file is used to define the BDF error enumeration constants.      */
   /*                                                                       */
   /*************************************************************************/
 
@@ -38,7 +38,7 @@
 
 #include FT_ERRORS_H
 
-#endif /* __PCFERROR_H__ */
+#endif /* __BDFERROR_H__ */
 
 
 /* END */
diff --git a/src/bdf/bdflib.c b/src/bdf/bdflib.c
index d7bc87c..ce00313 100644
--- a/src/bdf/bdflib.c
+++ b/src/bdf/bdflib.c
@@ -1,6 +1,6 @@
 /*
  * Copyright 2000 Computing Research Labs, New Mexico State University
- * Copyright 2001 Francesco Zappa Nardelli
+ * Copyright 2001, 2002 Francesco Zappa Nardelli
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -21,9 +21,14 @@
  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-/*
-static char rcsid[] = "$Id$";
-*/
+  /*************************************************************************/
+  /*                                                                       */
+  /*  This file is based on bdf.c,v 1.22 2000/03/16 20:08:50               */
+  /*                                                                       */
+  /*  taken from Mark Leisher's xmbdfed package                            */
+  /*                                                                       */
+  /*************************************************************************/
+
 
 #include <ft2build.h>
 
@@ -32,779 +37,708 @@ static char rcsid[] = "$Id$";
 #include FT_INTERNAL_OBJECTS_H
 
 #include "bdf.h"
-
 #include "bdferror.h"
 
-#undef MAX
-#define MAX(h, i) ((h) > (i) ? (h) : (i))
 
-#undef MIN
-#define MIN(l, o) ((l) < (o) ? (l) : (o))
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_bdflib
 
-/**************************************************************************
- *
- * Masks used for checking different bits per pixel cases.
- *
- **************************************************************************/
 
-static const unsigned char onebpp[]   = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
-static const unsigned char twobpp[]   = { 0xc0, 0x30, 0x0c, 0x03 };
-static const unsigned char fourbpp[]  = { 0xf0, 0x0f };
-static const unsigned char eightbpp[] = { 0xff };
+  /*************************************************************************/
+  /*                                                                       */
+  /* Default BDF font options.                                             */
+  /*                                                                       */
+  /*************************************************************************/
 
-/**************************************************************************
- *
- * Default BDF font options.
- *
- **************************************************************************/
 
-static const bdf_options_t _bdf_opts =
-{
-    1,                /* Hint TTF glyphs.               */
+  static bdf_options_t  _bdf_opts =
+  {
     1,                /* Correct metrics.               */
     1,                /* Preserve unencoded glyphs.     */
-    1,                /* Preserve comments.             */
-    1,                /* Pad character-cells.           */
-    BDF_PROPORTIONAL, /* Default spacing.               */
-    12,               /* Default point size.            */
-    0,                /* Default horizontal resolution. */
-    0,                /* Default vertical resolution.   */
-    1,                /* Bits per pixel.                */
-    BDF_UNIX_EOL,     /* Line separator.                */
-};
-
-/**************************************************************************
- *
- * Builtin BDF font properties.
- *
- **************************************************************************/
+    0,                /* Preserve comments.             */
+    BDF_PROPORTIONAL  /* Default spacing.               */
+  };
 
-/*
- * List of most properties that might appear in a font.  Doesn't include the
- * RAW_* and AXIS_* properties in X11R6 polymorphic fonts.
- */
-static const bdf_property_t _bdf_properties[] =
-{
-    {"ADD_STYLE_NAME",          BDF_ATOM,     1},
-    {"AVERAGE_WIDTH",           BDF_INTEGER,  1},
-    {"AVG_CAPITAL_WIDTH",       BDF_INTEGER,  1},
-    {"AVG_LOWERCASE_WIDTH",     BDF_INTEGER,  1},
-    {"CAP_HEIGHT",              BDF_INTEGER,  1},
-    {"CHARSET_COLLECTIONS",     BDF_ATOM,     1},
-    {"CHARSET_ENCODING",        BDF_ATOM,     1},
-    {"CHARSET_REGISTRY",        BDF_ATOM,     1},
-    {"COMMENT",                 BDF_ATOM,     1},
-    {"COPYRIGHT",               BDF_ATOM,     1},
-    {"DEFAULT_CHAR",            BDF_CARDINAL, 1},
-    {"DESTINATION",             BDF_CARDINAL, 1},
-    {"DEVICE_FONT_NAME",        BDF_ATOM,     1},
-    {"END_SPACE",               BDF_INTEGER,  1},
-    {"FACE_NAME",               BDF_ATOM,     1},
-    {"FAMILY_NAME",             BDF_ATOM,     1},
-    {"FIGURE_WIDTH",            BDF_INTEGER,  1},
-    {"FONT",                    BDF_ATOM,     1},
-    {"FONTNAME_REGISTRY",       BDF_ATOM,     1},
-    {"FONT_ASCENT",             BDF_INTEGER,  1},
-    {"FONT_DESCENT",            BDF_INTEGER,  1},
-    {"FOUNDRY",                 BDF_ATOM,     1},
-    {"FULL_NAME",               BDF_ATOM,     1},
-    {"ITALIC_ANGLE",            BDF_INTEGER,  1},
-    {"MAX_SPACE",               BDF_INTEGER,  1},
-    {"MIN_SPACE",               BDF_INTEGER,  1},
-    {"NORM_SPACE",              BDF_INTEGER,  1},
-    {"NOTICE",                  BDF_ATOM,     1},
-    {"PIXEL_SIZE",              BDF_INTEGER,  1},
-    {"POINT_SIZE",              BDF_INTEGER,  1},
-    {"QUAD_WIDTH",              BDF_INTEGER,  1},
-    {"RAW_ASCENT",              BDF_INTEGER,  1},
-    {"RAW_AVERAGE_WIDTH",       BDF_INTEGER,  1},
-    {"RAW_AVG_CAPITAL_WIDTH",   BDF_INTEGER,  1},
-    {"RAW_AVG_LOWERCASE_WIDTH", BDF_INTEGER,  1},
-    {"RAW_CAP_HEIGHT",          BDF_INTEGER,  1},
-    {"RAW_DESCENT",             BDF_INTEGER,  1},
-    {"RAW_END_SPACE",           BDF_INTEGER,  1},
-    {"RAW_FIGURE_WIDTH",        BDF_INTEGER,  1},
-    {"RAW_MAX_SPACE",           BDF_INTEGER,  1},
-    {"RAW_MIN_SPACE",           BDF_INTEGER,  1},
-    {"RAW_NORM_SPACE",          BDF_INTEGER,  1},
-    {"RAW_PIXEL_SIZE",          BDF_INTEGER,  1},
-    {"RAW_POINT_SIZE",          BDF_INTEGER,  1},
-    {"RAW_PIXELSIZE",           BDF_INTEGER,  1},
-    {"RAW_POINTSIZE",           BDF_INTEGER,  1},
-    {"RAW_QUAD_WIDTH",          BDF_INTEGER,  1},
-    {"RAW_SMALL_CAP_SIZE",      BDF_INTEGER,  1},
-    {"RAW_STRIKEOUT_ASCENT",    BDF_INTEGER,  1},
-    {"RAW_STRIKEOUT_DESCENT",   BDF_INTEGER,  1},
-    {"RAW_SUBSCRIPT_SIZE",      BDF_INTEGER,  1},
-    {"RAW_SUBSCRIPT_X",         BDF_INTEGER,  1},
-    {"RAW_SUBSCRIPT_Y",         BDF_INTEGER,  1},
-    {"RAW_SUPERSCRIPT_SIZE",    BDF_INTEGER,  1},
-    {"RAW_SUPERSCRIPT_X",       BDF_INTEGER,  1},
-    {"RAW_SUPERSCRIPT_Y",       BDF_INTEGER,  1},
-    {"RAW_UNDERLINE_POSITION",  BDF_INTEGER,  1},
-    {"RAW_UNDERLINE_THICKNESS", BDF_INTEGER,  1},
-    {"RAW_X_HEIGHT",            BDF_INTEGER,  1},
-    {"RELATIVE_SETWIDTH",       BDF_CARDINAL, 1},
-    {"RELATIVE_WEIGHT",         BDF_CARDINAL, 1},
-    {"RESOLUTION",              BDF_INTEGER,  1},
-    {"RESOLUTION_X",            BDF_CARDINAL, 1},
-    {"RESOLUTION_Y",            BDF_CARDINAL, 1},
-    {"SETWIDTH_NAME",           BDF_ATOM,     1},
-    {"SLANT",                   BDF_ATOM,     1},
-    {"SMALL_CAP_SIZE",          BDF_INTEGER,  1},
-    {"SPACING",                 BDF_ATOM,     1},
-    {"STRIKEOUT_ASCENT",        BDF_INTEGER,  1},
-    {"STRIKEOUT_DESCENT",       BDF_INTEGER,  1},
-    {"SUBSCRIPT_SIZE",          BDF_INTEGER,  1},
-    {"SUBSCRIPT_X",             BDF_INTEGER,  1},
-    {"SUBSCRIPT_Y",             BDF_INTEGER,  1},
-    {"SUPERSCRIPT_SIZE",        BDF_INTEGER,  1},
-    {"SUPERSCRIPT_X",           BDF_INTEGER,  1},
-    {"SUPERSCRIPT_Y",           BDF_INTEGER,  1},
-    {"UNDERLINE_POSITION",      BDF_INTEGER,  1},
-    {"UNDERLINE_THICKNESS",     BDF_INTEGER,  1},
-    {"WEIGHT",                  BDF_CARDINAL, 1},
-    {"WEIGHT_NAME",             BDF_ATOM,     1},
-    {"X_HEIGHT",                BDF_INTEGER,  1},
-    {"_MULE_BASELINE_OFFSET",   BDF_INTEGER,  1},
-    {"_MULE_RELATIVE_COMPOSE",  BDF_INTEGER,  1},
-};
-
-static const FT_ULong _num_bdf_properties = FT_NUM_ELEMENT(_bdf_properties);
 
-/*
- * User defined properties.
- */
-/*static bdf_property_t *user_props;
-  static unsigned long nuser_props = 0;*/
+  /*************************************************************************/
+  /*                                                                       */
+  /* Builtin BDF font properties.                                          */
+  /*                                                                       */
+  /*************************************************************************/
 
-/**************************************************************************
- *
- * Hash table utilities for the properties.
- *
- **************************************************************************/
+  /* List of most properties that might appear in a font.  Doesn't include */
+  /* the RAW_* and AXIS_* properties in X11R6 polymorphic fonts.           */
 
-#define INITIAL_HT_SIZE 241
+  static bdf_property_t  _bdf_properties[] =
+  {
+    { (char *)"ADD_STYLE_NAME",          BDF_ATOM,     1, { 0 } },
+    { (char *)"AVERAGE_WIDTH",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"AVG_CAPITAL_WIDTH",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"AVG_LOWERCASE_WIDTH",     BDF_INTEGER,  1, { 0 } },
+    { (char *)"CAP_HEIGHT",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"CHARSET_COLLECTIONS",     BDF_ATOM,     1, { 0 } },
+    { (char *)"CHARSET_ENCODING",        BDF_ATOM,     1, { 0 } },
+    { (char *)"CHARSET_REGISTRY",        BDF_ATOM,     1, { 0 } },
+    { (char *)"COMMENT",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"COPYRIGHT",               BDF_ATOM,     1, { 0 } },
+    { (char *)"DEFAULT_CHAR",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"DESTINATION",             BDF_CARDINAL, 1, { 0 } },
+    { (char *)"DEVICE_FONT_NAME",        BDF_ATOM,     1, { 0 } },
+    { (char *)"END_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"FACE_NAME",               BDF_ATOM,     1, { 0 } },
+    { (char *)"FAMILY_NAME",             BDF_ATOM,     1, { 0 } },
+    { (char *)"FIGURE_WIDTH",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"FONT",                    BDF_ATOM,     1, { 0 } },
+    { (char *)"FONTNAME_REGISTRY",       BDF_ATOM,     1, { 0 } },
+    { (char *)"FONT_ASCENT",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"FONT_DESCENT",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"FOUNDRY",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"FULL_NAME",               BDF_ATOM,     1, { 0 } },
+    { (char *)"ITALIC_ANGLE",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"MAX_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"MIN_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"NORM_SPACE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"NOTICE",                  BDF_ATOM,     1, { 0 } },
+    { (char *)"PIXEL_SIZE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"POINT_SIZE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"QUAD_WIDTH",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_ASCENT",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVERAGE_WIDTH",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVG_CAPITAL_WIDTH",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVG_LOWERCASE_WIDTH", BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_CAP_HEIGHT",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_DESCENT",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_END_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_FIGURE_WIDTH",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_MAX_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_MIN_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_NORM_SPACE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_PIXEL_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_POINT_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_PIXELSIZE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_POINTSIZE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_QUAD_WIDTH",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SMALL_CAP_SIZE",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_STRIKEOUT_ASCENT",    BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_STRIKEOUT_DESCENT",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_SIZE",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_X",         BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_Y",         BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_SIZE",    BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_X",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_Y",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_UNDERLINE_POSITION",  BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_UNDERLINE_THICKNESS", BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_X_HEIGHT",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"RELATIVE_SETWIDTH",       BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RELATIVE_WEIGHT",         BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RESOLUTION",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RESOLUTION_X",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RESOLUTION_Y",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"SETWIDTH_NAME",           BDF_ATOM,     1, { 0 } },
+    { (char *)"SLANT",                   BDF_ATOM,     1, { 0 } },
+    { (char *)"SMALL_CAP_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"SPACING",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"STRIKEOUT_ASCENT",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"STRIKEOUT_DESCENT",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_X",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_Y",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_SIZE",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_X",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_Y",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"UNDERLINE_POSITION",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"UNDERLINE_THICKNESS",     BDF_INTEGER,  1, { 0 } },
+    { (char *)"WEIGHT",                  BDF_CARDINAL, 1, { 0 } },
+    { (char *)"WEIGHT_NAME",             BDF_ATOM,     1, { 0 } },
+    { (char *)"X_HEIGHT",                BDF_INTEGER,  1, { 0 } },
+    { (char *)"_MULE_BASELINE_OFFSET",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"_MULE_RELATIVE_COMPOSE",  BDF_INTEGER,  1, { 0 } },
+  };
+
+  static unsigned long
+  _num_bdf_properties = sizeof ( _bdf_properties ) /
+                        sizeof ( _bdf_properties[0] );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Hash table utilities for the properties.                              */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* XXX: Replace this with FreeType's hash functions */
+
+
+#define INITIAL_HT_SIZE  241
+
+  typedef void
+  (*hash_free_func)( hashnode  node );
+
+  static hashnode*
+  hash_bucket( char*       key,
+               hashtable*  ht )
+  {
+    char*          kp  = key;
+    unsigned long  res = 0;
+    hashnode*      bp  = ht->table, *ndp;
+
+
+    /* Mocklisp hash function. */
+    while ( *kp )
+      res = ( res << 5 ) - res + *kp++;
 
-typedef void (*hash_free_func)(hashnode node);
+    ndp = bp + ( res % ht->size );
+    while ( *ndp )
+    {
+      kp = (*ndp)->key;
+      if ( kp[0] == key[0] && ft_strcmp( kp, key ) == 0 )
+        break;
+      ndp--;
+      if ( ndp < bp )
+        ndp = bp + ( ht->size - 1 );
+    }
 
-static hashnode*
-hash_bucket(char *key, hashtable *ht)
-{
-  char*         kp  = key;
-  unsigned long res = 0;
-  hashnode*     bp  = ht->table, *ndp;
+    return ndp;
+  }
 
-  /*
-   * Mocklisp hash function.
-   */
-  while (*kp)
-    res = (res << 5) - res + *kp++;
 
-  ndp = bp + (res % ht->size);
-  while (*ndp)
+  static FT_Error
+  hash_rehash( hashtable*  ht,
+               FT_Memory   memory )
   {
-    kp = (*ndp)->key;
+    hashnode*  obp = ht->table, *bp, *nbp;
+    int        i, sz = ht->size;
+    FT_Error   error = BDF_Err_Ok;
 
-    if (kp[0] == key[0] && ft_strcmp(kp, key) == 0)
-      break;
 
-    ndp--;
-    if (ndp < bp)
-      ndp = bp + (ht->size - 1);
+    ht->size <<= 1;
+    ht->limit  = ht->size / 3;
+
+    if ( FT_NEW_ARRAY( ht->table, ht->size ) )
+      goto Exit;
+    FT_MEM_SET( ht->table, 0, sizeof ( hashnode ) * ht->size );
+
+    for ( i = 0, bp = obp; i < sz; i++, bp++ )
+    {
+      if ( *bp )
+      {
+        nbp = hash_bucket( (*bp)->key, ht );
+        *nbp = *bp;
+      }
+    }
+    FT_FREE( obp );
+
+  Exit:
+    return error;
   }
-  return ndp;
-}
 
 
-static  FT_Error
-hash_rehash ( hashtable*  ht,
-              FT_Memory   memory )
-{
-  hashnode *obp = ht->table, *bp, *nbp;
-  int i, sz = ht->size;
-  FT_Error error;
+  static FT_Error
+  hash_init( hashtable*  ht,
+             FT_Memory   memory )
+  {
+    int       sz = INITIAL_HT_SIZE;
+    FT_Error  error = BDF_Err_Ok;
+
+
+    ht->size  = sz;
+    ht->limit = sz / 3;
+    ht->used  = 0;
 
-  ht->size <<= 1;
-  ht->limit  = ht->size / 3;
+    if ( FT_NEW_ARRAY( ht->table, sz ) )
+      goto Exit;
+    FT_MEM_SET( ht->table, 0, sizeof ( hashnode ) * sz );
 
-  if ( FT_NEW_ARRAY( ht->table , ht->size ) )
+  Exit:
     return error;
+  }
 
-  for (i = 0, bp = obp; i < sz; i++, bp++)
+
+  static void
+  hash_free( hashtable*  ht,
+             FT_Memory   memory )
   {
-    if (*bp)
+    if ( ht != 0 )
     {
-      nbp = hash_bucket((*bp)->key, ht);
-      *nbp = *bp;
+      int        i, sz = ht->size;
+      hashnode*  bp = ht->table;
+
+
+      for ( i = 0; i < sz; i++, bp++ )
+        FT_FREE( *bp );
+
+      FT_FREE( ht->table );
     }
   }
-  FT_FREE(obp);
 
-  return FT_Err_Ok;
-}
 
+  static FT_Error
+  hash_insert( char*       key,
+               void*       data,
+               hashtable*  ht,
+               FT_Memory   memory )
+  {
+    hashnode  nn, *bp = hash_bucket( key, ht );
+    FT_Error  error = BDF_Err_Ok;
 
-static FT_Error
-hash_init ( hashtable*  ht,
-            FT_Memory   memory )
-{
-  int      sz = INITIAL_HT_SIZE;
-  FT_Error error;
 
-  ht->size  = sz;
-  ht->limit = sz / 3;
-  ht->used  = 0;
+    nn = *bp;
+    if ( !nn )
+    {
+      if ( FT_NEW( nn ) )
+        goto Exit;
+      *bp = nn;
 
-  if ( FT_NEW_ARRAY( ht->table, size ) )
-    return error;
+      nn->key  = key;
+      nn->data = data;
 
-  return FT_Err_Ok;
-}
+      if ( ht->used >= ht->limit )
+      {
+        error = hash_rehash( ht, memory );
+        if ( error )
+          goto Exit;
+      }
+      ht->used++;
+    }
+    else
+      nn->data = data;
 
+  Exit:
+    return error;
+  }
 
-static void
-hash_free( hashtable*  ht,
-           FT_Memory   memory )
-{
-  /* FT_Error error; */
 
-  if ( ht != 0 )
+  static hashnode
+  hash_lookup( char*       key,
+               hashtable*  ht )
   {
-    int        i, sz = ht->size;
-    hashnode*  bp    = ht->table;
+    hashnode *np = hash_bucket( key, ht );
 
-    for (i = 0; i < sz; i++, bp++)
-    {
-      if (*bp)
-        FT_FREE(*bp);
-    }
-    if (sz > 0)
-      FT_FREE(ht->table);
+
+    return *np;
   }
-}
 
 
-static FT_Error
-hash_insert ( char*       key,
-              void*       data,
-              hashtable*  ht,
-              FT_Memory   memory )
-{
-  FT_Error  error   = FT_Err_Ok;
-  hashnode  nn, *bp = hash_bucket(key, ht);
+  /*************************************************************************/
+  /*                                                                       */
+  /* Utility types and functions.                                          */
+  /*                                                                       */
+  /*************************************************************************/
+
 
-  nn = *bp;
-  if (!nn)
+  /* Function type for parsing lines of a BDF font. */
+
+  typedef FT_Error
+  (*_bdf_line_func_t)( char*          line,
+                       unsigned long  linelen,
+                       unsigned long  lineno,
+                       void*          call_data,
+                       void*          client_data );
+
+
+  /* List structure for splitting lines into fields. */
+
+  typedef struct  _bdf_list_t_
   {
-    if ( FT_NEW( nn ) )
-      return error;
+    char**         field;
+    unsigned long  size;
+    unsigned long  used;
 
-    *bp      = nn;
-    nn->key  = key;
-    nn->data = data;
+  } _bdf_list_t;
 
-    if (ht->used >= ht->limit)
-      error = hash_rehash(ht, memory);
 
-    ht->used++;
-  }
-  else
-    nn->data = data;
+  /* Structure used while loading BDF fonts. */
 
-  return error;
-}
+  typedef struct  _bdf_parse_t_
+  {
+    unsigned long   flags;
+    unsigned long   cnt;
+    unsigned long   row;
 
+    short           minlb;
+    short           maxlb;
+    short           maxrb;
+    short           maxas;
+    short           maxds;
 
-static hashnode
-hash_lookup(char *key, hashtable *ht)
-{
-  hashnode *np = hash_bucket(key, ht);
-  return   *np;
-}
+    short           rbearing;
 
-#ifdef 0
-static void
-hash_delete(char *name, hashtable *ht , FT_Memory memory)
-{
-  hashnode *hp;
-  /* FT_Error error; */
+    char*           glyph_name;
+    long            glyph_enc;
 
-  hp = hash_bucket(name, ht);
-  FT_FREE( *hp );
-}
-#endif
+    bdf_font_t*     font;
+    bdf_options_t*  opts;
 
-/*
- * The builtin property table.
- */
-/*static hashtable proptbl; */ /* XXX eliminate this */
+    unsigned long   have[2048];
+    _bdf_list_t     list;
 
+    FT_Memory       memory;
 
+  } _bdf_parse_t;
 
-/**************************************************************************
- *
- * Utility types and functions.
- *
- **************************************************************************/
 
-/*
- * Function type for parsing lines of a BDF font.
- */
-typedef int (*_bdf_line_func_t)( char*         line,
-                                 unsigned long linelen,
-                                 unsigned long lineno,
-                                 void*         call_data,
-                                 void*         client_data );
+#define setsbit( m, cc )  ( m[(cc) >> 3] |= ( 1 << ( (cc) & 7 ) ) )
+#define sbitset( m, cc )  ( m[(cc) >> 3]  & ( 1 << ( (cc) & 7 ) ) )
 
-/*
- * List structure for splitting lines into fields.
- */
-typedef struct
-{
-  char**         field;
-  unsigned long  size;
-  unsigned long  used;
-  char*          bfield;
-  unsigned long  bsize;
-  unsigned long  bused;
 
-} _bdf_list_t;
+  /* An empty string for empty fields. */
 
+  static char  empty[1] = { 0 };   /* XXX eliminate this */
 
-/*
- * Structure used while loading BDF fonts.
- */
-typedef struct
-{
-  unsigned long          flags;
-  unsigned long          cnt;
-  unsigned long          row;
-  unsigned long          bpr;
-  short                  minlb;
-  short                  maxlb;
-  short                  maxrb;
-  short                  maxas;
-  short                  maxds;
-  short                  rbearing;
-  char*                  glyph_name;
-  long                   glyph_enc;
-  bdf_font_t*            font;
-  bdf_options_t*         opts;
-  void*                  client_data;
-  bdf_callback_t         callback;
-  bdf_callback_struct_t  cb;
-  unsigned long          have[2048];
-  _bdf_list_t            list;
-
-  FT_Memory              memory;
-
-} _bdf_parse_t;
-
-#define setsbit(m, cc) (m[(cc) >> 3] |= (1 << ((cc) & 7)))
-#define sbitset(m, cc) (m[(cc) >> 3] & (1 << ((cc) & 7)))
 
-/*
- * An empty string for empty fields.
- */
-static const char empty[1] = { 0 };   /* XXX eliminate this */
+  /* Assume the line is NULL-terminated and that the `list' parameter */
+  /* was initialized the first time it was used.                      */
 
-/*
- * Assume the line is NULL terminated and that the `list' parameter was
- * initialized the first time it was used.
- */
-static FT_Error
-_bdf_split ( char*          separators,
-             char*          line,
-             unsigned long  linelen,
-             _bdf_list_t*   list,
-             FT_Memory      memory )
-{
-  int mult, final_empty;
-  char *sp, *ep, *end;
-  unsigned char seps[32];
-  FT_Error error;
-
-  /*
-   * Initialize the list.
-   */
-  list->used = list->bused = 0;
-
-  /*
-   * If the line is empty, then simply return.
-   */
-  if ( linelen == 0 || line[0] == 0 )
-    return FT_Err_Ok;
-
-  /*
-   * If the `separators' parameter is NULL or empty, split the list into
-   * individual bytes.
-   */
-  if ( separators == 0 || *separators == 0 )
+  static FT_Error
+  _bdf_split( char*          separators,
+              char*          line,
+              unsigned long  linelen,
+              _bdf_list_t*   list,
+              FT_Memory      memory )
   {
-    if ( linelen > list->bsize )
+    int       mult, final_empty;
+    char      *sp, *ep, *end;
+    char      seps[32];
+    FT_Error  error = BDF_Err_Ok;
+
+
+    /* Initialize the list. */
+    list->used = 0;
+
+    /* If the line is empty, then simply return. */
+    if ( linelen == 0 || line[0] == 0 )
+      goto Exit;
+
+    /* In the original code, if the `separators' parameter is NULL or */
+    /* empty, the list is split into individual bytes.  We don't need */
+    /* this, so an error is signaled.                                 */
+    if ( separators == 0 || *separators == 0 )
     {
-      if ( list->bsize )
-      {
-        if ( FT_ALLOC ( list->bfield , linelen) )
-          return error;
-      }
-      else
-      {
-        if ( FT_REALLOC ( list->bfield , list->bsize, linelen) )
-          return error;
-      }
-      list->bsize = linelen;
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
     }
-    list->bused = linelen;
 
-    FT_MEM_COPY (list->bfield, line, linelen);
-    return FT_Err_Ok;
-  }
+    /* Prepare the separator bitmap. */
+    FT_MEM_SET( seps, 0, 32 );
 
-  /*
-   * Prepare the separator bitmap.
-   */
-  FT_MEM_ZERO( seps, 32 );
-
-  /*
-   * If the very last character of the separator string is a plus, then set
-   * the `mult' flag to indicate that multiple separators should be
-   * collapsed into one.
-   */
-  for ( mult = 0, sp = separators; sp && *sp; sp++ )
-  {
-    if ( sp[0] == '+' && sp[1] == 0)
-      mult = 1;
-    else
-      setsbit( seps, sp[0] );
-  }
+    /* If the very last character of the separator string is a plus, then */
+    /* set the `mult' flag to indicate that multiple separators should be */
+    /* collapsed into one.                                                */
+    for ( mult = 0, sp = separators; sp && *sp; sp++ )
+    {
+      if ( *sp == '+' && *( sp + 1 ) == 0 )
+        mult = 1;
+      else
+        setsbit( seps, *sp );
+    }
 
-  /*
-   * Break the line up into fields.
-   */
-  final_empty = 0;
-  sp          = ep = line;
-  end         = sp + linelen;
-  for ( ; sp < end && *sp;)
-  {
-    /*
-     * Collect everything that is not a separator.
-     */
-    for ( ; *ep && !sbitset( seps, *ep ); ep++ ) ;
-
-    /*
-     * Resize the list if necessary.
-     */
-    if ( list->used == list->size )
+    /* Break the line up into fields. */
+    for ( final_empty = 0, sp = ep = line, end = sp + linelen;
+          sp < end && *sp; )
     {
-      if ( list->size == 0 )
+      /* Collect everything that is not a separator. */
+      for ( ; *ep && !sbitset( seps, *ep ); ep++ )
+        ;
+
+      /* Resize the list if necessary. */
+      if ( list->used == list->size )
       {
-        if ( FT_NEW_ARRAY( list->field , 5) )
-          return error;
+        if ( list->size == 0 )
+        {
+          if ( FT_NEW_ARRAY( list->field, 5 ) )
+            goto Exit;
+        }
+        else
+        {
+          if ( FT_RENEW_ARRAY ( list->field ,
+                                list->size,
+                                list->size + 5 ) )
+            goto Exit;
+        }
+
+        list->size += 5;
       }
-      else
+
+      /* Assign the field appropriately. */
+      list->field[list->used++] = ( ep > sp ) ? sp : empty;
+
+      sp = ep;
+
+      if ( mult )
       {
-        if ( FT_RENEW_ARRAY( list->field , list->size, list->size+5 )
-          return error;
+        /* If multiple separators should be collapsed, do it now by */
+        /* setting all the separator characters to 0.               */
+        for ( ; *ep && sbitset( seps, *ep ); ep++ )
+          *ep = 0;
       }
-      list->size += 5;
-    }
+      else if ( *ep != 0 )
+        /* Don't collapse multiple separators by making them 0, so just */
+        /* make the one encountered 0.                                  */
+        *ep++ = 0;
 
-    /*
-     * Assign the field appropriately.
-     */
-    list->field[ list->used++ ] = (ep > sp) ? sp : empty;
+      final_empty = ( ep > sp && *ep == 0 );
+      sp = ep;
+    }
 
-    sp = ep;
-    if (mult)
+    /* Finally, NULL-terminate the list. */
+    if ( list->used + final_empty + 1 >= list->size )
     {
-      /*
-       * If multiple separators should be collapsed, do it now by
-       * setting all the separator characters to 0.
-       */
-      for ( ; *ep && sbitset(seps, *ep); ep++ )
-        *ep = 0;
+      if ( list->used == list->size )
+      {
+        if ( list->size == 0 )
+        {
+          if ( FT_NEW_ARRAY( list->field, 5 ) )
+            goto Exit;
+        }
+        else
+        {
+          if ( FT_RENEW_ARRAY( list->field,
+                               list->size,
+                               list->size + 5 ) )
+            goto Exit;
+        }
 
-    }
-    else if (*ep != 0)
-    {
-      /*
-       * Don't collapse multiple separators by making them 0, so just
-       * make the one encountered 0.
-       */
-      *ep++ = 0;
+        list->size += 5;
+      }
     }
 
-    final_empty = ( ep > sp && *ep == 0 );
-    sp          = ep;
-  }
+    if ( final_empty )
+      list->field[list->used++] = empty;
 
-  /*
-   * Finally, NULL terminate the list.
-   */
-  if ( list->used + final_empty + 1 >= list->size )
-  {
     if ( list->used == list->size )
     {
       if ( list->size == 0 )
       {
         if ( FT_NEW_ARRAY( list->field, 5 ) )
-          return error;
+          goto Exit;
       }
       else
       {
-        if ( FT_RENEW_ARRAY( list->field , list->size, list->size+5 ) )
-          return error;
+        if ( FT_RENEW_ARRAY( list->field,
+                             list->size,
+                             list->size + 5 ) )
+          goto Exit;
       }
+
       list->size += 5;
     }
+
+    list->field[list->used] = 0;
+
+  Exit:
+    return error;
   }
 
-  if (final_empty)
-    list->field[ list->used++ ] = empty;
 
-  if ( list->used == list->size )
+  static void
+  _bdf_shift( unsigned long  n,
+              _bdf_list_t*   list )
   {
-    if ( list->size == 0 )
-    {
-      if ( FT_NEW_ARRAY( list->field , 5 ) )
-        return error;
-    }
-    else
+    unsigned long  i, u;
+
+
+    if ( list == 0 || list->used == 0 || n == 0 )
+      return;
+
+    if ( n >= list->used )
     {
-      if ( FT_NEW_ARRAY( list->field, list->size, list->size + 5 ) )
-        return error;
+      list->used = 0;
+      return;
     }
-    list->size += 5;
+
+    for ( u = n, i = 0; u < list->used; i++, u++ )
+      list->field[i] = list->field[u];
+    list->used -= n;
   }
-  list->field[ list->used ] = 0;
 
-  return FT_Err_Ok;
-}
 
+  static char *
+  _bdf_join( int             c,
+             unsigned long*  len,
+             _bdf_list_t*    list )
+  {
+    unsigned long  i, j;
+    char           *fp, *dp;
 
-static void
-_bdf_shift( unsigned long  n,
-            _bdf_list_t*   list)
-{
-  unsigned long i, u;
 
-  if ( list == 0 || list->used == 0 || n == 0 )
-    return;
+    if ( list == 0 || list->used == 0 )
+      return 0;
 
-  if ( n >= list->used )
-  {
-    list->used = 0;
-    return;
+    *len = 0;
+
+    dp = list->field[0];
+    for ( i = j = 0; i < list->used; i++ )
+    {
+      fp = list->field[i];
+      while ( *fp )
+        dp[j++] = *fp++;
+
+      if ( i + 1 < list->used )
+        dp[j++] = c;
+    }
+    dp[j] = 0;
+
+    *len = j;
+    return dp;
   }
-  for ( u = n, i = 0; u < list->used; i++, u++ )
-    list->field[i] = list->field[u];
 
-  list->used -= n;
-}
 
+  /* High speed file reader that passes each line to a callback. */
+  static FT_Error
+  bdf_internal_readstream( FT_Stream  stream,
+                           char*      buffer,
+                           int        count,
+                           int       *read_bytes )
+  {
+    int            rbytes;
+    unsigned long  pos   = stream->pos;
+    FT_Error       error = BDF_Err_Ok;
 
-static char*
-_bdf_join( int             c,
-           unsigned long*  len,
-           _bdf_list_t*    list)
-{
-  unsigned long i, j;
-  char *fp, *dp;
 
-  if ( list == 0 || list->used == 0 )
-    return 0;
+    if ( pos > stream->size )
+    {
+      FT_ERROR(( "bdf_internal_readstream:" ));
+      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+                 pos, stream->size ));
+      error = BDF_Err_Invalid_Stream_Operation;
+      goto Exit;
+    }
 
-  *len = 0;
+    if ( stream->read )
+      rbytes = stream->read( stream, pos,
+                             (unsigned char *)buffer, count );
+    else
+    {
+      rbytes = stream->size - pos;
+      if ( rbytes > count )
+        rbytes = count;
 
-  dp = list->field[0];
+      FT_MEM_COPY( buffer, stream->base + pos, rbytes );
+    }
 
-  for ( i = j = 0; i < list->used; i++ )
-  {
-    fp = list->field[i];
-    while (*fp)
-      dp[j++] = *fp++;
-      
-    if (i + 1 < list->used)
-      dp[j++] = c;
-  }
-  dp[j] = 0;
+    stream->pos = pos + rbytes;
 
-  *len = j;
-  return dp;
-}
+    *read_bytes = rbytes;
 
-/*
- * High speed file reader that passes each line to a callback.
- */
-int ftreadstream( FT_Stream  stream,
-                  char*      buffer,
-                  int        count )
-{
-  int read_bytes;
-  int pos = stream->pos;
-
-  if ( pos >= stream->size )
-  {
-    FT_ERROR(( "FT_Read_Stream_At:" ));
-    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
-               pos, stream->size ));
-    return 0;
+  Exit:
+    return error;
   }
 
-  if ( stream->read )
-    read_bytes = stream->read( stream, pos, buffer, count );
-  else
+
+  static FT_Error
+  _bdf_readstream( FT_Stream         stream,
+                   _bdf_line_func_t  callback,
+                   void*             client_data,
+                   unsigned long    *lno )
   {
-    read_bytes = stream->size - pos;
-    if ( read_bytes > count )
-      read_bytes = count;
+    _bdf_line_func_t  cb;
+    unsigned long     lineno;
+    int               n, res, done, refill, bytes, hold;
+    char              *ls, *le, *pp, *pe, *hp;
+    /* XXX: Use a dynamic buffer */
+    char              buf[65536L];
+    FT_Error          error = BDF_Err_Ok;
 
-    ft_memcpy( buffer, stream->base + pos, read_bytes );
-  }
 
-  stream->pos = pos + read_bytes;
-
-  return read_bytes;
-}
-
-static int
-_bdf_readstream( FT_Stream         stream,
-                 _bdf_line_func_t  callback,
-                 void*             client_data,
-                 unsigned long*    lno)
-{
-  _bdf_line_func_t cb;
-  unsigned long lineno;
-  int n, res, done, refill, bytes, hold;
-  char *ls, *le, *pp, *pe, *hp;
-  char buf[65536];
-
-  if (callback == 0)
-    return -1;
-
-  cb     = callback;
-  lineno = 1;
-  buf[0] = 0;
-  res    = done = 0;
-  pp     = ls = le = buf;
-  bytes  = 65536;
-
-  while ( !done && (n = ftreadstream(stream, pp, bytes)) > 0 )
-  {
-    /*
-     * Determine the new end of the buffer pages.
-     */
-    pe = pp + n;
+    if ( callback == 0 )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
 
-    for (refill = 0; done == 0 && refill == 0; )
+    cb     = callback;
+    lineno = 1;
+    buf[0] = 0;
+
+    res = done = 0;
+    pp = ls = le = buf;
+
+    bytes = 65536L;
+
+    while ( !done )
     {
-      while (le < pe && *le != '\n' && *le != '\r')
-        le++;
+      error = bdf_internal_readstream( stream, pp, bytes, &n );
+      if ( error )
+        goto Exit;
 
-      if (le == pe)
-      {
-        /*
-         * Hit the end of the last page in the buffer.  Need to find
-         * out how many pages to shift and how many pages need to be
-         * read in.  Adjust the line start and end pointers down to
-         * point to the right places in the pages.
-         */
-        pp = buf + (((ls - buf) >> 13) << 13);
-        n = pp - buf;
-        ls -= n;
-        le -= n;
-        n   = pe - pp;
-        (void) ft_memcpy(buf, pp, n);
-        pp = buf + n;
-        bytes = 65536 - n;
-        refill = 1;
-      }
-      else
+      if ( n == 0 )
+        break;
+
+      /* Determine the new end of the buffer pages. */
+      pe = pp + n;
+
+      for ( refill = 0; done == 0 && refill == 0; )
       {
-        /*
-         * Temporarily NULL terminate the line.
-         */
-        hp   = le;
-        hold = *le;
-        *le  = 0;
-
-        if (callback && *ls != '#' && *ls != 0x1a && le > ls &&
-            (res = (*cb)(ls, le - ls, lineno, (void *) &cb,
-                         client_data)) != 0)
-          done = 1;
-        else {
+        while ( le < pe && *le != '\n' && *le != '\r' )
+          le++;
+
+        if ( le == pe )
+        {
+          /* Hit the end of the last page in the buffer.  Need to find */
+          /* out how many pages to shift and how many pages need to be */
+          /* read in.  Adjust the line start and end pointers down to  */
+          /* point to the right places in the pages.                   */
+
+          pp  = buf + ( ( ( ls - buf ) >> 13 ) << 13 );
+          n   = pp - buf;
+          ls -= n;
+          le -= n;
+          n   = pe - pp;
+
+          FT_MEM_COPY( buf, pp, n );
+
+          pp     = buf + n;
+          bytes  = 65536L - n;
+          refill = 1;
+        }
+        else
+        {
+          /* Temporarily NULL-terminate the line. */
+          hp   = le;
+          hold = *le;
+          *le  = 0;
+
+          /* XXX: Use encoding independent value for 0x1a */
+          if ( *ls != '#' && *ls != 0x1a                          &&
+               le > ls                                            &&
+               ( error = (*cb)( ls, le - ls, lineno, (void *)&cb,
+                                client_data ) ) != BDF_Err_Ok     )
+            done = 1;
+          else
+          {
             ls = ++le;
-            /*
-             * Handle the case of DOS crlf sequences.
-             */
-            if (le < pe && hold == '\n' && *le =='\r')
+            /* Handle the case of DOS crlf sequences. */
+            if ( le < pe && hold == '\n' && *le =='\r' )
               ls = ++le;
-        }
+          }
 
-        /*
-         * Increment the line number.
-         */
-        lineno++;
+          /* Increment the line number. */
+          lineno++;
 
-        /*
-         * Restore the character at the end of the line.
-         */
-        *hp = hold;
+          /* Restore the character at the end of the line. */
+          *hp = hold;
+        }
       }
     }
+
+    *lno             = lineno;
+
+  Exit:
+    return error;
   }
-  *lno = lineno;
-  return res;
-}
-
-
-FT_LOCAL_DEF( void )
-_bdf_memmove(char *dest, char *src, unsigned long bytes)
-{
-    long i, j;
-
-    i = (long) bytes;
-    j = i & 7;
-    i = (i + 7) >> 3;
-
-    /*
-     * Do a memmove using Ye Olde Duff's Device for efficiency.
-     */
-    if (src < dest) {
-        src += bytes;
-        dest += bytes;
-
-        switch (j) {
-          case 0: do {
-              *--dest = *--src;
-            case 7: *--dest = *--src;
-            case 6: *--dest = *--src;
-            case 5: *--dest = *--src;
-            case 4: *--dest = *--src;
-            case 3: *--dest = *--src;
-            case 2: *--dest = *--src;
-            case 1: *--dest = *--src;
-          } while (--i > 0);
-        }
-    } else if (src > dest) {
-        switch (j) {
-          case 0: do {
-              *dest++ = *src++;
-            case 7: *dest++ = *src++;
-            case 6: *dest++ = *src++;
-            case 5: *dest++ = *src++;
-            case 4: *dest++ = *src++;
-            case 3: *dest++ = *src++;
-            case 2: *dest++ = *src++;
-            case 1: *dest++ = *src++;
-          } while (--i > 0);
-        }
-    }
-}
 
-static const unsigned char a2i[128] = {
+
+  /* XXX: make this work with EBCDIC also */
+
+  static unsigned char  a2i[128] =
+  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -816,592 +750,596 @@ static const unsigned char a2i[128] = {
     0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
+  };
 
-static const unsigned char odigits[32] = {
+  static unsigned char  odigits[32] =
+  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
+  };
 
-static const unsigned char ddigits[32] = {
+  static unsigned char  ddigits[32] =
+  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
+  };
 
-static const unsigned char hdigits[32] = {
+  static unsigned char  hdigits[32] =
+  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
     0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
-
-#define isdigok(m, d) (m[(d) >> 3] & (1 << ((d) & 7)))
+  };
 
-/*
- * Routine to convert an ASCII string into an unsigned long integer.
- */
-static unsigned long
-_bdf_atoul(char *s, char **end, int base)
-{
-  unsigned long v;
-  unsigned char *dmap;
 
-  if (s == 0 || *s == 0)
-    return 0;
+#define isdigok( m, d )  (m[(d) >> 3] & ( 1 << ( (d) & 7 ) ) )
 
-  /*
-   * Make sure the radix is something recognizable.  Default to 10.
-   */
-  switch (base)
-  {
-    case 8: dmap = odigits; break;
-    case 16: dmap = hdigits; break;
-    default: base = 10; dmap = ddigits; break;
-  }
 
-  /*
-   * Check for the special hex prefix.
-   */
-  if ( s[0] == '0' && ( s[1] == 'x' || s[1] == 'X'))
+  /* Routine to convert an ASCII string into an unsigned long integer. */
+  static unsigned long
+  _bdf_atoul( char*   s,
+              char**  end,
+              int     base )
   {
-    base = 16;
-    dmap = hdigits;
-    s   += 2;
-  }
+    unsigned long   v;
+    unsigned char*  dmap;
 
-  for ( v = 0; isdigok(dmap, *s); s++ )
-    v = (v * base) + a2i[(int) *s];
 
-  if (end != 0)
-    *end = s;
+    if ( s == 0 || *s == 0 )
+      return 0;
 
-  return v;
-}
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
+    }
 
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
+      base = 16;
+      dmap = hdigits;
+      s   += 2;
+    }
 
-/*
- * Routine to convert an ASCII string into an signed long integer.
- */
-static long
-_bdf_atol(char *s, char **end, int base)
-{
-  long v, neg;
-  unsigned char *dmap;
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = v * base + a2i[(int)*s];
 
-  if (s == 0 || *s == 0)
-    return 0;
+    if ( end != 0 )
+      *end = s;
 
-  /*
-   * Make sure the radix is something recognizable.  Default to 10.
-   */
-  switch (base) {
-    case 8: dmap = odigits; break;
-    case 16: dmap = hdigits; break;
-    default: base = 10; dmap = ddigits; break;
+    return v;
   }
 
-  /*
-   * Check for a minus sign.
-   */
-  neg = 0;
-  if (*s == '-') {
+
+  /* Routine to convert an ASCII string into an signed long integer. */
+  static long
+  _bdf_atol( char*   s,
+             char**  end,
+             int     base )
+  {
+    long            v, neg;
+    unsigned char*  dmap;
+
+
+    if ( s == 0 || *s == 0 )
+      return 0;
+
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
+    }
+
+    /* Check for a minus sign. */
+    neg = 0;
+    if ( *s == '-' )
+    {
       s++;
       neg = 1;
-  }
+    }
 
-  /*
-   * Check for the special hex prefix.
-   */
-  if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
       base = 16;
       dmap = hdigits;
-      s += 2;
-  }
+      s   += 2;
+    }
 
-  for (v = 0; isdigok(dmap, *s); s++)
-    v = (v * base) + a2i[(int) *s];
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = v * base + a2i[(int)*s];
 
-  if (end != 0)
-    *end = s;
+    if ( end != 0 )
+      *end = s;
 
-  return (!neg) ? v : -v;
-}
+    return ( !neg ) ? v : -v;
+  }
 
 
-/*
- * Routine to convert an ASCII string into an signed short integer.
- */
-static short
-_bdf_atos(char *s, char **end, int base)
-{
-    short v, neg;
-    unsigned char *dmap;
+  /* Routine to convert an ASCII string into an signed short integer. */
+  static short
+  _bdf_atos( char*   s,
+             char**  end,
+             int     base )
+  {
+    short           v, neg;
+    unsigned char*  dmap;
 
-    if (s == 0 || *s == 0)
+
+    if ( s == 0 || *s == 0 )
       return 0;
 
-    /*
-     * Make sure the radix is something recognizable.  Default to 10.
-     */
-    switch (base) {
-      case 8: dmap = odigits; break;
-      case 16: dmap = hdigits; break;
-      default: base = 10; dmap = ddigits; break;
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
     }
 
-    /*
-     * Check for a minus.
-     */
+    /* Check for a minus. */
     neg = 0;
-    if (*s == '-') {
-        s++;
-        neg = 1;
+    if ( *s == '-' )
+    {
+      s++;
+      neg = 1;
     }
 
-    /*
-     * Check for the special hex prefix.
-     */
-    if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')) {
-        base = 16;
-        dmap = hdigits;
-        s += 2;
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
+      base = 16;
+      dmap = hdigits;
+      s   += 2;
     }
 
-    for (v = 0; isdigok(dmap, *s); s++)
-      v = (v * base) + a2i[(int) *s];
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = v * base + a2i[(int)*s];
 
-    if (end != 0)
+    if ( end != 0 )
       *end = s;
 
-    return (!neg) ? v : -v;
-}
+    return ( !neg ) ? v : -v;
+  }
 
-/*
- * Routine to compare two glyphs by encoding so they can be sorted.
- */
-static int
-by_encoding(const void *a, const void *b)
-{
-    bdf_glyph_t *c1, *c2;
-
-    c1 = (bdf_glyph_t *) a;
-    c2 = (bdf_glyph_t *) b;
-    if (c1->encoding < c2->encoding)
-      return -1;
-    else if (c1->encoding > c2->encoding)
-      return 1;
-    return 0;
-}
 
+  /* Routine to compare two glyphs by encoding so they can be sorted. */
+  static int
+  by_encoding( const void*  a,
+               const void*  b )
+  {
+    bdf_glyph_t  *c1, *c2;
 
 
-static FT_Error
-bdf_create_property( char*        name,
-                     int          format,
-                     bdf_font_t*  font )
-{
-  unsigned long    n;
-  bdf_property_t*  p;
-  FT_Memory        memory = font->memory;
-  FT_Error         error;
+    c1 = (bdf_glyph_t *)a;
+    c2 = (bdf_glyph_t *)b;
 
-  /*
-   * First check to see if the property has
-   * already been added or not.  If it has, then
-   * simply ignore it.
-   */
-  if ( hash_lookup( name, &(font->proptbl)) )
-    return FT_Err_Ok;
+    if ( c1->encoding < c2->encoding )
+      return -1;
+    else if ( c1->encoding > c2->encoding )
+      return 1;
 
-  if (font->nuser_props == 0)
-  {
-    if ( FT_NEW( font->user_props ) )
-      return error;
-  }
-  else
-  {
-    if ( FT_RENEW_ARRAY( font->user_props, font->nuser_props,
-                                          (font->nuser_props + 1) ) )
-      return error;
+    return 0;
   }
 
-  p = font->user_props + font->nuser_props;
-  
-  FT_ZERO( p );
-  
-  n = (unsigned long) (ft_strlen(name) + 1);
-  
-  if ( FT_ALLOC ( p->name , n) )
-    return error;
-    
-  FT_MEM_COPY(p->name, name, n);
-  p->format  = format;
-  p->builtin = 0;
 
-  n = _num_bdf_properties + font->nuser_props;
+  static FT_Error
+  bdf_create_property( char*        name,
+                       int          format,
+                       bdf_font_t*  font )
+  {
+    unsigned long    n;
+    bdf_property_t*  p;
+    FT_Memory        memory = font->memory;
+    FT_Error         error = BDF_Err_Ok;
 
-  error = hash_insert(p->name, (void *) n, &(font->proptbl) , memory);
-  if (error) return error;
 
-  font->nuser_props++;
-  return FT_Err_Ok;
-}
+    /* First check to see if the property has      */
+    /* already been added or not.  If it has, then */
+    /* simply ignore it.                           */
+    if ( hash_lookup( name, &(font->proptbl) ) )
+      goto Exit;
 
+    if ( font->nuser_props == 0 )
+    {
+      if ( FT_NEW_ARRAY( font->user_props, 1 ) )
+        goto Exit;
+    }
+    else
+    {
+      if ( FT_RENEW_ARRAY( font->user_props,
+                           font->nuser_props,
+                           font->nuser_props + 1 ) )
+        goto Exit;
+    }
 
-FT_LOCAL_DEF( bdf_property_t* )
-bdf_get_property(char *name, bdf_font_t *font)
-{
-  hashnode hn;
-  unsigned long propid;
+    p = font->user_props + font->nuser_props;
+    FT_MEM_SET( p, 0, sizeof ( bdf_property_t ) );
 
-  if (name == 0 || *name == 0)
-    return 0;
+    n = (unsigned long)( ft_strlen( name ) + 1 );
+    if ( FT_NEW_ARRAY( p->name, n ) )
+      goto Exit;
 
-  if ((hn = hash_lookup(name, &(font->proptbl))) == 0)
-    return 0;
+    FT_MEM_COPY( (char *)p->name, name, n );
 
-  propid = (unsigned long) hn->data;
-  if (propid >= _num_bdf_properties)
-    return font->user_props + (propid - _num_bdf_properties);
+    p->format  = format;
+    p->builtin = 0;
 
-  return _bdf_properties + propid;
-}
+    n = _num_bdf_properties + font->nuser_props;
 
+    error = hash_insert( p->name, (void *)n, &(font->proptbl), memory );
+    if ( error )
+      goto Exit;
 
-/**************************************************************************
- *
- * BDF font file parsing flags and functions.
- *
- **************************************************************************/
+    font->nuser_props++;
 
-/*
- * Parse flags.
- */
-#define _BDF_START     0x0001
-#define _BDF_FONT_NAME 0x0002
-#define _BDF_SIZE      0x0004
-#define _BDF_FONT_BBX  0x0008
-#define _BDF_PROPS     0x0010
-#define _BDF_GLYPHS    0x0020
-#define _BDF_GLYPH     0x0040
-#define _BDF_ENCODING  0x0080
-#define _BDF_SWIDTH    0x0100
-#define _BDF_DWIDTH    0x0200
-#define _BDF_BBX       0x0400
-#define _BDF_BITMAP    0x0800
-
-#define _BDF_SWIDTH_ADJ 0x1000
-
-#define _BDF_GLYPH_BITS (_BDF_GLYPH|_BDF_ENCODING|_BDF_SWIDTH|\
-                         _BDF_DWIDTH|_BDF_BBX|_BDF_BITMAP)
-
-#define _BDF_GLYPH_WIDTH_CHECK 0x40000000
-#define _BDF_GLYPH_HEIGHT_CHECK 0x80000000
+  Exit:
+    return error;
+  }
 
-/*
- * Auto correction messages.
- */
-#define ACMSG1 "FONT_ASCENT property missing.  Added \"FONT_ASCENT %hd\"."
-#define ACMSG2 "FONT_DESCENT property missing.  Added \"FONT_DESCENT %hd\"."
-#define ACMSG3 "Font width != actual width.  Old: %hd New: %hd."
-#define ACMSG4 "Font left bearing != actual left bearing.  Old: %hd New: %hd."
-#define ACMSG5 "Font ascent != actual ascent.  Old: %hd New: %hd."
-#define ACMSG6 "Font descent != actual descent.  Old: %hd New: %hd."
-#define ACMSG7 "Font height != actual height. Old: %hd New: %hd."
-#define ACMSG8 "Glyph scalable width (SWIDTH) adjustments made."
-#define ACMSG9 "SWIDTH field missing at line %ld.  Set automatically."
-#define ACMSG10 "DWIDTH field missing at line %ld.  Set to glyph width."
-#define ACMSG11 "SIZE bits per pixel field adjusted to %hd."
-#define ACMSG12 "Duplicate encoding %ld (%s) changed to unencoded."
-#define ACMSG13 "Glyph %ld extra rows removed."
-#define ACMSG14 "Glyph %ld extra columns removed."
-#define ACMSG15 "Incorrect glyph count: %ld indicated but %ld found."
 
-/*
- * Error messages.
- */
-#define ERRMSG1 "[line %ld] Missing \"%s\" line."
-#define ERRMSG2 "[line %ld] Font header corrupted or missing fields."
-#define ERRMSG3 "[line %ld] Font glyphs corrupted or missing fields."
-
-static FT_Error
-_bdf_add_acmsg ( bdf_font_t*    font,
-                 char*          msg,
-                 unsigned long  len )
-{
-  char*      cp;
-  FT_Memory  memory = font->memory;
-  FT_Error   error;
-
-  if ( font->acmsgs_len == 0 )
+  FT_LOCAL_DEF( bdf_property_t * )
+  bdf_get_property( char*        name,
+                    bdf_font_t*  font )
   {
-    if ( FT_ALLOC ( font->acmsgs , len + 1 ) )
-      return error;
-  }
-  else
-  {
-    if ( FT_REALLOC ( font->acmsgs , font->acmsgs_len ,
-                      font->acmsgs_len + len + 1 ) )
-      return error;
-  }
+    hashnode       hn;
+    unsigned long  propid;
 
-  cp = font->acmsgs + font->acmsgs_len;
-  FT_MEM_COPY(cp, msg, len);
-  cp   += len;
-  *cp++ = '\n';
-  font->acmsgs_len += len + 1;
 
-  return FT_Err_Ok;
-}
+    if ( name == 0 || *name == 0 )
+      return 0;
 
+    if ( ( hn = hash_lookup( name, &(font->proptbl) ) ) == 0 )
+      return 0;
 
-static FT_Error
-_bdf_add_comment ( bdf_font_t*    font,
-                   char*          comment,
-                   unsigned long  len )
-{
-  char *cp;
-  FT_Memory memory = font->memory;
-  FT_Error error;
+    propid = (unsigned long)hn->data;
+    if ( propid >= _num_bdf_properties )
+      return font->user_props + ( propid - _num_bdf_properties );
 
-  if (font->comments_len == 0) {
-    if ( FT_ALLOC ( font->comments , len + 1 ) )
-      return error;
+    return _bdf_properties + propid;
   }
-  else
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font file parsing flags and functions.                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Parse flags. */
+
+#define _BDF_START      0x0001
+#define _BDF_FONT_NAME  0x0002
+#define _BDF_SIZE       0x0004
+#define _BDF_FONT_BBX   0x0008
+#define _BDF_PROPS      0x0010
+#define _BDF_GLYPHS     0x0020
+#define _BDF_GLYPH      0x0040
+#define _BDF_ENCODING   0x0080
+#define _BDF_SWIDTH     0x0100
+#define _BDF_DWIDTH     0x0200
+#define _BDF_BBX        0x0400
+#define _BDF_BITMAP     0x0800
+
+#define _BDF_SWIDTH_ADJ  0x1000
+
+#define _BDF_GLYPH_BITS ( _BDF_GLYPH    | \
+                          _BDF_ENCODING | \
+                          _BDF_SWIDTH   | \
+                          _BDF_DWIDTH   | \
+                          _BDF_BBX      | \
+                          _BDF_BITMAP   )
+
+#define _BDF_GLYPH_WIDTH_CHECK   0x40000000L
+#define _BDF_GLYPH_HEIGHT_CHECK  0x80000000L
+
+
+  /* Auto correction messages. */
+#define ACMSG1   "FONT_ASCENT property missing.  " \
+                 "Added \"FONT_ASCENT %hd\".\n"
+#define ACMSG2   "FONT_DESCENT property missing.  " \
+                 "Added \"FONT_DESCENT %hd\".\n"
+#define ACMSG3   "Font width != actual width.  Old: %hd New: %hd.\n"
+#define ACMSG4   "Font left bearing != actual left bearing.  " \
+                 "Old: %hd New: %hd.\n"
+#define ACMSG5   "Font ascent != actual ascent.  Old: %hd New: %hd.\n"
+#define ACMSG6   "Font descent != actual descent.  Old: %hd New: %hd.\n"
+#define ACMSG7   "Font height != actual height. Old: %hd New: %hd.\n"
+#define ACMSG8   "Glyph scalable width (SWIDTH) adjustments made.\n"
+#define ACMSG9   "SWIDTH field missing at line %ld.  Set automatically.\n"
+#define ACMSG10  "DWIDTH field missing at line %ld.  Set to glyph width.\n"
+#define ACMSG11  "SIZE bits per pixel field adjusted to %hd.\n"
+#define ACMSG12  "Duplicate encoding %ld (%s) changed to unencoded.\n"
+#define ACMSG13  "Glyph %ld extra rows removed.\n"
+#define ACMSG14  "Glyph %ld extra columns removed.\n"
+#define ACMSG15  "Incorrect glyph count: %ld indicated but %ld found.\n"
+
+  /* Error messages. */
+#define ERRMSG1  "[line %ld] Missing \"%s\" line.\n"
+#define ERRMSG2  "[line %ld] Font header corrupted or missing fields.\n"
+#define ERRMSG3  "[line %ld] Font glyphs corrupted or missing fields.\n"
+
+
+  static FT_Error
+  _bdf_add_comment( bdf_font_t*    font,
+                    char*          comment,
+                    unsigned long  len )
   {
-    if ( FT_REALLOC ( font->comments , font->comments_len,
-                      font->comments_len + len + 1) )
-      return error;
+    char*      cp;
+    FT_Memory  memory = font->memory;
+    FT_Error   error = BDF_Err_Ok;
+
+
+    if ( font->comments_len == 0 )
+    {
+      if ( FT_NEW_ARRAY( font->comments, len + 1 ) )
+        goto Exit;
+    }
+    else
+    {
+      if ( FT_RENEW_ARRAY( font->comments,
+                           font->comments_len,
+                           font->comments_len + len + 1 ) )
+        goto Exit;
+    }
+
+    cp = font->comments + font->comments_len;
+    FT_MEM_COPY( cp, comment, len );
+    cp   += len;
+    *cp++ = '\n';
+    font->comments_len += len + 1;
+
+  Exit:
+    return error;
   }
 
-  cp = font->comments + font->comments_len;
-  FT_MEM_COPY(cp, comment, len);
-  cp += len;
-  *cp++ = '\n';
-  font->comments_len += len + 1;
 
-  return FT_Err_Ok;
-}
+  /* Set the spacing from the font name if it exists, or set it to the */
+  /* default specified in the options.                                 */
+  static FT_Error
+  _bdf_set_default_spacing( bdf_font_t*     font,
+                            bdf_options_t*  opts )
+  {
+    unsigned long  len;
+    char           name[128];
+    _bdf_list_t    list;
+    FT_Memory      memory;
+    FT_Error       error = BDF_Err_Ok;
 
-/*
- * Set the spacing from the font name if it exists, or set it to the default
- * specified in the options.
- */
-static void
-_bdf_set_default_spacing( bdf_font_t*     font,
-                          bdf_options_t*  opts)
-{
-  unsigned long  len;
-  char            name[128];
-  _bdf_list_t     list;
-  FT_Memory       memory;
-  /*    FT_Error error; */
-
-  if ( font == 0 || font->name == 0 || font->name[0] == 0 )
-    return;
-
-  memory = font->memory;
-
-  font->spacing = opts->font_spacing;
-
-  len = (unsigned long) ( ft_strlen(font->name) + 1 );
-  (void) ft_memcpy(name, font->name, len);
-  
-  list.size = list.used = 0;
-  _bdf_split("-", name, len, &list, memory);
-  
-  if (list.used == 15) {
-      switch (list.field[11][0]) {
-        case 'C': case 'c': font->spacing = BDF_CHARCELL; break;
-        case 'M': case 'm': font->spacing = BDF_MONOWIDTH; break;
-        case 'P': case 'p': font->spacing = BDF_PROPORTIONAL; break;
+
+    if ( font == 0 || font->name == 0 || font->name[0] == 0 )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    memory = font->memory;
+
+    font->spacing = opts->font_spacing;
+
+    len = (unsigned long)( ft_strlen( font->name ) + 1 );
+    FT_MEM_COPY( name, font->name, len );
+
+    list.size = list.used = 0;
+
+    error = _bdf_split( (char *)"-", name, len, &list, memory );
+    if ( error )
+      goto Exit;
+
+    if ( list.used == 15 )
+    {
+      switch ( list.field[11][0] )
+      {
+      case 'C':
+      case 'c':
+        font->spacing = BDF_CHARCELL;
+        break;
+      case 'M':
+      case 'm':
+        font->spacing = BDF_MONOWIDTH;
+        break;
+      case 'P':
+      case 'p':
+        font->spacing = BDF_PROPORTIONAL;
+        break;
       }
+    }
+
+    FT_FREE( list.field );
+
+  Exit:
+    return error;
   }
-  if (list.size > 0)
-    FT_FREE(list.field);
-}
 
 
-/*
- * Determine if the property is an atom or not.  If it is, then clean it up so
- * the double quotes are removed if they exist.
- */
-static int
-_bdf_is_atom( char*          line,
-              unsigned long  linelen,
-              char*         *name,
-              char*         *value,
-	      bdf_font_t*    font)
-{
-    int hold;
-    char *sp, *ep;
-    bdf_property_t *p;
+  /* Determine whether the property is an atom or not.  If it is, then */
+  /* clean it up so the double quotes are removed if they exist.       */
+  static int
+  _bdf_is_atom( char*          line,
+                unsigned long  linelen,
+                char**         name,
+                char**         value,
+                bdf_font_t*    font )
+  {
+    int              hold;
+    char             *sp, *ep;
+    bdf_property_t*  p;
+
 
     *name = sp = ep = line;
-    while (*ep && *ep != ' ' && *ep != '\t')
+
+    while ( *ep && *ep != ' ' && *ep != '\t' )
       ep++;
 
     hold = -1;
-    if (*ep)
+    if ( *ep )
     {
       hold = *ep;
       *ep  = 0;
     }
 
-    p = bdf_get_property(sp, font);
+    p = bdf_get_property( sp, font );
 
-    /*
-     * Restore the character that was saved before any return can happen.
-     */
-    if (hold != -1)
+    /* Restore the character that was saved before any return can happen. */
+    if ( hold != -1 )
       *ep = hold;
 
-    /*
-     * If the propert exists and is not an atom, just return here.
-     */
-    if (p && p->format != BDF_ATOM)
+    /* If the property exists and is not an atom, just return here. */
+    if ( p && p->format != BDF_ATOM )
       return 0;
 
-    /*
-     * The property is an atom.  Trim all leading and trailing whitespace and
-     * double quotes for the atom value.
-     */
+    /* The property is an atom.  Trim all leading and trailing whitespace */
+    /* and double quotes for the atom value.                              */
     sp = ep;
     ep = line + linelen;
 
-    /*
-     * Trim the leading whitespace if it exists.
-     */
+    /* Trim the leading whitespace if it exists. */
     *sp++ = 0;
-    while (*sp && (*sp == ' ' || *sp == '\t'))
+    while ( *sp                           &&
+            ( *sp == ' ' || *sp == '\t' ) )
       sp++;
 
-    /*
-     * Trim the leading double quote if it exists.
-     */
-    if (*sp == '"')
+    /* Trim the leading double quote if it exists. */
+    if ( *sp == '"' )
       sp++;
     *value = sp;
 
-    /*
-     * Trim the trailing whitespace if it exists.
-     */
-    while (ep > sp && (*(ep - 1) == ' ' || *(ep - 1) == '\t'))
+    /* Trim the trailing whitespace if it exists. */
+    while ( ep > sp                                       &&
+            ( *( ep - 1 ) == ' ' || *( ep - 1 ) == '\t' ) )
       *--ep = 0;
 
-    /*
-     * Trim the trailing double quote if it exists.
-     */
-    if (ep > sp && *(ep - 1) == '"')
+    /* Trim the trailing double quote if it exists. */
+    if ( ep > sp && *( ep - 1 ) == '"' )
       *--ep = 0;
 
     return 1;
-}
-
-
-static FT_Error
-_bdf_add_property ( bdf_font_t*  font,
-                    char*        name,
-                    char*        value)
-{
-    unsigned long propid;
-    hashnode hn;
-    int len;
-    bdf_property_t *prop, *fp;
-    FT_Memory memory = font->memory;
-    FT_Error error;
-    /*    hashtable proptbl = font->proptbl;
-    bdf_property_t *user_props = font->user_props;
-    unsigned long nuser_props = font->nuser_props;
-    */
-
-     /*
-     * First, check to see if the property already exists in the font.
-     */
-    if ((hn = hash_lookup(name, (hashtable *) font->internal)) != 0) {
-        /*
-         * The property already exists in the font, so simply replace
-         * the value of the property with the current value.
-         */
-        fp = font->props + (unsigned long) hn->data;
-
-        switch (prop->format)
+  }
+
+
+  static FT_Error
+  _bdf_add_property( bdf_font_t*  font,
+                     char*        name,
+                     char*        value )
+  {
+    unsigned long   propid;
+    hashnode        hn;
+    int             len;
+    bdf_property_t  *prop, *fp;
+    FT_Memory       memory = font->memory;
+    FT_Error        error = BDF_Err_Ok;
+
+
+    /* First, check to see if the property already exists in the font. */
+    if ( ( hn = hash_lookup( name, (hashtable *)font->internal ) ) != 0 )
+    {
+      /* The property already exists in the font, so simply replace */
+      /* the value of the property with the current value.          */
+      fp = font->props + (unsigned long)hn->data;
+
+      switch ( prop->format )
+      {
+      case BDF_ATOM:
+        /* Delete the current atom if it exists. */
+        FT_FREE( fp->value.atom );
+
+        if ( value == 0 )
+          len = 1;
+        else
+          len = ft_strlen( value ) + 1;
+
+        if ( len > 1 )
         {
-          case BDF_ATOM:
-            {
-              /*
-               * Delete the current atom if it exists.
-               */
-              FT_FREE ( fp->value.atom );
-  
-              if (value == 0)
-                len = 1;
-              else
-                len = ft_strlen(value) + 1;
-              if (len > 1)
-              {
-  	      if ( FT_ALLOC ( fp->value.atom , len ) )
-                  return error;
-                  
-                FT_MEM_COPY(fp->value.atom, value, len);
-              }
-              else
-                fp->value.atom = 0;
-            }
-            break;
-            
-          case BDF_INTEGER:
-            fp->value.int32 = _bdf_atol(value, 0, 10);
-            break;
-            
-          case BDF_CARDINAL:
-            fp->value.card32 = _bdf_atoul(value, 0, 10);
-            break;
-          
-          default:
-            ;
+          if ( FT_NEW_ARRAY( fp->value.atom, len ) )
+            goto Exit;
+          FT_MEM_COPY( fp->value.atom, value, len );
         }
-        return FT_Err_Ok;
+        else
+          fp->value.atom = 0;
+        break;
+
+      case BDF_INTEGER:
+        fp->value.int32 = _bdf_atol( value, 0, 10 );
+        break;
+
+      case BDF_CARDINAL:
+        fp->value.card32 = _bdf_atoul( value, 0, 10 );
+        break;
+      }
+
+      goto Exit;
     }
 
-    /*
-     * See if this property type exists yet or not.  If not, create it.
-     */
-    hn = hash_lookup(name, &(font->proptbl));
-    if (hn == 0) {
-        bdf_create_property(name, BDF_ATOM, font);
-        hn = hash_lookup(name, &(font->proptbl));
+    /* See whether this property type exists yet or not. */
+    /* If not, create it.                                */
+    hn = hash_lookup( name, &(font->proptbl) );
+    if ( hn == 0 )
+    {
+      error = bdf_create_property( name, BDF_ATOM, font );
+      if ( error )
+        goto Exit;
+      hn = hash_lookup( name, &(font->proptbl) );
     }
 
-    /*
-     * Allocate another property if this is overflow.
-     */
-    if (font->props_used == font->props_size)
+    /* Allocate another property if this is overflow. */
+    if ( font->props_used == font->props_size )
     {
-      if (font->props_size == 0)
+      if ( font->props_size == 0 )
       {
-        if ( FT_NEW( font->props ) )
-          return error;
+        if ( FT_NEW_ARRAY( font->props, 1 ) )
+          goto Exit;
       }
       else
       {
-        if ( FT_RENEW_ARRAY( font->props, font->props_size,
-                                         (font->props_size + 1) ) )
-          return error;
+        if ( FT_RENEW_ARRAY( font->props,
+                             font->props_size,
+                             font->props_size + 1 ) )
+          goto Exit;
       }
+
       fp = font->props + font->props_size;
-      FT_ZERO( fp );
+      FT_MEM_SET( fp, 0, sizeof ( bdf_property_t ) );
       font->props_size++;
     }
 
-    propid = (unsigned long) hn->data;
-    if (propid >= _num_bdf_properties)
-      prop = font->user_props + (propid - _num_bdf_properties);
+    propid = (unsigned long)hn->data;
+    if ( propid >= _num_bdf_properties )
+      prop = font->user_props + ( propid - _num_bdf_properties );
     else
       prop = _bdf_properties + propid;
 
@@ -1411,1055 +1349,1062 @@ _bdf_add_property ( bdf_font_t*  font,
     fp->format  = prop->format;
     fp->builtin = prop->builtin;
 
-    switch (prop->format)
+    switch ( prop->format )
     {
-      case BDF_ATOM:
-        {
-          fp->value.atom = NULL;
-          
-          if ( value && value[0] != 0 )
-          {
-            len = ft_strlen(value) + 1;
+    case BDF_ATOM:
+      if ( value == 0 )
+        len = 1;
+      else
+        len = ft_strlen( value ) + 1;
 
-  	    if ( FT_ALLOC ( fp->value.atom , len ) )
-                return error;
-                
-             FT_MEM_COPY (fp->value.atom, value, len);
-          }
-        }
-        break;
+      if ( len > 1 )
+      {
+        if ( FT_NEW_ARRAY( fp->value.atom, len ) )
+          goto Exit;
+        FT_MEM_COPY( fp->value.atom, value, len );
+      }
+      else
+        fp->value.atom = 0;
+      break;
 
     case BDF_INTEGER:
-      fp->value.int32 = _bdf_atol(value, 0, 10);
+      fp->value.int32 = _bdf_atol( value, 0, 10 );
       break;
 
     case BDF_CARDINAL:
-      fp->value.card32 = _bdf_atoul(value, 0, 10);
+      fp->value.card32 = _bdf_atoul( value, 0, 10 );
       break;
-    
-    default:
-      ;
     }
 
-    /*
-     * If the property happens to be a comment, then it doesn't need
-     * to be added to the internal hash table.
-     */
-    if ( ft_memcmp(name, "COMMENT", 7) != 0 )
-      /*
-       * Add the property to the font property table.
-       */
-      hash_insert( fp->name, (void *) font->props_used,
-                   (hashtable *) font->internal, memory);
+    /* If the property happens to be a comment, then it doesn't need */
+    /* to be added to the internal hash table.                       */
+    if ( ft_memcmp( name, "COMMENT", 7 ) != 0 ) {
+      /* Add the property to the font property table. */
+      error = hash_insert( fp->name,
+                           (void *)font->props_used,
+                           (hashtable *)font->internal,
+                           memory );
+      if ( error )
+        goto Exit;
+    }
 
     font->props_used++;
 
-    /*
-     * Some special cases need to be handled here.  The DEFAULT_CHAR property
-     * needs to be located if it exists in the property list, the FONT_ASCENT
-     * and FONT_DESCENT need to be assigned if they are present, and the
-     * SPACING property should override the default spacing.
-     */
-    if ( ft_memcmp(name, "DEFAULT_CHAR", 12) == 0 )
+    /* Some special cases need to be handled here.  The DEFAULT_CHAR       */
+    /* property needs to be located if it exists in the property list, the */
+    /* FONT_ASCENT and FONT_DESCENT need to be assigned if they are        */
+    /* present, and the SPACING property should override the default       */
+    /* spacing.                                                            */
+    if ( ft_memcmp( name, "DEFAULT_CHAR", 12 ) == 0 )
       font->default_glyph = fp->value.int32;
-      
-    else if ( ft_memcmp(name, "FONT_ASCENT", 11) == 0 )
+    else if ( ft_memcmp( name, "FONT_ASCENT", 11 ) == 0 )
       font->font_ascent = fp->value.int32;
-      
-    else if ( ft_memcmp(name, "FONT_DESCENT", 12) == 0 )
+    else if ( ft_memcmp( name, "FONT_DESCENT", 12 ) == 0 )
       font->font_descent = fp->value.int32;
-      
-    else if ( ft_memcmp(name, "SPACING", 7) == 0 )
+    else if ( ft_memcmp( name, "SPACING", 7 ) == 0 )
     {
-      if (fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P')
+      if ( fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P' )
         font->spacing = BDF_PROPORTIONAL;
-        
-      else if (fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M')
+      else if ( fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M' )
         font->spacing = BDF_MONOWIDTH;
-        
-      else if (fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C')
+      else if ( fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C' )
         font->spacing = BDF_CHARCELL;
     }
 
-    return FT_Err_Ok;
-}
+  Exit:
+    return error;
+  }
 
-/*
- * Actually parse the glyph info and bitmaps.
- */
-static int
-_bdf_parse_glyphs( char*          line,
-                   unsigned long  linelen,
-                   unsigned long  lineno,
-                   void*          call_data,
-                   void*          client_data)
-{
-  int c;
-  char *s;
-  unsigned char *bp;
-  unsigned long i, slen, nibbles;
-  double ps, rx, dw, sw;
-  _bdf_line_func_t *next;
-  _bdf_parse_t *p;
-  bdf_glyph_t *glyph;
-  bdf_font_t *font;
-  char nbuf[128];
-  FT_Memory memory;
-  FT_Error error;
-
-  next = (_bdf_line_func_t *) call_data;
-  p = (_bdf_parse_t *) client_data;
-
-  font = p->font;
-  memory = font->memory;
-
-  /*
-   * Check for a comment.
-   */
-  if (ft_memcmp(line, "COMMENT", 7) == 0) {
+
+  static unsigned char nibble_mask[8] =
+  {
+    0xFF, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE
+  };
+
+
+  /* Actually parse the glyph info and bitmaps. */
+  static FT_Error
+  _bdf_parse_glyphs( char*          line,
+                     unsigned long  linelen,
+                     unsigned long  lineno,
+                     void*          call_data,
+                     void*          client_data )
+  {
+    int                c, mask_index;
+    char*              s;
+    unsigned char*     bp;
+    unsigned long      i, slen, nibbles;
+    double             ps, rx, dw, sw;
+
+    _bdf_line_func_t*  next;
+    _bdf_parse_t*      p;
+    bdf_glyph_t*       glyph;
+    bdf_font_t*        font;
+
+    FT_Memory          memory;
+    FT_Error           error = BDF_Err_Ok;
+
+    FT_UNUSED( lineno );        /* only used in debug mode */
+
+
+    next = (_bdf_line_func_t *)call_data;
+    p    = (_bdf_parse_t *)    client_data;
+
+    font   = p->font;
+    memory = font->memory;
+
+    /* Check for a comment. */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
       linelen -= 7;
+
       s = line + 7;
-      if (*s != 0) {
-          s++;
-          linelen--;
+      if ( *s != 0 )
+      {
+        s++;
+        linelen--;
       }
-      _bdf_add_comment(p->font, s, linelen);
-      return 0;
-  }
+      error = _bdf_add_comment( p->font, s, linelen );
+      goto Exit;
+    }
 
-  /*
-   * The very first thing expected is the number of glyphs.
-   */
-  if (!(p->flags & _BDF_GLYPHS)) {
-      if (ft_memcmp(line, "CHARS", 5) != 0) {
-          sprintf(nbuf, ERRMSG1, lineno, "CHARS");
-          _bdf_add_acmsg(p->font, nbuf, ft_strlen(nbuf));
-          return BDF_MISSING_CHARS;
+    /* The very first thing expected is the number of glyphs. */
+    if ( !( p->flags & _BDF_GLYPHS ) )
+    {
+      if ( ft_memcmp( line, "CHARS", 5 ) != 0 )
+      {
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "CHARS" ));
+        error = BDF_Err_Missing_Chars_Field;
+        goto Exit;
       }
-      _bdf_split(" +", line, linelen, &p->list, memory);
-      p->cnt = font->glyphs_size = _bdf_atoul(p->list.field[1], 0, 10);
 
-      /*
-       * Make sure the number of glyphs is non-zero.
-       */
-      if (p->cnt == 0)
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->cnt = font->glyphs_size = _bdf_atoul( p->list.field[1], 0, 10 );
+
+      /* Make sure the number of glyphs is non-zero. */
+      if ( p->cnt == 0 )
         font->glyphs_size = 64;
 
-if ( FT_ALLOC ( font->glyphs , sizeof(bdf_glyph_t) *
-                      font->glyphs_size ) )
-        return FT_Err_Out_Of_Memory;
-
-      /*
-       * Set up the callback to indicate the glyph loading is about to
-       * begin.
-       */
-      if (p->callback != 0) {
-          p->cb.reason = BDF_LOAD_START;
-          p->cb.total = p->cnt;
-          p->cb.current = 0;
-          (*p->callback)(&p->cb, p->client_data);
-      }
+      if ( FT_NEW_ARRAY( font->glyphs, font->glyphs_size ) )
+        goto Exit;
+
       p->flags |= _BDF_GLYPHS;
-      return 0;
-  }
 
-  /*
-   * Check for the ENDFONT field.
-   */
-  if (ft_memcmp(line, "ENDFONT", 7) == 0) {
-      /*
-       * Sort the glyphs by encoding.
-       */
-    qsort((char *) font->glyphs, font->glyphs_used, sizeof(bdf_glyph_t),
-          by_encoding);
+      goto Exit;
+    }
+
+    /* Check for the ENDFONT field. */
+    if ( ft_memcmp( line, "ENDFONT", 7 ) == 0 )
+    {
+      /* Sort the glyphs by encoding. */
+      ft_qsort( (char *)font->glyphs,
+                font->glyphs_used,
+                sizeof ( bdf_glyph_t ),
+                by_encoding );
 
       p->flags &= ~_BDF_START;
-      return 0;
-  }
 
-  /*
-   * Check for the ENDCHAR field.
-   */
-  if (ft_memcmp(line, "ENDCHAR", 7) == 0) {
-      /*
-       * Set up and call the callback if it was passed.
-       */
-    if (p->callback != 0) {
-      p->cb.reason = BDF_LOADING;
-      p->cb.total = font->glyphs_size;
-      p->cb.current = font->glyphs_used;
-      (*p->callback)(&p->cb, p->client_data);
-    }
-    p->glyph_enc = 0;
-    p->flags &= ~_BDF_GLYPH_BITS;
-    return 0;
-  }
+      goto Exit;
+    }
 
-  /*
-   * Check to see if a glyph is being scanned but should be ignored
-   * because it is an unencoded glyph.
-   */
-  if ((p->flags & _BDF_GLYPH) &&
-      p->glyph_enc == -1 && p->opts->keep_unencoded == 0)
-    return 0;
+    /* Check for the ENDCHAR field. */
+    if ( ft_memcmp( line, "ENDCHAR", 7 ) == 0 )
+    {
+      p->glyph_enc = 0;
+      p->flags    &= ~_BDF_GLYPH_BITS;
 
-  /*
-   * Check for the STARTCHAR field.
-   */
-  if (ft_memcmp(line, "STARTCHAR", 9) == 0) {
-      /*
-       * Set the character name in the parse info first until the
-       * encoding can be checked for an unencoded character.
-       */
-    if (p->glyph_name != 0)
-      FT_FREE(p->glyph_name);
-    _bdf_split(" +", line, linelen, &p->list,memory);
-    _bdf_shift(1, &p->list);
-    s = _bdf_join(' ', &slen, &p->list);
-    if ( FT_ALLOC ( p->glyph_name , (slen + 1) ) )
-      return BDF_OUT_OF_MEMORY;
-    FT_MEM_COPY(p->glyph_name, s, slen + 1);
-    p->flags |= _BDF_GLYPH;
-    return 0;
-  }
+      goto Exit;
+    }
+
+    /* Check to see whether a glyph is being scanned but should be */
+    /* ignored because it is an unencoded glyph.                   */
+    if ( ( p->flags & _BDF_GLYPH )     &&
+         p->glyph_enc            == -1 &&
+         p->opts->keep_unencoded == 0  )
+      goto Exit;
+
+    /* Check for the STARTCHAR field. */
+    if ( ft_memcmp( line, "STARTCHAR", 9 ) == 0 )
+    {
+      /* Set the character name in the parse info first until the */
+      /* encoding can be checked for an unencoded character.      */
+      FT_FREE( p->glyph_name );
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list,memory );
+      if ( error )
+        goto Exit;
+      _bdf_shift( 1, &p->list );
+
+      s = _bdf_join( ' ', &slen, &p->list );
+
+      if ( FT_NEW_ARRAY( p->glyph_name, slen + 1 ) )
+        goto Exit;
+      FT_MEM_COPY( p->glyph_name, s, slen + 1 );
+
+      p->flags |= _BDF_GLYPH;
 
-  /*
-   * Check for the ENCODING field.
-   */
-  if (ft_memcmp(line, "ENCODING", 8) == 0) {
-    if (!(p->flags & _BDF_GLYPH)) {
-      /*
-       * Missing STARTCHAR field.
-       */
-      sprintf(nbuf, ERRMSG1, lineno, "STARTCHAR");
-      _bdf_add_acmsg(font, nbuf, ft_strlen(nbuf));
-      return BDF_MISSING_STARTCHAR;
-    }
-    _bdf_split(" +", line, linelen, &p->list, memory);
-    p->glyph_enc = _bdf_atol(p->list.field[1], 0, 10);
-
-    /*
-     * Check to see if this encoding has already been encountered.  If it
-     * has then change it to unencoded so it gets added if indicated.
-     */
-    if (p->glyph_enc >= 0) {
-      if (_bdf_glyph_modified(p->have, p->glyph_enc)) {
-        /*
-         * Add a message saying a glyph has been moved to the
-         * unencoded area.
-         */
-        sprintf(nbuf, ACMSG12, p->glyph_enc, p->glyph_name);
-        _bdf_add_acmsg(font, nbuf, ft_strlen(nbuf));
-        p->glyph_enc = -1;
-        font->modified = 1;
-      } else
-        _bdf_set_glyph_modified(p->have, p->glyph_enc);
-    }
-
-    if (p->glyph_enc >= 0) {
-      /*
-       * Make sure there are enough glyphs allocated in case the
-       * number of characters happen to be wrong.
-       */
-      if (font->glyphs_used == font->glyphs_size) {
-        if ( FT_REALLOC ( font->glyphs,
-                          sizeof(bdf_glyph_t) * font->glyphs_size,
-                          sizeof(bdf_glyph_t) * (font->glyphs_size + 64) ) )
-          return BDF_OUT_OF_MEMORY;
-        FT_MEM_SET ((char *) (font->glyphs + font->glyphs_size),
-                    0, sizeof(bdf_glyph_t) << 6); /* FZ inutile */
-        font->glyphs_size += 64;
+      goto Exit;
+    }
+
+    /* Check for the ENCODING field. */
+    if ( ft_memcmp( line, "ENCODING", 8 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_GLYPH ) )
+      {
+        /* Missing STARTCHAR field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "STARTCHAR" ));
+        error = BDF_Err_Missing_Startchar_Field;
+        goto Exit;
       }
 
-      glyph = font->glyphs + font->glyphs_used++;
-      glyph->name = p->glyph_name;
-      glyph->encoding = p->glyph_enc;
-
-      /*
-       * Reset the initial glyph info.
-       */
-      p->glyph_name = 0;
-    } else {
-      /*
-       * Unencoded glyph.  Check to see if it should be added or not.
-       */
-      if (p->opts->keep_unencoded != 0) {
-        /*
-         * Allocate the next unencoded glyph.
-         */
-        if (font->unencoded_used == font->unencoded_size) {
-          if (font->unencoded_size == 0) {
-            if ( FT_ALLOC ( font->unencoded , sizeof(bdf_glyph_t) << 2 ) )
-              return BDF_OUT_OF_MEMORY;
-          }
-          else {
-            if ( FT_REALLOC ( font->unencoded ,
-                              sizeof(bdf_glyph_t) * font->unencoded_size,
-                              sizeof(bdf_glyph_t) *
-                              (font->unencoded_size + 4) ) )
-              return BDF_OUT_OF_MEMORY;
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->glyph_enc = _bdf_atol( p->list.field[1], 0, 10 );
+
+      /* Check to see whether this encoding has already been encountered. */
+      /* If it has then change it to unencoded so it gets added if        */
+      /* indicated.                                                       */
+      if ( p->glyph_enc >= 0 )
+      {
+        if ( _bdf_glyph_modified( p->have, p->glyph_enc ) )
+        {
+          /* Emit a message saying a glyph has been moved to the */
+          /* unencoded area.                                     */
+          FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG12,
+                      p->glyph_enc, p->glyph_name ));
+          p->glyph_enc = -1;
+          font->modified = 1;
+        }
+        else
+          _bdf_set_glyph_modified( p->have, p->glyph_enc );
+      }
+
+      if ( p->glyph_enc >= 0 )
+      {
+        /* Make sure there are enough glyphs allocated in case the */
+        /* number of characters happen to be wrong.                */
+        if ( font->glyphs_used == font->glyphs_size )
+        {
+          if ( FT_RENEW_ARRAY( font->glyphs,
+                               font->glyphs_size,
+                               font->glyphs_size + 64 ) )
+            goto Exit;
+          FT_MEM_SET( font->glyphs + font->glyphs_size,
+                      0,
+                      sizeof ( bdf_glyph_t ) * 64 ); /* FZ inutile */
+          font->glyphs_size += 64;
+        }
+
+        glyph           = font->glyphs + font->glyphs_used++;
+        glyph->name     = p->glyph_name;
+        glyph->encoding = p->glyph_enc;
+
+        /* Reset the initial glyph info. */
+        p->glyph_name = 0;
+      }
+      else
+      {
+        /* Unencoded glyph.  Check to see whether it should */
+        /* be added or not.                                 */
+        if ( p->opts->keep_unencoded != 0 )
+        {
+          /* Allocate the next unencoded glyph. */
+          if ( font->unencoded_used == font->unencoded_size )
+          {
+            if ( font->unencoded_size == 0 )
+            {
+              if ( FT_NEW_ARRAY( font->unencoded, 2 ) )
+                goto Exit;
+            }
+            else
+            {
+              if ( FT_RENEW_ARRAY( font->unencoded ,
+                                   font->unencoded_size,
+                                   font->unencoded_size + 4 ) )
+                goto Exit;
+            }
+            font->unencoded_size += 4;
           }
-          font->unencoded_size += 4;
+
+          glyph           = font->unencoded + font->unencoded_used;
+          glyph->name     = p->glyph_name;
+          glyph->encoding = font->unencoded_used++;
         }
+        else
+          /* Free up the glyph name if the unencoded shouldn't be */
+          /* kept.                                                */
+          FT_FREE( p->glyph_name );
 
-        glyph = font->unencoded + font->unencoded_used;
-        glyph->name = p->glyph_name;
-        glyph->encoding = font->unencoded_used++;
-      } else
-        /*
-         * Free up the glyph name if the unencoded shouldn't be
-         * kept.
-         */
-        FT_FREE( p->glyph_name );
+        p->glyph_name = 0;
+      }
+
+      /* Clear the flags that might be added when width and height are */
+      /* checked for consistency.                                      */
+      p->flags &= ~( _BDF_GLYPH_WIDTH_CHECK | _BDF_GLYPH_HEIGHT_CHECK );
 
-      p->glyph_name = 0;
+      p->flags |= _BDF_ENCODING;
+
+      goto Exit;
     }
 
-    /*
-     * Clear the flags that might be added when width and height are
-     * checked for consistency.
-     */
-    p->flags &= ~(_BDF_GLYPH_WIDTH_CHECK|_BDF_GLYPH_HEIGHT_CHECK);
+    /* Point at the glyph being constructed. */
+    if ( p->glyph_enc == -1 )
+      glyph = font->unencoded + ( font->unencoded_used - 1 );
+    else
+      glyph = font->glyphs + ( font->glyphs_used - 1 );
 
-    p->flags |= _BDF_ENCODING;
-    return 0;
-  }
+    /* Check to see whether a bitmap is being constructed. */
+    if ( p->flags & _BDF_BITMAP )
+    {
+      /* If there are more rows than are specified in the glyph metrics, */
+      /* ignore the remaining lines.                                     */
+      if ( p->row >= glyph->bbx.height )
+      {
+        if ( !( p->flags & _BDF_GLYPH_HEIGHT_CHECK ) )
+        {
+          FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG13, glyph->encoding ));
+          p->flags |= _BDF_GLYPH_HEIGHT_CHECK;
+          font->modified = 1;
+        }
 
-  /*
-   * Point at the glyph being constructed.
-   */
-  if (p->glyph_enc == -1)
-    glyph = font->unencoded + (font->unencoded_used - 1);
-  else
-    glyph = font->glyphs + (font->glyphs_used - 1);
-
-  /*
-   * Check to see if a bitmap is being constructed.
-   */
-  if (p->flags & _BDF_BITMAP) {
-      /*
-       * If there are more rows than are specified in the glyph metrics,
-       * ignore the remaining lines.
-       */
-      if (p->row >= glyph->bbx.height) {
-          if (!(p->flags & _BDF_GLYPH_HEIGHT_CHECK)) {
-              sprintf(nbuf, ACMSG13, glyph->encoding);
-              _bdf_add_acmsg(font, nbuf, ft_strlen(nbuf));
-              p->flags |= _BDF_GLYPH_HEIGHT_CHECK;
-              font->modified = 1;
-          }
-          return 0;
+        goto Exit;
       }
 
-      /*
-       * Only collect the number of nibbles indicated by the glyph metrics.
-       * If there are more columns, they are simply ignored.
-       */
-      nibbles = p->bpr << 1;
-      bp = glyph->bitmap + (p->row * p->bpr);
-      for (i = 0, *bp = 0; i < nibbles; i++) {
-          c = line[i];
-          *bp = (*bp << 4) + a2i[c];
-          if (i + 1 < nibbles && (i & 1))
-            *++bp = 0;
+      /* Only collect the number of nibbles indicated by the glyph     */
+      /* metrics.  If there are more columns, they are simply ignored. */
+      nibbles = glyph->bpr << 1;
+      bp      = glyph->bitmap + p->row * glyph->bpr;
+
+      for ( i = 0, *bp = 0; i < nibbles; i++ )
+      {
+        c = line[i];
+        *bp = ( *bp << 4 ) + a2i[c];
+        if ( i + 1 < nibbles && ( i & 1 ) )
+          *++bp = 0;
       }
 
-      /*
-       * If any line has extra columns, indicate they have been removed.
-       */
-      if ((line[nibbles] == '0' || a2i[(int) line[nibbles]] != 0) &&
-          !(p->flags & _BDF_GLYPH_WIDTH_CHECK)) {
-          sprintf(nbuf, ACMSG14, glyph->encoding);
-          _bdf_add_acmsg(font, nbuf, ft_strlen(nbuf));
-          p->flags |= _BDF_GLYPH_WIDTH_CHECK;
-          font->modified = 1;
+      /* Remove possible garbage at the right. */
+      mask_index = ( glyph->bbx.width * p->font->bpp ) & 7;
+      *bp &= nibble_mask[mask_index];
+
+      /* If any line has extra columns, indicate they have been removed. */
+      if ( ( line[nibbles] == '0' || a2i[(int)line[nibbles]] != 0 ) &&
+           !( p->flags & _BDF_GLYPH_WIDTH_CHECK )                   )
+      {
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG14, glyph->encoding ));
+        p->flags       |= _BDF_GLYPH_WIDTH_CHECK;
+        font->modified  = 1;
       }
 
       p->row++;
-      return 0;
-  }
+      goto Exit;
+    }
 
-  /*
-   * Expect the SWIDTH (scalable width) field next.
-   */
-  if (ft_memcmp(line, "SWIDTH", 6) == 0) {
-      if (!(p->flags & _BDF_ENCODING)) {
-          /*
-           * Missing ENCODING field.
-           */
-          sprintf(nbuf, ERRMSG1, lineno, "ENCODING");
-          _bdf_add_acmsg(font, nbuf, ft_strlen(nbuf));
-          return BDF_MISSING_ENCODING;
+    /* Expect the SWIDTH (scalable width) field next. */
+    if ( ft_memcmp( line, "SWIDTH", 6 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_ENCODING ) )
+      {
+        /* Missing ENCODING field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "ENCODING" ));
+        error = BDF_Err_Missing_Encoding_Field;
+        goto Exit;
       }
-      _bdf_split(" +", line, linelen, &p->list, memory);
-      glyph->swidth = _bdf_atoul(p->list.field[1], 0, 10);
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      glyph->swidth = _bdf_atoul( p->list.field[1], 0, 10 );
       p->flags |= _BDF_SWIDTH;
-      return 0;
-  }
 
-  /*
-   * Expect the DWIDTH (scalable width) field next.
-   */
-  if (ft_memcmp(line, "DWIDTH", 6) == 0) {
-      _bdf_split(" +", line, linelen, &p->list,memory);
-      glyph->dwidth = _bdf_atoul(p->list.field[1], 0, 10);
-
-      if (!(p->flags & _BDF_SWIDTH)) {
-          /*
-           * Missing SWIDTH field.  Add an auto correction message and set
-           * the scalable width from the device width.
-           */
-          sprintf(nbuf, ACMSG9, lineno);
-          _bdf_add_acmsg(font, nbuf, ft_strlen(nbuf));
-          ps = (double) font->point_size;
-          rx = (double) font->resolution_x;
-          dw = (double) glyph->dwidth;
-          glyph->swidth = (unsigned short) ((dw * 72000.0) / (ps * rx));
+      goto Exit;
+    }
+
+    /* Expect the DWIDTH (scalable width) field next. */
+    if ( ft_memcmp( line, "DWIDTH", 6 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list,memory );
+      if ( error )
+        goto Exit;
+      glyph->dwidth = _bdf_atoul( p->list.field[1], 0, 10 );
+
+      if ( !( p->flags & _BDF_SWIDTH ) )
+      {
+        /* Missing SWIDTH field.  Emit an auto correction message and set */
+        /* the scalable width from the device width.                      */
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG9, lineno ));
+
+        ps = (double)font->point_size;
+        rx = (double)font->resolution_x;
+        dw = (double)glyph->dwidth;
+
+        glyph->swidth = (unsigned short)( ( dw * 72000.0 ) / ( ps * rx ) );
       }
 
       p->flags |= _BDF_DWIDTH;
-      return 0;
-  }
+      goto Exit;
+    }
+
+    /* Expect the BBX field next. */
+    if ( ft_memcmp( line, "BBX", 3 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+
+      glyph->bbx.width    = _bdf_atos( p->list.field[1], 0, 10 );
+      glyph->bbx.height   = _bdf_atos( p->list.field[2], 0, 10 );
+      glyph->bbx.x_offset = _bdf_atos( p->list.field[3], 0, 10 );
+      glyph->bbx.y_offset = _bdf_atos( p->list.field[4], 0, 10 );
 
-  /*
-   * Expect the BBX field next.
-   */
-  if (ft_memcmp(line, "BBX", 3) == 0) {
-      _bdf_split(" +", line, linelen, &p->list, memory);
-      glyph->bbx.width = _bdf_atos(p->list.field[1], 0, 10);
-      glyph->bbx.height = _bdf_atos(p->list.field[2], 0, 10);
-      glyph->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10);
-      glyph->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10);
-
-      /*
-       * Generate the ascent and descent of the character.
-       */
-      glyph->bbx.ascent = glyph->bbx.height + glyph->bbx.y_offset;
+      /* Generate the ascent and descent of the character. */
+      glyph->bbx.ascent  = glyph->bbx.height + glyph->bbx.y_offset;
       glyph->bbx.descent = -glyph->bbx.y_offset;
 
-      /*
-       * Determine the overall font bounding box as the characters are
-       * loaded so corrections can be done later if indicated.
-       */
-      p->maxas = MAX(glyph->bbx.ascent, p->maxas);
-      p->maxds = MAX(glyph->bbx.descent, p->maxds);
+      /* Determine the overall font bounding box as the characters are */
+      /* loaded so corrections can be done later if indicated.         */
+      p->maxas    = MAX( glyph->bbx.ascent, p->maxas );
+      p->maxds    = MAX( glyph->bbx.descent, p->maxds );
+
       p->rbearing = glyph->bbx.width + glyph->bbx.x_offset;
-      p->maxrb = MAX(p->rbearing, p->maxrb);
-      p->minlb = MIN(glyph->bbx.x_offset, p->minlb);
-      p->maxlb = MAX(glyph->bbx.x_offset, p->maxlb);
-
-      if (!(p->flags & _BDF_DWIDTH)) {
-          /*
-           * Missing DWIDTH field.  Add an auto correction message and set
-           * the device width to the glyph width.
-           */
-          sprintf(nbuf, ACMSG10, lineno);
-          _bdf_add_acmsg(font, nbuf, ft_strlen(nbuf));
-          glyph->dwidth = glyph->bbx.width;
+
+      p->maxrb    = MAX( p->rbearing, p->maxrb );
+      p->minlb    = MIN( glyph->bbx.x_offset, p->minlb );
+      p->maxlb    = MAX( glyph->bbx.x_offset, p->maxlb );
+
+      if ( !( p->flags & _BDF_DWIDTH ) )
+      {
+        /* Missing DWIDTH field.  Emit an auto correction message and set */
+        /* the device width to the glyph width.                           */
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG10, lineno ));
+        glyph->dwidth = glyph->bbx.width;
       }
 
-      /*
-       * If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH
-       * value if necessary.
-       */
-      if (p->opts->correct_metrics != 0) {
-          /*
-           * Determine the point size of the glyph.
-           */
-          ps = (double) font->point_size;
-          rx = (double) font->resolution_x;
-          dw = (double) glyph->dwidth;
-          sw = (unsigned short) ((dw * 72000.0) / (ps * rx));
-
-          if (sw != glyph->swidth) {
-              glyph->swidth = sw;
-              if (p->glyph_enc == -1)
-                _bdf_set_glyph_modified(font->umod,
-                                        font->unencoded_used - 1);
-              else
-                _bdf_set_glyph_modified(font->nmod, glyph->encoding);
-              p->flags |= _BDF_SWIDTH_ADJ;
-              font->modified = 1;
-          }
+      /* If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH */
+      /* value if necessary.                                            */
+      if ( p->opts->correct_metrics != 0 )
+      {
+        /* Determine the point size of the glyph. */
+        ps = (double)font->point_size;
+        rx = (double)font->resolution_x;
+        dw = (double)glyph->dwidth;
+
+        sw = (unsigned short)( ( dw * 72000.0 ) / ( ps * rx ) );
+
+        if ( sw != glyph->swidth )
+        {
+          glyph->swidth = sw;
+
+          if ( p->glyph_enc == -1 )
+            _bdf_set_glyph_modified( font->umod,
+                                     font->unencoded_used - 1 );
+          else
+            _bdf_set_glyph_modified( font->nmod, glyph->encoding );
+
+          p->flags       |= _BDF_SWIDTH_ADJ;
+          font->modified  = 1;
+        }
       }
+
       p->flags |= _BDF_BBX;
-      return 0;
-  }
+      goto Exit;
+    }
 
-  /*
-   * And finally, gather up the bitmap.
-   */
-  if (ft_memcmp(line, "BITMAP", 6) == 0) {
-      if (!(p->flags & _BDF_BBX)) {
-          /*
-           * Missing BBX field.
-           */
-          sprintf(nbuf, ERRMSG1, lineno, "BBX");
-          _bdf_add_acmsg(font, nbuf, ft_strlen(nbuf));
-          return BDF_MISSING_BBX;
+    /* And finally, gather up the bitmap. */
+    if ( ft_memcmp( line, "BITMAP", 6 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_BBX ) )
+      {
+        /* Missing BBX field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "BBX" ));
+        error = BDF_Err_Missing_Bbx_Field;
+        goto Exit;
       }
-      /*
-       * Allocate enough space for the bitmap.
-       */
-      p->bpr = ((glyph->bbx.width * p->font->bpp) + 7) >> 3;
-      glyph->bytes = p->bpr * glyph->bbx.height;
-      if ( FT_ALLOC ( glyph->bitmap , glyph->bytes ) )
-        return BDF_OUT_OF_MEMORY;
-      p->row = 0;
+
+      /* Allocate enough space for the bitmap. */
+      glyph->bpr   = ( glyph->bbx.width * p->font->bpp + 7 ) >> 3;
+      glyph->bytes = glyph->bpr * glyph->bbx.height;
+
+      if ( FT_NEW_ARRAY( glyph->bitmap, glyph->bytes ) )
+        goto Exit;
+
+      p->row    = 0;
       p->flags |= _BDF_BITMAP;
-      return 0;
+
+      goto Exit;
+    }
+
+    error = BDF_Err_Invalid_File_Format;
+
+  Exit:
+    return error;
   }
 
-  return BDF_INVALID_LINE;
-}
 
-/*
-* Load the font properties.
-*/
-static int
-_bdf_parse_properties(char *line, unsigned long linelen, unsigned long lineno,
-                    void *call_data, void *client_data)
-{
-  unsigned long vlen;
-  _bdf_line_func_t *next;
-  _bdf_parse_t *p;
-  char *name, *value, nbuf[128];
-  FT_Memory memory;
-
-  next = (_bdf_line_func_t *) call_data;
-  p = (_bdf_parse_t *) client_data;
-
-  memory = p->font->memory;
-  /*
-   * Check for the end of the properties.
-   */
-  if (ft_memcmp(line, "ENDPROPERTIES", 13) == 0) {
-      /*
-       * If the FONT_ASCENT or FONT_DESCENT properties have not been
-       * encountered yet, then make sure they are added as properties and
-       * make sure they are set from the font bounding box info.
-       *
-       * This is *always* done regardless of the options, because X11
-       * requires these two fields to compile fonts.
-       */
-      if (bdf_get_font_property(p->font, "FONT_ASCENT") == 0) {
-          p->font->font_ascent = p->font->bbx.ascent;
-          sprintf(nbuf, "%hd", p->font->bbx.ascent);
-          _bdf_add_property(p->font, "FONT_ASCENT", nbuf);
-          sprintf(nbuf, ACMSG1, p->font->bbx.ascent);
-          _bdf_add_acmsg(p->font, nbuf, ft_strlen(nbuf));
-          p->font->modified = 1;
+  /* Load the font properties. */
+  static FT_Error
+  _bdf_parse_properties( char*          line,
+                         unsigned long  linelen,
+                         unsigned long  lineno,
+                         void*          call_data,
+                         void*          client_data )
+  {
+    unsigned long      vlen;
+    _bdf_line_func_t*  next;
+    _bdf_parse_t*      p;
+    char*              name;
+    char*              value;
+    char               nbuf[128];
+    FT_Memory          memory;
+    FT_Error           error = BDF_Err_Ok;
+
+    FT_UNUSED( lineno );
+
+
+    next = (_bdf_line_func_t *)call_data;
+    p    = (_bdf_parse_t *)    client_data;
+
+    memory = p->font->memory;
+
+    /* Check for the end of the properties. */
+    if ( ft_memcmp( line, "ENDPROPERTIES", 13 ) == 0 )
+    {
+      /* If the FONT_ASCENT or FONT_DESCENT properties have not been      */
+      /* encountered yet, then make sure they are added as properties and */
+      /* make sure they are set from the font bounding box info.          */
+      /*                                                                  */
+      /* This is *always* done regardless of the options, because X11     */
+      /* requires these two fields to compile fonts.                      */
+      if ( bdf_get_font_property( p->font, (char *)"FONT_ASCENT" ) == 0 )
+      {
+        p->font->font_ascent = p->font->bbx.ascent;
+        ft_sprintf( nbuf, "%hd", p->font->bbx.ascent );
+        error = _bdf_add_property( p->font, (char *)"FONT_ASCENT", nbuf );
+        if ( error )
+          goto Exit;
+
+        FT_TRACE2(( "_bdf_parse_properties: " ACMSG1, p->font->bbx.ascent ));
+        p->font->modified = 1;
       }
-      if (bdf_get_font_property(p->font, "FONT_DESCENT") == 0) {
-          p->font->font_descent = p->font->bbx.descent;
-          sprintf(nbuf, "%hd", p->font->bbx.descent);
-          _bdf_add_property(p->font, "FONT_DESCENT", nbuf);
-          sprintf(nbuf, ACMSG2, p->font->bbx.descent);
-          _bdf_add_acmsg(p->font, nbuf, ft_strlen(nbuf));
-          p->font->modified = 1;
+
+      if ( bdf_get_font_property( p->font, (char *)"FONT_DESCENT" ) == 0 )
+      {
+        p->font->font_descent = p->font->bbx.descent;
+        ft_sprintf( nbuf, "%hd", p->font->bbx.descent );
+        error = _bdf_add_property( p->font, (char *)"FONT_DESCENT", nbuf );
+        if ( error )
+          goto Exit;
+
+        FT_TRACE2(( "_bdf_parse_properties: " ACMSG2, p->font->bbx.descent ));
+        p->font->modified = 1;
       }
+
       p->flags &= ~_BDF_PROPS;
-      *next = _bdf_parse_glyphs;
-      return 0;
-  }
+      *next     = _bdf_parse_glyphs;
 
-  /*
-   * Ignore the _XFREE86_GLYPH_RANGES properties.
-   */
-  if (ft_memcmp(line, "_XFREE86_GLYPH_RANGES", 21) == 0)
-    return 0;
+      goto Exit;
+    }
+
+    /* Ignore the _XFREE86_GLYPH_RANGES properties. */
+    if ( ft_memcmp( line, "_XFREE86_GLYPH_RANGES", 21 ) == 0 )
+      goto Exit;
 
-  /*
-   * Handle COMMENT fields and properties in a special way to preserve
-   * the spacing.
-   */
-  if (ft_memcmp(line, "COMMENT", 7) == 0) {
+    /* Handle COMMENT fields and properties in a special way to preserve */
+    /* the spacing.                                                      */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
       name = value = line;
       value += 7;
-      if (*value)
+      if ( *value )
         *value++ = 0;
-      _bdf_add_property(p->font, name, value);
-  } else if (_bdf_is_atom(line, linelen, &name, &value, p->font))
-    _bdf_add_property(p->font, name, value);
-  else {
-      _bdf_split(" +", line, linelen, &p->list, memory);
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+    else if ( _bdf_is_atom( line, linelen, &name, &value, p->font ) )
+    {
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+    else
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
       name = p->list.field[0];
-      _bdf_shift(1, &p->list);
-      value = _bdf_join(' ', &vlen, &p->list);
-      _bdf_add_property(p->font, name, value);
+
+      _bdf_shift( 1, &p->list );
+      value = _bdf_join( ' ', &vlen, &p->list );
+
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+
+  Exit:
+    return error;
   }
 
-  return 0;
-}
 
-/*
- * Load the font header.
- */
-static int
-_bdf_parse_start(char *line, unsigned long linelen, unsigned long lineno,
-                 void *call_data, void *client_data)
-{
-    unsigned long slen;
-    _bdf_line_func_t *next;
-    _bdf_parse_t *p;
-    bdf_font_t *font;
-    char *s, nbuf[128];
-    /*    int test; */
-    FT_Memory memory;
-    FT_Error error;
-
-    next = (_bdf_line_func_t *) call_data;
-    p = (_bdf_parse_t *) client_data;
-    if (p->font)
+  /* Load the font header. */
+  static FT_Error
+  _bdf_parse_start( char*          line,
+                    unsigned long  linelen,
+                    unsigned long  lineno,
+                    void*          call_data,
+                    void*          client_data )
+  {
+    unsigned long      slen;
+    _bdf_line_func_t*  next;
+    _bdf_parse_t*      p;
+    bdf_font_t*        font;
+    char               *s;
+
+    FT_Memory          memory;
+    FT_Error           error = BDF_Err_Ok;
+
+    FT_UNUSED( lineno );            /* only used in debug mode */
+
+
+    next = (_bdf_line_func_t *)call_data;
+    p    = (_bdf_parse_t *)    client_data;
+
+    if ( p->font )
       memory = p->font->memory;
 
-    /*
-     * Check for a comment.  This is done to handle those fonts that have
-     * comments before the STARTFONT line for some reason.
-     */
-    if (ft_memcmp(line, "COMMENT", 7) == 0) {
-        if (p->opts->keep_comments != 0 && p->font != 0) {
-            linelen -= 7;
-            s = line + 7;
-            if (*s != 0) {
-                s++;
-                linelen--;
-            }
-            _bdf_add_comment(p->font, s, linelen);
-	    /* here font is not defined ! */
+    /* Check for a comment.  This is done to handle those fonts that have */
+    /* comments before the STARTFONT line for some reason.                */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
+      if ( p->opts->keep_comments != 0 && p->font != 0 )
+      {
+        linelen -= 7;
+
+        s = line + 7;
+        if ( *s != 0 )
+        {
+          s++;
+          linelen--;
         }
-        return 0;
-    }
-
-    if (!(p->flags & _BDF_START)) {
-
-        memory = p->memory;
-
-        if (ft_memcmp(line, "STARTFONT", 9) != 0)
-          /*
-           * No STARTFONT field is a good indication of a problem.
-           */
-          return BDF_MISSING_START;
-        p->flags = _BDF_START;
-        font = p->font = 0;
-
-	if ( FT_ALLOC ( font, sizeof(bdf_font_t) ) )
-	  return BDF_OUT_OF_MEMORY;
-	p->font = font;
-
-	font->memory = p->memory;
-	p->memory = 0;
-
-	/*	if (font == 0) {
-          fprintf(stderr,"failed font\n");
-	  }*/ /* XXX */
-
-	{ /* setup */
-	  unsigned long i;
-	  bdf_property_t *prop;
-
-	  hash_init(&(font->proptbl), memory);
-	  for (i = 0, prop = _bdf_properties;
-		 i < _num_bdf_properties; i++, prop++)
-	    hash_insert(prop->name, (void *) i, &(font->proptbl) , memory);
-	}
-
-	if ( FT_ALLOC ( p->font->internal , sizeof(hashtable) ) )
-	  return BDF_OUT_OF_MEMORY;
-	hash_init((hashtable *) p->font->internal,memory);
-	p->font->spacing = p->opts->font_spacing;
-        p->font->default_glyph = -1;
-	return 0;
-    }
-
-    /*
-     * Check for the start of the properties.
-     */
-    if (ft_memcmp(line, "STARTPROPERTIES", 15) == 0) {
-        _bdf_split(" +", line, linelen, &p->list, memory);
-        p->cnt = p->font->props_size = _bdf_atoul(p->list.field[1], 0, 10);
-
-	if ( FT_ALLOC ( p->font->props , (sizeof(bdf_property_t) * p->cnt) ) )
-	  return BDF_OUT_OF_MEMORY;
-        p->flags |= _BDF_PROPS;
-        *next = _bdf_parse_properties;
-        return 0;
-    }
-
-    /*
-     * Check for the FONTBOUNDINGBOX field.
-     */
-    if (ft_memcmp(line, "FONTBOUNDINGBOX", 15) == 0) {
-        if (!(p->flags & _BDF_SIZE)) {
-            /*
-             * Missing the SIZE field.
-             */
-            sprintf(nbuf, ERRMSG1, lineno, "SIZE");
-            _bdf_add_acmsg(p->font, nbuf, ft_strlen(nbuf));
-            return BDF_MISSING_SIZE;
+
+        error = _bdf_add_comment( p->font, s, linelen );
+        if ( error )
+          goto Exit;
+        /* here font is not defined! */
+      }
+
+      goto Exit;
+    }
+
+    if ( !( p->flags & _BDF_START ) )
+    {
+      memory = p->memory;
+
+      if ( ft_memcmp( line, "STARTFONT", 9 ) != 0 )
+      {
+        /* No STARTFONT field is a good indication of a problem. */
+        error = BDF_Err_Missing_Startfont_Field;
+        goto Exit;
+      }
+
+      p->flags = _BDF_START;
+      font = p->font = 0;
+
+      if ( FT_NEW( font ) )
+        goto Exit;
+      p->font = font;
+
+      font->memory = p->memory;
+      p->memory    = 0;
+
+      { /* setup */
+        unsigned long    i;
+        bdf_property_t*  prop;
+
+
+        error = hash_init( &(font->proptbl), memory );
+        if ( error )
+          goto Exit;
+        for ( i = 0, prop = _bdf_properties;
+              i < _num_bdf_properties; i++, prop++ )
+        {
+          error = hash_insert( prop->name, (void *)i,
+                               &(font->proptbl), memory );
+          if ( error )
+            goto Exit;
+        }
+      }
+
+      if ( FT_ALLOC( p->font->internal, sizeof ( hashtable ) ) )
+        goto Exit;
+      error = hash_init( (hashtable *)p->font->internal,memory );
+      if ( error )
+        goto Exit;
+      p->font->spacing       = p->opts->font_spacing;
+      p->font->default_glyph = -1;
+
+      goto Exit;
+    }
+
+    /* Check for the start of the properties. */
+    if ( ft_memcmp( line, "STARTPROPERTIES", 15 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->cnt = p->font->props_size = _bdf_atoul( p->list.field[1], 0, 10 );
+
+      if ( FT_NEW_ARRAY( p->font->props, p->cnt ) )
+        goto Exit;
+
+      p->flags |= _BDF_PROPS;
+      *next     = _bdf_parse_properties;
+
+      goto Exit;
+    }
+
+    /* Check for the FONTBOUNDINGBOX field. */
+    if ( ft_memcmp( line, "FONTBOUNDINGBOX", 15 ) == 0 )
+    {
+      if ( !(p->flags & _BDF_SIZE ) )
+      {
+        /* Missing the SIZE field. */
+        FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "SIZE" ));
+        error = BDF_Err_Missing_Size_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list , memory );
+      if ( error )
+        goto Exit;
+
+      p->font->bbx.width  = _bdf_atos( p->list.field[1], 0, 10 );
+      p->font->bbx.height = _bdf_atos( p->list.field[2], 0, 10 );
+
+      p->font->bbx.x_offset = _bdf_atos( p->list.field[3], 0, 10 );
+      p->font->bbx.y_offset = _bdf_atos( p->list.field[4], 0, 10 );
+
+      p->font->bbx.ascent  = p->font->bbx.height + p->font->bbx.y_offset;
+      p->font->bbx.descent = -p->font->bbx.y_offset;
+
+      p->flags |= _BDF_FONT_BBX;
+
+      goto Exit;
+    }
+
+    /* The next thing to check for is the FONT field. */
+    if ( ft_memcmp( line, "FONT", 4 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list , memory );
+      if ( error )
+        goto Exit;
+      _bdf_shift( 1, &p->list );
+
+      s = _bdf_join( ' ', &slen, &p->list );
+      if ( FT_NEW_ARRAY( p->font->name, slen + 1 ) )
+        goto Exit;
+      FT_MEM_COPY( p->font->name, s, slen + 1 );
+
+      /* If the font name is an XLFD name, set the spacing to the one in  */
+      /* the font name.  If there is no spacing fall back on the default. */
+      error = _bdf_set_default_spacing( p->font, p->opts );
+      if ( error )
+        goto Exit;
+
+      p->flags |= _BDF_FONT_NAME;
+
+      goto Exit;
+    }
+
+    /* Check for the SIZE field. */
+    if ( ft_memcmp( line, "SIZE", 4 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_FONT_NAME ) )
+      {
+        /* Missing the FONT field. */
+        FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "FONT" ));
+        error = BDF_Err_Missing_Font_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+
+      p->font->point_size   = _bdf_atoul( p->list.field[1], 0, 10 );
+      p->font->resolution_x = _bdf_atoul( p->list.field[2], 0, 10 );
+      p->font->resolution_y = _bdf_atoul( p->list.field[3], 0, 10 );
+
+      /* Check for the bits per pixel field. */
+      if ( p->list.used == 5 )
+      {
+        p->font->bpp = _bdf_atos( p->list.field[4], 0, 10 );
+        if ( p->font->bpp > 1 && ( p->font->bpp & 1 ) )
+        {
+          /* Move up to the next bits per pixel value if an odd number */
+          /* is encountered.                                           */
+          p->font->bpp++;
+          if ( p->font->bpp <= 4 )
+            FT_TRACE2(( "_bdf_parse_start: " ACMSG11, p->font->bpp ));
         }
-        _bdf_split(" +", line, linelen, &p->list , memory);
-        p->font->bbx.width = _bdf_atos(p->list.field[1], 0, 10);
-        p->font->bbx.height = _bdf_atos(p->list.field[2], 0, 10);
-        p->font->bbx.x_offset = _bdf_atos(p->list.field[3], 0, 10);
-        p->font->bbx.y_offset = _bdf_atos(p->list.field[4], 0, 10);
-        p->font->bbx.ascent = p->font->bbx.height + p->font->bbx.y_offset;
-        p->font->bbx.descent = -p->font->bbx.y_offset;
-        p->flags |= _BDF_FONT_BBX;
-        return 0;
-    }
-
-    /*
-     * The next thing to check for is the FONT field.
-     */
-    if (ft_memcmp(line, "FONT", 4) == 0) {
-        _bdf_split(" +", line, linelen, &p->list , memory);
-        _bdf_shift(1, &p->list);
-        s = _bdf_join(' ', &slen, &p->list);
-	if ( FT_ALLOC ( p->font->name , slen + 1 ) )
-	  return BDF_OUT_OF_MEMORY;
-        (void) ft_memcpy(p->font->name, s, slen + 1);
-        /*
-         * If the font name is an XLFD name, set the spacing to the one in the
-         * font name.  If there is no spacing fall back on the default.
-         */
-        _bdf_set_default_spacing(p->font, p->opts);
-        p->flags |= _BDF_FONT_NAME;
-	return 0;
-    }
-
-    /*
-     * Check for the SIZE field.
-     */
-    if (ft_memcmp(line, "SIZE", 4) == 0) {
-        if (!(p->flags & _BDF_FONT_NAME)) {
-            /*
-             * Missing the FONT field.
-             */
-            sprintf(nbuf, ERRMSG1, lineno, "FONT");
-            _bdf_add_acmsg(p->font, nbuf, ft_strlen(nbuf));
-            return BDF_MISSING_FONTNAME;
+
+        if ( p->font->bpp > 4 )
+        {
+          FT_TRACE2(( "_bdf_parse_start: " ACMSG11, p->font->bpp ));
+          p->font->bpp = 4;
         }
-        _bdf_split(" +", line, linelen, &p->list, memory);
-        p->font->point_size = _bdf_atoul(p->list.field[1], 0, 10);
-        p->font->resolution_x = _bdf_atoul(p->list.field[2], 0, 10);
-        p->font->resolution_y = _bdf_atoul(p->list.field[3], 0, 10);
-
-        /*
-         * Check for the bits per pixel field.
-         */
-        if (p->list.used == 5) {
-            p->font->bpp = _bdf_atos(p->list.field[4], 0, 10);
-            if (p->font->bpp > 1 && (p->font->bpp & 1)) {
-                /*
-                 * Move up to the next bits per pixel value if an odd number
-                 * is encountered.
-                 */
-                p->font->bpp++;
-                if (p->font->bpp <= 4) {
-                    sprintf(nbuf, ACMSG11, p->font->bpp);
-                    _bdf_add_acmsg(p->font, nbuf, ft_strlen(nbuf));
-                }
-            }
-            if (p->font->bpp > 4) {
-                sprintf(nbuf, ACMSG11, p->font->bpp);
-                _bdf_add_acmsg(p->font, nbuf, ft_strlen(nbuf));
-                p->font->bpp = 4;
-            }
-        } else
-          p->font->bpp = 1;
+      }
+      else
+        p->font->bpp = 1;
+
+      p->flags |= _BDF_SIZE;
 
-        p->flags |= _BDF_SIZE;
-        return 0;
+      goto Exit;
     }
 
-    return BDF_INVALID_LINE;
-}
+    error = BDF_Err_Invalid_File_Format;
 
-/**************************************************************************
- *
- * API.
- *
- **************************************************************************/
-
-
-FT_LOCAL_DEF( bdf_font_t* )
-bdf_load_font( FT_Stream       stream,
-               FT_Memory       extmemory,
-               bdf_options_t*  opts,
-               bdf_callback_t  callback,
-               void*           data)
-{
-    int n;
-    unsigned long lineno;
-    char msgbuf[128];
-    _bdf_parse_t p;
-    FT_Memory memory;
-    FT_Error error;
-
-    (void) ft_memset((char *) &p, 0, sizeof(_bdf_parse_t));
-    p.opts = (opts != 0) ? opts : &_bdf_opts;
-    p.minlb = 32767;
-    p.callback = callback;
-    p.client_data = data;
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* API.                                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  bdf_load_font( FT_Stream       stream,
+                 FT_Memory       extmemory,
+                 bdf_options_t*  opts,
+                 bdf_font_t*    *font )
+  {
+    unsigned long  lineno;
+    _bdf_parse_t   p;
+
+    FT_Memory      memory;
+    FT_Error       error = BDF_Err_Ok;
 
+
+    FT_MEM_SET( &p, 0, sizeof ( _bdf_parse_t ) );
+
+    p.opts   = ( opts != 0 ) ? opts : &_bdf_opts;
+    p.minlb  = 32767;
     p.memory = extmemory;  /* only during font creation */
 
-    n = _bdf_readstream(stream, _bdf_parse_start, (void *) &p, &lineno);
+    error = _bdf_readstream( stream, _bdf_parse_start,
+                             (void *)&p, &lineno );
+    if ( error )
+      goto Exit;
 
-    if (p.font != 0) {
-        /*
-         * If the font is not proportional, set the fonts monowidth
-         * field to the width of the font bounding box.
-         */
+    if ( p.font != 0 )
+    {
+      /* If the font is not proportional, set the font's monowidth */
+      /* field to the width of the font bounding box.              */
       memory = p.font->memory;
 
-        if (p.font->spacing != BDF_PROPORTIONAL)
-          p.font->monowidth = p.font->bbx.width;
-
-        /*
-         * If the number of glyphs loaded is not that of the original count,
-         * indicate the difference.
-         */
-        if (p.cnt != p.font->glyphs_used + p.font->unencoded_used) {
-            sprintf(msgbuf, ACMSG15, p.cnt,
-                    p.font->glyphs_used + p.font->unencoded_used);
-            _bdf_add_acmsg(p.font, msgbuf, ft_strlen(msgbuf));
-            p.font->modified = 1;
-        }
+      if ( p.font->spacing != BDF_PROPORTIONAL )
+        p.font->monowidth = p.font->bbx.width;
 
-        /*
-         * Once the font has been loaded, adjust the overall font metrics if
-         * necessary.
-         */
-        if (p.opts->correct_metrics != 0 &&
-            (p.font->glyphs_used > 0 || p.font->unencoded_used > 0)) {
-            if (p.maxrb - p.minlb != p.font->bbx.width) {
-                sprintf(msgbuf, ACMSG3, p.font->bbx.width, p.maxrb - p.minlb);
-                _bdf_add_acmsg(p.font, msgbuf, ft_strlen(msgbuf));
-                p.font->bbx.width = p.maxrb - p.minlb;
-                p.font->modified = 1;
-            }
-            if (p.font->bbx.x_offset != p.minlb) {
-                sprintf(msgbuf, ACMSG4, p.font->bbx.x_offset, p.minlb);
-                _bdf_add_acmsg(p.font, msgbuf, ft_strlen(msgbuf));
-                p.font->bbx.x_offset = p.minlb;
-                p.font->modified = 1;
-            }
-            if (p.font->bbx.ascent != p.maxas) {
-                sprintf(msgbuf, ACMSG5, p.font->bbx.ascent, p.maxas);
-                _bdf_add_acmsg(p.font, msgbuf, ft_strlen(msgbuf));
-                p.font->bbx.ascent = p.maxas;
-                p.font->modified = 1;
-            }
-            if (p.font->bbx.descent != p.maxds) {
-                sprintf(msgbuf, ACMSG6, p.font->bbx.descent, p.maxds);
-                _bdf_add_acmsg(p.font, msgbuf, ft_strlen(msgbuf));
-                p.font->bbx.descent = p.maxds;
-                p.font->bbx.y_offset = -p.maxds;
-                p.font->modified = 1;
-            }
-            if (p.maxas + p.maxds != p.font->bbx.height) {
-                sprintf(msgbuf, ACMSG7, p.font->bbx.height, p.maxas + p.maxds);
-                _bdf_add_acmsg(p.font, msgbuf, ft_strlen(msgbuf));
-            }
-            p.font->bbx.height = p.maxas + p.maxds;
+      /* If the number of glyphs loaded is not that of the original count, */
+      /* indicate the difference.                                          */
+      if ( p.cnt != p.font->glyphs_used + p.font->unencoded_used )
+      {
+        FT_TRACE2(( "bdf_load_font: " ACMSG15, p.cnt,
+                    p.font->glyphs_used + p.font->unencoded_used ));
+        p.font->modified = 1;
+      }
 
-            if (p.flags & _BDF_SWIDTH_ADJ)
-              _bdf_add_acmsg(p.font, ACMSG8, ft_strlen(ACMSG8));
+      /* Once the font has been loaded, adjust the overall font metrics if */
+      /* necessary.                                                        */
+      if ( p.opts->correct_metrics != 0 &&
+           ( p.font->glyphs_used > 0 || p.font->unencoded_used > 0 ) )
+      {
+        if ( p.maxrb - p.minlb != p.font->bbx.width )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG3,
+                      p.font->bbx.width, p.maxrb - p.minlb ));
+          p.font->bbx.width = p.maxrb - p.minlb;
+          p.font->modified  = 1;
         }
-    }
-
-    /*
-     * Last, if an error happened during loading, handle the messages.
-     */
-    if (n < 0 && callback != 0) {
-        /*
-         * An error was returned.  Alert the client.
-         */
-        p.cb.reason = BDF_ERROR;
-        p.cb.errlineno = lineno;
-        (*callback)(&p.cb, data);
-    } else if (p.flags & _BDF_START) {
-        if (p.font != 0) {
-            /*
-             * The ENDFONT field was never reached or did not exist.
-             */
-            if (!(p.flags & _BDF_GLYPHS))
-              /*
-               * Error happened while parsing header.
-               */
-              sprintf(msgbuf, ERRMSG2, lineno);
-            else
-              /*
-               * Error happened when parsing glyphs.
-               */
-              sprintf(msgbuf, ERRMSG3, lineno);
 
-            _bdf_add_acmsg(p.font, msgbuf, ft_strlen(msgbuf));
+        if ( p.font->bbx.x_offset != p.minlb )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG4,
+                      p.font->bbx.x_offset, p.minlb ));
+          p.font->bbx.x_offset = p.minlb;
+          p.font->modified     = 1;
         }
 
-        if (callback != 0) {
-            p.cb.reason = BDF_ERROR;
-            p.cb.errlineno = lineno;
-            (*callback)(&p.cb, data);
+        if ( p.font->bbx.ascent != p.maxas )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG5,
+                      p.font->bbx.ascent, p.maxas ));
+          p.font->bbx.ascent = p.maxas;
+          p.font->modified   = 1;
         }
-    } else if (callback != 0) {
-        /*
-         * This forces the progress bar to always finish.
-         */
-        p.cb.current = p.cb.total;
-        (*p.callback)(&p.cb, p.client_data);
-    }
-
-    /*
-     * Free up the list used during the parsing.
-     */
-    if (p.list.size > 0)
-      FT_FREE( p.list.field );
-
-    if (p.font != 0) {
-        /*
-         * Make sure the comments are NULL terminated if they exist.
-         */
-        memory = p.font->memory;
-
-        if (p.font->comments_len > 0) {
-	  if ( FT_REALLOC ( p.font->comments , p.font->comments_len ,
-			 p.font->comments_len + 1 ) )
-	    return 0;
-            p.font->comments[p.font->comments_len] = 0;
+
+        if ( p.font->bbx.descent != p.maxds )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG6,
+                      p.font->bbx.descent, p.maxds ));
+          p.font->bbx.descent  = p.maxds;
+          p.font->bbx.y_offset = -p.maxds;
+          p.font->modified     = 1;
         }
 
-        /*
-         * Make sure the auto-correct messages are NULL terminated if they
-         * exist.
-         */
-        if (p.font->acmsgs_len > 0) {
-	  memory = p.font->memory;
-
-	  if ( FT_REALLOC ( p.font->acmsgs , p.font->acmsgs_len ,
-			 p.font->acmsgs_len + 1 ) )
-	    return 0;
-            p.font->acmsgs[p.font->acmsgs_len] = 0;
+        if ( p.maxas + p.maxds != p.font->bbx.height )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG7,
+                      p.font->bbx.height, p.maxas + p.maxds ));
+          p.font->bbx.height = p.maxas + p.maxds;
         }
+
+        if ( p.flags & _BDF_SWIDTH_ADJ )
+          FT_TRACE2(( "bdf_load_font: " ACMSG8 ));
+      }
+    }
+
+    if ( p.flags & _BDF_START )
+    {
+      {
+        /* The ENDFONT field was never reached or did not exist. */
+        if ( !( p.flags & _BDF_GLYPHS ) )
+          /* Error happened while parsing header. */
+          FT_ERROR(( "bdf_load_font: " ERRMSG2, lineno ));
+        else
+          /* Error happened when parsing glyphs. */
+          FT_ERROR(( "bdf_load_font: " ERRMSG3, lineno ));
+      }
+    }
+
+    /* Free up the list used during the parsing. */
+    FT_FREE( p.list.field );
+
+    if ( p.font != 0 )
+    {
+      /* Make sure the comments are NULL terminated if they exist. */
+      memory = p.font->memory;
+
+      if ( p.font->comments_len > 0 ) {
+        if ( FT_RENEW_ARRAY( p.font->comments,
+                             p.font->comments_len,
+                             p.font->comments_len + 1 ) )
+          goto Exit;
+
+        p.font->comments[p.font->comments_len] = 0;
+      }
     }
 
-    return p.font;
-}
+    *font = p.font;
 
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  bdf_free_font( bdf_font_t*  font )
+  {
+    bdf_property_t*  prop;
+    unsigned long    i;
+    bdf_glyph_t*     glyphs;
+    FT_Memory        memory;
 
-FT_LOCAL_DEF( void )
-bdf_free_font( bdf_font_t *font )
-{
-  bdf_property_t *prop;
-    unsigned long i;
-    bdf_glyph_t *glyphs;
-    FT_Memory memory;
 
-    if (font == 0)
-        return;
+    if ( font == 0 )
+      return;
 
     memory = font->memory;
 
-    if (font->name != 0)
-      FT_FREE(font->name);
-
-    /*
-     * Free up the internal hash table of property names.
-     */
-    if (font->internal) {
-      hash_free((hashtable *) font->internal, memory);
-      FT_FREE(font->internal);
-    }
-    /*
-     * Free up the comment info.
-     */
-    if (font->comments_len > 0)
-      FT_FREE(font->comments);
-
-    /*
-     * Free up the auto-correction messages.
-     */
-    if (font->acmsgs_len > 0)
-      FT_FREE(font->acmsgs);
-
-    /*
-     * Free up the properties.
-     */
-    for (i = 0; i < font->props_size; i++) {
-        if (font->props[i].format == BDF_ATOM && font->props[i].value.atom)
-          FT_FREE(font->props[i].value.atom);
-    }
-
-    if (font->props_size > 0 && font->props != 0)
-      FT_FREE(font->props);
-
-    /*
-     * Free up the character info.
-     */
-    for (i = 0, glyphs = font->glyphs; i < font->glyphs_used; i++, glyphs++) {
-        if (glyphs->name)
-          FT_FREE(glyphs->name);
-        if (glyphs->bytes > 0 && glyphs->bitmap != 0)
-          FT_FREE(glyphs->bitmap);
-    }
-
-    for (i = 0, glyphs = font->unencoded; i < font->unencoded_used;
-         i++, glyphs++) {
-        if (glyphs->name)
-          FT_FREE(glyphs->name);
-        if (glyphs->bytes > 0)
-          FT_FREE(glyphs->bitmap);
-    }
-
-    if (font->glyphs_size > 0)
-      FT_FREE( font->glyphs);
-
-    if (font->unencoded_size > 0)
-      FT_FREE( font->unencoded);
-
-    /*
-     * Free up the overflow storage if it was used.
-     */
-    for (i = 0, glyphs = font->overflow.glyphs; i < font->overflow.glyphs_used;
-         i++, glyphs++) {
-      if (glyphs->name != 0)
-	FT_FREE(glyphs->name);
-      if (glyphs->bytes > 0)
-	FT_FREE( glyphs->bitmap);;
-    }
-    if (font->overflow.glyphs_size > 0)
-      FT_FREE(font->overflow.glyphs);
+    FT_FREE( font->name );
+
+    /* Free up the internal hash table of property names. */
+    if ( font->internal )
+    {
+      hash_free( (hashtable *)font->internal, memory );
+      FT_FREE( font->internal );
+    }
+
+    /* Free up the comment info. */
+    FT_FREE( font->comments );
+
+    /* Free up the properties. */
+    for ( i = 0; i < font->props_size; i++ )
+    {
+      if ( font->props[i].format == BDF_ATOM )
+        FT_FREE( font->props[i].value.atom );
+    }
+
+    FT_FREE( font->props );
+
+    /* Free up the character info. */
+    for ( i = 0, glyphs = font->glyphs;
+          i < font->glyphs_used; i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    for ( i = 0, glyphs = font->unencoded; i < font->unencoded_used;
+          i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    FT_FREE( font->glyphs );
+    FT_FREE( font->unencoded );
+
+    /* Free up the overflow storage if it was used. */
+    for ( i = 0, glyphs = font->overflow.glyphs;
+          i < font->overflow.glyphs_used; i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    FT_FREE( font->overflow.glyphs );
 
     /* bdf_cleanup */
-    hash_free(&(font->proptbl),memory);
+    hash_free( &(font->proptbl), memory );
 
-    /*
-     * Free up the user defined properties.
-     */
-    for (prop = font->user_props, i = 0; i < font->nuser_props; i++, prop++) {
-      FT_FREE(prop->name);
-      if (prop->format == BDF_ATOM && prop->value.atom != 0)
-	FT_FREE(prop->value.atom);
+    /* Free up the user defined properties. */
+    for (prop = font->user_props, i = 0;
+         i < font->nuser_props; i++, prop++ )
+    {
+      FT_FREE( prop->name );
+      if ( prop->format == BDF_ATOM )
+        FT_FREE( prop->value.atom );
     }
-    if (font->nuser_props > 0)
-      FT_FREE(font->user_props);
 
-    /*FREE( font);*/ /* XXX Fixme */
-}
+    FT_FREE( font->user_props );
 
+    /* FREE( font ); */ /* XXX Fixme */
+  }
 
 
-FT_LOCAL_DEF( bdf_property_t* )
-bdf_get_font_property( bdf_font_t*  font,
-                       char*        name)
-{
-    hashnode hn;
+  FT_LOCAL_DEF( bdf_property_t * )
+  bdf_get_font_property( bdf_font_t*  font,
+                         char*        name )
+  {
+    hashnode  hn;
+
 
-    if (font == 0 || font->props_size == 0 || name == 0 || *name == 0)
+    if ( font == 0 || font->props_size == 0 || name == 0 || *name == 0 )
       return 0;
 
-    hn = hash_lookup(name, (hashtable *) font->internal);
-    return (hn) ? (font->props + ((unsigned long) hn->data)) : 0;
-}
+    hn = hash_lookup( name, (hashtable *)font->internal );
+
+    return hn ? ( font->props + (unsigned long)hn->data ) : 0;
+  }
+
+
+/* END */
diff --git a/src/bdf/module.mk b/src/bdf/module.mk
index 1e5a62c..24115e7 100644
--- a/src/bdf/module.mk
+++ b/src/bdf/module.mk
@@ -2,7 +2,7 @@
 # FreeType 2 BDF module definition
 #
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # Francesco Zappa Nardelli
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
diff --git a/src/bdf/rules.mk b/src/bdf/rules.mk
index 9201e24..b1a3ed9 100644
--- a/src/bdf/rules.mk
+++ b/src/bdf/rules.mk
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright (C) 2001 by
+# Copyright (C) 2001, 2002 by
 # Francesco Zappa Nardelli
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -38,14 +38,13 @@ BDF_COMPILE := $(FT_COMPILE) $I$(BDF_DIR)
 
 # bdf driver sources (i.e., C files)
 #
-BDF_DRV_SRC := $(BDF_DIR_)bdflib.c $(BDF_DIR_)bdfdriver.c
+BDF_DRV_SRC := $(BDF_DIR_)bdflib.c $(BDF_DIR_)bdfdrivr.c
 
 
 # bdf driver headers
 #
-#BDF_DRV_H := $(BDF_DRV_SRC:%.c=%.h)
 BDF_DRV_H := $(BDF_DIR_)bdf.h \
-             $(BDF_DIR_)bdfdriver.h
+             $(BDF_DIR_)bdfdrivr.h
 
 # bdf driver object(s)
 #
diff --git a/src/cache/ftcsbits.c b/src/cache/ftcsbits.c
index 5b03c20..2f87c35 100644
--- a/src/cache/ftcsbits.c
+++ b/src/cache/ftcsbits.c
@@ -213,16 +213,23 @@
              CHECK_CHAR( xadvance )          &&
              CHECK_CHAR( yadvance )          )
         {
-          sbit->width    = (FT_Byte)bitmap->width;
-          sbit->height   = (FT_Byte)bitmap->rows;
-          sbit->pitch    = (FT_Char)bitmap->pitch;
-          sbit->left     = (FT_Char)slot->bitmap_left;
-          sbit->top      = (FT_Char)slot->bitmap_top;
-          sbit->xadvance = (FT_Char)xadvance;
-          sbit->yadvance = (FT_Char)yadvance;
-          sbit->format   = (FT_Byte)bitmap->pixel_mode;
-
-          /* grab the bitmap when possible - this is a hack !! */
+          sbit->width     = (FT_Byte)bitmap->width;
+          sbit->height    = (FT_Byte)bitmap->rows;
+          sbit->pitch     = (FT_Char)bitmap->pitch;
+          sbit->left      = (FT_Char)slot->bitmap_left;
+          sbit->top       = (FT_Char)slot->bitmap_top;
+          sbit->xadvance  = (FT_Char)xadvance;
+          sbit->yadvance  = (FT_Char)yadvance;
+          sbit->format    = (FT_Byte)bitmap->pixel_mode;
+          /* XXX: Fixme: We don't handle the number of gray levels      */
+          /*             consistently -- we say num_grays == 1 for      */
+          /*             monochrome but num_grays == 256 for gray.  It  */
+          /*             would be better to make this variable hold the */
+          /*             highest possible value so that it fits into    */
+          /*             a single byte.                                 */
+          sbit->num_grays = bitmap->num_grays;
+
+          /* grab the bitmap when possible - this is a hack! */
           if ( slot->flags & FT_GLYPH_OWN_BITMAP )
           {
             slot->flags &= ~FT_GLYPH_OWN_BITMAP;
diff --git a/src/type42/t42drivr.c b/src/type42/t42drivr.c
index 81e0e8a..f713f8f 100644
--- a/src/type42/t42drivr.c
+++ b/src/type42/t42drivr.c
@@ -32,69 +32,22 @@
 #include FT_INTERNAL_DRIVER_H
 #include FT_INTERNAL_OBJECTS_H
 #include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_TYPE42_TYPES_H
 #include FT_INTERNAL_POSTSCRIPT_AUX_H
 #include FT_INTERNAL_STREAM_H
 
 
-  /********************* Data Definitions ******************/
-
-  typedef enum  T42_EncodingType_
-  {
-    T42_ENCODING_TYPE_NONE = 0,
-    T42_ENCODING_TYPE_ARRAY,
-    T42_ENCODING_TYPE_STANDARD,
-    T42_ENCODING_TYPE_EXPERT,
-    T42_ENCODING_TYPE_ISOLATIN1
-  
-  } T42_EncodingType;
-
-
-  typedef struct  T42_Font_ 
-  {
-    /* font info dictionary */
-    PS_FontInfoRec   font_info; 
-
-    /* top-level dictionary */
-    FT_String*        font_name;
-
-    T42_EncodingType  encoding_type; 
-    T1_EncodingRec    encoding;
-
-    FT_Byte*          charstrings_block;
-    FT_Byte*          glyph_names_block;
-
-    FT_Int            num_glyphs;
-    FT_String**       glyph_names;       /* array of glyph names       */
-    FT_Byte**         charstrings;       /* array of glyph charstrings */
-    FT_Int*           charstrings_len;
-
-    FT_Byte           paint_type;
-    FT_Byte           font_type;
-    FT_Matrix         font_matrix; /* From FontMatrix field: a, b, c, d */
-    FT_Vector         font_offset; /* From FontMatrix field: tx, ty */
-    FT_BBox           font_bbox;
-
-    FT_Int            stroke_width;  
-
-  } T42_FontRec, *T42_Font;
-
-
-  typedef struct  T42_FaceRec_
-  {
-    FT_FaceRec     root;
-    T42_FontRec    type42;
-    void*          psnames;
-    void*          psaux;
-    void*          afm_data;
-    FT_Byte*       ttf_data;
-    FT_ULong       ttf_size;
-    FT_Face        ttf_face;
-    FT_CharMapRec  charmaprecs[2];
-    FT_CharMap     charmaps[2];
-    PS_Unicodes    unicode_map;
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_t42
 
-  } T42_FaceRec, *T42_Face;
 
+  /********************* Data Definitions ******************/
 
   typedef struct  T42_DriverRec_
   {
@@ -431,11 +384,6 @@
     FT_Fixed    temp_scale;
 
 
-    /* XXX: Are these three lines necessary */
-    if ( matrix->xx || matrix->yx )
-      /* with synthetic fonts, it's possible we get here twice  */
-      return;
-
     (void)T1_ToFixedArray( parser, 6, temp, 3 );
 
     temp_scale = ABS( temp[3] );
@@ -604,7 +552,7 @@
           cur++;
       }
 
-      face->type42.encoding_type = T42_ENCODING_TYPE_ARRAY;
+      face->type42.encoding_type = T1_ENCODING_TYPE_ARRAY;
       parser->root.cursor        = cur;
     }
     /* Otherwise, we should have either `StandardEncoding', */
@@ -613,15 +561,15 @@
     {
       if ( cur + 17 < limit                                            &&
            ft_strncmp( (const char*)cur, "StandardEncoding", 16 ) == 0 )
-        face->type42.encoding_type = T42_ENCODING_TYPE_STANDARD;
+        face->type42.encoding_type = T1_ENCODING_TYPE_STANDARD;
 
       else if ( cur + 15 < limit                                          &&
                 ft_strncmp( (const char*)cur, "ExpertEncoding", 14 ) == 0 )
-        face->type42.encoding_type = T42_ENCODING_TYPE_EXPERT;
+        face->type42.encoding_type = T1_ENCODING_TYPE_EXPERT;
 
       else if ( cur + 18 < limit                                             &&
                 ft_strncmp( (const char*)cur, "ISOLatin1Encoding", 17 ) == 0 )
-        face->type42.encoding_type = T42_ENCODING_TYPE_ISOLATIN1;
+        face->type42.encoding_type = T1_ENCODING_TYPE_ISOLATIN1;
 
       else {
         FT_ERROR(( "parse_encoding: invalid token!\n" ));
@@ -654,10 +602,10 @@
     FT_Byte*    cur    = parser->root.cursor;
     FT_Byte*    limit  = parser->root.limit;
     FT_Error    error;
-    FT_Int      num_tables, status;
-    FT_ULong    count, ttf_size, string_size;
+    FT_Int      num_tables = 0, status;
+    FT_ULong    count, ttf_size = 0, string_size = 0;
     FT_Bool     in_string  = 0;
-    FT_Byte     v;
+    FT_Byte     v = 0;
 
 
     /* The format is `/sfnts [ <...> <...> ... ] def' */
@@ -1151,7 +1099,7 @@
     loader.glyph_names.elements = 0;
 
     /* we must now build type42.encoding when we have a custom array */
-    if ( type42->encoding_type == T42_ENCODING_TYPE_ARRAY )
+    if ( type42->encoding_type == T1_ENCODING_TYPE_ARRAY )
     {
       FT_Int    charcode, idx, min_char, max_char;
       FT_Byte*  char_name;
@@ -1416,22 +1364,22 @@
 
     switch ( face->type42.encoding_type )
     {
-    case T42_ENCODING_TYPE_STANDARD:
+    case T1_ENCODING_TYPE_STANDARD:
       charmap->encoding    = ft_encoding_adobe_standard;
       charmap->encoding_id = 0;
       break;
 
-    case T42_ENCODING_TYPE_EXPERT:
+    case T1_ENCODING_TYPE_EXPERT:
       charmap->encoding    = ft_encoding_adobe_expert;
       charmap->encoding_id = 1;
       break;
 
-    case T42_ENCODING_TYPE_ARRAY:
+    case T1_ENCODING_TYPE_ARRAY:
       charmap->encoding    = ft_encoding_adobe_custom;
       charmap->encoding_id = 2;
       break;
 
-    case T42_ENCODING_TYPE_ISOLATIN1:
+    case T1_ENCODING_TYPE_ISOLATIN1:
       charmap->encoding    = ft_encoding_latin_1;
       charmap->encoding_id = 3;
       break;
@@ -1540,12 +1488,6 @@
     ttmodule = FT_Get_Module( driver->root.root.library, "truetype" );
     driver->ttclazz = (FT_Driver_Class)ttmodule->clazz;
 
-    /* XXX: What about hinter support? */
-#if 0
-    if (ttmodule->clazz->module_flags & ft_module_driver_has_hinter)
-      driver->root.clazz->root.module_flags |= ft_module_driver_has_hinter;
-#endif
-
     return T42_Err_Ok;
   }
 
@@ -2063,7 +2005,11 @@
     {
       ft_module_font_driver      |
       ft_module_driver_scalable  |
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
       ft_module_driver_has_hinter,
+#else
+      0,
+#endif
 
       sizeof ( T42_DriverRec ),