* renaming stream functions to the FT_Subject_Action scheme:

          FT_Seek_Stream         => FT_Stream_Seek
          FT_Skip_Stream         => FT_Stream_Skip
          FT_Read_Stream         => FT_Stream_Read
          FT_Read_Stream_At      => FT_Stream_Read_At
          FT_Access_Frame        => FT_Stream_Enter_Frame
          FT_Forget_Frame        => FT_Stream_Exit_Frame
          FT_Extract_Frame       => FT_Stream_Extract_Frame
          FT_Release_Frame       => FT_Stream_Release_Frame
          FT_Get_XXXX            => FT_Stream_Get_XXXX
          FT_Read_XXXX           => FT_Stream_Read_XXXX

          note also that:

          FT_New_Stream( filename, stream ) =>
            FT_Stream_Open( stream, filename )

          (the function doesn't create the FT_Stream structure, it simply
           initializes it for reading)

          FT_New_Memory_Stream( library, FT_Byte*  base, size, stream ) =>
            FT_Stream_Open_Memory( stream, const FT_Byte* base, size )

          FT_Done_Stream => FT_Stream_Close

          note that the name of the stream methods, defined in
          "include/freetype/ftsystem.h" have also been changed without
          problems:

            FT_Stream_IO    => FT_Stream_IOFunc
            FT_Stream_Close => FT_Stream_CloseFunc

9 files changed, 138 insertions, 1054 deletions

