[tfm] Fix typo.

* src/gf/gfdrivr.c(gf_cmap_char_{index, next}): Use `linear search'
instead of `binary search' in the encoding table as it will always
be unsorted.

include/freetype/config/ftmodule.h

@@ -28,5 +28,6 @@ FT_USE_MODULE( FT_Renderer_Class, ft_smooth_renderer_class )
 FT_USE_MODULE( FT_Renderer_Class, ft_smooth_lcd_renderer_class )
 FT_USE_MODULE( FT_Renderer_Class, ft_smooth_lcdv_renderer_class )
 FT_USE_MODULE( FT_Driver_ClassRec, bdf_driver_class )
+FT_USE_MODULE( FT_Driver_ClassRec, gf_driver_class )
 
 /* EOF */

include/freetype/config/ftoption.h

@@ -413,8 +413,8 @@ FT_BEGIN_HEADER
    *   Do not #undef these macros here since the build system might define
    *   them for certain configurations only.
    */
-/* #define FT_DEBUG_LEVEL_ERROR */
-/* #define FT_DEBUG_LEVEL_TRACE */
+#define FT_DEBUG_LEVEL_ERROR
+#define FT_DEBUG_LEVEL_TRACE
 
 
   /**************************************************************************

include/freetype/internal/ftserv.h

@@ -510,6 +510,8 @@ FT_BEGIN_HEADER
 #define FT_SERVICE_TRUETYPE_GLYF_H      <freetype/internal/services/svttglyf.h>
 #define FT_SERVICE_TT_CMAP_H            <freetype/internal/services/svttcmap.h>
 #define FT_SERVICE_WINFNT_H             <freetype/internal/services/svwinfnt.h>
+#define FT_SERVICE_GF_H                 <freetype/internal/services/svgf.h>
+#define FT_SERVICE_PK_H                 <freetype/internal/services/svpk.h>
 
  /* */
 

include/freetype/internal/fttrace.h

@@ -116,6 +116,17 @@ FT_TRACE_DEF( pcfread )
 FT_TRACE_DEF( bdfdriver )
 FT_TRACE_DEF( bdflib )
 
+  /* GF font components */
+FT_TRACE_DEF( gfdriver )
+FT_TRACE_DEF( gflib )
+
+  /* TFM helper module components */
+FT_TRACE_DEF( tfmobjs )
+
+  /* PK font components */
+FT_TRACE_DEF( pkdriver )
+FT_TRACE_DEF( pklib )
+
   /* PFR font component */
 FT_TRACE_DEF( pfr )
 

include/freetype/internal/internal.h

@@ -50,6 +50,8 @@
 #define FT_INTERNAL_CFF_TYPES_H           <freetype/internal/cfftypes.h>
 #define FT_INTERNAL_CFF_OBJECTS_TYPES_H   <freetype/internal/cffotypes.h>
 
+#define FT_INTERNAL_TFM_H                 <freetype/internal/tfm.h>
+
 
 #if defined( _MSC_VER )      /* Visual C++ (and Intel C++) */
 

include/freetype/internal/services/svfntfmt.h

@@ -42,6 +42,8 @@ FT_BEGIN_HEADER
 #define FT_FONT_FORMAT_CFF       "CFF"
 #define FT_FONT_FORMAT_PFR       "PFR"
 #define FT_FONT_FORMAT_WINFNT    "Windows FNT"
+#define FT_FONT_FORMAT_GF        "GF"
+#define FT_FONT_FORMAT_PK        "PK"
 
   /* */
 

include/freetype/internal/services/svgf.h

@@ -0,0 +1,40 @@
+/****************************************************************************
+ *
+ * svgf.h
+ *
+ *   The FreeType GF services (specification).
+ *
+ * Copyright 2003-2018 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.
+ *
+ */
+
+
+#ifndef SVGF_H_
+#define SVGF_H_
+
+
+#include FT_INTERNAL_SERVICE_H
+
+
+FT_BEGIN_HEADER
+
+
+#define FT_SERVICE_ID_GF  "gf"
+
+  /* */
+
+
+FT_END_HEADER
+
+
+#endif /* SVBDF_H_ */
+
+
+/* END */

include/freetype/internal/services/svpk.h

@@ -0,0 +1,40 @@
+/****************************************************************************
+ *
+ * svpk.h
+ *
+ *   The FreeType PK services (specification).
+ *
+ * Copyright 2003-2018 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.
+ *
+ */
+
+
+#ifndef SVPK_H_
+#define SVPK_H_
+
+
+#include FT_INTERNAL_SERVICE_H
+
+
+FT_BEGIN_HEADER
+
+
+#define FT_SERVICE_ID_PK  "pk"
+
+  /* */
+
+
+FT_END_HEADER
+
+
+#endif /* SVPK_H_ */
+
+
+/* END */

include/freetype/internal/tfm.h

@@ -0,0 +1,145 @@
+/****************************************************************************
+ *
+ * tfm.h
+ *
+ *   Auxiliary functions and data structures related to TFM metric files
+ *   (specification).
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#ifndef TFM_H_
+#define TFM_H_
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_HASH_H
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***                TFM FONT INFORMATION STRUCTURES                    ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct  TFM_FontInfoRec_
+  {
+    /* Font Info */
+    FT_Long        cs; /* Check Sum */
+    /* Metrics */
+    FT_ULong       ds, fs; /* Design Size */
+    FT_UInt        design_size;
+    FT_ULong       slant;
+    FT_UInt        begin_char, end_char;
+    FT_Long        *width, *height, *depth;
+    /* Font bounding box */
+    FT_Long        font_bbx_w, font_bbx_h;
+    FT_Long        font_bbx_xoff, font_bbx_yoff;
+
+  } TFM_FontInfoRec, *TFM_FontInfo;
+
+  #define RDS2PT(rds)    (tfm->design_size * ((FT_Long)(rds)/(FT_Long)(1<<20)))
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                            TFM PARSER                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct TFM_ParserRec_*  TFM_Parser;
+
+  typedef struct  TFM_Parser_FuncsRec_
+  {
+    FT_Error
+    (*init)( TFM_Parser  parser,
+             FT_Memory   memory,
+             FT_Stream   stream );
+
+    FT_Error
+    (*parse_metrics)( TFM_Parser  parser );
+
+    void
+    (*done)( TFM_Parser  parser );
+
+  } TFM_Parser_FuncsRec;
+
+
+
+  /**************************************************************************
+   *
+   * @struct:
+   *   TFM_ParserRec
+   *
+   * @description:
+   *   An TFM_Parser is a parser for the TFM files.
+   *
+   * @fields:
+   *   memory ::
+   *     The object used for memory operations (alloc and
+   *     realloc).
+   *
+   *   stream ::
+   *     This is an FT_Stream object.
+   *
+   *   FontInfo ::
+   *     The result will be stored here.
+   */
+  typedef struct  TFM_ParserRec_
+  {
+    FT_Memory     memory;
+    FT_Stream     stream;
+
+    TFM_FontInfo  FontInfo;
+
+    void*         user_data;  /* To be checked for compatibility */
+
+  } TFM_ParserRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        TFM Module Interface                   *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct  TFM_ServiceRec_
+  {
+    const TFM_Parser_FuncsRec* tfm_parser_funcs;
+
+  } TFM_ServiceRec, *TFM_Service;
+
+  /* backward compatible type definition */
+  typedef TFM_ServiceRec   TFM_Interface;
+
+
+FT_END_HEADER
+
+#endif /* PSAUX_H_ */
+
+
+/* END */

modules.cfg

@@ -67,6 +67,12 @@ FONT_MODULES += pcf
 # BDF font driver.  See optional extension ftbdf.c below also.
 FONT_MODULES += bdf
 
+# GF font driver.
+FONT_MODULES += gf
+
+# PK font driver.
+FONT_MODULES += pk
+
 # SFNT files support.  If used without `truetype' or `cff', it supports
 # bitmap-only fonts within an SFNT wrapper.
 #
@@ -137,6 +143,11 @@ AUX_MODULES += bzip2
 # This module depends on `psnames'.
 AUX_MODULES += psaux
 
+# Auxiliary METAFONT driver component to share common code.
+#
+# TFM Module.
+AUX_MODULES += tfm
+
 # Support for PostScript glyph names.
 #
 # This module can be controlled in ftconfig.h

src/gf/gf.c

@@ -0,0 +1,27 @@
+/****************************************************************************
+ *
+ * gf.c
+ *
+ *   FreeType font driver for TeX's GF FONT files
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+
+#include <ft2build.h>
+
+#include "gflib.c"
+#include "gfdrivr.c"
+
+
+/* END */

src/gf/gf.h

@@ -0,0 +1,70 @@
+/****************************************************************************
+ *
+ * gf.h
+ *
+ *   FreeType font driver for METAFONT GF FONT files
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#ifndef GF_H_
+#define GF_H_
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+#include FT_SYSTEM_H
+
+
+FT_BEGIN_HEADER
+
+#define  FONT_DRIVER_GF   1
+
+#define  GF_PRE          247
+#define  GF_ID           131
+#define  GF_POST         248
+#define  GF_CHAR_LOC     245
+#define  GF_CHAR_LOC0    246
+#define  GF_POST_POST    249
+
+#define  GF_PAINT_0        0
+#define  GF_PAINT_1        1
+#define  GF_PAINT_63      63
+#define  GF_PAINT1        64
+#define  GF_PAINT2        65
+#define  GF_PAINT3        66
+#define  GF_BOC           67
+#define  GF_BOC1          68
+#define  GF_EOC           69
+#define  GF_SKIP0         70
+#define  GF_SKIP1         71
+#define  GF_SKIP2         72
+#define  GF_SKIP3         73
+#define  GF_NEW_ROW_0     74
+#define  GF_NEW_ROW_164  238
+#define  GF_XXX1         239
+#define  GF_XXX2         240
+#define  GF_XXX3         241
+#define  GF_XXX4         242
+#define  GF_YYY          243
+#define  GF_NO_OP        244
+
+#define toint(x)  (int)(((x)>0)?(x+0.5):(x-0.5))
+
+FT_END_HEADER
+
+
+#endif /* GF_H_ */
+
+
+/* END */

src/gf/gfdrivr.c

