freetype2/src/base/ftobjs.c

/***************************************************************************/
/*                                                                         */
/*  ftobjs.c                                                               */
/*                                                                         */
/*  The FreeType private base classes (base).                              */
/*                                                                         */
/*  Copyright 1996-2000 by                                                 */
/*  David Turner, Robert Wilhelm, and Werner Lemberg                       */
/*                                                                         */
/*  This file is part of the FreeType project, and may only be used        */
/*  modified and distributed under the terms of the FreeType project       */
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/***************************************************************************/

#include <freetype/internal/ftobjs.h>
#include <freetype/internal/ftlist.h>
#include <freetype/internal/ftdebug.h>
#include <freetype/internal/ftstream.h>

#include <freetype/tttables.h>

  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/
  /****                                                                 ****/
  /****                                                                 ****/
  /****                           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


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Alloc                                                           */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Allocates a new block of memory.  The returned area is always      */
  /*    zero-filled; this is a strong convention in many FreeType parts.   */
  /*                                                                       */
  /* <Input>                                                               */
  /*    memory :: A handle to a given `memory object' where allocation     */
  /*              occurs.                                                  */
  /*                                                                       */
  /*    size   :: The size in bytes of the block to allocate.              */
  /*                                                                       */
  /* <Output>                                                              */
  /*    P      :: A pointer to the fresh new block.  It should be set to   */
  /*              NULL if `size' is 0, or in case of error.                */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  BASE_FUNC(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_TRACE2(( "FT_Alloc:" ));
    FT_TRACE2(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
                size, *P, P ));

    return FT_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Realloc                                                         */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Reallocates a block of memory pointed to by `*P' to `Size' bytes   */
  /*    from the heap, possibly changing `*P'.                             */
  /*                                                                       */
  /* <Input>                                                               */
  /*    memory  :: A handle to a given `memory object' where allocation    */
  /*               occurs.                                                 */
  /*                                                                       */
  /*    current :: The current block size in bytes.                        */
  /*    size    :: The new block size in bytes.                            */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    P       :: A pointer to the fresh new block.  It should be set to  */
  /*               NULL if `size' is 0, or in case of error.               */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    All callers of FT_Realloc() _must_ provide the current block size  */
  /*    as well as the new one.                                            */
  /*                                                                       */
  /*    If the memory object's flag FT_SYSTEM_FLAG_NO_REALLOC is set, this */
  /*    function will try to emulate a reallocation using FT_Alloc() and   */
  /*    FT_Free().  Otherwise, it will call the system-specific `realloc'  */
  /*    implementation.                                                    */
  /*                                                                       */
  /*    (Some embedded systems do not have a working realloc function).    */
  /*                                                                       */
  BASE_FUNC(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;

    *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;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Free                                                            */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Releases a given block of memory allocated through FT_Alloc().     */
  /*                                                                       */
  /* <Input>                                                               */
  /*    memory :: A handle to a given `memory object' where allocation     */
  /*              occurred.                                                */
  /*                                                                       */
  /*    P      :: This is the _address_ of a _pointer_ which points to the */
  /*              allocated block.  It is always set to NULL on exit.      */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    If P or *P are NULL, this function should return successfully.     */
  /*    This is a strong convention within all of FreeType and its         */
  /*    drivers.                                                           */
  /*                                                                       */
  BASE_FUNC(void)  FT_Free( FT_Memory  memory,
                            void**     P )
  {
    FT_TRACE2(( "FT_Free:" ));
    FT_TRACE2(( " Freeing block 0x%08p, ref 0x%08p\n",
                P, (P ? *P : (void*)0) ));

    FT_Assert( P != 0 );

    if ( *P )
    {
      memory->free( memory, *P );
      *P = 0;
    }
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    ft_new_input_stream                                                */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Creates a new input stream object from an FT_Open_Args structure.  */
  /*                                                                       */
  static
  FT_Error  ft_new_input_stream( FT_Library     library,
                                 FT_Open_Args*  args,
                                 FT_Stream     *astream )
  {
    FT_Error   error;
    FT_Memory  memory;
    FT_Stream  stream;

    *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,
                            args->memory_base,
                            args->memory_size,
                            stream );
    }
    else if (args->flags & ft_open_pathname)
    {
      error = FT_New_Stream( args->pathname, stream );
      stream->pathname.pointer = args->pathname;
    }
    else if (args->flags & ft_open_stream && args->stream)
    {
      *stream        = *(args->stream);
      stream->memory = memory;
    }
    else
    {
      error = FT_Err_Invalid_Argument;
    }

    if ( error )
      FREE( stream );

    *astream = stream;
  Exit:
    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Done_Stream                                                     */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Closes and destroys a stream object.                               */
  /*                                                                       */
  FT_EXPORT_FUNC(void)  FT_Done_Stream( FT_Stream  stream )
  {
    if ( stream->close )
      stream->close( stream );
  }


  static
  void  ft_done_stream( FT_Stream*  astream )
  {
    FT_Stream  stream = *astream;
    FT_Memory  memory = stream->memory;

    if ( stream->close )
      stream->close( stream );

    FREE( stream );
    *astream = 0;
  }

  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/
  /****                                                                 ****/
  /****                                                                 ****/
  /****               O B J E C T   M A N A G E M E N T                 ****/
  /****                                                                 ****/
  /****                                                                 ****/
  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/

  /* destructor for sizes list */
  static
  void  destroy_size( FT_Memory  memory,
                      FT_Size    size,
                      FT_Driver  driver )
  {
    /* finalize format-specific stuff */
    driver->interface.done_size( size );
    FREE( size );
  }


  /* destructor for faces list */
  static
  void  destroy_face( FT_Memory  memory,
                      FT_Face    face,
                      FT_Driver  driver )
  {
    /* Discard glyph slots for this face                                */
    /* XXX: Beware!  FT_Done_GlyphSlot() changes the field `face->slot' */
    while ( face->glyph )
      FT_Done_GlyphSlot( face->glyph );

    /* Discard all sizes for this face */
    FT_List_Finalize( &face->sizes_list,
                     (FT_List_Destructor)destroy_size,
                     memory,
                     driver );
    face->size = 0;

    /* finalize format-specific stuff */
    driver->interface.done_face( face );

    /* Now discard client data */
    if ( face->generic.finalizer )
      face->generic.finalizer( face );

    /* close the stream for this face */
    ft_done_stream( &face->stream );

    /* get rid of it */
    FREE( face );
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    Destroy_Driver                                                     */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Destroys a given driver object.  This also destroys all child      */
  /*    faces.                                                             */
  /*                                                                       */
  /* <InOut>                                                               */
  /*     driver :: A handle to the target driver object.                   */
  /*                                                                       */
  /* <Note>                                                                */
  /*     The driver _must_ be LOCKED!                                      */
  /*                                                                       */
  static
  void  Destroy_Driver( FT_Driver  driver )
  {
    FT_Memory  memory = driver->memory;


    /* now, finalize all faces in the driver list */
    FT_List_Finalize( &driver->faces_list,
                      (FT_List_Destructor)destroy_face,
                      memory,
                      driver );

    /* finalize the driver object */
    if ( driver->interface.done_driver )
      driver->interface.done_driver( driver );

    /* finalize client-data */
    if ( driver->generic.finalizer )
      driver->generic.finalizer( driver );

    /* discard it */
    FREE( driver );
  }


 /*************************************************************************
  *
  * <Function>
  *   FT_Get_Raster
  *
  * <Description>
  *   Return a pointer to the raster corresponding to a given glyph
  *   format tag.
  *
  * <Input>
  *   library      :: handle to source library object
  *   glyph_format :: glyph format tag
  *
  * <Output>
  *   raster_funcs :: if this field is not 0, returns the raster's interface
  *
  * <Return>
  *   a pointer to the corresponding raster object.
  *
  *************************************************************************/

  FT_EXPORT_FUNC(FT_Raster)  FT_Get_Raster( FT_Library        library,
                                            FT_Glyph_Format   glyph_format,
                                            FT_Raster_Funcs  *raster_funcs )
  {
    FT_Int  n;

    for ( n = 0; n < FT_MAX_GLYPH_FORMATS; n++ )
    {
      FT_Raster_Funcs*  funcs = &library->raster_funcs[n];
      if (funcs->glyph_format == glyph_format)
      {
        if (raster_funcs)
          *raster_funcs = *funcs;
        return library->rasters[n];
      }
    }
    return 0;
  }

  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Set_Raster                                                      */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Register a given raster to the library.                            */
  /*                                                                       */
  /* <Input>                                                               */
  /*    library      :: A handle to a target library object.               */
  /*    raster_funcs :: pointer to the raster's interface                  */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  /* <Note>                                                                */
  /*    This function will do the following:                               */
  /*                                                                       */
  /*    - a new raster object is created through raster_func.raster_new    */
  /*      if this fails, then the function returns                         */
  /*                                                                       */
  /*    - if a raster is already registered for the glyph format           */
  /*      specified in raster_funcs, it will be destroyed                  */
  /*                                                                       */
  /*    - the new raster is registered for the glyph format                */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Set_Raster( FT_Library        library,
                                           FT_Raster_Funcs*  raster_funcs )
  {
    FT_Glyph_Format  glyph_format = raster_funcs->glyph_format;
    FT_Raster_Funcs* funcs;
    FT_Raster        raster;
    FT_Error         error;
    FT_Int           n, index;

    if ( glyph_format == ft_glyph_format_none)
      return FT_Err_Invalid_Argument;

    /* create a new raster object */
    error = raster_funcs->raster_new( library->memory, &raster );
    if (error) goto Exit;

    raster_funcs->raster_reset( raster,
                                library->raster_pool,
                                library->raster_pool_size );

    index = -1;
    for (n = 0; n < FT_MAX_GLYPH_FORMATS; n++)
    {
      FT_Raster_Funcs*  funcs = library->raster_funcs + n;

      /* record the first vacant entry in "index" */
      if (index < 0 && funcs->glyph_format == ft_glyph_format_none)
        index = n;

      /* compare this entry's glyph format with the one we need */
      if (funcs->glyph_format == glyph_format)
      {
        /* a raster already exists for this glyph format, we will */
        /* destroy it before updating its entry in the table      */
        funcs->raster_done( library->rasters[n] );
        index = n;
        break;
      }
    }

    if (index < 0)
    {
      /* the table is full and has no vacant entries */
      error = FT_Err_Too_Many_Glyph_Formats;
      goto Fail;
    }

    funcs  = library->raster_funcs + index;
    *funcs = *raster_funcs;
    library->rasters[index] = raster;

  Exit:
    return error;

  Fail:
    raster_funcs->raster_done( raster );
    goto Exit;
  }

  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Unset_Raster                                                    */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Removes a given raster from the library.                           */
  /*                                                                       */
  /* <Input>                                                               */
  /*    library      :: A handle to a target library object.               */
  /*    raster_funcs :: pointer to the raster's interface                  */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  FT_EXPORT_DEF(FT_Error)  FT_Unset_Raster( FT_Library        library,
                                            FT_Raster_Funcs*  raster_funcs )
  {
    FT_Glyph_Format  glyph_format = raster_funcs->glyph_format;
    FT_Error         error;
    FT_Int           n;

    error = FT_Err_Invalid_Argument;
    if ( glyph_format == ft_glyph_format_none)
      goto Exit;

    for (n = 0; n < FT_MAX_GLYPH_FORMATS; n++)
    {
      FT_Raster_Funcs*  funcs = library->raster_funcs + n;

      if (funcs->glyph_format == glyph_format)
      {
        funcs->raster_done( library->rasters[n] );
        library->rasters[n]                   = 0;
        library->raster_funcs[n].glyph_format = ft_glyph_format_none;
        error = FT_Err_Ok;
        break;
      }
    }

  Exit:
    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Set_Raster_Mode                                                 */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Set a raster-specific mode.                                        */
  /*                                                                       */
  /* <Input>                                                               */
  /*    library :: A handle to a target library object.                    */
  /*    format  :: the glyph format used to select the raster              */
  /*    mode    :: the raster-specific mode descriptor                     */
  /*    args    :: the mode arguments                                      */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Set_Raster_Mode( FT_Library      library,
                                                FT_Glyph_Format format,
                                                unsigned long   mode,
                                                void*           args )
  {
    FT_Raster_Funcs  funcs;
    FT_Raster        raster;

    raster = FT_Get_Raster( library, format, &funcs );
    if (raster && funcs.raster_set_mode )
      return funcs.raster_set_mode( raster, mode, args );
    else
      return FT_Err_Invalid_Argument;
  }

  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Set_Debug_Hook                                                  */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Sets a debug hook function for debugging the interpreter of a      */
  /*    font format.                                                       */
  /*                                                                       */
  /* <Input>                                                               */
  /*    library    :: A handle to the library object.                      */
  /*    hook_index :: The index of the debug hook.  You should use the     */
  /*                  values defined in ftobjs.h, e.g.                     */
  /*                  FT_DEBUG_HOOK_TRUETYPE                               */
  /*    debug_hook :: The function used to debug the interpreter.          */
  /*                                                                       */
  /* <Note>                                                                */
  /*    Currently, four debug hook slots are available, but only two (for  */
  /*    the TrueType and the Type 1 interpreter) are defined.              */
  /*                                                                       */
  FT_EXPORT_FUNC(void)  FT_Set_Debug_Hook( FT_Library         library,
                                        FT_UInt            hook_index,
                                        FT_DebugHook_Func  debug_hook )
  {
    if ( hook_index < ( sizeof ( library->debug_hooks ) / sizeof ( void* ) ) )
      library->debug_hooks[hook_index] = debug_hook;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_New_Library                                                     */
  /*                                                                       */
  /* <Description>                                                         */
  /*    This function is used to create a new FreeType library instance    */
  /*    from a given memory object.  It is thus possible to use libraries  */
  /*    with distinct memory allocators within the same program.           */
  /*                                                                       */
  /* <Input>                                                               */
  /*    memory   :: A handle to the original memory object.                */
  /*                                                                       */
  /* <Output>                                                              */
  /*    alibrary :: A pointer to handle of a new library object.           */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_New_Library( FT_Memory    memory,
                                            FT_Library*  alibrary )
  {
    FT_Library library = 0;
    FT_Error   error;

    /* first of all, allocate the library object */
    if ( ALLOC( library, sizeof ( *library ) ) )
      return error;

    library->memory = memory;

    /* allocate the render pool */
    library->raster_pool_size = FT_RENDER_POOL_SIZE;
    if ( ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) )
      goto Fail;

    /* now register the default raster for the `outline' glyph image format */
    /* for now, ignore the error...                                         */
    error = FT_Set_Raster( library, &ft_default_raster );


    /* That's ok now */
    *alibrary = library;

    return FT_Err_Ok;
  Fail:
    FREE( library );
    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Done_Library                                                    */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Discards a given library object.  This closes all drivers and      */
  /*    discards all resource objects.                                     */
  /*                                                                       */
  /* <Input>                                                               */
  /*    library :: A handle to the target library                          */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Done_Library( FT_Library  library )
  {
    FT_Memory  memory;
    FT_Int     n;


    if ( !library )
      return FT_Err_Invalid_Library_Handle;

    memory = library->memory;

    /* Discard client-data */
    if ( library->generic.finalizer )
      library->generic.finalizer( library );

    /* Close all drivers in the library */
    for ( n = 0; n < library->num_drivers; n++ )
    {
      FT_Driver  driver = library->drivers[n];


      if ( driver )
      {
        Destroy_Driver( driver );
        library->drivers[n] = 0;
      }
    }

    /* Destroy raster objects */
    FREE( library->raster_pool );
    library->raster_pool_size = 0;

    {
      FT_Raster_Funcs*  cur   = library->raster_funcs;
      FT_Raster_Funcs*  limit = cur + FT_MAX_GLYPH_FORMATS;
      FT_Raster*        raster = library->rasters;

      for ( ; cur < limit; cur++, raster++ )
      {
        if ( cur->glyph_format != ft_glyph_format_none )
        {
          cur->raster_done( *raster );
          *raster = 0;
          cur->glyph_format = ft_glyph_format_none;
        }
      }
    }

    FREE( library );

    return FT_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Add_Driver                                                      */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Registers a new driver in a given library object.  This function   */
  /*    takes only a pointer to a driver interface; it uses it to create   */
  /*    the new driver, then sets up some important fields.                */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    library          :: A handle to the target library object.         */
  /*                                                                       */
  /* <Input>                                                               */
  /*    driver_interface :: A pointer to a driver interface table.         */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    This function doesn't check whether the driver is already          */
  /*    installed!                                                         */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Add_Driver( FT_Library                 library,
                                           const FT_DriverInterface*  driver_interface )
  {
    FT_Error   error;
    FT_Driver  driver;
    FT_Memory  memory;


    if ( !library || !driver_interface )
      return FT_Err_Invalid_Library_Handle;

    memory = library->memory;
    error  = FT_Err_Ok;

    if ( library->num_drivers >= FT_MAX_DRIVERS )
      error = FT_Err_Too_Many_Drivers;
    else
    {
      if ( ALLOC( driver, driver_interface->driver_object_size ) )
        goto Exit;

      driver->library   = library;
      driver->memory    = memory;
      driver->interface = *driver_interface;

      if ( driver_interface->init_driver )
      {
        error = driver_interface->init_driver( driver );
        if ( error )
          goto Fail;
      }

      library->drivers[library->num_drivers++] = driver;
      goto Exit;

    Fail:
      FREE( driver );
    }

  Exit:
    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Remove_Driver                                                   */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Unregisters a given driver.  This closes the driver, which in turn */
  /*    destroys all faces, sizes, slots, etc. associated with it.         */
  /*                                                                       */
  /*    This function also DESTROYS the driver object.                     */
  /*                                                                       */
  /* <Input>                                                               */
  /*    driver :: A handle to target driver object.                        */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Remove_Driver( FT_Driver  driver )
  {
    FT_Library  library;
    FT_Memory   memory;
    FT_Driver   *cur, *last;
    FT_Error    error;


    if ( !driver )
      return FT_Err_Invalid_Driver_Handle;

    library = driver->library;
    memory  = driver->memory;

    if ( !library || !memory )
      return FT_Err_Invalid_Driver_Handle;

    /* look-up driver entry in library table */
    error = FT_Err_Invalid_Driver_Handle;
    cur   = library->drivers;
    last  = cur + library->num_drivers - 1;

    for ( ; cur <= last; cur++ )
    {
      if ( *cur == driver )
      {
        /* destroy the driver object */
        Destroy_Driver( driver );

        /* now move the last driver in the table to the vacant slot */
        if ( cur < last )
        {
          *cur  = *last;
          *last = 0;
        }
        library->num_drivers--;

        /* exit loop */
        error = FT_Err_Ok;
        break;
      }
    }

    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Get_Driver                                                      */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Returns the handle of the driver responsible for a given format    */
  /*    (or service) according to its `name'.                              */
  /*                                                                       */
  /* <Input>                                                               */
  /*    library     :: A handle to the library object.                     */
  /*    driver_name :: The name of the driver to look up.                  */
  /*                                                                       */
  /* <Return>                                                              */
  /*    A handle to the driver object, 0 otherwise.                        */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Driver)  FT_Get_Driver( FT_Library  library,
                                            char*       driver_name )
  {
    FT_Driver  *cur, *limit;


    if ( !library || !driver_name )
      return 0;

    cur   = library->drivers;
    limit = cur + library->num_drivers;
    for ( ; cur < limit; cur++ )
    {
      if ( strcmp( (*cur)->interface.driver_name, driver_name ) == 0 )
        return *cur;
    }
    return 0;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    open_face                                                          */
  /*                                                                       */
  /* <Description>                                                         */
  /*    This function does some work for FT_Open_Face().                   */
  /*                                                                       */
  static
  FT_Error  open_face( FT_Driver      driver,
                       FT_Stream      stream,
                       FT_Long        face_index,
                       FT_Int         num_params,
                       FT_Parameter*  params,
                       FT_Face*       aface )
  {
    FT_Memory            memory;
    FT_DriverInterface*  interface;
    FT_Face              face = 0;
    FT_Error             error;


    interface = &driver->interface;
    memory    = driver->memory;

    /* allocate the face object, and perform basic initialization */
    if ( ALLOC( face, interface->face_object_size ) )
      goto Fail;

    face->driver = driver;
    face->memory = memory;
    face->stream = stream;

    error = interface->init_face( stream, face, face_index, num_params, params );
    if ( error )
      goto Fail;

    *aface = face;

  Fail:
    if ( error )
    {
      interface->done_face( face );
      FREE( face );
      *aface = 0;
    }

    return error;
  }



  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_New_Face                                                        */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Creates a new face object from a given resource and typeface index */
  /*    using a pathname to the font file.                                 */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    library    :: A handle to the library resource.                    */
  /*                                                                       */
  /* <Input>                                                               */
  /*    pathname   :: A path to the font file.                             */
  /*    face_index :: The index of the face within the resource.  The      */
  /*                  first face has index 0.                              */
  /* <Output>                                                              */
  /*    face       :: A handle to a new face object.                       */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    Unlike FreeType 1.x, this function automatically creates a glyph   */
  /*    slot for the face object which can be accessed directly through    */
  /*    `face->glyph'.                                                     */
  /*                                                                       */
  /*    Note that additional slots can be added to each face with the      */
  /*    FT_New_GlyphSlot() API function.  Slots are linked in a single     */
  /*    list through their `next' field.                                   */
  /*                                                                       */
  /*    FT_New_Face() can be used to determine and/or check the font       */
  /*    format of a given font resource.  If the `face_index' field is     */
  /*    negative, the function will _not_ return any face handle in        */
  /*    `*face'.  Its return value should be 0 if the resource is          */
  /*    recognized, or non-zero if not.                                    */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_New_Face( FT_Library   library,
                                         const char*  pathname,
                                         FT_Long      face_index,
                                         FT_Face*     aface )
  {
    FT_Open_Args  args;

    args.flags    = ft_open_pathname;
    args.pathname = (char*)pathname;
    return FT_Open_Face( library, &args, face_index, aface );
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_New_Memory_Face                                                 */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Creates a new face object from a given resource and typeface index */
  /*    using a font file already loaded into memory.                      */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    library    :: A handle to the library resource.                    */
  /*                                                                       */
  /* <Input>                                                               */
  /*    file_base  :: A pointer to the beginning of the font data.         */
  /*    file_size  :: The size of the memory chunk used by the font data.  */
  /*    face_index :: The index of the face within the resource.  The      */
  /*                  first face has index 0.                              */
  /* <Output>                                                              */
  /*    face       :: A handle to a new face object.                       */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    Unlike FreeType 1.x, this function automatically creates a glyph   */
  /*    slot for the face object which can be accessed directly through    */
  /*    `face->glyph'.                                                     */
  /*                                                                       */
  /*    Note that additional slots can be added to each face with the      */
  /*    FT_New_GlyphSlot() API function.  Slots are linked in a single     */
  /*    list through their `next' field.                                   */
  /*                                                                       */
  /*    FT_New_Memory_Face() can be used to determine and/or check the     */
  /*    font format of a given font resource.  If the `face_index' field   */
  /*    is negative, the function will _not_ return any face handle in     */
  /*    `*face'.  Its return value should be 0 if the resource is          */
  /*    recognized, or non-zero if not.                                    */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_New_Memory_Face( FT_Library   library,
                                                void*        file_base,
                                                FT_Long      file_size,
                                                FT_Long      face_index,
                                                FT_Face*     face )
  {
    FT_Open_Args  args;

    args.flags       = ft_open_memory;
    args.memory_base = file_base;
    args.memory_size = file_size;
    return FT_Open_Face( library, &args, face_index, face );
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Open_Face                                                       */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Opens a face object from a given resource and typeface index using */
  /*    an `FT_Open_Args' structure.  If the face object doesn't exist, it */
  /*    will be created.                                                   */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    library    :: A handle to the library resource.                    */
  /*                                                                       */
  /* <Input>                                                               */
  /*    args       :: A pointer to an `FT_Open_Args' structure which must  */
  /*                  be filled by the caller.                             */
  /*    face_index :: The index of the face within the resource.  The      */
  /*                  first face has index 0.                              */
  /* <Output>                                                              */
  /*    face       :: A handle to a new face object.                       */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    Unlike FreeType 1.x, this function automatically creates a glyph   */
  /*    slot for the face object which can be accessed directly through    */
  /*    `face->glyph'.                                                     */
  /*                                                                       */
  /*    Note that additional slots can be added to each face with the      */
  /*    FT_New_GlyphSlot() API function.  Slots are linked in a single     */
  /*    list through their `next' field.                                   */
  /*                                                                       */
  /*    FT_Open_Face() can be used to determine and/or check the font      */
  /*    format of a given font resource.  If the `face_index' field is     */
  /*    negative, the function will _not_ return any face handle in        */
  /*    `*face'.  Its return value should be 0 if the resource is          */
  /*    recognized, or non-zero if not.                                    */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Open_Face( FT_Library     library,
                                          FT_Open_Args*  args,
                                          FT_Long        face_index,
                                          FT_Face*       aface )
  {
    FT_Error     error;
    FT_Driver    driver;
    FT_Memory    memory;
    FT_Stream    stream;
    FT_Face      face = 0;
    FT_ListNode  node = 0;


    *aface = 0;

    if ( !library )
      return FT_Err_Invalid_Handle;

    /* create input stream */
    error = ft_new_input_stream( library, args, &stream );
    if ( error ) goto Exit;

    memory = library->memory;

    /* if the font driver is specified in the `args' structure, use */
    /* it.  Otherwise, we'll scan the list of registered drivers.   */
    if ( args->flags & ft_open_driver && args->driver )
    {
      driver = args->driver;
      /* not all drivers directly support face objects, so check... */
      if ( driver->interface.face_object_size )
      {
        FT_Int         num_params = 0;
        FT_Parameter*  params     = 0;

        if ( args->flags & ft_open_params )
        {
          num_params = args->num_params;
          params     = args->params;
        }

        error = open_face( driver, stream, face_index,
                           num_params, params, &face );
        if ( !error )
          goto Success;
      }
      else
        error = FT_Err_Invalid_Handle;

      goto Fail;
    }
    else
    {
      /* check each font driver for an appropriate format */
      FT_Driver*  cur   = library->drivers;
      FT_Driver*  limit = cur + library->num_drivers;

      for ( ; cur < limit; cur++ )
      {
        driver = *cur;
        /* not all drivers directly support face objects, so check... */
        if ( driver->interface.face_object_size )
        {
          FT_Int         num_params = 0;
          FT_Parameter*  params     = 0;

          if ( args->flags & ft_open_params )
          {
            num_params = args->num_params;
            params     = args->params;
          }

          error = open_face( driver, stream, face_index,
                             num_params, params, &face );
          if ( !error )
            goto Success;

          if ( error != FT_Err_Unknown_File_Format )
            goto Fail;
        }
      }

      /* no driver is able to handle this format */
      error = FT_Err_Unknown_File_Format;
      goto Fail;
    }

  Success:
    FT_TRACE4(( "FT_New_Face: New face object, adding to list\n" ));

    /* add the face object to its driver's list */
    if ( ALLOC( node, sizeof ( *node ) ) )
      goto Fail;

    node->data = face;
    /* don't assume driver is the same as face->driver, so use
       face->driver instead. (JvR 3/5/2000) */
    FT_List_Add( &face->driver->faces_list, node );

    /* now allocate a glyph slot object for the face */
    {
      FT_GlyphSlot  slot;


      FT_TRACE4(( "FT_Open_Face: Creating glyph slot\n" ));
      error = FT_New_GlyphSlot( face, &slot );
      if ( error )
        goto Fail;
    }

    /* finally allocate a size object for the face */
    {
      FT_Size  size;


      FT_TRACE4(( "FT_Open_Face: Creating size object\n" ));
      error = FT_New_Size( face, &size );
      if ( error )
        goto Fail;
    }

    /* initialize transform for convenience functions */
    face->transform_matrix.xx = 0x10000L;
    face->transform_matrix.xy = 0;
    face->transform_matrix.yx = 0;
    face->transform_matrix.yy = 0x10000L;

    face->transform_delta.x = 0;
    face->transform_delta.y = 0;

    *aface = face;
    goto Exit;

  Fail:
    FT_Done_Face( face );

  Exit:
    FT_TRACE4(( "FT_Open_Face: Return %d\n", error ));
    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Attach_File                                                     */
  /*                                                                       */
  /* <Description>                                                         */
  /*    `Attaches' a given font file to an existing face.  This is usually */
  /*    to read additional information for a single face object.  For      */
  /*    example, it is used to read the AFM files that come with Type 1    */
  /*    fonts in order to add kerning data and other metrics.              */
  /*                                                                       */
  /* <InOut>                                                               */
  /*    face         :: The target face object.                            */
  /*                                                                       */
  /* <Input>                                                               */
  /*    filepathname :: An 8-bit pathname naming the `metrics' file.       */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    If your font file is in memory, or if you want to provide your     */
  /*    own input stream object, use FT_Attach_Stream().                   */
  /*                                                                       */
  /*    The meaning of the `attach' action (i.e., what really happens when */
  /*    the new file is read) is not fixed by FreeType itself.  It really  */
  /*    depends on the font format (and thus the font driver).             */
  /*                                                                       */
  /*    Client applications are expected to know what they are doing       */
  /*    when invoking this function. Most  drivers simply do not implement */
  /*    file attachments.                                                  */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Attach_File( FT_Face      face,
                                            const char*  filepathname )
  {
    FT_Open_Args  open;

    open.flags    = ft_open_pathname;
    open.pathname = (char*)filepathname;
    return FT_Attach_Stream( face, &open );
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Attach_Stream                                                   */
  /*                                                                       */
  /* <Description>                                                         */
  /*    This function is similar to FT_Attach_File with the exception      */
  /*    that it reads the attachment from an arbitrary stream.             */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face :: target face object                                         */
  /*                                                                       */
  /*    args :: a pointer to an FT_Open_Args structure used to describe    */
  /*            the input stream to FreeType                               */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  /*    The meaning of the "attach" (i.e. what really happens when the     */
  /*    new file is read) is not fixed by FreeType itself. It really       */
  /*    depends on the font format (and thus the font driver).             */
  /*                                                                       */
  /*    Client applications are expected to know what they're doing        */
  /*    when invoking this function. Most drivers simply do not implement  */
  /*    file attachments..                                                 */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Attach_Stream( FT_Face       face,
                                              FT_Open_Args* parameters )
  {
    FT_Stream  stream;
    FT_Error   error;
    FT_Driver  driver;

    FTDriver_getInterface  get_interface;

    if ( !face || !face->driver )
      return FT_Err_Invalid_Handle;

    driver = face->driver;
    error = ft_new_input_stream( driver->library, parameters, &stream );
    if (error) goto Exit;

    /* we implement FT_Attach_Stream in each driver through the */
    /* "attach_file" interface..                                */
    error = FT_Err_Unimplemented_Feature;

    get_interface = driver->interface.get_interface;
    if (get_interface)
    {
      FT_Attach_Reader  reader;

      reader = (FT_Attach_Reader)(get_interface( driver, "attach_file" ));
      if (reader)
        error = reader( face, stream );
    }

    /* close the attached stream */
    ft_done_stream( &stream );

  Exit:
    return error;
  }



  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Done_Face                                                       */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Discards a given face object, as well as all of its child slots    */
  /*    and sizes.                                                         */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face :: A handle to a target face object.                          */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Done_Face( FT_Face  face )
  {
    FT_Error             error;
    FT_Driver            driver;
    FT_Memory            memory;
    FT_DriverInterface*  interface;
    FT_ListNode          node;


    if (!face || !face->driver )
      return FT_Err_Invalid_Face_Handle;

    driver    = face->driver;
    interface = &driver->interface;
    memory    = driver->memory;

    /* find face in driver's list */
    node = FT_List_Find( &driver->faces_list, face );
    if ( node )
    {
      /* remove face object from the driver's list */
      FT_List_Remove( &driver->faces_list, node );
      FREE( node );

      /* now destroy the object proper */
      destroy_face( memory, face, driver );
      error = FT_Err_Ok;
    }
    else
      error = FT_Err_Invalid_Face_Handle;

    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_New_Size                                                        */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Creates a new size object from a given face object.                */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face :: A handle to a parent face object.                          */
  /*                                                                       */
  /* <Output>                                                              */
  /*    size :: A handle to a new size object.                             */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_New_Size( FT_Face   face,
                                         FT_Size*  asize )
  {
    FT_Error             error;
    FT_Memory            memory;
    FT_Driver            driver;
    FT_DriverInterface*  interface;

    FT_Size              size = 0;
    FT_ListNode          node = 0;


    if ( !face || !face->driver )
      return FT_Err_Invalid_Face_Handle;

    *asize    = 0;
    driver    = face->driver;
    interface = &driver->interface;
    memory    = face->memory;

    /* Allocate new size object and perform basic initialisation */
    if ( ALLOC( size, interface->size_object_size ) ||
         ALLOC( node, sizeof ( FT_ListNodeRec )   ) )
      goto Exit;

    size->face = face;

    error = interface->init_size( size );

    /* in case of success, add to the face's list */
    if ( !error )
    {
      *asize     = size;
      node->data = size;
      FT_List_Add( &face->sizes_list, node );

      /* record as current size for the face */
      face->size = size;
    }

  Exit:
    if ( error )
    {
      FREE( node );
      FREE( size );
    }

    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Done_Size                                                       */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Discards a given size object.                                      */
  /*                                                                       */
  /* <Input>                                                               */
  /*    size :: A handle to a target size object                           */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Done_Size( FT_Size  size )
  {
    FT_Error     error;
    FT_Driver    driver;
    FT_Memory    memory;
    FT_Face      face;
    FT_ListNode  node;


    if ( !size || !size->face )
      return FT_Err_Invalid_Size_Handle;

    driver = size->face->driver;
    if ( !driver )
      return FT_Err_Invalid_Driver_Handle;

    memory = driver->memory;

    error = FT_Err_Ok;
    face  = size->face;
    node  = FT_List_Find( &face->sizes_list, size );
    if ( node )
    {
      FT_List_Remove( &face->sizes_list, node );
      FREE( node );

      if (face->size == size)
      {
        face->size = 0;
        if (face->sizes_list.head)
          face->size = (FT_Size)(face->sizes_list.head->data);
      }

      destroy_size( memory, size, driver );
    }
    else
      error = FT_Err_Invalid_Size_Handle;

    return FT_Err_Ok;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Set_Char_Size                                                   */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Sets the character dimensions of a given size object.  The         */
  /*    `char_size' value is used for the width and height, expressed in   */
  /*    26.6 fractional points.  1 point = 1/72 inch.                      */
  /*                                                                       */
  /* <Input>                                                               */
  /*    size      :: A handle to a target size object.                     */
  /*    char_size :: The character size, in 26.6 fractional points.        */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  /* <Note>                                                                */
  /*    When dealing with fixed-size faces (i.e., non-scalable formats),   */
  /*    use the function FT_Set_Pixel_Sizes().                             */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Set_Char_Size( FT_Face     face,
                                              FT_F26Dot6  char_width,
                                              FT_F26Dot6  char_height,
                                              FT_UInt     horz_resolution,
                                              FT_UInt     vert_resolution )
  {
    FT_Error             error;
    FT_Driver            driver;
    FT_Memory            memory;
    FT_DriverInterface*  interface;
    FT_Size_Metrics*     metrics = &face->size->metrics;
    FT_Long              dim_x, dim_y;

    if ( !face || !face->size || !face->driver)
      return FT_Err_Invalid_Face_Handle;

    if (!char_width)
      char_width = char_height;

    else if (!char_height)
      char_height = char_width;

    if (!horz_resolution)
      horz_resolution = 72;

    if (!vert_resolution)
      vert_resolution = 72;

    driver    = face->driver;
    interface = &driver->interface;
    memory    = driver->memory;

    /* default processing - this can be overriden by the driver */
    if ( char_width  < 1*64 ) char_width  = 1*64;
    if ( char_height < 1*64 ) char_height = 1*64;

    /* Compute pixel sizes in 26.6 units */
    dim_x = (((char_width  * horz_resolution) / 72) + 32) & -64;
    dim_y = (((char_height * vert_resolution) / 72) + 32) & -64;

    metrics->x_ppem    = (FT_UShort)(dim_x >> 6);
    metrics->y_ppem    = (FT_UShort)(dim_y >> 6);

    metrics->x_scale = 0x10000;
    metrics->y_scale = 0x10000;
    if ( face->face_flags & FT_FACE_FLAG_SCALABLE)
    {
      metrics->x_scale = FT_DivFix( dim_x, face->units_per_EM );
      metrics->y_scale = FT_DivFix( dim_y, face->units_per_EM );
    }

    error = interface->set_char_sizes( face->size,
                                       char_width,
                                       char_height,
                                       horz_resolution,
                                       vert_resolution );
    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Set_Pixel_Sizes                                                 */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Sets the character dimensions of a given size object.  The width   */
  /*    and height are expressed in integer pixels.                        */
  /*                                                                       */
  /* <Input>                                                               */
  /*    size         :: A handle to a target size object.                  */
  /*    pixel_width  :: The character width, in integer pixels.            */
  /*    pixel_height :: The character height, in integer pixels.           */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Set_Pixel_Sizes( FT_Face  face,
                                                FT_UInt  pixel_width,
                                                FT_UInt  pixel_height )
  {
    FT_Error             error;
    FT_Driver            driver;
    FT_Memory            memory;
    FT_DriverInterface*  interface;
    FT_Size_Metrics*     metrics = &face->size->metrics;

    if ( !face || !face->size || !face->driver )
      return FT_Err_Invalid_Face_Handle;

    driver    = face->driver;
    interface = &driver->interface;
    memory    = driver->memory;

    /* default processing - this can be overriden by the driver */
    if ( pixel_width  < 1 ) pixel_width  = 1;
    if ( pixel_height < 1 ) pixel_height = 1;

    metrics->x_ppem = pixel_width;
    metrics->y_ppem = pixel_height;

    if ( face->face_flags & FT_FACE_FLAG_SCALABLE )
    {
      metrics->x_scale = FT_DivFix( metrics->x_ppem << 6,
                                    face->units_per_EM );

      metrics->y_scale = FT_DivFix( metrics->y_ppem << 6,
                                    face->units_per_EM );
    }

    error = interface->set_pixel_sizes( face->size,
                                        pixel_width,
                                        pixel_height );
    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_New_GlyphSlot                                                   */
  /*                                                                       */
  /* <Description>                                                         */
  /*    It is sometimes useful to have more than one glyph slot for a      */
  /*    given face object.  This function is used to create additional     */
  /*    slots.  All of them are automatically discarded when the face is   */
  /*    destroyed.                                                         */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face  :: A handle to a parent face object.                         */
  /*                                                                       */
  /* <Output>                                                              */
  /*    aslot :: A handle to a new glyph slot object.                      */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_New_GlyphSlot( FT_Face        face,
                                              FT_GlyphSlot*  aslot )
  {
    FT_Error             error;
    FT_Driver            driver;
    FT_DriverInterface*  interface;
    FT_Memory            memory;
    FT_GlyphSlot         slot;


    *aslot = 0;

    if ( !face || !face->driver )
      return FT_Err_Invalid_Face_Handle;

    driver    = face->driver;
    interface = &driver->interface;
    memory    = driver->memory;

    FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" ));
    if ( ALLOC( slot, interface->slot_object_size ) )
      goto Exit;

    slot->face = face;

    slot->max_subglyphs = 0;
    slot->num_subglyphs = 0;
    slot->subglyphs     = 0;

    error = interface->init_glyph_slot( slot );
    if ( !error )
    {
      /* in case of success, add slot to the face's list */
      slot->next  = face->glyph;
      face->glyph = slot;
      *aslot      = slot;
    }

    if ( error )
      FREE( slot );

  Exit:
    FT_TRACE4(( "FT_New_GlyphSlot: Return %d\n", error ));
    return error;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Done_GlyphSlot                                                  */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Destroys a given glyph slot.  Remember however that all slots are  */
  /*    automatically destroyed with its parent.  Using this function is   */
  /*    not always mandatory.                                              */
  /*                                                                       */
  /* <Input>                                                               */
  /*    slot :: A handle to a target glyph slot.                           */
  /*                                                                       */
  FT_EXPORT_FUNC(void)  FT_Done_GlyphSlot( FT_GlyphSlot  slot )
  {
    if (slot)
    {
      FT_Driver      driver = slot->face->driver;
      FT_Memory      memory = driver->memory;
      FT_GlyphSlot*  parent;
      FT_GlyphSlot   cur;


      /* Remove slot from its parent face's list */
      parent = &slot->face->glyph;
      cur    = *parent;
      while ( cur )
      {
        if ( cur == slot )
        {
          *parent = cur->next;
          break;
        }
        cur = cur->next;
      }

      driver->interface.done_glyph_slot( slot );
      FREE( slot );
    }
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Load_Glyph                                                      */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A function used to load a single glyph within a given glyph slot,  */
  /*    for a given size.                                                  */
  /*                                                                       */
  /* <Input>                                                               */
  /*    slot        :: A handle to a target slot object where the glyph    */
  /*                   will be loaded.                                     */
  /*                                                                       */
  /*    size        :: A handle to the source face size at which the glyph */
  /*                   must be scaled/loaded.                              */
  /*                                                                       */
  /*    glyph_index :: The index of the glyph in the font file.            */
  /*                                                                       */
  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
  /*                   FT_LOAD_XXX constants can be used to control the    */
  /*                   glyph loading process (e.g., whether the outline    */
  /*                   should be scaled, whether to load bitmaps or not,   */
  /*                   whether to hint the outline, etc).                  */
  /* <Output>                                                              */
  /*    result      :: A set of bit flags indicating the type of data that */
  /*                   was loaded in the glyph slot (outline or bitmap,    */
  /*                   etc).                                               */
  /*                                                                       */
  /*                   You can set this field to 0 if you don't want this  */
  /*                   information.                                        */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Load_Glyph( FT_Face  face,
                                           FT_UInt  glyph_index,
                                           FT_Int   load_flags )
  {
    FT_Error   error;
    FT_Driver  driver;

    if ( !face || !face->size || !face->glyph )
      return FT_Err_Invalid_Face_Handle;

    driver = face->driver;

    /* when the flag NO_RECURSE is set, we disable hinting and scaling */
    if (load_flags & FT_LOAD_NO_RECURSE)
      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;

    error = driver->interface.load_glyph( face->glyph,
                                          face->size,
                                          glyph_index,
                                          load_flags );

    return error;
  }


  FT_EXPORT_FUNC(FT_Error)  FT_Load_Char( FT_Face   face,
                                          FT_ULong  char_code,
                                          FT_Int    load_flags )
  {
    FT_Error   error;
    FT_Driver  driver;
    FT_UInt    glyph_index;

    if (!face || !face->size || !face->glyph || !face->charmap )
      return FT_Err_Invalid_Face_Handle;

    driver      = face->driver;
    glyph_index = FT_Get_Char_Index( face, char_code );

    if (glyph_index == 0)
      error = FT_Err_Invalid_Character_Code;
    else
      error = driver->interface.load_glyph( face->glyph,
                                            face->size,
                                            glyph_index,
                                            load_flags );
    return error;
  }

  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Get_Kerning                                                     */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Returns the kerning vector between two glyphs of a same face.      */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face        :: A handle to a source face object.                   */
  /*                                                                       */
  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
  /*                                                                       */
  /*    right_glyph :: The index of the right glyph in the kern pair.      */
  /*                                                                       */
  /* <Output>                                                              */
  /*    kerning     :: The kerning vector.  This is in font units for      */
  /*                   scalable formats, and in pixels for fixed-sizes     */
  /*                   formats.                                            */
  /*                                                                       */
  /* <Return>                                                              */
  /*    FreeType error code.  0 means success.                             */
  /*                                                                       */
  /* <Note>                                                                */
  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
  /*    supported by this method.  Other layouts, or more sophisticated    */
  /*    kernings, are out of the scope of this API function -- they can be */
  /*    implemented through format-specific interfaces.                    */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Get_Kerning( FT_Face     face,
                                            FT_UInt     left_glyph,
                                            FT_UInt     right_glyph,
                                            FT_Vector*  kerning )
  {
    FT_Error   error;
    FT_Driver  driver;
    FT_Memory  memory;


    if ( !face )
    {
      error = FT_Err_Invalid_Face_Handle;
      goto Exit;
    }

    driver = face->driver;
    memory = driver->memory;

    if ( driver->interface.get_kerning )
    {
      error = driver->interface.get_kerning( face, left_glyph,
                                             right_glyph, kerning );
    }
    else
    {
      kerning->x = 0;
      kerning->y = 0;
      error      = FT_Err_Ok;
    }

  Exit:
    return error;
  }

  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Select_Charmap                                                  */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Selects a given charmap by its encoding tag.                       */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face     :: A handle to the source face object.                    */
  /*    encoding :: handle to the selected charmap                         */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code. 0 means success.                                       */
  /*                                                                       */
  /* <Note>                                                                */
  /*    This function will return an error if no charmap in the face       */
  /*    corresponds to the encoding queried here                           */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Select_Charmap( FT_Face      face,
                                               FT_Encoding  encoding )
  {
    FT_CharMap*  cur   = face->charmaps;
    FT_CharMap*  limit = cur + face->num_charmaps;

    for ( ; cur < limit; cur++ )
    {
      if ( cur[0]->encoding == encoding )
      {
        face->charmap = cur[0];
        return 0;
      }
    }
    return FT_Err_Invalid_Argument;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Set_Charmap                                                     */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Selects a given charmap for character code to glyph index          */
  /*    decoding.                                                          */
  /*                                                                       */
  /* <Input>                                                               */
  /*    face     :: A handle to the source face object.                    */
  /*    charmap  :: handle to the selected charmap                         */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code. 0 means success.                                       */
  /*                                                                       */
  /* <Note>                                                                */
  /*    this function will return an error when the charmap is not part    */
  /*    of the face (i.e. if it is not listed in the face->charmaps[]      */
  /*    table).                                                            */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Set_Charmap( FT_Face     face,
                                            FT_CharMap  charmap )
  {
    FT_CharMap*  cur   = face->charmaps;
    FT_CharMap*  limit = cur + face->num_charmaps;

    for ( ; cur < limit; cur++ )
    {
      if ( cur[0] == charmap )
      {
        face->charmap = cur[0];
        return 0;
      }
    }
    return FT_Err_Invalid_Argument;
  }

  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Get_Char_Index                                                  */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Returns the glyph index of a given character code.  This function  */
  /*    uses a charmap object to do the translation.                       */
  /*                                                                       */
  /* <Input>                                                               */
  /*    charmap  :: A handle to a filter charmap object.                   */
  /*    charcode :: The character code.                                    */
  /*                                                                       */
  /* <Return>                                                              */
  /*    The glyph index.  0 means `undefined character code'.              */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_UInt)  FT_Get_Char_Index( FT_Face  face,
                                              FT_ULong charcode )
  {
    FT_UInt    result;
    FT_Driver  driver;

    result = 0;
    if ( face && face->charmap )
    {
      driver = face->driver;
      result = driver->interface.get_char_index( face->charmap, charcode );
    }
    return result;
  }


 /***************************************************************************
  *
  * <Function>
  *    FT_Get_Sfnt_Table
  *
  * <Description>
  *    Returns a pointer to a given SFNT table within a face.
  *
  * <Input>
  *    face  :: handle to source
  *    tag   :: index if SFNT table
  *
  * <Return>
  *    type-less pointer to the table. This will be 0 in case of error, or
  *    when the corresponding table was not found *OR* loaded from the file.
  *
  * <Note>
  *    The table is owned by the face object, and disappears with it.
  *
  *    This function is only useful to access Sfnt tables that are loaded
  *    by the sfnt/truetype/opentype drivers. See FT_Sfnt_tag for a list.
  *
  *    You can load any table with a different function.. XXX
  *
  ***************************************************************************/


  FT_EXPORT_FUNC(void*)  FT_Get_Sfnt_Table( FT_Face      face,
                                            FT_Sfnt_Tag  tag )
  {
    void*                   table = 0;
    FT_Get_Sfnt_Table_Func  func;
    FT_Driver               driver;

    if (!face || !FT_IS_SFNT(face))
      goto Exit;

    driver = face->driver;
    func = (FT_Get_Sfnt_Table_Func)driver->interface.get_interface(
                 driver, "get_sfnt" );
    if (func)
      table = func(face,tag);

  Exit:
    return table;
  }



  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    FT_Done_FreeType                                                   */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Destroys a given FreeType library object and all of its childs,    */
  /*    including resources, drivers, faces, sizes, etc.                   */
  /*                                                                       */
  /* <Input>                                                               */
  /*    library :: A handle to the target library object.                  */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  FT_EXPORT_FUNC(FT_Error)  FT_Done_FreeType( FT_Library  library )
  {
    /* Discard the library object */
    FT_Done_Library( library );

    return FT_Err_Ok;
  }

/* END */