diff --git a/src/base/Jamfile b/src/base/Jamfile
index 3e2ff7e09..6b9de2103 100644
--- a/src/base/Jamfile
+++ b/src/base/Jamfile
@@ -10,8 +10,8 @@ SubDirHdrs  [ FT2_SubDir  src base ] ;
 
   if $(FT2_MULTI)
   {
-    _sources = ftcalc ftgloadr ftlist ftobjs ftstream ftoutln ftnames fttrigon
-               ftdbgmem ;
+    _sources = ftutil ftdbgmem ftstream ftcalc fttrigon ftgloadr ftoutln
+               ftobjs ftnames ;
   }
   else
   {
diff --git a/src/base/ftapi.c b/src/base/ftapi.c
index b95c42a19..8ae8e81c2 100644
--- a/src/base/ftapi.c
+++ b/src/base/ftapi.c
@@ -2011,7 +2011,7 @@
 
 
   FT_BASE_DEF( void )
-  FT_New_Memory_Stream( FT_Library  library,
+  FT_Stream_OpenMemory( FT_Library  library,
                         FT_Byte*    base,
                         FT_ULong    size,
                         FT_Stream   stream )
@@ -2021,7 +2021,7 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Seek_Stream( FT_Stream  stream,
+  FT_Stream_Seek( FT_Stream  stream,
                   FT_ULong   pos )
   {
     return FT_Stream_Seek( stream, pos );
@@ -2029,7 +2029,7 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Skip_Stream( FT_Stream  stream,
+  FT_Stream_Skip( FT_Stream  stream,
                   FT_Long    distance )
   {
     return FT_Stream_Skip( stream, distance );
@@ -2037,7 +2037,7 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Read_Stream( FT_Stream  stream,
+  FT_Stream_Read( FT_Stream  stream,
                   FT_Byte*   buffer,
                   FT_ULong   count )
   {
@@ -2046,7 +2046,7 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Read_Stream_At( FT_Stream  stream,
+  FT_Stream_Read_At( FT_Stream  stream,
                      FT_ULong   pos,
                      FT_Byte*   buffer,
                      FT_ULong   count )
@@ -2056,7 +2056,7 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Extract_Frame( FT_Stream  stream,
+  FT_Stream_Extract_Frame( FT_Stream  stream,
                     FT_ULong   count,
                     FT_Byte**  pbytes )
   {
@@ -2065,14 +2065,14 @@
 
 
   FT_BASE_DEF( void )
-  FT_Release_Frame( FT_Stream  stream,
+  FT_Stream_Release_Frame( FT_Stream  stream,
                     FT_Byte**  pbytes )
   {
     FT_Stream_Release_Frame( stream, pbytes );
   }                    
 
   FT_BASE_DEF( FT_Error )
-  FT_Access_Frame( FT_Stream  stream,
+  FT_Stream_Enter_Frame( FT_Stream  stream,
                    FT_ULong   count )
   {
     return FT_Stream_Enter_Frame( stream, count );
@@ -2080,7 +2080,7 @@
 
 
   FT_BASE_DEF( void )
-  FT_Forget_Frame( FT_Stream  stream )
+  FT_Stream_Exit_Frame( FT_Stream  stream )
   {
     FT_Stream_Exit_Frame( stream );
   }
diff --git a/src/base/ftbase.c b/src/base/ftbase.c
index 83e0ad01f..9852d26c3 100644
--- a/src/base/ftbase.c
+++ b/src/base/ftbase.c
@@ -20,14 +20,14 @@
 
 #define  FT_MAKE_OPTION_SINGLE_OBJECT
 
+#include "ftutil.c"
+#include "ftdbgmem.c"
+#include "ftstream.c"
 #include "ftcalc.c"
 #include "fttrigon.c"
+#include "ftoutln.c"
 #include "ftgloadr.c"
 #include "ftobjs.c"
-#include "ftstream.c"
-#include "ftlist.c"
-#include "ftoutln.c"
 #include "ftnames.c"
-#include "ftdbgmem.c"
 
 /* END */
diff --git a/src/base/ftmac.c b/src/base/ftmac.c
index 0c9611644..5e3ee780b 100644
--- a/src/base/ftmac.c
+++ b/src/base/ftmac.c
@@ -465,7 +465,7 @@
       if ( ALLOC( stream, sizeof ( *stream ) ) )
         goto Exit;
 
-      FT_New_Memory_Stream( library,
+      FT_Stream_OpenMemory( library,
                             base,
                             size,
                             stream );
@@ -518,7 +518,7 @@
       (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
     else
     {
-      FT_Done_Stream( stream );
+      FT_Stream_Close( stream );
       FREE( stream );
     }
     return error;
diff --git a/src/base/ftobjs.c b/src/base/ftobjs.c
index 3a7e2b32b..5d56b2e59 100644
--- a/src/base/ftobjs.c
+++ b/src/base/ftobjs.c
@@ -33,121 +33,6 @@
   /*************************************************************************/
   /****                                                                 ****/
   /****                                                                 ****/
-  /****                           M E M O R Y                           ****/
-  /****                                                                 ****/
-  /****                                                                 ****/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* 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_memory
-
-
-  /* documentation is in ftmemory.h */
-
-  FT_BASE_DEF( FT_Error )
-  FT_Alloc( FT_Memory  memory,
-            FT_Long    size,
-            void*     *P )
-  {
-    FT_ASSERT( P != 0 );
-
-    if ( size > 0 )
-    {
-      *P = memory->alloc( memory, size );
-      if ( !*P )
-      {
-        FT_ERROR(( "FT_Alloc:" ));
-        FT_ERROR(( " Out of memory? (%ld requested)\n",
-                   size ));
-
-        return FT_Err_Out_Of_Memory;
-      }
-      MEM_Set( *P, 0, size );
-    }
-    else
-      *P = NULL;
-
-    FT_TRACE7(( "FT_Alloc:" ));
-    FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
-                size, *P, P ));
-
-    return FT_Err_Ok;
-  }
-
-
-  /* documentation is in ftmemory.h */
-
-  FT_BASE_DEF( FT_Error )
-  FT_Realloc( FT_Memory  memory,
-              FT_Long    current,
-              FT_Long    size,
-              void**     P )
-  {
-    void*  Q;
-
-
-    FT_ASSERT( P != 0 );
-
-    /* if the original pointer is NULL, call FT_Alloc() */
-    if ( !*P )
-      return FT_Alloc( memory, size, P );
-
-    /* if the new block if zero-sized, clear the current one */
-    if ( size <= 0 )
-    {
-      FT_Free( memory, P );
-      return FT_Err_Ok;
-    }
-
-    Q = memory->realloc( memory, current, size, *P );
-    if ( !Q )
-      goto Fail;
-
-    if ( size > current )
-      memset( (char*)Q + current, 0, size - current );
-
-    *P = Q;
-    return FT_Err_Ok;
-
-  Fail:
-    FT_ERROR(( "FT_Realloc:" ));
-    FT_ERROR(( " Failed (current %ld, requested %ld)\n",
-               current, size ));
-    return FT_Err_Out_Of_Memory;
-  }
-
-
-  /* documentation is in ftmemory.h */
-
-  FT_BASE_DEF( void )
-  FT_Free( FT_Memory  memory,
-           void**     P )
-  {
-    FT_TRACE7(( "FT_Free:" ));
-    FT_TRACE7(( " Freeing block 0x%08p, ref 0x%08p\n",
-                P, P ? *P : (void*)0 ));
-
-    if ( P && *P )
-    {
-      memory->free( memory, *P );
-      *P = 0;
-    }
-  }
-
-
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-  /****                                                                 ****/
-  /****                                                                 ****/
   /****                           S T R E A M                           ****/
   /****                                                                 ****/
   /****                                                                 ****/
@@ -156,19 +41,10 @@
   /*************************************************************************/
 
 
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    ft_new_input_stream                                                */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Creates a new input stream object from an FT_Open_Args structure.  */
-  /*                                                                       */
-  /* <Note>                                                                */
-  /*    The function expects a valid `astream' parameter.                  */
-  /*                                                                       */
+ /* create a new input stream from a FT_Open_Args structure */
+ /*                                                         */
   static FT_Error
-  ft_new_input_stream( FT_Library     library,
+  ft_input_stream_new( FT_Library     library,
                        FT_Open_Args*  args,
                        FT_Stream*     astream )
   {
@@ -190,22 +66,23 @@
 
     stream->memory = memory;
 
-    /* now, look at the stream flags */
     if ( args->flags & ft_open_memory )
     {
-      error = 0;
-      FT_New_Memory_Stream( library,
+      /* create a memory-based stream */
+      FT_Stream_Open_Memory( stream,
                             (FT_Byte*)args->memory_base,
-                            args->memory_size,
-                            stream );
+                            args->memory_size );
     }
     else if ( args->flags & ft_open_pathname )
     {
-      error = FT_New_Stream( args->pathname, stream );
+      /* create a normal system stream */
+      error = FT_Stream_Open( stream, args->pathname );
       stream->pathname.pointer = args->pathname;
     }
     else if ( ( args->flags & ft_open_stream ) && args->stream )
     {
+      /* use an existing, user-provided stream */
+
       /* in this case, we do not need to allocate a new stream object */
       /* since the caller is responsible for closing it himself       */
       FREE( stream );
@@ -216,6 +93,8 @@
 
     if ( error )
       FREE( stream );
+    else
+      stream->memory = memory;  /* just to be certain */
 
     *astream = stream;
 
@@ -224,37 +103,20 @@
   }
 
 
-  /* documentation is in ftobjs.h */
-
-  FT_EXPORT_DEF( void )
-  FT_Done_Stream( FT_Stream  stream )
-  {
-    if ( stream && stream->close )
-    {
-      stream->close( stream );
-      stream->close = 0;
-    }
-  }
-
 
   static void
-  ft_done_stream( FT_Stream*  astream,
-                  FT_Int      external )
+  ft_input_stream_free( FT_Stream  stream,
+                        FT_Int     external )
   {
-    FT_Stream  stream = *astream;
-
-
-    if ( stream->close )
-      stream->close( stream );
-
-    if ( !external )
+    if ( stream )
     {
       FT_Memory  memory = stream->memory;
 
+      FT_Stream_Close( stream );
 
-      FREE( stream );
+      if ( !external )
+        FREE( stream );
     }
-    *astream = 0;
   }
 
 
@@ -262,346 +124,6 @@
 #define FT_COMPONENT  trace_objs
 
 
-#if 0
-
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-  /****                                                                 ****/
-  /****                                                                 ****/
-  /****                     G L Y P H   L O A D E R                     ****/
-  /****                                                                 ****/
-  /****                                                                 ****/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* The glyph loader is a simple object which is used to load a set of    */
-  /* glyphs easily.  It is critical for the correct loading of composites. */
-  /*                                                                       */
-  /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
-  /*                                                                       */
-  /*   loader.base     Is really the bottom of the stack.  It describes a  */
-  /*                   single glyph image made of the juxtaposition of     */
-  /*                   several glyphs (those `in the stack').              */
-  /*                                                                       */
-  /*   loader.current  Describes the top of the stack, on which a new      */
-  /*                   glyph can be loaded.                                */
-  /*                                                                       */
-  /*   Rewind          Clears the stack.                                   */
-  /*   Prepare         Set up `loader.current' for addition of a new glyph */
-  /*                   image.                                              */
-  /*   Add             Add the `current' glyph image to the `base' one,    */
-  /*                   and prepare for another one.                        */
-  /*                                                                       */
-  /* The glyph loader is now a base object.  Each driver used to           */
-  /* re-implement it in one way or the other, which wasted code and        */
-  /* energy.                                                               */
-  /*                                                                       */
-  /*************************************************************************/
-
-
-  /* create a new glyph loader */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_New( FT_Memory         memory,
-                      FT_GlyphLoader*  *aloader )
-  {
-    FT_GlyphLoader*  loader;
-    FT_Error         error;
-
-
-    if ( !ALLOC( loader, sizeof ( *loader ) ) )
-    {
-      loader->memory = memory;
-      *aloader       = loader;
-    }
-    return error;
-  }
-
-
-  /* rewind the glyph loader - reset counters to 0 */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Rewind( FT_GlyphLoader*  loader )
-  {
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    base->outline.n_points   = 0;
-    base->outline.n_contours = 0;
-    base->num_subglyphs      = 0;
-
-    *current = *base;
-  }
-
-
-  /* reset the glyph loader, frees all allocated tables */
-  /* and starts from zero                               */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Reset( FT_GlyphLoader*  loader )
-  {
-    FT_Memory memory = loader->memory;
-
-
-    FREE( loader->base.outline.points );
-    FREE( loader->base.outline.tags );
-    FREE( loader->base.outline.contours );
-    FREE( loader->base.extra_points );
-    FREE( loader->base.subglyphs );
-
-    loader->max_points    = 0;
-    loader->max_contours  = 0;
-    loader->max_subglyphs = 0;
-
-    FT_GlyphLoader_Rewind( loader );
-  }
-
-
-  /* delete a glyph loader */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Done( FT_GlyphLoader*  loader )
-  {
-    if ( loader )
-    {
-      FT_Memory memory = loader->memory;
-
-
-      FT_GlyphLoader_Reset( loader );
-      FREE( loader );
-    }
-  }
-
-
-  /* re-adjust the `current' outline fields */
-  static void
-  FT_GlyphLoader_Adjust_Points( FT_GlyphLoader*  loader )
-  {
-    FT_Outline*  base    = &loader->base.outline;
-    FT_Outline*  current = &loader->current.outline;
-
-
-    current->points   = base->points   + base->n_points;
-    current->tags     = base->tags     + base->n_points;
-    current->contours = base->contours + base->n_contours;
-
-    /* handle extra points table - if any */
-    if ( loader->use_extra )
-      loader->current.extra_points =
-        loader->base.extra_points + base->n_points;
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_Create_Extra( FT_GlyphLoader*  loader )
-  {
-    FT_Error   error;
-    FT_Memory  memory = loader->memory;
-
-
-    if ( !ALLOC_ARRAY( loader->base.extra_points,
-                       loader->max_points, FT_Vector ) )
-    {
-      loader->use_extra = 1;
-      FT_GlyphLoader_Adjust_Points( loader );
-    }
-    return error;
-  }
-
-
-  /* re-adjust the `current' subglyphs field */
-  static void
-  FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader*  loader )
-  {
-    FT_GlyphLoad* base    = &loader->base;
-    FT_GlyphLoad* current = &loader->current;
-
-
-    current->subglyphs = base->subglyphs + base->num_subglyphs;
-  }
-
-
-  /* Ensure that we can add `n_points' and `n_contours' to our glyph. this */
-  /* function reallocates its outline tables if necessary.  Note that it   */
-  /* DOESN'T change the number of points within the loader!                */
-  /*                                                                       */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_Check_Points( FT_GlyphLoader*  loader,
-                               FT_UInt          n_points,
-                               FT_UInt          n_contours )
-  {
-    FT_Memory    memory  = loader->memory;
-    FT_Error     error   = FT_Err_Ok;
-    FT_Outline*  base    = &loader->base.outline;
-    FT_Outline*  current = &loader->current.outline;
-    FT_Bool      adjust  = 1;
-
-    FT_UInt      new_max, old_max;
-
-
-    /* check points & tags */
-    new_max = base->n_points + current->n_points + n_points;
-    old_max = loader->max_points;
-
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 7 ) & -8;
-
-      if ( REALLOC_ARRAY( base->points, old_max, new_max, FT_Vector ) ||
-           REALLOC_ARRAY( base->tags,   old_max, new_max, FT_Byte   ) )
-       goto Exit;
-
-      if ( loader->use_extra &&
-           REALLOC_ARRAY( loader->base.extra_points, old_max,
-                          new_max, FT_Vector ) )
-       goto Exit;
-
-      adjust = 1;
-      loader->max_points = new_max;
-    }
-
-    /* check contours */
-    old_max = loader->max_contours;
-    new_max = base->n_contours + current->n_contours +
-              n_contours;
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 3 ) & -4;
-      if ( REALLOC_ARRAY( base->contours, old_max, new_max, FT_Short ) )
-        goto Exit;
-
-      adjust = 1;
-      loader->max_contours = new_max;
-    }
-
-    if ( adjust )
-      FT_GlyphLoader_Adjust_Points( loader );
-
-  Exit:
-    return error;
-  }
-
-
-  /* Ensure that we can add `n_subglyphs' to our glyph. this function */
-  /* reallocates its subglyphs table if necessary.  Note that it DOES */
-  /* NOT change the number of subglyphs within the loader!            */
-  /*                                                                  */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_Check_Subglyphs( FT_GlyphLoader*  loader,
-                                  FT_UInt          n_subs )
-  {
-    FT_Memory  memory = loader->memory;
-    FT_Error   error  = FT_Err_Ok;
-    FT_UInt    new_max, old_max;
-
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
-    old_max = loader->max_subglyphs;
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 1 ) & -2;
-      if ( REALLOC_ARRAY( base->subglyphs, old_max, new_max, FT_SubGlyph ) )
-        goto Exit;
-
-      loader->max_subglyphs = new_max;
-
-      FT_GlyphLoader_Adjust_Subglyphs( loader );
-    }
-
-  Exit:
-    return error;
-  }
-
-
-  /* prepare loader for the addition of a new glyph on top of the base one */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Prepare( FT_GlyphLoader*  loader )
-  {
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    current->outline.n_points   = 0;
-    current->outline.n_contours = 0;
-    current->num_subglyphs      = 0;
-
-    FT_GlyphLoader_Adjust_Points   ( loader );
-    FT_GlyphLoader_Adjust_Subglyphs( loader );
-  }
-
-
-  /* add current glyph to the base image - and prepare for another */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Add( FT_GlyphLoader*  loader )
-  {
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-    FT_UInt        n_curr_contours = current->outline.n_contours;
-    FT_UInt        n_base_points   = base->outline.n_points;
-    FT_UInt        n;
-
-
-    base->outline.n_points =
-      (short)( base->outline.n_points + current->outline.n_points );
-    base->outline.n_contours =
-      (short)( base->outline.n_contours + current->outline.n_contours );
-
-    base->num_subglyphs += current->num_subglyphs;
-
-    /* adjust contours count in newest outline */
-    for ( n = 0; n < n_curr_contours; n++ )
-      current->outline.contours[n] =
-        (short)( current->outline.contours[n] + n_base_points );
-
-    /* prepare for another new glyph image */
-    FT_GlyphLoader_Prepare( loader );
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_Copy_Points( FT_GlyphLoader*  target,
-                              FT_GlyphLoader*  source )
-  {
-    FT_Error  error;
-    FT_UInt   num_points   = source->base.outline.n_points;
-    FT_UInt   num_contours = source->base.outline.n_contours;
-
-
-    error = FT_GlyphLoader_Check_Points( target, num_points, num_contours );
-    if ( !error )
-    {
-      FT_Outline*  out = &target->base.outline;
-      FT_Outline*  in  = &source->base.outline;
-
-
-      MEM_Copy( out->points, in->points,
-                num_points * sizeof ( FT_Vector ) );
-      MEM_Copy( out->tags, in->tags,
-                num_points * sizeof ( char ) );
-      MEM_Copy( out->contours, in->contours,
-                num_contours * sizeof ( short ) );
-
-      /* do we need to copy the extra points? */
-      if ( target->use_extra && source->use_extra )
-        MEM_Copy( target->base.extra_points, source->base.extra_points,
-                  num_points * sizeof ( FT_Vector ) );
-
-      out->n_points   = (short)num_points;
-      out->n_contours = (short)num_contours;
-
-      FT_GlyphLoader_Adjust_Points( target );
-    }
-
-    return error;
-  }
-
-#endif
-
   /*************************************************************************/
   /*************************************************************************/
   /*************************************************************************/
@@ -1064,10 +586,11 @@
       clazz->done_face( face );
 
     /* close the stream for this face if needed */
-    ft_done_stream(
-      &face->stream,
+    ft_input_stream_free( face->stream,
       ( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );
 
+    face->stream = 0;
+
     /* get rid of it */
     if ( face->internal )
     {
@@ -1225,7 +748,7 @@
 
 
     /* test for valid `library' delayed to */
-    /* ft_new_input_stream()               */
+    /* ft_input_stream_new()               */
 
     if ( !aface || !args )
       return FT_Err_Invalid_Argument;
@@ -1236,7 +759,7 @@
                                args->stream                     );
 
     /* create input stream */
-    error = ft_new_input_stream( library, args, &stream );
+    error = ft_input_stream_new( library, args, &stream );
     if ( error )
       goto Exit;
 
@@ -1269,7 +792,7 @@
       else
         error = FT_Err_Invalid_Handle;
 
-      ft_done_stream( &stream, external_stream );
+      ft_input_stream_free( stream, external_stream );
       goto Fail;
     }
     else
@@ -1310,7 +833,7 @@
       error = FT_Err_Unknown_File_Format;
 
   Fail2:
-      ft_done_stream( &stream, external_stream );
+      ft_input_stream_free( stream, external_stream );
       goto Fail;
     }
 
@@ -1419,7 +942,7 @@
     FT_Driver_Class*  clazz;
 
 
-    /* test for valid `parameters' delayed to ft_new_input_stream() */
+    /* test for valid `parameters' delayed to ft_input_stream_new() */
 
     if ( !face )
       return FT_Err_Invalid_Face_Handle;
@@ -1428,7 +951,7 @@
     if ( !driver )
       return FT_Err_Invalid_Driver_Handle;
 
-    error = ft_new_input_stream( driver->root.library, parameters, &stream );
+    error = ft_input_stream_new( driver->root.library, parameters, &stream );
     if ( error )
       goto Exit;
 
@@ -1441,7 +964,7 @@
       error = clazz->attach_file( face, stream );
 
     /* close the attached stream */
-    ft_done_stream( &stream,
+    ft_input_stream_free( stream,
                     (FT_Bool)( parameters->stream &&
                                ( parameters->flags & ft_open_stream ) ) );
 
@@ -2636,6 +2159,9 @@
     if ( !memory )
       return FT_Err_Invalid_Argument;
 
+    /* init debugging support */
+    ft_debug_init();
+
     /* first of all, allocate the library object */
     if ( ALLOC( library, sizeof ( *library ) ) )
       return error;
diff --git a/src/base/ftstream.c b/src/base/ftstream.c
index 3fc40f9f7..459bf8342 100644
--- a/src/base/ftstream.c
+++ b/src/base/ftstream.c
@@ -32,13 +32,11 @@
 
 
   FT_BASE_DEF( void )
-  FT_New_Memory_Stream( FT_Library  library,
-                        FT_Byte*    base,
-                        FT_ULong    size,
-                        FT_Stream   stream )
+  FT_Stream_Open_Memory( FT_Stream       stream,
+                         const FT_Byte*  base,
+                         FT_ULong        size )
   {
-    stream->memory = library->memory;
-    stream->base   = base;
+    stream->base   = (FT_Byte*) base;
     stream->size   = size;
     stream->pos    = 0;
     stream->cursor = 0;
@@ -47,8 +45,19 @@
   }
 
 
+  FT_BASE_DEF( void )
+  FT_Stream_Close( FT_Stream  stream )
+  {
+    if ( stream && stream->close )
+    {
+      stream->close( stream );
+      stream->close = NULL;
+    }
+  }
+
+
   FT_BASE_DEF( FT_Error )
-  FT_Seek_Stream( FT_Stream  stream,
+  FT_Stream_Seek( FT_Stream  stream,
                   FT_ULong   pos )
   {
     FT_Error  error;
@@ -60,7 +69,7 @@
     {
       if ( stream->read( stream, pos, 0, 0 ) )
       {
-        FT_ERROR(( "FT_Seek_Stream:" ));
+        FT_ERROR(( "FT_Stream_Seek:" ));
         FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                    pos, stream->size ));
 
@@ -72,7 +81,7 @@
     /* note that seeking to the first position after the file is valid */
     else if ( pos > stream->size )
     {
-      FT_ERROR(( "FT_Seek_Stream:" ));
+      FT_ERROR(( "FT_Stream_Seek:" ));
       FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                  pos, stream->size ));
 
@@ -87,10 +96,10 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Skip_Stream( FT_Stream  stream,
+  FT_Stream_Skip( FT_Stream  stream,
                   FT_Long    distance )
   {
-    return FT_Seek_Stream( stream, (FT_ULong)( stream->pos + distance ) );
+    return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );
   }
 
 
@@ -102,16 +111,16 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Read_Stream( FT_Stream  stream,
+  FT_Stream_Read( FT_Stream  stream,
                   FT_Byte*   buffer,
                   FT_ULong   count )
   {
-    return FT_Read_Stream_At( stream, stream->pos, buffer, count );
+    return FT_Stream_Read_At( stream, stream->pos, buffer, count );
   }
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Read_Stream_At( FT_Stream  stream,
+  FT_Stream_Read_At( FT_Stream  stream,
                      FT_ULong   pos,
                      FT_Byte*   buffer,
                      FT_ULong   count )
@@ -122,7 +131,7 @@
 
     if ( pos >= stream->size )
     {
-      FT_ERROR(( "FT_Read_Stream_At:" ));
+      FT_ERROR(( "FT_Stream_Read_At:" ));
       FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                  pos, stream->size ));
 
@@ -144,7 +153,7 @@
 
     if ( read_bytes < count )
     {
-      FT_ERROR(( "FT_Read_Stream_At:" ));
+      FT_ERROR(( "FT_Stream_Read_At:" ));
       FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
                  count, read_bytes ));
 
@@ -156,19 +165,19 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Extract_Frame( FT_Stream  stream,
+  FT_Stream_Extract_Frame( FT_Stream  stream,
                     FT_ULong   count,
                     FT_Byte**  pbytes )
   {
     FT_Error  error;
 
 
-    error = FT_Access_Frame( stream, count );
+    error = FT_Stream_Enter_Frame( stream, count );
     if ( !error )
     {
       *pbytes = (FT_Byte*)stream->cursor;
 
-      /* equivalent to FT_Forget_Frame(), with no memory block release */
+      /* equivalent to FT_Stream_Exit_Frame(), with no memory block release */
       stream->cursor = 0;
       stream->limit  = 0;
     }
@@ -178,7 +187,7 @@
 
 
   FT_BASE_DEF( void )
-  FT_Release_Frame( FT_Stream  stream,
+  FT_Stream_Release_Frame( FT_Stream  stream,
                     FT_Byte**  pbytes )
   {
     if ( stream->read )
@@ -193,7 +202,7 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Access_Frame( FT_Stream  stream,
+  FT_Stream_Enter_Frame( FT_Stream  stream,
                    FT_ULong   count )
   {
     FT_Error  error = FT_Err_Ok;
@@ -217,7 +226,7 @@
                                  stream->base, count );
       if ( read_bytes < count )
       {
-        FT_ERROR(( "FT_Access_Frame:" ));
+        FT_ERROR(( "FT_Stream_Enter_Frame:" ));
         FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
                    count, read_bytes ));
 
@@ -234,7 +243,7 @@
       if ( stream->pos >= stream->size        ||
            stream->pos + count > stream->size )
       {
-        FT_ERROR(( "FT_Access_Frame:" ));
+        FT_ERROR(( "FT_Stream_Enter_Frame:" ));
         FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
                    stream->pos, count, stream->size ));
 
@@ -254,7 +263,7 @@
 
 
   FT_BASE_DEF( void )
-  FT_Forget_Frame( FT_Stream  stream )
+  FT_Stream_Exit_Frame( FT_Stream  stream )
   {
     /* IMPORTANT: The assertion stream->cursor != 0 was removed, given    */
     /*            that it is possible to access a frame of length 0 in    */
@@ -263,7 +272,7 @@
     /*                                                                    */
     /*  In this case, the loader code handles the 0-length table          */
     /*  gracefully; however, stream.cursor is really set to 0 by the      */
-    /*  FT_Access_Frame() call, and this is not an error.                 */
+    /*  FT_Stream_Enter_Frame() call, and this is not an error.                 */
     /*                                                                    */
     FT_ASSERT( stream );
 
@@ -296,7 +305,7 @@
 
 
   FT_BASE_DEF( FT_Short )
-  FT_Get_Short( FT_Stream  stream )
+  FT_Stream_Get_Short( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Short  result;
@@ -315,7 +324,7 @@
 
 
   FT_BASE_DEF( FT_Short )
-  FT_Get_ShortLE( FT_Stream  stream )
+  FT_Stream_Get_ShortLE( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Short  result;
@@ -334,7 +343,7 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Get_Offset( FT_Stream  stream )
+  FT_Stream_Get_Offset( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Long   result;
@@ -352,7 +361,7 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Get_Long( FT_Stream  stream )
+  FT_Stream_Get_Long( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Long   result;
@@ -370,7 +379,7 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Get_LongLE( FT_Stream  stream )
+  FT_Stream_Get_LongLE( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Long   result;
@@ -388,7 +397,7 @@
 
 
   FT_BASE_DEF( FT_Char )
-  FT_Read_Char( FT_Stream  stream,
+  FT_Stream_Read_Char( FT_Stream  stream,
                 FT_Error*  error )
   {
     FT_Byte  result = 0;
@@ -416,7 +425,7 @@
 
   Fail:
     *error = FT_Err_Invalid_Stream_Operation;
-    FT_ERROR(( "FT_Read_Char:" ));
+    FT_ERROR(( "FT_Stream_Read_Char:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
@@ -425,8 +434,8 @@
 
 
   FT_BASE_DEF( FT_Short )
-  FT_Read_Short( FT_Stream  stream,
-                 FT_Error*  error )
+  FT_Stream_Read_Short( FT_Stream  stream,
+                        FT_Error*  error )
   {
     FT_Byte   reads[2];
     FT_Byte*  p = 0;
@@ -463,7 +472,7 @@
 
   Fail:
     *error = FT_Err_Invalid_Stream_Operation;
-    FT_ERROR(( "FT_Read_Short:" ));
+    FT_ERROR(( "FT_Stream_Read_Short:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
@@ -472,7 +481,7 @@
 
 
   FT_BASE_DEF( FT_Short )
-  FT_Read_ShortLE( FT_Stream  stream,
+  FT_Stream_Read_ShortLE( FT_Stream  stream,
                    FT_Error*  error )
   {
     FT_Byte   reads[2];
@@ -510,7 +519,7 @@
 
   Fail:
     *error = FT_Err_Invalid_Stream_Operation;
-    FT_ERROR(( "FT_Read_Short:" ));
+    FT_ERROR(( "FT_Stream_Read_Short:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
@@ -519,7 +528,7 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Read_Offset( FT_Stream  stream,
+  FT_Stream_Read_Offset( FT_Stream  stream,
                   FT_Error*  error )
   {
     FT_Byte   reads[3];
@@ -557,7 +566,7 @@
 
   Fail:
     *error = FT_Err_Invalid_Stream_Operation;
-    FT_ERROR(( "FT_Read_Offset:" ));
+    FT_ERROR(( "FT_Stream_Read_Offset:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
@@ -566,7 +575,7 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Read_Long( FT_Stream  stream,
+  FT_Stream_Read_Long( FT_Stream  stream,
                 FT_Error*  error )
   {
     FT_Byte   reads[4];
@@ -603,7 +612,7 @@
     return result;
 
   Fail:
-    FT_ERROR(( "FT_Read_Long:" ));
+    FT_ERROR(( "FT_Stream_Read_Long:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
     *error = FT_Err_Invalid_Stream_Operation;
@@ -613,7 +622,7 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Read_LongLE( FT_Stream  stream,
+  FT_Stream_Read_LongLE( FT_Stream  stream,
                   FT_Error*  error )
   {
     FT_Byte   reads[4];
@@ -650,7 +659,7 @@
     return result;
 
   Fail:
-    FT_ERROR(( "FT_Read_Long:" ));
+    FT_ERROR(( "FT_Stream_Read_Long:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
     *error = FT_Err_Invalid_Stream_Operation;
@@ -660,9 +669,9 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Read_Fields( FT_Stream              stream,
-                  const FT_Frame_Field*  fields,
-                  void*                  structure )
+  FT_Stream_Read_Fields( FT_Stream              stream,
+                         const FT_Frame_Field*  fields,
+                         void*                  structure )
   {
     FT_Error  error;
     FT_Bool   frame_accessed = 0;
@@ -683,7 +692,7 @@
       switch ( fields->value )
       {
       case ft_frame_start:  /* access a new frame */
-        error = FT_Access_Frame( stream, fields->offset );
+        error = FT_Stream_Enter_Frame( stream, fields->offset );
         if ( error )
           goto Exit;
 
@@ -795,7 +804,7 @@
   Exit:
     /* close the frame if it was opened by this read */
     if ( frame_accessed )
-      FT_Forget_Frame( stream );
+      FT_Stream_Exit_Frame( stream );
 
     return error;
   }
diff --git a/src/base/ftsystem.c b/src/base/ftsystem.c
index fca525c73..499d309a9 100644
--- a/src/base/ftsystem.c
+++ b/src/base/ftsystem.c
@@ -158,7 +158,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    ft_close_stream                                                    */
+  /*    ft_ansi_stream_close                                               */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The function to close a stream.                                    */
@@ -167,7 +167,7 @@
   /*    stream :: A pointer to the stream object.                          */
   /*                                                                       */
   FT_CALLBACK_DEF( void )
-  ft_close_stream( FT_Stream  stream )
+  ft_ansi_stream_close( FT_Stream  stream )
   {
     fclose( STREAM_FILE( stream ) );
 
@@ -180,7 +180,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    ft_io_stream                                                       */
+  /*    ft_ansi_stream_io                                                  */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The function to open a stream.                                     */
@@ -198,10 +198,10 @@
   /*    The number of bytes actually read.                                 */
   /*                                                                       */
   FT_CALLBACK_DEF( unsigned long )
-  ft_io_stream( FT_Stream       stream,
-                unsigned long   offset,
-                unsigned char*  buffer,
-                unsigned long   count )
+  ft_ansi_stream_io( FT_Stream       stream,
+                     unsigned long   offset,
+                     unsigned char*  buffer,
+                     unsigned long   count )
   {
     FILE*  file;
 
@@ -217,38 +217,38 @@
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Error )
-  FT_New_Stream( const char*  filepathname,
-                 FT_Stream    astream )
+  FT_Stream_Open( FT_Stream    stream,
+                  const char*  filepathname )
   {
     FILE*  file;
 
 
-    if ( !astream )
+    if ( !stream )
       return FT_Err_Invalid_Stream_Handle;
 
     file = fopen( filepathname, "rb" );
     if ( !file )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not open `%s'\n", filepathname ));
 
       return FT_Err_Cannot_Open_Resource;
     }
 
     fseek( file, 0, SEEK_END );
-    astream->size = ftell( file );
+    stream->size = ftell( file );
     fseek( file, 0, SEEK_SET );
 
-    astream->descriptor.pointer = file;
-    astream->pathname.pointer   = (char*)filepathname;
-    astream->pos                = 0;
+    stream->descriptor.pointer = file;
+    stream->pathname.pointer   = (char*)filepathname;
+    stream->pos                = 0;
 
-    astream->read  = ft_io_stream;
-    astream->close = ft_close_stream;
+    stream->read  = ft_ansi_stream_io;
+    stream->close = ft_ansi_stream_close;
 
-    FT_TRACE1(( "FT_New_Stream:" ));
+    FT_TRACE1(( "FT_Stream_Open:" ));
     FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
-                filepathname, astream->size ));
+                filepathname, stream->size ));
 
     return FT_Err_Ok;
   }
@@ -259,13 +259,13 @@
 
   extern FT_Int
   ft_mem_debug_init( FT_Memory  memory );
-  
+
   extern void
   ft_mem_debug_done( FT_Memory  memory );
-  
-#endif  
-      
-      
+
+#endif
+
+
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Memory )
@@ -283,7 +283,7 @@
       memory->free    = ft_free;
 #ifdef FT_DEBUG_MEMORY
       ft_mem_debug_init( memory );
-#endif    
+#endif
     }
 
     return memory;
@@ -297,7 +297,7 @@
   {
 #ifdef FT_DEBUG_MEMORY
     ft_mem_debug_done( memory );
-#endif  
+#endif
     memory->free( memory, memory );
   }
 
diff --git a/src/base/ftutil.c b/src/base/ftutil.c
index 898729752..f30ca4240 100644
--- a/src/base/ftutil.c
+++ b/src/base/ftutil.c
@@ -1,6 +1,7 @@
 #include <ft2build.h>
 #include FT_INTERNAL_DEBUG_H
-#include FT_INTERNAL_UTIL_H
+#include FT_INTERNAL_MEMORY_H
+#include FT_LIST_H
 
 
   /*************************************************************************/
@@ -32,7 +33,7 @@
             FT_Long    size,
             void*     *P )
   {
-    FT_Assert( P != 0 );
+    FT_ASSERT( P != 0 );
 
     if ( size > 0 )
     {
@@ -69,7 +70,7 @@
     void*  Q;
 
 
-    FT_Assert( P != 0 );
+    FT_ASSERT( P != 0 );
 
     /* if the original pointer is NULL, call FT_Alloc() */
     if ( !*P )
@@ -308,455 +309,3 @@
   }
 
 
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*****                                                               *****/
-  /*****                                                               *****/
-  /*****                    G L Y P H   L O A D E R                    *****/
-  /*****                                                               *****/
-  /*****                                                               *****/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* The glyph loader is a simple object which is used to load a set of    */
-  /* glyphs easily.  It is critical for the correct loading of composites. */
-  /*                                                                       */
-  /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
-  /*                                                                       */
-  /*   loader.base     Is really the bottom of the stack.  It describes a  */
-  /*                   single glyph image made of the juxtaposition of     */
-  /*                   several glyphs (those `in the stack').              */
-  /*                                                                       */
-  /*   loader.current  Describes the top of the stack, on which a new      */
-  /*                   glyph can be loaded.                                */
-  /*                                                                       */
-  /*   Rewind          Clears the stack.                                   */
-  /*   Prepare         Set up `loader.current' for addition of a new glyph */
-  /*                   image.                                              */
-  /*   Add             Add the `current' glyph image to the `base' one,    */
-  /*                   and prepare for another one.                        */
-  /*                                                                       */
-  /* The glyph loader is now a base object.  Each driver used to           */
-  /* re-implement it in one way or the other, which wasted code and        */
-  /* energy.                                                               */
-  /*                                                                       */
-  /*************************************************************************/
-
-
-  /* create a new glyph loader */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader _New( FT_Memory         memory,
-                      FT_GlyphLoader   *aloader )
-  {
-    FT_GlyphLoader   loader;
-    FT_Error         error;
-
-
-    if ( !ALLOC( loader, sizeof ( *loader ) ) )
-    {
-      loader->memory = memory;
-      *aloader       = loader;
-    }
-    return error;
-  }
-
-
-  /* rewind the glyph loader - reset counters to 0 */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader _Rewind( FT_GlyphLoader   loader )
-  {
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    base->outline.n_points   = 0;
-    base->outline.n_contours = 0;
-    base->num_subglyphs      = 0;
-
-    *current = *base;
-  }
-
-
-  /* reset the glyph loader, frees all allocated tables */
-  /* and starts from zero                               */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader _Reset( FT_GlyphLoader   loader )
-  {
-    FT_Memory memory = loader->memory;
-
-
-    FREE( loader->base.outline.points );
-    FREE( loader->base.outline.tags );
-    FREE( loader->base.outline.contours );
-    FREE( loader->base.extra_points );
-    FREE( loader->base.subglyphs );
-
-    loader->max_points    = 0;
-    loader->max_contours  = 0;
-    loader->max_subglyphs = 0;
-
-    FT_GlyphLoader _Rewind( loader );
-  }
-
-
-  /* delete a glyph loader */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader _Done( FT_GlyphLoader   loader )
-  {
-    if ( loader )
-    {
-      FT_Memory memory = loader->memory;
-
-
-      FT_GlyphLoader _Reset( loader );
-      FREE( loader );
-    }
-  }
-
-
-  /* re-adjust the `current' outline fields */
-  static void
-  FT_GlyphLoader _Adjust_Points( FT_GlyphLoader   loader )
-  {
-    FT_Outline*  base    = &loader->base.outline;
-    FT_Outline*  current = &loader->current.outline;
-
-
-    current->points   = base->points   + base->n_points;
-    current->tags     = base->tags     + base->n_points;
-    current->contours = base->contours + base->n_contours;
-
-    /* handle extra points table - if any */
-    if ( loader->use_extra )
-      loader->current.extra_points =
-        loader->base.extra_points + base->n_points;
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader _Create_Extra( FT_GlyphLoader   loader )
-  {
-    FT_Error   error;
-    FT_Memory  memory = loader->memory;
-
-
-    if ( !ALLOC_ARRAY( loader->base.extra_points,
-                       loader->max_points, FT_Vector ) )
-    {
-      loader->use_extra = 1;
-      FT_GlyphLoader _Adjust_Points( loader );
-    }
-    return error;
-  }
-
-
-  /* re-adjust the `current' subglyphs field */
-  static void
-  FT_GlyphLoader _Adjust_Subglyphs( FT_GlyphLoader   loader )
-  {
-    FT_GlyphLoad* base    = &loader->base;
-    FT_GlyphLoad* current = &loader->current;
-
-
-    current->subglyphs = base->subglyphs + base->num_subglyphs;
-  }
-
-
-  /* Ensure that we can add `n_points' and `n_contours' to our glyph. this */
-  /* function reallocates its outline tables if necessary.  Note that it   */
-  /* DOESN'T change the number of points within the loader!                */
-  /*                                                                       */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader _Check_Points( FT_GlyphLoader   loader,
-                               FT_UInt          n_points,
-                               FT_UInt          n_contours )
-  {
-    FT_Memory    memory  = loader->memory;
-    FT_Error     error   = FT_Err_Ok;
-    FT_Outline*  base    = &loader->base.outline;
-    FT_Outline*  current = &loader->current.outline;
-    FT_Bool      adjust  = 1;
-
-    FT_UInt      new_max, old_max;
-
-
-    /* check points & tags */
-    new_max = base->n_points + current->n_points + n_points;
-    old_max = loader->max_points;
-
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 7 ) & -8;
-
-      if ( REALLOC_ARRAY( base->points, old_max, new_max, FT_Vector ) ||
-           REALLOC_ARRAY( base->tags,   old_max, new_max, FT_Byte   ) )
-       goto Exit;
-
-      if ( loader->use_extra &&
-           REALLOC_ARRAY( loader->base.extra_points, old_max,
-                          new_max, FT_Vector ) )
-       goto Exit;
-
-      adjust = 1;
-      loader->max_points = new_max;
-    }
-
-    /* check contours */
-    old_max = loader->max_contours;
-    new_max = base->n_contours + current->n_contours +
-              n_contours;
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 3 ) & -4;
-      if ( REALLOC_ARRAY( base->contours, old_max, new_max, FT_Short ) )
-        goto Exit;
-
-      adjust = 1;
-      loader->max_contours = new_max;
-    }
-
-    if ( adjust )
-      FT_GlyphLoader _Adjust_Points( loader );
-
-  Exit:
-    return error;
-  }
-
-
-  /* Ensure that we can add `n_subglyphs' to our glyph. this function */
-  /* reallocates its subglyphs table if necessary.  Note that it DOES */
-  /* NOT change the number of subglyphs within the loader!            */
-  /*                                                                  */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader _Check_Subglyphs( FT_GlyphLoader   loader,
-                                  FT_UInt          n_subs )
-  {
-    FT_Memory  memory = loader->memory;
-    FT_Error   error  = FT_Err_Ok;
-    FT_UInt    new_max, old_max;
-
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
-    old_max = loader->max_subglyphs;
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 1 ) & -2;
-      if ( REALLOC_ARRAY( base->subglyphs, old_max, new_max, FT_SubGlyph ) )
-        goto Exit;
-
-      loader->max_subglyphs = new_max;
-
-      FT_GlyphLoader _Adjust_Subglyphs( loader );
-    }
-
-  Exit:
-    return error;
-  }
-
-
-  /* prepare loader for the addition of a new glyph on top of the base one */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader _Prepare( FT_GlyphLoader   loader )
-  {
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    current->outline.n_points   = 0;
-    current->outline.n_contours = 0;
-    current->num_subglyphs      = 0;
-
-    FT_GlyphLoader _Adjust_Points   ( loader );
-    FT_GlyphLoader _Adjust_Subglyphs( loader );
-  }
-
-
-  /* add current glyph to the base image - and prepare for another */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader _Add( FT_GlyphLoader   loader )
-  {
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-    FT_UInt        n_curr_contours = current->outline.n_contours;
-    FT_UInt        n_base_points   = base->outline.n_points;
-    FT_UInt        n;
-
-
-    base->outline.n_points =
-      (short)( base->outline.n_points + current->outline.n_points );
-    base->outline.n_contours =
-      (short)( base->outline.n_contours + current->outline.n_contours );
-
-    base->num_subglyphs += current->num_subglyphs;
-
-    /* adjust contours count in newest outline */
-    for ( n = 0; n < n_curr_contours; n++ )
-      current->outline.contours[n] =
-        (short)( current->outline.contours[n] + n_base_points );
-
-    /* prepare for another new glyph image */
-    FT_GlyphLoader _Prepare( loader );
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader _Copy_Points( FT_GlyphLoader   target,
-                              FT_GlyphLoader   source )
-  {
-    FT_Error  error;
-    FT_UInt   num_points   = source->base.outline.n_points;
-    FT_UInt   num_contours = source->base.outline.n_contours;
-
-
-    error = FT_GlyphLoader _Check_Points( target, num_points, num_contours );
-    if ( !error )
-    {
-      FT_Outline*  out = &target->base.outline;
-      FT_Outline*  in  = &source->base.outline;
-
-
-      MEM_Copy( out->points, in->points,
-                num_points * sizeof ( FT_Vector ) );
-      MEM_Copy( out->tags, in->tags,
-                num_points * sizeof ( char ) );
-      MEM_Copy( out->contours, in->contours,
-                num_contours * sizeof ( short ) );
-
-      /* do we need to copy the extra points? */
-      if ( target->use_extra && source->use_extra )
-        MEM_Copy( target->base.extra_points, source->base.extra_points,
-                  num_points * sizeof ( FT_Vector ) );
-
-      out->n_points   = (short)num_points;
-      out->n_contours = (short)num_contours;
-
-      FT_GlyphLoader _Adjust_Points( target );
-    }
-
-    return error;
-  }
-
-
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*****                                                               *****/
-  /*****                                                               *****/
-  /*****                          S T R E A M S                        *****/
-  /*****                                                               *****/
-  /*****                                                               *****/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-
-#undef  FT_COMPONENT
-#define FT_COMPONENT  trace_stream
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    ft_new_input_stream                                                */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Creates a new input stream object from an FT_Open_Args structure.  */
-  /*                                                                       */
-  /* <Note>                                                                */
-  /*    The function expects a valid `astream' parameter.                  */
-  /*                                                                       */
-  FT_EXPORT_DEF( FT_Error )
-  FT_Stream_Open( FT_Library     library,
-                  FT_Open_Args*  args,
-                  FT_Stream*     astream )
-  {
-    FT_Error   error;
-    FT_Memory  memory;
-    FT_Stream  stream;
-
-
-    if ( !library )
-      return FT_Err_Invalid_Library_Handle;
-
-    if ( !args )
-      return FT_Err_Invalid_Argument;
-
-    *astream = 0;
-    memory   = library->memory;
-    if ( ALLOC( stream, sizeof ( *stream ) ) )
-      goto Exit;
-
-    stream->memory = memory;
-
-    /* now, look at the stream flags */
-    if ( args->flags & ft_open_memory )
-    {
-      error = 0;
-      FT_New_Memory_Stream( library,
-                            (FT_Byte*)args->memory_base,
-                            args->memory_size,
-                            stream );
-    }
-    else if ( args->flags & ft_open_pathname )
-    {
-      error = FT_Stream_New( args->pathname, stream );
-      stream->pathname.pointer = args->pathname;
-    }
-    else if ( ( args->flags & ft_open_stream ) && args->stream )
-    {
-      /* in this case, we do not need to allocate a new stream object */
-      /* since the caller is responsible for closing it himself       */
-      FREE( stream );
-      stream = args->stream;
-    }
-    else
-      error = FT_Err_Invalid_Argument;
-
-    if ( error )
-      FREE( stream );
-
-    *astream = stream;
-
-  Exit:
-    return error;
-  }
-
-
-  /* documentation is in ftobjs.h */
-
-  FT_EXPORT_DEF( void )
-  FT_Stream_Done( FT_Stream  stream )
-  {
-    if ( stream && stream->close )
-    {
-      stream->close( stream );
-      stream->close = 0;
-    }
-  }
-
-
-  static void
-  ft_done_stream( FT_Stream*  astream,
-                  FT_Int      external )
-  {
-    FT_Stream  stream = *astream;
-
-
-    if ( stream->close )
-      stream->close( stream );
-
-    if ( !external )
-    {
-      FT_Memory  memory = stream->memory;
-
-
-      FREE( stream );
-    }
-    *astream = 0;
-  }
-
diff --git a/src/base/rules.mk b/src/base/rules.mk
index 2da51b318..0fe18817d 100644
--- a/src/base/rules.mk
+++ b/src/base/rules.mk
@@ -34,11 +34,11 @@ BASE_COMPILE := $(FT_COMPILE) $I$(SRC_)base
 #
 BASE_SRC := $(BASE_)ftcalc.c   \
             $(BASE_)fttrigon.c \
-            $(BASE_)ftgloadr.c \
-            $(BASE_)ftlist.c   \
-            $(BASE_)ftobjs.c   \
+            $(BASE_)ftutil.c   \
             $(BASE_)ftstream.c \
+            $(BASE_)ftgloadr.c \
             $(BASE_)ftoutln.c  \
+            $(BASE_)ftobjs.c   \
             $(BASE_)ftnames.c  \
             $(BASE_)ftdbgmem.c