@@ -0,0 +1,630 @@
+/****************************************************************************
+ *
+ * gfdrivr.c
+ *
+ *   FreeType font driver for METAFONT GF FONT files
+ *
+ * Copyright 1996-2018 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 <ft2build.h>
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_TRUETYPE_IDS_H
+#include FT_INTERNAL_TFM_H
+
+#include FT_SERVICE_GF_H
+#include FT_SERVICE_FONT_FORMAT_H
+
+#include "gf.h"
+#include "gfdrivr.h"
+#include "gferror.h"
+
+
+  /**************************************************************************
+   *
+   * The macro FT_COMPONENT is used in trace mode.  It is an implicit
+   * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
+   * messages during execution.
+   */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_gfdriver
+
+
+  typedef struct  GF_CMapRec_
+  {
+    FT_CMapRec      cmap;
+    FT_ULong        num_encodings;
+    GF_Encoding     encodings;
+  } GF_CMapRec, *GF_CMap;
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  gf_cmap_init(  FT_CMap     gfcmap,
+                 FT_Pointer  init_data )
+  {
+    GF_CMap  cmap = (GF_CMap)gfcmap;
+    GF_Face  face = (GF_Face)FT_CMAP_FACE( cmap );
+    FT_UNUSED( init_data );
+
+    cmap->num_encodings = face->gf_glyph->nencodings;
+    cmap->encodings     = face->gf_glyph->encodings;
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  gf_cmap_done( FT_CMap  gfcmap )
+  {
+    GF_CMap  cmap = (GF_CMap)gfcmap;
+
+    cmap->encodings     = NULL;
+    cmap->num_encodings = 0;
+
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  gf_cmap_char_index(  FT_CMap    gfcmap,
+                       FT_UInt32  charcode )
+  {
+    GF_CMap       cmap      = (GF_CMap)gfcmap;
+    GF_Encoding   encodings = cmap->encodings;
+    FT_UInt       max, code, result    = 0, i;
+
+    max = cmap->num_encodings;
+
+    for( i = 0; i < max; i++ )
+    {
+      code = (FT_ULong)encodings[i].enc;
+      if ( charcode == code )
+      {
+        result = encodings[i].glyph;
+        goto Exit;
+      }
+    }
+    Exit:
+      return result;
+  }
+
+  FT_CALLBACK_DEF( FT_UInt )
+  gf_cmap_char_next(  FT_CMap     gfcmap,
+                      FT_UInt32  *acharcode )
+  {
+    GF_CMap       cmap      = (GF_CMap)gfcmap;
+    GF_Encoding   encodings = cmap->encodings;
+    FT_UInt       result    = 0, i, code, max;
+    FT_ULong      charcode  = *acharcode + 1;
+
+    max = cmap->num_encodings;
+
+    for( i = 0; i < max; i++ )
+    {
+      code = (FT_ULong)encodings[i].enc;
+      if ( charcode == code )
+      {
+        result = encodings[i].glyph + 1;
+        goto Exit;
+      }
+    }
+
+  Exit:
+    if ( charcode > 0xFFFFFFFFUL )
+    {
+      FT_TRACE1(( "gf_cmap_char_next: charcode 0x%x > 32bit API" ));
+      *acharcode = 0;
+      /* XXX: result should be changed to indicate an overflow error */
+    }
+    else
+      *acharcode = (FT_UInt32)charcode;
+    return result;
+  }
+
+
+  static
+  const FT_CMap_ClassRec  gf_cmap_class =
+  {
+    sizeof ( GF_CMapRec ),
+    gf_cmap_init,
+    gf_cmap_done,
+    gf_cmap_char_index,
+    gf_cmap_char_next,
+
+    NULL, NULL, NULL, NULL, NULL
+  };
+
+
+  FT_CALLBACK_DEF( void )
+  GF_Face_Done( FT_Face        gfface )         /* GF_Face */
+  {
+    GF_Face    face   = (GF_Face)gfface;
+    FT_Memory  memory;
+
+
+    if ( !face )
+      return;
+
+    memory = FT_FACE_MEMORY( face );
+
+    FT_FREE( gfface->available_sizes );
+
+    if( face->gf_glyph )
+      FT_FREE( face->gf_glyph->encodings );
+
+    gf_free_font( face );
+
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  GF_Face_Init(  FT_Stream      stream,
+                 FT_Face        gfface,         /* GF_Face */
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    GF_Face     face   = (GF_Face)gfface;
+    FT_Error    error  = FT_Err_Ok;
+    FT_Memory   memory = FT_FACE_MEMORY( face );
+    GF_Glyph    go=NULL;
+
+    TFM_Service tfm;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+
+
+    face->tfm = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                           "tfm" );
+    tfm = (TFM_Service)face->tfm;
+    if ( !tfm )
+    {
+      FT_ERROR(( "GF_Face_Init: cannot access `tfm' module\n" ));
+      error = FT_THROW( Missing_Module );
+      goto Exit;
+    }
+
+    FT_TRACE2(( "GF driver\n" ));
+
+    /* load font */
+    error = gf_load_font( stream, memory, &go );
+    if ( FT_ERR_EQ( error, Unknown_File_Format ) )
+    {
+      FT_TRACE2(( "  not a GF file\n" ));
+      goto Fail;
+    }
+    else if ( error )
+      goto Exit;
+
+    /* we have a gf font: let's construct the face object */
+    face->gf_glyph = go;
+
+    /* sanity check */
+    if ( !face->gf_glyph->bm_table )
+    {
+      FT_TRACE2(( "glyph bitmaps not allocated\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+    /* GF cannot have multiple faces in a single font file.
+     * XXX: non-zero face_index is already invalid argument, but
+     *      Type1, Type42 driver has a convention to return
+     *      an invalid argument error when the font could be
+     *      opened by the specified driver.
+     */
+    if ( face_index > 0 && ( face_index & 0xFFFF ) > 0 )
+    {
+      FT_ERROR(( "GF_Face_Init: invalid face index\n" ));
+      GF_Face_Done( gfface );
+      return FT_THROW( Invalid_Argument );
+    }
+
+    /* we now need to fill the root FT_Face fields */
+    /* with relevant information                   */
+
+    gfface->num_faces       = 1;
+    gfface->face_index      = 0;
+    gfface->face_flags     |= FT_FACE_FLAG_FIXED_SIZES |
+                             FT_FACE_FLAG_HORIZONTAL ;
+    /*
+     * XXX: TO-DO: gfface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+     * XXX: I have to check for this.
+     */
+
+    gfface->family_name     = NULL;
+    gfface->num_glyphs      = (FT_Long)go->nglyphs;
+
+    FT_TRACE4(( "  number of glyphs: allocated %d\n",gfface->num_glyphs ));
+
+    if ( gfface->num_glyphs <= 0 )
+    {
+      FT_ERROR(( "GF_Face_Init: glyphs not allocated\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+    gfface->num_fixed_sizes = 1;
+    if ( FT_NEW_ARRAY( gfface->available_sizes, 1 ) )
+      goto Exit;
+
+    {
+      FT_Bitmap_Size*  bsize = gfface->available_sizes;
+      FT_UShort        x_res, y_res;
+
+      bsize->height = (FT_Short) face->gf_glyph->font_bbx_h ;
+      bsize->width  = (FT_Short) face->gf_glyph->font_bbx_w ;
+      bsize->size   = (FT_Pos)   FT_MulDiv( FT_ABS( face->gf_glyph->ds ),
+                                     64 * 7200,
+                                     72270L );
+
+      x_res = toint( go->hppp * 72.27 );
+      y_res = toint( go->vppp * 72.27 );
+
+      bsize->y_ppem = (FT_Pos) toint((face->gf_glyph->ds * y_res)/ 72.27) << 6 ;
+      bsize->x_ppem = (FT_Pos)FT_MulDiv( bsize->y_ppem,
+                                         x_res,
+                                         y_res ); ;
+    }
+
+    /* set up charmap */
+    {
+      /* FT_Bool     unicode_charmap ; */
+
+      /*
+       * XXX: TO-DO
+       * Currently the unicode_charmap is set to `0'
+       * The functionality of extracting coding scheme
+       * from `xxx' and `yyy' commands will be used to
+       * set the unicode_charmap.
+      */
+    }
+
+    /* Charmaps */
+    {
+      FT_CharMapRec  charmap;
+      FT_Bool        unicode_charmap = 0;
+
+      charmap.face        = FT_FACE( face );
+      charmap.encoding    = FT_ENCODING_NONE;
+      /* initial platform/encoding should indicate unset status? */
+      charmap.platform_id = TT_PLATFORM_APPLE_UNICODE;
+      charmap.encoding_id = TT_APPLE_ID_DEFAULT;
+
+      if( unicode_charmap )
+      {
+        /* Unicode Charmap */
+        charmap.encoding    = FT_ENCODING_UNICODE;
+        charmap.platform_id = TT_PLATFORM_MICROSOFT;
+        charmap.encoding_id = TT_MS_ID_UNICODE_CS;
+      }
+
+      error = FT_CMap_New( &gf_cmap_class, NULL, &charmap, NULL );
+
+      if ( error )
+        goto Exit;
+    }
+
+    if ( go->code_max < go->code_min )
+    {
+      FT_TRACE2(( "invalid number of glyphs\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+  Exit:
+    return error;
+
+  Fail:
+    GF_Face_Done( gfface );
+    return FT_THROW( Unknown_File_Format );
+  }
+
+  FT_CALLBACK_DEF( FT_Error )
+  GF_Size_Select(  FT_Size   size,
+                   FT_ULong  strike_index )
+  {
+    GF_Face     face  = (GF_Face)size->face;
+    GF_Glyph    go    = face->gf_glyph;
+    FT_UNUSED( strike_index );
+
+    FT_Select_Metrics( size->face, 0 );
+
+    size->metrics.ascender    = (go->font_bbx_h - go->font_bbx_yoff) * 64;
+    size->metrics.descender   = -go->font_bbx_yoff * 64;
+    size->metrics.max_advance = go->font_bbx_w * 64;
+
+    return FT_Err_Ok;
+
+  }
+
+  FT_CALLBACK_DEF( FT_Error )
+  GF_Size_Request(  FT_Size          size,
+                    FT_Size_Request  req )
+  {
+    GF_Face           face    = (GF_Face)size->face;
+    FT_Bitmap_Size*   bsize   = size->face->available_sizes;
+    FT_Error          error   = FT_ERR( Invalid_Pixel_Size );
+    FT_Long           height;
+
+
+    height = FT_REQUEST_HEIGHT( req );
+    height = ( height + 32 ) >> 6;
+
+    switch ( req->type )
+    {
+    case FT_SIZE_REQUEST_TYPE_NOMINAL:
+      if ( height == ( ( bsize->y_ppem + 32 ) >> 6 ) )
+        error = FT_Err_Ok;
+      break;
+
+    case FT_SIZE_REQUEST_TYPE_REAL_DIM:
+      if ( height == face->gf_glyph->font_bbx_h )
+        error = FT_Err_Ok;
+      break;
+
+    default:
+      error = FT_THROW( Unimplemented_Feature );
+      break;
+    }
+
+    if ( error )
+      return error;
+    else
+      return GF_Size_Select( size, 0 );
+  }
+
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  GF_Glyph_Load(  FT_GlyphSlot  slot,
+                  FT_Size       size,
+                  FT_UInt       glyph_index,
+                  FT_Int32      load_flags )
+  {
+    GF_Face      gf     = (GF_Face)FT_SIZE_FACE( size );
+    FT_Face      face   = FT_FACE( gf );
+    FT_Error     error  = FT_Err_Ok;
+    FT_Bitmap*   bitmap = &slot->bitmap;
+    GF_Bitmap    bm;
+    GF_Glyph     go;
+
+    go = gf->gf_glyph;
+
+    FT_UNUSED( load_flags );
+
+    if ( !face )
+    {
+      error = FT_THROW( Invalid_Face_Handle );
+      goto Exit;
+    }
+
+    if ( !go                                         ||
+         glyph_index >= (FT_UInt)( face->num_glyphs ) )
+    {
+      error = FT_THROW( Invalid_Argument );
+      goto Exit;
+    }
+
+    FT_TRACE1(( "GF_Glyph_Load: glyph index %d charcode is %d\n", glyph_index, go->bm_table[glyph_index].code ));
+
+    if ( (FT_Int)glyph_index < 0 )
+      glyph_index = 0;
+
+    if ( !go->bm_table )
+    {
+      FT_TRACE2(( "invalid bitmap table\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+    /* slot, bitmap => freetype, bm => gflib */
+    bm = &gf->gf_glyph->bm_table[glyph_index];
+
+    bitmap->rows       = bm->bbx_height;
+    bitmap->width      = bm->bbx_width;
+    bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
+
+    if ( !bm->raster )
+    {
+      FT_TRACE2(( "invalid bitmap width\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+    bitmap->pitch = (int)bm->raster ;
+
+    /* note: we don't allocate a new array to hold the bitmap; */
+    /*       we can simply point to it                         */
+    ft_glyphslot_set_bitmap( slot, bm->bitmap );
+
+    slot->format      = FT_GLYPH_FORMAT_BITMAP;
+    slot->bitmap_left = bm->off_x ;
+    slot->bitmap_top  = bm->off_y ;
+
+    slot->metrics.horiAdvance  = (FT_Pos) (bm->mv_x ) * 64;
+    slot->metrics.horiBearingX = (FT_Pos) (bm->off_x ) * 64;
+    slot->metrics.horiBearingY = (FT_Pos) (bm->bbx_height) * 64;
+    slot->metrics.width        = (FT_Pos) ( bitmap->width * 64 );
+    slot->metrics.height       = (FT_Pos) ( bitmap->rows * 64 );
+
+    FT_TRACE2(( "Glyph metric values are: bm->bbx_height is %ld\n"
+                "                         bm->bbx_width  is %ld\n"
+                "                         bm->off_x      is %ld\n"
+                "                         bm->off_y      is %ld\n"
+                "                         bm->mv_x       is %ld\n"
+                "                         bm->mv_y       is %ld\n", bm->bbx_height, bm->bbx_width,
+                                                                    bm->off_x, bm->off_y, bm->mv_x,
+                                                                    bm->mv_y ));
+
+    ft_synthesize_vertical_metrics( &slot->metrics, bm->bbx_height * 64 );
+
+  Exit:
+    return error;
+  }
+
+  FT_LOCAL_DEF( void )
+  TFM_Done_Metrics( FT_Memory     memory,
+                    TFM_FontInfo  fi )
+  {
+    FT_FREE(fi->width);
+    FT_FREE(fi->height);
+    FT_FREE(fi->depth);
+    FT_FREE( fi );
+  }
+
+  /* parse a TFM metrics file */
+  FT_LOCAL_DEF( FT_Error )
+  TFM_Read_Metrics( FT_Face    gf_face,
+                    FT_Stream  stream )
+  {
+    TFM_Service    tfm;
+    FT_Memory      memory  = stream->memory;
+    TFM_ParserRec  parser;
+    TFM_FontInfo   fi      = NULL;
+    FT_Error       error   = FT_ERR( Unknown_File_Format );
+    GF_Face        face    = (GF_Face)gf_face;
+    GF_Glyph       gf_glyph= face->gf_glyph;
+
+
+    if ( face->tfm_data )
+    {
+      FT_TRACE1(( "TFM_Read_Metrics:"
+                  " Freeing previously attached metrics data.\n" ));
+      TFM_Done_Metrics( memory, (TFM_FontInfo)face->tfm_data );
+
+      face->tfm_data = NULL;
+    }
+
+    if ( FT_NEW( fi ) )
+      goto Exit;
+
+    FT_TRACE4(( "TFM_Read_Metrics: Invoking TFM_Service.\n" ));
+
+    tfm = (TFM_Service)face->tfm;
+    if ( tfm->tfm_parser_funcs )
+    {
+      /* Initialise TFM Service */
+      error = tfm->tfm_parser_funcs->init( &parser,
+                                           memory,
+                                           stream );
+
+      if ( !error )
+      {
+        FT_TRACE4(( "TFM_Read_Metrics: Initialised tfm metric data.\n" ));
+        parser.FontInfo  = fi;
+        parser.user_data = gf_glyph;
+
+        error = tfm->tfm_parser_funcs->parse_metrics( &parser );
+        if( !error )
+          FT_TRACE4(( "TFM_Read_Metrics: parsing TFM metric information done.\n" ));
+
+        FT_TRACE6(( "TFM_Read_Metrics: TFM Metric Information:\n"
+                    "                  Check Sum  : %ld\n"
+                    "                  Design Size: %ld\n"
+                    "                  Begin Char : %d\n"
+                    "                  End Char   : %d\n"
+                    "                  font_bbx_w : %d\n"
+                    "                  font_bbx_h : %d\n"
+                    "                  slant      : %d\n", parser.FontInfo->cs, parser.FontInfo->design_size, parser.FontInfo->begin_char,
+                                                           parser.FontInfo->end_char, parser.FontInfo->font_bbx_w,
+                                                           parser.FontInfo->font_bbx_h, parser.FontInfo->slant ));
+        tfm->tfm_parser_funcs->done( &parser );
+      }
+    }
+
+    if ( !error )
+    {
+      /* Modify GF_Glyph data according to TFM metric values */
+
+      /*
+      face->gf_glyph->font_bbx_w = fi->font_bbx_w;
+      face->gf_glyph->font_bbx_h = fi->font_bbx_h;
+      */
+
+      face->tfm_data       = fi;
+    }
+
+  Exit:
+    if ( fi )
+      TFM_Done_Metrics( memory, fi );
+
+    return error;
+  }
+
+ /*
+  *
+  * SERVICES LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  gf_services[] =
+  {
+    { FT_SERVICE_ID_GF,          NULL },
+    { FT_SERVICE_ID_FONT_FORMAT, FT_FONT_FORMAT_GF },
+    { NULL, NULL }
+  };
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  gf_driver_requester( FT_Module    module,
+                        const char*  name )
+  {
+    FT_UNUSED( module );
+
+    return ft_service_list_lookup( gf_services, name );
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  gf_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER         |
+      FT_MODULE_DRIVER_NO_OUTLINES,
+      sizeof ( FT_DriverRec ),
+
+      "gf",
+      0x10000L,
+      0x20000L,
+
+      NULL,    									/* module-specific interface */
+
+      NULL,                     /* FT_Module_Constructor  module_init   */
+      NULL,                     /* FT_Module_Destructor   module_done   */
+      gf_driver_requester     	/* FT_Module_Requester    get_interface */
+    },
+
+    sizeof ( GF_FaceRec ),
+    sizeof ( FT_SizeRec ),
+    sizeof ( FT_GlyphSlotRec ),
+
+    GF_Face_Init,               /* FT_Face_InitFunc  init_face */
+    GF_Face_Done,               /* FT_Face_DoneFunc  done_face */
+    NULL,                       /* FT_Size_InitFunc  init_size */
+    NULL,                       /* FT_Size_DoneFunc  done_size */
+    NULL,                       /* FT_Slot_InitFunc  init_slot */
+    NULL,                       /* FT_Slot_DoneFunc  done_slot */
+
+    GF_Glyph_Load,              /* FT_Slot_LoadFunc  load_glyph */
+
+    NULL,                       /* FT_Face_GetKerningFunc   get_kerning  */
+    TFM_Read_Metrics,           /* FT_Face_AttachFunc       attach_file  */
+    NULL,                       /* FT_Face_GetAdvancesFunc  get_advances */
+
+    GF_Size_Request,           /* FT_Size_RequestFunc  request_size */
+    GF_Size_Select             /* FT_Size_SelectFunc   select_size  */
+  };
+
+
+/* END */

src/gf/gfdrivr.h

@@ -0,0 +1,87 @@
+/****************************************************************************
+ *
+ * gfdrivr.h
+ *
+ *   FreeType font driver for METAFONT GF FONT files
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#ifndef GFDRIVR_H_
+#define GFDRIVR_H_
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+#include "gf.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  GF_EncodingRec_
+  {
+    FT_Long   enc;
+    FT_UShort glyph;
+
+  } GF_EncodingRec, *GF_Encoding;
+
+  /* BitmapRec for GF format specific glyphs  */
+  typedef struct GF_BitmapRec_
+  {
+    FT_Long         bbx_width, bbx_height;
+    FT_Long         off_x, off_y;
+    FT_Long         mv_x,  mv_y;
+    FT_Byte         *bitmap;
+    FT_UInt         raster;
+    FT_UShort       code;
+
+  } GF_BitmapRec, *GF_Bitmap;
+
+
+  typedef struct GF_GlyphRec_
+  {
+    FT_UInt         code_min, code_max;
+    GF_Bitmap       bm_table;
+    FT_Int          ds, hppp, vppp;
+    FT_Int          font_bbx_w, font_bbx_h;
+    FT_Int          font_bbx_xoff, font_bbx_yoff;
+
+    FT_ULong        nencodings;
+    GF_Encoding     encodings;
+
+    FT_ULong        nglyphs;
+
+  } GF_GlyphRec, *GF_Glyph;
+
+
+  typedef struct  GF_FaceRec_
+  {
+    FT_FaceRec      root;
+    GF_Glyph        gf_glyph;
+
+    const void*     tfm;
+    const void*     tfm_data;
+
+  } GF_FaceRec, *GF_Face;
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  gf_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* GFDRIVR_H_ */
+
+
+/* END */

src/gf/gferror.h

@@ -0,0 +1,40 @@
+/****************************************************************************
+ *
+ * gferror.h
+ *
+ *   FreeType font driver for TeX's GF FONT files
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+  /**************************************************************************
+   *
+   * This file is used to define the GF error enumeration constants.
+   *
+   */
+
+#ifndef GFERROR_H_
+#define GFERROR_H_
+
+#include FT_MODULE_ERRORS_H
+
+#undef FTERRORS_H_
+
+#undef  FT_ERR_PREFIX
+#define FT_ERR_PREFIX  GF_Err_
+#define FT_ERR_BASE    FT_Mod_Err_GF
+
+#include FT_ERRORS_H
+
+#endif /* GFERROR_H_ */
+
+
+/* END */

src/gf/gflib.c

@@ -0,0 +1,719 @@
+/****************************************************************************
+ *
+ * gflib.c
+ *
+ *   FreeType font driver for METAFONT GF FONT files
+ *
+ * Copyright 1996-2018 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 <ft2build.h>
+
+#include FT_FREETYPE_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_SYSTEM_H
+#include FT_CONFIG_CONFIG_H
+#include FT_ERRORS_H
+#include FT_TYPES_H
+
+#include "gf.h"
+#include "gfdrivr.h"
+#include "gferror.h"
+
+
+  /**************************************************************************
+   *
+   * The macro FT_COMPONENT is used in trace mode.  It is an implicit
+   * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
+   * messages during execution.
+   */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_gflib
+
+FT_Byte  bit_table[] = {
+  0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+
+  typedef struct GF_CharOffsetRec_
+  {
+    FT_Long         char_offset;
+    FT_UShort       code;
+    FT_Short        gid;
+
+  } GF_CharOffsetRec, *GF_CharOffset;
+
+  /**************************************************************************
+   *
+   * GF font utility functions.
+   *
+   */
+
+  FT_Long     gf_read_intn(FT_Stream, FT_Int);
+  FT_ULong    gf_read_uintn(FT_Stream, FT_Int);
+
+#define READ_UINT1( stream )    (FT_Byte)gf_read_uintn( stream, 1)
+#define READ_UINT2( stream )    (FT_Byte)gf_read_uintn( stream, 2)
+#define READ_UINT3( stream )    (FT_Byte)gf_read_uintn( stream, 3)
+#define READ_UINT4( stream )    (FT_Byte)gf_read_uintn( stream, 4)
+#define READ_UINTN( stream,n)   (FT_ULong)gf_read_uintn( stream, n)
+#define READ_INT1( stream )     (FT_String)gf_read_intn( stream, 1)
+#define READ_INT4( stream )     (FT_Long)gf_read_intn( stream, 4)
+
+/*
+ * Reading a Number from file
+ */
+  FT_ULong
+  gf_read_uintn(FT_Stream stream, FT_Int size)
+  {
+    FT_ULong  v,k;
+    FT_Error  error;
+    FT_Byte   tp;
+
+    v = 0L;
+
+    while (size >= 1)
+    {
+      if ( FT_READ_BYTE(tp) )
+        return 0;
+      k = (FT_ULong)tp;
+      v = v*256L + k;
+      --size;
+    }
+    return v;
+  }
+
+  FT_Long
+  gf_read_intn(FT_Stream stream, FT_Int size)
+  {
+    FT_Long   v;
+    FT_Byte   tp;
+    FT_Error  error;
+    FT_ULong  z;
+
+    if ( FT_READ_BYTE(tp) )
+        return 0;
+    z = (FT_ULong)tp;
+    v = (FT_Long)z & 0xffL;
+
+    if (v & 0x80L)
+      v = v - 256L;
+    --size;
+
+    while (size >= 1)
+    {
+      if ( FT_READ_BYTE(tp) )
+        return 0;
+      z = (FT_ULong)tp;
+      v = v*256L + z;
+      --size;
+		}
+    return v;
+  }
+
+  static int
+  compare( FT_Long*  a,
+           FT_Long*  b )
+  {
+    if ( *a < *b )
+      return -1;
+    else if ( *a > *b )
+      return 1;
+    else
+      return 0;
+  }
+
+  /**************************************************************************
+   *
+   * API.
+   *
+   */
+
+  static FT_Error
+  gf_set_encodings( GF_CharOffset of,
+                    FT_Int        ngphs,
+                    GF_Glyph      go,
+                    FT_Memory     memory )
+  {
+    FT_Error      error;
+    FT_ULong      nencoding;
+    FT_Int        i, j;
+    FT_ULong      k;
+    GF_Encoding   encoding = NULL;
+    FT_Long       *tosort;
+
+    nencoding = ngphs;
+    FT_TRACE2(( "gf_set_encodings: Reached here.\n" ));
+
+    if ( FT_NEW_ARRAY( encoding, nencoding ) )
+      return error;
+
+    if ( FT_NEW_ARRAY( tosort, nencoding ) )
+      return error;
+
+
+    FT_TRACE2(( "gf_set_encodings: Allocated sufficient memory.\n" ));
+
+    for( i = 0 ; i < ngphs ; i++ )
+    {
+      if( of[i].char_offset >= 0 )
+        tosort[i] = of[i].char_offset;
+    }
+
+    ft_qsort( (void*)tosort, ngphs, sizeof(FT_Long),
+               (int(*)(const void*, const void*) )compare );
+
+    k = 0;
+    for ( i = 0; i < ngphs; i++ )
+    {
+      for ( j = 0; j < ngphs; j++ )
+      {
+        if( of[j].char_offset == tosort[i] )
+        break;
+      }
+      encoding[k].enc   = of[j].code;
+      encoding[k].glyph = k;
+      of[j].gid         = k;
+      k++;
+    }
+
+    FT_FREE(tosort);
+
+    go->nencodings = k;
+    go->encodings  = encoding;
+
+    return error;
+  }
+
+  FT_LOCAL_DEF( FT_Error )
+  gf_read_glyph( FT_Stream    stream,
+                 GF_Bitmap    bm,
+                 FT_Memory    memory )
+  {
+    FT_Long        m, n;
+    FT_Int         paint_sw;
+    FT_Int         instr,inst;
+    FT_Long        min_m, max_m, min_n, max_n, del_m, del_n;
+    FT_Long        w, h, d;
+    FT_Int         m_b, k;
+    FT_Byte        *ptr;
+    FT_Error       error  = FT_Err_Ok;
+
+    for (  ;  ;  )
+    {
+      inst = READ_UINT1( stream );
+      switch ((FT_Int)inst)
+      {
+      case GF_BOC:
+        if ( FT_STREAM_SKIP( 4 ) )
+          return -1;
+        if ( FT_STREAM_SKIP( 4 ) )
+          return -1;
+        min_m = READ_INT4( stream );
+        max_m = READ_INT4( stream );
+        min_n = READ_INT4( stream );
+        max_n = READ_INT4( stream );
+        goto BOC;
+        break;
+      case GF_BOC1:
+        if ( FT_STREAM_SKIP( 1 ) )
+          return -1;
+        del_m = (FT_Long)READ_UINT1( stream );
+        max_m = (FT_Long)READ_UINT1( stream );
+        del_n = (FT_Long)READ_UINT1( stream );
+        max_n = (FT_Long)READ_UINT1( stream );
+        min_m = max_m - del_m;
+        min_n = max_n - del_n;
+        goto BOC;
+        break;
+      case GF_XXX1:
+        k = (FT_ULong)READ_UINT1( stream );
+        if ( FT_STREAM_SKIP( k ) )
+          return -1;
+        break;
+      case GF_XXX2:
+        k = (FT_ULong)READ_UINT2( stream );
+        if ( FT_STREAM_SKIP( k ) )
+          return -1;
+        break;
+      case GF_XXX3:
+        k = (FT_ULong)READ_UINT3( stream );
+        if ( FT_STREAM_SKIP( k ) )
+          return -1;
+        break;
+      case GF_XXX4:
+        k = (FT_ULong)READ_UINT4( stream );
+        if ( FT_STREAM_SKIP( k ) )
+          return -1;
+        break;
+      case GF_YYY :
+        if ( FT_STREAM_SKIP( 4 ) )
+          return -1;
+        break;
+      case GF_NO_OP:
+        break;
+      default:
+        return -1;
+      }
+    }
+
+    return 0;
+
+    BOC:
+      if(error != FT_Err_Ok)
+        return -1;
+      w = max_m - min_m + 1;
+      h = max_n - min_n + 1;
+      if ((w < 0) || (h < 0))
+      {
+        FT_ERROR(( "gf_read_glyph: invalid w and h values\n" ));
+        error = FT_THROW( Invalid_File_Format );
+        return -1;
+      }
+
+      /* allocate and build bitmap */
+      if ((bm->bitmap = (FT_Byte*)malloc(h*((w+7)/8))) == NULL)
+      {
+        error = FT_THROW( Invalid_File_Format );
+        return -1;
+      }
+
+      memset(bm->bitmap, 0, h*((w+7)/8));
+      bm->raster     = (FT_UInt)(w+7)/8;
+      bm->bbx_width  = w;
+      bm->bbx_height = h;
+      bm->off_x      = -min_m;
+      bm->off_y      = max_n;
+      #if 0
+        bm->mv_x       = -min_m;
+        bm->mv_y       = max_n;
+      #endif
+
+      m        = min_m;
+      n        = max_n;
+      paint_sw = 0;
+      while ((instr = (FT_Int)READ_UINT1( stream )) != GF_EOC)
+      {
+        if (instr == GF_PAINT_0)
+        {
+          paint_sw = 1 - paint_sw;
+        }
+        else if ((GF_NEW_ROW_0 <= instr) && (instr <= GF_NEW_ROW_164))
+        {
+          m        = min_m + (instr - GF_NEW_ROW_0);
+          n        = n - 1;
+          paint_sw = 1;
+        }
+        else if ((GF_PAINT_1 <= instr) && (instr <= GF_PAINT_63))
+        {
+          d = (instr - GF_PAINT_1 + 1);
+          goto Paint;
+        }
+        else
+        {
+          switch ((FT_Int)instr)
+          {
+          case GF_PAINT1:
+          case GF_PAINT2:
+          case GF_PAINT3:
+            d = (FT_ULong)READ_UINTN( stream, (instr - GF_PAINT1 + 1));
+            Paint:
+              if (paint_sw == 0)
+              {
+                m = m + d;
+              }
+              else
+              {
+                ptr = &bm->bitmap[(max_n - n) * bm->raster + (m - min_m)/8];
+                m_b = (m - min_m) % 8;
+                while (d > 0)
+                {
+                  *ptr |= bit_table[m_b];
+                  m++;
+                  if (++m_b >= 8)
+                  {
+                    m_b = 0;
+                    ++ptr;
+                  }
+                  d--;
+                }
+              }
+              paint_sw = 1 - paint_sw;
+            break;
+          case GF_SKIP0:
+            m = min_m;
+            n = n - 1;
+            paint_sw = 0;
+            break;
+          case GF_SKIP1:
+          case GF_SKIP2:
+          case GF_SKIP3:
+            m = min_m;
+            n = n - (FT_ULong)READ_UINTN( stream, (instr - GF_SKIP1 + 1)) - 1;
+            paint_sw = 0;
+            break;
+          case GF_XXX1:
+          case GF_XXX2:
+          case GF_XXX3:
+          case GF_XXX4:
+            k = READ_UINTN( stream, instr - GF_XXX1 + 1);
+            if ( FT_STREAM_SKIP( k ) )
+              return -1;
+            break;
+          case GF_YYY:
+            if ( FT_STREAM_SKIP( 4 ) )
+              return -1;
+            break;
+          case GF_NO_OP:
+            break;
+          default:
+            FT_FREE(bm->bitmap);
+            bm->bitmap = NULL;
+            error = FT_THROW( Invalid_File_Format );
+            return -1;
+           }
+        }
+      }
+    return 0;
+  }
+
+  FT_LOCAL_DEF( FT_Error )
+  gf_load_font(  FT_Stream    stream,
+                 FT_Memory    extmemory,
+                 GF_Glyph     *goptr  )
+  {
+    GF_Glyph         go;
+    GF_Bitmap        bm;
+    GF_CharOffset    of;
+    FT_Byte          instr, d, pre, id, k, code;
+    FT_Long          ds, check_sum, hppp, vppp;
+    FT_Long          min_m, max_m, min_n, max_n, w;
+    FT_UInt          dx, dy;
+    FT_Long          ptr_post, ptr_p, ptr, optr, rptr;
+    FT_Int           bc, ec, nchars, i, ngphs, idx;
+    FT_Error         error  = FT_Err_Ok;
+    FT_Memory        memory = extmemory; /* needed for FT_NEW */
+
+    go = NULL;
+    nchars = -1;
+
+    if( FT_STREAM_SEEK( 0 ) )
+      goto Exit;
+
+    pre = READ_UINT1( stream );
+    if (pre != GF_PRE)
+    {
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    id = READ_UINT1( stream );
+    if (id != GF_ID)
+    {
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    k = READ_UINT1( stream );
+    if ( FT_STREAM_SKIP( k ) )
+      goto Exit;
+
+    /* seek to post_post instr. */
+    if( FT_STREAM_SEEK( stream->size - 1 ) )
+      goto Exit;
+    if( FT_STREAM_SEEK( stream->size - 1 ) )
+      goto Exit;
+
+    while ( READ_UINT1( stream ) == 223)
+    {
+      if( FT_STREAM_SEEK( stream->pos -2 ) )
+        goto Exit;
+    }
+
+
+    if( FT_STREAM_SEEK( stream->pos -1 ) )
+        goto Exit;
+    d= READ_UINT1( stream );
+
+    if (d != GF_ID)
+    {
+      FT_ERROR(( "gf_load_font: missing GF_ID(131) field\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    FT_TRACE2(( "gf_load_font: GF_ID(131) found\n" ));
+
+    if(FT_STREAM_SEEK( stream->pos -6 ))
+      goto Exit;
+
+    /* check if the code is post_post */
+    if (READ_UINT1( stream ) != GF_POST_POST)
+    {
+      FT_ERROR(( "gf_load_font: missing GF_POST_POST(249) field\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    FT_TRACE2(( "gf_load_font: GF_POST_POST(249) found\n" ));
+
+    /* read pointer to post instr. */
+    if(FT_READ_ULONG( ptr_post ))
+      goto Exit;
+
+    if (ptr_post == -1)
+    {
+      FT_ERROR(( "gf_load_font: invalid postamble pointer\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    /* goto post instr. and read it */
+    if(FT_STREAM_SEEK( ptr_post ))
+      goto Exit;
+
+    if (READ_UINT1( stream ) != GF_POST)
+    {
+      FT_ERROR(( "gf_load_font: missing GF_POST(248) field\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+    FT_TRACE2(( "gf_load_font: GF Postamble found\n" ));
+
+    if(FT_READ_ULONG( ptr_p ))
+      goto Exit;
+    if(FT_READ_ULONG( ds ))
+      goto Exit;
+    if(FT_READ_ULONG( check_sum ))
+      goto Exit;
+    if(FT_READ_ULONG( hppp ))
+      goto Exit;
+    if(FT_READ_ULONG( vppp ))
+      goto Exit;
+    min_m     = READ_INT4( stream );
+    max_m     = READ_INT4( stream );
+    min_n     = READ_INT4( stream );
+    max_n     = READ_INT4( stream );
+
+    FT_TRACE5(( "gf_load_font: checksum is %ld\n",check_sum ));
+
+    if( ptr_p < 0 )     /* Defined to use ptr_p */
+    {
+      FT_ERROR(( "gf_load_font: invalid pointer in postamble\n" ));
+      goto Exit;
+    }
+
+    if( check_sum < 0 ) /* Defined to use check_sum */
+    {
+      FT_ERROR(( "gf_load_font: invalid check sum value\n" ));
+      goto Exit;
+    }
+    #if 0
+      gptr = ftell(fp);
+    #endif
+
+    #if 0
+      /* read min & max char code */
+      bc = 256;
+      ec = -1;
+      for (  ;  ;  )
+      {
+        instr = READ_UINT1(fp);
+        if (instr == GF_POST_POST)
+        {
+          break;
+        }
+        else if (instr == GF_CHAR_LOC)
+        {
+          code = READ_UINT1(fp);
+          (void)SKIP_N(fp, 16);
+        }
+        else if (instr == GF_CHAR_LOC0)
+        {
+          code = READ_UINT1(fp);
+          (void)SKIP_N(fp, 9);
+        }
+        else
+        {
+          error = FT_THROW( Invalid_File_Format );
+          goto Exit;
+        }
+        if (code < bc)
+          bc = code;
+        if (code > ec)
+          ec = code;
+      }
+    #else
+      bc = 0;
+      ec = 255;
+    #endif
+
+    nchars = ec - bc + 1;
+
+    if( FT_ALLOC(go, sizeof(GF_GlyphRec)) )
+      goto Exit;
+
+    FT_TRACE2(( "gf_load_font: Allocated bitmap table\n" ));
+
+    go->ds   = (FT_UInt)ds/(1<<20);
+    go->hppp = (FT_UInt)hppp/(1<<16);
+    go->vppp = (FT_UInt)vppp/(1<<16);
+    go->font_bbx_w = max_m - min_m;
+    go->font_bbx_h = max_n - min_n;
+    go->font_bbx_xoff = min_m;
+    go->font_bbx_yoff = min_n;
+    go->code_min = bc;
+    go->code_max = ec;
+
+    go->nglyphs = 0;
+
+    if( FT_ALLOC_MULT(of, sizeof(GF_CharOffsetRec), nchars) )
+      goto Exit;
+
+    rptr = stream->pos;
+    i    =0;
+    ngphs=0;
+
+    for (  ;  ;  )
+    {
+      if ((instr = READ_UINT1( stream )) == GF_POST_POST)
+        break;
+      switch ((FT_Int)instr)
+      {
+      case GF_CHAR_LOC:
+        code = READ_UINT1( stream );
+        dx   = (FT_UInt)READ_INT4( stream )/(FT_UInt)(1<<16);
+        dy   = (FT_UInt)READ_INT4( stream )/(FT_UInt)(1<<16);
+        w    = READ_INT4( stream );
+        ptr  = READ_INT4( stream );
+        break;
+      case GF_CHAR_LOC0:
+        code = READ_UINT1( stream );
+        dx   = (FT_UInt)READ_INT1( stream );
+        dy   = (FT_UInt)0;
+        w    = READ_INT4( stream );
+        ptr  = READ_INT4( stream );
+        break;
+      default:
+        FT_ERROR(( "gf_load_font: missing character locators in postamble\n" ));
+        error = FT_THROW( Unknown_File_Format );
+        goto Exit;
+      }
+
+      of[i].char_offset = (FT_ULong)ptr;
+      of[i].code        = (FT_UShort)code;
+      of[i].gid         = -1;
+      ngphs            += 1;
+      i++;
+    }
+
+    if( FT_ALLOC_MULT(go->bm_table, sizeof(GF_BitmapRec), ngphs) )
+      goto Exit;
+
+    error = gf_set_encodings( of, ngphs, go, memory );
+    if( error )
+      goto Exit;
+
+    if( FT_STREAM_SEEK( rptr ) )
+        goto Exit;
+
+    for (  ;  ;  )
+    {
+      if ((instr = READ_UINT1( stream )) == GF_POST_POST)
+        break;
+      switch ((FT_Int)instr)
+      {
+      case GF_CHAR_LOC:
+        code = READ_UINT1( stream );
+        dx   = (FT_UInt)READ_INT4( stream )/(FT_UInt)(1<<16);
+        dy   = (FT_UInt)READ_INT4( stream )/(FT_UInt)(1<<16);
+        w    = READ_INT4( stream );
+        ptr  = READ_INT4( stream );
+        break;
+      case GF_CHAR_LOC0:
+        code = READ_UINT1( stream );
+        dx   = (FT_UInt)READ_INT1( stream );
+        dy   = (FT_UInt)0;
+        w    = READ_INT4( stream );
+        ptr  = READ_INT4( stream );
+        break;
+      default:
+        FT_ERROR(( "gf_load_font: missing character locators in postamble\n" ));
+        error = FT_THROW( Unknown_File_Format );
+        goto Exit;
+      }
+
+      optr = stream->pos;
+      if( FT_STREAM_SEEK( ptr ) )
+        goto Exit;
+
+      for ( i = 0; i < 256; i++ )
+      {
+        if( of[i].code == code && of[i].char_offset == ptr )
+        {
+          idx = of[i].gid;
+          break;
+        }
+      }
+      bm = &go->bm_table[idx];
+
+      bm->mv_x     = dx;
+      bm->mv_y     = dy;
+      bm->code     = code;
+      go->nglyphs += 1;
+
+      if (gf_read_glyph( stream, bm, memory ) < 0)
+        goto Exit;
+
+      if(FT_STREAM_SEEK( optr ))
+        goto Exit;
+    }
+
+    FT_FREE(of);
+    *goptr          = go;
+    return error;
+
+    Exit:
+      if (go != NULL)
+      {
+        if( go->bm_table )
+        {
+          for (i = 0; i < nchars; i++)
+	          FT_FREE(go->bm_table[i].bitmap);
+        }
+        FT_FREE(go->bm_table);
+        FT_FREE(go);
+      }
+      return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  gf_free_font( GF_Face face )
+  {
+    FT_Memory  memory = FT_FACE( face )->memory;
+    GF_Glyph   go     = face->gf_glyph;
+    FT_UInt    nchars = FT_FACE( face )->num_glyphs,i;
+
+    if ( !go )
+      return;
+
+    if( go->bm_table )
+    {
+      for (i = 0; i < nchars; i++)
+	      FT_FREE(go->bm_table[i].bitmap);
+    }
+    FT_FREE(go->bm_table);
+    FT_FREE(go);
+  }
+
+
+/* END */

src/gf/module.mk

@@ -0,0 +1,23 @@
+#
+# FreeType 2 GF Font module definition
+#
+
+
+# Copyright 1996-2018 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.
+
+
+FTMODULE_H_COMMANDS += GF_DRIVER
+
+define GF_DRIVER
+$(OPEN_DRIVER) FT_Driver_ClassRec, gf_driver_class $(CLOSE_DRIVER)
+$(ECHO_DRIVER)gf        $(ECHO_DRIVER_DESC)METAFONT bitmap fonts$(ECHO_DRIVER_DONE)
+endef
+
+# EOF

src/gf/rules.mk

@@ -0,0 +1,70 @@
+#
+# FreeType 2 GF driver configuration rules
+#
+
+
+# Copyright 1996-2018 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.
+
+
+# gf driver directory
+#
+GF_DIR := $(SRC_DIR)/gf
+
+
+GF_COMPILE := $(CC) $(ANSIFLAGS)                            \
+                     $I$(subst /,$(COMPILER_SEP),$(GF_DIR)) \
+                     $(INCLUDE_FLAGS)                        \
+                     $(FT_CFLAGS)
+
+
+# gf driver sources (i.e., C files)
+#
+GF_DRV_SRC := $(GF_DIR)/gflib.c \
+               $(GF_DIR)/gfdrivr.c
+
+
+# gf driver headers
+#
+GF_DRV_H :=  $(GF_DIR)/gf.h \
+             $(GF_DIR)/gfdrivr.h \
+             $(GF_DIR)/gferror.h
+
+# gf driver object(s)
+#
+#   GF_DRV_OBJ_M is used during `multi' builds
+#   GF_DRV_OBJ_S is used during `single' builds
+#
+GF_DRV_OBJ_M := $(GF_DRV_SRC:$(GF_DIR)/%.c=$(OBJ_DIR)/%.$O)
+GF_DRV_OBJ_S := $(OBJ_DIR)/gf.$O
+
+# gf driver source file for single build
+#
+GF_DRV_SRC_S := $(GF_DIR)/gf.c
+
+
+# gf driver - single object
+#
+$(GF_DRV_OBJ_S): $(GF_DRV_SRC_S) $(GF_DRV_SRC) $(FREETYPE_H) $(GF_DRV_H)
+	$(GF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(GF_DRV_SRC_S))
+
+
+# gf driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(GF_DIR)/%.c $(FREETYPE_H) $(GF_DRV_H)
+	$(GF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(GF_DRV_OBJ_S)
+DRV_OBJS_M += $(GF_DRV_OBJ_M)
+
+
+# EOF

src/pk/module.mk

@@ -0,0 +1,23 @@
+#
+# FreeType 2 PK Font module definition
+#
+
+
+# Copyright 1996-2018 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.
+
+
+FTMODULE_H_COMMANDS += PK_DRIVER
+
+define PK_DRIVER
+$(OPEN_DRIVER) FT_Driver_ClassRec, pk_driver_class $(CLOSE_DRIVER)
+$(ECHO_DRIVER)pk        $(ECHO_DRIVER_DESC)METAFONT bitmap fonts$(ECHO_DRIVER_DONE)
+endef
+
+# EOF

src/pk/pk.c

@@ -0,0 +1,27 @@
+/****************************************************************************
+ *
+ * pk.c
+ *
+ *   FreeType font driver for TeX's PK FONT files.
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+
+#include <ft2build.h>
+
+#include "pklib.c"
+#include "pkdrivr.c"
+
+
+/* END */

src/pk/pk.h

@@ -0,0 +1,50 @@
+/****************************************************************************
+ *
+ * pk.h
+ *
+ *   FreeType font driver for TeX's PK FONT files.
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#ifndef PK_H_
+#define PK_H_
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+#include FT_SYSTEM_H
+
+
+FT_BEGIN_HEADER
+
+
+#define  PK_PRE   247
+#define  PK_ID    89
+#define  PK_XXX1  240
+#define  PK_XXX2  241
+#define  PK_XXX3  242
+#define  PK_XXX4  243
+#define  PK_YYY   244
+#define  PK_POST  245
+#define  PK_NO_OP 246
+
+#define toint(x)  (int)(((x)>0)?(x+0.5):(x-0.5))
+
+
+FT_END_HEADER
+
+
+#endif /* PK_H_ */
+
+
+/* END */

src/pk/pkdrivr.c

@@ -0,0 +1,624 @@
+/****************************************************************************
+ *
+ * pkdrivr.c
+ *
+ *   FreeType font driver for TeX's PK FONT files.
+ *
+ * Copyright 1996-2018 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 <ft2build.h>
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_TRUETYPE_IDS_H
+#include FT_INTERNAL_TFM_H
+
+#include FT_SERVICE_PK_H
+#include FT_SERVICE_FONT_FORMAT_H
+
+#include "pk.h"
+#include "pkdrivr.h"
+#include "pkerror.h"
+
+
+  /**************************************************************************
+   *
+   * The macro FT_COMPONENT is used in trace mode.  It is an implicit
+   * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
+   * messages during execution.
+   */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pkdriver
+
+
+  typedef struct  PK_CMapRec_
+  {
+    FT_CMapRec      cmap;
+    FT_ULong        num_encodings;
+    PK_Encoding     encodings;
+  } PK_CMapRec, *PK_CMap;
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  pk_cmap_init(  FT_CMap     pkcmap,
+                 FT_Pointer  init_data )
+  {
+    PK_CMap  cmap = (PK_CMap)pkcmap;
+    PK_Face  face = (PK_Face)FT_CMAP_FACE( cmap );
+    FT_UNUSED( init_data );
+
+    cmap->num_encodings = face->pk_glyph->nencodings;
+    cmap->encodings     = face->pk_glyph->encodings;
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  pk_cmap_done( FT_CMap  pkcmap )
+  {
+    PK_CMap  cmap = (PK_CMap)pkcmap;
+
+    cmap->encodings     = NULL;
+    cmap->num_encodings = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pk_cmap_char_index(  FT_CMap    pkcmap,
+                       FT_UInt32  charcode )
+  {
+    PK_CMap       cmap      = (PK_CMap)pkcmap;
+    PK_Encoding   encodings = cmap->encodings;
+    FT_UInt       max, code, result    = 0, i;
+
+    max = cmap->num_encodings;
+
+    for( i = 0; i < max; i++ )
+    {
+      code = (FT_ULong)encodings[i].enc;
+      if ( charcode == code )
+      {
+        result = encodings[i].glyph;
+        goto Exit;
+      }
+    }
+    Exit:
+      return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pk_cmap_char_next(  FT_CMap    pkcmap,
+                       FT_UInt32  *acharcode )
+  {
+    PK_CMap       cmap      = (PK_CMap)pkcmap;
+    PK_Encoding   encodings = cmap->encodings;
+    FT_UInt       result    = 0, i, code, max;
+    FT_ULong      charcode  = *acharcode + 1;
+
+    max = cmap->num_encodings;
+
+    for( i = 0; i < max; i++ )
+    {
+      code = (FT_ULong)encodings[i].enc;
+      if ( charcode == code )
+      {
+        result = encodings[i].glyph + 1;
+        goto Exit;
+      }
+    }
+
+  Exit:
+    if ( charcode > 0xFFFFFFFFUL )
+    {
+      FT_TRACE1(( "gf_cmap_char_next: charcode 0x%x > 32bit API" ));
+      *acharcode = 0;
+      /* XXX: result should be changed to indicate an overflow error */
+    }
+    else
+      *acharcode = (FT_UInt32)charcode;
+    return result;
+  }
+
+
+  static
+  const FT_CMap_ClassRec  pk_cmap_class =
+  {
+    sizeof ( PK_CMapRec ),
+    pk_cmap_init,
+    pk_cmap_done,
+    pk_cmap_char_index,
+    pk_cmap_char_next,
+
+    NULL, NULL, NULL, NULL, NULL
+  };
+
+
+  FT_CALLBACK_DEF( void )
+  PK_Face_Done( FT_Face        pkface )         /* PK_Face */
+  {
+    PK_Face    face   = (PK_Face)pkface;
+    FT_Memory  memory;
+
+
+    if ( !face )
+      return;
+
+    memory = FT_FACE_MEMORY( face );
+
+    pk_free_font( face );
+
+    FT_FREE( pkface->available_sizes );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  PK_Face_Init(   FT_Stream      stream,
+                  FT_Face        pkface,         /* PK_Face */
+                  FT_Int         face_index,
+                  FT_Int         num_params,
+                  FT_Parameter*  params )
+  {
+    PK_Face     face   = (PK_Face)pkface;
+    FT_Error    error  = FT_Err_Ok;
+    FT_Memory   memory = FT_FACE_MEMORY( face );
+    PK_Glyph    go=NULL;
+    FT_UInt16   i,count;
+
+    TFM_Service tfm;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+
+    face->tfm = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                           "tfm" );
+    tfm = (TFM_Service)face->tfm;
+    if ( !tfm )
+    {
+      FT_ERROR(( "GF_Face_Init: cannot access `tfm' module\n" ));
+      error = FT_THROW( Missing_Module );
+      goto Exit;
+    }
+
+    FT_TRACE2(( "PK driver\n" ));
+
+    /* load font */
+    error = pk_load_font( stream, memory, &go );
+    if ( FT_ERR_EQ( error, Unknown_File_Format ) )
+    {
+      FT_TRACE2(( "  not a PK file\n" ));
+      goto Fail;
+    }
+    else if ( error )
+      goto Exit;
+
+    /* we have a pk font: let's construct the face object */
+    face->pk_glyph = go ;
+
+    /* sanity check */
+    if ( !face->pk_glyph->bm_table )
+    {
+      FT_TRACE2(( "glyph bitmaps not allocated\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+    /* PK cannot have multiple faces in a single font file.
+     * XXX: non-zero face_index is already invalid argument, but
+     *      Type1, Type42 driver has a convention to return
+     *      an invalid argument error when the font could be
+     *      opened by the specified driver.
+     */
+    if ( face_index > 0 && ( face_index & 0xFFFF ) > 0 )
+    {
+      FT_ERROR(( "PK_Face_Init: invalid face index\n" ));
+      PK_Face_Done( pkface );
+      return FT_THROW( Invalid_Argument );
+    }
+
+    /* we now need to fill the root FT_Face fields */
+    /* with relevant information                   */
+
+    pkface->num_faces       = 1;
+    pkface->face_index      = 0;
+    pkface->face_flags     |= FT_FACE_FLAG_FIXED_SIZES |
+                             FT_FACE_FLAG_HORIZONTAL ;
+    /*
+     * XXX: TO-DO: pkface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+     * XXX: I have to check for this.
+     */
+
+    pkface->family_name     = NULL;
+    count=0;
+    for (i = 0; i < 256; i++)
+    {
+      if(go->bm_table[i].bitmap != NULL)
+        count++;
+    }
+    pkface->num_glyphs      = (FT_Long)count;
+
+    FT_TRACE4(( "  number of glyphs: allocated %d\n",pkface->num_glyphs ));
+
+    if ( pkface->num_glyphs <= 0 )
+    {
+      FT_ERROR(( "PK_Face_Init: glyphs not allocated\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+    pkface->num_fixed_sizes = 1;
+    if ( FT_NEW_ARRAY( pkface->available_sizes, 1 ) )
+      goto Exit;
+
+    {
+      FT_Bitmap_Size*  bsize = pkface->available_sizes;
+      FT_UShort        x_res, y_res;
+
+      bsize->height = (FT_Short) face->pk_glyph->font_bbx_h ;
+      bsize->width  = (FT_Short) face->pk_glyph->font_bbx_w ;
+      bsize->size   = (FT_Pos)   FT_MulDiv( FT_ABS( face->pk_glyph->ds ),
+                                     64 * 7200,
+                                     72270L );
+
+      x_res = toint( face->pk_glyph->hppp * 72.27 );
+      y_res = toint( face->pk_glyph->vppp * 72.27 );
+
+      bsize->y_ppem = (FT_Pos) toint((face->pk_glyph->ds * y_res)/ 72.27) << 6 ;
+      bsize->x_ppem = (FT_Pos) FT_MulDiv( bsize->y_ppem,
+                                         x_res,
+                                         y_res );
+    }
+
+    /* set up charmap */
+    {
+      /* FT_Bool     unicode_charmap ; */
+
+      /*
+       * XXX: TO-DO
+       * Currently the unicode_charmap is set to `0'
+       * The functionality of extracting coding scheme
+       * from `xxx' and `yyy' commands will be used to
+       * set the unicode_charmap.
+      */
+    }
+
+    /* Charmaps */
+    {
+      FT_CharMapRec  charmap;
+      FT_Bool        unicode_charmap = 0;
+
+      charmap.face        = FT_FACE( face );
+      charmap.encoding    = FT_ENCODING_NONE;
+      /* initial platform/encoding should indicate unset status? */
+      charmap.platform_id = TT_PLATFORM_APPLE_UNICODE;
+      charmap.encoding_id = TT_APPLE_ID_DEFAULT;
+
+      if( unicode_charmap )
+      {
+        /* Unicode Charmap */
+        charmap.encoding    = FT_ENCODING_UNICODE;
+        charmap.platform_id = TT_PLATFORM_MICROSOFT;
+        charmap.encoding_id = TT_MS_ID_UNICODE_CS;
+      }
+
+
+      error = FT_CMap_New( &pk_cmap_class, NULL, &charmap, NULL );
+
+      if ( error )
+        goto Exit;
+    }
+
+    if ( go->code_max < go->code_min )
+    {
+      FT_TRACE2(( "invalid number of glyphs\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+  Exit:
+    return error;
+
+  Fail:
+    PK_Face_Done( pkface );
+    return FT_THROW( Unknown_File_Format );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  PK_Size_Select(  FT_Size   size,
+                   FT_ULong  strike_index )
+  {
+    PK_Face     face  = (PK_Face)size->face;
+    PK_Glyph    go    = face->pk_glyph;
+    FT_UNUSED( strike_index );
+
+    FT_Select_Metrics( size->face, 0 );
+
+    size->metrics.ascender    = (go->font_bbx_h - go->font_bbx_yoff) * 64;
+    size->metrics.descender   = -go->font_bbx_yoff * 64;
+    size->metrics.max_advance = go->font_bbx_w * 64;
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  PK_Size_Request( FT_Size          size,
+                   FT_Size_Request  req )
+  {
+    PK_Face           face    = (PK_Face)size->face;
+    FT_Bitmap_Size*   bsize   = size->face->available_sizes;
+    FT_Error          error   = FT_ERR( Invalid_Pixel_Size );
+    FT_Long           height;
+
+
+    height = FT_REQUEST_HEIGHT( req );
+    height = ( height + 32 ) >> 6;
+
+    switch ( req->type )
+    {
+    case FT_SIZE_REQUEST_TYPE_NOMINAL:
+      if ( height == ( ( bsize->y_ppem + 32 ) >> 6 ) )
+        error = FT_Err_Ok;
+      break;
+
+    case FT_SIZE_REQUEST_TYPE_REAL_DIM:
+      if ( height == face->pk_glyph->font_bbx_h )
+        error = FT_Err_Ok;
+      break;
+
+    default:
+      error = FT_THROW( Unimplemented_Feature );
+      break;
+    }
+
+    if ( error )
+      return error;
+    else
+      return PK_Size_Select( size, 0 );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  PK_Glyph_Load(   FT_GlyphSlot  slot,
+                   FT_Size       size,
+                   FT_UInt       glyph_index,
+                   FT_Int32      load_flags )
+  {
+    PK_Face      pk     = (PK_Face)FT_SIZE_FACE( size );
+    FT_Face      face   = FT_FACE( pk );
+    FT_Error     error  = FT_Err_Ok;
+    FT_Bitmap*   bitmap = &slot->bitmap;
+    PK_Bitmap    bm;
+    PK_Glyph     go;
+
+    go = pk->pk_glyph;
+
+    FT_UNUSED( load_flags );
+
+    if ( !face )
+    {
+      error = FT_THROW( Invalid_Face_Handle );
+      goto Exit;
+    }
+
+    if ( !go                                         ||
+         glyph_index >= (FT_UInt)( face->num_glyphs ) )
+    {
+      error = FT_THROW( Invalid_Argument );
+      goto Exit;
+    }
+
+    FT_TRACE1(( "PK_Glyph_Load: glyph index %d\n", glyph_index ));
+
+    if ( !go->bm_table )
+    {
+      FT_TRACE2(( "invalid bitmap table\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+    /* slot, bitmap => freetype, bm => pklib */
+    bm = &pk->pk_glyph->bm_table[glyph_index];
+
+    bitmap->rows       = bm->bbx_height;
+    bitmap->width      = bm->bbx_width;
+    bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
+
+    if ( !bm->raster )
+    {
+      FT_TRACE2(( "invalid bitmap width\n" ));
+      error = FT_THROW( Invalid_File_Format );
+      goto Exit;
+    }
+
+    bitmap->pitch = (int)bm->raster ;
+
+    /* note: we don't allocate a new array to hold the bitmap; */
+    /*       we can simply point to it                         */
+    ft_glyphslot_set_bitmap( slot, bm->bitmap );
+
+    slot->format      = FT_GLYPH_FORMAT_BITMAP;
+    slot->bitmap_left = bm->off_x ;
+    slot->bitmap_top  = bm->off_y ;
+
+    slot->metrics.horiAdvance  = (FT_Pos) (bm->mv_x ) * 64;
+    slot->metrics.horiBearingX = (FT_Pos) (bm->off_x ) * 64;
+    slot->metrics.horiBearingY = (FT_Pos) (bm->bbx_height) * 64;
+    slot->metrics.width        = (FT_Pos) ( bitmap->width * 64 );
+    slot->metrics.height       = (FT_Pos) ( bitmap->rows * 64 );
+
+    ft_synthesize_vertical_metrics( &slot->metrics, bm->bbx_height * 64 );
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  TFM_Done_Metrics( FT_Memory     memory,
+                    TFM_FontInfo  fi )
+  {
+    FT_FREE(fi->width);
+    FT_FREE(fi->height);
+    FT_FREE(fi->depth);
+    FT_FREE( fi );
+  }
+
+
+  /* parse a TFM metrics file */
+  FT_LOCAL_DEF( FT_Error )
+  TFM_Read_Metrics( FT_Face    pk_face,
+                    FT_Stream  stream )
+  {
+    TFM_Service    tfm;
+    FT_Memory      memory  = stream->memory;
+    TFM_ParserRec  parser;
+    TFM_FontInfo   fi      = NULL;
+    FT_Error       error   = FT_ERR( Unknown_File_Format );
+    PK_Face        face    = (PK_Face)pk_face;
+    PK_Glyph       pk_glyph= face->pk_glyph;
+
+
+    if ( face->tfm_data )
+    {
+      FT_TRACE1(( "TFM_Read_Metrics:"
+                  " Freeing previously attached metrics data.\n" ));
+      TFM_Done_Metrics( memory, (TFM_FontInfo)face->tfm_data );
+
+      face->tfm_data = NULL;
+    }
+
+    if ( FT_NEW( fi ) )
+      goto Exit;
+
+    FT_TRACE4(( "TFM_Read_Metrics: Invoking TFM_Service.\n" ));
+
+    tfm = (TFM_Service)face->tfm;
+    if ( tfm->tfm_parser_funcs )
+    {
+      /* Initialise TFM Service */
+      error = tfm->tfm_parser_funcs->init( &parser,
+                                           memory,
+                                           stream );
+
+      if ( !error )
+      {
+        FT_TRACE4(( "TFM_Read_Metrics: Initialised tfm metric data.\n" ));
+        parser.FontInfo  = fi;
+        parser.user_data = pk_glyph;
+
+        error = tfm->tfm_parser_funcs->parse_metrics( &parser );
+        if( !error )
+          FT_TRACE4(( "TFM_Read_Metrics: parsing TFM metric information done.\n" ));
+
+        FT_TRACE6(( "TFM_Read_Metrics: TFM Metric Information:\n"
+                    "                  Check Sum  : %ld\n"
+                    "                  Design Size: %ld\n"
+                    "                  Begin Char : %d\n"
+                    "                  End Char   : %d\n"
+                    "                  font_bbx_w : %d\n"
+                    "                  font_bbx_h : %d\n"
+                    "                  slant      : %d\n", parser.FontInfo->cs, parser.FontInfo->design_size, parser.FontInfo->begin_char,
+                                                           parser.FontInfo->end_char, parser.FontInfo->font_bbx_w,
+                                                           parser.FontInfo->font_bbx_h, parser.FontInfo->slant ));
+        tfm->tfm_parser_funcs->done( &parser );
+      }
+    }
+
+    if ( !error )
+    {
+      /* Modify PK_Glyph data according to TFM metric values */
+
+      /*
+      face->pk_glyph->font_bbx_w = fi->font_bbx_w;
+      face->pk_glyph->font_bbx_h = fi->font_bbx_h;
+      */
+
+      face->tfm_data       = fi;
+    }
+
+  Exit:
+    if ( fi )
+      TFM_Done_Metrics( memory, fi );
+
+    return error;
+  }
+
+ /*
+  *
+  * SERVICES LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  pk_services[] =
+  {
+    { FT_SERVICE_ID_PK,          NULL },
+    { FT_SERVICE_ID_FONT_FORMAT, FT_FONT_FORMAT_PK },
+    { NULL, NULL }
+  };
+
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  pk_driver_requester( FT_Module    module,
+                        const char*  name )
+  {
+    FT_UNUSED( module );
+
+    return ft_service_list_lookup( pk_services, name );
+  }
+
+
+   FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  pk_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER         |
+      FT_MODULE_DRIVER_NO_OUTLINES,
+      sizeof ( FT_DriverRec ),
+
+      "pk",
+      0x10000L,
+      0x20000L,
+
+      NULL,    									/* module-specific interface */
+
+      NULL,                     /* FT_Module_Constructor  module_init   */
+      NULL,                     /* FT_Module_Destructor   module_done   */
+      pk_driver_requester       /* FT_Module_Requester    get_interface */
+    },
+
+    sizeof ( PK_FaceRec ),
+    sizeof ( FT_SizeRec ),
+    sizeof ( FT_GlyphSlotRec ),
+
+    PK_Face_Init,               /* FT_Face_InitFunc  init_face */
+    PK_Face_Done,               /* FT_Face_DoneFunc  done_face */
+    NULL,                       /* FT_Size_InitFunc  init_size */
+    NULL,                       /* FT_Size_DoneFunc  done_size */
+    NULL,                       /* FT_Slot_InitFunc  init_slot */
+    NULL,                       /* FT_Slot_DoneFunc  done_slot */
+
+    PK_Glyph_Load,              /* FT_Slot_LoadFunc  load_glyph */
+
+    NULL,                       /* FT_Face_GetKerningFunc   get_kerning  */
+    TFM_Read_Metrics,           /* FT_Face_AttachFunc       attach_file  */
+    NULL,                       /* FT_Face_GetAdvancesFunc  get_advances */
+
+    PK_Size_Request,           /* FT_Size_RequestFunc  request_size */
+    PK_Size_Select             /* FT_Size_SelectFunc   select_size  */
+  };
+
+
+/* END */

src/pk/pkdrivr.h

@@ -0,0 +1,83 @@
+/****************************************************************************
+ *
+ * pkdrivr.h
+ *
+ *   FreeType font driver for TeX's PK FONT files.
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#ifndef PKDRIVR_H_
+#define PKDRIVR_H_
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+#include "pk.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  PK_EncodingRec_
+  {
+    FT_Long   enc;
+    FT_UShort glyph;
+
+  } PK_EncodingRec, *PK_Encoding;
+
+  typedef struct PK_BitmapRec_
+  {
+    FT_Int          bbx_width, bbx_height;
+    FT_Int          off_x, off_y;
+    FT_Int          mv_x,  mv_y;
+    FT_Byte         *bitmap;
+    FT_UInt         raster;
+    FT_UShort       code;
+
+  } PK_BitmapRec, *PK_Bitmap;
+
+  typedef struct PK_GlyphRec_
+  {
+    FT_UInt         code_min, code_max;
+    PK_Bitmap       bm_table;
+    FT_Int          ds, hppp, vppp;
+    FT_UInt         font_bbx_w, font_bbx_h;
+    FT_UInt         font_bbx_xoff, font_bbx_yoff;
+
+    FT_ULong        nencodings;
+    PK_Encoding     encodings;
+
+    FT_ULong        nglyphs;
+
+  } PK_GlyphRec, *PK_Glyph;
+
+  typedef struct  PK_FaceRec_
+  {
+    FT_FaceRec      root;
+    PK_Glyph        pk_glyph;
+
+    const void*     tfm;
+    const void*     tfm_data;
+
+  } PK_FaceRec, *PK_Face;
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  pk_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* PKDRIVR_H_ */
+
+
+/* END */

src/pk/pkerror.h

@@ -0,0 +1,40 @@
+/****************************************************************************
+ *
+ * pkerror.h
+ *
+ *   FreeType font driver for TeX's PK FONT files.
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+  /**************************************************************************
+   *
+   * This file is used to define the PK error enumeration constants.
+   *
+   */
+
+#ifndef PKERROR_H_
+#define PKERROR_H_
+
+#include FT_MODULE_ERRORS_H
+
+#undef FTERRORS_H_
+
+#undef  FT_ERR_PREFIX
+#define FT_ERR_PREFIX  PK_Err_
+#define FT_ERR_BASE    FT_Mod_Err_PK
+
+#include FT_ERRORS_H
+
+#endif /* PKERROR_H_ */
+
+
+/* END */

src/pk/pklib.c

@@ -0,0 +1,597 @@
+/****************************************************************************
+ *
+ * pklib.c
+ *
+ *   FreeType font driver for TeX's PK FONT files.
+ *
+ * Copyright 1996-2018 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 <ft2build.h>
+
+#include FT_FREETYPE_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_SYSTEM_H
+#include FT_CONFIG_CONFIG_H
+#include FT_ERRORS_H
+#include FT_TYPES_H
+
+#include "pk.h"
+#include "pkdrivr.h"
+#include "pkerror.h"
+
+
+  /**************************************************************************
+   *
+   * The macro FT_COMPONENT is used in trace mode.  It is an implicit
+   * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
+   * messages during execution.
+   */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pklib
+
+FT_Byte  bits_table[] = {
+  0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+
+
+  /**************************************************************************
+   *
+   * PK font utility functions.
+   *
+   */
+
+  FT_Long   pk_read_intn( FT_Stream, FT_Int );
+  FT_ULong  pk_read_uintn( FT_Stream, FT_Int );
+
+#define READ_UINT1( stream )    (FT_Byte)pk_read_uintn( stream, 1)
+#define READ_UINT2( stream )    (FT_Byte)pk_read_uintn( stream, 2)
+#define READ_UINT3( stream )    (FT_Byte)pk_read_uintn( stream, 3)
+#define READ_UINT4( stream )    (FT_Byte)pk_read_uintn( stream, 4)
+#define READ_UINTN( stream,n)   (FT_ULong)pk_read_uintn( stream, n)
+#define READ_INT1( stream )     (FT_String)pk_read_intn( stream, 1)
+#define READ_INT2( stream )     (FT_String)pk_read_intn( stream, 2)
+#define READ_INT4( stream )     (FT_Long)pk_read_intn( stream, 4)
+
+/*
+ * Reading a Number from file
+ */
+  FT_ULong
+  pk_read_uintn(FT_Stream stream, FT_Int size)
+  {
+    FT_ULong  v,k;
+    FT_Error  error;
+    FT_Byte tp;
+    v = 0L;
+    while (size >= 1)
+    {
+      if ( FT_READ_BYTE(tp) )
+        return 0;
+      k =(FT_ULong)tp;
+      v = v*256L + k;
+      --size;
+    }
+    return v;
+  }
+
+  FT_Long
+  pk_read_intn(FT_Stream stream, FT_Int size)
+  {
+    FT_Long  v;
+    FT_Byte  tp;
+    FT_Error error;
+    FT_ULong z ;
+
+    if ( FT_READ_BYTE(tp) )
+        return 0;
+    z= (FT_ULong)tp;
+    v = (FT_Long)z & 0xffL;
+    if (v & 0x80L)
+      v = v - 256L;
+    --size;
+    while (size >= 1)
+    {
+      if ( FT_READ_BYTE(tp) )
+        return 0;
+      z= (FT_ULong)tp;
+      v = v*256L + z;
+      --size;
+		}
+    return v;
+  }
+
+  FT_Int  pk_read_nyble_rest_cnt;
+  FT_Int  pk_read_nyble_max_bytes;
+
+  void
+  pk_read_nyble_init( FT_Int max )
+  {
+    pk_read_nyble_rest_cnt  = 0;
+    pk_read_nyble_max_bytes = max;
+  }
+
+  FT_Int
+  pk_read_nyble(FT_Stream stream)
+  {
+    static FT_Byte  d;
+    FT_Int          v;
+
+    switch (pk_read_nyble_rest_cnt)
+    {
+    case 0:
+      d = READ_UINT1( stream );
+      if (--pk_read_nyble_max_bytes < 0)
+        return -1L;
+      v = d / 0x10;
+      d = d % 0x10;
+      pk_read_nyble_rest_cnt = 1;
+      break;
+    case 1:
+    default:
+      v = d;
+      pk_read_nyble_rest_cnt = 0;
+      break;
+    }
+  return v;
+  }
+
+  FT_Long
+  pk_read_packed_number(FT_Long* repeat, FT_Stream stream, int dyn_f)
+  {
+    FT_Int   d, n;
+    FT_Long  di;
+
+    entry:
+      d = pk_read_nyble( stream );
+      if (d == 0)
+      {
+        n = 0;
+        do
+        {
+          di = pk_read_nyble( stream );
+          n++;
+        }
+        while (di == 0);
+        for ( ; n > 0; n--)
+          di = di*16 + pk_read_nyble( stream );
+        return di - 15 + (13 - dyn_f)*16 + dyn_f;
+      }
+    if (d <= dyn_f)
+      return d;
+    if (d <= 13)
+      return (d - dyn_f - 1)*16 + pk_read_nyble( stream ) + dyn_f + 1;
+    *repeat = 1;
+    if (d == 14)
+      *repeat = pk_read_packed_number(repeat, stream, dyn_f);
+    goto entry;
+  }
+
+  FT_Int
+  pk_read_14( FT_Stream stream,
+              FT_ULong rs,
+              PK_Bitmap bm )
+  {
+    FT_Long   x, y, x8, xm;
+    FT_Byte   *bm_ptr;
+    FT_ULong  bit16_buff;
+    FT_Int    rest_bit16_buff;
+
+    static FT_UInt mask_table[] =
+      { 0xdead,   0x80,   0xc0,   0xe0,   0xf0,   0xf8,   0xfc,   0xfe, 0xdead };
+
+    if (rs == 0)
+      return 0;
+
+    x8 = bm->bbx_width / 8;
+    xm = bm->bbx_width % 8;
+    bm_ptr = bm->bitmap;
+
+    bit16_buff = READ_UINT1( stream ) << 8;
+    rest_bit16_buff = 8;
+    --rs;
+
+    for(y = 0; y < bm->bbx_height; y++)
+    {
+      for(x = 0; x < x8; x++)
+      {
+        *(bm_ptr++) = bit16_buff >> 8;
+        rest_bit16_buff -= 8;
+        bit16_buff = (bit16_buff << 8) & 0xffff;
+        if (rs > 0)
+        {
+	        bit16_buff |= (READ_UINT1( stream ) << (8 - rest_bit16_buff));
+	        rest_bit16_buff += 8;
+	        --rs;
+        }
+      }
+      if (xm != 0)
+      {
+        *(bm_ptr++) = (bit16_buff >> 8) & mask_table[xm];
+        rest_bit16_buff -= xm;
+        bit16_buff = (bit16_buff << xm) & 0xffff;
+        if (rest_bit16_buff < 8)
+        {
+	        if (rs > 0)
+	        {
+	          bit16_buff |= (READ_UINT1( stream ) << (8 - rest_bit16_buff));
+	          rest_bit16_buff += 8;
+	          --rs;
+	        }
+        }
+      }
+    }
+    return 0;
+  }
+
+  FT_Int
+  pk_read_n14( FT_Stream stream,
+               FT_Int dyn_f,
+               FT_Int bw,
+               FT_ULong rs,
+               PK_Bitmap bm )
+  {
+    FT_Long   x, y, xx, yy, repeat;
+    FT_Int    bits, b_p;
+    FT_Byte   *p, *p0, *p1;
+
+    pk_read_nyble_init(rs);
+    p    = bm->bitmap;
+    bw   = 1-bw;
+    bits = 0;
+    for (y = 0; y < bm->bbx_height; )
+    {
+      b_p    = 0;
+      repeat = 0;
+      p0     = p;
+      for (x = 0; x < bm->bbx_width; x++)
+      {
+        if (bits == 0)
+        {
+	        bw   = 1-bw;
+	        if ((bits = pk_read_packed_number(&repeat, stream, dyn_f)) < 0)
+	          return -1;
+        }
+        if (bw == 1)
+	        *p = *p | bits_table[b_p];
+        --bits;
+        if (++b_p >= 8)
+        {
+	        b_p = 0;
+	        p++;
+        }
+      }
+      if (b_p != 0)
+        p++;
+      y++;
+      for (yy = 0; yy < repeat; yy++)
+      {
+        p1 = p0;
+        for (xx = 0; xx < bm->raster; xx++)
+	        *(p++) = *(p1++);
+        y++;
+      }
+    }
+    return 0;
+  }
+
+  /**************************************************************************
+   *
+   * API.
+   *
+   */
+
+  FT_LOCAL_DEF( FT_Error )
+  pk_load_font(FT_Stream       stream,
+               FT_Memory       extmemory,
+               PK_Glyph        *goptr )
+  {
+    PK_Glyph   go;
+    FT_Byte    instr, pre, id;
+    FT_ULong   ds, check_sum, hppp, vppp, k;
+    FT_UInt    flag, dny_f, bw, ess, size;
+    FT_ULong   cc, tfm, dx, dy, dm, w, h, rs;
+    FT_Long    hoff, voff, mv_x, mv_y, gptr;
+    FT_Int     bc, ec, nchars, index, i;
+    FT_Error   error  = FT_Err_Ok;
+    FT_Memory  memory = extmemory; /* needed for FT_NEW */
+    PK_Encoding   encoding = NULL;
+
+    go = NULL;
+    nchars = -1;
+
+    if( FT_STREAM_SEEK( 0 ) )
+      goto Exit;
+
+    pre = READ_UINT1( stream );
+    if (pre != PK_PRE)
+    {
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    id = READ_UINT1( stream );
+    if (id != PK_ID)
+    {
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    k = READ_UINT1( stream );
+    if ( FT_STREAM_SKIP( k ) )
+      goto Exit;
+
+    ds        = READ_INT4( stream );
+    check_sum = READ_INT4( stream );
+    hppp      = READ_INT4( stream );
+    vppp      = READ_INT4( stream );
+
+    FT_TRACE2(( "pk_load_font: checksum is %ld\n",check_sum ));
+
+    gptr = stream->pos;
+
+    #if 0
+      /* read min & max char code */
+      bc = 256;
+      ec = -1;
+      for (;;)
+      {
+        instr = READ_UINT1( stream );
+        if (instr == PK_POST)
+        break;
+        switch ((int) instr)
+        {
+          case PK_XXX1:  k = (FT_ULong)READ_UINT1( stream ); if ( FT_STREAM_SKIP( k ) ) goto Exit; break;
+          case PK_XXX2:  k = (FT_ULong)READ_UINT2( stream ); if ( FT_STREAM_SKIP( k ) ) goto Exit; break;
+          case PK_XXX3:  k = (FT_ULong)READ_UINT3( stream ); if ( FT_STREAM_SKIP( k ) ) goto Exit; break;
+          case PK_XXX4:  k = (FT_ULong)READ_UINT4( stream ); if ( FT_STREAM_SKIP( k ) ) goto Exit; break;
+          case PK_YYY:   if ( FT_STREAM_SKIP( 4 ) ) goto Exit; break;
+          case PK_NO_OP: break;
+          default:
+            size  = instr & 0x3; instr >>= 2;
+            ess   = instr & 0x1;
+          if (ess == 0)
+          {                          /* short */
+	          rs = (FT_ULong)(size*256) + (FT_ULong)READ_UINT1( stream );
+	          cc   = (FT_ULong)READ_UINT1( stream );
+          }
+          else if ((ess == 1) && (size != 3))
+          {                          /* extended short */
+	          rs = (FT_ULong)(size*65536) + (FT_ULong)READ_UINT2( stream );
+	          cc   = (FT_ULong)READ_UINT1( stream );
+          }
+          else
+          {                          /* standard */
+	          rs   = READ_UINT4( stream );
+	          cc   = (FT_ULong)READ_UINT4( stream );
+          }
+          if ( FT_STREAM_SKIP( rs ) )
+            goto Exit;
+          if (cc < bc)
+	          bc = cc;
+          if (cc > ec)
+	          ec = cc;
+          break;
+        }
+      }
+    #else
+      bc = 0;
+      ec = 255;
+    #endif
+
+    nchars    = ec - bc + 1;
+    if( FT_ALLOC(go, sizeof(PK_GlyphRec)) )
+      goto Exit;
+
+    if( FT_ALLOC_MULT(go->bm_table, sizeof(PK_BitmapRec), nchars) )
+      goto Exit;
+
+    if ( FT_NEW_ARRAY( encoding, nchars ) )
+      return error;
+
+    go->ds   = (FT_UInt)ds/(1<<20);
+    go->hppp = (FT_UInt)hppp/(1<<16);
+    go->vppp = (FT_UInt)vppp/(1<<16);
+    go->font_bbx_w = 0;
+    go->font_bbx_h = 0;
+    go->font_bbx_xoff = 0;
+    go->font_bbx_yoff = 0;
+    go->code_min = bc;
+    go->code_max = ec;
+
+    /* read glyphs */
+    if( FT_STREAM_SEEK( gptr ) )
+        goto Exit;
+
+    index = 0;
+    go->nglyphs = 0;
+    for (;;)
+    {
+      if ((instr = READ_UINT1( stream )) == PK_POST)
+        break;
+      switch ((FT_Int)instr)
+      {
+        case PK_XXX1:
+          k = (FT_ULong)READ_UINT1( stream );
+          if ( FT_STREAM_SKIP( k ) )
+            goto Exit;
+          break;
+        case PK_XXX2:
+          k = (FT_ULong)READ_UINT2( stream );
+          if ( FT_STREAM_SKIP( k ) )
+            goto Exit;
+          break;
+        case PK_XXX3:
+          k = (FT_ULong)READ_UINT3( stream );
+          if ( FT_STREAM_SKIP( k ) )
+            goto Exit;
+          break;
+        case PK_XXX4:
+          k = (FT_ULong)READ_UINT4( stream );
+          if ( FT_STREAM_SKIP( k ) )
+            goto Exit;
+          break;
+        case PK_YYY:
+          if ( FT_STREAM_SKIP( 4 ) )
+            goto Exit;
+          break;
+        case PK_NO_OP:
+          break;
+        default:
+          flag  = instr;
+          size  = flag % 0x04;  flag = flag >> 2;
+          ess   = flag % 0x02;  flag = flag >> 1;
+          bw    = flag % 0x02;  flag = flag >> 1;
+          dny_f = flag % 0x10;
+        if (ess == 0)
+        {                          /* short */
+          rs   = (FT_ULong)(size*256) + (FT_ULong)READ_UINT1( stream ) - (FT_ULong)8;
+          cc   = (FT_ULong)READ_UINT1( stream );
+          tfm  = (FT_ULong)READ_UINT3( stream );
+          dm   = (FT_ULong)READ_UINT1( stream );
+          w    = (FT_ULong)READ_UINT1( stream );
+          h    = (FT_ULong)READ_UINT1( stream );
+          hoff = (FT_Long)READ_INT1( stream );
+          voff = (FT_Long)READ_INT1( stream );
+          mv_x = dm;
+          mv_y = 0;
+        }
+        else if ((ess == 1) && (size != 3))
+        {                          /* extended short */
+          rs   = (FT_ULong)(size*65536) + (FT_ULong)READ_UINT2( stream ) - (FT_ULong)13;
+          cc   = (FT_ULong)READ_UINT1( stream );
+          tfm  = (FT_ULong)READ_UINT3( stream );
+          dm   = (FT_ULong)READ_UINT2( stream );
+          w    = (FT_ULong)READ_UINT2( stream );
+          h    = (FT_ULong)READ_UINT2( stream );
+          hoff = (FT_Long)READ_INT2( stream );
+          voff = (FT_Long)READ_INT2( stream );
+          mv_x = dm;
+          mv_y = 0;
+        }
+        else
+        {                           /* standard */
+          rs   = READ_UINT4( stream ) - (FT_ULong)28;
+          cc   = READ_UINT4( stream );
+          tfm  = READ_UINT4( stream );
+          dx   = READ_UINT4( stream );
+          dy   = READ_UINT4( stream );
+	        w    = READ_UINT4( stream );
+          h    = READ_UINT4( stream );
+          hoff = READ_INT4( stream );
+          voff = READ_INT4( stream );
+          mv_x = (FT_UInt)dx/(FT_UInt)(1<<16);
+          mv_y = (FT_UInt)dy/(FT_UInt)(1<<16);
+        }
+
+        if ((cc < go->code_min) || (go->code_max < cc))
+        {
+          error = FT_THROW( Invalid_File_Format );
+          goto Exit;
+        }
+
+        go->bm_table[index].bbx_width  = w;
+        go->bm_table[index].bbx_height = h;
+        go->bm_table[index].raster = (w+7)/8;
+        go->bm_table[index].off_x  = -hoff;
+        go->bm_table[index].off_y  = voff;
+        go->bm_table[index].mv_x   = mv_x;
+        go->bm_table[index].mv_y   = mv_y;
+        go->bm_table[index].bitmap = (unsigned char*)malloc(h*((w+7)/8));
+        go->bm_table[index].code   = cc ; /* For backward compatibility */
+        go->nglyphs               += 1;
+
+        encoding[index].enc   = cc ;
+        encoding[index].glyph = index;
+
+
+        if (go->bm_table[index].bitmap == NULL)
+        {
+          error = FT_THROW( Invalid_File_Format );
+          goto Exit;
+        }
+
+        memset(go->bm_table[index].bitmap, 0, h*((w+7)/8));
+
+        if (dny_f == 14)
+        {
+          if ( pk_read_14(stream, rs, &(go->bm_table[index]) ) < 0)
+          {
+            FT_ERROR(( "pk_load_font: error in `pk_read_14'\n" ));
+            error = FT_THROW( Unknown_File_Format );
+            goto Exit;
+          }
+        }
+        else
+        {
+          if (pk_read_n14(stream, dny_f, bw, rs, &(go->bm_table[index]) ) < 0)
+          {
+            FT_ERROR(( "pk_load_font: error in `pk_read_n14'\n" ));
+            error = FT_THROW( Unknown_File_Format );
+            goto Exit;
+          }
+        }
+        if (go->font_bbx_w < w)
+          go->font_bbx_w = w;
+        if (go->font_bbx_h < h)
+          go->font_bbx_h = h;
+        if (go->font_bbx_xoff > -hoff)
+          go->font_bbx_xoff = -hoff;
+        if (go->font_bbx_yoff > (voff - h))
+          go->font_bbx_yoff = (voff - h);
+
+        index++;
+      }
+    }
+
+    go->nencodings = go->nglyphs;
+    go->encodings  = encoding;
+
+    *goptr          = go;
+    return error;
+
+    Exit:
+      if (go != NULL)
+      {
+        for (i = 0; i < nchars; i++)
+        {
+          if (go->bm_table[i].bitmap != NULL)
+           FT_FREE(go->bm_table[i].bitmap);
+        }
+        FT_FREE(go->bm_table);
+        FT_FREE(go);
+      }
+      return error;
+  }
+
+  FT_LOCAL_DEF( void )
+  pk_free_font( PK_Face face )
+  {
+    FT_Memory  memory = FT_FACE( face )->memory;
+    PK_Glyph   go     = face->pk_glyph;
+    FT_UInt    nchars = FT_FACE( face )->num_glyphs,i;
+
+    if ( !go )
+      return;
+
+    if( go->bm_table )
+    {
+      for (i = 0; i < nchars; i++)
+      {
+        if (go->bm_table[i].bitmap != NULL)
+          FT_FREE(go->bm_table[i].bitmap);
+       }
+    }
+    FT_FREE(go->bm_table);
+    FT_FREE(go);
+  }
+
+/* END */

src/pk/rules.mk

@@ -0,0 +1,70 @@
+#
+# FreeType 2 PK driver configuration rules
+#
+
+
+# Copyright 1996-2018 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.
+
+
+# pk driver directory
+#
+PK_DIR := $(SRC_DIR)/pk
+
+
+PK_COMPILE := $(CC) $(ANSIFLAGS)                            \
+                     $I$(subst /,$(COMPILER_SEP),$(PK_DIR)) \
+                     $(INCLUDE_FLAGS)                        \
+                     $(FT_CFLAGS)
+
+
+# pk driver sources (i.e., C files)
+#
+PK_DRV_SRC :=  $(PK_DIR)/pklib.c \
+               $(PK_DIR)/pkdrivr.c
+
+
+# pk driver headers
+#
+PK_DRV_H :=  $(PK_DIR)/pk.h \
+             $(PK_DIR)/pkdrivr.h \
+             $(PK_DIR)/pkerror.h
+
+# pk driver object(s)
+#
+#   PK_DRV_OBJ_M is used during `multi' builds
+#   PK_DRV_OBJ_S is used during `single' builds
+#
+PK_DRV_OBJ_M := $(PK_DRV_SRC:$(PK_DIR)/%.c=$(OBJ_DIR)/%.$O)
+PK_DRV_OBJ_S := $(OBJ_DIR)/pk.$O
+
+# pk driver source file for single build
+#
+PK_DRV_SRC_S := $(PK_DIR)/pk.c
+
+
+# pk driver - single object
+#
+$(PK_DRV_OBJ_S): $(PK_DRV_SRC_S) $(PK_DRV_SRC) $(FREETYPE_H) $(PK_DRV_H)
+	$(PK_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(PK_DRV_SRC_S))
+
+
+# pk driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(PK_DIR)/%.c $(FREETYPE_H) $(PK_DRV_H)
+	$(PK_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(PK_DRV_OBJ_S)
+DRV_OBJS_M += $(PK_DRV_OBJ_M)
+
+
+# EOF

src/tfm/Jamfile

@@ -0,0 +1,30 @@
+# FreeType 2 src/tfm Jamfile
+#
+# Copyright 2001-2018 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.
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) tfm ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = tfmmod
+               ;
+  }
+  else
+  {
+    _sources = tfm ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/tfm Jamfile

src/tfm/module.mk

@@ -0,0 +1,23 @@
+#
+# FreeType 2 TFM module definition
+#
+
+
+# Copyright 1996-2018 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.
+
+
+FTMODULE_H_COMMANDS += TFM_MODULE
+
+define TFM_MODULE
+$(OPEN_DRIVER) FT_Module_Class, tfm_module_class $(CLOSE_DRIVER)
+$(ECHO_DRIVER)tfm       $(ECHO_DRIVER_DESC)TFM helper module$(ECHO_DRIVER_DONE)
+endef
+
+# EOF

src/tfm/rules.mk

@@ -0,0 +1,72 @@
+#
+# FreeType 2 TFM driver configuration rules
+#
+
+
+# Copyright 1996-2018 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.
+
+
+# TFM driver directory
+#
+TFM_DIR := $(SRC_DIR)/tfm
+
+
+# compilation flags for the driver
+#
+TFM_COMPILE := $(CC) $(ANSIFLAGS)                              \
+                       $I$(subst /,$(COMPILER_SEP),$(TFM_DIR)) \
+                       $(INCLUDE_FLAGS)                          \
+                       $(FT_CFLAGS)
+
+
+# TFM driver sources (i.e., C files)
+#
+TFM_DRV_SRC := $(TFM_DIR)/tfmmod.c   \
+               $(TFM_DIR)/tfmobjs.c   \
+
+# TFM driver headers
+#
+TFM_DRV_H := $(TFM_DRV_SRC:%c=%h)  \
+               $(TFM_DIR)/tfmerr.h \
+
+
+# TFM driver object(s)
+#
+#   TFM_DRV_OBJ_M is used during `multi' builds.
+#   TFM_DRV_OBJ_S is used during `single' builds.
+#
+TFM_DRV_OBJ_M := $(TFM_DRV_SRC:$(TFM_DIR)/%.c=$(OBJ_DIR)/%.$O)
+TFM_DRV_OBJ_S := $(OBJ_DIR)/tfm.$O
+
+# TFM driver source file for single build
+#
+TFM_DRV_SRC_S := $(TFM_DIR)/tfm.c
+
+
+# TFM driver - single object
+#
+$(TFM_DRV_OBJ_S): $(TFM_DRV_SRC_S) $(TFM_DRV_SRC) \
+                   $(FREETYPE_H) $(TFM_DRV_H)
+	$(TFM_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(TFM_DRV_SRC_S))
+
+
+# TFM driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(TFM_DIR)/%.c $(FREETYPE_H) $(TFM_DRV_H)
+	$(TFM_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(TFM_DRV_OBJ_S)
+DRV_OBJS_M += $(TFM_DRV_OBJ_M)
+
+
+# EOF

src/tfm/tfm.c

@@ -0,0 +1,26 @@
+/****************************************************************************
+ *
+ * tfm.c
+ *
+ *   FreeType auxiliary TFM module.
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+#include <ft2build.h>
+
+#include "tfmmod.c"
+#include "tfmobjs.c"
+
+
+/* END */

src/tfm/tfmerr.h

@@ -0,0 +1,42 @@
+/****************************************************************************
+ *
+ * tfmerr.h
+ *
+ *   FreeType auxiliary TFM module error codes (specification only).
+ *
+ * Copyright 2001-2018 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.
+ *
+ */
+
+
+  /**************************************************************************
+   *
+   * This file is used to define the TFM auxiliary module error enumeration
+   * constants.
+   *
+   */
+
+#ifndef TFMERR_H_
+#define TFMERR_H_
+
+#include FT_MODULE_ERRORS_H
+
+#undef FTERRORS_H_
+
+#undef  FT_ERR_PREFIX
+#define FT_ERR_PREFIX  TFM_Err_
+#define FT_ERR_BASE    FT_Mod_Err_TFM
+
+#include FT_ERRORS_H
+
+#endif /* TFMERR_H_ */
+
+
+/* END */

src/tfm/tfmmod.c

@@ -0,0 +1,55 @@
+/****************************************************************************
+ *
+ * tfmmod.c
+ *
+ *   FreeType auxiliary TFM module.
+ *
+ * Copyright 2000-2018 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 <ft2build.h>
+#include "tfmmod.h"
+#include "tfmobjs.h"
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TFM_Parser_FuncsRec  tfm_parser_funcs =
+  {
+    tfm_init,           /* init          */
+    tfm_parse_metrics,  /* parse metrics */
+    tfm_close,          /* done          */
+  };
+
+  static
+  const TFM_Interface  tfm_interface =
+  {
+    &tfm_parser_funcs,
+  };
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Module_Class  tfm_module_class =
+  {
+    0,
+    sizeof ( FT_ModuleRec ),
+    "tfm",
+    0x20000L,
+    0x20000L,
+
+    &tfm_interface,   /* module-specific interface */
+
+    (FT_Module_Constructor)NULL,  /* module_init   */
+    (FT_Module_Destructor) NULL,  /* module_done   */
+    (FT_Module_Requester)  NULL   /* get_interface */
+  };
+
+
+/* END */

src/tfm/tfmmod.h

@@ -0,0 +1,39 @@
+/****************************************************************************
+ *
+ * tfmmod.h
+ *
+ *   FreeType auxiliary TFM module.
+ *
+ * Copyright 2000-2018 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.
+ *
+ */
+
+
+#ifndef TFMMOD_H_
+#define TFMMOD_H_
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+
+#include FT_INTERNAL_TFM_H
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Module_Class )  tfm_driver_class;
+
+
+FT_END_HEADER
+
+#endif /* TFMMOD_H_ */
+
+
+/* END */

src/tfm/tfmobjs.c

@@ -0,0 +1,356 @@
+/****************************************************************************
+ *
+ * tfmobjs.c
+ *
+ *   FreeType auxiliary TFM module.
+ *
+ * Copyright 1996-2018 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 <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_TFM_H
+
+#include "tfmobjs.h"
+#include "tfmmod.h"
+#include "tfmerr.h"
+
+
+
+
+
+  /**************************************************************************
+   *
+   * The macro FT_COMPONENT is used in trace mode.  It is an implicit
+   * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
+   * messages during execution.
+   */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_tfmobjs
+
+   /**************************************************************************
+   *
+   * Global TFM parameters.
+   *
+   */
+#define tfm_size  30000 /* maximum length of tfm data, in bytes */
+#define lig_size  5000  /* maximum length of lig kern program, in words */
+#define hash_size 5003
+
+  /**************************************************************************
+   *
+   * TFM font utility functions.
+   *
+   */
+
+  long           tfm_read_intn(FT_Stream,int);
+  unsigned long  tfm_read_uintn(FT_Stream,int);
+
+#define READ_UINT1( stream )    (FT_ULong)tfm_read_uintn( stream, 1)
+#define READ_UINT2( stream )    (FT_ULong)tfm_read_uintn( stream, 2)
+#define READ_UINT4( stream )    (FT_ULong)tfm_read_uintn( stream, 4)
+#define READ_INT4( stream )     (FT_Long)tfm_read_intn( stream, 4)
+
+/*
+ * Reading a Number from file
+ */
+  unsigned long
+  tfm_read_uintn(FT_Stream stream, int size)
+  {
+    unsigned long  v,k;
+    FT_Error error = FT_Err_Ok;
+    FT_Byte tp;
+    v = 0L;
+    while (size >= 1)
+    {
+      if ( FT_READ_BYTE(tp) )
+        return 0;
+      k =(unsigned long)tp;
+      v = v*256L + k;
+      --size;
+    }
+    return v;
+  }
+
+  long
+  tfm_read_intn(FT_Stream stream, int size)
+  {
+    long           v;
+    FT_Byte tp;
+    FT_Error error= FT_Err_Ok;
+    unsigned long z ;
+    if ( FT_READ_BYTE(tp) )
+        return 0;
+    z= (unsigned long)tp;
+    v = (long)z & 0xffL;
+    if (v & 0x80L)
+      v = v - 256L;
+    --size;
+    while (size >= 1)
+    {
+      if ( FT_READ_BYTE(tp) )
+        return 0;
+      z= (unsigned long)tp;
+      v = v*256L + z;
+      --size;
+		}
+    return v;
+  }
+
+  /**************************************************************************
+   *
+   * API.
+   *
+   */
+
+  FT_LOCAL_DEF( FT_Error )
+  tfm_init( TFM_Parser  parser,
+            FT_Memory   memory,
+            FT_Stream   stream )
+  {
+    parser->memory    = memory;
+    parser->stream    = stream;
+    parser->FontInfo  = NULL;
+    parser->user_data = NULL;
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_LOCAL( void )
+  tfm_close( TFM_Parser  parser )
+  {
+    FT_UNUSED( parser );
+
+    /* nothing */
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  tfm_parse_metrics( TFM_Parser  parser )
+  {
+    FT_Memory     memory = parser->memory;
+    TFM_FontInfo  fi     = parser->FontInfo;
+    FT_Stream     stream = parser->stream;
+    FT_Error      error  = FT_ERR( Syntax_Error );
+
+    FT_ULong      lf, lh, nc, nci;
+    FT_ULong      offset_char_info, offset_param;
+    FT_ULong      nw, nh, nd, ni, nl, nk, ne, np, bc, ec;
+
+    FT_Long       *w,  *h,  *d;
+    FT_ULong      *ci, v;
+
+    FT_ULong      i;
+    FT_Long       bbxw, bbxh, xoff, yoff;
+
+    if ( !fi )
+      return FT_THROW( Invalid_Argument );
+
+    fi->width  = NULL;
+    fi->height = NULL;
+    fi->depth  = NULL;
+    ci         = NULL;
+    w          = NULL;
+    h          = NULL;
+    d          = NULL;
+
+    fi->font_bbx_w = 0.0;
+    fi->font_bbx_h = 0.0;
+    fi->font_bbx_xoff = 0.0;
+    fi->font_bbx_yoff = 0.0;
+
+    if( FT_STREAM_SEEK( 0 ) )
+      return error;
+
+    /* Checking the correctness of the TFM file */
+    if( READ_UINT1( stream ) > 127 )
+    {
+      FT_ERROR(( "Malformed TFM file: The first byte of the input file exceeds 127!\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    if( FT_STREAM_SEEK( 0 ) )
+      return error;
+
+    lf  = READ_UINT2( stream );
+    lh  = READ_UINT2( stream );
+    bc  = READ_UINT2( stream );
+    ec  = READ_UINT2( stream );
+    nw  = READ_UINT2( stream );
+    nh  = READ_UINT2( stream );
+    nd  = READ_UINT2( stream );
+    ni  = READ_UINT2( stream );
+    nl  = READ_UINT2( stream );
+    nk  = READ_UINT2( stream );
+    ne  = READ_UINT2( stream );
+    np  = READ_UINT2( stream );
+
+    /* Uncomment this to check for the tfm file's header info if this program returns malformed tfm file */
+    /*
+    FT_TRACE6(( "tfm_parse_metrics: First 24 bytes in the tfm file:\n"
+                    "                  lf : %ld\n"
+                    "                  lh : %ld\n"
+                    "                  bc : %d\n"
+                    "                  ec : %d\n"
+                    "                  nw : %d\n"
+                    "                  nh : %d\n"
+                    "                  nd : %d\n"
+                    "                  ni : %d\n"
+                    "                  nl : %d\n"
+                    "                  nk : %d\n"
+                    "                  ne : %d\n"
+                    "                  np : %d\n", lf, lh, bc, ec, nw, nh, nd, ni, nl, nk, ne, np ));
+    */
+
+    if( lf == 0 || ((4*lf) - 1) > tfm_size)
+    {
+      FT_ERROR(( "Malformed TFM file: The file claims to have length zero, but that's impossible!\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    if(lh < 2)
+    {
+      FT_ERROR(( "Malformed TFM file: The header length is only %ld\n",lh ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    if( nl > lig_size )
+    {
+      FT_ERROR(( "Malformed TFM file: The lig/kern program is longer than I can handle!\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    if( ne > 256 )
+    {
+      FT_ERROR(( "Malformed TFM file: There are %ld extensible recipes!\n",ne ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    if ( ((signed)(fi->begin_char-1) > (signed)fi->end_char) ||
+       ( fi->end_char > 255) ||
+       ( ne > 256 ) )
+    {
+      FT_ERROR(( "tfm_parse_metrics: Incorrect header information in `tfm' file.\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    if ( lf != 6 + lh + (ec - bc + 1) + nw + nh + nd + ni + nl + nk + ne + np )
+    {
+      FT_ERROR(( "tfm_parse_metrics: Incorrect header information in `tfm' file.\n" ));
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    fi->begin_char  = bc;
+    fi->end_char    = ec;
+    fi->cs          = READ_INT4( stream ); /* Check Sum  */
+    fi->ds          = READ_INT4( stream ); /* Design Size */
+    fi->design_size = (FT_ULong)((double)(fi->ds)/(double)(1<<20));
+
+    if( fi->cs <= 0 )
+    {
+      error = FT_THROW( Unknown_File_Format );
+      goto Exit;
+    }
+
+    nc  = fi->end_char - fi->begin_char + 1;
+    nci = nc;
+
+    ci = (FT_ULong*)calloc(nci, sizeof(FT_ULong));
+    w  = (FT_Long*)calloc(nw,  sizeof(FT_ULong));
+    h  = (FT_Long*)calloc(nh,  sizeof(FT_ULong));
+    d  = (FT_Long*)calloc(nd,  sizeof(FT_ULong));
+
+    if ((ci == NULL) || (w == NULL) || (h == NULL) || (d == NULL))
+    {
+      error = FT_THROW( Invalid_Argument );
+      goto Exit;
+    }
+
+    offset_char_info = 4*(6+lh);
+    if( FT_STREAM_SEEK( offset_char_info ) ) /* Skip over coding scheme and font family name */
+      goto Exit;
+
+    for (i = 0; i < nci; i++)
+      ci[i] = READ_UINT4( stream );
+
+    offset_param = stream->pos + 4*(nw + nh + nd + ni + nl + nk + ne);
+
+    for (i = 0; i < nw; i++)
+      w[i] = READ_INT4( stream );
+    for (i = 0; i < nh; i++)
+      h[i] = READ_INT4( stream );
+    for (i = 0; i < nd; i++)
+      d[i] = READ_INT4( stream );
+
+    fi->width  = (FT_Long*)calloc(nc, sizeof(FT_Long));
+    fi->height = (FT_Long*)calloc(nc, sizeof(FT_Long));
+    fi->depth  = (FT_Long*)calloc(nc, sizeof(FT_Long));
+
+    if ((fi->width == NULL) || (fi->height == NULL) || (fi->depth == NULL))
+    {
+      error = FT_THROW( Invalid_Argument );
+      goto Exit;
+    }
+
+    bbxw = 0;
+    bbxh = 0;
+    xoff = 0;
+    yoff = 0;
+
+    for (i = 0; i < nc; i++)
+    {
+      v = ci[i] / 0x10000L;
+      fi->depth[i]  = d[v & 0xf];  v >>= 4;
+      fi->height[i] = h[v & 0xf];  v >>= 4;
+      fi->width[i]  = w[v & 0xff];
+
+      if (bbxw < fi->width[i])
+	      bbxw = fi->width[i];
+
+      if (bbxh < (fi->height[i] + fi->depth[i]))
+	      bbxh = fi->height[i] + fi->depth[i];
+
+      if (yoff > -fi->depth[i])
+	      yoff = -fi->depth[i];
+    }
+
+    fi->font_bbx_w = (FT_ULong)(fi->design_size * ((double)bbxw / (double)(1<<20)));
+    fi->font_bbx_h = (FT_ULong)(fi->design_size * ((FT_ULong)bbxh / (double)(1<<20)));
+    fi->font_bbx_xoff = (FT_ULong)(fi->design_size * ((double)xoff / (double)(1<<20)));
+    fi->font_bbx_yoff = (FT_ULong)(fi->design_size * ((double)yoff / (double)(1<<20)));
+
+    if( FT_STREAM_SEEK( offset_param ) )
+      return error;
+    if (FT_READ_ULONG(fi->slant) )
+      return error;
+    fi->slant = (FT_ULong)((double)fi->slant/(double)(1<<20));
+
+  Exit:
+    FT_FREE(ci);
+    FT_FREE(w);
+    FT_FREE(h);
+    FT_FREE(d);
+    return error;
+  }
+
+
+/* END */

src/tfm/tfmobjs.h

@@ -0,0 +1,53 @@
+/****************************************************************************
+ *
+ * tfmobjs.h
+ *
+ *   FreeType auxiliary TFM module.
+ *
+ * Copyright 1996-2018 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.
+ *
+ */
+
+
+#ifndef TFMOBJS_H_
+#define TFMOBJS_H_
+
+#include <ft2build.h>
+#include "tfmmod.h"
+
+FT_BEGIN_HEADER
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_TFM_H
+
+
+FT_BEGIN_HEADER
+
+  /* Initialise the TFM stream */
+  FT_LOCAL( FT_Error )
+  tfm_init( TFM_Parser  parser,
+            FT_Memory   memory,
+            FT_Stream   stream );
+
+  /* Parse TFM metric data */
+  FT_LOCAL( FT_Error )
+  tfm_parse_metrics( TFM_Parser  parser );
+
+  FT_LOCAL( void )
+  tfm_close( TFM_Parser  parser );
+
+
+FT_END_HEADER
+
+#endif /* TFMOBJS_H_ */
+
+
+/* END */