346 files changed, 124102 insertions, 0 deletions

diff --git a/nx-X11/extras/freetype2/src/Jamfile b/nx-X11/extras/freetype2/src/Jamfile
new file mode 100644
index 000000000..e4d357569
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/Jamfile
@@ -0,0 +1,17 @@
+# FreeType 2 src Jamfile (c) 2001, 2002 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) ;
+
+# The file <freetype/internal/internal.h> is used to define macros that are
+# later used in #include statements.  It needs to be parsed in order to
+# record these definitions.
+#
+HDRMACRO  [ FT2_SubDir $(FT2_INCLUDE_DIR) internal internal.h ] ;
+
+for xx in $(FT2_COMPONENTS)
+{
+  SubInclude FT2_TOP $(FT2_SRC_DIR) $(xx) ;
+}
+
+# end of src Jamfile
diff --git a/nx-X11/extras/freetype2/src/autofit/Jamfile b/nx-X11/extras/freetype2/src/autofit/Jamfile
new file mode 100644
index 000000000..3063f2371
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/Jamfile
@@ -0,0 +1,18 @@
+SubDir FT2_TOP src autofit ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = afangles afglobal afhints aflatin afloader afmodule afdummy ;
+  }
+  else
+  {
+    _sources = autofit ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/autofir Jamfile
diff --git a/nx-X11/extras/freetype2/src/autofit/afangles.c b/nx-X11/extras/freetype2/src/autofit/afangles.c
new file mode 100644
index 000000000..e42c962d1
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afangles.c
@@ -0,0 +1,302 @@
+#include "aftypes.h"
+
+/*
+ * a python script used to generate the following table
+ *
+
+import sys, math
+
+units  = 256
+scale  = units/math.pi
+comma  = ""
+
+print ""
+print "table of arctan( 1/2^n ) for PI = " + repr(units/65536.0) + " units"
+
+r = [-1] + range(32)
+
+for n in r:
+
+    if n >= 0:
+        x = 1.0/(2.0**n)    # tangent value
+    else:
+        x = 2.0**(-n)
+
+    angle  = math.atan(x)    # arctangent
+    angle2 = angle*scale     # arctangent in FT_Angle units
+
+    # determine which integer value for angle gives the best tangent
+    lo  = int(angle2)
+    hi  = lo + 1
+    tlo = math.tan(lo/scale)
+    thi = math.tan(hi/scale)
+
+    errlo = abs( tlo - x )
+    errhi = abs( thi - x )
+
+    angle2 = hi
+    if errlo < errhi:
+        angle2 = lo
+
+    if angle2 <= 0:
+        break
+
+    sys.stdout.write( comma + repr( int(angle2) ) )
+    comma = ", "
+
+*
+* end of python script
+*/
+
+
+  /* this table was generated for AF_ANGLE_PI = 256 */
+#define AF_ANGLE_MAX_ITERS  8
+#define AF_TRIG_MAX_ITERS   8
+
+  static const FT_Fixed
+  af_angle_arctan_table[9] =
+  {
+    90, 64, 38, 20, 10, 5, 3, 1, 1
+  };
+
+
+  static FT_Int
+  af_angle_prenorm( FT_Vector*  vec )
+  {
+    FT_Fixed  x, y, z;
+    FT_Int    shift;
+
+
+    x = vec->x;
+    y = vec->y;
+
+    z     = ( ( x >= 0 ) ? x : - x ) | ( (y >= 0) ? y : -y );
+    shift = 0;
+
+    if ( z < ( 1L << 27 ) )
+    {
+      do
+      {
+        shift++;
+        z <<= 1;
+      } while ( z < ( 1L << 27 ) );
+
+      vec->x = x << shift;
+      vec->y = y << shift;
+    }
+    else if ( z > ( 1L << 28 ) )
+    {
+      do
+      {
+        shift++;
+        z >>= 1;
+      } while ( z > ( 1L << 28 ) );
+
+      vec->x = x >> shift;
+      vec->y = y >> shift;
+      shift  = -shift;
+    }
+    return shift;
+  }
+
+
+  static void
+  af_angle_pseudo_polarize( FT_Vector*  vec )
+  {
+    FT_Fixed         theta;
+    FT_Fixed         yi, i;
+    FT_Fixed         x, y;
+    const FT_Fixed  *arctanptr;
+
+
+    x = vec->x;
+    y = vec->y;
+
+    /* Get the vector into the right half plane */
+    theta = 0;
+    if ( x < 0 )
+    {
+      x = -x;
+      y = -y;
+      theta = AF_ANGLE_PI;
+    }
+
+    if ( y > 0 )
+      theta = - theta;
+
+    arctanptr = af_angle_arctan_table;
+
+    if ( y < 0 )
+    {
+      /* Rotate positive */
+      yi     = y + ( x << 1 );
+      x      = x - ( y << 1 );
+      y      = yi;
+      theta -= *arctanptr++;  /* Subtract angle */
+    }
+    else
+    {
+      /* Rotate negative */
+      yi     = y - ( x << 1 );
+      x      = x + ( y << 1 );
+      y      = yi;
+      theta += *arctanptr++;  /* Add angle */
+    }
+
+    i = 0;
+    do
+    {
+      if ( y < 0 )
+      {
+        /* Rotate positive */
+        yi     = y + ( x >> i );
+        x      = x - ( y >> i );
+        y      = yi;
+        theta -= *arctanptr++;
+      }
+      else
+      {
+        /* Rotate negative */
+        yi     = y - ( x >> i );
+        x      = x + ( y >> i );
+        y      = yi;
+        theta += *arctanptr++;
+      }
+    } while ( ++i < AF_TRIG_MAX_ITERS );
+
+#if 0
+    /* round theta */
+    if ( theta >= 0 )
+      theta =   FT_PAD_ROUND( theta, 2 );
+    else
+      theta = - FT_PAD_ROUND( -theta, 2 );
+#endif
+
+    vec->x = x;
+    vec->y = theta;
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_LOCAL_DEF( AF_Angle )
+  af_angle_atan( FT_Fixed  dx,
+                 FT_Fixed  dy )
+  {
+    FT_Vector  v;
+
+
+    if ( dx == 0 && dy == 0 )
+      return 0;
+
+    v.x = dx;
+    v.y = dy;
+    af_angle_prenorm( &v );
+    af_angle_pseudo_polarize( &v );
+
+    return v.y;
+  }
+
+
+
+  FT_LOCAL_DEF( AF_Angle )
+  af_angle_diff( AF_Angle  angle1,
+                 AF_Angle  angle2 )
+  {
+    AF_Angle  delta = angle2 - angle1;
+
+    delta %= AF_ANGLE_2PI;
+    if ( delta < 0 )
+      delta += AF_ANGLE_2PI;
+
+    if ( delta > AF_ANGLE_PI )
+      delta -= AF_ANGLE_2PI;
+
+    return delta;
+  }
+
+
+ /* well, this needs to be somewhere, right :-)
+  */
+
+  FT_LOCAL_DEF( void )
+  af_sort_pos( FT_UInt   count,
+               FT_Pos*   table )
+  {
+    FT_UInt  i, j;
+    FT_Pos   swap;
+
+
+    for ( i = 1; i < count; i++ )
+    {
+      for ( j = i; j > 0; j-- )
+      {
+        if ( table[j] > table[j - 1] )
+          break;
+
+        swap         = table[j];
+        table[j]     = table[j - 1];
+        table[j - 1] = swap;
+      }
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_sort_widths( FT_UInt   count,
+                  AF_Width  table )
+  {
+    FT_UInt      i, j;
+    AF_WidthRec  swap;
+
+
+    for ( i = 1; i < count; i++ )
+    {
+      for ( j = i; j > 0; j-- )
+      {
+        if ( table[j].org > table[j - 1].org )
+          break;
+
+        swap         = table[j];
+        table[j]     = table[j - 1];
+        table[j - 1] = swap;
+      }
+    }
+  }
+
+
+#ifdef TEST
+#include <stdio.h>
+#include <math.h>
+
+int main( void )
+{
+  int  angle;
+  int  dist;
+
+  for ( dist = 100; dist < 1000; dist++ )
+  {
+    for ( angle = AF_ANGLE_PI; angle < AF_ANGLE_2PI*4; angle++ )
+    {
+      double a = (angle*3.1415926535)/(1.0*AF_ANGLE_PI);
+      int    dx, dy, angle1, angle2, delta;
+
+      dx = dist * cos(a);
+      dy = dist * sin(a);
+
+      angle1  = ((atan2(dy,dx)*AF_ANGLE_PI)/3.1415926535);
+      angle2  = af_angle_atan( dx, dy );
+      delta   = (angle2 - angle1) % AF_ANGLE_2PI;
+      if ( delta < 0 )
+        delta = -delta;
+
+      if ( delta >= 2 )
+      {
+        printf( "dist:%4d angle:%4d => (%4d,%4d) angle1:%4d angle2:%4d\n",
+                dist, angle, dx, dy, angle1, angle2 );
+      }
+    }
+  }
+  return 0;
+}
+#endif
diff --git a/nx-X11/extras/freetype2/src/autofit/afdummy.c b/nx-X11/extras/freetype2/src/autofit/afdummy.c
new file mode 100644
index 000000000..2d5f89839
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afdummy.c
@@ -0,0 +1,37 @@
+#include "afdummy.h"
+#include "afhints.h"
+
+
+  static FT_Error
+  af_dummy_hints_init( AF_GlyphHints     hints,
+                       AF_ScriptMetrics  metrics )
+  {
+    af_glyph_hints_rescale( hints,
+                            metrics );
+    return 0;
+  }
+
+  static FT_Error
+  af_dummy_hints_apply( AF_GlyphHints  hints,
+                        FT_Outline*    outline )
+  {
+    FT_UNUSED( hints );
+    FT_UNUSED( outline );
+
+    return 0;
+  }
+
+
+  FT_LOCAL_DEF( const AF_ScriptClassRec )  af_dummy_script_class =
+  {
+    AF_SCRIPT_NONE,
+    NULL,
+
+    sizeof( AF_ScriptMetricsRec ),
+    (AF_Script_InitMetricsFunc)  NULL,
+    (AF_Script_ScaleMetricsFunc) NULL,
+    (AF_Script_DoneMetricsFunc)  NULL,
+
+    (AF_Script_InitHintsFunc)    af_dummy_hints_init,
+    (AF_Script_ApplyHintsFunc)   af_dummy_hints_apply
+  };
diff --git a/nx-X11/extras/freetype2/src/autofit/afdummy.h b/nx-X11/extras/freetype2/src/autofit/afdummy.h
new file mode 100644
index 000000000..f4594c0f9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afdummy.h
@@ -0,0 +1,18 @@
+#ifndef __AFDUMMY_H__
+#define __AFDUMMY_H__
+
+#include "aftypes.h"
+
+FT_BEGIN_HEADER
+
+ /* a dummy script metrics class used when no hinting should
+  * be performed. This is the default for non-latin glyphs !
+  */
+
+  FT_LOCAL( const AF_ScriptClassRec )    af_dummy_script_class;
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __AFDUMMY_H__ */
diff --git a/nx-X11/extras/freetype2/src/autofit/afglobal.c b/nx-X11/extras/freetype2/src/autofit/afglobal.c
new file mode 100644
index 000000000..54852ab31
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afglobal.c
@@ -0,0 +1,236 @@
+#include "afglobal.h"
+#include "afdummy.h"
+#include "aflatin.h"
+
+ /* populate this list when you add new scripts
+  */
+  static AF_ScriptClass const   af_script_classes[] =
+  {
+    & af_dummy_script_class,
+    & af_latin_script_class,
+
+    NULL  /* do not remove */
+  };
+
+#define AF_SCRIPT_LIST_DEFAULT   1    /* index of default script in 'af_script_classes' */
+#define AF_SCRIPT_LIST_NONE      255  /* indicates an uncovered glyph                      */
+
+ /*
+  *  note that glyph_scripts[] is used to map each glyph into
+  *  an index into the 'af_script_classes' array.
+  *
+  */
+  typedef struct AF_FaceGlobalsRec_
+  {
+    FT_Face            face;
+    FT_UInt            glyph_count;    /* same as face->num_glyphs     */
+    FT_Byte*           glyph_scripts;
+
+    AF_ScriptMetrics   metrics[ AF_SCRIPT_MAX ];
+
+  } AF_FaceGlobalsRec;
+
+
+
+
+ /* this function is used to compute the script index of each glyph
+  * within a given face
+  */
+  static FT_Error
+  af_face_globals_compute_script_coverage( AF_FaceGlobals  globals )
+  {
+    FT_Error    error       = 0;
+    FT_Face     face        = globals->face;
+    FT_CharMap  old_charmap = face->charmap;
+    FT_Byte*    gscripts    = globals->glyph_scripts;
+    FT_UInt     ss;
+
+   /* the value 255 means "uncovered glyph"
+    */
+    FT_MEM_SET( globals->glyph_scripts,
+                AF_SCRIPT_LIST_NONE,
+                globals->glyph_count );
+
+    error = FT_Select_Charmap( face, FT_ENCODING_UNICODE );
+    if ( error )
+    {
+     /* ignore this error, we'll simply use Latin as the standard
+      * script. XXX: Shouldn't we rather disable hinting ??
+      */
+      error = 0;
+      goto Exit;
+    }
+
+   /* scan each script in a Unicode charmap
+    */
+    for ( ss = 0; af_script_classes[ss]; ss++ )
+    {
+      AF_ScriptClass      clazz = af_script_classes[ss];
+      AF_Script_UniRange  range;
+
+      if ( clazz->script_uni_ranges == NULL )
+        continue;
+
+     /* scan all unicode points in the range, and set the corresponding
+      * glyph script index
+      */
+      for ( range = clazz->script_uni_ranges; range->first != 0; range++ )
+      {
+        FT_ULong  charcode = range->first;
+        FT_UInt   gindex;
+
+        gindex = FT_Get_Char_Index( face, charcode );
+
+        if ( gindex != 0                               &&
+             gindex < globals->glyph_count             &&
+             gscripts[ gindex ] == AF_SCRIPT_LIST_NONE )
+        {
+          gscripts[ gindex ] = (FT_Byte) ss;
+        }
+        for (;;)
+        {
+          charcode = FT_Get_Next_Char( face, charcode, &gindex );
+
+          if ( gindex == 0 || charcode > range->last )
+            break;
+
+          if ( gindex < globals->glyph_count       &&
+               gscripts[ gindex ] == AF_SCRIPT_LIST_NONE )
+          {
+            gscripts[ gindex ] = (FT_Byte) ss;
+          }
+        }
+      }
+    }
+
+  Exit:
+   /* by default, all uncovered glyphs are set to the latin script
+    * XXX: shouldnt' we disable hinting or do something similar ?
+    */
+    {
+      FT_UInt  nn;
+
+      for ( nn = 0; nn < globals->glyph_count; nn++ )
+      {
+        if ( gscripts[ nn ] == AF_SCRIPT_LIST_NONE )
+          gscripts[ nn ] = AF_SCRIPT_LIST_DEFAULT;
+      }
+    }
+
+    FT_Set_Charmap( face, old_charmap );
+    return error;
+  }
+
+
+
+  FT_LOCAL_DEF( FT_Error )
+  af_face_globals_new( FT_Face          face,
+                       AF_FaceGlobals  *aglobals )
+  {
+    FT_Error        error;
+    FT_Memory       memory;
+    AF_FaceGlobals  globals;
+
+    memory = face->memory;
+
+    if ( !FT_ALLOC( globals, sizeof(*globals) +
+                             face->num_glyphs*sizeof(FT_Byte) ) )
+    {
+      globals->face          = face;
+      globals->glyph_count   = face->num_glyphs;
+      globals->glyph_scripts = (FT_Byte*)( globals+1 );
+
+      error = af_face_globals_compute_script_coverage( globals );
+      if ( error )
+      {
+        af_face_globals_free( globals );
+        globals = NULL;
+      }
+    }
+
+    *aglobals = globals;
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_face_globals_free( AF_FaceGlobals  globals )
+  {
+    if ( globals )
+    {
+      FT_Memory  memory = globals->face->memory;
+      FT_UInt    nn;
+
+      for ( nn = 0; nn < AF_SCRIPT_MAX; nn++ )
+      {
+        if ( globals->metrics[nn] )
+        {
+          AF_ScriptClass  clazz = af_script_classes[nn];
+
+          FT_ASSERT( globals->metrics[nn]->clazz == clazz );
+
+          if ( clazz->script_metrics_done )
+            clazz->script_metrics_done( globals->metrics[nn] );
+
+          FT_FREE( globals->metrics[nn] );
+        }
+      }
+
+      globals->glyph_count   = 0;
+      globals->glyph_scripts = NULL;  /* no need to free this one !! */
+      globals->face          = NULL;
+      FT_FREE( globals );
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  af_face_globals_get_metrics( AF_FaceGlobals     globals,
+                               FT_UInt            gindex,
+                               AF_ScriptMetrics  *ametrics )
+  {
+    AF_ScriptMetrics  metrics = NULL;
+    FT_UInt           index;
+    AF_ScriptClass    clazz;
+    FT_Error          error = 0;
+
+    if ( gindex >= globals->glyph_count )
+    {
+      error = FT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    index   = globals->glyph_scripts[ gindex ];
+    clazz   = af_script_classes[ index ];
+    metrics = globals->metrics[ clazz->script ];
+    if ( metrics == NULL )
+    {
+     /* create the global metrics object when needed
+      */
+      FT_Memory  memory = globals->face->memory;
+
+      if ( FT_ALLOC( metrics, clazz->script_metrics_size ) )
+        goto Exit;
+
+      metrics->clazz = clazz;
+
+      if ( clazz->script_metrics_init )
+      {
+        error = clazz->script_metrics_init( metrics, globals->face );
+        if ( error )
+        {
+          if ( clazz->script_metrics_done )
+            clazz->script_metrics_done( metrics );
+
+          FT_FREE( metrics );
+          goto Exit;
+        }
+      }
+
+      globals->metrics[ clazz->script ] = metrics;
+    }
+
+  Exit:
+    *ametrics = metrics;
+    return error;
+  }
diff --git a/nx-X11/extras/freetype2/src/autofit/afglobal.h b/nx-X11/extras/freetype2/src/autofit/afglobal.h
new file mode 100644
index 000000000..64f35c3ff
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afglobal.h
@@ -0,0 +1,41 @@
+#ifndef __AF_GLOBAL_H__
+#define __AF_GLOBAL_H__
+
+#include "aftypes.h"
+
+FT_BEGIN_HEADER
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                F A C E   G L O B A L S                         *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+
+ /*
+  *  models the global hints data for a given face, decomposed into
+  *  script-specific items..
+  *
+  */
+  typedef struct AF_FaceGlobalsRec_*   AF_FaceGlobals;
+
+
+  FT_LOCAL( FT_Error )
+  af_face_globals_new( FT_Face          face,
+                       AF_FaceGlobals  *aglobals );
+
+  FT_LOCAL( FT_Error )
+  af_face_globals_get_metrics( AF_FaceGlobals     globals,
+                               FT_UInt            gindex,
+                               AF_ScriptMetrics  *ametrics );
+
+  FT_LOCAL( void )
+  af_face_globals_free( AF_FaceGlobals  globals );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __AF_GLOBALS_H__ */
diff --git a/nx-X11/extras/freetype2/src/autofit/afhints.c b/nx-X11/extras/freetype2/src/autofit/afhints.c
new file mode 100644
index 000000000..a1a50dce3
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afhints.c
@@ -0,0 +1,989 @@
+#include "afhints.h"
+
+#ifdef AF_DEBUG
+
+#include <stdio.h>
+
+  static const char* af_dir_str( AF_Direction  dir )
+  {
+    const char*  result;
+
+    switch (dir)
+    {
+     case AF_DIR_UP:    result = "up";    break;
+     case AF_DIR_DOWN:  result = "down";  break;
+     case AF_DIR_LEFT:  result = "left";  break;
+     case AF_DIR_RIGHT: result = "right"; break;
+     default:           result = "none";
+    }
+    return result;
+  }
+
+#define  AF_INDEX_NUM(ptr,base)  ( (ptr) ? ((ptr)-(base)) : -1 )
+
+  void
+  af_glyph_hints_dump_points( AF_GlyphHints  hints )
+  {
+    AF_Point  points = hints->points;
+    AF_Point  limit  = points + hints->num_points;
+    AF_Point  point;
+
+    printf( "Table of points:\n" );
+    printf(   "  [ index |  xorg |  yorg |  xscale |  yscale |  xfit  |  yfit  |  flags ]\n" );
+    for ( point = points; point < limit; point++ )
+    {
+      printf( "  [ %5d | %5d | %5d | %-5.2f | %-5.2f | %-5.2f | %-5.2f | %c%c%c%c%c%c ]\n",
+              point - points,
+              point->fx,
+              point->fy,
+              point->ox/64.0,
+              point->oy/64.0,
+              point->x/64.0,
+              point->y/64.0,
+              (point->flags & AF_FLAG_WEAK_INTERPOLATION) ? 'w' : ' ',
+              (point->flags & AF_FLAG_INFLECTION)         ? 'i' : ' ',
+              (point->flags & AF_FLAG_EXTREMA_X)          ? '<' : ' ',
+              (point->flags & AF_FLAG_EXTREMA_Y)          ? 'v' : ' ',
+              (point->flags & AF_FLAG_ROUND_X)            ? '(' : ' ',
+              (point->flags & AF_FLAG_ROUND_Y)            ? 'u' : ' '
+            );
+    }
+    printf( "\n" );
+  }
+
+
+  /* A function used to dump the array of linked segments */
+  void
+  af_glyph_hints_dump_segments( AF_GlyphHints  hints )
+  {
+    AF_Point    points = hints->points;
+    FT_Int      dimension;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AF_AxisHints  axis = &hints->axis[dimension];
+      AF_Segment    segments = axis->segments;
+      AF_Segment    limit    = segments + axis->num_segments;
+      AF_Segment    seg;
+
+
+      printf ( "Table of %s segments:\n",
+               dimension == AF_DIMENSION_HORZ ? "vertical" : "horizontal" );
+      printf ( "  [ index |  pos |  dir  | link | serif |"
+               " numl | first | start ]\n" );
+
+      for ( seg = segments; seg < limit; seg++ )
+      {
+        printf ( "  [ %5d | %4d | %5s | %4d | %5d | %4d | %5d | %5d ]\n",
+                 seg - segments,
+                 (int)seg->pos,
+                 af_dir_str( seg->dir ),
+                 AF_INDEX_NUM( seg->link, segments ),
+                 AF_INDEX_NUM( seg->serif, segments ),
+                 (int)seg->num_linked,
+                 seg->first - points,
+                 seg->last - points );
+      }
+      printf( "\n" );
+    }
+  }
+
+
+  void
+  af_glyph_hints_dump_edges( AF_GlyphHints  hints )
+  {
+    FT_Int      dimension;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AF_AxisHints  axis  = &hints->axis[ dimension ];
+      AF_Edge       edges = axis->edges;
+      AF_Edge       limit = edges + axis->num_edges;
+      AF_Edge       edge;
+
+     /* note: AF_DIMENSION_HORZ corresponds to _vertical_ edges
+      * since they have constant X coordinate
+      */
+      printf ( "Table of %s edges:\n",
+               dimension == AF_DIMENSION_HORZ ? "vertical" : "horizontal" );
+      printf ( "  [ index |  pos |  dir  | link |"
+               " serif | blue | opos  |  pos  ]\n" );
+
+      for ( edge = edges; edge < limit; edge++ )
+      {
+        printf ( "  [ %5d | %4d | %5s | %4d | %5d |   %c  | %5.2f | %5.2f ]\n",
+                 edge - edges,
+                 (int)edge->fpos,
+                 af_dir_str( edge->dir ),
+                 AF_INDEX_NUM( edge->link, edges ),
+                 AF_INDEX_NUM( edge->serif, edges ),
+                 edge->blue_edge ? 'y' : 'n',
+                 edge->opos / 64.0,
+                 edge->pos / 64.0 );
+      }
+
+      printf( "\n" );
+    }
+  }
+
+
+
+#endif /* AF_DEBUG */
+
+
+  /* compute the direction value of a given vector */
+  FT_LOCAL_DEF( AF_Direction )
+  af_direction_compute( FT_Pos  dx,
+                        FT_Pos  dy )
+  {
+    AF_Direction  dir;
+    FT_Pos        ax = FT_ABS( dx );
+    FT_Pos        ay = FT_ABS( dy );
+
+
+    dir = AF_DIR_NONE;
+
+    /* atan(1/12) == 4.7 degrees */
+
+    /* test for vertical direction */
+    if ( ax * 12 < ay )
+    {
+      dir = dy > 0 ? AF_DIR_UP : AF_DIR_DOWN;
+    }
+    /* test for horizontal direction */
+    else if ( ay * 12 < ax )
+    {
+      dir = dx > 0 ? AF_DIR_RIGHT : AF_DIR_LEFT;
+    }
+
+    return dir;
+  }
+
+
+  /* compute all inflex points in a given glyph */
+  static void
+  af_glyph_hints_compute_inflections( AF_GlyphHints  hints )
+  {
+    AF_Point*  contour       = hints->contours;
+    AF_Point*  contour_limit = contour + hints->num_contours;
+
+
+    /* do each contour separately */
+    for ( ; contour < contour_limit; contour++ )
+    {
+      AF_Point   point = contour[0];
+      AF_Point   first = point;
+      AF_Point   start = point;
+      AF_Point   end   = point;
+      AF_Point   before;
+      AF_Point   after;
+      AF_Angle   angle_in, angle_seg, angle_out;
+      AF_Angle   diff_in, diff_out;
+      FT_Int     finished = 0;
+
+
+      /* compute first segment in contour */
+      first = point;
+
+      start = end = first;
+      do
+      {
+        end = end->next;
+        if ( end == first )
+          goto Skip;
+
+      } while ( end->fx == first->fx && end->fy == first->fy );
+
+      angle_seg = af_angle_atan( end->fx - start->fx,
+                                 end->fy - start->fy );
+
+      /* extend the segment start whenever possible */
+      before = start;
+      do
+      {
+        do
+        {
+          start  = before;
+          before = before->prev;
+          if ( before == first )
+            goto Skip;
+
+        } while ( before->fx == start->fx && before->fy == start->fy );
+
+        angle_in = af_angle_atan( start->fx - before->fx,
+                                  start->fy - before->fy );
+
+      } while ( angle_in == angle_seg );
+
+      first   = start;
+      diff_in = af_angle_diff( angle_in, angle_seg );
+
+      /* now, process all segments in the contour */
+      do
+      {
+        /* first, extend current segment's end whenever possible */
+        after = end;
+        do
+        {
+          do
+          {
+            end   = after;
+            after = after->next;
+            if ( after == first )
+              finished = 1;
+
+          } while ( end->fx == after->fx && end->fy == after->fy );
+
+          angle_out = af_angle_atan( after->fx - end->fx,
+                                     after->fy - end->fy );
+
+        } while ( angle_out == angle_seg );
+
+        diff_out = af_angle_diff( angle_seg, angle_out );
+
+        if ( ( diff_in ^ diff_out ) < 0 )
+        {
+          /* diff_in and diff_out have different signs, we have */
+          /* inflection points here...                          */
+          do
+          {
+            start->flags |= AF_FLAG_INFLECTION;
+            start = start->next;
+
+          } while ( start != end );
+
+          start->flags |= AF_FLAG_INFLECTION;
+        }
+
+        start     = end;
+        end       = after;
+        angle_seg = angle_out;
+        diff_in   = diff_out;
+
+      } while ( !finished );
+
+    Skip:
+      ;
+    }
+  }
+
+
+
+  FT_LOCAL_DEF( void )
+  af_glyph_hints_init( AF_GlyphHints  hints,
+                       FT_Memory      memory )
+  {
+    FT_ZERO( hints );
+    hints->memory = memory;
+  }
+
+
+
+  FT_LOCAL_DEF( void )
+  af_glyph_hints_done( AF_GlyphHints  hints )
+  {
+    if ( hints && hints->memory )
+    {
+      FT_Memory     memory = hints->memory;
+      AF_Dimension  dim;
+
+     /* note that we don't need to free the segment and edge
+      * buffers, since they're really within the hints->points array
+      */
+      for ( dim = 0; dim < 2; dim++ )
+      {
+        AF_AxisHints  axis = &hints->axis[ dim ];
+
+        axis->num_segments = 0;
+        axis->num_edges    = 0;
+        axis->segments     = NULL;
+        axis->edges        = NULL;
+      }
+
+      FT_FREE( hints->contours );
+      hints->max_contours = 0;
+      hints->num_contours = 0;
+
+      FT_FREE( hints->points );
+      hints->num_points = 0;
+      hints->max_points = 0;
+
+      hints->memory = NULL;
+    }
+  }
+
+
+
+  FT_LOCAL_DEF( void )
+  af_glyph_hints_rescale( AF_GlyphHints     hints,
+                          AF_ScriptMetrics  metrics )
+  {
+    hints->metrics = metrics;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  af_glyph_hints_reload( AF_GlyphHints     hints,
+                         FT_Outline*       outline )
+  {
+    FT_Error     error        = FT_Err_Ok;
+    AF_Point     points;
+    FT_UInt      old_max, new_max;
+    AF_Scaler    scaler  = &hints->metrics->scaler;
+    FT_Fixed     x_scale = hints->x_scale;
+    FT_Fixed     y_scale = hints->y_scale;
+    FT_Pos       x_delta = hints->x_delta;
+    FT_Pos       y_delta = hints->y_delta;
+    FT_Memory    memory  = hints->memory;
+
+    hints->scaler_flags  = scaler->flags;
+    hints->num_points    = 0;
+    hints->num_contours  = 0;
+
+    hints->axis[0].num_segments = 0;
+    hints->axis[0].num_edges    = 0;
+    hints->axis[1].num_segments = 0;
+    hints->axis[1].num_edges    = 0;
+
+   /* first of all, reallocate the contours array when necessary
+    */
+    new_max = (FT_UInt) outline->n_contours;
+    old_max = hints->max_contours;
+    if ( new_max > old_max )
+    {
+      new_max = (new_max + 3) & ~3;
+
+      if ( FT_RENEW_ARRAY( hints->contours, old_max, new_max ) )
+        goto Exit;
+
+      hints->max_contours = new_max;
+    }
+
+   /* then, reallocate the points, segments & edges arrays if needed --
+    * note that we reserved two additional point positions, used to
+    * hint metrics appropriately
+    */
+    new_max = (FT_UInt)( outline->n_points + 2 );
+    old_max = hints->max_points;
+    if ( new_max > old_max )
+    {
+      FT_Byte*    items;
+      FT_ULong    off1, off2, off3;
+
+     /* we store in a single buffer the following arrays:
+      *
+      *  - an array of   N  AF_PointRec   items
+      *  - an array of 2*N  AF_SegmentRec items
+      *  - an array of 2*N  AF_EdgeRec    items
+      *
+      */
+
+      new_max = ( new_max + 2 + 7 ) & ~7;
+
+#define OFF_PAD2(x,y)   (((x)+(y)-1) & ~((y)-1))
+#define OFF_PADX(x,y)   ((((x)+(y)-1)/(y))*(y))
+#define OFF_PAD(x,y)    ( ((y) & ((y)-1)) ? OFF_PADX(x,y) : OFF_PAD2(x,y) )
+
+#undef  OFF_INCREMENT
+#define OFF_INCREMENT( _off, _type, _count )   \
+     ( OFF_PAD( _off, sizeof(_type) ) + (_count)*sizeof(_type))
+
+      off1 = OFF_INCREMENT( 0, AF_PointRec, new_max );
+      off2 = OFF_INCREMENT( off1, AF_SegmentRec, new_max*2 );
+      off3 = OFF_INCREMENT( off2, AF_EdgeRec, new_max*2 );
+
+      FT_FREE( hints->points );
+
+      if ( FT_ALLOC( items, off3 ) )
+      {
+        hints->max_points       = 0;
+        hints->axis[0].segments = NULL;
+        hints->axis[0].edges    = NULL;
+        hints->axis[1].segments = NULL;
+        hints->axis[1].edges    = NULL;
+        goto Exit;
+      }
+
+     /* readjust some pointers
+      */
+      hints->max_points       = new_max;
+      hints->points           = (AF_Point) items;
+
+      hints->axis[0].segments = (AF_Segment)( items + off1 );
+      hints->axis[1].segments = hints->axis[0].segments + new_max;
+
+      hints->axis[0].edges    = (AF_Edge)   ( items + off2 );
+      hints->axis[1].edges    = hints->axis[0].edges + new_max;
+    }
+
+    hints->num_points   = outline->n_points;
+    hints->num_contours = outline->n_contours;
+
+
+    /* We can't rely on the value of `FT_Outline.flags' to know the fill  */
+    /* direction used for a glyph, given that some fonts are broken (e.g. */
+    /* the Arphic ones).  We thus recompute it each time we need to.      */
+    /*                                                                    */
+    hints->axis[ AF_DIMENSION_HORZ ].major_dir = AF_DIR_UP;
+    hints->axis[ AF_DIMENSION_VERT ].major_dir = AF_DIR_LEFT;
+
+    if ( FT_Outline_Get_Orientation( outline ) == FT_ORIENTATION_POSTSCRIPT )
+    {
+      hints->axis[ AF_DIMENSION_HORZ ].major_dir = AF_DIR_DOWN;
+      hints->axis[ AF_DIMENSION_VERT ].major_dir = AF_DIR_RIGHT;
+    }
+
+    hints->x_scale = x_scale;
+    hints->y_scale = y_scale;
+    hints->x_delta = x_delta;
+    hints->y_delta = y_delta;
+
+    points = hints->points;
+    if ( hints->num_points == 0 )
+      goto Exit;
+
+    {
+      AF_Point  point;
+      AF_Point  point_limit = points + hints->num_points;
+
+
+      /* compute coordinates & bezier flags */
+      {
+        FT_Vector*  vec = outline->points;
+        char*       tag = outline->tags;
+
+
+        for ( point = points; point < point_limit; point++, vec++, tag++ )
+        {
+          point->fx = vec->x;
+          point->fy = vec->y;
+          point->ox = point->x = FT_MulFix( vec->x, x_scale ) + x_delta;
+          point->oy = point->y = FT_MulFix( vec->y, y_scale ) + y_delta;
+
+          switch ( FT_CURVE_TAG( *tag ) )
+          {
+          case FT_CURVE_TAG_CONIC:
+            point->flags = AF_FLAG_CONIC;
+            break;
+          case FT_CURVE_TAG_CUBIC:
+            point->flags = AF_FLAG_CUBIC;
+            break;
+          default:
+            point->flags = 0;
+            ;
+          }
+        }
+      }
+
+      /* compute `next' and `prev' */
+      {
+        FT_Int    contour_index;
+        AF_Point  prev;
+        AF_Point  first;
+        AF_Point  end;
+
+
+        contour_index = 0;
+
+        first = points;
+        end   = points + outline->contours[0];
+        prev  = end;
+
+        for ( point = points; point < point_limit; point++ )
+        {
+          point->prev = prev;
+          if ( point < end )
+          {
+            point->next = point + 1;
+            prev        = point;
+          }
+          else
+          {
+            point->next = first;
+            contour_index++;
+            if ( point + 1 < point_limit )
+            {
+              end   = points + outline->contours[contour_index];
+              first = point + 1;
+              prev  = end;
+            }
+          }
+        }
+      }
+
+      /* set-up the contours array */
+      {
+        AF_Point*  contour       = hints->contours;
+        AF_Point*  contour_limit = contour + hints->num_contours;
+        short*     end           = outline->contours;
+        short      idx           = 0;
+
+
+        for ( ; contour < contour_limit; contour++, end++ )
+        {
+          contour[0] = points + idx;
+          idx        = (short)( end[0] + 1 );
+        }
+      }
+
+      /* compute directions of in & out vectors */
+      {
+        for ( point = points; point < point_limit; point++ )
+        {
+          AF_Point   prev;
+          AF_Point   next;
+          FT_Pos     in_x, in_y, out_x, out_y;
+
+
+          prev   = point->prev;
+          in_x   = point->fx - prev->fx;
+          in_y   = point->fy - prev->fy;
+
+          point->in_dir = af_direction_compute( in_x, in_y );
+
+          next   = point->next;
+          out_x  = next->fx - point->fx;
+          out_y  = next->fy - point->fy;
+
+          point->out_dir = af_direction_compute( out_x, out_y );
+
+          if ( point->flags & ( AF_FLAG_CONIC | AF_FLAG_CUBIC ) )
+          {
+          Is_Weak_Point:
+            point->flags |= AF_FLAG_WEAK_INTERPOLATION;
+          }
+          else if ( point->out_dir == point->in_dir )
+          {
+            AF_Angle  angle_in, angle_out, delta;
+
+
+            if ( point->out_dir != AF_DIR_NONE )
+              goto Is_Weak_Point;
+
+            angle_in  = af_angle_atan( in_x, in_y );
+            angle_out = af_angle_atan( out_x, out_y );
+            delta     = af_angle_diff( angle_in, angle_out );
+
+            if ( delta < 2 && delta > -2 )
+              goto Is_Weak_Point;
+          }
+          else if ( point->in_dir == -point->out_dir )
+            goto Is_Weak_Point;
+        }
+      }
+    }
+
+   /* compute inflection points
+    */
+    af_glyph_hints_compute_inflections( hints );
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_glyph_hints_save( AF_GlyphHints   hints,
+                       FT_Outline*     outline )
+  {
+    AF_Point    point = hints->points;
+    AF_Point    limit = point + hints->num_points;
+    FT_Vector*  vec   = outline->points;
+    char*       tag   = outline->tags;
+
+    for ( ; point < limit; point++, vec++, tag++ )
+    {
+      vec->x = (FT_Pos) point->x;
+      vec->y = (FT_Pos) point->y;
+
+      if ( point->flags & AF_FLAG_CONIC )
+        tag[0] = FT_CURVE_TAG_CONIC;
+      else if ( point->flags & AF_FLAG_CUBIC )
+        tag[0] = FT_CURVE_TAG_CUBIC;
+      else
+        tag[0] = FT_CURVE_TAG_ON;
+    }
+  }
+
+
+ /*
+  *
+  *  E D G E   P O I N T   G R I D - F I T T I N G
+  *
+  */
+
+
+  FT_LOCAL_DEF( void )
+  af_glyph_hints_align_edge_points( AF_GlyphHints  hints,
+                                    AF_Dimension   dim )
+  {
+    AF_AxisHints  axis       = & hints->axis[ dim ];
+    AF_Edge       edges      = axis->edges;
+    AF_Edge       edge_limit = edges + axis->num_edges;
+    AF_Edge       edge;
+
+    for ( edge = edges; edge < edge_limit; edge++ )
+    {
+      /* move the points of each segment     */
+      /* in each edge to the edge's position */
+      AF_Segment  seg = edge->first;
+
+
+      do
+      {
+        AF_Point  point = seg->first;
+
+
+        for (;;)
+        {
+          if ( dim == AF_DIMENSION_HORZ )
+          {
+            point->x      = edge->pos;
+            point->flags |= AF_FLAG_TOUCH_X;
+          }
+          else
+          {
+            point->y      = edge->pos;
+            point->flags |= AF_FLAG_TOUCH_Y;
+          }
+
+          if ( point == seg->last )
+            break;
+
+          point = point->next;
+        }
+
+        seg = seg->edge_next;
+
+      } while ( seg != edge->first );
+    }
+  }
+
+
+ /*
+  *
+  *  S T R O N G   P O I N T   I N T E R P O L A T I O N
+  *
+  */
+
+
+  /* hint the strong points -- this is equivalent to the TrueType `IP' */
+  /* hinting instruction                                               */
+  FT_LOCAL_DEF( void )
+  af_glyph_hints_align_strong_points( AF_GlyphHints  hints,
+                                      AF_Dimension   dim )
+  {
+    AF_Point      points      = hints->points;
+    AF_Point      point_limit = points + hints->num_points;
+    AF_AxisHints  axis        = &hints->axis[dim];
+    AF_Edge       edges       = axis->edges;
+    AF_Edge       edge_limit  = edges + axis->num_edges;
+    AF_Flags      touch_flag;
+
+
+    if ( dim == AF_DIMENSION_HORZ )
+      touch_flag = AF_FLAG_TOUCH_X;
+    else
+      touch_flag  = AF_FLAG_TOUCH_Y;
+
+    if ( edges < edge_limit )
+    {
+      AF_Point  point;
+      AF_Edge   edge;
+
+      for ( point = points; point < point_limit; point++ )
+      {
+        FT_Pos  u, ou, fu;  /* point position */
+        FT_Pos  delta;
+
+
+        if ( point->flags & touch_flag )
+          continue;
+
+        /* if this point is candidate to weak interpolation, we will  */
+        /* interpolate it after all strong points have been processed */
+        if (  ( point->flags & AF_FLAG_WEAK_INTERPOLATION ) &&
+             !( point->flags & AF_FLAG_INFLECTION )         )
+          continue;
+
+        if ( dim == AF_DIMENSION_VERT )
+        {
+          u  = point->fy;
+          ou = point->oy;
+        }
+        else
+        {
+          u  = point->fx;
+          ou = point->ox;
+        }
+
+        fu = u;
+
+        /* is the point before the first edge? */
+        edge  = edges;
+        delta = edge->fpos - u;
+        if ( delta >= 0 )
+        {
+          u = edge->pos - ( edge->opos - ou );
+          goto Store_Point;
+        }
+
+        /* is the point after the last edge? */
+        edge  = edge_limit - 1;
+        delta = u - edge->fpos;
+        if ( delta >= 0 )
+        {
+          u = edge->pos + ( ou - edge->opos );
+          goto Store_Point;
+        }
+
+        {
+          FT_UInt  min, max, mid;
+          FT_Pos   fpos;
+
+
+          /* find enclosing edges */
+          min = 0;
+          max = edge_limit - edges;
+
+          while ( min < max )
+          {
+            mid  = ( max + min ) >> 1;
+            edge = edges + mid;
+            fpos = edge->fpos;
+
+            if ( u < fpos )
+              max = mid;
+            else if ( u > fpos )
+              min = mid + 1;
+            else
+            {
+              /* we are on the edge */
+              u = edge->pos;
+              goto Store_Point;
+            }
+          }
+
+          {
+            AF_Edge  before = edges + min - 1;
+            AF_Edge  after  = edges + min + 0;
+
+
+            /* assert( before && after && before != after ) */
+            if ( before->scale == 0 )
+              before->scale = FT_DivFix( after->pos - before->pos,
+                                         after->fpos - before->fpos );
+
+            u = before->pos + FT_MulFix( fu - before->fpos,
+                                         before->scale );
+          }
+        }
+
+
+      Store_Point:
+
+        /* save the point position */
+        if ( dim == AF_DIMENSION_HORZ )
+          point->x = u;
+        else
+          point->y = u;
+
+        point->flags |= touch_flag;
+      }
+    }
+  }
+
+
+ /*
+  *
+  *  W E A K   P O I N T   I N T E R P O L A T I O N
+  *
+  */
+
+  static void
+  af_iup_shift( AF_Point  p1,
+                AF_Point  p2,
+                AF_Point  ref )
+  {
+    AF_Point  p;
+    FT_Pos    delta = ref->u - ref->v;
+
+
+    for ( p = p1; p < ref; p++ )
+      p->u = p->v + delta;
+
+    for ( p = ref + 1; p <= p2; p++ )
+      p->u = p->v + delta;
+  }
+
+
+  static void
+  af_iup_interp( AF_Point  p1,
+                 AF_Point  p2,
+                 AF_Point  ref1,
+                 AF_Point  ref2 )
+  {
+    AF_Point  p;
+    FT_Pos    u;
+    FT_Pos    v1 = ref1->v;
+    FT_Pos    v2 = ref2->v;
+    FT_Pos    d1 = ref1->u - v1;
+    FT_Pos    d2 = ref2->u - v2;
+
+
+    if ( p1 > p2 )
+      return;
+
+    if ( v1 == v2 )
+    {
+      for ( p = p1; p <= p2; p++ )
+      {
+        u = p->v;
+
+        if ( u <= v1 )
+          u += d1;
+        else
+          u += d2;
+
+        p->u = u;
+      }
+      return;
+    }
+
+    if ( v1 < v2 )
+    {
+      for ( p = p1; p <= p2; p++ )
+      {
+        u = p->v;
+
+        if ( u <= v1 )
+          u += d1;
+        else if ( u >= v2 )
+          u += d2;
+        else
+          u = ref1->u + FT_MulDiv( u - v1, ref2->u - ref1->u, v2 - v1 );
+
+        p->u = u;
+      }
+    }
+    else
+    {
+      for ( p = p1; p <= p2; p++ )
+      {
+        u = p->v;
+
+        if ( u <= v2 )
+          u += d2;
+        else if ( u >= v1 )
+          u += d1;
+        else
+          u = ref1->u + FT_MulDiv( u - v1, ref2->u - ref1->u, v2 - v1 );
+
+        p->u = u;
+      }
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_glyph_hints_align_weak_points( AF_GlyphHints  hints,
+                                    AF_Dimension   dim )
+  {
+    AF_Point    points        = hints->points;
+    AF_Point    point_limit   = points + hints->num_points;
+    AF_Point*   contour       = hints->contours;
+    AF_Point*   contour_limit = contour + hints->num_contours;
+    AF_Flags    touch_flag;
+    AF_Point    point;
+    AF_Point    end_point;
+    AF_Point    first_point;
+
+
+    /* PASS 1: Move segment points to edge positions */
+
+    if ( dim == AF_DIMENSION_HORZ )
+    {
+      touch_flag = AF_FLAG_TOUCH_X;
+
+      for ( point = points; point < point_limit; point++ )
+      {
+        point->u = point->x;
+        point->v = point->ox;
+      }
+    }
+    else
+    {
+      touch_flag = AF_FLAG_TOUCH_Y;
+
+      for ( point = points; point < point_limit; point++ )
+      {
+        point->u = point->y;
+        point->v = point->oy;
+      }
+    }
+
+    point   = points;
+
+    for ( ; contour < contour_limit; contour++ )
+    {
+      point       = *contour;
+      end_point   = point->prev;
+      first_point = point;
+
+      while ( point <= end_point && !( point->flags & touch_flag ) )
+        point++;
+
+      if ( point <= end_point )
+      {
+        AF_Point  first_touched = point;
+        AF_Point  cur_touched   = point;
+
+
+        point++;
+        while ( point <= end_point )
+        {
+          if ( point->flags & touch_flag )
+          {
+            /* we found two successive touched points; we interpolate */
+            /* all contour points between them                        */
+            af_iup_interp( cur_touched + 1, point - 1,
+                           cur_touched, point );
+            cur_touched = point;
+          }
+          point++;
+        }
+
+        if ( cur_touched == first_touched )
+        {
+          /* this is a special case: only one point was touched in the */
+          /* contour; we thus simply shift the whole contour           */
+          af_iup_shift( first_point, end_point, cur_touched );
+        }
+        else
+        {
+          /* now interpolate after the last touched point to the end */
+          /* of the contour                                          */
+          af_iup_interp( cur_touched + 1, end_point,
+                         cur_touched, first_touched );
+
+          /* if the first contour point isn't touched, interpolate */
+          /* from the contour start to the first touched point     */
+          if ( first_touched > points )
+            af_iup_interp( first_point, first_touched - 1,
+                           cur_touched, first_touched );
+        }
+      }
+    }
+
+    /* now save the interpolated values back to x/y */
+    if ( dim == AF_DIMENSION_HORZ )
+    {
+      for ( point = points; point < point_limit; point++ )
+        point->x = point->u;
+    }
+    else
+    {
+      for ( point = points; point < point_limit; point++ )
+        point->y = point->u;
+    }
+  }
diff --git a/nx-X11/extras/freetype2/src/autofit/afhints.h b/nx-X11/extras/freetype2/src/autofit/afhints.h
new file mode 100644
index 000000000..40fd613a4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afhints.h
@@ -0,0 +1,248 @@
+#ifndef __AFHINTS_H__
+#define __AFHINTS_H__
+
+#include "aftypes.h"
+
+FT_BEGIN_HEADER
+
+ /*
+  *  The definition of outline glyph hints. These are shared by all
+  *  script analysis routines (until now)
+  *
+  */
+
+  typedef enum
+  {
+    AF_DIMENSION_HORZ = 0,  /* x coordinates, i.e. vertical segments & edges   */
+    AF_DIMENSION_VERT = 1,  /* y coordinates, i.e. horizontal segments & edges */
+
+    AF_DIMENSION_MAX  /* do not remove */
+
+  } AF_Dimension;
+
+
+  /* hint directions -- the values are computed so that two vectors are */
+  /* in opposite directions iff `dir1+dir2 == 0'                        */
+  typedef enum
+  {
+    AF_DIR_NONE  =  4,
+    AF_DIR_RIGHT =  1,
+    AF_DIR_LEFT  = -1,
+    AF_DIR_UP    =  2,
+    AF_DIR_DOWN  = -2
+
+  } AF_Direction;
+
+
+  /* point hint flags */
+  typedef enum
+  {
+    AF_FLAG_NONE    = 0,
+
+   /* point type flags */
+    AF_FLAG_CONIC   = (1 << 0),
+    AF_FLAG_CUBIC   = (1 << 1),
+    AF_FLAG_CONTROL = AF_FLAG_CONIC | AF_FLAG_CUBIC,
+
+   /* point extremum flags */
+    AF_FLAG_EXTREMA_X = (1 << 2),
+    AF_FLAG_EXTREMA_Y = (1 << 3),
+
+   /* point roundness flags */
+    AF_FLAG_ROUND_X = (1 << 4),
+    AF_FLAG_ROUND_Y = (1 << 5),
+
+   /* point touch flags */
+    AF_FLAG_TOUCH_X = (1 << 6),
+    AF_FLAG_TOUCH_Y = (1 << 7),
+
+   /* candidates for weak interpolation have this flag set */
+    AF_FLAG_WEAK_INTERPOLATION = (1 << 8),
+
+   /* all inflection points in the outline have this flag set */
+    AF_FLAG_INFLECTION         = (1 << 9)
+
+  } AF_Flags;
+
+
+  /* edge hint flags */
+  typedef enum
+  {
+    AF_EDGE_NORMAL = 0,
+    AF_EDGE_ROUND  = (1 << 0),
+    AF_EDGE_SERIF  = (1 << 1),
+    AF_EDGE_DONE   = (1 << 2)
+
+  } AF_Edge_Flags;
+
+
+
+  typedef struct AF_PointRec_*    AF_Point;
+  typedef struct AF_SegmentRec_*  AF_Segment;
+  typedef struct AF_EdgeRec_*     AF_Edge;
+
+
+  typedef struct  AF_PointRec_
+  {
+    AF_Flags      flags;    /* point flags used by hinter */
+    FT_Pos        ox, oy;   /* original, scaled position  */
+    FT_Pos        fx, fy;   /* original, unscaled position (font units) */
+    FT_Pos        x,  y;    /* current position */
+    FT_Pos        u,  v;    /* current (x,y) or (y,x) depending on context */
+
+    AF_Direction  in_dir;   /* direction of inwards vector  */
+    AF_Direction  out_dir;  /* direction of outwards vector */
+
+    AF_Point      next;     /* next point in contour     */
+    AF_Point      prev;     /* previous point in contour */
+
+  } AF_PointRec;
+
+
+  typedef struct  AF_SegmentRec_
+  {
+    AF_Edge_Flags  flags;       /* edge/segment flags for this segment */
+    AF_Direction   dir;         /* segment direction                   */
+    FT_Pos         pos;         /* position of segment                 */
+    FT_Pos         min_coord;   /* minimum coordinate of segment       */
+    FT_Pos         max_coord;   /* maximum coordinate of segment       */
+
+    AF_Edge        edge;        /* the segment's parent edge */
+    AF_Segment     edge_next;   /* link to next segment in parent edge */
+
+    AF_Segment     link;        /* (stem) link segment        */
+    AF_Segment     serif;       /* primary segment for serifs */
+    FT_Pos         num_linked;  /* number of linked segments  */
+    FT_Pos         score;       /* used during stem matching  */
+
+    AF_Point       first;       /* first point in edge segment             */
+    AF_Point       last;        /* last point in edge segment              */
+    AF_Point*      contour;     /* ptr to first point of segment's contour */
+
+  } AF_SegmentRec;
+
+
+  typedef struct  AF_EdgeRec_
+  {
+    FT_Pos         fpos;       /* original, unscaled position (font units) */
+    FT_Pos         opos;       /* original, scaled position                */
+    FT_Pos         pos;        /* current position                         */
+
+    AF_Edge_Flags  flags;      /* edge flags */
+    AF_Direction   dir;        /* edge direction */
+    FT_Fixed       scale;      /* used to speed up interpolation between edges */
+    AF_Width       blue_edge;  /* non-NULL if this is a blue edge              */
+
+    AF_Edge        link;
+    AF_Edge        serif;
+    FT_Int         num_linked;
+
+    FT_Int         score;
+
+    AF_Segment     first;
+    AF_Segment     last;
+
+  } AF_EdgeRec;
+
+
+  typedef struct AF_AxisHintsRec_
+  {
+    FT_Int        num_segments;
+    AF_Segment    segments;
+
+    FT_Int        num_edges;
+    AF_Edge       edges;
+
+    AF_Direction  major_dir;
+
+  } AF_AxisHintsRec, *AF_AxisHints;
+
+
+  typedef struct AF_GlyphHintsRec_
+  {
+    FT_Memory     memory;
+
+    FT_Fixed      x_scale;
+    FT_Pos        x_delta;
+
+    FT_Fixed      y_scale;
+    FT_Pos        y_delta;
+
+    FT_Pos        edge_distance_threshold;
+
+    FT_Int        max_points;
+    FT_Int        num_points;
+    AF_Point      points;
+
+    FT_Int        max_contours;
+    FT_Int        num_contours;
+    AF_Point*     contours;
+
+    AF_AxisHintsRec  axis[ AF_DIMENSION_MAX ];
+    
+    FT_UInt32         scaler_flags;  /* copy of scaler flags */
+    FT_UInt32         other_flags;   /* free for script-specific implementations */
+    AF_ScriptMetrics  metrics;
+
+  } AF_GlyphHintsRec;
+
+
+#define  AF_HINTS_TEST_SCALER(h,f)  ( (h)->scaler_flags & (f) )
+#define  AF_HINTS_TEST_OTHER(h,f)   ( (h)->other_flags  & (f) )
+
+#define  AF_HINTS_DO_HORIZONTAL(h)  \
+            !AF_HINTS_TEST_SCALER(h,AF_SCALER_FLAG_NO_HORIZONTAL)
+
+#define  AF_HINTS_DO_VERTICAL(h)    \
+            !AF_HINTS_TEST_SCALER(h,AF_SCALER_FLAG_NO_VERTICAL)
+
+#define  AF_HINTS_DO_ADVANCE(h)     \
+            !AF_HINTS_TEST_SCALER(h,AF_SCALER_FLAG_NO_ADVANCE)
+
+
+  FT_LOCAL( AF_Direction )
+  af_direction_compute( FT_Pos  dx,
+                        FT_Pos  dy );
+
+
+  FT_LOCAL( void )
+  af_glyph_hints_init( AF_GlyphHints  hints,
+                       FT_Memory      memory );
+
+
+
+ /*  recomputes all AF_Point in a AF_GlyphHints from the definitions
+  *  in a source outline
+  */
+  FT_LOCAL( void )
+  af_glyph_hints_rescale( AF_GlyphHints     hints,
+                          AF_ScriptMetrics  metrics );
+
+  FT_LOCAL( FT_Error )
+  af_glyph_hints_reload( AF_GlyphHints     hints,
+                         FT_Outline*       outline );
+
+  FT_LOCAL( void )
+  af_glyph_hints_save( AF_GlyphHints   hints,
+                       FT_Outline*     outline );
+
+  FT_LOCAL( void )
+  af_glyph_hints_align_edge_points( AF_GlyphHints  hints,
+                                    AF_Dimension   dim );
+
+  FT_LOCAL( void )
+  af_glyph_hints_align_strong_points( AF_GlyphHints  hints,
+                                      AF_Dimension   dim );
+
+  FT_LOCAL( void )
+  af_glyph_hints_align_weak_points( AF_GlyphHints  hints,
+                                    AF_Dimension   dim );
+
+  FT_LOCAL( void )
+  af_glyph_hints_done( AF_GlyphHints  hints );
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __AFHINTS_H__ */
diff --git a/nx-X11/extras/freetype2/src/autofit/aflatin.c b/nx-X11/extras/freetype2/src/autofit/aflatin.c
new file mode 100644
index 000000000..ce0f8c961
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/aflatin.c
@@ -0,0 +1,1871 @@
+#include "aflatin.h"
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****       L A T I N   G L O B A L   M E T R I C S                   *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+  static void
+  af_latin_metrics_init_widths( AF_LatinMetrics  metrics,
+                                FT_Face          face )
+  {
+    /* scan the array of segments in each direction */
+    AF_GlyphHintsRec  hints[1];
+
+    af_glyph_hints_init( hints, face->memory );
+
+    metrics->axis[ AF_DIMENSION_HORZ ].width_count = 0;
+    metrics->axis[ AF_DIMENSION_VERT ].width_count = 0;
+
+    /* For now, compute the standard width and height from the `o' */
+    {
+      FT_Error      error;
+      FT_UInt       glyph_index;
+      AF_Dimension  dim;
+      AF_ScriptMetricsRec  dummy[1];
+      AF_Scaler            scaler = &dummy->scaler;
+
+      glyph_index = FT_Get_Char_Index( face, 'o' );
+      if ( glyph_index == 0 )
+        goto Exit;
+
+      error = FT_Load_Glyph( face, glyph_index, FT_LOAD_NO_SCALE );
+      if ( error || face->glyph->outline.n_points <= 0 )
+        goto Exit;
+
+      FT_ZERO( dummy );
+
+      scaler->x_scale     = scaler->y_scale = 0x10000L;
+      scaler->x_delta     = scaler->y_delta = 0;
+      scaler->face        = face;
+      scaler->render_mode = 0;
+      scaler->flags       = 0;
+
+      af_glyph_hints_rescale( hints, dummy );
+
+      error = af_glyph_hints_reload( hints, &face->glyph->outline );
+      if ( error )
+        goto Exit;
+
+      for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
+      {
+        AF_LatinAxis  axis    = & metrics->axis[ dim ];
+        AF_AxisHints  axhints = & hints->axis[ dim ];
+        AF_Segment    seg, limit, link;
+        FT_UInt       num_widths = 0;
+        FT_Pos        edge_distance_threshold = 32000;
+
+        af_latin_hints_compute_segments( hints, dim );
+        af_latin_hints_link_segments   ( hints, dim );
+
+        seg   = axhints->segments;
+        limit = seg + axhints->num_segments;
+
+        for ( ; seg < limit; seg++ )
+        {
+          link = seg->link;
+          /* we only consider stem segments there! */
+          if ( link && link->link == seg && link > seg )
+          {
+            FT_Pos  dist;
+
+
+            dist = seg->pos - link->pos;
+            if ( dist < 0 )
+              dist = -dist;
+
+            if ( num_widths < AF_LATIN_MAX_WIDTHS )
+              axis->widths[ num_widths++ ].org = dist;
+          }
+        }
+
+        af_sort_widths( num_widths, axis->widths );
+        axis->width_count = num_widths;
+
+        /* we will now try to find the smallest width */
+        if ( num_widths > 0 && axis->widths[0].org < edge_distance_threshold )
+          edge_distance_threshold = axis->widths[0].org;
+
+        /* Now, compute the edge distance threshold as a fraction of the */
+        /* smallest width in the font. Set it in `hinter->glyph' too!    */
+        if ( edge_distance_threshold == 32000 )
+          edge_distance_threshold = 50;
+
+        /* let's try 20% */
+        axis->edge_distance_threshold = edge_distance_threshold / 5;
+      }
+    }
+
+  Exit:
+    af_glyph_hints_done( hints );
+  }
+
+
+
+#define AF_LATIN_MAX_TEST_CHARACTERS  12
+
+
+  static  const char* const  af_latin_blue_chars[ AF_LATIN_MAX_BLUES ] =
+  {
+    "THEZOCQS",
+    "HEZLOCUS",
+    "fijkdbh",
+    "xzroesc",
+    "xzroesc",
+    "pqgjy"
+  };
+
+
+  static void
+  af_latin_metrics_init_blues( AF_LatinMetrics  metrics,
+                               FT_Face          face )
+  {
+    FT_Pos        flats [ AF_LATIN_MAX_TEST_CHARACTERS ];
+    FT_Pos        rounds[ AF_LATIN_MAX_TEST_CHARACTERS ];
+    FT_Int        num_flats;
+    FT_Int        num_rounds;
+    FT_Int        bb;
+    AF_LatinBlue  blue;
+    FT_Error      error;
+    AF_LatinAxis  axis  = &metrics->axis[ AF_DIMENSION_VERT ];
+    FT_GlyphSlot  glyph = face->glyph;
+
+    /* we compute the blues simply by loading each character from the    */
+    /* 'af_latin_blue_chars[blues]' string, then compute its top-most or */
+    /* bottom-most points (depending on `AF_IS_TOP_BLUE')                */
+
+    AF_LOG(( "blue zones computation\n" ));
+    AF_LOG(( "------------------------------------------------\n" ));
+
+    for ( bb = 0; bb < AF_LATIN_BLUE_MAX; bb++ )
+    {
+      const char*  p     = af_latin_blue_chars[bb];
+      const char*  limit = p + AF_LATIN_MAX_TEST_CHARACTERS;
+      FT_Pos*      blue_ref;
+      FT_Pos*      blue_shoot;
+
+      AF_LOG(( "blue %3d: ", bb ));
+
+      num_flats  = 0;
+      num_rounds = 0;
+
+      for ( ; p < limit && *p; p++ )
+      {
+        FT_UInt     glyph_index;
+        FT_Vector*  extremum;
+        FT_Vector*  points;
+        FT_Vector*  point_limit;
+        FT_Vector*  point;
+        FT_Bool     round;
+
+
+        AF_LOG(( "'%c'", *p ));
+
+        /* load the character in the face -- skip unknown or empty ones */
+        glyph_index = FT_Get_Char_Index( face, (FT_UInt)*p );
+        if ( glyph_index == 0 )
+          continue;
+
+        error = FT_Load_Glyph( face, glyph_index, FT_LOAD_NO_SCALE );
+        if ( error || glyph->outline.n_points <= 0 )
+          continue;
+
+        /* now compute min or max point indices and coordinates */
+        points      = glyph->outline.points;
+        point_limit = points + glyph->outline.n_points;
+        point       = points;
+        extremum    = point;
+        point++;
+
+        if ( AF_LATIN_IS_TOP_BLUE( bb ) )
+        {
+          for ( ; point < point_limit; point++ )
+            if ( point->y > extremum->y )
+              extremum = point;
+        }
+        else
+        {
+          for ( ; point < point_limit; point++ )
+            if ( point->y < extremum->y )
+              extremum = point;
+        }
+
+        AF_LOG(( "%5d", (int)extremum->y ));
+
+        /* now, check whether the point belongs to a straight or round  */
+        /* segment; we first need to find in which contour the extremum */
+        /* lies, then see its previous and next points                  */
+        {
+          FT_Int  idx = (FT_Int)( extremum - points );
+          FT_Int  n;
+          FT_Int  first, last, prev, next, end;
+          FT_Pos  dist;
+
+
+          last  = -1;
+          first = 0;
+
+          for ( n = 0; n < glyph->outline.n_contours; n++ )
+          {
+            end = glyph->outline.contours[n];
+            if ( end >= idx )
+            {
+              last = end;
+              break;
+            }
+            first = end + 1;
+          }
+
+          /* XXX: should never happen! */
+          if ( last < 0 )
+            continue;
+
+          /* now look for the previous and next points that are not on the */
+          /* same Y coordinate.  Threshold the `closeness'...              */
+
+          prev = idx;
+          next = prev;
+
+          do
+          {
+            if ( prev > first )
+              prev--;
+            else
+              prev = last;
+
+            dist = points[prev].y - extremum->y;
+            if ( dist < -5 || dist > 5 )
+              break;
+
+          } while ( prev != idx );
+
+          do
+          {
+            if ( next < last )
+              next++;
+            else
+              next = first;
+
+            dist = points[next].y - extremum->y;
+            if ( dist < -5 || dist > 5 )
+              break;
+
+          } while ( next != idx );
+
+          /* now, set the `round' flag depending on the segment's kind */
+          round = FT_BOOL(
+            FT_CURVE_TAG( glyph->outline.tags[prev] ) != FT_CURVE_TAG_ON ||
+            FT_CURVE_TAG( glyph->outline.tags[next] ) != FT_CURVE_TAG_ON );
+
+          AF_LOG(( "%c ", round ? 'r' : 'f' ));
+        }
+
+        if ( round )
+          rounds[num_rounds++] = extremum->y;
+        else
+          flats[num_flats++] = extremum->y;
+      }
+
+      AF_LOG(( "\n" ));
+
+      if ( num_flats == 0 && num_rounds == 0 )
+      {
+       /* we couldn't find a single glyph to compute this blue zone,
+        * we will simply ignore it then
+        */
+        AF_LOG(( "empty !!\n" ));
+        continue;
+      }
+
+      /* we have computed the contents of the `rounds' and `flats' tables, */
+      /* now determine the reference and overshoot position of the blue -- */
+      /* we simply take the median value after a simple sort               */
+      af_sort_pos( num_rounds, rounds );
+      af_sort_pos( num_flats,  flats );
+
+      blue       = & axis->blues[ axis->blue_count ];
+      blue_ref   = & blue->ref.org;
+      blue_shoot = & blue->shoot.org;
+
+      axis->blue_count ++;
+
+      if ( num_flats == 0 )
+      {
+        *blue_ref    =
+        *blue_shoot = rounds[num_rounds / 2];
+      }
+      else if ( num_rounds == 0 )
+      {
+        *blue_ref   =
+        *blue_shoot = flats[num_flats / 2];
+      }
+      else
+      {
+        *blue_ref   = flats[num_flats / 2];
+        *blue_shoot = rounds[num_rounds / 2];
+      }
+
+      /* there are sometimes problems: if the overshoot position of top     */
+      /* zones is under its reference position, or the opposite for bottom  */
+      /* zones.  We must thus check everything there and correct the errors */
+      if ( *blue_shoot != *blue_ref )
+      {
+        FT_Pos   ref      = *blue_ref;
+        FT_Pos   shoot    = *blue_shoot;
+        FT_Bool  over_ref = FT_BOOL( shoot > ref );
+
+
+        if ( AF_LATIN_IS_TOP_BLUE( bb ) ^ over_ref )
+          *blue_shoot = *blue_ref = ( shoot + ref ) / 2;
+      }
+
+      blue->flags = 0;
+      if ( AF_LATIN_IS_TOP_BLUE(bb) )
+        blue->flags |= AF_LATIN_BLUE_TOP;
+
+     /* the following flags is used later to adjust the y and x scales
+      * in order to optimize the pixel grid alignment of the top of small
+      * letters.
+      */
+      if ( bb == AF_LATIN_BLUE_SMALL_TOP )
+        blue->flags |= AF_LATIN_BLUE_ADJUSTMENT;
+
+      AF_LOG(( "-- ref = %ld, shoot = %ld\n", *blue_ref, *blue_shoot ));
+    }
+
+    return;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  af_latin_metrics_init( AF_LatinMetrics  metrics,
+                         FT_Face          face )
+  {
+    FT_Error      error;
+    FT_CharMap    oldmap = face->charmap;
+
+    /* do we have a Unicode charmap in there? */
+    error = FT_Select_Charmap( face, FT_ENCODING_UNICODE );
+    if ( error ) goto Exit;
+
+    metrics->units_per_em = face->units_per_EM;
+
+    af_latin_metrics_init_widths( metrics, face );
+    af_latin_metrics_init_blues( metrics, face );
+
+  Exit:
+    FT_Set_Charmap( face, oldmap );
+    return error;
+  }
+
+
+  static void
+  af_latin_metrics_scale_dim( AF_LatinMetrics   metrics,
+                              AF_Scaler         scaler,
+                              AF_Dimension      dim )
+  {
+    FT_Fixed      scale;
+    FT_Pos        delta;
+    AF_LatinAxis  axis;
+    FT_UInt       nn;
+
+    if ( dim == AF_DIMENSION_HORZ )
+    {
+      scale = scaler->x_scale;
+      delta = scaler->x_delta;
+    }
+    else
+    {
+      scale = scaler->y_scale;
+      delta = scaler->y_delta;
+    }
+
+    axis = & metrics->axis[ dim ];
+
+    if ( axis->org_scale == scale && axis->org_delta == delta )
+      return;
+
+    axis->org_scale = scale;
+    axis->org_delta = delta;
+
+   /* correct X and Y scale to optimize the alignment of the top of small
+    * letters to the pixel grid
+    */
+    {
+      AF_LatinAxis  axis  = &metrics->axis[ AF_DIMENSION_VERT ];
+      AF_LatinBlue  blue  = NULL;
+      FT_UInt       nn;
+
+      for ( nn = 0; nn < axis->blue_count; nn++ )
+      {
+        if ( axis->blues[nn].flags & AF_LATIN_BLUE_ADJUSTMENT )
+        {
+          blue = &axis->blues[nn];
+          break;
+        }
+      }
+
+      if ( blue )
+      {
+        FT_Pos  scaled = FT_MulFix( blue->shoot.org, scaler->y_scale );
+        FT_Pos  fitted = FT_PIX_ROUND( scaled );
+
+
+        if ( scaled != fitted )
+        {
+          if ( dim == AF_DIMENSION_HORZ )
+          {
+            if ( fitted < scaled )
+              scale -= scale/50;  /* x_scale = x_scale*0.98 */
+          }
+          else
+          {
+            scale = FT_MulDiv( scale, fitted, scaled );
+          }
+        }
+      }
+    }
+
+    axis->scale = scale;
+    axis->delta = delta;
+
+    if ( dim == AF_DIMENSION_HORZ )
+    {
+      metrics->root.scaler.x_scale = scale;
+      metrics->root.scaler.x_delta = delta;
+    }
+    else
+    {
+      metrics->root.scaler.y_scale = scale;
+      metrics->root.scaler.y_delta = delta;
+    }
+
+   /* scale the standard widths
+    */
+    for ( nn = 0; nn < axis->width_count; nn++ )
+    {
+      AF_Width  width = axis->widths + nn;
+
+      width->cur = FT_MulFix( width->org, scale );
+      width->fit = width->cur;
+    }
+
+    if ( dim == AF_DIMENSION_VERT )
+    {
+     /* scale the blue zones
+      */
+      for ( nn = 0; nn < axis->blue_count; nn++ )
+      {
+        AF_LatinBlue  blue  = & axis->blues[nn];
+        FT_Pos        dist;
+
+        blue->ref.cur   = FT_MulFix( blue->ref.org, scale ) + delta;
+        blue->ref.fit   = blue->ref.cur;
+        blue->shoot.cur = FT_MulFix( blue->shoot.org, scale ) + delta;
+        blue->shoot.fit = blue->shoot.cur;
+        blue->flags    &= ~AF_LATIN_BLUE_ACTIVE;
+
+       /* a blue zone is only active when it is less than 3/4 pixels tall
+        */
+        dist = FT_MulFix( blue->ref.org - blue->shoot.org, scale );
+        if ( dist <= 48 && dist >= -48 )
+        {
+          FT_Pos  delta, delta2;
+
+          delta  = blue->shoot.org - blue->ref.org;
+          delta2 = delta;
+          if ( delta < 0 )
+            delta2 = -delta2;
+
+          delta2 = FT_MulFix( delta2, scale );
+
+          if ( delta2 < 32 )
+            delta2 = 0;
+          else if ( delta2 < 64 )
+            delta2 = 32 + ( ( ( delta2 - 32 ) + 16 ) & ~31 );
+          else
+            delta2 = FT_PIX_ROUND( delta2 );
+
+          if ( delta < 0 )
+            delta2 = -delta2;
+
+          blue->ref.fit   = FT_PIX_ROUND( blue->ref.cur );
+          blue->shoot.fit = blue->ref.fit + delta2;
+
+          blue->flags |= AF_LATIN_BLUE_ACTIVE;
+        }
+      }
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_latin_metrics_scale( AF_LatinMetrics  metrics,
+                          AF_Scaler        scaler )
+  {
+    if ( AF_SCALER_EQUAL_SCALES( scaler, &metrics->root.scaler ) )
+      return;
+
+    af_latin_metrics_scale_dim( metrics, scaler, AF_DIMENSION_HORZ );
+    af_latin_metrics_scale_dim( metrics, scaler, AF_DIMENSION_VERT );
+  }
+
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****            L A T I N   G L Y P H   A N A L Y S I S              *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+  FT_LOCAL_DEF( void )
+  af_latin_hints_compute_segments( AF_GlyphHints  hints,
+                                   AF_Dimension   dim )
+  {
+    AF_AxisHints  axis = &hints->axis[dim];
+    AF_Segment    segments = axis->segments;
+    AF_Segment    segment       =  segments;
+    FT_Int        num_segments  =  0;
+    AF_Point*     contour       =  hints->contours;
+    AF_Point*     contour_limit =  contour + hints->num_contours;
+    AF_Direction  major_dir, segment_dir;
+
+#ifdef AF_HINT_METRICS
+    AF_Point    min_point     =  0;
+    AF_Point    max_point     =  0;
+    FT_Pos      min_coord     =  32000;
+    FT_Pos      max_coord     = -32000;
+#endif
+
+    major_dir   = FT_ABS( axis->major_dir );
+    segment_dir = major_dir;
+
+    /* set up (u,v) in each point */
+    if ( dim == AF_DIMENSION_HORZ )
+    {
+      AF_Point  point = hints->points;
+      AF_Point  limit = point + hints->num_points;
+
+      for ( ; point < limit; point++ )
+      {
+        point->u = point->fx;
+        point->v = point->fy;
+      }
+    }
+    else
+    {
+      AF_Point  point = hints->points;
+      AF_Point  limit = point + hints->num_points;
+
+      for ( ; point < limit; point++ )
+      {
+        point->u = point->fy;
+        point->v = point->fx;
+      }
+    }
+
+
+    /* do each contour separately */
+    for ( ; contour < contour_limit; contour++ )
+    {
+      AF_Point  point   =  contour[0];
+      AF_Point  last    =  point->prev;
+      int       on_edge =  0;
+      FT_Pos    min_pos =  32000;  /* minimum segment pos != min_coord */
+      FT_Pos    max_pos = -32000;  /* maximum segment pos != max_coord */
+      FT_Bool   passed;
+
+
+#ifdef AF_HINT_METRICS
+      if ( point->u < min_coord )
+      {
+        min_coord = point->u;
+        min_point = point;
+      }
+      if ( point->u > max_coord )
+      {
+        max_coord = point->u;
+        max_point = point;
+      }
+#endif
+
+      if ( point == last )  /* skip singletons -- just in case */
+        continue;
+
+      if ( FT_ABS( last->out_dir )  == major_dir &&
+           FT_ABS( point->out_dir ) == major_dir )
+      {
+        /* we are already on an edge, try to locate its start */
+        last = point;
+
+        for (;;)
+        {
+          point = point->prev;
+          if ( FT_ABS( point->out_dir ) != major_dir )
+          {
+            point = point->next;
+            break;
+          }
+          if ( point == last )
+            break;
+        }
+      }
+
+      last   = point;
+      passed = 0;
+
+      for (;;)
+      {
+        FT_Pos  u, v;
+
+
+        if ( on_edge )
+        {
+          u = point->u;
+          if ( u < min_pos )
+            min_pos = u;
+          if ( u > max_pos )
+            max_pos = u;
+
+          if ( point->out_dir != segment_dir || point == last )
+          {
+            /* we are just leaving an edge; record a new segment! */
+            segment->last = point;
+            segment->pos  = ( min_pos + max_pos ) >> 1;
+
+            /* a segment is round if either its first or last point */
+            /* is a control point                                   */
+            if ( ( segment->first->flags | point->flags ) &
+                   AF_FLAG_CONTROL                        )
+              segment->flags |= AF_EDGE_ROUND;
+
+            /* compute segment size */
+            min_pos = max_pos = point->v;
+
+            v = segment->first->v;
+            if ( v < min_pos )
+              min_pos = v;
+            if ( v > max_pos )
+              max_pos = v;
+
+            segment->min_coord = min_pos;
+            segment->max_coord = max_pos;
+
+            on_edge = 0;
+            num_segments++;
+            segment++;
+            /* fallthrough */
+          }
+        }
+
+        /* now exit if we are at the start/end point */
+        if ( point == last )
+        {
+          if ( passed )
+            break;
+          passed = 1;
+        }
+
+        if ( !on_edge && FT_ABS( point->out_dir ) == major_dir )
+        {
+          /* this is the start of a new segment! */
+          segment_dir = point->out_dir;
+
+          /* clear all segment fields */
+          FT_ZERO( segment );
+
+          segment->dir      = segment_dir;
+          segment->flags    = AF_EDGE_NORMAL;
+          min_pos = max_pos = point->u;
+          segment->first    = point;
+          segment->last     = point;
+          segment->contour  = contour;
+          segment->score    = 32000;
+          segment->link     = NULL;
+          on_edge           = 1;
+
+#ifdef AF_HINT_METRICS
+          if ( point == max_point )
+            max_point = 0;
+
+          if ( point == min_point )
+            min_point = 0;
+#endif
+        }
+
+        point = point->next;
+      }
+
+    } /* contours */
+
+#ifdef AF_HINT_METRICS
+    /* we need to ensure that there are edges on the left-most and  */
+    /* right-most points of the glyph in order to hint the metrics; */
+    /* we do this by inserting fake segments when needed            */
+    if ( dim == AF_DIMENSION_HORZ )
+    {
+      AF_Point  point       = hints->points;
+      AF_Point  point_limit = point + hints->num_points;
+
+      FT_Pos    min_pos =  32000;
+      FT_Pos    max_pos = -32000;
+
+
+      min_point = 0;
+      max_point = 0;
+
+      /* compute minimum and maximum points */
+      for ( ; point < point_limit; point++ )
+      {
+        FT_Pos  x = point->fx;
+
+
+        if ( x < min_pos )
+        {
+          min_pos   = x;
+          min_point = point;
+        }
+        if ( x > max_pos )
+        {
+          max_pos   = x;
+          max_point = point;
+        }
+      }
+
+      /* insert minimum segment */
+      if ( min_point )
+      {
+        /* clear all segment fields */
+        FT_ZERO( segment );
+
+        segment->dir   = segment_dir;
+        segment->flags = AF_EDGE_NORMAL;
+        segment->first = min_point;
+        segment->last  = min_point;
+        segment->pos   = min_pos;
+        segment->score = 32000;
+        segment->link  = NULL;
+
+        num_segments++;
+        segment++;
+      }
+
+      /* insert maximum segment */
+      if ( max_point )
+      {
+        /* clear all segment fields */
+        FT_ZERO( segment );
+
+        segment->dir   = segment_dir;
+        segment->flags = AF_EDGE_NORMAL;
+        segment->first = max_point;
+        segment->last  = max_point;
+        segment->pos   = max_pos;
+        segment->score = 32000;
+        segment->link  = NULL;
+
+        num_segments++;
+        segment++;
+      }
+    }
+#endif /* AF_HINT_METRICS */
+
+    axis->num_segments = num_segments;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_latin_hints_link_segments( AF_GlyphHints  hints,
+                                AF_Dimension   dim )
+  {
+    AF_AxisHints  axis          = &hints->axis[dim];
+    AF_Segment    segments      = axis->segments;
+    AF_Segment    segment_limit = segments + axis->num_segments;
+    AF_Direction  major_dir     = axis->major_dir;
+    AF_Segment    seg1, seg2;
+
+    /* now compare each segment to the others */
+    for ( seg1 = segments; seg1 < segment_limit; seg1++ )
+    {
+      /* the fake segments are introduced to hint the metrics -- */
+      /* we must never link them to anything                     */
+      if ( seg1->first == seg1->last || seg1->dir != major_dir )
+        continue;
+
+      for ( seg2 = segments; seg2 < segment_limit; seg2++ )
+        if ( seg2 != seg1 && seg1->dir + seg2->dir == 0 )
+        {
+          FT_Pos  pos1 = seg1->pos;
+          FT_Pos  pos2 = seg2->pos;
+          FT_Pos  dist = pos2 - pos1;
+
+
+          if ( dist < 0 )
+            continue;
+
+          {
+            FT_Pos  min = seg1->min_coord;
+            FT_Pos  max = seg1->max_coord;
+            FT_Pos  len, score;
+
+
+            if ( min < seg2->min_coord )
+              min = seg2->min_coord;
+
+            if ( max > seg2->max_coord )
+              max = seg2->max_coord;
+
+            len = max - min;
+            if ( len >= 8 )
+            {
+              score = dist + 3000 / len;
+
+              if ( score < seg1->score )
+              {
+                seg1->score = score;
+                seg1->link  = seg2;
+              }
+
+              if ( score < seg2->score )
+              {
+                seg2->score = score;
+                seg2->link  = seg1;
+              }
+            }
+          }
+        }
+    }
+
+    /* now, compute the `serif' segments */
+    for ( seg1 = segments; seg1 < segment_limit; seg1++ )
+    {
+      seg2 = seg1->link;
+
+      if ( seg2 )
+      {
+        seg2->num_linked++;
+        if ( seg2->link != seg1 )
+        {
+          seg1->link  = 0;
+          seg1->serif = seg2->link;
+        }
+      }
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_latin_hints_compute_edges( AF_GlyphHints  hints,
+                                AF_Dimension   dim )
+  {
+    AF_AxisHints  axis = &hints->axis[dim];
+    AF_LatinAxis  laxis = &((AF_LatinMetrics)hints->metrics)->axis[dim];
+    AF_Edge       edges = axis->edges;
+    AF_Edge       edge, edge_limit;
+
+    AF_Segment    segments = axis->segments;
+    AF_Segment    segment_limit = segments + axis->num_segments;
+    AF_Segment    seg;
+
+    AF_Direction  up_dir;
+    FT_Fixed      scale;
+    FT_Pos        edge_distance_threshold;
+
+
+    scale = ( dim == AF_DIMENSION_HORZ ) ? hints->x_scale
+                                         : hints->y_scale;
+
+    up_dir = ( dim == AF_DIMENSION_HORZ ) ? AF_DIR_UP
+                                          : AF_DIR_RIGHT;
+
+    /*********************************************************************/
+    /*                                                                   */
+    /* We will begin by generating a sorted table of edges for the       */
+    /* current direction.  To do so, we simply scan each segment and try */
+    /* to find an edge in our table that corresponds to its position.    */
+    /*                                                                   */
+    /* If no edge is found, we create and insert a new edge in the       */
+    /* sorted table.  Otherwise, we simply add the segment to the edge's */
+    /* list which will be processed in the second step to compute the    */
+    /* edge's properties.                                                */
+    /*                                                                   */
+    /* Note that the edges table is sorted along the segment/edge        */
+    /* position.                                                         */
+    /*                                                                   */
+    /*********************************************************************/
+
+    edge_distance_threshold = FT_MulFix( laxis->edge_distance_threshold,
+                                         scale );
+    if ( edge_distance_threshold > 64 / 4 )
+      edge_distance_threshold = 64 / 4;
+
+    edge_distance_threshold = FT_DivFix( edge_distance_threshold,
+                                         scale );
+
+    edge_limit = edges;
+    for ( seg = segments; seg < segment_limit; seg++ )
+    {
+      AF_Edge  found = 0;
+
+
+      /* look for an edge corresponding to the segment */
+      for ( edge = edges; edge < edge_limit; edge++ )
+      {
+        FT_Pos  dist;
+
+
+        dist = seg->pos - edge->fpos;
+        if ( dist < 0 )
+          dist = -dist;
+
+        if ( dist < edge_distance_threshold )
+        {
+          found = edge;
+          break;
+        }
+      }
+
+      if ( !found )
+      {
+        /* insert a new edge in the list and */
+        /* sort according to the position    */
+        while ( edge > edges && edge[-1].fpos > seg->pos )
+        {
+          edge[0] = edge[-1];
+          edge--;
+        }
+        edge_limit++;
+
+        /* clear all edge fields */
+        FT_ZERO( edge );
+
+        /* add the segment to the new edge's list */
+        edge->first    = seg;
+        edge->last     = seg;
+        edge->fpos     = seg->pos;
+        edge->opos     = edge->pos = FT_MulFix( seg->pos, scale );
+        seg->edge_next = seg;
+      }
+      else
+      {
+        /* if an edge was found, simply add the segment to the edge's */
+        /* list                                                       */
+        seg->edge_next        = edge->first;
+        edge->last->edge_next = seg;
+        edge->last            = seg;
+      }
+    }
+    axis->num_edges = (FT_Int)( edge_limit - edges );
+
+
+    /*********************************************************************/
+    /*                                                                   */
+    /* Good, we will now compute each edge's properties according to     */
+    /* segments found on its position.  Basically, these are:            */
+    /*                                                                   */
+    /*  - edge's main direction                                          */
+    /*  - stem edge, serif edge or both (which defaults to stem then)    */
+    /*  - rounded edge, straight or both (which defaults to straight)    */
+    /*  - link for edge                                                  */
+    /*                                                                   */
+    /*********************************************************************/
+
+    /* first of all, set the `edge' field in each segment -- this is */
+    /* required in order to compute edge links                       */
+
+    /* Note that I've tried to remove this loop, setting
+     * the "edge" field of each segment directly in the
+     * code above.  For some reason, it slows down execution
+     * speed -- on a Sun.
+     */
+    for ( edge = edges; edge < edge_limit; edge++ )
+    {
+      seg = edge->first;
+      if ( seg )
+        do
+        {
+          seg->edge = edge;
+          seg       = seg->edge_next;
+        }
+        while ( seg != edge->first );
+    }
+
+    /* now, compute each edge properties */
+    for ( edge = edges; edge < edge_limit; edge++ )
+    {
+      FT_Int  is_round    = 0;  /* does it contain round segments?    */
+      FT_Int  is_straight = 0;  /* does it contain straight segments? */
+      FT_Pos  ups         = 0;  /* number of upwards segments         */
+      FT_Pos  downs       = 0;  /* number of downwards segments       */
+
+
+      seg = edge->first;
+
+      do
+      {
+        FT_Bool  is_serif;
+
+
+        /* check for roundness of segment */
+        if ( seg->flags & AF_EDGE_ROUND )
+          is_round++;
+        else
+          is_straight++;
+
+        /* check for segment direction */
+        if ( seg->dir == up_dir )
+          ups   += seg->max_coord-seg->min_coord;
+        else
+          downs += seg->max_coord-seg->min_coord;
+
+        /* check for links -- if seg->serif is set, then seg->link must */
+        /* be ignored                                                   */
+        is_serif = (FT_Bool)( seg->serif && seg->serif->edge != edge );
+
+        if ( seg->link || is_serif )
+        {
+          AF_Edge     edge2;
+          AF_Segment  seg2;
+
+
+          edge2 = edge->link;
+          seg2  = seg->link;
+
+          if ( is_serif )
+          {
+            seg2  = seg->serif;
+            edge2 = edge->serif;
+          }
+
+          if ( edge2 )
+          {
+            FT_Pos  edge_delta;
+            FT_Pos  seg_delta;
+
+
+            edge_delta = edge->fpos - edge2->fpos;
+            if ( edge_delta < 0 )
+              edge_delta = -edge_delta;
+
+            seg_delta = seg->pos - seg2->pos;
+            if ( seg_delta < 0 )
+              seg_delta = -seg_delta;
+
+            if ( seg_delta < edge_delta )
+              edge2 = seg2->edge;
+          }
+          else
+            edge2 = seg2->edge;
+
+          if ( is_serif )
+          {
+            edge->serif   = edge2;
+            edge2->flags |= AF_EDGE_SERIF;
+          }
+          else
+            edge->link  = edge2;
+        }
+
+        seg = seg->edge_next;
+
+      } while ( seg != edge->first );
+
+      /* set the round/straight flags */
+      edge->flags = AF_EDGE_NORMAL;
+
+      if ( is_round > 0 && is_round >= is_straight )
+        edge->flags |= AF_EDGE_ROUND;
+
+      /* set the edge's main direction */
+      edge->dir = AF_DIR_NONE;
+
+      if ( ups > downs )
+        edge->dir = up_dir;
+
+      else if ( ups < downs )
+        edge->dir = -up_dir;
+
+      else if ( ups == downs )
+        edge->dir = 0;  /* both up and down! */
+
+      /* gets rid of serifs if link is set                */
+      /* XXX: This gets rid of many unpleasant artefacts! */
+      /*      Example: the `c' in cour.pfa at size 13     */
+
+      if ( edge->serif && edge->link )
+        edge->serif = 0;
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_latin_hints_detect_features( AF_GlyphHints  hints,
+                                  AF_Dimension   dim )
+  {
+    af_latin_hints_compute_segments( hints, dim );
+    af_latin_hints_link_segments   ( hints, dim );
+    af_latin_hints_compute_edges   ( hints, dim );
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_latin_hints_compute_blue_edges( AF_GlyphHints    hints,
+                                     AF_LatinMetrics  metrics )
+  {
+    AF_AxisHints  axis       = &hints->axis[ AF_DIMENSION_VERT ];
+    AF_Edge       edge       = axis->edges;
+    AF_Edge       edge_limit = edge + axis->num_edges;
+    AF_LatinAxis  latin      = &metrics->axis[ AF_DIMENSION_VERT ];
+    FT_Fixed      scale      = latin->scale;
+
+
+    /* compute which blue zones are active, i.e. have their scaled */
+    /* size < 3/4 pixels                                           */
+
+   /* for each horizontal edge search the blue zone which is closest */
+    for ( ; edge < edge_limit; edge++ )
+    {
+      FT_Int     bb;
+      AF_Width   best_blue = NULL;
+      FT_Pos     best_dist;  /* initial threshold */
+
+
+      /* compute the initial threshold as a fraction of the EM size */
+      best_dist = FT_MulFix( metrics->units_per_em / 40, scale );
+
+      if ( best_dist > 64 / 2 )
+        best_dist = 64 / 2;
+
+      for ( bb = 0; bb < AF_LATIN_BLUE_MAX; bb++ )
+      {
+        AF_LatinBlue  blue = latin->blues + bb;
+        FT_Bool       is_top_blue, is_major_dir;
+
+       /* skip inactive blue zones (i.e. those that are too small
+        */
+        if ( !(blue->flags & AF_LATIN_BLUE_ACTIVE) )
+          continue;
+
+        /* if it is a top zone, check for right edges -- if it is a bottom */
+        /* zone, check for left edges                                      */
+        /*                                                                 */
+        /* of course, that's for TrueType                                  */
+        is_top_blue  = (blue->flags & AF_LATIN_BLUE_TOP) != 0;
+        is_major_dir = FT_BOOL( edge->dir == axis->major_dir );
+
+        /* if it is a top zone, the edge must be against the major    */
+        /* direction; if it is a bottom zone, it must be in the major */
+        /* direction                                                  */
+        if ( is_top_blue ^ is_major_dir )
+        {
+          FT_Pos   dist;
+
+
+          /* first of all, compare it to the reference position */
+          dist = edge->fpos - blue->ref.org;
+          if ( dist < 0 )
+            dist = -dist;
+
+          dist = FT_MulFix( dist, scale );
+          if ( dist < best_dist )
+          {
+            best_dist = dist;
+            best_blue = & blue->ref;
+          }
+
+          /* now, compare it to the overshoot position if the edge is     */
+          /* rounded, and if the edge is over the reference position of a */
+          /* top zone, or under the reference position of a bottom zone   */
+          if ( edge->flags & AF_EDGE_ROUND && dist != 0 )
+          {
+            FT_Bool  is_under_ref = FT_BOOL( edge->fpos < blue->ref.org );
+
+
+            if ( is_top_blue ^ is_under_ref )
+            {
+              blue = latin->blues + bb;
+              dist = edge->fpos - blue->shoot.org;
+              if ( dist < 0 )
+                dist = -dist;
+
+              dist = FT_MulFix( dist, scale );
+              if ( dist < best_dist )
+              {
+                best_dist = dist;
+                best_blue = & blue->shoot;
+              }
+            }
+          }
+        }
+      }
+
+      if ( best_blue )
+        edge->blue_edge = best_blue;
+    }
+  }
+
+
+  static FT_Error
+  af_latin_hints_init( AF_GlyphHints    hints,
+                       AF_LatinMetrics  metrics )
+  {
+    FT_Render_Mode  mode;
+
+    af_glyph_hints_rescale( hints, (AF_ScriptMetrics)metrics );
+
+   /* correct x_scale and y_scale when needed, since they may have
+    * been modified af_latin_scale_dim above
+    */
+    hints->x_scale = metrics->axis[ AF_DIMENSION_HORZ ].scale;
+    hints->x_delta = metrics->axis[ AF_DIMENSION_HORZ ].delta;
+    hints->y_scale = metrics->axis[ AF_DIMENSION_VERT ].scale;
+    hints->y_delta = metrics->axis[ AF_DIMENSION_VERT ].delta;
+
+   /* compute flags depending on render mode, etc...
+    */
+
+    mode = metrics->root.scaler.render_mode;
+
+   /* we snap the width of vertical stems for the monochrome and
+    * horizontal LCD rendering targets only.
+    */
+    if ( mode == FT_RENDER_MODE_MONO || mode == FT_RENDER_MODE_LCD )
+      hints->other_flags |= AF_LATIN_HINTS_HORZ_SNAP;
+
+   /* we snap the width of horizontal stems for the monochrome and
+    * vertical LCD rendering targets only.
+    */
+    if ( mode == FT_RENDER_MODE_MONO || mode == FT_RENDER_MODE_LCD_V )
+      hints->other_flags |= AF_LATIN_HINTS_VERT_SNAP;
+
+   /* XXX
+    */
+    if ( mode != FT_RENDER_MODE_LIGHT )
+      hints->other_flags |= AF_LATIN_HINTS_STEM_ADJUST;
+
+    if ( mode == FT_RENDER_MODE_MONO )
+      hints->other_flags |= AF_LATIN_HINTS_MONO;
+
+    return 0;
+  }
+
+
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****         L A T I N   G L Y P H   G R I D - F I T T I N G         *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+  /* snap a given width in scaled coordinates to one of the */
+  /* current standard widths                                */
+  static FT_Pos
+  af_latin_snap_width( AF_Width  widths,
+                       FT_Int    count,
+                       FT_Pos    width )
+  {
+    int     n;
+    FT_Pos  best      = 64 + 32 + 2;
+    FT_Pos  reference = width;
+    FT_Pos  scaled;
+
+
+    for ( n = 0; n < count; n++ )
+    {
+      FT_Pos  w;
+      FT_Pos  dist;
+
+
+      w = widths[n].cur;
+      dist = width - w;
+      if ( dist < 0 )
+        dist = -dist;
+      if ( dist < best )
+      {
+        best      = dist;
+        reference = w;
+      }
+    }
+
+    scaled = FT_PIX_ROUND( reference );
+
+    if ( width >= reference )
+    {
+      if ( width < scaled + 48 )
+        width = reference;
+    }
+    else
+    {
+      if ( width > scaled - 48 )
+        width = reference;
+    }
+
+    return width;
+  }
+
+
+  /* compute the snapped width of a given stem */
+
+  static FT_Pos
+  af_latin_compute_stem_width( AF_GlyphHints  hints,
+                               AF_Dimension   dim,
+                               FT_Pos         width,
+                               AF_Edge_Flags  base_flags,
+                               AF_Edge_Flags  stem_flags )
+  {
+    AF_LatinMetrics  metrics  = (AF_LatinMetrics) hints->metrics;
+    AF_LatinAxis     axis     = & metrics->axis[ dim ];
+    FT_Pos           dist     = width;
+    FT_Int           sign     = 0;
+    FT_Int           vertical = AF_HINTS_DO_VERTICAL( hints );
+
+
+    if ( !AF_LATIN_HINTS_DO_STEM_ADJUST( hints ) )
+      return width;
+
+    if ( dist < 0 )
+    {
+      dist = -width;
+      sign = 1;
+    }
+
+    if ( (  vertical && !AF_LATIN_HINTS_DO_VERT_SNAP( hints ) ) ||
+         ( !vertical && !AF_LATIN_HINTS_DO_HORZ_SNAP( hints ) ) )
+    {
+      /* smooth hinting process: very lightly quantize the stem width */
+      /*                                                              */
+
+      /* leave the widths of serifs alone */
+
+      if ( ( stem_flags & AF_EDGE_SERIF ) && vertical && ( dist < 3 * 64 ) )
+        goto Done_Width;
+
+      else if ( ( base_flags & AF_EDGE_ROUND ) )
+      {
+        if ( dist < 80 )
+          dist = 64;
+      }
+      else if ( dist < 56 )
+        dist = 56;
+
+      if ( axis->width_count > 0 )
+      {
+        FT_Pos  delta;
+
+       /* compare to standard width
+        */
+        if ( axis->width_count > 0 )
+        {
+          delta = dist - axis->widths[0].cur;
+
+          if ( delta < 0 )
+            delta = -delta;
+
+          if ( delta < 40 )
+          {
+            dist = axis->widths[ 0 ].cur;
+            if ( dist < 48 )
+              dist = 48;
+
+            goto Done_Width;
+          }
+        }
+
+        if ( dist < 3 * 64 )
+        {
+          delta  = dist & 63;
+          dist  &= -64;
+
+          if ( delta < 10 )
+            dist += delta;
+
+          else if ( delta < 32 )
+            dist += 10;
+
+          else if ( delta < 54 )
+            dist += 54;
+
+          else
+            dist += delta;
+        }
+        else
+          dist = ( dist + 32 ) & ~63;
+      }
+    }
+    else
+    {
+      /* strong hinting process: snap the stem width to integer pixels */
+      /*                                                               */
+      dist = af_latin_snap_width( axis->widths, axis->width_count, dist );
+
+      if ( vertical )
+      {
+        /* in the case of vertical hinting, always round */
+        /* the stem heights to integer pixels            */
+        if ( dist >= 64 )
+          dist = ( dist + 16 ) & ~63;
+        else
+          dist = 64;
+      }
+      else
+      {
+        if ( AF_LATIN_HINTS_DO_MONO( hints ) )
+        {
+          /* monochrome horizontal hinting: snap widths to integer pixels */
+          /* with a different threshold                                   */
+          if ( dist < 64 )
+            dist = 64;
+          else
+            dist = ( dist + 32 ) & ~63;
+        }
+        else
+        {
+          /* for horizontal anti-aliased hinting, we adopt a more subtle */
+          /* approach: we strengthen small stems, round stems whose size */
+          /* is between 1 and 2 pixels to an integer, otherwise nothing  */
+          if ( dist < 48 )
+            dist = ( dist + 64 ) >> 1;
+
+          else if ( dist < 128 )
+            dist = ( dist + 22 ) & ~63;
+          else
+            /* round otherwise to prevent color fringes in LCD mode */
+            dist = ( dist + 32 ) & ~63;
+        }
+      }
+    }
+
+  Done_Width:
+    if ( sign )
+      dist = -dist;
+
+    return dist;
+  }
+
+
+
+  /* align one stem edge relative to the previous stem edge */
+  static void
+  af_latin_align_linked_edge( AF_GlyphHints  hints,
+                              AF_Dimension   dim,
+                              AF_Edge        base_edge,
+                              AF_Edge        stem_edge )
+  {
+    FT_Pos  dist = stem_edge->opos - base_edge->opos;
+
+    FT_Pos  fitted_width = af_latin_compute_stem_width( hints,
+                                                        dim,
+                                                        dist,
+                                                        base_edge->flags,
+                                                        stem_edge->flags );
+
+    stem_edge->pos = base_edge->pos + fitted_width;
+  }
+
+
+  static void
+  af_latin_align_serif_edge( AF_GlyphHints  hints,
+                             AF_Edge        base,
+                             AF_Edge        serif )
+  {
+    FT_UNUSED( hints );
+
+    serif->pos = base->pos + (serif->opos - base->opos);
+  }
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****       E D G E   H I N T I N G                                   ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( void )
+  af_latin_hint_edges( AF_GlyphHints   hints,
+                       AF_Dimension    dim )
+  {
+    AF_AxisHints  axis = & hints->axis[dim];
+    AF_Edge       edges = axis->edges;
+    AF_Edge       edge_limit = edges + axis->num_edges;
+    FT_Int        n_edges;
+    AF_Edge       edge;
+    AF_Edge       anchor = 0;
+    FT_Int        has_serifs = 0;
+
+
+    /* we begin by aligning all stems relative to the blue zone */
+    /* if needed -- that's only for horizontal edges            */
+    if ( dim == AF_DIMENSION_VERT )
+    {
+      for ( edge = edges; edge < edge_limit; edge++ )
+      {
+        AF_Width  blue;
+        AF_Edge   edge1, edge2;
+
+
+        if ( edge->flags & AF_EDGE_DONE )
+          continue;
+
+        blue  = edge->blue_edge;
+        edge1 = NULL;
+        edge2 = edge->link;
+
+        if ( blue )
+        {
+          edge1 = edge;
+        }
+        else if ( edge2 && edge2->blue_edge )
+        {
+          blue  = edge2->blue_edge;
+          edge1 = edge2;
+          edge2 = edge;
+        }
+
+        if ( !edge1 )
+          continue;
+
+        edge1->pos    = blue->fit;
+        edge1->flags |= AF_EDGE_DONE;
+
+        if ( edge2 && !edge2->blue_edge )
+        {
+          af_latin_align_linked_edge( hints, dim, edge1, edge2 );
+          edge2->flags |= AF_EDGE_DONE;
+        }
+
+        if ( !anchor )
+          anchor = edge;
+      }
+    }
+
+    /* now we will align all stem edges, trying to maintain the */
+    /* relative order of stems in the glyph                     */
+    for ( edge = edges; edge < edge_limit; edge++ )
+    {
+      AF_Edge  edge2;
+
+
+      if ( edge->flags & AF_EDGE_DONE )
+        continue;
+
+      /* skip all non-stem edges */
+      edge2 = edge->link;
+      if ( !edge2 )
+      {
+        has_serifs++;
+        continue;
+      }
+
+      /* now align the stem */
+
+      /* this should not happen, but it's better to be safe */
+      if ( edge2->blue_edge || edge2 < edge )
+      {
+        af_latin_align_linked_edge( hints, dim, edge2, edge );
+        edge->flags |= AF_EDGE_DONE;
+        continue;
+      }
+
+      if ( !anchor )
+      {
+        FT_Pos  org_len, org_center, cur_len;
+        FT_Pos  cur_pos1, error1, error2, u_off, d_off;
+
+
+        org_len = edge2->opos - edge->opos;
+        cur_len = af_latin_compute_stem_width( hints, dim, org_len,
+                                               edge->flags, edge2->flags );
+        if ( cur_len <= 64 )
+          u_off = d_off = 32;
+        else
+        {
+          u_off = 38;
+          d_off = 26;
+        }
+
+        if ( cur_len < 96 )
+        {
+          org_center = edge->opos + ( org_len >> 1 );
+
+          cur_pos1   = FT_PIX_ROUND( org_center );
+
+          error1 = org_center - ( cur_pos1 - u_off );
+          if ( error1 < 0 )
+            error1 = -error1;
+
+          error2 = org_center - ( cur_pos1 + d_off );
+          if ( error2 < 0 )
+            error2 = -error2;
+
+          if ( error1 < error2 )
+            cur_pos1 -= u_off;
+          else
+            cur_pos1 += d_off;
+
+          edge->pos  = cur_pos1 - cur_len / 2;
+          edge2->pos = cur_pos1 + cur_len / 2;
+
+        }
+        else
+          edge->pos = FT_PIX_ROUND( edge->opos );
+
+        anchor = edge;
+
+        edge->flags |= AF_EDGE_DONE;
+
+        af_latin_align_linked_edge( hints, dim, edge, edge2 );
+      }
+      else
+      {
+        FT_Pos  org_pos, org_len, org_center, cur_len;
+        FT_Pos  cur_pos1, cur_pos2, delta1, delta2;
+
+
+        org_pos    = anchor->pos + ( edge->opos - anchor->opos );
+        org_len    = edge2->opos - edge->opos;
+        org_center = org_pos + ( org_len >> 1 );
+
+        cur_len = af_latin_compute_stem_width( hints, dim, org_len,
+                                               edge->flags, edge2->flags  );
+
+        if ( cur_len < 96 )
+        {
+          FT_Pos  u_off, d_off;
+
+
+          cur_pos1 = FT_PIX_ROUND( org_center );
+
+          if (cur_len <= 64 )
+            u_off = d_off = 32;
+          else
+          {
+            u_off = 38;
+            d_off = 26;
+          }
+
+          delta1 = org_center - ( cur_pos1 - u_off );
+          if ( delta1 < 0 )
+            delta1 = -delta1;
+
+          delta2 = org_center - ( cur_pos1 + d_off );
+          if ( delta2 < 0 )
+            delta2 = -delta2;
+
+          if ( delta1 < delta2 )
+            cur_pos1 -= u_off;
+          else
+            cur_pos1 += d_off;
+
+          edge->pos  = cur_pos1 - cur_len / 2;
+          edge2->pos = cur_pos1 + cur_len / 2;
+        }
+        else
+        {
+          org_pos    = anchor->pos + ( edge->opos - anchor->opos );
+          org_len    = edge2->opos - edge->opos;
+          org_center = org_pos + ( org_len >> 1 );
+
+          cur_len    = af_latin_compute_stem_width( hints, dim, org_len,
+                                                    edge->flags, edge2->flags );
+
+          cur_pos1   = FT_PIX_ROUND( org_pos );
+          delta1     = ( cur_pos1 + ( cur_len >> 1 ) - org_center );
+          if ( delta1 < 0 )
+            delta1 = -delta1;
+
+          cur_pos2   = FT_PIX_ROUND( org_pos + org_len ) - cur_len;
+          delta2     = ( cur_pos2 + ( cur_len >> 1 ) - org_center );
+          if ( delta2 < 0 )
+            delta2 = -delta2;
+
+          edge->pos  = ( delta1 < delta2 ) ? cur_pos1 : cur_pos2;
+          edge2->pos = edge->pos + cur_len;
+        }
+
+        edge->flags  |= AF_EDGE_DONE;
+        edge2->flags |= AF_EDGE_DONE;
+
+        if ( edge > edges && edge->pos < edge[-1].pos )
+          edge->pos = edge[-1].pos;
+      }
+    }
+
+    /* make sure that lowercase m's maintain their symmetry */
+
+    /* In general, lowercase m's have six vertical edges if they are sans */
+    /* serif, or twelve if they are avec serif.  This implementation is   */
+    /* based on that assumption, and seems to work very well with most    */
+    /* faces.  However, if for a certain face this assumption is not      */
+    /* true, the m is just rendered like before.  In addition, any stem   */
+    /* correction will only be applied to symmetrical glyphs (even if the */
+    /* glyph is not an m), so the potential for unwanted distortion is    */
+    /* relatively low.                                                    */
+
+    /* We don't handle horizontal edges since we can't easily assure that */
+    /* the third (lowest) stem aligns with the base line; it might end up */
+    /* one pixel higher or lower.                                         */
+
+    n_edges = edge_limit - edges;
+    if ( dim == AF_DIMENSION_HORZ && ( n_edges == 6 || n_edges == 12 ) )
+    {
+      AF_Edge  edge1, edge2, edge3;
+      FT_Pos   dist1, dist2, span, delta;
+
+
+      if ( n_edges == 6 )
+      {
+        edge1 = edges;
+        edge2 = edges + 2;
+        edge3 = edges + 4;
+      }
+      else
+      {
+        edge1 = edges + 1;
+        edge2 = edges + 5;
+        edge3 = edges + 9;
+      }
+
+      dist1 = edge2->opos - edge1->opos;
+      dist2 = edge3->opos - edge2->opos;
+
+      span = dist1 - dist2;
+      if ( span < 0 )
+        span = -span;
+
+      if ( span < 8 )
+      {
+        delta = edge3->pos - ( 2 * edge2->pos - edge1->pos );
+        edge3->pos -= delta;
+        if ( edge3->link )
+          edge3->link->pos -= delta;
+
+        /* move the serifs along with the stem */
+        if ( n_edges == 12 )
+        {
+          ( edges + 8 )->pos -= delta;
+          ( edges + 11 )->pos -= delta;
+        }
+
+        edge3->flags |= AF_EDGE_DONE;
+        if ( edge3->link )
+          edge3->link->flags |= AF_EDGE_DONE;
+      }
+    }
+
+    if ( has_serifs || !anchor )
+    {
+     /* now hint the remaining edges (serifs and single) in order
+      * to complete our processing
+      */
+      for ( edge = edges; edge < edge_limit; edge++ )
+      {
+        if ( edge->flags & AF_EDGE_DONE )
+          continue;
+
+        if ( edge->serif )
+          af_latin_align_serif_edge( hints, edge->serif, edge );
+        else if ( !anchor )
+        {
+          edge->pos = FT_PIX_ROUND( edge->opos );
+          anchor    = edge;
+        }
+        else
+          edge->pos = anchor->pos +
+                      FT_PIX_ROUND( edge->opos - anchor->opos );
+
+        edge->flags |= AF_EDGE_DONE;
+
+        if ( edge > edges && edge->pos < edge[-1].pos )
+          edge->pos = edge[-1].pos;
+
+        if ( edge + 1 < edge_limit        &&
+             edge[1].flags & AF_EDGE_DONE &&
+             edge->pos > edge[1].pos      )
+          edge->pos = edge[1].pos;
+      }
+    }
+  }
+
+
+  static FT_Error
+  af_latin_hints_apply( AF_GlyphHints    hints,
+                        FT_Outline*      outline,
+                        AF_LatinMetrics  metrics )
+  {
+    FT_Error      error;
+    AF_Dimension  dim;
+
+    error = af_glyph_hints_reload( hints, outline );
+    if ( error )
+      goto Exit;
+
+   /* analyze glyph outline
+    */
+    if ( AF_HINTS_DO_HORIZONTAL(hints) )
+      af_latin_hints_detect_features( hints, AF_DIMENSION_HORZ );
+
+    if ( AF_HINTS_DO_VERTICAL(hints) )
+    {
+      af_latin_hints_detect_features( hints, AF_DIMENSION_VERT );
+      af_latin_hints_compute_blue_edges( hints, metrics );
+    }
+
+   /* grid-fit the outline
+    */
+    for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
+    {
+      if ( (dim == AF_DIMENSION_HORZ && AF_HINTS_DO_HORIZONTAL(hints)) ||
+           (dim == AF_DIMENSION_VERT && AF_HINTS_DO_VERTICAL(hints))   )
+      {
+        af_latin_hint_edges( hints, dim );
+        af_glyph_hints_align_edge_points( hints, dim );
+        af_glyph_hints_align_strong_points( hints, dim );
+        af_glyph_hints_align_weak_points( hints, dim );
+      }
+    }
+    af_glyph_hints_save( hints, outline );
+
+  Exit:
+    return error;
+  }
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****      L A T I N   S C R I P T   C L A S S                        *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+  static const AF_Script_UniRangeRec  af_latin_uniranges[] =
+  {
+    { 32,  127 },    /* XXX: TODO: Add new Unicode ranges here !! */
+    { 160, 255 },
+    { 0,   0 }
+  };
+
+
+  FT_LOCAL_DEF( const AF_ScriptClassRec )  af_latin_script_class =
+  {
+    AF_SCRIPT_LATIN,
+    af_latin_uniranges,
+
+    sizeof( AF_LatinMetricsRec ),
+    (AF_Script_InitMetricsFunc)  af_latin_metrics_init,
+    (AF_Script_ScaleMetricsFunc) af_latin_metrics_scale,
+    (AF_Script_DoneMetricsFunc)  NULL,
+
+    (AF_Script_InitHintsFunc)    af_latin_hints_init,
+    (AF_Script_ApplyHintsFunc)   af_latin_hints_apply
+  };
+
diff --git a/nx-X11/extras/freetype2/src/autofit/aflatin.h b/nx-X11/extras/freetype2/src/autofit/aflatin.h
new file mode 100644
index 000000000..e7e8e4842
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/aflatin.h
@@ -0,0 +1,169 @@
+#ifndef __AFLATIN_H__
+#define __AFLATIN_H__
+
+#include "afhints.h"
+
+FT_BEGIN_HEADER
+
+ /*
+  * the latin-specific script class
+  *
+  */
+  FT_LOCAL( const AF_ScriptClassRec )    af_latin_script_class;
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****       L A T I N   G L O B A L   M E T R I C S                   *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+ /*
+  * the following declarations could be embedded in the file "aflatin.c"
+  * they've been made semi-public to allow alternate script hinters to
+  * re-use some of them
+  */
+
+ /*
+  *  Latin (global) metrics management
+  *
+  */
+
+  enum
+  {
+    AF_LATIN_BLUE_CAPITAL_TOP,
+    AF_LATIN_BLUE_CAPITAL_BOTTOM,
+    AF_LATIN_BLUE_SMALL_F_TOP,
+    AF_LATIN_BLUE_SMALL_TOP,
+    AF_LATIN_BLUE_SMALL_BOTTOM,
+    AF_LATIN_BLUE_SMALL_MINOR,
+
+    AF_LATIN_BLUE_MAX
+  };
+
+#define AF_LATIN_IS_TOP_BLUE( b )  ( (b) == AF_LATIN_BLUE_CAPITAL_TOP || \
+                                     (b) == AF_LATIN_BLUE_SMALL_F_TOP || \
+                                     (b) == AF_LATIN_BLUE_SMALL_TOP   )
+
+#define  AF_LATIN_MAX_WIDTHS     16
+#define  AF_LATIN_MAX_BLUES      AF_LATIN_BLUE_MAX
+
+  enum
+  {
+    AF_LATIN_BLUE_ACTIVE     = (1 << 0),
+    AF_LATIN_BLUE_TOP        = (1 << 1),
+    AF_LATIN_BLUE_ADJUSTMENT = (1 << 2),  /* used for scale adjustment */
+                                          /* optimization              */
+    AF_LATIN_BLUE_FLAG_MAX
+  };
+
+
+  typedef struct AF_LatinBlueRec_
+  {
+    AF_WidthRec   ref;
+    AF_WidthRec   shoot;
+    FT_UInt       flags;
+
+  } AF_LatinBlueRec, *AF_LatinBlue;
+
+
+  typedef struct AF_LatinAxisRec_
+  {
+    FT_Fixed         scale;
+    FT_Pos           delta;
+
+    FT_UInt          width_count;
+    AF_WidthRec      widths[ AF_LATIN_MAX_WIDTHS ];
+    FT_Pos           edge_distance_threshold;
+
+   /* ignored for horizontal metrics */
+    FT_Bool          control_overshoot;
+    FT_UInt          blue_count;
+    AF_LatinBlueRec  blues[ AF_LATIN_BLUE_MAX ];
+
+    FT_Fixed         org_scale;
+    FT_Pos           org_delta;
+
+  } AF_LatinAxisRec, *AF_LatinAxis;
+
+
+  typedef struct AF_LatinMetricsRec_
+  {
+    AF_ScriptMetricsRec   root;
+    FT_UInt               units_per_em;
+    AF_LatinAxisRec       axis[ AF_DIMENSION_MAX ];
+
+  } AF_LatinMetricsRec, *AF_LatinMetrics;
+
+
+
+  FT_LOCAL( FT_Error )
+  af_latin_metrics_init( AF_LatinMetrics  metrics,
+                         FT_Face          face );
+
+  FT_LOCAL( void )
+  af_latin_metrics_scale( AF_LatinMetrics  metrics,
+                          AF_Scaler        scaler );
+
+
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****            L A T I N   G L Y P H   A N A L Y S I S              *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+  enum
+  {
+    AF_LATIN_HINTS_HORZ_SNAP   = (1 << 0),  /* enable stem width snapping  */
+    AF_LATIN_HINTS_VERT_SNAP   = (1 << 1),  /* enable stem height snapping */
+    AF_LATIN_HINTS_STEM_ADJUST = (1 << 2),  /* enable stem width/height adjustment */
+    AF_LATIN_HINTS_MONO        = (1 << 3)   /* indicate monochrome rendering */
+  };
+
+#define  AF_LATIN_HINTS_DO_HORZ_SNAP(h) \
+   AF_HINTS_TEST_OTHER(h,AF_LATIN_HINTS_HORZ_SNAP)
+
+#define  AF_LATIN_HINTS_DO_VERT_SNAP(h) \
+   AF_HINTS_TEST_OTHER(h,AF_LATIN_HINTS_VERT_SNAP)
+
+#define  AF_LATIN_HINTS_DO_STEM_ADJUST(h)  \
+   AF_HINTS_TEST_OTHER(h,AF_LATIN_HINTS_STEM_ADJUST)
+
+#define  AF_LATIN_HINTS_DO_MONO(h)  \
+   AF_HINTS_TEST_OTHER(h,AF_LATIN_HINTS_MONO)
+
+
+ /* this shouldn't normally be exported. However, other scripts might
+  * like to use this function as-is
+  */
+  FT_LOCAL( void )
+  af_latin_hints_compute_segments( AF_GlyphHints  hints,
+                                   AF_Dimension   dim );
+
+ /* this shouldn't normally be exported. However, other scripts might
+  * want to use this function as-is
+  */
+  FT_LOCAL( void )
+  af_latin_hints_link_segments( AF_GlyphHints  hints,
+                                AF_Dimension   dim );
+
+ /* this shouldn't normally be exported. However, other scripts might
+  * want to use this function as-is
+  */
+  FT_LOCAL( void )
+  af_latin_hints_compute_edges( AF_GlyphHints  hints,
+                                AF_Dimension   dim );
+
+  FT_LOCAL( void )
+  af_latin_hints_detect_features( AF_GlyphHints  hints,
+                                  AF_Dimension   dim );
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __AFLATIN_H__ */
diff --git a/nx-X11/extras/freetype2/src/autofit/afloader.c b/nx-X11/extras/freetype2/src/autofit/afloader.c
new file mode 100644
index 000000000..6782ee8de
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afloader.c
@@ -0,0 +1,467 @@
+#include "afloader.h"
+#include "afhints.h"
+#include "afglobal.h"
+#include "aflatin.h"
+
+  FT_LOCAL_DEF( FT_Error )
+  af_loader_init( AF_Loader  loader,
+                  FT_Memory  memory )
+  {
+    FT_Error  error;
+
+    FT_ZERO( loader );
+
+    af_glyph_hints_init( &loader->hints, memory );
+
+    error = FT_GlyphLoader_New( memory, &loader->gloader );
+    if ( !error )
+    {
+      error = FT_GlyphLoader_CreateExtra( loader->gloader );
+      if ( error )
+      {
+        FT_GlyphLoader_Done( loader->gloader );
+        loader->gloader = NULL;
+      }
+    }
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  af_loader_reset( AF_Loader   loader,
+                   FT_Face     face )
+  {
+    FT_Error   error = 0;
+
+    loader->face    = face;
+    loader->globals = (AF_FaceGlobals) face->autohint.data;
+
+    FT_GlyphLoader_Rewind( loader->gloader );
+
+    if ( loader->globals == NULL )
+    {
+      error = af_face_globals_new( face, &loader->globals );
+      if ( !error )
+      {
+        face->autohint.data      = (FT_Pointer) loader->globals;
+        face->autohint.finalizer = (FT_Generic_Finalizer) af_face_globals_free;
+      }
+    }
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  af_loader_done( AF_Loader   loader )
+  {
+    loader->face    = NULL;
+    loader->globals = NULL;
+
+    FT_GlyphLoader_Done( loader->gloader );
+    loader->gloader = NULL;
+  }
+
+
+  static FT_Error
+  af_loader_load_g( AF_Loader  loader,
+                    AF_Scaler  scaler,
+                    FT_UInt    glyph_index,
+                    FT_Int32   load_flags,
+                    FT_UInt    depth )
+  {
+    FT_Error          error    = 0;
+    FT_Face           face     = loader->face;
+    FT_GlyphLoader    gloader  = loader->gloader;
+    AF_ScriptMetrics  metrics  = loader->metrics;
+    AF_GlyphHints     hints    = &loader->hints;
+    FT_GlyphSlot      slot     = face->glyph;
+    FT_Slot_Internal  internal = slot->internal;
+
+    error = FT_Load_Glyph( face, glyph_index, load_flags );
+    if ( error )
+      goto Exit;
+
+    loader->transformed = internal->glyph_transformed;
+    if ( loader->transformed )
+    {
+      FT_Matrix  inverse;
+
+      loader->trans_matrix = internal->glyph_matrix;
+      loader->trans_delta  = internal->glyph_delta;
+
+      inverse = loader->trans_matrix;
+      FT_Matrix_Invert( &inverse );
+      FT_Vector_Transform( &loader->trans_delta, &inverse );
+    }
+
+    /* set linear metrics */
+    slot->linearHoriAdvance = slot->metrics.horiAdvance;
+    slot->linearVertAdvance = slot->metrics.vertAdvance;
+
+    switch ( slot->format )
+    {
+      case FT_GLYPH_FORMAT_OUTLINE:
+       /* translate the loaded glyph when an internal transform
+        * is needed
+        */
+        if ( loader->transformed )
+          FT_Outline_Translate( &slot->outline,
+                                loader->trans_delta.x,
+                                loader->trans_delta.y );
+
+        /* copy the outline points in the loader's current               */
+        /* extra points which is used to keep original glyph coordinates */
+        error = FT_GlyphLoader_CheckPoints( gloader,
+                                            slot->outline.n_points + 4,
+                                            slot->outline.n_contours );
+        if ( error )
+          goto Exit;
+
+        FT_ARRAY_COPY( gloader->current.outline.points,
+                       slot->outline.points,
+                       slot->outline.n_points );
+
+        FT_ARRAY_COPY( gloader->current.extra_points,
+                       slot->outline.points,
+                       slot->outline.n_points );
+
+        FT_ARRAY_COPY( gloader->current.outline.contours,
+                       slot->outline.contours,
+                       slot->outline.n_contours );
+
+        FT_ARRAY_COPY( gloader->current.outline.tags,
+                       slot->outline.tags,
+                       slot->outline.n_points );
+
+        gloader->current.outline.n_points   = slot->outline.n_points;
+        gloader->current.outline.n_contours = slot->outline.n_contours;
+
+        /* compute original horizontal phantom points (and ignore */
+        /* vertical ones)                                         */
+        loader->pp1.x = hints->x_delta;
+        loader->pp1.y = hints->y_delta;
+        loader->pp2.x = FT_MulFix( slot->metrics.horiAdvance,
+                                   hints->x_scale ) + hints->x_delta;
+        loader->pp2.y = hints->y_delta;
+
+        /* be sure to check for spacing glyphs */
+        if ( slot->outline.n_points == 0 )
+          goto Hint_Metrics;
+
+        /* now load the slot image into the auto-outline and run the */
+        /* automatic hinting process                                 */
+        metrics->clazz->script_hints_apply( hints,
+                                            &gloader->current.outline,
+                                            metrics );
+
+        /* we now need to hint the metrics according to the change in */
+        /* width/positioning that occured during the hinting process  */
+        {
+          FT_Pos        old_advance, old_rsb, old_lsb, new_lsb;
+          FT_Pos        pp1x_uh, pp2x_uh;
+          AF_AxisHints  axis  = &hints->axis[ AF_DIMENSION_HORZ ];
+          AF_Edge       edge1 = axis->edges;         /* leftmost edge  */
+          AF_Edge       edge2 = edge1 +
+                                axis->num_edges - 1; /* rightmost edge */
+
+
+          if ( edge2 > edge1 )
+          {
+            old_advance = loader->pp2.x;
+            old_rsb     = old_advance - edge2->opos;
+            old_lsb     = edge1->opos;
+            new_lsb     = edge1->pos;
+
+            /* remember unhinted values to later account */
+            /* for rounding errors                       */
+
+            pp1x_uh = new_lsb    - old_lsb;
+            pp2x_uh = edge2->pos + old_rsb;
+
+            /* prefer too much space over too little space */
+            /* for very small sizes                        */
+
+            if ( old_lsb < 24 )
+              pp1x_uh -= 5;
+
+            if ( old_rsb < 24 )
+              pp2x_uh += 5;
+
+            loader->pp1.x = FT_PIX_ROUND( pp1x_uh );
+            loader->pp2.x = FT_PIX_ROUND( pp2x_uh );
+
+            slot->lsb_delta = loader->pp1.x - pp1x_uh;
+            slot->rsb_delta = loader->pp2.x - pp2x_uh;
+
+#if 0
+            /* try to fix certain bad advance computations */
+            if ( loader->pp2.x + loader->pp1.x == edge2->pos && old_rsb > 4 )
+              loader->pp2.x += 64;
+#endif
+          }
+          else
+          {
+            loader->pp1.x = FT_PIX_ROUND( loader->pp1.x );
+            loader->pp2.x = FT_PIX_ROUND( loader->pp2.x );
+          }
+        }
+
+        /* good, we simply add the glyph to our loader's base */
+        FT_GlyphLoader_Add( gloader );
+        break;
+
+    case FT_GLYPH_FORMAT_COMPOSITE:
+      {
+        FT_UInt      nn, num_subglyphs = slot->num_subglyphs;
+        FT_UInt      num_base_subgs, start_point;
+        FT_SubGlyph  subglyph;
+
+
+        start_point = gloader->base.outline.n_points;
+
+        /* first of all, copy the subglyph descriptors in the glyph loader */
+        error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs );
+        if ( error )
+          goto Exit;
+
+        FT_ARRAY_COPY( gloader->current.subglyphs,
+                       slot->subglyphs,
+                       num_subglyphs );
+
+        gloader->current.num_subglyphs = num_subglyphs;
+        num_base_subgs = gloader->base.num_subglyphs;
+
+        /* now, read each subglyph independently */
+        for ( nn = 0; nn < num_subglyphs; nn++ )
+        {
+          FT_Vector  pp1, pp2;
+          FT_Pos     x, y;
+          FT_UInt    num_points, num_new_points, num_base_points;
+
+
+          /* gloader.current.subglyphs can change during glyph loading due */
+          /* to re-allocation -- we must recompute the current subglyph on */
+          /* each iteration                                                */
+          subglyph = gloader->base.subglyphs + num_base_subgs + nn;
+
+          pp1 = loader->pp1;
+          pp2 = loader->pp2;
+
+          num_base_points = gloader->base.outline.n_points;
+
+          error = af_loader_load_g( loader, scaler, subglyph->index,
+                                    load_flags, depth + 1 );
+          if ( error )
+            goto Exit;
+
+          /* recompute subglyph pointer */
+          subglyph = gloader->base.subglyphs + num_base_subgs + nn;
+
+          if ( subglyph->flags & FT_SUBGLYPH_FLAG_USE_MY_METRICS )
+          {
+            pp1 = loader->pp1;
+            pp2 = loader->pp2;
+          }
+          else
+          {
+            loader->pp1 = pp1;
+            loader->pp2 = pp2;
+          }
+
+          num_points     = gloader->base.outline.n_points;
+          num_new_points = num_points - num_base_points;
+
+          /* now perform the transform required for this subglyph */
+
+          if ( subglyph->flags & ( FT_SUBGLYPH_FLAG_SCALE    |
+                                   FT_SUBGLYPH_FLAG_XY_SCALE |
+                                   FT_SUBGLYPH_FLAG_2X2      ) )
+          {
+            FT_Vector*  cur   = gloader->base.outline.points +
+                                num_base_points;
+            FT_Vector*  org   = gloader->base.extra_points +
+                                num_base_points;
+            FT_Vector*  limit = cur + num_new_points;
+
+
+            for ( ; cur < limit; cur++, org++ )
+            {
+              FT_Vector_Transform( cur, &subglyph->transform );
+              FT_Vector_Transform( org, &subglyph->transform );
+            }
+          }
+
+          /* apply offset */
+
+          if ( !( subglyph->flags & FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES ) )
+          {
+            FT_Int      k = subglyph->arg1;
+            FT_UInt     l = subglyph->arg2;
+            FT_Vector*  p1;
+            FT_Vector*  p2;
+
+
+            if ( start_point + k >= num_base_points         ||
+                               l >= (FT_UInt)num_new_points )
+            {
+              error = FT_Err_Invalid_Composite;
+              goto Exit;
+            }
+
+            l += num_base_points;
+
+            /* for now, only use the current point coordinates;    */
+            /* we may consider another approach in the near future */
+            p1 = gloader->base.outline.points + start_point + k;
+            p2 = gloader->base.outline.points + start_point + l;
+
+            x = p1->x - p2->x;
+            y = p1->y - p2->y;
+          }
+          else
+          {
+            x = FT_MulFix( subglyph->arg1, hints->x_scale ) + hints->x_delta;
+            y = FT_MulFix( subglyph->arg2, hints->y_scale ) + hints->y_delta;
+
+            x = FT_PIX_ROUND(x);
+            y = FT_PIX_ROUND(y);
+          }
+
+          {
+            FT_Outline  dummy = gloader->base.outline;
+
+
+            dummy.points  += num_base_points;
+            dummy.n_points = (short)num_new_points;
+
+            FT_Outline_Translate( &dummy, x, y );
+          }
+        }
+      }
+      break;
+
+    default:
+      /* we don't support other formats (yet?) */
+      error = FT_Err_Unimplemented_Feature;
+    }
+
+  Hint_Metrics:
+    if ( depth == 0 )
+    {
+      FT_BBox  bbox;
+
+
+      /* transform the hinted outline if needed */
+      if ( loader->transformed )
+        FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );
+
+      /* we must translate our final outline by -pp1.x and compute */
+      /* the new metrics                                           */
+      if ( loader->pp1.x )
+        FT_Outline_Translate( &gloader->base.outline, -loader->pp1.x, 0 );
+
+      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );
+
+      bbox.xMin  = FT_PIX_FLOOR(  bbox.xMin );
+      bbox.yMin  = FT_PIX_FLOOR(  bbox.yMin );
+      bbox.xMax  = FT_PIX_CEIL( bbox.xMax );
+      bbox.yMax  = FT_PIX_CEIL( bbox.yMax );
+
+      slot->metrics.width        = bbox.xMax - bbox.xMin;
+      slot->metrics.height       = bbox.yMax - bbox.yMin;
+      slot->metrics.horiBearingX = bbox.xMin;
+      slot->metrics.horiBearingY = bbox.yMax;
+
+      /* for mono-width fonts (like Andale, Courier, etc.) we need */
+      /* to keep the original rounded advance width                */
+#if 0
+      if ( !FT_IS_FIXED_WIDTH( slot->face ) )
+        slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
+      else
+        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
+                                               x_scale );
+#else
+      /* for mono-width fonts (like Andale, Courier, etc.) we need */
+      /* to keep the original rounded advance width                */
+      if ( !FT_IS_FIXED_WIDTH( slot->face ) )
+        slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
+      else
+        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
+                                               metrics->scaler.x_scale );
+#endif
+
+      slot->metrics.horiAdvance = FT_PIX_ROUND( slot->metrics.horiAdvance );
+
+      /* now copy outline into glyph slot */
+      FT_GlyphLoader_Rewind( internal->loader );
+      error = FT_GlyphLoader_CopyPoints( internal->loader, gloader );
+      if ( error )
+        goto Exit;
+
+      slot->outline = internal->loader->base.outline;
+      slot->format  = FT_GLYPH_FORMAT_OUTLINE;
+    }
+
+#ifdef DEBUG_HINTER
+    af_debug_hinter = hinter;
+#endif
+
+  Exit:
+    return error;
+  }
+
+
+
+
+  FT_LOCAL_DEF( FT_Error )
+  af_loader_load_glyph( AF_Loader  loader,
+                        FT_Face    face,
+                        FT_UInt    gindex,
+                        FT_UInt32  load_flags )
+  {
+    FT_Error      error;
+    FT_Size       size = face->size;
+    AF_ScalerRec  scaler;
+
+    if ( !size )
+      return FT_Err_Invalid_Argument;
+
+    FT_ZERO( &scaler );
+
+    scaler.face    = face;
+    scaler.x_scale = size->metrics.x_scale;
+    scaler.x_delta = 0;  /* XXX: TODO: add support for sub-pixel hinting */
+    scaler.y_scale = size->metrics.y_scale;
+    scaler.y_delta = 0;  /* XXX: TODO: add support for sub-pixel hinting */
+
+    scaler.render_mode = FT_LOAD_TARGET_MODE( load_flags );
+    scaler.flags       = 0;  /* XXX: fix this */
+
+    error = af_loader_reset( loader, face );
+    if ( !error )
+    {
+      AF_ScriptMetrics  metrics;
+
+      error = af_face_globals_get_metrics( loader->globals, gindex, &metrics );
+      if ( !error )
+      {
+        loader->metrics = metrics;
+
+        metrics->scaler = scaler;
+
+        if ( metrics->clazz->script_metrics_scale )
+          metrics->clazz->script_metrics_scale( metrics, &scaler );
+
+        load_flags |=  FT_LOAD_NO_SCALE | FT_LOAD_IGNORE_TRANSFORM;
+        load_flags &= ~FT_LOAD_RENDER;
+
+        error = metrics->clazz->script_hints_init( &loader->hints, metrics );
+        if ( error )
+          goto Exit;
+
+        error = af_loader_load_g( loader, &scaler, gindex, load_flags, 0 );
+      }
+    }
+  Exit:
+    return error;
+  }
diff --git a/nx-X11/extras/freetype2/src/autofit/afloader.h b/nx-X11/extras/freetype2/src/autofit/afloader.h
new file mode 100644
index 000000000..12361560a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afloader.h
@@ -0,0 +1,50 @@
+#ifndef __AF_LOADER_H__
+#define __AF_LOADER_H__
+
+#include "afhints.h"
+#include "afglobal.h"
+
+FT_BEGIN_HEADER
+
+  typedef struct AF_LoaderRec_
+  {
+    FT_Face           face;           /* current face */
+    AF_FaceGlobals    globals;        /* current face globals */
+    FT_GlyphLoader    gloader;        /* glyph loader */
+    AF_GlyphHintsRec  hints;
+    AF_ScriptMetrics  metrics;
+    FT_Bool           transformed;
+    FT_Matrix         trans_matrix;
+    FT_Vector         trans_delta;
+    FT_Vector         pp1;
+    FT_Vector         pp2;
+    /* we don't handle vertical phantom points */
+
+  } AF_LoaderRec, *AF_Loader;
+
+
+  FT_LOCAL( FT_Error )
+  af_loader_init( AF_Loader  loader,
+                  FT_Memory  memory );
+
+
+  FT_LOCAL( FT_Error )
+  af_loader_reset( AF_Loader  loader,
+                   FT_Face    face );
+
+
+  FT_LOCAL( void )
+  af_loader_done( AF_Loader  loader );
+
+
+  FT_LOCAL( FT_Error )
+  af_loader_load_glyph( AF_Loader  loader,
+                        FT_Face    face,
+                        FT_UInt    gindex,
+                        FT_UInt32  load_flags );
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __AF_LOADER_H__ */
diff --git a/nx-X11/extras/freetype2/src/autofit/afmodule.c b/nx-X11/extras/freetype2/src/autofit/afmodule.c
new file mode 100644
index 000000000..e22ffffc6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afmodule.c
@@ -0,0 +1,70 @@
+#include "afmodule.h"
+#include "afloader.h"
+#include FT_INTERNAL_OBJECTS_H
+
+  typedef struct  FT_AutofitterRec_
+  {
+    FT_ModuleRec  root;
+    AF_LoaderRec  loader[1];
+
+  } FT_AutofitterRec, *FT_Autofitter;
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  af_autofitter_init( FT_Autofitter  module )
+  {
+    return af_loader_init( module->loader, module->root.library->memory );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  af_autofitter_done( FT_Autofitter  module )
+  {
+    af_loader_done( module->loader );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  af_autofitter_load_glyph( FT_Autofitter  module,
+                            FT_GlyphSlot   slot,
+                            FT_Size        size,
+                            FT_UInt        glyph_index,
+                            FT_Int32       load_flags )
+  {
+    FT_UNUSED( size );
+
+    return af_loader_load_glyph( module->loader, slot->face,
+                                 glyph_index, load_flags );
+  }
+
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_AutoHinter_ServiceRec  af_autofitter_service =
+  {
+    NULL,
+    NULL,
+    NULL,
+    (FT_AutoHinter_GlyphLoadFunc) af_autofitter_load_glyph
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Module_Class  autofit_module_class =
+  {
+    FT_MODULE_HINTER,
+    sizeof ( FT_AutofitterRec ),
+
+    "autofitter",
+    0x10000L,   /* version 1.0 of the autofitter  */
+    0x20000L,   /* requires FreeType 2.0 or above */
+
+    (const void*) &af_autofitter_service,
+
+    (FT_Module_Constructor) af_autofitter_init,
+    (FT_Module_Destructor)  af_autofitter_done,
+    (FT_Module_Requester)   0
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autofit/afmodule.h b/nx-X11/extras/freetype2/src/autofit/afmodule.h
new file mode 100644
index 000000000..b898cb375
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/afmodule.h
@@ -0,0 +1,16 @@
+#ifndef __AFMODULE_H__
+#define __AFMODULE_H__
+
+#include <ft2build.h>
+#include FT_MODULE_H
+
+
+FT_BEGIN_HEADER
+
+  FT_CALLBACK_TABLE
+  const FT_Module_Class  autofit_module_class;
+
+
+FT_END_HEADER
+
+#endif /* __AFMODULE_H__ */
diff --git a/nx-X11/extras/freetype2/src/autofit/aftypes.h b/nx-X11/extras/freetype2/src/autofit/aftypes.h
new file mode 100644
index 000000000..5d0371fcb
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/aftypes.h
@@ -0,0 +1,290 @@
+/***************************************************************************
+ *
+ *  FreeType auto-fitter
+ *
+ *  (c) 2004 David Turner
+ *
+ *  The auto-fitter is a complete rewrite of the old auto-hinter.
+ *  its main feature is the ability to differentiate between different
+ *  scripts in order to apply language-specific rules.
+ *
+ *  the code has also been compartimentized into several entities that
+ *  should make algorithmic experimentation easier than with the old
+ *  code.
+ *
+ *  finally, we get rid of the Catharon license, since this code is
+ *  released under the FreeType one.
+ */
+#ifndef __AFTYPES_H__
+#define __AFTYPES_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+
+FT_BEGIN_HEADER
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                D E B U G G I N G                               *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+#define xxAF_DEBUG
+
+#ifdef AF_DEBUG
+
+#  include <stdio.h>
+#  define AF_LOG( x )  printf x
+
+#else
+
+#  define AF_LOG( x )  do ; while ( 0 ) /* nothing */
+
+#endif /* AF_DEBUG */
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                U T I L I T Y                                   *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+  typedef struct AF_WidthRec_
+  {
+    FT_Pos  org;  /* original position/width in font units              */
+    FT_Pos  cur;  /* current/scaled position/width in device sub-pixels */
+    FT_Pos  fit;  /* current/fitted position/width in device sub-pixels */
+
+  } AF_WidthRec, *AF_Width;
+
+
+  FT_LOCAL( void )
+  af_sort_pos( FT_UInt   count,
+               FT_Pos*   table );
+
+  FT_LOCAL( void )
+  af_sort_widths( FT_UInt   count,
+                  AF_Width  widths );
+
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                A N G L E   T Y P E S                           *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+ /*
+  *  Angle type. The auto-fitter doesn't need a very high angular accuracy,
+  *  and this allows us to speed up some computations considerably with a
+  *  light Cordic algorithm (see afangles.c)
+  *
+  */
+
+  typedef FT_Int    AF_Angle;
+
+#define  AF_ANGLE_PI     256
+#define  AF_ANGLE_2PI    (AF_ANGLE_PI*2)
+#define  AF_ANGLE_PI2    (AF_ANGLE_PI/2)
+#define  AF_ANGLE_PI4    (AF_ANGLE_PI/4)
+
+ /*
+  *  compute the angle of a given 2-D vector
+  *
+  */
+  FT_LOCAL( AF_Angle )
+  af_angle_atan( FT_Pos  dx,
+                 FT_Pos  dy );
+
+
+ /*
+  *  computes "angle2 - angle1", the result is always within
+  *  the range [ -AF_ANGLE_PI .. AF_ANGLE_PI-1 ]
+  *
+  */
+  FT_LOCAL( AF_Angle )
+  af_angle_diff( AF_Angle  angle1,
+                 AF_Angle  angle2 );
+
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                O U T L I N E S                                 *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+ /* opaque handle to glyph-specific hints. see "afhints.h" for more
+  * details
+  */
+  typedef struct AF_GlyphHintsRec_*     AF_GlyphHints;
+
+ /* this structure is used to model an input glyph outline to
+  * the auto-hinter. The latter will set the "hints" field
+  * depending on the glyph's script
+  */
+  typedef struct AF_OutlineRec_
+  {
+    FT_Face          face;
+    FT_Outline       outline;
+    FT_UInt          outline_resolution;
+
+    FT_Int           advance;
+    FT_UInt          metrics_resolution;
+
+    AF_GlyphHints    hints;
+
+  } AF_OutlineRec;
+
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                S C A L E R S                                   *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+ /*
+  *  A scaler models the target pixel device that will receive the
+  *  auto-hinted glyph image
+  *
+  */
+
+  typedef enum
+  {
+    AF_SCALER_FLAG_NO_HORIZONTAL = 1,  /* disable horizontal hinting */
+    AF_SCALER_FLAG_NO_VERTICAL   = 2,  /* disable vertical hinting   */
+    AF_SCALER_FLAG_NO_ADVANCE    = 4   /* disable advance hinting    */
+
+  } AF_ScalerFlags;
+
+
+  typedef struct AF_ScalerRec_
+  {
+    FT_Face         face;         /* source font face                        */
+    FT_Fixed        x_scale;      /* from font units to 1/64th device pixels */
+    FT_Fixed        y_scale;      /* from font units to 1/64th device pixels */
+    FT_Pos          x_delta;      /* in 1/64th device pixels                 */
+    FT_Pos          y_delta;      /* in 1/64th device pixels                 */
+    FT_Render_Mode  render_mode;  /* monochrome, anti-aliased, LCD, etc..    */
+    FT_UInt32       flags;        /* additionnal control flags, see above    */
+
+  } AF_ScalerRec, *AF_Scaler;
+
+
+#define  AF_SCALER_EQUAL_SCALES(a,b)    \
+   ( (a)->x_scale == (b)->x_scale &&    \
+     (a)->y_scale == (b)->y_scale &&    \
+     (a)->x_delta == (b)->x_delta &&    \
+     (a)->y_delta == (b)->y_delta )
+
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                S C R I P T S                                   *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+ /*
+  *  the list of know scripts. Each different script correspond to the
+  *  following information:
+  *
+  *   - a set of Unicode ranges to test weither the face supports the
+  *     script
+  *
+  *   - a specific global analyzer that will compute global metrics
+  *     specific to the script.
+  *
+  *   - a specific glyph analyzer that will compute segments and
+  *     edges for each glyph covered by the script
+  *
+  *   - a specific grid-fitting algorithm that will distort the
+  *     scaled glyph outline according to the results of the glyph
+  *     analyzer
+  *
+  *  note that a given analyzer and/or grid-fitting algorithm can be
+  *  used by more than one script
+  */
+  typedef enum
+  {
+    AF_SCRIPT_NONE  = 0,
+    AF_SCRIPT_LATIN = 1,
+    /* add new scripts here. don't forget to update the list in "afglobal.c" */
+
+    AF_SCRIPT_MAX   /* do not remove */
+
+  } AF_Script;
+
+
+
+  typedef struct AF_ScriptClassRec_ const*  AF_ScriptClass;
+
+  typedef struct AF_ScriptMetricsRec_
+  {
+    AF_ScriptClass    clazz;
+    AF_ScalerRec      scaler;
+
+  } AF_ScriptMetricsRec, *AF_ScriptMetrics;
+
+
+ /* this function parses a FT_Face to compute global metrics for
+  * a specific script
+  */
+  typedef FT_Error  (*AF_Script_InitMetricsFunc)( AF_ScriptMetrics   metrics,
+                                                  FT_Face            face );
+
+  typedef void      (*AF_Script_ScaleMetricsFunc)( AF_ScriptMetrics  metrics,
+                                                   AF_Scaler         scaler );
+
+  typedef void      (*AF_Script_DoneMetricsFunc)( AF_ScriptMetrics   metrics );
+
+
+  typedef FT_Error  (*AF_Script_InitHintsFunc)( AF_GlyphHints     hints,
+                                                AF_ScriptMetrics  metrics );
+
+  typedef void      (*AF_Script_ApplyHintsFunc)( AF_GlyphHints     hints,
+                                                 FT_Outline*       outline,
+                                                 AF_ScriptMetrics  metrics );
+
+
+  typedef struct AF_Script_UniRangeRec_
+  {
+    FT_UInt32    first;
+    FT_UInt32    last;
+
+  } AF_Script_UniRangeRec;
+
+  typedef const AF_Script_UniRangeRec *  AF_Script_UniRange;
+
+  typedef struct AF_ScriptClassRec_
+  {
+    AF_Script                   script;
+    AF_Script_UniRange          script_uni_ranges;  /* last must be { 0, 0 } */
+
+    FT_UInt                     script_metrics_size;
+    AF_Script_InitMetricsFunc   script_metrics_init;
+    AF_Script_ScaleMetricsFunc  script_metrics_scale;
+    AF_Script_DoneMetricsFunc   script_metrics_done;
+
+    AF_Script_InitHintsFunc     script_hints_init;
+    AF_Script_ApplyHintsFunc    script_hints_apply;
+
+  } AF_ScriptClassRec;
+
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __AFTYPES_H__ */
diff --git a/nx-X11/extras/freetype2/src/autofit/autofit.c b/nx-X11/extras/freetype2/src/autofit/autofit.c
new file mode 100644
index 000000000..c258e0d7a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autofit/autofit.c
@@ -0,0 +1,9 @@
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+#include <ft2build.h>
+#include "afangles.c"
+#include "afglobal.c"
+#include "afhints.c"
+#include "afdummy.c"
+#include "aflatin.c"
+#include "afloader.c"
+#include "afmodule.c"
diff --git a/nx-X11/extras/freetype2/src/autohint/CatharonLicense.txt b/nx-X11/extras/freetype2/src/autohint/CatharonLicense.txt
new file mode 100644
index 000000000..789c8c9fe
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/CatharonLicense.txt
@@ -0,0 +1,123 @@
+                  The Catharon Open Source LICENSE
+                    ----------------------------
+
+                            2000-Jul-04
+
+          Copyright (C) 2000 by Catharon Productions, Inc.
+
+
+
+Introduction
+============
+
+  This  license  applies to  source  files  distributed by  Catharon
+  Productions,  Inc.  in  several  archive packages.   This  license
+  applies  to all files  found in  such packages  which do  not fall
+  under their own explicit license.
+
+  This  license   was  inspired  by  the  BSD,   Artistic,  and  IJG
+  (Independent JPEG  Group) licenses, which  all encourage inclusion
+  and  use of  free  software in  commercial  and freeware  products
+  alike.  As a consequence, its main points are that:
+
+    o We  don't promise that  this software works.  However,  we are
+      interested in any kind of bug reports. (`as is' distribution)
+
+    o You can  use this software for whatever you  want, in parts or
+      full form, without having to pay us. (`royalty-free' usage)
+
+    o You may not pretend that  you wrote this software.  If you use
+      it, or  only parts of it,  in a program,  you must acknowledge
+      somewhere  in  your  documentation  that  you  have  used  the
+      Catharon Code. (`credits')
+
+  We  specifically  permit  and  encourage  the  inclusion  of  this
+  software, with  or without modifications,  in commercial products.
+  We disclaim  all warranties  covering the packages  distributed by
+  Catharon  Productions, Inc.  and  assume no  liability related  to
+  their use.
+
+
+Legal Terms
+===========
+
+0. Definitions
+--------------
+
+  Throughout this license,  the terms `Catharon Package', `package',
+  and  `Catharon  Code'  refer   to  the  set  of  files  originally
+  distributed by Catharon Productions, Inc.
+
+  `You' refers to  the licensee, or person using  the project, where
+  `using' is a generic term including compiling the project's source
+  code as  well as linking it  to form a  `program' or `executable'.
+  This  program  is referred  to  as `a  program  using  one of  the
+  Catharon Packages'.
+
+  This  license applies  to all  files distributed  in  the original
+  Catharon  Package(s),  including  all  source code,  binaries  and
+  documentation,  unless  otherwise  stated   in  the  file  in  its
+  original, unmodified form as  distributed in the original archive.
+  If you are  unsure whether or not a particular  file is covered by
+  this license, you must contact us to verify this.
+
+  The  Catharon   Packages  are  copyright  (C)   2000  by  Catharon
+  Productions, Inc.  All rights reserved except as specified below.
+
+1. No Warranty
+--------------
+
+  THE CATHARON PACKAGES ARE PROVIDED `AS IS' WITHOUT WARRANTY OF ANY
+  KIND, EITHER  EXPRESS OR IMPLIED,  INCLUDING, BUT NOT  LIMITED TO,
+  WARRANTIES  OF  MERCHANTABILITY   AND  FITNESS  FOR  A  PARTICULAR
+  PURPOSE.  IN NO EVENT WILL ANY OF THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY DAMAGES CAUSED BY THE USE OF OR THE INABILITY TO
+  USE THE CATHARON PACKAGE.
+
+2. Redistribution
+-----------------
+
+  This  license  grants  a  worldwide, royalty-free,  perpetual  and
+  irrevocable right  and license to use,  execute, perform, compile,
+  display,  copy,   create  derivative  works   of,  distribute  and
+  sublicense the  Catharon Packages (in both source  and object code
+  forms)  and  derivative works  thereof  for  any  purpose; and  to
+  authorize others  to exercise  some or all  of the  rights granted
+  herein, subject to the following conditions:
+
+    o Redistribution  of source code  must retain this  license file
+      (`license.txt') unaltered; any additions, deletions or changes
+      to   the  original   files  must   be  clearly   indicated  in
+      accompanying  documentation.   The  copyright notices  of  the
+      unaltered, original  files must be preserved in  all copies of
+      source files.
+
+    o Redistribution  in binary form must provide  a disclaimer that
+      states  that the  software is  based in  part on  the  work of
+      Catharon Productions, Inc. in the distribution documentation.
+
+  These conditions  apply to any  software derived from or  based on
+  the Catharon Packages, not just  the unmodified files.  If you use
+  our work, you  must acknowledge us.  However, no  fee need be paid
+  to us.
+
+3. Advertising
+--------------
+
+  Neither Catharon Productions, Inc.  and contributors nor you shall
+  use  the  name  of  the  other  for  commercial,  advertising,  or
+  promotional purposes without specific prior written permission.
+
+  We suggest, but do not  require, that you use the following phrase
+  to refer to this software in your documentation: 'this software is
+  based in part on the Catharon Typography Project'.
+
+  As  you have  not signed  this license,  you are  not  required to
+  accept  it.  However,  as  the Catharon  Packages are  copyrighted
+  material, only  this license, or  another one contracted  with the
+  authors, grants you  the right to use, distribute,  and modify it.
+  Therefore,  by  using,  distributing,  or modifying  the  Catharon
+  Packages,  you indicate  that you  understand and  accept  all the
+  terms of this license.
+
+--- end of license.txt ---
diff --git a/nx-X11/extras/freetype2/src/autohint/Jamfile b/nx-X11/extras/freetype2/src/autohint/Jamfile
new file mode 100644
index 000000000..a129e5eea
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/autohint Jamfile (c) 2001 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) autohint ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = ahangles ahglobal ahglyph ahhint ahmodule ;
+  }
+  else
+  {
+    _sources = autohint ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/autohint Jamfile
diff --git a/nx-X11/extras/freetype2/src/autohint/ahangles.c b/nx-X11/extras/freetype2/src/autohint/ahangles.c
new file mode 100644
index 000000000..ef5a88ee6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahangles.c
@@ -0,0 +1,147 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahangles.h                                                             */
+/*                                                                         */
+/*    A routine used to compute vector angles with limited accuracy        */
+/*    and very high speed (body).                                          */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include "ahangles.h"
+
+
+  /* the following table has been automatically generated with */
+  /* the `mather.py' Python script                             */
+
+  const AH_Angle  ah_arctan[1L << AH_ATAN_BITS] =
+  {
+     0,  0,  1,  1,  1,  2,  2,  2,
+     3,  3,  3,  3,  4,  4,  4,  5,
+     5,  5,  6,  6,  6,  7,  7,  7,
+     8,  8,  8,  9,  9,  9, 10, 10,
+    10, 10, 11, 11, 11, 12, 12, 12,
+    13, 13, 13, 14, 14, 14, 14, 15,
+    15, 15, 16, 16, 16, 17, 17, 17,
+    18, 18, 18, 18, 19, 19, 19, 20,
+    20, 20, 21, 21, 21, 21, 22, 22,
+    22, 23, 23, 23, 24, 24, 24, 24,
+    25, 25, 25, 26, 26, 26, 26, 27,
+    27, 27, 28, 28, 28, 28, 29, 29,
+    29, 30, 30, 30, 30, 31, 31, 31,
+    31, 32, 32, 32, 33, 33, 33, 33,
+    34, 34, 34, 34, 35, 35, 35, 35,
+    36, 36, 36, 36, 37, 37, 37, 38,
+    38, 38, 38, 39, 39, 39, 39, 40,
+    40, 40, 40, 41, 41, 41, 41, 42,
+    42, 42, 42, 42, 43, 43, 43, 43,
+    44, 44, 44, 44, 45, 45, 45, 45,
+    46, 46, 46, 46, 46, 47, 47, 47,
+    47, 48, 48, 48, 48, 48, 49, 49,
+    49, 49, 50, 50, 50, 50, 50, 51,
+    51, 51, 51, 51, 52, 52, 52, 52,
+    52, 53, 53, 53, 53, 53, 54, 54,
+    54, 54, 54, 55, 55, 55, 55, 55,
+    56, 56, 56, 56, 56, 57, 57, 57,
+    57, 57, 57, 58, 58, 58, 58, 58,
+    59, 59, 59, 59, 59, 59, 60, 60,
+    60, 60, 60, 61, 61, 61, 61, 61,
+    61, 62, 62, 62, 62, 62, 62, 63,
+    63, 63, 63, 63, 63, 64, 64, 64
+  };
+
+
+  FT_LOCAL_DEF( AH_Angle )
+  ah_angle( FT_Vector*  v )
+  {
+    FT_Pos    dx, dy;
+    AH_Angle  angle;
+
+
+    dx = v->x;
+    dy = v->y;
+
+    /* check trivial cases */
+    if ( dy == 0 )
+    {
+      angle = 0;
+      if ( dx < 0 )
+        angle = AH_PI;
+      return angle;
+    }
+    else if ( dx == 0 )
+    {
+      angle = AH_HALF_PI;
+      if ( dy < 0 )
+        angle = -AH_HALF_PI;
+      return angle;
+    }
+
+    angle = 0;
+    if ( dx < 0 )
+    {
+      dx = -v->x;
+      dy = -v->y;
+      angle = AH_PI;
+    }
+
+    if ( dy < 0 )
+    {
+      FT_Pos  tmp;
+
+
+      tmp = dx;
+      dx  = -dy;
+      dy  = tmp;
+      angle -= AH_HALF_PI;
+    }
+
+    if ( dx == 0 && dy == 0 )
+      return 0;
+
+    if ( dx == dy )
+      angle += AH_PI / 4;
+    else if ( dx > dy )
+      angle += ah_arctan[FT_DivFix( dy, dx ) >> ( 16 - AH_ATAN_BITS )];
+    else
+      angle += AH_HALF_PI -
+               ah_arctan[FT_DivFix( dx, dy ) >> ( 16 - AH_ATAN_BITS )];
+
+    if ( angle > AH_PI )
+      angle -= AH_2PI;
+
+    return angle;
+  }
+
+
+  FT_LOCAL_DEF( AH_Angle )
+  ah_angle_diff( AH_Angle  angle1,
+                 AH_Angle  angle2 )
+  {
+    AH_Angle  delta;
+    
+
+    delta = ( angle2 - angle1 );
+    if ( delta < 0 )
+      delta += AH_2PI;
+    
+    if ( delta > AH_PI )
+      delta -= AH_2PI;
+    
+    return delta;
+  }                 
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahangles.h b/nx-X11/extras/freetype2/src/autohint/ahangles.h
new file mode 100644
index 000000000..f46bfaad7
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahangles.h
@@ -0,0 +1,64 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahangles.h                                                             */
+/*                                                                         */
+/*    A routine used to compute vector angles with limited accuracy        */
+/*    and very high speed (specification).                                 */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __AHANGLES_H__
+#define __AHANGLES_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include "ahtypes.h"
+
+
+FT_BEGIN_HEADER
+
+
+  /* PI expressed in ah_angles -- we don't really need an important */
+  /* precision, so 256 should be enough                             */
+#define AH_PI       256
+#define AH_2PI      ( AH_PI * 2 )
+#define AH_HALF_PI  ( AH_PI / 2 )
+#define AH_2PIMASK  ( AH_2PI - 1 )
+
+  /* the number of bits used to express an arc tangent; */
+  /* see the structure of the lookup table              */
+#define AH_ATAN_BITS  8
+
+  extern
+  const AH_Angle  ah_arctan[1L << AH_ATAN_BITS];
+
+
+  FT_LOCAL( AH_Angle )
+  ah_angle( FT_Vector*  v );
+
+
+  FT_LOCAL( AH_Angle )
+  ah_angle_diff( AH_Angle  angle1,
+                 AH_Angle  angle2 );
+
+
+FT_END_HEADER
+
+#endif /* __AHANGLES_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/aherrors.h b/nx-X11/extras/freetype2/src/autohint/aherrors.h
new file mode 100644
index 000000000..bce6107d3
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/aherrors.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  aherrors.h                                                             */
+/*                                                                         */
+/*    Autohinter error codes (specification only).                         */
+/*                                                                         */
+/*  Copyright 2001 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 Autohinter error enumeration          */
+  /* constants.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __AHERRORS_H__
+#define __AHERRORS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  AH_Err_
+#define FT_ERR_BASE    FT_Mod_Err_Autohint
+
+#include FT_ERRORS_H
+
+#endif /* __AHERRORS_H__ */
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahglobal.c b/nx-X11/extras/freetype2/src/autohint/ahglobal.c
new file mode 100644
index 000000000..e157014b5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahglobal.c
@@ -0,0 +1,402 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahglobal.c                                                             */
+/*                                                                         */
+/*    Routines used to compute global metrics automatically (body).        */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 Catharon Productions Inc.        */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include "ahglobal.h"
+#include "ahglyph.h"
+
+
+#define MAX_TEST_CHARACTERS  12
+
+  /* cf. AH_BLUE_XXX constants in ahtypes.h */
+
+  static
+  const char* const  blue_chars[AH_BLUE_MAX] =
+  {
+    "THEZOCQS",
+    "HEZLOCUS",
+#ifdef FT_CONFIG_CHESTER_SMALL_F
+    "fijkdbh",
+#endif
+    "xzroesc",
+    "xzroesc",
+    "pqgjy"
+  };
+
+
+  /* simple insertion sort */
+  static void
+  sort_values( FT_Int   count,
+               FT_Pos*  table )
+  {
+    FT_Int  i, j;
+    FT_Pos  swap;
+
+
+    for ( i = 1; i < count; i++ )
+    {
+      for ( j = i; j > 0; j-- )
+      {
+        if ( table[j] > table[j - 1] )
+          break;
+
+        swap         = table[j];
+        table[j]     = table[j - 1];
+        table[j - 1] = swap;
+      }
+    }
+  }
+
+
+  static FT_Error
+  ah_hinter_compute_blues( AH_Hinter  hinter )
+  {
+    AH_Blue       blue;
+    AH_Globals    globals = &hinter->globals->design;
+    FT_Pos        flats [MAX_TEST_CHARACTERS];
+    FT_Pos        rounds[MAX_TEST_CHARACTERS];
+    FT_Int        num_flats;
+    FT_Int        num_rounds;
+
+    FT_Face       face;
+    FT_GlyphSlot  glyph;
+    FT_Error      error;
+    FT_CharMap    charmap;
+
+
+    face  = hinter->face;
+    glyph = face->glyph;
+
+    /* save current charmap */
+    charmap = face->charmap;
+
+    /* do we have a Unicode charmap in there? */
+    error = FT_Select_Charmap( face, FT_ENCODING_UNICODE );
+    if ( error )
+      goto Exit;
+
+    /* we compute the blues simply by loading each character from the */
+    /* `blue_chars[blues]' string, then compute its top-most or       */
+    /* bottom-most points (depending on `AH_IS_TOP_BLUE')             */
+
+    AH_LOG(( "blue zones computation\n" ));
+    AH_LOG(( "------------------------------------------------\n" ));
+
+    for ( blue = AH_BLUE_CAPITAL_TOP; blue < AH_BLUE_MAX; blue++ )
+    {
+      const char*  p     = blue_chars[blue];
+      const char*  limit = p + MAX_TEST_CHARACTERS;
+
+      FT_Pos       *blue_ref, *blue_shoot;
+
+
+      AH_LOG(( "blue %3d: ", blue ));
+
+      num_flats  = 0;
+      num_rounds = 0;
+
+      for ( ; p < limit; p++ )
+      {
+        FT_UInt     glyph_index;
+        FT_Vector*  extremum;
+        FT_Vector*  points;
+        FT_Vector*  point_limit;
+        FT_Vector*  point;
+        FT_Bool     round;
+
+
+        /* exit if we reach the end of the string */
+        if ( !*p )
+          break;
+
+        AH_LOG(( "`%c'", *p ));
+
+        /* load the character in the face -- skip unknown or empty ones */
+        glyph_index = FT_Get_Char_Index( face, (FT_UInt)*p );
+        if ( glyph_index == 0 )
+          continue;
+
+        error = FT_Load_Glyph( face, glyph_index, FT_LOAD_NO_SCALE );
+        if ( error || glyph->outline.n_points <= 0 )
+          continue;
+
+        /* now compute min or max point indices and coordinates */
+        points      = glyph->outline.points;
+        point_limit = points + glyph->outline.n_points;
+        point       = points;
+        extremum    = point;
+        point++;
+
+        if ( AH_IS_TOP_BLUE( blue ) )
+        {
+          for ( ; point < point_limit; point++ )
+            if ( point->y > extremum->y )
+              extremum = point;
+        }
+        else
+        {
+          for ( ; point < point_limit; point++ )
+            if ( point->y < extremum->y )
+              extremum = point;
+        }
+
+        AH_LOG(( "%5d", (int)extremum->y ));
+
+        /* now, check whether the point belongs to a straight or round  */
+        /* segment; we first need to find in which contour the extremum */
+        /* lies, then see its previous and next points                  */
+        {
+          FT_Int  idx = (FT_Int)( extremum - points );
+          FT_Int  n;
+          FT_Int  first, last, prev, next, end;
+          FT_Pos  dist;
+
+
+          last  = -1;
+          first = 0;
+
+          for ( n = 0; n < glyph->outline.n_contours; n++ )
+          {
+            end = glyph->outline.contours[n];
+            if ( end >= idx )
+            {
+              last = end;
+              break;
+            }
+            first = end + 1;
+          }
+
+          /* XXX: should never happen! */
+          if ( last < 0 )
+            continue;
+
+          /* now look for the previous and next points that are not on the */
+          /* same Y coordinate.  Threshold the `closeness'...              */
+
+          prev = idx;
+          next = prev;
+
+          do
+          {
+            if ( prev > first )
+              prev--;
+            else
+              prev = last;
+
+            dist = points[prev].y - extremum->y;
+            if ( dist < -5 || dist > 5 )
+              break;
+
+          } while ( prev != idx );
+
+          do
+          {
+            if ( next < last )
+              next++;
+            else
+              next = first;
+
+            dist = points[next].y - extremum->y;
+            if ( dist < -5 || dist > 5 )
+              break;
+
+          } while ( next != idx );
+
+          /* now, set the `round' flag depending on the segment's kind */
+          round = FT_BOOL(
+            FT_CURVE_TAG( glyph->outline.tags[prev] ) != FT_CURVE_TAG_ON ||
+            FT_CURVE_TAG( glyph->outline.tags[next] ) != FT_CURVE_TAG_ON );
+
+          AH_LOG(( "%c ", round ? 'r' : 'f' ));
+        }
+
+        if ( round )
+          rounds[num_rounds++] = extremum->y;
+        else
+          flats[num_flats++] = extremum->y;
+      }
+
+      AH_LOG(( "\n" ));
+
+      /* we have computed the contents of the `rounds' and `flats' tables, */
+      /* now determine the reference and overshoot position of the blue -- */
+      /* we simply take the median value after a simple sort               */
+      sort_values( num_rounds, rounds );
+      sort_values( num_flats,  flats  );
+
+      blue_ref   = globals->blue_refs + blue;
+      blue_shoot = globals->blue_shoots + blue;
+      if ( num_flats == 0 && num_rounds == 0 )
+      {
+        *blue_ref   = -10000;
+        *blue_shoot = -10000;
+      }
+      else if ( num_flats == 0 )
+      {
+        *blue_ref   =
+        *blue_shoot = rounds[num_rounds / 2];
+      }
+      else if ( num_rounds == 0 )
+      {
+        *blue_ref   =
+        *blue_shoot = flats[num_flats / 2];
+      }
+      else
+      {
+        *blue_ref   = flats[num_flats / 2];
+        *blue_shoot = rounds[num_rounds / 2];
+      }
+
+      /* there are sometimes problems: if the overshoot position of top     */
+      /* zones is under its reference position, or the opposite for bottom  */
+      /* zones.  We must thus check everything there and correct the errors */
+      if ( *blue_shoot != *blue_ref )
+      {
+        FT_Pos   ref      = *blue_ref;
+        FT_Pos   shoot    = *blue_shoot;
+        FT_Bool  over_ref = FT_BOOL( shoot > ref );
+
+
+        if ( AH_IS_TOP_BLUE( blue ) ^ over_ref )
+          *blue_shoot = *blue_ref = ( shoot + ref ) / 2;
+      }
+
+      AH_LOG(( "-- ref = %ld, shoot = %ld\n", *blue_ref, *blue_shoot ));
+    }
+
+    /* reset original face charmap */
+    FT_Set_Charmap( face, charmap );
+    error = 0;
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  ah_hinter_compute_widths( AH_Hinter  hinter )
+  {
+    /* scan the array of segments in each direction */
+    AH_Outline  outline = hinter->glyph;
+    AH_Segment  segments;
+    AH_Segment  limit;
+    AH_Globals  globals = &hinter->globals->design;
+    FT_Pos*     widths;
+    FT_Int      dimension;
+    FT_Int*     p_num_widths;
+    FT_Error    error = 0;
+    FT_Pos      edge_distance_threshold = 32000;
+
+
+    globals->num_widths  = 0;
+    globals->num_heights = 0;
+
+    /* For now, compute the standard width and height from the `o'       */
+    /* character.  I started computing the stem width of the `i' and the */
+    /* stem height of the "-", but it wasn't too good.  Moreover, we now */
+    /* have a single character that gives us standard width and height.  */
+    {
+      FT_UInt  glyph_index;
+
+
+      glyph_index = FT_Get_Char_Index( hinter->face, 'o' );
+      if ( glyph_index == 0 )
+        return 0;
+
+      error = FT_Load_Glyph( hinter->face, glyph_index, FT_LOAD_NO_SCALE );
+      if ( error )
+        goto Exit;
+
+      error = ah_outline_load( hinter->glyph, 0x10000L, 0x10000L,
+                               hinter->face );
+      if ( error )
+        goto Exit;
+
+      ah_outline_compute_segments( hinter->glyph );
+      ah_outline_link_segments( hinter->glyph );
+    }
+
+    segments     = outline->horz_segments;
+    limit        = segments + outline->num_hsegments;
+    widths       = globals->heights;
+    p_num_widths = &globals->num_heights;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Segment  seg = segments;
+      AH_Segment  link;
+      FT_Int      num_widths = 0;
+
+
+      for ( ; seg < limit; seg++ )
+      {
+        link = seg->link;
+        /* we only consider stem segments there! */
+        if ( link && link->link == seg && link > seg )
+        {
+          FT_Pos  dist;
+
+
+          dist = seg->pos - link->pos;
+          if ( dist < 0 )
+            dist = -dist;
+
+          if ( num_widths < AH_MAX_WIDTHS )
+            widths[num_widths++] = dist;
+        }
+      }
+
+      sort_values( num_widths, widths );
+      *p_num_widths = num_widths;
+
+      /* we will now try to find the smallest width */
+      if ( num_widths > 0 && widths[0] < edge_distance_threshold )
+        edge_distance_threshold = widths[0];
+
+      segments     = outline->vert_segments;
+      limit        = segments + outline->num_vsegments;
+      widths       = globals->widths;
+      p_num_widths = &globals->num_widths;
+    }
+
+    /* Now, compute the edge distance threshold as a fraction of the */
+    /* smallest width in the font. Set it in `hinter->glyph' too!    */
+    if ( edge_distance_threshold == 32000 )
+      edge_distance_threshold = 50;
+
+    /* let's try 20% */
+    hinter->glyph->edge_distance_threshold = edge_distance_threshold / 5;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  ah_hinter_compute_globals( AH_Hinter  hinter )
+  {
+    return ah_hinter_compute_widths( hinter ) ||
+           ah_hinter_compute_blues ( hinter );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahglobal.h b/nx-X11/extras/freetype2/src/autohint/ahglobal.h
new file mode 100644
index 000000000..5a9bcf835
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahglobal.h
@@ -0,0 +1,59 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahglobal.h                                                             */
+/*                                                                         */
+/*    Routines used to compute global metrics automatically                */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003 Catharon Productions Inc.              */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __AHGLOBAL_H__
+#define __AHGLOBAL_H__
+
+
+#include <ft2build.h>
+#include "ahtypes.h"
+#include FT_INTERNAL_OBJECTS_H
+
+
+FT_BEGIN_HEADER
+
+
+#ifdef  FT_CONFIG_CHESTER_SMALL_F
+
+#define AH_IS_TOP_BLUE( b )  ( (b) == AH_BLUE_CAPITAL_TOP || \
+                               (b) == AH_BLUE_SMALL_F_TOP || \
+                               (b) == AH_BLUE_SMALL_TOP   )
+
+#else /* !FT_CONFIG_CHESTER_SMALL_F */
+
+#define AH_IS_TOP_BLUE( b )  ( (b) == AH_BLUE_CAPITAL_TOP || \
+                               (b) == AH_BLUE_SMALL_TOP   )
+
+#endif /* !FT_CONFIG_CHESTER_SMALL_F */
+
+
+  /* compute global metrics automatically */
+  FT_LOCAL( FT_Error )
+  ah_hinter_compute_globals( AH_Hinter  hinter );
+
+
+FT_END_HEADER
+
+#endif /* __AHGLOBAL_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahglyph.c b/nx-X11/extras/freetype2/src/autohint/ahglyph.c
new file mode 100644
index 000000000..2a0390be4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahglyph.c
@@ -0,0 +1,1699 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahglyph.c                                                              */
+/*                                                                         */
+/*    Routines used to load and analyze a given glyph before hinting       */
+/*    (body).                                                              */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 Catharon Productions Inc.        */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include "ahglyph.h"
+#include "ahangles.h"
+#include "ahglobal.h"
+#include "aherrors.h"
+
+
+#ifdef AH_DEBUG
+
+#include <stdio.h>
+
+  void
+  ah_dump_edges( AH_Outline  outline )
+  {
+    AH_Edge     edges;
+    AH_Edge     edge_limit;
+    AH_Segment  segments;
+    FT_Int      dimension;
+
+
+    edges      = outline->horz_edges;
+    edge_limit = edges + outline->num_hedges;
+    segments   = outline->horz_segments;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Edge   edge;
+
+
+      printf ( "Table of %s edges:\n",
+               !dimension ? "vertical" : "horizontal" );
+      printf ( "  [ index |  pos |  dir  | link |"
+               " serif | blue | opos  |  pos  ]\n" );
+
+      for ( edge = edges; edge < edge_limit; edge++ )
+      {
+        printf ( "  [ %5d | %4d | %5s | %4d | %5d |  %c  | %5.2f | %5.2f ]\n",
+                 edge - edges,
+                 (int)edge->fpos,
+                 edge->dir == AH_DIR_UP
+                   ? "up"
+                   : ( edge->dir == AH_DIR_DOWN
+                         ? "down"
+                         : ( edge->dir == AH_DIR_LEFT
+                               ? "left"
+                               : ( edge->dir == AH_DIR_RIGHT
+                                     ? "right"
+                                     : "none" ) ) ),
+                 edge->link ? ( edge->link - edges ) : -1,
+                 edge->serif ? ( edge->serif - edges ) : -1,
+                 edge->blue_edge ? 'y' : 'n',
+                 edge->opos / 64.0,
+                 edge->pos / 64.0 );
+      }
+
+      edges      = outline->vert_edges;
+      edge_limit = edges + outline->num_vedges;
+      segments   = outline->vert_segments;
+    }
+  }
+
+
+  /* A function used to dump the array of linked segments */
+  void
+  ah_dump_segments( AH_Outline  outline )
+  {
+    AH_Segment  segments;
+    AH_Segment  segment_limit;
+    AH_Point    points;
+    FT_Int      dimension;
+
+
+    points        = outline->points;
+    segments      = outline->horz_segments;
+    segment_limit = segments + outline->num_hsegments;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Segment  seg;
+
+
+      printf ( "Table of %s segments:\n",
+               !dimension ? "vertical" : "horizontal" );
+      printf ( "  [ index |  pos |  dir  | link | serif |"
+               " numl | first | start ]\n" );
+
+      for ( seg = segments; seg < segment_limit; seg++ )
+      {
+        printf ( "  [ %5d | %4d | %5s | %4d | %5d | %4d | %5d | %5d ]\n",
+                 seg - segments,
+                 (int)seg->pos,
+                 seg->dir == AH_DIR_UP
+                   ? "up"
+                   : ( seg->dir == AH_DIR_DOWN
+                         ? "down"
+                         : ( seg->dir == AH_DIR_LEFT
+                               ? "left"
+                               : ( seg->dir == AH_DIR_RIGHT
+                                     ? "right"
+                                     : "none" ) ) ),
+                 seg->link ? ( seg->link - segments ) : -1,
+                 seg->serif ? ( seg->serif - segments ) : -1,
+                 (int)seg->num_linked,
+                 seg->first - points,
+                 seg->last - points );
+      }
+
+      segments      = outline->vert_segments;
+      segment_limit = segments + outline->num_vsegments;
+    }
+  }
+
+#endif /* AH_DEBUG */
+
+
+  /* compute the direction value of a given vector */
+  static AH_Direction
+  ah_compute_direction( FT_Pos  dx,
+                        FT_Pos  dy )
+  {
+    AH_Direction  dir;
+    FT_Pos        ax = FT_ABS( dx );
+    FT_Pos        ay = FT_ABS( dy );
+
+
+    dir = AH_DIR_NONE;
+
+    /* atan(1/12) == 4.7 degrees */
+
+    /* test for vertical direction */
+    if ( ax * 12 < ay )
+    {
+      dir = dy > 0 ? AH_DIR_UP : AH_DIR_DOWN;
+    }
+    /* test for horizontal direction */
+    else if ( ay * 12 < ax )
+    {
+      dir = dx > 0 ? AH_DIR_RIGHT : AH_DIR_LEFT;
+    }
+
+    return dir;
+  }
+
+
+  /* this function is used by ah_get_orientation (see below) to test */
+  /* the fill direction of given bbox extremum                       */
+  static FT_Int
+  ah_test_extremum( FT_Outline*  outline,
+                    FT_Int       n )
+  {
+    FT_Vector  *prev, *cur, *next;
+    FT_Pos      product;
+    FT_Int      first, last, c;
+    FT_Int      retval;
+
+
+    /* we need to compute the `previous' and `next' point */
+    /* for this extremum; we check whether the extremum   */
+    /* is start or end of a contour and providing         */
+    /* appropriate values if so                           */
+    cur  = outline->points + n;
+    prev = cur - 1;
+    next = cur + 1;
+
+    first = 0;
+    for ( c = 0; c < outline->n_contours; c++ )
+    {
+      last = outline->contours[c];
+
+      if ( n == first )
+        prev = outline->points + last;
+
+      if ( n == last )
+        next = outline->points + first;
+
+      first = last + 1;
+    }
+
+    /* compute the vectorial product -- since we know that the angle */
+    /* is <= 180 degrees (otherwise it wouldn't be an extremum) we   */
+    /* can determine the filling orientation if the product is       */
+    /* either positive or negative                                   */
+    product = FT_MulDiv( cur->x  - prev->x,  /* in.x  */
+                         next->y - cur->y,   /* out.y */
+                         0x40 )
+              -
+              FT_MulDiv( cur->y  - prev->y,  /* in.y  */
+                         next->x - cur->x,   /* out.x */
+                         0x40 );
+
+    retval = 0;
+    if ( product )
+      retval = product > 0 ? 2 : 1;
+
+    return retval;
+  }
+
+
+  /* Compute the orientation of path filling.  It differs between TrueType */
+  /* and Type1 formats.  We could use the `FT_OUTLINE_REVERSE_FILL' flag,  */
+  /* but it is better to re-compute it directly (it seems that this flag   */
+  /* isn't correctly set for some weird composite glyphs currently).       */
+  /*                                                                       */
+  /* We do this by computing bounding box points, and computing their      */
+  /* curvature.                                                            */
+  /*                                                                       */
+  /* The function returns either 1 or 2.                                   */
+  /*                                                                       */
+  static FT_Int
+  ah_get_orientation( FT_Outline*  outline )
+  {
+    FT_BBox  box;
+    FT_Int   indices_xMin, indices_yMin, indices_xMax, indices_yMax;
+    FT_Int   n, last;
+
+
+    indices_xMin = -1;
+    indices_yMin = -1;
+    indices_xMax = -1;
+    indices_yMax = -1;
+
+    box.xMin = box.yMin =  32767L;
+    box.xMax = box.yMax = -32768L;
+
+    /* is it empty? */
+    if ( outline->n_contours < 1 )
+      return 1;
+
+    last = outline->contours[outline->n_contours - 1];
+
+    for ( n = 0; n <= last; n++ )
+    {
+      FT_Pos  x, y;
+
+
+      x = outline->points[n].x;
+      if ( x < box.xMin )
+      {
+        box.xMin     = x;
+        indices_xMin = n;
+      }
+      if ( x > box.xMax )
+      {
+        box.xMax     = x;
+        indices_xMax = n;
+      }
+
+      y = outline->points[n].y;
+      if ( y < box.yMin )
+      {
+        box.yMin     = y;
+        indices_yMin = n;
+      }
+      if ( y > box.yMax )
+      {
+        box.yMax     = y;
+        indices_yMax = n;
+      }
+    }
+
+    /* test orientation of the extrema */
+    n = ah_test_extremum( outline, indices_xMin );
+    if ( n )
+      goto Exit;
+
+    n = ah_test_extremum( outline, indices_yMin );
+    if ( n )
+      goto Exit;
+
+    n = ah_test_extremum( outline, indices_xMax );
+    if ( n )
+      goto Exit;
+
+    n = ah_test_extremum( outline, indices_yMax );
+    if ( !n )
+      n = 1;
+
+  Exit:
+    return n;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_new                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new and empty AH_OutlineRec object.                      */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  ah_outline_new( FT_Memory    memory,
+                  AH_Outline*  aoutline )
+  {
+    FT_Error    error;
+    AH_Outline  outline;
+
+
+    if ( !FT_NEW( outline ) )
+    {
+      outline->memory = memory;
+      *aoutline       = outline;
+    }
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_done                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a given AH_OutlineRec object.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  ah_outline_done( AH_Outline  outline )
+  {
+    FT_Memory memory = outline->memory;
+
+
+    FT_FREE( outline->horz_edges );
+    FT_FREE( outline->horz_segments );
+    FT_FREE( outline->contours );
+    FT_FREE( outline->points );
+
+    FT_FREE( outline );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_save                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Saves the contents of a given AH_OutlineRec object into a face's   */
+  /*    glyph slot.                                                        */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  ah_outline_save( AH_Outline  outline,
+                   AH_Loader   gloader )
+  {
+    AH_Point    point       = outline->points;
+    AH_Point    point_limit = point + outline->num_points;
+    FT_Vector*  vec         = gloader->current.outline.points;
+    char*       tag         = gloader->current.outline.tags;
+
+
+    /* we assume that the glyph loader has already been checked for storage */
+    for ( ; point < point_limit; point++, vec++, tag++ )
+    {
+      vec->x = point->x;
+      vec->y = point->y;
+
+      if ( point->flags & AH_FLAG_CONIC )
+        tag[0] = FT_CURVE_TAG_CONIC;
+      else if ( point->flags & AH_FLAG_CUBIC )
+        tag[0] = FT_CURVE_TAG_CUBIC;
+      else
+        tag[0] = FT_CURVE_TAG_ON;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_load                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads an unscaled outline from a glyph slot into an AH_OutlineRec  */
+  /*    object.                                                            */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  ah_outline_load( AH_Outline  outline,
+                   FT_Fixed    x_scale,
+                   FT_Fixed    y_scale,
+                   FT_Face     face )
+  {
+    FT_Memory    memory       = outline->memory;
+    FT_Error     error        = AH_Err_Ok;
+    FT_Outline*  source       = &face->glyph->outline;
+    FT_Int       num_points   = source->n_points;
+    FT_Int       num_contours = source->n_contours;
+    AH_Point     points;
+
+
+    /* check arguments */
+    if ( !face                                          ||
+         !face->size                                    ||
+         face->glyph->format != FT_GLYPH_FORMAT_OUTLINE )
+      return AH_Err_Invalid_Argument;
+
+    /* first of all, reallocate the contours array if necessary */
+    if ( num_contours > outline->max_contours )
+    {
+      FT_Int  new_contours = FT_PAD_CEIL( num_contours, 4 );
+
+
+      if ( FT_RENEW_ARRAY( outline->contours,
+                           outline->max_contours,
+                           new_contours ) )
+        goto Exit;
+
+      outline->max_contours = new_contours;
+    }
+
+    /* then, reallocate the points, segments & edges arrays if needed -- */
+    /* note that we reserved two additional point positions, used to     */
+    /* hint metrics appropriately                                        */
+    /*                                                                   */
+    if ( num_points + 2 > outline->max_points )
+    {
+      FT_Int  news = FT_PAD_CEIL( num_points + 2, 8 );
+      FT_Int  max  = outline->max_points;
+
+
+      if ( FT_RENEW_ARRAY( outline->points,        max,     news     ) ||
+           FT_RENEW_ARRAY( outline->horz_edges,    max * 2, news * 2 ) ||
+           FT_RENEW_ARRAY( outline->horz_segments, max * 2, news * 2 ) )
+        goto Exit;
+
+      /* readjust some pointers */
+      outline->vert_edges    = outline->horz_edges    + news;
+      outline->vert_segments = outline->horz_segments + news;
+      outline->max_points    = news;
+    }
+
+    outline->num_points   = num_points;
+    outline->num_contours = num_contours;
+
+    outline->num_hedges    = 0;
+    outline->num_vedges    = 0;
+    outline->num_hsegments = 0;
+    outline->num_vsegments = 0;
+
+    /* We can't rely on the value of `FT_Outline.flags' to know the fill  */
+    /* direction used for a glyph, given that some fonts are broken (e.g. */
+    /* the Arphic ones).  We thus recompute it each time we need to.      */
+    /*                                                                    */
+    outline->vert_major_dir = AH_DIR_UP;
+    outline->horz_major_dir = AH_DIR_LEFT;
+
+    if ( ah_get_orientation( source ) > 1 )
+    {
+      outline->vert_major_dir = AH_DIR_DOWN;
+      outline->horz_major_dir = AH_DIR_RIGHT;
+    }
+
+    outline->x_scale = x_scale;
+    outline->y_scale = y_scale;
+
+    points = outline->points;
+    if ( outline->num_points == 0 )
+      goto Exit;
+
+    {
+      /* do one thing at a time -- it is easier to understand, and */
+      /* the code is clearer                                       */
+      AH_Point  point;
+      AH_Point  point_limit = points + outline->num_points;
+
+
+      /* compute coordinates */
+      {
+        FT_Vector*  vec = source->points;
+
+
+        for ( point = points; point < point_limit; vec++, point++ )
+        {
+          point->fx = vec->x;
+          point->fy = vec->y;
+          point->ox = point->x = FT_MulFix( vec->x, x_scale );
+          point->oy = point->y = FT_MulFix( vec->y, y_scale );
+
+          point->flags = 0;
+        }
+      }
+
+      /* compute Bezier flags */
+      {
+        char*  tag = source->tags;
+
+
+        for ( point = points; point < point_limit; point++, tag++ )
+        {
+          switch ( FT_CURVE_TAG( *tag ) )
+          {
+          case FT_CURVE_TAG_CONIC:
+            point->flags = AH_FLAG_CONIC;
+            break;
+          case FT_CURVE_TAG_CUBIC:
+            point->flags = AH_FLAG_CUBIC;
+            break;
+          default:
+            ;
+          }
+        }
+      }
+
+      /* compute `next' and `prev' */
+      {
+        FT_Int    contour_index;
+        AH_Point  prev;
+        AH_Point  first;
+        AH_Point  end;
+
+
+        contour_index = 0;
+
+        first = points;
+        end   = points + source->contours[0];
+        prev  = end;
+
+        for ( point = points; point < point_limit; point++ )
+        {
+          point->prev = prev;
+          if ( point < end )
+          {
+            point->next = point + 1;
+            prev        = point;
+          }
+          else
+          {
+            point->next = first;
+            contour_index++;
+            if ( point + 1 < point_limit )
+            {
+              end   = points + source->contours[contour_index];
+              first = point + 1;
+              prev  = end;
+            }
+          }
+        }
+      }
+
+      /* set-up the contours array */
+      {
+        AH_Point*  contour       = outline->contours;
+        AH_Point*  contour_limit = contour + outline->num_contours;
+        short*     end           = source->contours;
+        short      idx           = 0;
+
+
+        for ( ; contour < contour_limit; contour++, end++ )
+        {
+          contour[0] = points + idx;
+          idx        = (short)( end[0] + 1 );
+        }
+      }
+
+      /* compute directions of in & out vectors */
+      {
+        for ( point = points; point < point_limit; point++ )
+        {
+          AH_Point   prev;
+          AH_Point   next;
+          FT_Vector  ivec, ovec;
+
+
+          prev   = point->prev;
+          ivec.x = point->fx - prev->fx;
+          ivec.y = point->fy - prev->fy;
+
+          point->in_dir = ah_compute_direction( ivec.x, ivec.y );
+
+          next   = point->next;
+          ovec.x = next->fx - point->fx;
+          ovec.y = next->fy - point->fy;
+
+          point->out_dir = ah_compute_direction( ovec.x, ovec.y );
+
+#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
+          if ( point->flags & ( AH_FLAG_CONIC | AH_FLAG_CUBIC ) )
+          {
+          Is_Weak_Point:
+            point->flags |= AH_FLAG_WEAK_INTERPOLATION;
+          }
+          else if ( point->out_dir == point->in_dir )
+          {
+            AH_Angle  angle_in, angle_out, delta;
+
+
+            if ( point->out_dir != AH_DIR_NONE )
+              goto Is_Weak_Point;
+
+            angle_in  = ah_angle( &ivec );
+            angle_out = ah_angle( &ovec );
+            delta     = angle_in - angle_out;
+
+            if ( delta > AH_PI )
+              delta = AH_2PI - delta;
+
+            if ( delta < 0 )
+              delta = -delta;
+
+            if ( delta < 2 )
+              goto Is_Weak_Point;
+          }
+          else if ( point->in_dir == -point->out_dir )
+            goto Is_Weak_Point;
+#endif
+        }
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ah_setup_uv( AH_Outline  outline,
+               AH_UV       source )
+  {
+    AH_Point  point       = outline->points;
+    AH_Point  point_limit = point + outline->num_points;
+
+
+    switch ( source )
+    {
+    case AH_UV_FXY:
+      for ( ; point < point_limit; point++ )
+      {
+        point->u = point->fx;
+        point->v = point->fy;
+      }
+      break;
+
+    case AH_UV_FYX:
+      for ( ; point < point_limit; point++ )
+      {
+        point->u = point->fy;
+        point->v = point->fx;
+      }
+      break;
+
+    case AH_UV_OXY:
+      for ( ; point < point_limit; point++ )
+      {
+        point->u = point->ox;
+        point->v = point->oy;
+      }
+      break;
+
+    case AH_UV_OYX:
+      for ( ; point < point_limit; point++ )
+      {
+        point->u = point->oy;
+        point->v = point->ox;
+      }
+      break;
+
+    case AH_UV_YX:
+      for ( ; point < point_limit; point++ )
+      {
+        point->u = point->y;
+        point->v = point->x;
+      }
+      break;
+
+    case AH_UV_OX:
+      for ( ; point < point_limit; point++ )
+      {
+        point->u = point->x;
+        point->v = point->ox;
+      }
+      break;
+
+    case AH_UV_OY:
+      for ( ; point < point_limit; point++ )
+      {
+        point->u = point->y;
+        point->v = point->oy;
+      }
+      break;
+
+    default:
+      for ( ; point < point_limit; point++ )
+      {
+        point->u = point->x;
+        point->v = point->y;
+      }
+    }
+  }
+
+
+  /* compute all inflex points in a given glyph */
+  static void
+  ah_outline_compute_inflections( AH_Outline  outline )
+  {
+    AH_Point*  contour       = outline->contours;
+    AH_Point*  contour_limit = contour + outline->num_contours;
+
+
+    /* load original coordinates in (u,v) */
+    ah_setup_uv( outline, AH_UV_FXY );
+
+    /* do each contour separately */
+    for ( ; contour < contour_limit; contour++ )
+    {
+      FT_Vector  vec;
+      AH_Point   point = contour[0];
+      AH_Point   first = point;
+      AH_Point   start = point;
+      AH_Point   end   = point;
+      AH_Point   before;
+      AH_Point   after;
+      AH_Angle   angle_in, angle_seg, angle_out;
+      AH_Angle   diff_in, diff_out;
+      FT_Int     finished = 0;
+
+
+      /* compute first segment in contour */
+      first = point;
+
+      start = end = first;
+      do
+      {
+        end = end->next;
+        if ( end == first )
+          goto Skip;
+
+      } while ( end->u == first->u && end->v == first->v );
+
+      vec.x = end->u - start->u;
+      vec.y = end->v - start->v;
+      angle_seg = ah_angle( &vec );
+
+      /* extend the segment start whenever possible */
+      before = start;
+      do
+      {
+        do
+        {
+          start  = before;
+          before = before->prev;
+          if ( before == first )
+            goto Skip;
+
+        } while ( before->u == start->u && before->v == start->v );
+
+        vec.x    = start->u - before->u;
+        vec.y    = start->v - before->v;
+        angle_in = ah_angle( &vec );
+
+      } while ( angle_in == angle_seg );
+
+      first   = start;
+      diff_in = ah_angle_diff( angle_in, angle_seg );
+
+      /* now, process all segments in the contour */
+      do
+      {
+        /* first, extend current segment's end whenever possible */
+        after = end;
+        do
+        {
+          do
+          {
+            end   = after;
+            after = after->next;
+            if ( after == first )
+              finished = 1;
+
+          } while ( end->u == after->u && end->v == after->v );
+
+          vec.x     = after->u - end->u;
+          vec.y     = after->v - end->v;
+          angle_out = ah_angle( &vec );
+
+        } while ( angle_out == angle_seg );
+
+        diff_out = ah_angle_diff( angle_seg, angle_out );
+
+        if ( ( diff_in ^ diff_out ) < 0 )
+        {
+          /* diff_in and diff_out have different signs, we have */
+          /* inflection points here...                          */
+          do
+          {
+            start->flags |= AH_FLAG_INFLECTION;
+            start = start->next;
+
+          } while ( start != end );
+
+          start->flags |= AH_FLAG_INFLECTION;
+        }
+
+        start     = end;
+        end       = after;
+        angle_seg = angle_out;
+        diff_in   = diff_out;
+
+      } while ( !finished );
+
+    Skip:
+      ;
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ah_outline_compute_segments( AH_Outline  outline )
+  {
+    int           dimension;
+    AH_Segment    segments;
+    FT_Int*       p_num_segments;
+    AH_Direction  segment_dir;
+    AH_Direction  major_dir;
+
+
+    segments       = outline->horz_segments;
+    p_num_segments = &outline->num_hsegments;
+    major_dir      = AH_DIR_RIGHT;      /* This value must be positive! */
+    segment_dir    = major_dir;
+
+    /* set up (u,v) in each point */
+    ah_setup_uv( outline, AH_UV_FYX );
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Point*   contour       =  outline->contours;
+      AH_Point*   contour_limit =  contour + outline->num_contours;
+      AH_Segment  segment       =  segments;
+      FT_Int      num_segments  =  0;
+
+#ifdef AH_HINT_METRICS
+      AH_Point    min_point     =  0;
+      AH_Point    max_point     =  0;
+      FT_Pos      min_coord     =  32000;
+      FT_Pos      max_coord     = -32000;
+#endif
+
+
+      /* do each contour separately */
+      for ( ; contour < contour_limit; contour++ )
+      {
+        AH_Point  point   =  contour[0];
+        AH_Point  last    =  point->prev;
+        int       on_edge =  0;
+        FT_Pos    min_pos =  32000;  /* minimum segment pos != min_coord */
+        FT_Pos    max_pos = -32000;  /* maximum segment pos != max_coord */
+        FT_Bool   passed;
+
+
+#ifdef AH_HINT_METRICS
+        if ( point->u < min_coord )
+        {
+          min_coord = point->u;
+          min_point = point;
+        }
+        if ( point->u > max_coord )
+        {
+          max_coord = point->u;
+          max_point = point;
+        }
+#endif
+
+        if ( point == last )  /* skip singletons -- just in case */
+          continue;
+
+        if ( FT_ABS( last->out_dir )  == major_dir &&
+             FT_ABS( point->out_dir ) == major_dir )
+        {
+          /* we are already on an edge, try to locate its start */
+          last = point;
+
+          for (;;)
+          {
+            point = point->prev;
+            if ( FT_ABS( point->out_dir ) != major_dir )
+            {
+              point = point->next;
+              break;
+            }
+            if ( point == last )
+              break;
+          }
+        }
+
+        last   = point;
+        passed = 0;
+
+        for (;;)
+        {
+          FT_Pos  u, v;
+
+
+          if ( on_edge )
+          {
+            u = point->u;
+            if ( u < min_pos )
+              min_pos = u;
+            if ( u > max_pos )
+              max_pos = u;
+
+            if ( point->out_dir != segment_dir || point == last )
+            {
+              /* we are just leaving an edge; record a new segment! */
+              segment->last = point;
+              segment->pos  = ( min_pos + max_pos ) >> 1;
+
+              /* a segment is round if either its first or last point */
+              /* is a control point                                   */
+              if ( ( segment->first->flags | point->flags ) &
+                     AH_FLAG_CONTROL                        )
+                segment->flags |= AH_EDGE_ROUND;
+
+              /* compute segment size */
+              min_pos = max_pos = point->v;
+
+              v = segment->first->v;
+              if ( v < min_pos )
+                min_pos = v;
+              if ( v > max_pos )
+                max_pos = v;
+
+              segment->min_coord = min_pos;
+              segment->max_coord = max_pos;
+
+              on_edge = 0;
+              num_segments++;
+              segment++;
+              /* fallthrough */
+            }
+          }
+
+          /* now exit if we are at the start/end point */
+          if ( point == last )
+          {
+            if ( passed )
+              break;
+            passed = 1;
+          }
+
+          if ( !on_edge && FT_ABS( point->out_dir ) == major_dir )
+          {
+            /* this is the start of a new segment! */
+            segment_dir = point->out_dir;
+
+            /* clear all segment fields */
+            FT_ZERO( segment );
+
+            segment->dir      = segment_dir;
+            segment->flags    = AH_EDGE_NORMAL;
+            min_pos = max_pos = point->u;
+            segment->first    = point;
+            segment->last     = point;
+            segment->contour  = contour;
+            segment->score    = 32000;
+            segment->link     = NULL;
+            on_edge           = 1;
+
+#ifdef AH_HINT_METRICS
+            if ( point == max_point )
+              max_point = 0;
+
+            if ( point == min_point )
+              min_point = 0;
+#endif
+          }
+
+          point = point->next;
+        }
+
+      } /* contours */
+
+#ifdef AH_HINT_METRICS
+      /* we need to ensure that there are edges on the left-most and  */
+      /* right-most points of the glyph in order to hint the metrics; */
+      /* we do this by inserting fake segments when needed            */
+      if ( dimension == 0 )
+      {
+        AH_Point  point       = outline->points;
+        AH_Point  point_limit = point + outline->num_points;
+
+        FT_Pos    min_pos =  32000;
+        FT_Pos    max_pos = -32000;
+
+
+        min_point = 0;
+        max_point = 0;
+
+        /* compute minimum and maximum points */
+        for ( ; point < point_limit; point++ )
+        {
+          FT_Pos  x = point->fx;
+
+
+          if ( x < min_pos )
+          {
+            min_pos   = x;
+            min_point = point;
+          }
+          if ( x > max_pos )
+          {
+            max_pos   = x;
+            max_point = point;
+          }
+        }
+
+        /* insert minimum segment */
+        if ( min_point )
+        {
+          /* clear all segment fields */
+          FT_ZERO( segment );
+
+          segment->dir   = segment_dir;
+          segment->flags = AH_EDGE_NORMAL;
+          segment->first = min_point;
+          segment->last  = min_point;
+          segment->pos   = min_pos;
+          segment->score = 32000;
+          segment->link  = NULL;
+
+          num_segments++;
+          segment++;
+        }
+
+        /* insert maximum segment */
+        if ( max_point )
+        {
+          /* clear all segment fields */
+          FT_ZERO( segment );
+
+          segment->dir   = segment_dir;
+          segment->flags = AH_EDGE_NORMAL;
+          segment->first = max_point;
+          segment->last  = max_point;
+          segment->pos   = max_pos;
+          segment->score = 32000;
+          segment->link  = NULL;
+
+          num_segments++;
+          segment++;
+        }
+      }
+#endif /* AH_HINT_METRICS */
+
+      *p_num_segments = num_segments;
+
+      segments       = outline->vert_segments;
+      major_dir      = AH_DIR_UP;
+      p_num_segments = &outline->num_vsegments;
+
+      ah_setup_uv( outline, AH_UV_FXY );
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ah_outline_link_segments( AH_Outline  outline )
+  {
+    AH_Segment    segments;
+    AH_Segment    segment_limit;
+    AH_Direction  major_dir;
+    int           dimension;
+
+
+    segments      = outline->horz_segments;
+    segment_limit = segments + outline->num_hsegments;
+    major_dir     = outline->horz_major_dir;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Segment  seg1;
+      AH_Segment  seg2;
+
+#if 0
+      /* now compare each segment to the others */
+      for ( seg1 = segments; seg1 < segment_limit; seg1++ )
+      {
+        FT_Pos      best_score;
+        AH_Segment  best_segment;
+
+
+        /* the fake segments are introduced to hint the metrics -- */
+        /* we must never link them to anything                     */
+        if ( seg1->first == seg1->last )
+          continue;
+
+        best_segment = seg1->link;
+        if ( best_segment )
+          best_score = seg1->score;
+        else
+          best_score = +32000;
+
+        for ( seg2 = segments; seg2 < segment_limit; seg2++ )
+          if ( seg1 != seg2 && seg1->dir + seg2->dir == 0 )
+          {
+            FT_Pos   pos1 = seg1->pos;
+            FT_Pos   pos2 = seg2->pos;
+            FT_Bool  is_dir;
+            FT_Bool  is_pos;
+
+
+            /* check that the segments are correctly oriented and */
+            /* positioned to form a black distance                */
+
+            is_dir = (FT_Bool)( seg1->dir == outline->horz_major_dir ||
+                                seg1->dir == outline->vert_major_dir );
+            is_pos = (FT_Bool)( pos1 > pos2 );
+
+            if ( pos1 == pos2 || !(is_dir ^ is_pos) )
+              continue;
+
+            {
+              FT_Pos  min = seg1->min_coord;
+              FT_Pos  max = seg1->max_coord;
+              FT_Pos  len, dist, score;
+
+
+              if ( min < seg2->min_coord )
+                min = seg2->min_coord;
+
+              if ( max > seg2->max_coord )
+                max = seg2->max_coord;
+
+              len = max - min;
+              if ( len >= 8 )
+              {
+                dist = seg2->pos - seg1->pos;
+                if ( dist < 0 )
+                  dist = -dist;
+
+                score = dist + 3000 / len;
+
+                if ( score < best_score )
+                {
+                  best_score   = score;
+                  best_segment = seg2;
+                }
+              }
+            }
+          }
+
+        if ( best_segment )
+        {
+          seg1->link  = best_segment;
+          seg1->score = best_score;
+          best_segment->num_linked++;
+        }
+      }
+#endif /* 0 */
+
+#if 1
+      /* the following code does the same, but much faster! */
+
+      /* now compare each segment to the others */
+      for ( seg1 = segments; seg1 < segment_limit; seg1++ )
+      {
+        /* the fake segments are introduced to hint the metrics -- */
+        /* we must never link them to anything                     */
+        if ( seg1->first == seg1->last || seg1->dir != major_dir )
+          continue;
+
+        for ( seg2 = segments; seg2 < segment_limit; seg2++ )
+          if ( seg2 != seg1 && seg1->dir + seg2->dir == 0 )
+          {
+            FT_Pos  pos1 = seg1->pos;
+            FT_Pos  pos2 = seg2->pos;
+            FT_Pos  dist = pos2 - pos1;
+
+
+            if ( dist < 0 )
+              continue;
+
+            {
+              FT_Pos  min = seg1->min_coord;
+              FT_Pos  max = seg1->max_coord;
+              FT_Pos  len, score;
+
+
+              if ( min < seg2->min_coord )
+                min = seg2->min_coord;
+
+              if ( max > seg2->max_coord )
+                max = seg2->max_coord;
+
+              len = max - min;
+              if ( len >= 8 )
+              {
+                score = dist + 3000 / len;
+
+                if ( score < seg1->score )
+                {
+                  seg1->score = score;
+                  seg1->link  = seg2;
+                }
+
+                if ( score < seg2->score )
+                {
+                  seg2->score = score;
+                  seg2->link  = seg1;
+                }
+              }
+            }
+          }
+      }
+#endif /* 1 */
+
+      /* now, compute the `serif' segments */
+      for ( seg1 = segments; seg1 < segment_limit; seg1++ )
+      {
+        seg2 = seg1->link;
+
+        if ( seg2 )
+        {
+          seg2->num_linked++;
+          if ( seg2->link != seg1 )
+          {
+            seg1->link  = 0;
+            seg1->serif = seg2->link;
+          }
+        }
+      }
+
+      segments      = outline->vert_segments;
+      segment_limit = segments + outline->num_vsegments;
+      major_dir     = outline->vert_major_dir;
+    }
+  }
+
+
+  static void
+  ah_outline_compute_edges( AH_Outline  outline )
+  {
+    AH_Edge       edges;
+    AH_Segment    segments;
+    AH_Segment    segment_limit;
+    AH_Direction  up_dir;
+    FT_Int*       p_num_edges;
+    FT_Int        dimension;
+    FT_Fixed      scale;
+    FT_Pos        edge_distance_threshold;
+
+
+    edges         = outline->horz_edges;
+    segments      = outline->horz_segments;
+    segment_limit = segments + outline->num_hsegments;
+    p_num_edges   = &outline->num_hedges;
+    up_dir        = AH_DIR_RIGHT;
+    scale         = outline->y_scale;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Edge     edge;
+      AH_Edge     edge_limit;  /* really == edge + num_edges */
+      AH_Segment  seg;
+
+
+      /*********************************************************************/
+      /*                                                                   */
+      /* We will begin by generating a sorted table of edges for the       */
+      /* current direction.  To do so, we simply scan each segment and try */
+      /* to find an edge in our table that corresponds to its position.    */
+      /*                                                                   */
+      /* If no edge is found, we create and insert a new edge in the       */
+      /* sorted table.  Otherwise, we simply add the segment to the edge's */
+      /* list which will be processed in the second step to compute the    */
+      /* edge's properties.                                                */
+      /*                                                                   */
+      /* Note that the edges table is sorted along the segment/edge        */
+      /* position.                                                         */
+      /*                                                                   */
+      /*********************************************************************/
+
+      edge_distance_threshold = FT_MulFix( outline->edge_distance_threshold,
+                                           scale );
+      if ( edge_distance_threshold > 64 / 4 )
+        edge_distance_threshold = 64 / 4;
+
+      edge_distance_threshold = FT_DivFix( edge_distance_threshold,
+                                           scale );
+
+      edge_limit = edges;
+      for ( seg = segments; seg < segment_limit; seg++ )
+      {
+        AH_Edge  found = 0;
+
+
+        /* look for an edge corresponding to the segment */
+        for ( edge = edges; edge < edge_limit; edge++ )
+        {
+          FT_Pos  dist;
+
+
+          dist = seg->pos - edge->fpos;
+          if ( dist < 0 )
+            dist = -dist;
+
+          if ( dist < edge_distance_threshold )
+          {
+            found = edge;
+            break;
+          }
+        }
+
+        if ( !found )
+        {
+          /* insert a new edge in the list and */
+          /* sort according to the position    */
+          while ( edge > edges && edge[-1].fpos > seg->pos )
+          {
+            edge[0] = edge[-1];
+            edge--;
+          }
+          edge_limit++;
+
+          /* clear all edge fields */
+          FT_MEM_ZERO( edge, sizeof ( *edge ) );
+
+          /* add the segment to the new edge's list */
+          edge->first    = seg;
+          edge->last     = seg;
+          edge->fpos     = seg->pos;
+          edge->opos     = edge->pos = FT_MulFix( seg->pos, scale );
+          seg->edge_next = seg;
+        }
+        else
+        {
+          /* if an edge was found, simply add the segment to the edge's */
+          /* list                                                       */
+          seg->edge_next        = edge->first;
+          edge->last->edge_next = seg;
+          edge->last            = seg;
+        }
+      }
+      *p_num_edges = (FT_Int)( edge_limit - edges );
+
+
+      /*********************************************************************/
+      /*                                                                   */
+      /* Good, we will now compute each edge's properties according to     */
+      /* segments found on its position.  Basically, these are:            */
+      /*                                                                   */
+      /*  - edge's main direction                                          */
+      /*  - stem edge, serif edge or both (which defaults to stem then)    */
+      /*  - rounded edge, straight or both (which defaults to straight)    */
+      /*  - link for edge                                                  */
+      /*                                                                   */
+      /*********************************************************************/
+
+      /* first of all, set the `edge' field in each segment -- this is */
+      /* required in order to compute edge links                       */
+
+      /* Note that I've tried to remove this loop, setting
+       * the "edge" field of each segment directly in the
+       * code above.  For some reason, it slows down execution
+       * speed -- on a Sun.
+       */
+      for ( edge = edges; edge < edge_limit; edge++ )
+      {
+        seg = edge->first;
+        if ( seg )
+          do
+          {
+            seg->edge = edge;
+            seg       = seg->edge_next;
+          }
+          while ( seg != edge->first );
+      }
+
+      /* now, compute each edge properties */
+      for ( edge = edges; edge < edge_limit; edge++ )
+      {
+        FT_Int  is_round    = 0;  /* does it contain round segments?    */
+        FT_Int  is_straight = 0;  /* does it contain straight segments? */
+        FT_Pos  ups         = 0;  /* number of upwards segments         */
+        FT_Pos  downs       = 0;  /* number of downwards segments       */
+
+
+        seg = edge->first;
+
+        do
+        {
+          FT_Bool  is_serif;
+
+
+          /* check for roundness of segment */
+          if ( seg->flags & AH_EDGE_ROUND )
+            is_round++;
+          else
+            is_straight++;
+
+          /* check for segment direction */
+          if ( seg->dir == up_dir )
+            ups   += seg->max_coord-seg->min_coord;
+          else
+            downs += seg->max_coord-seg->min_coord;
+
+          /* check for links -- if seg->serif is set, then seg->link must */
+          /* be ignored                                                   */
+          is_serif = (FT_Bool)( seg->serif && seg->serif->edge != edge );
+
+          if ( seg->link || is_serif )
+          {
+            AH_Edge     edge2;
+            AH_Segment  seg2;
+
+
+            edge2 = edge->link;
+            seg2  = seg->link;
+
+            if ( is_serif )
+            {
+              seg2  = seg->serif;
+              edge2 = edge->serif;
+            }
+
+            if ( edge2 )
+            {
+              FT_Pos  edge_delta;
+              FT_Pos  seg_delta;
+
+
+              edge_delta = edge->fpos - edge2->fpos;
+              if ( edge_delta < 0 )
+                edge_delta = -edge_delta;
+
+              seg_delta = seg->pos - seg2->pos;
+              if ( seg_delta < 0 )
+                seg_delta = -seg_delta;
+
+              if ( seg_delta < edge_delta )
+                edge2 = seg2->edge;
+            }
+            else
+              edge2 = seg2->edge;
+
+#ifdef FT_CONFIG_CHESTER_SERIF
+            if ( is_serif )
+            {
+              edge->serif   = edge2;
+              edge2->flags |= AH_EDGE_SERIF;
+            }
+            else
+              edge->link  = edge2;
+#else /* !FT_CONFIG_CHESTER_SERIF */
+            if ( is_serif )
+              edge->serif = edge2;
+            else
+              edge->link  = edge2;
+#endif /* !FT_CONFIG_CHESTER_SERIF */
+          }
+
+          seg = seg->edge_next;
+
+        } while ( seg != edge->first );
+
+        /* set the round/straight flags */
+        edge->flags = AH_EDGE_NORMAL;
+
+        if ( is_round > 0 && is_round >= is_straight )
+          edge->flags |= AH_EDGE_ROUND;
+
+        /* set the edge's main direction */
+        edge->dir = AH_DIR_NONE;
+
+        if ( ups > downs )
+          edge->dir = up_dir;
+
+        else if ( ups < downs )
+          edge->dir = -up_dir;
+
+        else if ( ups == downs )
+          edge->dir = 0;  /* both up and down! */
+
+        /* gets rid of serifs if link is set                */
+        /* XXX: This gets rid of many unpleasant artefacts! */
+        /*      Example: the `c' in cour.pfa at size 13     */
+
+        if ( edge->serif && edge->link )
+          edge->serif = 0;
+      }
+
+      edges         = outline->vert_edges;
+      segments      = outline->vert_segments;
+      segment_limit = segments + outline->num_vsegments;
+      p_num_edges   = &outline->num_vedges;
+      up_dir        = AH_DIR_UP;
+      scale         = outline->x_scale;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_detect_features                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Performs feature detection on a given AH_OutlineRec object.        */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  ah_outline_detect_features( AH_Outline  outline )
+  {
+    ah_outline_compute_segments   ( outline );
+    ah_outline_link_segments      ( outline );
+    ah_outline_compute_edges      ( outline );
+    ah_outline_compute_inflections( outline );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_compute_blue_edges                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the `blue edges' in a given outline (i.e. those that must */
+  /*    be snapped to a blue zone edge (top or bottom).                    */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  ah_outline_compute_blue_edges( AH_Outline       outline,
+                                 AH_Face_Globals  face_globals )
+  {
+    AH_Edge     edge       = outline->horz_edges;
+    AH_Edge     edge_limit = edge + outline->num_hedges;
+    AH_Globals  globals    = &face_globals->design;
+    FT_Fixed    y_scale    = outline->y_scale;
+
+    FT_Bool     blue_active[AH_BLUE_MAX];
+
+
+    /* compute which blue zones are active, i.e. have their scaled */
+    /* size < 3/4 pixels                                           */
+    {
+      AH_Blue  blue;
+      FT_Bool  check = 0;
+
+
+      for ( blue = AH_BLUE_CAPITAL_TOP; blue < AH_BLUE_MAX; blue++ )
+      {
+        FT_Pos  ref, shoot, dist;
+
+
+        ref   = globals->blue_refs[blue];
+        shoot = globals->blue_shoots[blue];
+        dist  = ref - shoot;
+        if ( dist < 0 )
+          dist = -dist;
+
+        blue_active[blue] = 0;
+
+        if ( FT_MulFix( dist, y_scale ) < 48 )
+        {
+          blue_active[blue] = 1;
+          check = 1;
+        }
+      }
+
+      /* return immediately if no blue zone is active */
+      if ( !check )
+        return;
+    }
+
+    /* for each horizontal edge search the blue zone which is closest */
+    for ( ; edge < edge_limit; edge++ )
+    {
+      AH_Blue  blue;
+      FT_Pos*  best_blue = 0;
+      FT_Pos   best_dist;  /* initial threshold */
+
+
+      /* compute the initial threshold as a fraction of the EM size */
+      best_dist = FT_MulFix( face_globals->face->units_per_EM / 40, y_scale );
+
+#ifdef FT_CONFIG_CHESTER_SMALL_F
+      if ( best_dist > 64 / 2 )
+        best_dist = 64 / 2;
+#else
+      if ( best_dist > 64 / 4 )
+        best_dist = 64 / 4;
+#endif
+
+      for ( blue = AH_BLUE_CAPITAL_TOP; blue < AH_BLUE_MAX; blue++ )
+      {
+        /* if it is a top zone, check for right edges -- if it is a bottom */
+        /* zone, check for left edges                                      */
+        /*                                                                 */
+        /* of course, that's for TrueType XXX                              */
+        FT_Bool  is_top_blue  =
+                   FT_BOOL( AH_IS_TOP_BLUE( blue ) );
+        FT_Bool  is_major_dir =
+                   FT_BOOL( edge->dir == outline->horz_major_dir );
+
+
+        if ( !blue_active[blue] )
+          continue;
+
+        /* if it is a top zone, the edge must be against the major    */
+        /* direction; if it is a bottom zone, it must be in the major */
+        /* direction                                                  */
+        if ( is_top_blue ^ is_major_dir )
+        {
+          FT_Pos   dist;
+          FT_Pos*  blue_pos = globals->blue_refs + blue;
+
+
+          /* first of all, compare it to the reference position */
+          dist = edge->fpos - *blue_pos;
+          if ( dist < 0 )
+            dist = -dist;
+
+          dist = FT_MulFix( dist, y_scale );
+          if ( dist < best_dist )
+          {
+            best_dist = dist;
+            best_blue = blue_pos;
+          }
+
+          /* now, compare it to the overshoot position if the edge is     */
+          /* rounded, and if the edge is over the reference position of a */
+          /* top zone, or under the reference position of a bottom zone   */
+          if ( edge->flags & AH_EDGE_ROUND && dist != 0 )
+          {
+            FT_Bool  is_under_ref = FT_BOOL( edge->fpos < *blue_pos );
+
+
+            if ( is_top_blue ^ is_under_ref )
+            {
+              blue_pos = globals->blue_shoots + blue;
+              dist = edge->fpos - *blue_pos;
+              if ( dist < 0 )
+                dist = -dist;
+
+              dist = FT_MulFix( dist, y_scale );
+              if ( dist < best_dist )
+              {
+                best_dist = dist;
+                best_blue = blue_pos;
+              }
+            }
+          }
+        }
+      }
+
+      if ( best_blue )
+        edge->blue_edge = best_blue;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ah_outline_scale_blue_edges                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function must be called before hinting in order to re-adjust  */
+  /*    the contents of the detected edges (basically change the `blue     */
+  /*    edge' pointer from `design units' to `scaled ones').               */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  ah_outline_scale_blue_edges( AH_Outline       outline,
+                               AH_Face_Globals  globals )
+  {
+    AH_Edge  edge       = outline->horz_edges;
+    AH_Edge  edge_limit = edge + outline->num_hedges;
+    FT_Pos   delta;
+
+
+    delta = globals->scaled.blue_refs - globals->design.blue_refs;
+
+    for ( ; edge < edge_limit; edge++ )
+    {
+      if ( edge->blue_edge )
+        edge->blue_edge += delta;
+    }
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahglyph.h b/nx-X11/extras/freetype2/src/autohint/ahglyph.h
new file mode 100644
index 000000000..b346cbe8b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahglyph.h
@@ -0,0 +1,95 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahglyph.h                                                              */
+/*                                                                         */
+/*    Routines used to load and analyze a given glyph before hinting       */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __AHGLYPH_H__
+#define __AHGLYPH_H__
+
+
+#include <ft2build.h>
+#include "ahtypes.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef enum  AH_UV_
+  {
+    AH_UV_FXY,
+    AH_UV_FYX,
+    AH_UV_OXY,
+    AH_UV_OYX,
+    AH_UV_OX,
+    AH_UV_OY,
+    AH_UV_YX,
+    AH_UV_XY  /* should always be last! */
+
+  } AH_UV;
+
+
+  FT_LOCAL( void )
+  ah_setup_uv( AH_Outline  outline,
+               AH_UV       source );
+
+
+  /* AH_OutlineRec functions - they should be typically called in this order */
+
+  FT_LOCAL( FT_Error )
+  ah_outline_new( FT_Memory    memory,
+                  AH_Outline*  aoutline );
+
+  FT_LOCAL( FT_Error )
+  ah_outline_load( AH_Outline  outline,
+                   FT_Fixed    x_scale,
+                   FT_Fixed    y_scale,
+                   FT_Face     face );
+
+  FT_LOCAL( void )
+  ah_outline_compute_segments( AH_Outline  outline );
+
+  FT_LOCAL( void )
+  ah_outline_link_segments( AH_Outline  outline );
+
+  FT_LOCAL( void )
+  ah_outline_detect_features( AH_Outline  outline );
+
+  FT_LOCAL( void )
+  ah_outline_compute_blue_edges( AH_Outline       outline,
+                                 AH_Face_Globals  globals );
+
+  FT_LOCAL( void )
+  ah_outline_scale_blue_edges( AH_Outline       outline,
+                               AH_Face_Globals  globals );
+
+  FT_LOCAL( void )
+  ah_outline_save( AH_Outline  outline,
+                   AH_Loader   loader );
+
+  FT_LOCAL( void )
+  ah_outline_done( AH_Outline  outline );
+
+
+FT_END_HEADER
+
+#endif /* __AHGLYPH_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahhint.c b/nx-X11/extras/freetype2/src/autohint/ahhint.c
new file mode 100644
index 000000000..8e8afeac4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahhint.c
@@ -0,0 +1,1937 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahhint.c                                                               */
+/*                                                                         */
+/*    Glyph hinter (body).                                                 */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 Catharon Productions Inc.        */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include "ahhint.h"
+#include "ahglyph.h"
+#include "ahangles.h"
+#include "aherrors.h"
+#include FT_OUTLINE_H
+
+
+#define FACE_GLOBALS( face )  ( (AH_Face_Globals)(face)->autohint.data )
+
+#define AH_USE_IUP
+#define OPTIM_STEM_SNAP
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****   Hinting routines                                              ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* snap a given width in scaled coordinates to one of the */
+  /* current standard widths                                */
+  static FT_Pos
+  ah_snap_width( FT_Pos*  widths,
+                 FT_Int   count,
+                 FT_Pos   width )
+  {
+    int     n;
+    FT_Pos  best      = 64 + 32 + 2;
+    FT_Pos  reference = width;
+    FT_Pos  scaled;
+
+
+    for ( n = 0; n < count; n++ )
+    {
+      FT_Pos  w;
+      FT_Pos  dist;
+
+
+      w = widths[n];
+      dist = width - w;
+      if ( dist < 0 )
+        dist = -dist;
+      if ( dist < best )
+      {
+        best      = dist;
+        reference = w;
+      }
+    }
+
+    scaled = FT_PIX_ROUND( reference );
+
+    if ( width >= reference )
+    {
+      if ( width < scaled + 48 )
+        width = reference;
+    }
+    else
+    {
+      if ( width > scaled - 48 )
+        width = reference;
+    }
+
+    return width;
+  }
+
+
+  /* compute the snapped width of a given stem */
+
+#ifdef FT_CONFIG_CHESTER_SERIF
+
+  static FT_Pos
+  ah_compute_stem_width( AH_Hinter      hinter,
+                         int            vertical,
+                         FT_Pos         width,
+                         AH_Edge_Flags  base_flags,
+                         AH_Edge_Flags  stem_flags )
+  {
+    AH_Globals  globals = &hinter->globals->scaled;
+    FT_Pos      dist    = width;
+    FT_Int      sign    = 0;
+
+
+    if ( dist < 0 )
+    {
+      dist = -width;
+      sign = 1;
+    }
+
+    if ( !hinter->do_stem_adjust )
+    {
+      /* leave stem widths unchanged */
+    }
+    else if ( (  vertical && !hinter->do_vert_snapping ) ||
+              ( !vertical && !hinter->do_horz_snapping ) )
+    {
+      /* smooth hinting process: very lightly quantize the stem width */
+      /*                                                              */
+
+      /* leave the widths of serifs alone */
+
+      if ( ( stem_flags & AH_EDGE_SERIF ) && vertical && ( dist < 3 * 64 ) )
+        goto Done_Width;
+
+      else if ( ( base_flags & AH_EDGE_ROUND ) )
+      {
+        if ( dist < 80 )
+          dist = 64;
+      }
+      else if ( dist < 56 )
+        dist = 56;
+
+      {
+        FT_Pos  delta = dist - globals->stds[vertical];
+
+
+        if ( delta < 0 )
+          delta = -delta;
+
+        if ( delta < 40 )
+        {
+          dist = globals->stds[vertical];
+          if ( dist < 48 )
+            dist = 48;
+
+          goto Done_Width;
+        }
+
+        if ( dist < 3 * 64 )
+        {
+          delta  = dist & 63;
+          dist  &= -64;
+
+          if ( delta < 10 )
+            dist += delta;
+
+          else if ( delta < 32 )
+            dist += 10;
+
+          else if ( delta < 54 )
+            dist += 54;
+
+          else
+            dist += delta;
+        }
+        else
+          dist = ( dist + 32 ) & ~63;
+      }
+    }
+    else
+    {
+      /* strong hinting process: snap the stem width to integer pixels */
+      /*                                                               */
+      if ( vertical )
+      {
+        dist = ah_snap_width( globals->heights, globals->num_heights, dist );
+
+        /* in the case of vertical hinting, always round */
+        /* the stem heights to integer pixels            */
+        if ( dist >= 64 )
+          dist = ( dist + 16 ) & ~63;
+        else
+          dist = 64;
+      }
+      else
+      {
+        dist = ah_snap_width( globals->widths, globals->num_widths, dist );
+
+        if ( hinter->flags & AH_HINTER_MONOCHROME )
+        {
+          /* monochrome horizontal hinting: snap widths to integer pixels */
+          /* with a different threshold                                   */
+          if ( dist < 64 )
+            dist = 64;
+          else
+            dist = ( dist + 32 ) & ~63;
+        }
+        else
+        {
+          /* for horizontal anti-aliased hinting, we adopt a more subtle */
+          /* approach: we strengthen small stems, round stems whose size */
+          /* is between 1 and 2 pixels to an integer, otherwise nothing  */
+          if ( dist < 48 )
+            dist = ( dist + 64 ) >> 1;
+
+          else if ( dist < 128 )
+            dist = ( dist + 22 ) & ~63;
+          else
+            /* XXX: round otherwise to prevent color fringes in LCD mode */
+            dist = ( dist + 32 ) & ~63;
+        }
+      }
+    }
+
+  Done_Width:
+    if ( sign )
+      dist = -dist;
+
+    return dist;
+  }
+
+#else /* !FT_CONFIG_CHESTER_SERIF */
+
+  static FT_Pos
+  ah_compute_stem_width( AH_Hinter  hinter,
+                         int        vertical,
+                         FT_Pos     width )
+  {
+    AH_Globals  globals = &hinter->globals->scaled;
+    FT_Pos      dist    = width;
+    FT_Int      sign    = 0;
+
+
+    if ( dist < 0 )
+    {
+      dist = -width;
+      sign = 1;
+    }
+
+    if ( !hinter->do_stem_adjust )
+    {
+      /* leave stem widths unchanged */
+    }
+    else if ( (  vertical && !hinter->do_vert_snapping ) ||
+              ( !vertical && !hinter->do_horz_snapping ) )
+    {
+      /* smooth hinting process: very lightly quantize the stem width */
+      /*                                                              */
+      if ( dist < 64 )
+        dist = 64;
+
+      {
+        FT_Pos  delta = dist - globals->stds[vertical];
+
+
+        if ( delta < 0 )
+          delta = -delta;
+
+        if ( delta < 40 )
+        {
+          dist = globals->stds[vertical];
+          if ( dist < 48 )
+            dist = 48;
+        }
+
+        if ( dist < 3 * 64 )
+        {
+          delta  = dist & 63;
+          dist  &= -64;
+
+          if ( delta < 10 )
+            dist += delta;
+
+          else if ( delta < 32 )
+            dist += 10;
+
+          else if ( delta < 54 )
+            dist += 54;
+
+          else
+            dist += delta;
+        }
+        else
+          dist = ( dist + 32 ) & ~63;
+      }
+    }
+    else
+    {
+      /* strong hinting process: snap the stem width to integer pixels */
+      /*                                                               */
+      if ( vertical )
+      {
+        dist = ah_snap_width( globals->heights, globals->num_heights, dist );
+
+        /* in the case of vertical hinting, always round */
+        /* the stem heights to integer pixels            */
+        if ( dist >= 64 )
+          dist = ( dist + 16 ) & ~63;
+        else
+          dist = 64;
+      }
+      else
+      {
+        dist = ah_snap_width( globals->widths, globals->num_widths, dist );
+
+        if ( hinter->flags & AH_HINTER_MONOCHROME )
+        {
+          /* monochrome horizontal hinting: snap widths to integer pixels */
+          /* with a different threshold                                   */
+          if ( dist < 64 )
+            dist = 64;
+          else
+            dist = ( dist + 32 ) & ~63;
+        }
+        else
+        {
+          /* for horizontal anti-aliased hinting, we adopt a more subtle */
+          /* approach: we strengthen small stems, round stems whose size */
+          /* is between 1 and 2 pixels to an integer, otherwise nothing  */
+          if ( dist < 48 )
+            dist = ( dist + 64 ) >> 1;
+
+          else if ( dist < 128 )
+            dist = ( dist + 22 ) & ~63;
+          else
+            /* XXX: round otherwise to prevent color fringes in LCD mode */
+            dist = ( dist + 32 ) & ~63;
+        }
+      }
+    }
+
+    if ( sign )
+      dist = -dist;
+
+    return dist;
+  }
+
+#endif /* !FT_CONFIG_CHESTER_SERIF */
+
+
+  /* align one stem edge relative to the previous stem edge */
+  static void
+  ah_align_linked_edge( AH_Hinter  hinter,
+                        AH_Edge    base_edge,
+                        AH_Edge    stem_edge,
+                        int        vertical )
+  {
+    FT_Pos  dist = stem_edge->opos - base_edge->opos;
+
+#ifdef FT_CONFIG_CHESTER_SERIF
+
+    FT_Pos  fitted_width = ah_compute_stem_width( hinter,
+                                                  vertical,
+                                                  dist,
+                                                  base_edge->flags,
+                                                  stem_edge->flags );
+
+
+    stem_edge->pos = base_edge->pos + fitted_width;
+
+#else
+
+    stem_edge->pos = base_edge->pos +
+                     ah_compute_stem_width( hinter, vertical, dist );
+
+#endif
+
+  }
+
+
+  static void
+  ah_align_serif_edge( AH_Hinter  hinter,
+                       AH_Edge    base,
+                       AH_Edge    serif,
+                       int        vertical )
+  {
+    FT_Pos  dist;
+    FT_Pos  sign = 1;
+
+    FT_UNUSED( hinter );
+    FT_UNUSED( vertical );
+
+
+    dist = serif->opos - base->opos;
+    if ( dist < 0 )
+    {
+      dist = -dist;
+      sign = -1;
+    }
+
+#if 0
+    /* do not touch serifs widths! */
+    if ( base->flags & AH_EDGE_DONE )
+    {
+      if ( dist >= 64 )
+        dist = ( dist + 8 ) & ~63;
+
+      else if ( dist <= 32 && !vertical )
+        dist = ( dist + 33 ) >> 1;
+
+      else
+        dist = 0;
+    }
+#endif
+
+    serif->pos = base->pos + sign * dist;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****       E D G E   H I N T I N G                                   ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( void )
+  ah_hinter_hint_edges( AH_Hinter  hinter )
+  {
+    AH_Edge     edges;
+    AH_Edge     edge_limit;
+    AH_Outline  outline = hinter->glyph;
+    FT_Int      dimension;
+    FT_Int      n_edges;
+
+
+    edges      = outline->horz_edges;
+    edge_limit = edges + outline->num_hedges;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Edge  edge;
+      AH_Edge  anchor = 0;
+      int      has_serifs = 0;
+
+
+      if ( !hinter->do_horz_hints && !dimension )
+        goto Next_Dimension;
+
+      if ( !hinter->do_vert_hints && dimension )
+        goto Next_Dimension;
+
+      /* we begin by aligning all stems relative to the blue zone */
+      /* if needed -- that's only for horizontal edges            */
+      if ( dimension )
+      {
+        for ( edge = edges; edge < edge_limit; edge++ )
+        {
+          FT_Pos*      blue;
+          AH_EdgeRec  *edge1, *edge2;
+
+
+          if ( edge->flags & AH_EDGE_DONE )
+            continue;
+
+          blue  = edge->blue_edge;
+          edge1 = 0;
+          edge2 = edge->link;
+
+          if ( blue )
+          {
+            edge1 = edge;
+          }
+          else if ( edge2 && edge2->blue_edge )
+          {
+            blue  = edge2->blue_edge;
+            edge1 = edge2;
+            edge2 = edge;
+          }
+
+          if ( !edge1 )
+            continue;
+
+          edge1->pos    = blue[0];
+          edge1->flags |= AH_EDGE_DONE;
+
+          if ( edge2 && !edge2->blue_edge )
+          {
+            ah_align_linked_edge( hinter, edge1, edge2, dimension );
+            edge2->flags |= AH_EDGE_DONE;
+          }
+
+          if ( !anchor )
+            anchor = edge;
+        }
+      }
+
+      /* now we will align all stem edges, trying to maintain the */
+      /* relative order of stems in the glyph                     */
+      for ( edge = edges; edge < edge_limit; edge++ )
+      {
+        AH_EdgeRec*  edge2;
+
+
+        if ( edge->flags & AH_EDGE_DONE )
+          continue;
+
+        /* skip all non-stem edges */
+        edge2 = edge->link;
+        if ( !edge2 )
+        {
+          has_serifs++;
+          continue;
+        }
+
+        /* now align the stem */
+
+        /* this should not happen, but it's better to be safe */
+        if ( edge2->blue_edge || edge2 < edge )
+        {
+          ah_align_linked_edge( hinter, edge2, edge, dimension );
+          edge->flags |= AH_EDGE_DONE;
+          continue;
+        }
+
+        if ( !anchor )
+        {
+
+#ifdef FT_CONFIG_CHESTER_STEM
+
+          FT_Pos  org_len, org_center, cur_len;
+          FT_Pos  cur_pos1, error1, error2, u_off, d_off;
+
+
+          org_len = edge2->opos - edge->opos;
+          cur_len = ah_compute_stem_width( hinter, dimension, org_len,
+                                           edge->flags, edge2->flags );
+
+          if ( cur_len <= 64 )
+            u_off = d_off = 32;
+          else
+          {
+            u_off = 38;
+            d_off = 26;
+          }
+
+          if ( cur_len < 96 )
+          {
+            org_center = edge->opos + ( org_len >> 1 );
+
+            cur_pos1   = FT_PIX_ROUND( org_center );
+
+            error1 = org_center - ( cur_pos1 - u_off );
+            if ( error1 < 0 )
+              error1 = -error1;
+
+            error2 = org_center - ( cur_pos1 + d_off );
+            if ( error2 < 0 )
+              error2 = -error2;
+
+            if ( error1 < error2 )
+              cur_pos1 -= u_off;
+            else
+              cur_pos1 += d_off;
+
+            edge->pos  = cur_pos1 - cur_len / 2;
+            edge2->pos = cur_pos1 + cur_len / 2;
+
+          }
+          else
+            edge->pos = FT_PIX_ROUND( edge->opos );
+
+          anchor = edge;
+
+          edge->flags |= AH_EDGE_DONE;
+
+          ah_align_linked_edge( hinter, edge, edge2, dimension );
+
+#else /* !FT_CONFIG_CHESTER_STEM */
+
+          edge->pos = FT_PIX_ROUND( edge->opos );
+          anchor    = edge;
+
+          edge->flags |= AH_EDGE_DONE;
+
+          ah_align_linked_edge( hinter, edge, edge2, dimension );
+
+#endif /* !FT_CONFIG_CHESTER_STEM */
+
+        }
+        else
+        {
+          FT_Pos  org_pos, org_len, org_center, cur_len;
+          FT_Pos  cur_pos1, cur_pos2, delta1, delta2;
+
+
+          org_pos    = anchor->pos + ( edge->opos - anchor->opos );
+          org_len    = edge2->opos - edge->opos;
+          org_center = org_pos + ( org_len >> 1 );
+
+#ifdef FT_CONFIG_CHESTER_SERIF
+
+          cur_len = ah_compute_stem_width( hinter, dimension, org_len,
+                                           edge->flags, edge2->flags  );
+
+
+#else  /* !FT_CONFIG_CHESTER_SERIF */
+
+          cur_len = ah_compute_stem_width( hinter, dimension, org_len );
+
+#endif /* !FT_CONFIG_CHESTER_SERIF */
+
+#ifdef FT_CONFIG_CHESTER_STEM
+
+          if ( cur_len < 96 )
+          {
+            FT_Pos  u_off, d_off;
+
+
+            cur_pos1 = FT_PIX_ROUND( org_center );
+
+            if (cur_len <= 64 )
+              u_off = d_off = 32;
+            else
+            {
+              u_off = 38;
+              d_off = 26;
+            }
+
+            delta1 = org_center - ( cur_pos1 - u_off );
+            if ( delta1 < 0 )
+              delta1 = -delta1;
+
+            delta2 = org_center - ( cur_pos1 + d_off );
+            if ( delta2 < 0 )
+              delta2 = -delta2;
+
+            if ( delta1 < delta2 )
+              cur_pos1 -= u_off;
+            else
+              cur_pos1 += d_off;
+
+            edge->pos  = cur_pos1 - cur_len / 2;
+            edge2->pos = cur_pos1 + cur_len / 2;
+          }
+          else
+          {
+            org_pos    = anchor->pos + ( edge->opos - anchor->opos );
+            org_len    = edge2->opos - edge->opos;
+            org_center = org_pos + ( org_len >> 1 );
+
+            cur_len    = ah_compute_stem_width( hinter, dimension, org_len,
+                                                edge->flags, edge2->flags );
+
+            cur_pos1   = FT_PIX_ROUND( org_pos );
+            delta1     = ( cur_pos1 + ( cur_len >> 1 ) - org_center );
+            if ( delta1 < 0 )
+              delta1 = -delta1;
+
+            cur_pos2   = FT_PIX_ROUND( org_pos + org_len ) - cur_len;
+            delta2     = ( cur_pos2 + ( cur_len >> 1 ) - org_center );
+            if ( delta2 < 0 )
+              delta2 = -delta2;
+
+            edge->pos  = ( delta1 < delta2 ) ? cur_pos1 : cur_pos2;
+            edge2->pos = edge->pos + cur_len;
+          }
+
+#else /* !FT_CONFIG_CHESTER_STEM */
+
+          cur_pos1   = FT_PIX_ROUND( org_pos );
+          delta1     = ( cur_pos1 + ( cur_len >> 1 ) - org_center );
+          if ( delta1 < 0 )
+            delta1 = -delta1;
+
+          cur_pos2   = FT_PIX_ROUND( org_pos + org_len ) - cur_len;
+          delta2     = ( cur_pos2 + ( cur_len >> 1 ) - org_center );
+          if ( delta2 < 0 )
+            delta2 = -delta2;
+
+          edge->pos  = ( delta1 <= delta2 ) ? cur_pos1 : cur_pos2;
+          edge2->pos = edge->pos + cur_len;
+
+#endif /* !FT_CONFIG_CHESTER_STEM */
+
+          edge->flags  |= AH_EDGE_DONE;
+          edge2->flags |= AH_EDGE_DONE;
+
+          if ( edge > edges && edge->pos < edge[-1].pos )
+            edge->pos = edge[-1].pos;
+        }
+      }
+
+      /* make sure that lowercase m's maintain their symmetry */
+
+      /* In general, lowercase m's have six vertical edges if they are sans */
+      /* serif, or twelve if they are avec serif.  This implementation is   */
+      /* based on that assumption, and seems to work very well with most    */
+      /* faces.  However, if for a certain face this assumption is not      */
+      /* true, the m is just rendered like before.  In addition, any stem   */
+      /* correction will only be applied to symmetrical glyphs (even if the */
+      /* glyph is not an m), so the potential for unwanted distortion is    */
+      /* relatively low.                                                    */
+
+      /* We don't handle horizontal edges since we can't easily assure that */
+      /* the third (lowest) stem aligns with the base line; it might end up */
+      /* one pixel higher or lower.                                         */
+
+      n_edges = (FT_Int)( edge_limit - edges );
+      if ( !dimension && ( n_edges == 6 || n_edges == 12 ) )
+      {
+        AH_EdgeRec  *edge1, *edge2, *edge3;
+        FT_Pos       dist1, dist2, span, delta;
+
+
+        if ( n_edges == 6 )
+        {
+          edge1 = edges;
+          edge2 = edges + 2;
+          edge3 = edges + 4;
+        }
+        else
+        {
+          edge1 = edges + 1;
+          edge2 = edges + 5;
+          edge3 = edges + 9;
+        }
+
+        dist1 = edge2->opos - edge1->opos;
+        dist2 = edge3->opos - edge2->opos;
+
+        span = dist1 - dist2;
+        if ( span < 0 )
+          span = -span;
+
+        if ( span < 8 )
+        {
+          delta = edge3->pos - ( 2 * edge2->pos - edge1->pos );
+          edge3->pos -= delta;
+          if ( edge3->link )
+            edge3->link->pos -= delta;
+
+          /* move the serifs along with the stem */
+          if ( n_edges == 12 )
+          {
+            ( edges + 8 )->pos -= delta;
+            ( edges + 11 )->pos -= delta;
+          }
+
+          edge3->flags |= AH_EDGE_DONE;
+          if ( edge3->link )
+            edge3->link->flags |= AH_EDGE_DONE;
+        }
+      }
+
+      if ( !has_serifs )
+        goto Next_Dimension;
+
+      /* now hint the remaining edges (serifs and single) in order */
+      /* to complete our processing                                */
+      for ( edge = edges; edge < edge_limit; edge++ )
+      {
+        if ( edge->flags & AH_EDGE_DONE )
+          continue;
+
+        if ( edge->serif )
+          ah_align_serif_edge( hinter, edge->serif, edge, dimension );
+        else if ( !anchor )
+        {
+          edge->pos = FT_PIX_ROUND( edge->opos );
+          anchor    = edge;
+        }
+        else
+          edge->pos = anchor->pos +
+                      FT_PIX_ROUND( edge->opos - anchor->opos );
+
+        edge->flags |= AH_EDGE_DONE;
+
+        if ( edge > edges && edge->pos < edge[-1].pos )
+          edge->pos = edge[-1].pos;
+
+        if ( edge + 1 < edge_limit        &&
+             edge[1].flags & AH_EDGE_DONE &&
+             edge->pos > edge[1].pos      )
+          edge->pos = edge[1].pos;
+      }
+
+    Next_Dimension:
+      edges      = outline->vert_edges;
+      edge_limit = edges + outline->num_vedges;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****       P O I N T   H I N T I N G                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  ah_hinter_align_edge_points( AH_Hinter  hinter )
+  {
+    AH_Outline  outline = hinter->glyph;
+    AH_Edge     edges;
+    AH_Edge     edge_limit;
+    FT_Int      dimension;
+
+
+    edges      = outline->horz_edges;
+    edge_limit = edges + outline->num_hedges;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Edge  edge;
+
+
+      edge = edges;
+      for ( ; edge < edge_limit; edge++ )
+      {
+        /* move the points of each segment     */
+        /* in each edge to the edge's position */
+        AH_Segment  seg = edge->first;
+
+
+        do
+        {
+          AH_Point  point = seg->first;
+
+
+          for (;;)
+          {
+            if ( dimension )
+            {
+              point->y      = edge->pos;
+              point->flags |= AH_FLAG_TOUCH_Y;
+            }
+            else
+            {
+              point->x      = edge->pos;
+              point->flags |= AH_FLAG_TOUCH_X;
+            }
+
+            if ( point == seg->last )
+              break;
+
+            point = point->next;
+          }
+
+          seg = seg->edge_next;
+
+        } while ( seg != edge->first );
+      }
+
+      edges      = outline->vert_edges;
+      edge_limit = edges + outline->num_vedges;
+    }
+  }
+
+
+  /* hint the strong points -- this is equivalent to the TrueType `IP' */
+  /* hinting instruction                                               */
+  static void
+  ah_hinter_align_strong_points( AH_Hinter  hinter )
+  {
+    AH_Outline  outline = hinter->glyph;
+    FT_Int      dimension;
+    AH_Edge     edges;
+    AH_Edge     edge_limit;
+    AH_Point    points;
+    AH_Point    point_limit;
+    AH_Flags    touch_flag;
+
+
+    points      = outline->points;
+    point_limit = points + outline->num_points;
+
+    edges       = outline->horz_edges;
+    edge_limit  = edges + outline->num_hedges;
+    touch_flag  = AH_FLAG_TOUCH_Y;
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Point  point;
+      AH_Edge   edge;
+
+
+      if ( edges < edge_limit )
+        for ( point = points; point < point_limit; point++ )
+        {
+          FT_Pos  u, ou, fu;  /* point position */
+          FT_Pos  delta;
+
+
+          if ( point->flags & touch_flag )
+            continue;
+
+#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
+          /* if this point is candidate to weak interpolation, we will  */
+          /* interpolate it after all strong points have been processed */
+          if (  ( point->flags & AH_FLAG_WEAK_INTERPOLATION ) &&
+               !( point->flags & AH_FLAG_INFLECTION )         )
+            continue;
+#endif
+
+          if ( dimension )
+          {
+            u  = point->fy;
+            ou = point->oy;
+          }
+          else
+          {
+            u  = point->fx;
+            ou = point->ox;
+          }
+
+          fu = u;
+
+          /* is the point before the first edge? */
+          edge  = edges;
+          delta = edge->fpos - u;
+          if ( delta >= 0 )
+          {
+            u = edge->pos - ( edge->opos - ou );
+            goto Store_Point;
+          }
+
+          /* is the point after the last edge? */
+          edge  = edge_limit - 1;
+          delta = u - edge->fpos;
+          if ( delta >= 0 )
+          {
+            u = edge->pos + ( ou - edge->opos );
+            goto Store_Point;
+          }
+
+#if 1
+          {
+            FT_UInt  min, max, mid;
+            FT_Pos   fpos;
+
+
+            /* find enclosing edges */
+            min = 0;
+            max = (FT_UInt)( edge_limit - edges );
+
+            while ( min < max )
+            {
+              mid  = ( max + min ) >> 1;
+              edge = edges + mid;
+              fpos = edge->fpos;
+
+              if ( u < fpos )
+                max = mid;
+              else if ( u > fpos )
+                min = mid + 1;
+              else
+              {
+                /* we are on the edge */
+                u = edge->pos;
+                goto Store_Point;
+              }
+            }
+
+            {
+              AH_Edge  before = edges + min - 1;
+              AH_Edge  after  = edges + min + 0;
+
+
+              /* assert( before && after && before != after ) */
+              if ( before->scale == 0 )
+                before->scale = FT_DivFix( after->pos - before->pos,
+                                           after->fpos - before->fpos );
+
+              u = before->pos + FT_MulFix( fu - before->fpos,
+                                           before->scale );
+            }
+          }
+
+#else /* !0 */
+
+          /* otherwise, interpolate the point in between */
+          {
+            AH_Edge  before = 0;
+            AH_Edge  after  = 0;
+
+
+            for ( edge = edges; edge < edge_limit; edge++ )
+            {
+              if ( u == edge->fpos )
+              {
+                u = edge->pos;
+                goto Store_Point;
+              }
+              if ( u < edge->fpos )
+                break;
+              before = edge;
+            }
+
+            for ( edge = edge_limit - 1; edge >= edges; edge-- )
+            {
+              if ( u == edge->fpos )
+              {
+                u = edge->pos;
+                goto Store_Point;
+              }
+              if ( u > edge->fpos )
+                break;
+              after = edge;
+            }
+
+            if ( before->scale == 0 )
+              before->scale = FT_DivFix( after->pos - before->pos,
+                                        after->fpos - before->fpos );
+
+            u = before->pos + FT_MulFix( fu - before->fpos,
+                                        before->scale );
+          }
+
+#endif /* !0 */
+
+        Store_Point:
+
+          /* save the point position */
+          if ( dimension )
+            point->y = u;
+          else
+            point->x = u;
+
+          point->flags |= touch_flag;
+        }
+
+      edges      = outline->vert_edges;
+      edge_limit = edges + outline->num_vedges;
+      touch_flag = AH_FLAG_TOUCH_X;
+    }
+  }
+
+
+#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
+
+  static void
+  ah_iup_shift( AH_Point  p1,
+                AH_Point  p2,
+                AH_Point  ref )
+  {
+    AH_Point  p;
+    FT_Pos    delta = ref->u - ref->v;
+
+
+    for ( p = p1; p < ref; p++ )
+      p->u = p->v + delta;
+
+    for ( p = ref + 1; p <= p2; p++ )
+      p->u = p->v + delta;
+  }
+
+
+  static void
+  ah_iup_interp( AH_Point  p1,
+                 AH_Point  p2,
+                 AH_Point  ref1,
+                 AH_Point  ref2 )
+  {
+    AH_Point  p;
+    FT_Pos    u;
+    FT_Pos    v1 = ref1->v;
+    FT_Pos    v2 = ref2->v;
+    FT_Pos    d1 = ref1->u - v1;
+    FT_Pos    d2 = ref2->u - v2;
+
+
+    if ( p1 > p2 )
+      return;
+
+    if ( v1 == v2 )
+    {
+      for ( p = p1; p <= p2; p++ )
+      {
+        u = p->v;
+
+        if ( u <= v1 )
+          u += d1;
+        else
+          u += d2;
+
+        p->u = u;
+      }
+      return;
+    }
+
+    if ( v1 < v2 )
+    {
+      for ( p = p1; p <= p2; p++ )
+      {
+        u = p->v;
+
+        if ( u <= v1 )
+          u += d1;
+        else if ( u >= v2 )
+          u += d2;
+        else
+          u = ref1->u + FT_MulDiv( u - v1, ref2->u - ref1->u, v2 - v1 );
+
+        p->u = u;
+      }
+    }
+    else
+    {
+      for ( p = p1; p <= p2; p++ )
+      {
+        u = p->v;
+
+        if ( u <= v2 )
+          u += d2;
+        else if ( u >= v1 )
+          u += d1;
+        else
+          u = ref1->u + FT_MulDiv( u - v1, ref2->u - ref1->u, v2 - v1 );
+
+        p->u = u;
+      }
+    }
+  }
+
+
+  /* interpolate weak points -- this is equivalent to the TrueType `IUP' */
+  /* hinting instruction                                                 */
+  static void
+  ah_hinter_align_weak_points( AH_Hinter  hinter )
+  {
+    AH_Outline  outline = hinter->glyph;
+    FT_Int      dimension;
+    AH_Point    points;
+    AH_Point    point_limit;
+    AH_Point*   contour_limit;
+    AH_Flags    touch_flag;
+
+
+    points      = outline->points;
+    point_limit = points + outline->num_points;
+
+    /* PASS 1: Move segment points to edge positions */
+
+    touch_flag = AH_FLAG_TOUCH_Y;
+
+    contour_limit = outline->contours + outline->num_contours;
+
+    ah_setup_uv( outline, AH_UV_OY );
+
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      AH_Point   point;
+      AH_Point   end_point;
+      AH_Point   first_point;
+      AH_Point*  contour;
+
+
+      point   = points;
+      contour = outline->contours;
+
+      for ( ; contour < contour_limit; contour++ )
+      {
+        point       = *contour;
+        end_point   = point->prev;
+        first_point = point;
+
+        while ( point <= end_point && !( point->flags & touch_flag ) )
+          point++;
+
+        if ( point <= end_point )
+        {
+          AH_Point  first_touched = point;
+          AH_Point  cur_touched   = point;
+
+
+          point++;
+          while ( point <= end_point )
+          {
+            if ( point->flags & touch_flag )
+            {
+              /* we found two successive touched points; we interpolate */
+              /* all contour points between them                        */
+              ah_iup_interp( cur_touched + 1, point - 1,
+                             cur_touched, point );
+              cur_touched = point;
+            }
+            point++;
+          }
+
+          if ( cur_touched == first_touched )
+          {
+            /* this is a special case: only one point was touched in the */
+            /* contour; we thus simply shift the whole contour           */
+            ah_iup_shift( first_point, end_point, cur_touched );
+          }
+          else
+          {
+            /* now interpolate after the last touched point to the end */
+            /* of the contour                                          */
+            ah_iup_interp( cur_touched + 1, end_point,
+                           cur_touched, first_touched );
+
+            /* if the first contour point isn't touched, interpolate */
+            /* from the contour start to the first touched point     */
+            if ( first_touched > points )
+              ah_iup_interp( first_point, first_touched - 1,
+                             cur_touched, first_touched );
+          }
+        }
+      }
+
+      /* now save the interpolated values back to x/y */
+      if ( dimension )
+      {
+        for ( point = points; point < point_limit; point++ )
+          point->y = point->u;
+
+        touch_flag = AH_FLAG_TOUCH_X;
+        ah_setup_uv( outline, AH_UV_OX );
+      }
+      else
+      {
+        for ( point = points; point < point_limit; point++ )
+          point->x = point->u;
+
+        break;  /* exit loop */
+      }
+    }
+  }
+
+#endif /* !AH_OPTION_NO_WEAK_INTERPOLATION */
+
+
+  FT_LOCAL_DEF( void )
+  ah_hinter_align_points( AH_Hinter  hinter )
+  {
+    ah_hinter_align_edge_points( hinter );
+
+#ifndef AH_OPTION_NO_STRONG_INTERPOLATION
+    ah_hinter_align_strong_points( hinter );
+#endif
+
+#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
+    ah_hinter_align_weak_points( hinter );
+#endif
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****       H I N T E R   O B J E C T   M E T H O D S                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* scale and fit the global metrics */
+  static void
+  ah_hinter_scale_globals( AH_Hinter  hinter,
+                           FT_Fixed   x_scale,
+                           FT_Fixed   y_scale )
+  {
+    FT_Int           n;
+    AH_Face_Globals  globals = hinter->globals;
+    AH_Globals       design  = &globals->design;
+    AH_Globals       scaled  = &globals->scaled;
+
+
+    /* copy content */
+    *scaled = *design;
+
+    /* scale the standard widths & heights */
+    for ( n = 0; n < design->num_widths; n++ )
+      scaled->widths[n] = FT_MulFix( design->widths[n], x_scale );
+
+    for ( n = 0; n < design->num_heights; n++ )
+      scaled->heights[n] = FT_MulFix( design->heights[n], y_scale );
+
+    scaled->stds[0] = ( design->num_widths  > 0 ) ? scaled->widths[0]  : 32000;
+    scaled->stds[1] = ( design->num_heights > 0 ) ? scaled->heights[0] : 32000;
+
+    /* scale the blue zones */
+    for ( n = 0; n < AH_BLUE_MAX; n++ )
+    {
+      FT_Pos  delta, delta2;
+
+
+      delta = design->blue_shoots[n] - design->blue_refs[n];
+      delta2 = delta;
+      if ( delta < 0 )
+        delta2 = -delta2;
+      delta2 = FT_MulFix( delta2, y_scale );
+
+      if ( delta2 < 32 )
+        delta2 = 0;
+      else if ( delta2 < 64 )
+        delta2 = 32 + ( ( ( delta2 - 32 ) + 16 ) & ~31 );
+      else
+        delta2 = FT_PIX_ROUND( delta2 );
+
+      if ( delta < 0 )
+        delta2 = -delta2;
+
+      scaled->blue_refs[n] =
+        FT_PIX_ROUND( FT_MulFix( design->blue_refs[n], y_scale ) );
+
+      scaled->blue_shoots[n] = scaled->blue_refs[n] + delta2;
+    }
+
+    globals->x_scale = x_scale;
+    globals->y_scale = y_scale;
+  }
+
+
+  static void
+  ah_hinter_align( AH_Hinter  hinter )
+  {
+    ah_hinter_align_edge_points( hinter );
+    ah_hinter_align_points( hinter );
+  }
+
+
+  /* finalize a hinter object */
+  FT_LOCAL_DEF( void )
+  ah_hinter_done( AH_Hinter  hinter )
+  {
+    if ( hinter )
+    {
+      FT_Memory  memory = hinter->memory;
+
+
+      ah_loader_done( hinter->loader );
+      ah_outline_done( hinter->glyph );
+
+      /* note: the `globals' pointer is _not_ owned by the hinter */
+      /*       but by the current face object; we don't need to   */
+      /*       release it                                         */
+      hinter->globals = 0;
+      hinter->face    = 0;
+
+      FT_FREE( hinter );
+    }
+  }
+
+
+  /* create a new empty hinter object */
+  FT_LOCAL_DEF( FT_Error )
+  ah_hinter_new( FT_Library  library,
+                 AH_Hinter  *ahinter )
+  {
+    AH_Hinter  hinter = 0;
+    FT_Memory  memory = library->memory;
+    FT_Error   error;
+
+
+    *ahinter = 0;
+
+    /* allocate object */
+    if ( FT_NEW( hinter ) )
+      goto Exit;
+
+    hinter->memory = memory;
+    hinter->flags  = 0;
+
+    /* allocate outline and loader */
+    error = ah_outline_new( memory, &hinter->glyph )  ||
+            ah_loader_new ( memory, &hinter->loader ) ||
+            ah_loader_create_extra( hinter->loader );
+    if ( error )
+      goto Exit;
+
+    *ahinter = hinter;
+
+  Exit:
+    if ( error )
+      ah_hinter_done( hinter );
+
+    return error;
+  }
+
+
+  /* create a face's autohint globals */
+  FT_LOCAL_DEF( FT_Error )
+  ah_hinter_new_face_globals( AH_Hinter   hinter,
+                              FT_Face     face,
+                              AH_Globals  globals )
+  {
+    FT_Error         error;
+    FT_Memory        memory = hinter->memory;
+    AH_Face_Globals  face_globals;
+
+
+    if ( FT_NEW( face_globals ) )
+      goto Exit;
+
+    hinter->face    = face;
+    hinter->globals = face_globals;
+
+    if ( globals )
+      face_globals->design = *globals;
+    else
+      ah_hinter_compute_globals( hinter );
+
+    face->autohint.data      = face_globals;
+    face->autohint.finalizer = (FT_Generic_Finalizer)
+                                 ah_hinter_done_face_globals;
+    face_globals->face       = face;
+
+  Exit:
+    return error;
+  }
+
+
+  /* discard a face's autohint globals */
+  FT_LOCAL_DEF( void )
+  ah_hinter_done_face_globals( AH_Face_Globals  globals )
+  {
+    FT_Face    face   = globals->face;
+    FT_Memory  memory = face->memory;
+
+
+    FT_FREE( globals );
+  }
+
+
+  static FT_Error
+  ah_hinter_load( AH_Hinter  hinter,
+                  FT_UInt    glyph_index,
+                  FT_Int32   load_flags,
+                  FT_UInt    depth )
+  {
+    FT_Face           face     = hinter->face;
+    FT_GlyphSlot      slot     = face->glyph;
+    FT_Slot_Internal  internal = slot->internal;
+    FT_Fixed          x_scale  = hinter->globals->x_scale;
+    FT_Fixed          y_scale  = hinter->globals->y_scale;
+    FT_Error          error;
+    AH_Outline        outline  = hinter->glyph;
+    AH_Loader         gloader  = hinter->loader;
+
+
+    /* load the glyph */
+    error = FT_Load_Glyph( face, glyph_index, load_flags );
+    if ( error )
+      goto Exit;
+
+    /* Set `hinter->transformed' after loading with FT_LOAD_NO_RECURSE. */
+    hinter->transformed = internal->glyph_transformed;
+
+    if ( hinter->transformed )
+    {
+      FT_Matrix  imatrix;
+
+
+      imatrix              = internal->glyph_matrix;
+      hinter->trans_delta  = internal->glyph_delta;
+      hinter->trans_matrix = imatrix;
+
+      FT_Matrix_Invert( &imatrix );
+      FT_Vector_Transform( &hinter->trans_delta, &imatrix );
+    }
+
+    /* set linear horizontal metrics */
+    slot->linearHoriAdvance = slot->metrics.horiAdvance;
+    slot->linearVertAdvance = slot->metrics.vertAdvance;
+
+    switch ( slot->format )
+    {
+    case FT_GLYPH_FORMAT_OUTLINE:
+
+      /* translate glyph outline if we need to */
+      if ( hinter->transformed )
+      {
+        FT_UInt     n     = slot->outline.n_points;
+        FT_Vector*  point = slot->outline.points;
+
+
+        for ( ; n > 0; point++, n-- )
+        {
+          point->x += hinter->trans_delta.x;
+          point->y += hinter->trans_delta.y;
+        }
+      }
+
+      /* copy the outline points in the loader's current               */
+      /* extra points which is used to keep original glyph coordinates */
+      error = ah_loader_check_points( gloader, slot->outline.n_points + 4,
+                                      slot->outline.n_contours );
+      if ( error )
+        goto Exit;
+
+      FT_ARRAY_COPY( gloader->current.extra_points, slot->outline.points,
+                     slot->outline.n_points );
+
+      FT_ARRAY_COPY( gloader->current.outline.contours, slot->outline.contours,
+                     slot->outline.n_contours );
+
+      FT_ARRAY_COPY( gloader->current.outline.tags, slot->outline.tags,
+                     slot->outline.n_points );
+
+      gloader->current.outline.n_points   = slot->outline.n_points;
+      gloader->current.outline.n_contours = slot->outline.n_contours;
+
+      /* compute original horizontal phantom points, ignoring vertical ones */
+      hinter->pp1.x = 0;
+      hinter->pp1.y = 0;
+      hinter->pp2.x = FT_MulFix( slot->metrics.horiAdvance, x_scale );
+      hinter->pp2.y = 0;
+
+      /* be sure to check for spacing glyphs */
+      if ( slot->outline.n_points == 0 )
+        goto Hint_Metrics;
+
+      /* now load the slot image into the auto-outline and run the */
+      /* automatic hinting process                                 */
+      error = ah_outline_load( outline, x_scale, y_scale, face );
+      if ( error )
+        goto Exit;
+
+      /* perform feature detection */
+      ah_outline_detect_features( outline );
+
+      if ( hinter->do_vert_hints )
+      {
+        ah_outline_compute_blue_edges( outline, hinter->globals );
+        ah_outline_scale_blue_edges( outline, hinter->globals );
+      }
+
+      /* perform alignment control */
+      ah_hinter_hint_edges( hinter );
+      ah_hinter_align( hinter );
+
+      /* now save the current outline into the loader's current table */
+      ah_outline_save( outline, gloader );
+
+      /* we now need to hint the metrics according to the change in */
+      /* width/positioning that occured during the hinting process  */
+      if ( outline->num_vedges > 0 )
+      {
+        FT_Pos   old_advance, old_rsb, old_lsb, new_lsb, pp1x_uh, pp2x_uh;
+        AH_Edge  edge1 = outline->vert_edges;     /* leftmost edge  */
+        AH_Edge  edge2 = edge1 +
+                         outline->num_vedges - 1; /* rightmost edge */
+
+
+        old_advance = hinter->pp2.x;
+        old_rsb     = old_advance - edge2->opos;
+        old_lsb     = edge1->opos;
+        new_lsb     = edge1->pos;
+
+        /* remember unhinted values to later account for rounding errors */
+
+        pp1x_uh = new_lsb    - old_lsb;
+        pp2x_uh = edge2->pos + old_rsb;
+
+        /* prefer too much space over too little space for very small sizes */
+
+        if ( old_lsb < 24 )
+          pp1x_uh -= 5;
+
+        if ( old_rsb < 24 )
+          pp2x_uh += 5;
+
+        hinter->pp1.x = FT_PIX_ROUND( pp1x_uh );
+        hinter->pp2.x = FT_PIX_ROUND( pp2x_uh );
+
+        slot->lsb_delta = hinter->pp1.x - pp1x_uh;
+        slot->rsb_delta = hinter->pp2.x - pp2x_uh;
+
+#if 0
+        /* try to fix certain bad advance computations */
+        if ( hinter->pp2.x + hinter->pp1.x == edge2->pos && old_rsb > 4 )
+          hinter->pp2.x += 64;
+#endif
+      }
+
+      else
+      {
+        hinter->pp1.x = ( hinter->pp1.x + 32 ) & -64;
+        hinter->pp2.x = ( hinter->pp2.x + 32 ) & -64;
+      }
+
+      /* good, we simply add the glyph to our loader's base */
+      ah_loader_add( gloader );
+      break;
+
+    case FT_GLYPH_FORMAT_COMPOSITE:
+      {
+        FT_UInt      nn, num_subglyphs = slot->num_subglyphs;
+        FT_UInt      num_base_subgs, start_point;
+        FT_SubGlyph  subglyph;
+
+
+        start_point = gloader->base.outline.n_points;
+
+        /* first of all, copy the subglyph descriptors in the glyph loader */
+        error = ah_loader_check_subglyphs( gloader, num_subglyphs );
+        if ( error )
+          goto Exit;
+
+        FT_ARRAY_COPY( gloader->current.subglyphs, slot->subglyphs,
+                       num_subglyphs );
+
+        gloader->current.num_subglyphs = num_subglyphs;
+        num_base_subgs = gloader->base.num_subglyphs;
+
+        /* now, read each subglyph independently */
+        for ( nn = 0; nn < num_subglyphs; nn++ )
+        {
+          FT_Vector  pp1, pp2;
+          FT_Pos     x, y;
+          FT_UInt    num_points, num_new_points, num_base_points;
+
+
+          /* gloader.current.subglyphs can change during glyph loading due */
+          /* to re-allocation -- we must recompute the current subglyph on */
+          /* each iteration                                                */
+          subglyph = gloader->base.subglyphs + num_base_subgs + nn;
+
+          pp1 = hinter->pp1;
+          pp2 = hinter->pp2;
+
+          num_base_points = gloader->base.outline.n_points;
+
+          error = ah_hinter_load( hinter, subglyph->index,
+                                  load_flags, depth + 1 );
+          if ( error )
+            goto Exit;
+
+          /* recompute subglyph pointer */
+          subglyph = gloader->base.subglyphs + num_base_subgs + nn;
+
+          if ( subglyph->flags & FT_SUBGLYPH_FLAG_USE_MY_METRICS )
+          {
+            pp1 = hinter->pp1;
+            pp2 = hinter->pp2;
+          }
+          else
+          {
+            hinter->pp1 = pp1;
+            hinter->pp2 = pp2;
+          }
+
+          num_points     = gloader->base.outline.n_points;
+          num_new_points = num_points - num_base_points;
+
+          /* now perform the transform required for this subglyph */
+
+          if ( subglyph->flags & ( FT_SUBGLYPH_FLAG_SCALE    |
+                                   FT_SUBGLYPH_FLAG_XY_SCALE |
+                                   FT_SUBGLYPH_FLAG_2X2      ) )
+          {
+            FT_Vector*  cur   = gloader->base.outline.points +
+                                num_base_points;
+            FT_Vector*  org   = gloader->base.extra_points +
+                                num_base_points;
+            FT_Vector*  limit = cur + num_new_points;
+
+
+            for ( ; cur < limit; cur++, org++ )
+            {
+              FT_Vector_Transform( cur, &subglyph->transform );
+              FT_Vector_Transform( org, &subglyph->transform );
+            }
+          }
+
+          /* apply offset */
+
+          if ( !( subglyph->flags & FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES ) )
+          {
+            FT_Int      k = subglyph->arg1;
+            FT_UInt     l = subglyph->arg2;
+            FT_Vector*  p1;
+            FT_Vector*  p2;
+
+
+            if ( start_point + k >= num_base_points         ||
+                               l >= (FT_UInt)num_new_points )
+            {
+              error = AH_Err_Invalid_Composite;
+              goto Exit;
+            }
+
+            l += num_base_points;
+
+            /* for now, only use the current point coordinates;    */
+            /* we may consider another approach in the near future */
+            p1 = gloader->base.outline.points + start_point + k;
+            p2 = gloader->base.outline.points + start_point + l;
+
+            x = p1->x - p2->x;
+            y = p1->y - p2->y;
+          }
+          else
+          {
+            x = FT_MulFix( subglyph->arg1, x_scale );
+            y = FT_MulFix( subglyph->arg2, y_scale );
+
+            x = FT_PIX_ROUND(x);
+            y = FT_PIX_ROUND(y);
+          }
+
+          {
+            FT_Outline  dummy = gloader->base.outline;
+
+
+            dummy.points  += num_base_points;
+            dummy.n_points = (short)num_new_points;
+
+            FT_Outline_Translate( &dummy, x, y );
+          }
+        }
+      }
+      break;
+
+    default:
+      /* we don't support other formats (yet?) */
+      error = AH_Err_Unimplemented_Feature;
+    }
+
+  Hint_Metrics:
+    if ( depth == 0 )
+    {
+      FT_BBox  bbox;
+
+
+      /* transform the hinted outline if needed */
+      if ( hinter->transformed )
+        FT_Outline_Transform( &gloader->base.outline, &hinter->trans_matrix );
+
+      /* we must translate our final outline by -pp1.x and compute */
+      /* the new metrics                                           */
+      if ( hinter->pp1.x )
+        FT_Outline_Translate( &gloader->base.outline, -hinter->pp1.x, 0 );
+
+      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );
+      bbox.xMin  = FT_PIX_FLOOR(  bbox.xMin );
+      bbox.yMin  = FT_PIX_FLOOR(  bbox.yMin );
+      bbox.xMax  = FT_PIX_CEIL( bbox.xMax );
+      bbox.yMax  = FT_PIX_CEIL( bbox.yMax );
+
+      slot->metrics.width        = bbox.xMax - bbox.xMin;
+      slot->metrics.height       = bbox.yMax - bbox.yMin;
+      slot->metrics.horiBearingX = bbox.xMin;
+      slot->metrics.horiBearingY = bbox.yMax;
+
+      /* for mono-width fonts (like Andale, Courier, etc.) we need */
+      /* to keep the original rounded advance width                */
+      if ( !FT_IS_FIXED_WIDTH( slot->face ) )
+        slot->metrics.horiAdvance = hinter->pp2.x - hinter->pp1.x;
+      else
+        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
+                                               x_scale );
+
+      slot->metrics.horiAdvance = FT_PIX_ROUND( slot->metrics.horiAdvance );
+
+      /* now copy outline into glyph slot */
+      ah_loader_rewind( slot->internal->loader );
+      error = ah_loader_copy_points( slot->internal->loader, gloader );
+      if ( error )
+        goto Exit;
+
+      slot->outline = slot->internal->loader->base.outline;
+      slot->format  = FT_GLYPH_FORMAT_OUTLINE;
+    }
+
+#ifdef DEBUG_HINTER
+    ah_debug_hinter = hinter;
+#endif
+
+  Exit:
+    return error;
+  }
+
+
+  /* load and hint a given glyph */
+  FT_LOCAL_DEF( FT_Error )
+  ah_hinter_load_glyph( AH_Hinter     hinter,
+                        FT_GlyphSlot  slot,
+                        FT_Size       size,
+                        FT_UInt       glyph_index,
+                        FT_Int32      load_flags )
+  {
+    FT_Face          face         = slot->face;
+    FT_Error         error;
+    FT_Fixed         x_scale      = size->metrics.x_scale;
+    FT_Fixed         y_scale      = size->metrics.y_scale;
+    AH_Face_Globals  face_globals = FACE_GLOBALS( face );
+    FT_Render_Mode   hint_mode    = FT_LOAD_TARGET_MODE( load_flags );
+
+
+    /* first of all, we need to check that we're using the correct face and */
+    /* global hints to load the glyph                                       */
+    if ( hinter->face != face || hinter->globals != face_globals )
+    {
+      hinter->face = face;
+      if ( !face_globals )
+      {
+        error = ah_hinter_new_face_globals( hinter, face, 0 );
+        if ( error )
+          goto Exit;
+
+      }
+      hinter->globals = FACE_GLOBALS( face );
+      face_globals    = FACE_GLOBALS( face );
+
+    }
+
+#ifdef FT_CONFIG_CHESTER_BLUE_SCALE
+
+   /* try to optimize the y_scale so that the top of non-capital letters
+    * is aligned on a pixel boundary whenever possible
+    */
+    {
+      AH_Globals  design = &face_globals->design;
+      FT_Pos      shoot  = design->blue_shoots[AH_BLUE_SMALL_TOP];
+
+
+      /* the value of 'shoot' will be -1000 if the font doesn't have */
+      /* small latin letters; we simply check the sign here...       */
+      if ( shoot > 0 )
+      {
+        FT_Pos  scaled = FT_MulFix( shoot, y_scale );
+        FT_Pos  fitted = FT_PIX_ROUND( scaled );
+
+
+        if ( scaled != fitted )
+        {
+         /* adjust y_scale
+          */
+          y_scale = FT_MulDiv( y_scale, fitted, scaled );
+
+         /* adust x_scale
+          */
+          if ( fitted < scaled )
+            x_scale -= x_scale / 50;  /* x_scale*0.98 with integers */
+        }
+      }
+    }
+
+#endif /* FT_CONFIG_CHESTER_BLUE_SCALE */
+
+    /* now, we must check the current character pixel size to see if we */
+    /* need to rescale the global metrics                               */
+    if ( face_globals->x_scale != x_scale ||
+         face_globals->y_scale != y_scale )
+      ah_hinter_scale_globals( hinter, x_scale, y_scale );
+
+    ah_loader_rewind( hinter->loader );
+
+    /* reset hinting flags according to load flags and current render target */
+    hinter->do_horz_hints = FT_BOOL( !(load_flags & FT_LOAD_NO_AUTOHINT) );
+    hinter->do_vert_hints = FT_BOOL( !(load_flags & FT_LOAD_NO_AUTOHINT) );
+
+#ifdef DEBUG_HINTER
+    hinter->do_horz_hints = !ah_debug_disable_vert;  /* not a bug, the meaning */
+    hinter->do_vert_hints = !ah_debug_disable_horz;  /* of h/v is inverted!    */
+#endif
+
+    /* we snap the width of vertical stems for the monochrome and         */
+    /* horizontal LCD rendering targets only.  Corresponds to X snapping. */
+    hinter->do_horz_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO ||
+                                        hint_mode == FT_RENDER_MODE_LCD  );
+
+    /* we snap the width of horizontal stems for the monochrome and     */
+    /* vertical LCD rendering targets only.  Corresponds to Y snapping. */
+    hinter->do_vert_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO   ||
+                                        hint_mode == FT_RENDER_MODE_LCD_V  );
+
+    hinter->do_stem_adjust   = FT_BOOL( hint_mode != FT_RENDER_MODE_LIGHT );
+
+    load_flags |= FT_LOAD_NO_SCALE
+                | FT_LOAD_IGNORE_TRANSFORM;
+    load_flags &= ~FT_LOAD_RENDER;
+
+    error = ah_hinter_load( hinter, glyph_index, load_flags, 0 );
+
+  Exit:
+    return error;
+  }
+
+
+  /* retrieve a face's autohint globals for client applications */
+  FT_LOCAL_DEF( void )
+  ah_hinter_get_global_hints( AH_Hinter  hinter,
+                              FT_Face    face,
+                              void**     global_hints,
+                              long*      global_len )
+  {
+    AH_Globals  globals = 0;
+    FT_Memory   memory  = hinter->memory;
+    FT_Error    error;
+
+
+    /* allocate new master globals */
+    if ( FT_NEW( globals ) )
+      goto Fail;
+
+    /* compute face globals if needed */
+    if ( !FACE_GLOBALS( face ) )
+    {
+      error = ah_hinter_new_face_globals( hinter, face, 0 );
+      if ( error )
+        goto Fail;
+    }
+
+    *globals      = FACE_GLOBALS( face )->design;
+    *global_hints = globals;
+    *global_len   = sizeof( *globals );
+
+    return;
+
+  Fail:
+    FT_FREE( globals );
+
+    *global_hints = 0;
+    *global_len   = 0;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ah_hinter_done_global_hints( AH_Hinter  hinter,
+                               void*      global_hints )
+  {
+    FT_Memory  memory = hinter->memory;
+
+
+    FT_FREE( global_hints );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahhint.h b/nx-X11/extras/freetype2/src/autohint/ahhint.h
new file mode 100644
index 000000000..2c352d0c9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahhint.h
@@ -0,0 +1,75 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahhint.h                                                               */
+/*                                                                         */
+/*    Glyph hinter (declaration).                                          */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __AHHINT_H__
+#define __AHHINT_H__
+
+
+#include <ft2build.h>
+#include "ahglobal.h"
+
+
+FT_BEGIN_HEADER
+
+
+#define AH_HINT_DEFAULT        0
+#define AH_HINT_NO_ALIGNMENT   1
+#define AH_HINT_NO_HORZ_EDGES  0x200000L  /* temporary hack */
+#define AH_HINT_NO_VERT_EDGES  0x400000L  /* temporary hack */
+
+
+  /* create a new empty hinter object */
+  FT_LOCAL( FT_Error )
+  ah_hinter_new( FT_Library  library,
+                 AH_Hinter*  ahinter );
+
+  /* Load a hinted glyph in the hinter */
+  FT_LOCAL( FT_Error )
+  ah_hinter_load_glyph( AH_Hinter     hinter,
+                        FT_GlyphSlot  slot,
+                        FT_Size       size,
+                        FT_UInt       glyph_index,
+                        FT_Int32      load_flags );
+
+  /* finalize a hinter object */
+  FT_LOCAL( void )
+  ah_hinter_done( AH_Hinter  hinter );
+
+  FT_LOCAL( void )
+  ah_hinter_done_face_globals( AH_Face_Globals  globals );
+
+  FT_LOCAL( void )
+  ah_hinter_get_global_hints( AH_Hinter  hinter,
+                              FT_Face    face,
+                              void**     global_hints,
+                              long*      global_len );
+
+  FT_LOCAL( void )
+  ah_hinter_done_global_hints( AH_Hinter  hinter,
+                               void*      global_hints );
+
+
+FT_END_HEADER
+
+#endif /* __AHHINT_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahloader.h b/nx-X11/extras/freetype2/src/autohint/ahloader.h
new file mode 100644
index 000000000..c8e42ef22
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahloader.h
@@ -0,0 +1,61 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahloader.h                                                             */
+/*                                                                         */
+/*    Glyph loader for the auto-hinting module (declaration only).         */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This defines the AH_GlyphLoader type; it is simply a typedef to       */
+  /* FT_GlyphLoader.                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __AHLOADER_H__
+#define __AHLOADER_H__
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+#include FT_INTERNAL_GLYPH_LOADER_H
+
+  #define AH_Load    FT_GlyphLoad
+  #define AH_Loader  FT_GlyphLoader
+
+  #define ah_loader_new              FT_GlyphLoader_New
+  #define ah_loader_done             FT_GlyphLoader_Done
+  #define ah_loader_reset            FT_GlyphLoader_Reset
+  #define ah_loader_rewind           FT_GlyphLoader_Rewind
+  #define ah_loader_create_extra     FT_GlyphLoader_CreateExtra
+  #define ah_loader_check_points     FT_GlyphLoader_CheckPoints
+  #define ah_loader_check_subglyphs  FT_GlyphLoader_CheckSubGlyphs
+  #define ah_loader_prepare          FT_GlyphLoader_Prepare
+  #define ah_loader_add              FT_GlyphLoader_Add
+  #define ah_loader_copy_points      FT_GlyphLoader_CopyPoints
+
+
+FT_END_HEADER
+
+#endif /* __AHLOADER_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahmodule.c b/nx-X11/extras/freetype2/src/autohint/ahmodule.c
new file mode 100644
index 000000000..03d067b87
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahmodule.c
@@ -0,0 +1,143 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahmodule.c                                                             */
+/*                                                                         */
+/*    Auto-hinting module implementation (declaration).                    */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 Catharon Productions Inc.        */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+#include "ahhint.h"
+
+
+#ifdef  DEBUG_HINTER
+   AH_Hinter  ah_debug_hinter       = NULL;
+   FT_Bool    ah_debug_disable_horz = 0;
+   FT_Bool    ah_debug_disable_vert = 0;
+#endif
+
+  typedef struct  FT_AutoHinterRec_
+  {
+    FT_ModuleRec  root;
+    AH_Hinter     hinter;
+
+  } FT_AutoHinterRec;
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ft_autohinter_init( FT_Module  module )       /* FT_AutoHinter */
+  {
+    FT_AutoHinter  autohinter = (FT_AutoHinter)module;
+    FT_Error       error;
+
+
+    error = ah_hinter_new( module->library, &autohinter->hinter );
+
+#ifdef DEBUG_HINTER
+    if ( !error )
+      ah_debug_hinter = autohinter->hinter;
+#endif
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_autohinter_done( FT_Module  module )
+  {
+    FT_AutoHinter  autohinter = (FT_AutoHinter)module;
+
+
+    ah_hinter_done( autohinter->hinter );
+
+#ifdef DEBUG_HINTER
+    ah_debug_hinter = NULL;
+#endif
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ft_autohinter_load_glyph( FT_AutoHinter  module,
+                            FT_GlyphSlot   slot,
+                            FT_Size        size,
+                            FT_UInt        glyph_index,
+                            FT_Int32       load_flags )
+  {
+    return ah_hinter_load_glyph( module->hinter,
+                                 slot, size, glyph_index, load_flags );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_autohinter_reset_globals( FT_AutoHinter  module,
+                               FT_Face        face )
+  {
+    FT_UNUSED( module );
+
+    if ( face->autohint.data )
+      ah_hinter_done_face_globals( (AH_Face_Globals)(face->autohint.data) );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_autohinter_get_globals( FT_AutoHinter  module,
+                             FT_Face        face,
+                             void**         global_hints,
+                             long*          global_len )
+  {
+    ah_hinter_get_global_hints( module->hinter, face,
+                                global_hints, global_len );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_autohinter_done_globals( FT_AutoHinter  module,
+                              void*          global_hints )
+  {
+    ah_hinter_done_global_hints( module->hinter, global_hints );
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_AutoHinter_ServiceRec  ft_autohinter_service =
+  {
+    ft_autohinter_reset_globals,
+    ft_autohinter_get_globals,
+    ft_autohinter_done_globals,
+    ft_autohinter_load_glyph
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Module_Class  autohint_module_class =
+  {
+    FT_MODULE_HINTER,
+    sizeof ( FT_AutoHinterRec ),
+
+    "autohinter",
+    0x10000L,   /* version 1.0 of the autohinter  */
+    0x20000L,   /* requires FreeType 2.0 or above */
+
+    (const void*) &ft_autohinter_service,
+
+    ft_autohinter_init,
+    ft_autohinter_done,
+    0                       /* FT_Module_Requester */
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahmodule.h b/nx-X11/extras/freetype2/src/autohint/ahmodule.h
new file mode 100644
index 000000000..43b1dbe98
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahmodule.h
@@ -0,0 +1,42 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahmodule.h                                                             */
+/*                                                                         */
+/*    Auto-hinting module (declaration).                                   */
+/*                                                                         */
+/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __AHMODULE_H__
+#define __AHMODULE_H__
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_CALLBACK_TABLE
+  const FT_Module_Class  autohint_module_class;
+
+
+FT_END_HEADER
+
+#endif /* __AHMODULE_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/ahtypes.h b/nx-X11/extras/freetype2/src/autohint/ahtypes.h
new file mode 100644
index 000000000..f2cedd288
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/ahtypes.h
@@ -0,0 +1,527 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ahtypes.h                                                              */
+/*                                                                         */
+/*    General types and definitions for the auto-hint module               */
+/*    (specification only).                                                */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 Catharon Productions Inc.        */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __AHTYPES_H__
+#define __AHTYPES_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+
+#ifdef DEBUG_HINTER
+#include <../src/autohint/ahloader.h>
+#else
+#include "ahloader.h"
+#endif
+
+
+#define xxAH_DEBUG
+
+
+#ifdef AH_DEBUG
+
+#include <stdio.h>
+#define AH_LOG( x )  printf ## x
+
+#else
+
+#define AH_LOG( x )  do ; while ( 0 ) /* nothing */
+
+#endif /* AH_DEBUG */
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /**** COMPILE-TIME BUILD OPTIONS                                      ****/
+  /****                                                                 ****/
+  /**** Toggle these configuration macros to experiment with `features' ****/
+  /**** of the auto-hinter.                                             ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* If this option is defined, only strong interpolation will be used to  */
+  /* place the points between edges.  Otherwise, `smooth' points are       */
+  /* detected and later hinted through weak interpolation to correct some  */
+  /* unpleasant artefacts.                                                 */
+  /*                                                                       */
+#undef AH_OPTION_NO_WEAK_INTERPOLATION
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Undefine this macro if you don't want to hint the metrics.  There is  */
+  /* no reason to do this (at least for non-CJK scripts), except for       */
+  /* experimentation.                                                      */
+  /*                                                                       */
+#undef  AH_HINT_METRICS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define this macro if you do not want to insert extra edges at a       */
+  /* glyph's x and y extremum (if there isn't one already available).      */
+  /* This helps to reduce a number of artefacts and allows hinting of      */
+  /* metrics.                                                              */
+  /*                                                                       */
+#undef AH_OPTION_NO_EXTREMUM_EDGES
+
+
+  /* don't touch for now */
+#define AH_MAX_WIDTHS   12
+#define AH_MAX_HEIGHTS  12
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****   TYPE DEFINITIONS                                              ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* see ahangles.h */
+  typedef FT_Int  AH_Angle;
+
+
+  /* hint flags */
+#define AH_FLAG_NONE       0
+
+  /* bezier control points flags */
+#define AH_FLAG_CONIC                 1
+#define AH_FLAG_CUBIC                 2
+#define AH_FLAG_CONTROL               ( AH_FLAG_CONIC | AH_FLAG_CUBIC )
+
+  /* extrema flags */
+#define AH_FLAG_EXTREMA_X             4
+#define AH_FLAG_EXTREMA_Y             8
+
+  /* roundness */
+#define AH_FLAG_ROUND_X              16
+#define AH_FLAG_ROUND_Y              32
+
+  /* touched */
+#define AH_FLAG_TOUCH_X              64
+#define AH_FLAG_TOUCH_Y             128
+
+  /* weak interpolation */
+#define AH_FLAG_WEAK_INTERPOLATION  256
+#define AH_FLAG_INFLECTION          512
+
+  typedef FT_Int AH_Flags;
+
+
+  /* edge hint flags */
+#define AH_EDGE_NORMAL  0
+#define AH_EDGE_ROUND   1
+#define AH_EDGE_SERIF   2
+#define AH_EDGE_DONE    4
+
+  typedef FT_Int  AH_Edge_Flags;
+
+
+  /* hint directions -- the values are computed so that two vectors are */
+  /* in opposite directions iff `dir1+dir2 == 0'                        */
+#define AH_DIR_NONE    4
+#define AH_DIR_RIGHT   1
+#define AH_DIR_LEFT   -1
+#define AH_DIR_UP      2
+#define AH_DIR_DOWN   -2
+
+  typedef FT_Int  AH_Direction;
+
+
+  typedef struct AH_PointRec_*    AH_Point;
+  typedef struct AH_SegmentRec_*  AH_Segment;
+  typedef struct AH_EdgeRec_*     AH_Edge;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    AH_PointRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model an outline point to the AH_OutlineRec    */
+  /*    type.                                                              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    flags     :: The current point hint flags.                         */
+  /*                                                                       */
+  /*    ox, oy    :: The current original scaled coordinates.              */
+  /*                                                                       */
+  /*    fx, fy    :: The current coordinates in font units.                */
+  /*                                                                       */
+  /*    x,  y     :: The current hinted coordinates.                       */
+  /*                                                                       */
+  /*    u, v      :: Point coordinates -- meaning varies with context.     */
+  /*                                                                       */
+  /*    in_dir    :: The direction of the inwards vector (prev->point).    */
+  /*                                                                       */
+  /*    out_dir   :: The direction of the outwards vector (point->next).   */
+  /*                                                                       */
+  /*    next      :: The next point in same contour.                       */
+  /*                                                                       */
+  /*    prev      :: The previous point in same contour.                   */
+  /*                                                                       */
+  typedef struct  AH_PointRec_
+  {
+    AH_Flags      flags;    /* point flags used by hinter */
+    FT_Pos        ox, oy;
+    FT_Pos        fx, fy;
+    FT_Pos        x,  y;
+    FT_Pos        u,  v;
+
+    AH_Direction  in_dir;   /* direction of inwards vector  */
+    AH_Direction  out_dir;  /* direction of outwards vector */
+
+    AH_Point      next;     /* next point in contour     */
+    AH_Point      prev;     /* previous point in contour */
+
+  } AH_PointRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    AH_SegmentRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to describe an edge segment to the auto-hinter.   */
+  /*    A segment is simply a sequence of successive points located on the */
+  /*    same horizontal or vertical `position', in a given direction.      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    flags      :: The segment edge flags (straight, rounded, etc.).    */
+  /*                                                                       */
+  /*    dir        :: The segment direction.                               */
+  /*                                                                       */
+  /*    min_coord  :: The minimum coordinate of the segment.               */
+  /*                                                                       */
+  /*    max_coord  :: The maximum coordinate of the segment.               */
+  /*                                                                       */
+  /*    edge       :: The edge of the current segment.                     */
+  /*                                                                       */
+  /*    edge_next  :: The next segment on the same edge.                   */
+  /*                                                                       */
+  /*    link       :: The pairing segment for this edge.                   */
+  /*                                                                       */
+  /*    serif      :: The primary segment for serifs.                      */
+  /*                                                                       */
+  /*    num_linked :: The number of other segments that link to this one.  */
+  /*                                                                       */
+  /*    score      :: Used to score the segment when selecting them.       */
+  /*                                                                       */
+  /*    first      :: The first point in the segment.                      */
+  /*                                                                       */
+  /*    last       :: The last point in the segment.                       */
+  /*                                                                       */
+  /*    contour    :: A pointer to the first point of the segment's        */
+  /*                  contour.                                             */
+  /*                                                                       */
+  typedef struct  AH_SegmentRec_
+  {
+    AH_Edge_Flags  flags;
+    AH_Direction   dir;
+    FT_Pos         pos;         /* position of segment           */
+    FT_Pos         min_coord;   /* minimum coordinate of segment */
+    FT_Pos         max_coord;   /* maximum coordinate of segment */
+
+    AH_Edge        edge;
+    AH_Segment     edge_next;
+
+    AH_Segment     link;        /* link segment               */
+    AH_Segment     serif;       /* primary segment for serifs */
+    FT_Pos         num_linked;  /* number of linked segments  */
+    FT_Pos         score;
+
+    AH_Point       first;       /* first point in edge segment             */
+    AH_Point       last;        /* last point in edge segment              */
+    AH_Point*      contour;     /* ptr to first point of segment's contour */
+
+  } AH_SegmentRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    AH_EdgeRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to describe an edge, which really is a horizontal */
+  /*    or vertical coordinate to be hinted depending on the segments      */
+  /*    located on it.                                                     */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    fpos       :: The original edge position in font units.            */
+  /*                                                                       */
+  /*    opos       :: The original scaled edge position.                   */
+  /*                                                                       */
+  /*    pos        :: The hinted edge position.                            */
+  /*                                                                       */
+  /*    flags      :: The segment edge flags (straight, rounded, etc.).    */
+  /*                                                                       */
+  /*    dir        :: The main segment direction on this edge.             */
+  /*                                                                       */
+  /*    scale      :: Scaling factor between original and hinted edge      */
+  /*                  positions.                                           */
+  /*                                                                       */
+  /*    blue_edge  :: Indicate the blue zone edge this edge is related to. */
+  /*                  Only set for some of the horizontal edges in a latin */
+  /*                  font.                                                */
+  /*                                                                       */
+  /*    link       :: The linked edge.                                     */
+  /*                                                                       */
+  /*    serif      :: The serif edge.                                      */
+  /*                                                                       */
+  /*    num_linked :: The number of other edges that pair to this one.     */
+  /*                                                                       */
+  /*    score      :: Used to score the edge when selecting them.          */
+  /*                                                                       */
+  /*    first      :: The first edge segment.                              */
+  /*                                                                       */
+  /*    last       :: The last edge segment.                               */
+  /*                                                                       */
+  typedef struct  AH_EdgeRec_
+  {
+    FT_Pos         fpos;
+    FT_Pos         opos;
+    FT_Pos         pos;
+
+    AH_Edge_Flags  flags;
+    AH_Direction   dir;
+    FT_Fixed       scale;
+    FT_Pos*        blue_edge;
+
+    AH_Edge        link;
+    AH_Edge        serif;
+    FT_Int         num_linked;
+
+    FT_Int         score;
+
+    AH_Segment     first;
+    AH_Segment     last;
+
+
+  } AH_EdgeRec;
+
+
+  /* an outline as seen by the hinter */
+  typedef struct  AH_OutlineRec_
+  {
+    FT_Memory     memory;
+
+    AH_Direction  vert_major_dir;   /* vertical major direction   */
+    AH_Direction  horz_major_dir;   /* horizontal major direction */
+
+    FT_Fixed      x_scale;
+    FT_Fixed      y_scale;
+    FT_Pos        edge_distance_threshold;
+
+    FT_Int        max_points;
+    FT_Int        num_points;
+    AH_Point      points;
+
+    FT_Int        max_contours;
+    FT_Int        num_contours;
+    AH_Point*     contours;
+
+    FT_Int        num_hedges;
+    AH_Edge       horz_edges;
+
+    FT_Int        num_vedges;
+    AH_Edge       vert_edges;
+
+    FT_Int        num_hsegments;
+    AH_Segment    horz_segments;
+
+    FT_Int        num_vsegments;
+    AH_Segment    vert_segments;
+
+  } AH_OutlineRec, *AH_Outline;
+
+
+#ifdef FT_CONFIG_CHESTER_SMALL_F
+
+#define AH_BLUE_CAPITAL_TOP     0                              /* THEZOCQS */
+#define AH_BLUE_CAPITAL_BOTTOM  ( AH_BLUE_CAPITAL_TOP + 1 )    /* HEZLOCUS */
+#define AH_BLUE_SMALL_F_TOP     ( AH_BLUE_CAPITAL_BOTTOM + 1 ) /* fijkdbh  */
+#define AH_BLUE_SMALL_TOP       ( AH_BLUE_SMALL_F_TOP + 1 )    /* xzroesc  */
+#define AH_BLUE_SMALL_BOTTOM    ( AH_BLUE_SMALL_TOP + 1 )      /* xzroesc  */
+#define AH_BLUE_SMALL_MINOR     ( AH_BLUE_SMALL_BOTTOM + 1 )   /* pqgjy    */
+#define AH_BLUE_MAX             ( AH_BLUE_SMALL_MINOR + 1 )
+
+#else /* !FT_CONFIG_CHESTER_SMALL_F */
+
+#define AH_BLUE_CAPITAL_TOP     0                              /* THEZOCQS */
+#define AH_BLUE_CAPITAL_BOTTOM  ( AH_BLUE_CAPITAL_TOP + 1 )    /* HEZLOCUS */
+#define AH_BLUE_SMALL_TOP       ( AH_BLUE_CAPITAL_BOTTOM + 1 ) /* xzroesc  */
+#define AH_BLUE_SMALL_BOTTOM    ( AH_BLUE_SMALL_TOP + 1 )      /* xzroesc  */
+#define AH_BLUE_SMALL_MINOR     ( AH_BLUE_SMALL_BOTTOM + 1 )   /* pqgjy    */
+#define AH_BLUE_MAX             ( AH_BLUE_SMALL_MINOR + 1 )
+
+#endif /* !FT_CONFIG_CHESTER_SMALL_F */
+
+  typedef FT_Int  AH_Blue;
+
+
+#define AH_HINTER_MONOCHROME  1
+#define AH_HINTER_OPTIMIZE    2
+
+  typedef FT_Int  AH_Hinter_Flags;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    AH_GlobalsRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Holds the global metrics for a given font face (be it in design    */
+  /*    units or scaled pixel values).                                     */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_widths  :: The number of widths.                               */
+  /*                                                                       */
+  /*    num_heights :: The number of heights.                              */
+  /*                                                                       */
+  /*    stds        :: A two-element array giving the default stem width   */
+  /*                   and height.                                         */
+  /*                                                                       */
+  /*    widths      :: Snap widths, including standard one.                */
+  /*                                                                       */
+  /*    heights     :: Snap height, including standard one.                */
+  /*                                                                       */
+  /*    blue_refs   :: The reference positions of blue zones.              */
+  /*                                                                       */
+  /*    blue_shoots :: The overshoot positions of blue zones.              */
+  /*                                                                       */
+  typedef struct  AH_GlobalsRec_
+  {
+    FT_Int  num_widths;
+    FT_Int  num_heights;
+
+    FT_Pos  stds[2];
+
+    FT_Pos  widths [AH_MAX_WIDTHS];
+    FT_Pos  heights[AH_MAX_HEIGHTS];
+
+    FT_Pos  blue_refs  [AH_BLUE_MAX];
+    FT_Pos  blue_shoots[AH_BLUE_MAX];
+
+  } AH_GlobalsRec, *AH_Globals;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    AH_Face_GlobalsRec                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Holds the complete global metrics for a given font face (i.e., the */
+  /*    design units version + a scaled version + the current scales       */
+  /*    used).                                                             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    face    :: A handle to the source face object                      */
+  /*                                                                       */
+  /*    design  :: The globals in font design units.                       */
+  /*                                                                       */
+  /*    scaled  :: Scaled globals in sub-pixel values.                     */
+  /*                                                                       */
+  /*    x_scale :: The current horizontal scale.                           */
+  /*                                                                       */
+  /*    y_scale :: The current vertical scale.                             */
+  /*                                                                       */
+  /*    control_overshoot ::                                               */
+  /*               Currently unused.                                       */
+  /*                                                                       */
+  typedef struct  AH_Face_GlobalsRec_
+  {
+    FT_Face        face;
+    AH_GlobalsRec  design;
+    AH_GlobalsRec  scaled;
+    FT_Fixed       x_scale;
+    FT_Fixed       y_scale;
+    FT_Bool        control_overshoot;
+
+  } AH_Face_GlobalsRec, *AH_Face_Globals;
+
+
+  typedef struct  AH_HinterRec_
+  {
+    FT_Memory        memory;
+    AH_Hinter_Flags  flags;
+
+    FT_Int           algorithm;
+    FT_Face          face;
+
+    AH_Face_Globals  globals;
+
+    AH_Outline       glyph;
+
+    AH_Loader        loader;
+    FT_Vector        pp1;               /* horizontal phantom points */
+    FT_Vector        pp2;
+    /* we ignore vertical phantom points */
+
+    FT_Bool          transformed;
+    FT_Vector        trans_delta;
+    FT_Matrix        trans_matrix;
+
+    FT_Bool          do_horz_hints;     /* disable X hinting            */
+    FT_Bool          do_vert_hints;     /* disable Y hinting            */
+    FT_Bool          do_horz_snapping;  /* disable X stem size snapping */
+    FT_Bool          do_vert_snapping;  /* disable Y stem size snapping */
+    FT_Bool          do_stem_adjust;    /* disable light stem snapping  */
+
+  } AH_HinterRec, *AH_Hinter;
+
+
+#ifdef DEBUG_HINTER
+  extern AH_Hinter  ah_debug_hinter;
+  extern FT_Bool    ah_debug_disable_horz;
+  extern FT_Bool    ah_debug_disable_vert;
+#else
+#define ah_debug_disable_horz  0
+#define ah_debug_disable_vert  0
+#endif /* DEBUG_HINTER */
+
+
+FT_END_HEADER
+
+#endif /* __AHTYPES_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/autohint.c b/nx-X11/extras/freetype2/src/autohint/autohint.c
new file mode 100644
index 000000000..3783a82d9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/autohint.c
@@ -0,0 +1,32 @@
+/***************************************************************************/
+/*                                                                         */
+/*  autohint.c                                                             */
+/*                                                                         */
+/*    Automatic Hinting wrapper (body only).                               */
+/*                                                                         */
+/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Author: David Turner                                                   */
+/*                                                                         */
+/*  This file is part of the Catharon Typography Project and shall only    */
+/*  be used, modified, and distributed under the terms of the Catharon     */
+/*  Open Source License that should come with this file under the name     */
+/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*  Note that this license is compatible with the FreeType license.        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+
+#include <ft2build.h>
+#include "ahangles.c"
+#include "ahglyph.c"
+#include "ahglobal.c"
+#include "ahhint.c"
+#include "ahmodule.c"
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/autohint/mather.py b/nx-X11/extras/freetype2/src/autohint/mather.py
new file mode 100644
index 000000000..8ad8b5535
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/mather.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+#
+
+#
+# autohint math table builder
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+import math
+
+ag_pi = 256
+
+def print_arctan( atan_bits ):
+    atan_base = 1 << atan_bits
+
+    print "  static AH_Angle  ag_arctan[1L << AG_ATAN_BITS] ="
+    print "  {"
+
+    count = 0
+    line  = "   "
+
+    for n in range( atan_base ):
+        comma = ","
+        if ( n == atan_base - 1 ):
+            comma = ""
+
+        angle = math.atan( n * 1.0 / atan_base ) / math.pi * ag_pi
+        line  = line + " " + repr( int( angle + 0.5 ) ) + comma
+        count = count + 1;
+        if ( count == 8 ):
+            count = 0
+            print line
+            line = "   "
+
+    if ( count > 0 ):
+        print line
+    print "  };"
+
+
+# This routine is not used currently.
+#
+def print_sines():
+    print "  static FT_Fixed  ah_sines[AG_HALF_PI + 1] ="
+    print "  {"
+
+    count = 0
+    line  = "   "
+
+    for n in range( ag_pi / 2 ):
+        sinus = math.sin( n * math.pi / ag_pi )
+        line  = line + " " + repr( int( 65536.0 * sinus ) ) + ","
+        count = count + 1
+        if ( count == 8 ):
+            count = 0
+            print line
+            line = "   "
+
+    if ( count > 0 ):
+        print line
+    print "   65536"
+    print "  };"
+
+
+print_arctan( 8 )
+print
+
+
+# END
diff --git a/nx-X11/extras/freetype2/src/autohint/module.mk b/nx-X11/extras/freetype2/src/autohint/module.mk
new file mode 100644
index 000000000..edc9f4e1a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/module.mk
@@ -0,0 +1,25 @@
+#
+# FreeType 2 auto-hinter module definition
+#
+
+
+# Copyright 2000 Catharon Productions Inc.
+# Author: David Turner
+#
+# This file is part of the Catharon Typography Project and shall only
+# be used, modified, and distributed under the terms of the Catharon
+# Open Source License that should come with this file under the name
+# `CatharonLicense.txt'.  By continuing to use, modify, or distribute
+# this file you indicate that you have read the license and
+# understand and accept it fully.
+#
+# Note that this license is compatible with the FreeType license.
+
+
+make_module_list: add_autohint_module
+
+add_autohint_module:
+	$(OPEN_DRIVER)autohint_module_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)autohint  $(ECHO_DRIVER_DESC)automatic hinting module$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/autohint/rules.mk b/nx-X11/extras/freetype2/src/autohint/rules.mk
new file mode 100644
index 000000000..ee264e862
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/autohint/rules.mk
@@ -0,0 +1,77 @@
+#
+# FreeType 2 auto-hinter module configuration rules
+#
+
+
+# Copyright 2000, 2001, 2002, 2003 Catharon Productions Inc.
+# Author: David Turner
+#
+# This file is part of the Catharon Typography Project and shall only
+# be used, modified, and distributed under the terms of the Catharon
+# Open Source License that should come with this file under the name
+# `CatharonLicense.txt'.  By continuing to use, modify, or distribute
+# this file you indicate that you have read the license and
+# understand and accept it fully.
+#
+# Note that this license is compatible with the FreeType license.
+
+
+# AUTO driver directory
+#
+AUTO_DIR := $(SRC_DIR)/autohint
+
+
+# compilation flags for the driver
+#
+AUTO_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(AUTO_DIR))
+
+
+# AUTO driver sources (i.e., C files)
+#
+AUTO_DRV_SRC := $(AUTO_DIR)/ahangles.c \
+                $(AUTO_DIR)/ahglobal.c \
+                $(AUTO_DIR)/ahglyph.c  \
+                $(AUTO_DIR)/ahhint.c   \
+                $(AUTO_DIR)/ahmodule.c
+
+# AUTO driver headers
+#
+AUTO_DRV_H := $(AUTO_DRV_SRC:%c=%h)  \
+              $(AUTO_DIR)/ahloader.h \
+              $(AUTO_DIR)/ahtypes.h  \
+              $(AUTO_DIR)/aherrors.h
+
+
+# AUTO driver object(s)
+#
+#   AUTO_DRV_OBJ_M is used during `multi' builds.
+#   AUTO_DRV_OBJ_S is used during `single' builds.
+#
+AUTO_DRV_OBJ_M := $(AUTO_DRV_SRC:$(AUTO_DIR)/%.c=$(OBJ_DIR)/%.$O)
+AUTO_DRV_OBJ_S := $(OBJ_DIR)/autohint.$O
+
+# AUTO driver source file for single build
+#
+AUTO_DRV_SRC_S := $(AUTO_DIR)/autohint.c
+
+
+# AUTO driver - single object
+#
+$(AUTO_DRV_OBJ_S): $(AUTO_DRV_SRC_S) $(AUTO_DRV_SRC) \
+                   $(FREETYPE_H) $(AUTO_DRV_H)
+	$(AUTO_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(AUTO_DRV_SRC_S))
+
+
+# AUTO driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(AUTO_DIR)/%.c $(FREETYPE_H) $(AUTO_DRV_H)
+	$(AUTO_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(AUTO_DRV_OBJ_S)
+DRV_OBJS_M += $(AUTO_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/base/Jamfile b/nx-X11/extras/freetype2/src/base/Jamfile
new file mode 100644
index 000000000..d82e65d6d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/Jamfile
@@ -0,0 +1,36 @@
+# FreeType 2 src/base Jamfile (c) 2001, 2002, 2003, 2004 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) base ;
+
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = ftutil ftdbgmem ftstream ftcalc fttrigon ftgloadr ftoutln
+               ftobjs ftnames ftrfork ;
+  }
+  else
+  {
+    _sources = ftbase ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# Add the optional/replaceable files.
+#
+Library  $(FT2_LIB) : ftsystem.c   ftinit.c    ftglyph.c  ftmm.c     ftbdf.c
+                      ftbbox.c     ftdebug.c   ftxf86.c   fttype1.c  ftpfr.c
+                      ftstroke.c   ftwinfnt.c ;
+
+# Add Macintosh-specific file to the library when necessary.
+#
+if $(MAC)
+{
+  Library  $(FT2_LIB) : ftmac.c ;
+}
+
+# end of src/base Jamfile
diff --git a/nx-X11/extras/freetype2/src/base/descrip.mms b/nx-X11/extras/freetype2/src/base/descrip.mms
new file mode 100644
index 000000000..73bad4d73
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 base layer compilation rules for VMS
+#
+
+
+# Copyright 2001, 2003, 2004 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.builds.vms],[--.include],[--.src.base])
+
+OBJS=ftbase.obj,ftinit.obj,ftglyph.obj,ftdebug.obj,ftbdf.obj,ftmm.obj,fttype1.obj,ftxf86.obj,ftpfr.obj,ftstroke.obj,ftwinfnt.obj,ftbbox.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/base/ftapi.c b/nx-X11/extras/freetype2/src/base/ftapi.c
new file mode 100644
index 000000000..1ef3005e2
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftapi.c
@@ -0,0 +1,121 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftapi.c                                                                */
+/*                                                                         */
+/*    The FreeType compatibility functions (body).                         */
+/*                                                                         */
+/*  Copyright 2002 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_LIST_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_TRUETYPE_TABLES_H
+#include FT_OUTLINE_H
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                 C O M P A T I B I L I T Y                       ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* backwards compatibility API */
+
+  FT_BASE_DEF( void )
+  FT_New_Memory_Stream( FT_Library  library,
+                        FT_Byte*    base,
+                        FT_ULong    size,
+                        FT_Stream   stream )
+  {
+    FT_UNUSED( library );
+
+    FT_Stream_OpenMemory( stream, base, size );
+  }                        
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Seek_Stream( FT_Stream  stream,
+                  FT_ULong   pos )
+  {
+    return FT_Stream_Seek( stream, pos );
+  }                  
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Skip_Stream( FT_Stream  stream,
+                  FT_Long    distance )
+  {
+    return FT_Stream_Skip( stream, distance );
+  }                  
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Read_Stream( FT_Stream  stream,
+                  FT_Byte*   buffer,
+                  FT_ULong   count )
+  {
+    return FT_Stream_Read( stream, buffer, count );
+  }                  
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Read_Stream_At( FT_Stream  stream,
+                     FT_ULong   pos,
+                     FT_Byte*   buffer,
+                     FT_ULong   count )
+  {
+    return FT_Stream_ReadAt( stream, pos, buffer, count );
+  }                    
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Extract_Frame( FT_Stream  stream,
+                    FT_ULong   count,
+                    FT_Byte**  pbytes )
+  {
+    return FT_Stream_ExtractFrame( stream, count, pbytes );
+  }                    
+
+
+  FT_BASE_DEF( void )
+  FT_Release_Frame( FT_Stream  stream,
+                    FT_Byte**  pbytes )
+  {
+    FT_Stream_ReleaseFrame( stream, pbytes );
+  }                    
+
+  FT_BASE_DEF( FT_Error )
+  FT_Access_Frame( FT_Stream  stream,
+                   FT_ULong   count )
+  {
+    return FT_Stream_EnterFrame( stream, count );
+  }                   
+
+
+  FT_BASE_DEF( void )
+  FT_Forget_Frame( FT_Stream  stream )
+  {
+    FT_Stream_ExitFrame( stream );
+  }
+                   
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftbase.c b/nx-X11/extras/freetype2/src/base/ftbase.c
new file mode 100644
index 000000000..7d5a7fd8e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftbase.c
@@ -0,0 +1,38 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbase.c                                                               */
+/*                                                                         */
+/*    Single object library component (body only).                         */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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>
+
+#define  FT_MAKE_OPTION_SINGLE_OBJECT
+
+#include "ftutil.c"
+#include "ftdbgmem.c"
+#include "ftstream.c"
+#include "ftcalc.c"
+#include "fttrigon.c"
+#include "ftoutln.c"
+#include "ftgloadr.c"
+#include "ftobjs.c"
+#include "ftnames.c"
+#include "ftrfork.c"
+
+#if defined( __APPLE__ ) && !defined ( DARWIN_NO_CARBON )
+#include "ftmac.c"
+#endif
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftbbox.c b/nx-X11/extras/freetype2/src/base/ftbbox.c
new file mode 100644
index 000000000..888699573
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftbbox.c
@@ -0,0 +1,659 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbbox.c                                                               */
+/*                                                                         */
+/*    FreeType bbox computation (body).                                    */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2004 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 component has a _single_ role: to compute exact outline bounding */
+  /* boxes.                                                                */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_BBOX_H
+#include FT_IMAGE_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_CALC_H
+
+
+  typedef struct  TBBox_Rec_
+  {
+    FT_Vector  last;
+    FT_BBox    bbox;
+
+  } TBBox_Rec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    BBox_Move_To                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used as a `move_to' and `line_to' emitter during  */
+  /*    FT_Outline_Decompose().  It simply records the destination point   */
+  /*    in `user->last'; no further computations are necessary since we    */
+  /*    use the cbox as the starting bbox which must be refined.           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    to   :: A pointer to the destination vector.                       */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    user :: A pointer to the current walk context.                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Always 0.  Needed for the interface only.                          */
+  /*                                                                       */
+  static int
+  BBox_Move_To( FT_Vector*  to,
+                TBBox_Rec*  user )
+  {
+    user->last = *to;
+
+    return 0;
+  }
+
+
+#define CHECK_X( p, bbox )  \
+          ( p->x < bbox.xMin || p->x > bbox.xMax )
+
+#define CHECK_Y( p, bbox )  \
+          ( p->y < bbox.yMin || p->y > bbox.yMax )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    BBox_Conic_Check                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finds the extrema of a 1-dimensional conic Bezier curve and update */
+  /*    a bounding range.  This version uses direct computation, as it     */
+  /*    doesn't need square roots.                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    y1  :: The start coordinate.                                       */
+  /*                                                                       */
+  /*    y2  :: The coordinate of the control point.                        */
+  /*                                                                       */
+  /*    y3  :: The end coordinate.                                         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    min :: The address of the current minimum.                         */
+  /*                                                                       */
+  /*    max :: The address of the current maximum.                         */
+  /*                                                                       */
+  static void
+  BBox_Conic_Check( FT_Pos   y1,
+                    FT_Pos   y2,
+                    FT_Pos   y3,
+                    FT_Pos*  min,
+                    FT_Pos*  max )
+  {
+    if ( y1 <= y3 && y2 == y1 )     /* flat arc */
+      goto Suite;
+
+    if ( y1 < y3 )
+    {
+      if ( y2 >= y1 && y2 <= y3 )   /* ascending arc */
+        goto Suite;
+    }
+    else
+    {
+      if ( y2 >= y3 && y2 <= y1 )   /* descending arc */
+      {
+        y2 = y1;
+        y1 = y3;
+        y3 = y2;
+        goto Suite;
+      }
+    }
+
+    y1 = y3 = y1 - FT_MulDiv( y2 - y1, y2 - y1, y1 - 2*y2 + y3 );
+
+  Suite:
+    if ( y1 < *min ) *min = y1;
+    if ( y3 > *max ) *max = y3;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    BBox_Conic_To                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used as a `conic_to' emitter during               */
+  /*    FT_Raster_Decompose().  It checks a conic Bezier curve with the    */
+  /*    current bounding box, and computes its extrema if necessary to     */
+  /*    update it.                                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    control :: A pointer to a control point.                           */
+  /*                                                                       */
+  /*    to      :: A pointer to the destination vector.                    */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    user    :: The address of the current walk context.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Always 0.  Needed for the interface only.                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    In the case of a non-monotonous arc, we compute directly the       */
+  /*    extremum coordinates, as it is sufficiently fast.                  */
+  /*                                                                       */
+  static int
+  BBox_Conic_To( FT_Vector*  control,
+                 FT_Vector*  to,
+                 TBBox_Rec*  user )
+  {
+    /* we don't need to check `to' since it is always an `on' point, thus */
+    /* within the bbox                                                    */
+
+    if ( CHECK_X( control, user->bbox ) )
+      BBox_Conic_Check( user->last.x,
+                        control->x,
+                        to->x,
+                        &user->bbox.xMin,
+                        &user->bbox.xMax );
+
+    if ( CHECK_Y( control, user->bbox ) )
+      BBox_Conic_Check( user->last.y,
+                        control->y,
+                        to->y,
+                        &user->bbox.yMin,
+                        &user->bbox.yMax );
+
+    user->last = *to;
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    BBox_Cubic_Check                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finds the extrema of a 1-dimensional cubic Bezier curve and        */
+  /*    updates a bounding range.  This version uses splitting because we  */
+  /*    don't want to use square roots and extra accuracy.                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    p1  :: The start coordinate.                                       */
+  /*                                                                       */
+  /*    p2  :: The coordinate of the first control point.                  */
+  /*                                                                       */
+  /*    p3  :: The coordinate of the second control point.                 */
+  /*                                                                       */
+  /*    p4  :: The end coordinate.                                         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    min :: The address of the current minimum.                         */
+  /*                                                                       */
+  /*    max :: The address of the current maximum.                         */
+  /*                                                                       */
+
+#if 0
+
+  static void
+  BBox_Cubic_Check( FT_Pos   p1,
+                    FT_Pos   p2,
+                    FT_Pos   p3,
+                    FT_Pos   p4,
+                    FT_Pos*  min,
+                    FT_Pos*  max )
+  {
+    FT_Pos  stack[32*3 + 1], *arc;
+
+
+    arc = stack;
+
+    arc[0] = p1;
+    arc[1] = p2;
+    arc[2] = p3;
+    arc[3] = p4;
+
+    do
+    {
+      FT_Pos  y1 = arc[0];
+      FT_Pos  y2 = arc[1];
+      FT_Pos  y3 = arc[2];
+      FT_Pos  y4 = arc[3];
+
+
+      if ( y1 == y4 )
+      {
+        if ( y1 == y2 && y1 == y3 )                         /* flat */
+          goto Test;
+      }
+      else if ( y1 < y4 )
+      {
+        if ( y2 >= y1 && y2 <= y4 && y3 >= y1 && y3 <= y4 ) /* ascending */
+          goto Test;
+      }
+      else
+      {
+        if ( y2 >= y4 && y2 <= y1 && y3 >= y4 && y3 <= y1 ) /* descending */
+        {
+          y2 = y1;
+          y1 = y4;
+          y4 = y2;
+          goto Test;
+        }
+      }
+
+      /* unknown direction -- split the arc in two */
+      arc[6] = y4;
+      arc[1] = y1 = ( y1 + y2 ) / 2;
+      arc[5] = y4 = ( y4 + y3 ) / 2;
+      y2 = ( y2 + y3 ) / 2;
+      arc[2] = y1 = ( y1 + y2 ) / 2;
+      arc[4] = y4 = ( y4 + y2 ) / 2;
+      arc[3] = ( y1 + y4 ) / 2;
+
+      arc += 3;
+      goto Suite;
+
+   Test:
+      if ( y1 < *min ) *min = y1;
+      if ( y4 > *max ) *max = y4;
+      arc -= 3;
+
+    Suite:
+      ;
+    } while ( arc >= stack );
+  }
+
+#else
+
+  static void
+  test_cubic_extrema( FT_Pos    y1,
+                      FT_Pos    y2,
+                      FT_Pos    y3,
+                      FT_Pos    y4,
+                      FT_Fixed  u,
+                      FT_Pos*   min,
+                      FT_Pos*   max )
+  {
+ /* FT_Pos    a = y4 - 3*y3 + 3*y2 - y1; */
+    FT_Pos    b = y3 - 2*y2 + y1;
+    FT_Pos    c = y2 - y1;
+    FT_Pos    d = y1;
+    FT_Pos    y;
+    FT_Fixed  uu;
+
+    FT_UNUSED ( y4 );
+
+
+    /* The polynom is                         */
+    /*                                        */
+    /*    P(x) = a*x^3 + 3b*x^2 + 3c*x + d  , */
+    /*                                        */
+    /*   dP/dx = 3a*x^2 + 6b*x + 3c         . */
+    /*                                        */
+    /* However, we also have                  */
+    /*                                        */
+    /*   dP/dx(u) = 0                       , */
+    /*                                        */
+    /* which implies by subtraction that      */
+    /*                                        */
+    /*   P(u) = b*u^2 + 2c*u + d            . */
+
+    if ( u > 0 && u < 0x10000L )
+    {
+      uu = FT_MulFix( u, u );
+      y  = d + FT_MulFix( c, 2*u ) + FT_MulFix( b, uu );
+
+      if ( y < *min ) *min = y;
+      if ( y > *max ) *max = y;
+    }
+  }
+
+
+  static void
+  BBox_Cubic_Check( FT_Pos   y1,
+                    FT_Pos   y2,
+                    FT_Pos   y3,
+                    FT_Pos   y4,
+                    FT_Pos*  min,
+                    FT_Pos*  max )
+  {
+    /* always compare first and last points */
+    if      ( y1 < *min )  *min = y1;
+    else if ( y1 > *max )  *max = y1;
+
+    if      ( y4 < *min )  *min = y4;
+    else if ( y4 > *max )  *max = y4;
+
+    /* now, try to see if there are split points here */
+    if ( y1 <= y4 )
+    {
+      /* flat or ascending arc test */
+      if ( y1 <= y2 && y2 <= y4 && y1 <= y3 && y3 <= y4 )
+        return;
+    }
+    else /* y1 > y4 */
+    {
+      /* descending arc test */
+      if ( y1 >= y2 && y2 >= y4 && y1 >= y3 && y3 >= y4 )
+        return;
+    }
+
+    /* There are some split points.  Find them. */
+    {
+      FT_Pos    a = y4 - 3*y3 + 3*y2 - y1;
+      FT_Pos    b = y3 - 2*y2 + y1;
+      FT_Pos    c = y2 - y1;
+      FT_Pos    d;
+      FT_Fixed  t;
+
+
+      /* We need to solve `ax^2+2bx+c' here, without floating points!      */
+      /* The trick is to normalize to a different representation in order  */
+      /* to use our 16.16 fixed point routines.                            */
+      /*                                                                   */
+      /* We compute FT_MulFix(b,b) and FT_MulFix(a,c) after normalization. */
+      /* These values must fit into a single 16.16 value.                  */
+      /*                                                                   */
+      /* We normalize a, b, and c to `8.16' fixed float values to ensure   */
+      /* that its product is held in a `16.16' value.                      */
+
+      {
+        FT_ULong  t1, t2;
+        int       shift = 0;
+
+
+        /* The following computation is based on the fact that for   */
+        /* any value `y', if `n' is the position of the most         */
+        /* significant bit of `abs(y)' (starting from 0 for the      */
+        /* least significant bit), then `y' is in the range          */
+        /*                                                           */
+        /*   -2^n..2^n-1                                             */
+        /*                                                           */
+        /* We want to shift `a', `b', and `c' concurrently in order  */
+        /* to ensure that they all fit in 8.16 values, which maps    */
+        /* to the integer range `-2^23..2^23-1'.                     */
+        /*                                                           */
+        /* Necessarily, we need to shift `a', `b', and `c' so that   */
+        /* the most significant bit of its absolute values is at     */
+        /* _most_ at position 23.                                    */
+        /*                                                           */
+        /* We begin by computing `t1' as the bitwise `OR' of the     */
+        /* absolute values of `a', `b', `c'.                         */
+
+        t1  = (FT_ULong)( ( a >= 0 ) ? a : -a );
+        t2  = (FT_ULong)( ( b >= 0 ) ? b : -b );
+        t1 |= t2;
+        t2  = (FT_ULong)( ( c >= 0 ) ? c : -c );
+        t1 |= t2;
+
+        /* Now we can be sure that the most significant bit of `t1'  */
+        /* is the most significant bit of either `a', `b', or `c',   */
+        /* depending on the greatest integer range of the particular */
+        /* variable.                                                 */
+        /*                                                           */
+        /* Next, we compute the `shift', by shifting `t1' as many    */
+        /* times as necessary to move its MSB to position 23.  This  */
+        /* corresponds to a value of `t1' that is in the range       */
+        /* 0x40_0000..0x7F_FFFF.                                     */
+        /*                                                           */
+        /* Finally, we shift `a', `b', and `c' by the same amount.   */
+        /* This ensures that all values are now in the range         */
+        /* -2^23..2^23, i.e., they are now expressed as 8.16         */
+        /* fixed-float numbers.  This also means that we are using   */
+        /* 24 bits of precision to compute the zeros, independently  */
+        /* of the range of the original polynomial coefficients.     */
+        /*                                                           */
+        /* This algorithm should ensure reasonably accurate values   */
+        /* for the zeros.  Note that they are only expressed with    */
+        /* 16 bits when computing the extrema (the zeros need to     */
+        /* be in 0..1 exclusive to be considered part of the arc).   */
+
+        if ( t1 == 0 )  /* all coefficients are 0! */
+          return;
+
+        if ( t1 > 0x7FFFFFUL )
+        {
+          do
+          {
+            shift++;
+            t1 >>= 1;
+
+          } while ( t1 > 0x7FFFFFUL );
+
+          /* this loses some bits of precision, but we use 24 of them */
+          /* for the computation anyway                               */
+          a >>= shift;
+          b >>= shift;
+          c >>= shift;
+        }
+        else if ( t1 < 0x400000UL )
+        {
+          do
+          {
+            shift++;
+            t1 <<= 1;
+
+          } while ( t1 < 0x400000UL );
+
+          a <<= shift;
+          b <<= shift;
+          c <<= shift;
+        }
+      }
+
+      /* handle a == 0 */
+      if ( a == 0 )
+      {
+        if ( b != 0 )
+        {
+          t = - FT_DivFix( c, b ) / 2;
+          test_cubic_extrema( y1, y2, y3, y4, t, min, max );
+        }
+      }
+      else
+      {
+        /* solve the equation now */
+        d = FT_MulFix( b, b ) - FT_MulFix( a, c );
+        if ( d < 0 )
+          return;
+
+        if ( d == 0 )
+        {
+          /* there is a single split point at -b/a */
+          t = - FT_DivFix( b, a );
+          test_cubic_extrema( y1, y2, y3, y4, t, min, max );
+        }
+        else
+        {
+          /* there are two solutions; we need to filter them */
+          d = FT_SqrtFixed( (FT_Int32)d );
+          t = - FT_DivFix( b - d, a );
+          test_cubic_extrema( y1, y2, y3, y4, t, min, max );
+
+          t = - FT_DivFix( b + d, a );
+          test_cubic_extrema( y1, y2, y3, y4, t, min, max );
+        }
+      }
+    }
+  }
+
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    BBox_Cubic_To                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used as a `cubic_to' emitter during               */
+  /*    FT_Raster_Decompose().  It checks a cubic Bezier curve with the    */
+  /*    current bounding box, and computes its extrema if necessary to     */
+  /*    update it.                                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    control1 :: A pointer to the first control point.                  */
+  /*                                                                       */
+  /*    control2 :: A pointer to the second control point.                 */
+  /*                                                                       */
+  /*    to       :: A pointer to the destination vector.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    user     :: The address of the current walk context.               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Always 0.  Needed for the interface only.                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    In the case of a non-monotonous arc, we don't compute directly     */
+  /*    extremum coordinates, we subdivide instead.                        */
+  /*                                                                       */
+  static int
+  BBox_Cubic_To( FT_Vector*  control1,
+                 FT_Vector*  control2,
+                 FT_Vector*  to,
+                 TBBox_Rec*  user )
+  {
+    /* we don't need to check `to' since it is always an `on' point, thus */
+    /* within the bbox                                                    */
+
+    if ( CHECK_X( control1, user->bbox ) ||
+         CHECK_X( control2, user->bbox ) )
+      BBox_Cubic_Check( user->last.x,
+                        control1->x,
+                        control2->x,
+                        to->x,
+                        &user->bbox.xMin,
+                        &user->bbox.xMax );
+
+    if ( CHECK_Y( control1, user->bbox ) ||
+         CHECK_Y( control2, user->bbox ) )
+      BBox_Cubic_Check( user->last.y,
+                        control1->y,
+                        control2->y,
+                        to->y,
+                        &user->bbox.yMin,
+                        &user->bbox.yMax );
+
+    user->last = *to;
+
+    return 0;
+  }
+
+
+  /* documentation is in ftbbox.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_Get_BBox( FT_Outline*  outline,
+                       FT_BBox     *abbox )
+  {
+    FT_BBox     cbox;
+    FT_BBox     bbox;
+    FT_Vector*  vec;
+    FT_UShort   n;
+
+
+    if ( !abbox )
+      return FT_Err_Invalid_Argument;
+
+    if ( !outline )
+      return FT_Err_Invalid_Outline;
+
+    /* if outline is empty, return (0,0,0,0) */
+    if ( outline->n_points == 0 || outline->n_contours <= 0 )
+    {
+      abbox->xMin = abbox->xMax = 0;
+      abbox->yMin = abbox->yMax = 0;
+      return 0;
+    }
+
+    /* We compute the control box as well as the bounding box of  */
+    /* all `on' points in the outline.  Then, if the two boxes    */
+    /* coincide, we exit immediately.                             */
+
+    vec = outline->points;
+    bbox.xMin = bbox.xMax = cbox.xMin = cbox.xMax = vec->x;
+    bbox.yMin = bbox.yMax = cbox.yMin = cbox.yMax = vec->y;
+    vec++;
+
+    for ( n = 1; n < outline->n_points; n++ )
+    {
+      FT_Pos  x = vec->x;
+      FT_Pos  y = vec->y;
+
+
+      /* update control box */
+      if ( x < cbox.xMin ) cbox.xMin = x;
+      if ( x > cbox.xMax ) cbox.xMax = x;
+
+      if ( y < cbox.yMin ) cbox.yMin = y;
+      if ( y > cbox.yMax ) cbox.yMax = y;
+
+      if ( FT_CURVE_TAG( outline->tags[n] ) == FT_CURVE_TAG_ON )
+      {
+        /* update bbox for `on' points only */
+        if ( x < bbox.xMin ) bbox.xMin = x;
+        if ( x > bbox.xMax ) bbox.xMax = x;
+
+        if ( y < bbox.yMin ) bbox.yMin = y;
+        if ( y > bbox.yMax ) bbox.yMax = y;
+      }
+
+      vec++;
+    }
+
+    /* test two boxes for equality */
+    if ( cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax ||
+         cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax )
+    {
+      /* the two boxes are different, now walk over the outline to */
+      /* get the Bezier arc extrema.                               */
+
+      static const FT_Outline_Funcs  bbox_interface =
+      {
+        (FT_Outline_MoveTo_Func) BBox_Move_To,
+        (FT_Outline_LineTo_Func) BBox_Move_To,
+        (FT_Outline_ConicTo_Func)BBox_Conic_To,
+        (FT_Outline_CubicTo_Func)BBox_Cubic_To,
+        0, 0
+      };
+
+      FT_Error   error;
+      TBBox_Rec  user;
+
+
+      user.bbox = bbox;
+
+      error = FT_Outline_Decompose( outline, &bbox_interface, &user );
+      if ( error )
+        return error;
+
+      *abbox = user.bbox;
+    }
+    else
+      *abbox = bbox;
+
+    return FT_Err_Ok;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftbdf.c b/nx-X11/extras/freetype2/src/base/ftbdf.c
new file mode 100644
index 000000000..d2f133db7
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftbdf.c
@@ -0,0 +1,84 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbdf.c                                                                */
+/*                                                                         */
+/*    FreeType API for accessing BDF-specific strings (body).              */
+/*                                                                         */
+/*  Copyright 2002, 2003 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_OBJECTS_H
+#include FT_SERVICE_BDF_H
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_BDF_Charset_ID( FT_Face       face,
+                         const char*  *acharset_encoding,
+                         const char*  *acharset_registry )
+  {
+    FT_Error     error;
+    const char*  encoding = NULL;
+    const char*  registry = NULL;
+
+
+    error = FT_Err_Invalid_Argument;
+
+    if ( face )
+    {
+      FT_Service_BDF  service;
+
+
+      FT_FACE_FIND_SERVICE( face, service, BDF );
+
+      if ( service && service->get_charset_id )
+        error = service->get_charset_id( face, &encoding, &registry );
+    }
+
+    if ( acharset_encoding )
+      *acharset_encoding = encoding;
+
+    if ( acharset_registry )
+      *acharset_registry = registry;
+
+    return error;
+  }
+
+
+  FT_EXPORT( FT_Error )
+  FT_Get_BDF_Property( FT_Face           face,
+                       const char*       prop_name,
+                       BDF_PropertyRec  *aproperty )
+  {
+    FT_Error  error;
+
+
+    error = FT_Err_Invalid_Argument;
+
+    aproperty->type = BDF_PROPERTY_TYPE_NONE;
+
+    if ( face )
+    {
+      FT_Service_BDF  service;
+
+
+      FT_FACE_FIND_SERVICE( face, service, BDF );
+
+      if ( service && service->get_property )
+        error = service->get_property( face, prop_name, aproperty );
+    }
+
+    return  error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftcalc.c b/nx-X11/extras/freetype2/src/base/ftcalc.c
new file mode 100644
index 000000000..f169642e0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftcalc.c
@@ -0,0 +1,624 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcalc.c                                                               */
+/*                                                                         */
+/*    Arithmetic computations (body).                                      */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Support for 1-complement arithmetic has been totally dropped in this  */
+  /* release.  You can still write your own code if you need it.           */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Implementing basic computation routines.                              */
+  /*                                                                       */
+  /* FT_MulDiv(), FT_MulFix(), FT_DivFix(), FT_RoundFix(), FT_CeilFix(),   */
+  /* and FT_FloorFix() are declared in freetype.h.                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_CALC_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_OBJECTS_H
+
+
+/* we need to define a 64-bits data type here */
+
+#ifdef FT_LONG64
+
+  typedef FT_INT64  FT_Int64;
+
+#else
+
+  typedef struct  FT_Int64_
+  {
+    FT_UInt32  lo;
+    FT_UInt32  hi;
+
+  } FT_Int64;
+
+#endif /* FT_LONG64 */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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_calc
+
+
+  /* The following three functions are available regardless of whether */
+  /* FT_LONG64 is defined.                                             */
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Fixed )
+  FT_RoundFix( FT_Fixed  a )
+  {
+    return ( a >= 0 ) ?   ( a + 0x8000L ) & ~0xFFFFL
+                      : -((-a + 0x8000L ) & ~0xFFFFL );
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Fixed )
+  FT_CeilFix( FT_Fixed  a )
+  {
+    return ( a >= 0 ) ?   ( a + 0xFFFFL ) & ~0xFFFFL
+                      : -((-a + 0xFFFFL ) & ~0xFFFFL );
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Fixed )
+  FT_FloorFix( FT_Fixed  a )
+  {
+    return ( a >= 0 ) ?   a & ~0xFFFFL
+                      : -((-a) & ~0xFFFFL );
+  }
+
+
+  /* documentation is in ftcalc.h */
+
+  FT_EXPORT_DEF( FT_Int32 )
+  FT_Sqrt32( FT_Int32  x )
+  {
+    FT_ULong  val, root, newroot, mask;
+
+
+    root = 0;
+    mask = 0x40000000L;
+    val  = (FT_ULong)x;
+
+    do
+    {
+      newroot = root + mask;
+      if ( newroot <= val )
+      {
+        val -= newroot;
+        root = newroot + mask;
+      }
+
+      root >>= 1;
+      mask >>= 2;
+
+    } while ( mask != 0 );
+
+    return root;
+  }
+
+
+#ifdef FT_LONG64
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Long )
+  FT_MulDiv( FT_Long  a,
+             FT_Long  b,
+             FT_Long  c )
+  {
+    FT_Int   s;
+    FT_Long  d;
+
+
+    s = 1;
+    if ( a < 0 ) { a = -a; s = -1; }
+    if ( b < 0 ) { b = -b; s = -s; }
+    if ( c < 0 ) { c = -c; s = -s; }
+
+    d = (FT_Long)( c > 0 ? ( (FT_Int64)a * b + ( c >> 1 ) ) / c
+                         : 0x7FFFFFFFL );
+
+    return ( s > 0 ) ? d : -d;
+  }
+
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+  /* documentation is in ftcalc.h */
+
+  FT_BASE_DEF( FT_Long )
+  FT_MulDiv_No_Round( FT_Long  a,
+                      FT_Long  b,
+                      FT_Long  c )
+  {
+    FT_Int   s;
+    FT_Long  d;
+
+
+    s = 1;
+    if ( a < 0 ) { a = -a; s = -1; }
+    if ( b < 0 ) { b = -b; s = -s; }
+    if ( c < 0 ) { c = -c; s = -s; }
+
+    d = (FT_Long)( c > 0 ? (FT_Int64)a * b / c
+                         : 0x7FFFFFFFL );
+
+    return ( s > 0 ) ? d : -d;
+  }
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Long )
+  FT_MulFix( FT_Long  a,
+             FT_Long  b )
+  {
+    FT_Int   s = 1;
+    FT_Long  c;
+
+
+    if ( a < 0 ) { a = -a; s = -1; }
+    if ( b < 0 ) { b = -b; s = -s; }
+
+    c = (FT_Long)( ( (FT_Int64)a * b + 0x8000L ) >> 16 );
+    return ( s > 0 ) ? c : -c ;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Long )
+  FT_DivFix( FT_Long  a,
+             FT_Long  b )
+  {
+    FT_Int32   s;
+    FT_UInt32  q;
+
+    s = 1;
+    if ( a < 0 ) { a = -a; s = -1; }
+    if ( b < 0 ) { b = -b; s = -s; }
+
+    if ( b == 0 )
+      /* check for division by 0 */
+      q = 0x7FFFFFFFL;
+    else
+      /* compute result directly */
+      q = (FT_UInt32)( ( ( (FT_Int64)a << 16 ) + ( b >> 1 ) ) / b );
+
+    return ( s < 0 ? -(FT_Long)q : (FT_Long)q );
+  }
+
+
+#else /* FT_LONG64 */
+
+
+  static void
+  ft_multo64( FT_UInt32  x,
+              FT_UInt32  y,
+              FT_Int64  *z )
+  {
+    FT_UInt32  lo1, hi1, lo2, hi2, lo, hi, i1, i2;
+
+
+    lo1 = x & 0x0000FFFFU;  hi1 = x >> 16;
+    lo2 = y & 0x0000FFFFU;  hi2 = y >> 16;
+
+    lo = lo1 * lo2;
+    i1 = lo1 * hi2;
+    i2 = lo2 * hi1;
+    hi = hi1 * hi2;
+
+    /* Check carry overflow of i1 + i2 */
+    i1 += i2;
+    hi += (FT_UInt32)( i1 < i2 ) << 16;
+
+    hi += i1 >> 16;
+    i1  = i1 << 16;
+
+    /* Check carry overflow of i1 + lo */
+    lo += i1;
+    hi += ( lo < i1 );
+
+    z->lo = lo;
+    z->hi = hi;
+  }
+
+
+  static FT_UInt32
+  ft_div64by32( FT_UInt32  hi,
+                FT_UInt32  lo,
+                FT_UInt32  y )
+  {
+    FT_UInt32  r, q;
+    FT_Int     i;
+
+
+    q = 0;
+    r = hi;
+
+    if ( r >= y )
+      return (FT_UInt32)0x7FFFFFFFL;
+
+    i = 32;
+    do
+    {
+      r <<= 1;
+      q <<= 1;
+      r  |= lo >> 31;
+
+      if ( r >= (FT_UInt32)y )
+      {
+        r -= y;
+        q |= 1;
+      }
+      lo <<= 1;
+    } while ( --i );
+
+    return q;
+  }
+
+
+  /* documentation is in ftcalc.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Add64( FT_Int64*  x,
+            FT_Int64*  y,
+            FT_Int64  *z )
+  {
+    register FT_UInt32  lo, hi, max;
+
+
+    max = x->lo > y->lo ? x->lo : y->lo;
+    lo  = x->lo + y->lo;
+    hi  = x->hi + y->hi + ( lo < max );
+
+    z->lo = lo;
+    z->hi = hi;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Long )
+  FT_MulDiv( FT_Long  a,
+             FT_Long  b,
+             FT_Long  c )
+  {
+    long  s;
+
+
+    if ( a == 0 || b == c )
+      return a;
+
+    s  = a; a = FT_ABS( a );
+    s ^= b; b = FT_ABS( b );
+    s ^= c; c = FT_ABS( c );
+
+    if ( a <= 46340L && b <= 46340L && c <= 176095L && c > 0 )
+      a = ( a * b + ( c >> 1 ) ) / c;
+
+    else if ( c > 0 )
+    {
+      FT_Int64  temp, temp2;
+
+
+      ft_multo64( a, b, &temp );
+
+      temp2.hi = 0;
+      temp2.lo = (FT_UInt32)(c >> 1);
+      FT_Add64( &temp, &temp2, &temp );
+      a = ft_div64by32( temp.hi, temp.lo, c );
+    }
+    else
+      a = 0x7FFFFFFFL;
+
+    return ( s < 0 ? -a : a );
+  }
+
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+  FT_BASE_DEF( FT_Long )
+  FT_MulDiv_No_Round( FT_Long  a,
+                      FT_Long  b,
+                      FT_Long  c )
+  {
+    long  s;
+
+
+    if ( a == 0 || b == c )
+      return a;
+
+    s  = a; a = FT_ABS( a );
+    s ^= b; b = FT_ABS( b );
+    s ^= c; c = FT_ABS( c );
+
+    if ( a <= 46340L && b <= 46340L && c > 0 )
+      a = a * b / c;
+
+    else if ( c > 0 )
+    {
+      FT_Int64  temp;
+
+
+      ft_multo64( a, b, &temp );
+      a = ft_div64by32( temp.hi, temp.lo, c );
+    }
+    else
+      a = 0x7FFFFFFFL;
+
+    return ( s < 0 ? -a : a );
+  }
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Long )
+  FT_MulFix( FT_Long  a,
+             FT_Long  b )
+  {
+    FT_Long   s;
+    FT_ULong  ua, ub;
+
+
+    if ( a == 0 || b == 0x10000L )
+      return a;
+
+    s  = a; a = FT_ABS(a);
+    s ^= b; b = FT_ABS(b);
+
+    ua = (FT_ULong)a;
+    ub = (FT_ULong)b;
+
+    if ( ua <= 2048 && ub <= 1048576L )
+    {
+      ua = ( ua * ub + 0x8000L ) >> 16;
+    }
+    else
+    {
+      FT_ULong  al = ua & 0xFFFFL;
+
+
+      ua = ( ua >> 16 ) * ub +  al * ( ub >> 16 ) +
+           ( ( al * ( ub & 0xFFFFL ) + 0x8000L ) >> 16 );
+    }
+
+    return ( s < 0 ? -(FT_Long)ua : (FT_Long)ua );
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Long )
+  FT_DivFix( FT_Long  a,
+             FT_Long  b )
+  {
+    FT_Int32   s;
+    FT_UInt32  q;
+
+
+    s  = a; a = FT_ABS(a);
+    s ^= b; b = FT_ABS(b);
+
+    if ( b == 0 )
+    {
+      /* check for division by 0 */
+      q = 0x7FFFFFFFL;
+    }
+    else if ( ( a >> 16 ) == 0 )
+    {
+      /* compute result directly */
+      q = (FT_UInt32)( (a << 16) + (b >> 1) ) / (FT_UInt32)b;
+    }
+    else
+    {
+      /* we need more bits; we have to do it by hand */
+      FT_Int64  temp, temp2;
+
+      temp.hi  = (FT_Int32) (a >> 16);
+      temp.lo  = (FT_UInt32)(a << 16);
+      temp2.hi = 0;
+      temp2.lo = (FT_UInt32)( b >> 1 );
+      FT_Add64( &temp, &temp2, &temp );
+      q = ft_div64by32( temp.hi, temp.lo, b );
+    }
+
+    return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
+  }
+
+
+  /* documentation is in ftcalc.h */
+
+  FT_EXPORT_DEF( void )
+  FT_MulTo64( FT_Int32   x,
+              FT_Int32   y,
+              FT_Int64  *z )
+  {
+    FT_Int32  s;
+
+
+    s  = x; x = FT_ABS( x );
+    s ^= y; y = FT_ABS( y );
+
+    ft_multo64( x, y, z );
+
+    if ( s < 0 )
+    {
+      z->lo = (FT_UInt32)-(FT_Int32)z->lo;
+      z->hi = ~z->hi + !( z->lo );
+    }
+  }
+
+
+  /* documentation is in ftcalc.h */
+
+  /* apparently, the second version of this code is not compiled correctly */
+  /* on Mac machines with the MPW C compiler..  tsss, tsss, tss...         */
+
+#if 1
+
+  FT_EXPORT_DEF( FT_Int32 )
+  FT_Div64by32( FT_Int64*  x,
+                FT_Int32   y )
+  {
+    FT_Int32   s;
+    FT_UInt32  q, r, i, lo;
+
+
+    s  = x->hi;
+    if ( s < 0 )
+    {
+      x->lo = (FT_UInt32)-(FT_Int32)x->lo;
+      x->hi = ~x->hi + !x->lo;
+    }
+    s ^= y;  y = FT_ABS( y );
+
+    /* Shortcut */
+    if ( x->hi == 0 )
+    {
+      if ( y > 0 )
+        q = x->lo / y;
+      else
+        q = 0x7FFFFFFFL;
+
+      return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
+    }
+
+    r  = x->hi;
+    lo = x->lo;
+
+    if ( r >= (FT_UInt32)y ) /* we know y is to be treated as unsigned here */
+      return ( s < 0 ? 0x80000001UL : 0x7FFFFFFFUL );
+                             /* Return Max/Min Int32 if division overflow. */
+                             /* This includes division by zero! */
+    q = 0;
+    for ( i = 0; i < 32; i++ )
+    {
+      r <<= 1;
+      q <<= 1;
+      r  |= lo >> 31;
+
+      if ( r >= (FT_UInt32)y )
+      {
+        r -= y;
+        q |= 1;
+      }
+      lo <<= 1;
+    }
+
+    return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
+  }
+
+#else /* 0 */
+
+  FT_EXPORT_DEF( FT_Int32 )
+  FT_Div64by32( FT_Int64*  x,
+                FT_Int32   y )
+  {
+    FT_Int32   s;
+    FT_UInt32  q;
+
+
+    s  = x->hi;
+    if ( s < 0 )
+    {
+      x->lo = (FT_UInt32)-(FT_Int32)x->lo;
+      x->hi = ~x->hi + !x->lo;
+    }
+    s ^= y;  y = FT_ABS( y );
+
+    /* Shortcut */
+    if ( x->hi == 0 )
+    {
+      if ( y > 0 )
+        q = ( x->lo + ( y >> 1 ) ) / y;
+      else
+        q = 0x7FFFFFFFL;
+
+      return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
+    }
+
+    q = ft_div64by32( x->hi, x->lo, y );
+
+    return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
+  }
+
+#endif /* 0 */
+
+
+#endif /* FT_LONG64 */
+
+
+  /* a not-so-fast but working 16.16 fixed point square root function */
+
+  FT_EXPORT_DEF( FT_Int32 )
+  FT_SqrtFixed( FT_Int32  x )
+  {
+    FT_UInt32  root, rem_hi, rem_lo, test_div;
+    FT_Int     count;
+
+
+    root = 0;
+
+    if ( x > 0 )
+    {
+      rem_hi = 0;
+      rem_lo = x;
+      count  = 24;
+      do
+      {
+        rem_hi   = ( rem_hi << 2 ) | ( rem_lo >> 30 );
+        rem_lo <<= 2;
+        root   <<= 1;
+        test_div = ( root << 1 ) + 1;
+
+        if ( rem_hi >= test_div )
+        {
+          rem_hi -= test_div;
+          root   += 1;
+        }
+      } while ( --count );
+    }
+
+    return (FT_Int32)root;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftdbgmem.c b/nx-X11/extras/freetype2/src/base/ftdbgmem.c
new file mode 100644
index 000000000..61227b64a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftdbgmem.c
@@ -0,0 +1,763 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftdbgmem.c                                                             */
+/*                                                                         */
+/*    Memory debugger (body).                                              */
+/*                                                                         */
+/*  Copyright 2001, 2002, 2003, 2004 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_CONFIG_CONFIG_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_MEMORY_H
+#include FT_SYSTEM_H
+#include FT_ERRORS_H
+#include FT_TYPES_H
+
+
+#ifdef FT_DEBUG_MEMORY
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+  typedef struct FT_MemNodeRec_*   FT_MemNode;
+  typedef struct FT_MemTableRec_*  FT_MemTable;
+
+#define FT_MEM_VAL( addr )  ((FT_ULong)(FT_Pointer)( addr ))
+
+  typedef struct  FT_MemNodeRec_
+  {
+    FT_Byte*     address;
+    FT_Long      size;     /* < 0 if the block was freed */
+
+    const char*  alloc_file_name;
+    FT_Long      alloc_line_no;
+
+    const char*  free_file_name;
+    FT_Long      free_line_no;
+
+    FT_MemNode   link;
+
+  } FT_MemNodeRec;
+
+
+  typedef struct  FT_MemTableRec_
+  {
+    FT_ULong         size;
+    FT_ULong         nodes;
+    FT_MemNode*      buckets;
+
+    FT_ULong         alloc_total;
+    FT_ULong         alloc_current;
+    FT_ULong         alloc_max;
+    FT_ULong         alloc_count;
+
+    FT_Bool          bound_total;    
+    FT_ULong         alloc_total_max;
+    
+    FT_Bool          bound_count;
+    FT_ULong         alloc_count_max;
+
+    const char*      file_name;
+    FT_Long          line_no;
+
+    FT_Memory        memory;
+    FT_Pointer       memory_user;
+    FT_Alloc_Func    alloc;
+    FT_Free_Func     free;
+    FT_Realloc_Func  realloc;
+
+  } FT_MemTableRec;
+
+
+#define FT_MEM_SIZE_MIN  7
+#define FT_MEM_SIZE_MAX  13845163
+
+#define FT_FILENAME( x )  ((x) ? (x) : "unknown file")
+
+
+  static const FT_UInt  ft_mem_primes[] =
+  {
+    7,
+    11,
+    19,
+    37,
+    73,
+    109,
+    163,
+    251,
+    367,
+    557,
+    823,
+    1237,
+    1861,
+    2777,
+    4177,
+    6247,
+    9371,
+    14057,
+    21089,
+    31627,
+    47431,
+    71143,
+    106721,
+    160073,
+    240101,
+    360163,
+    540217,
+    810343,
+    1215497,
+    1823231,
+    2734867,
+    4102283,
+    6153409,
+    9230113,
+    13845163,
+  };
+
+
+
+  extern void
+  ft_mem_debug_panic( const char*  fmt, ... )
+  {
+    va_list  ap;
+
+
+    printf( "FreeType.Debug: " );
+
+    va_start( ap, fmt );
+    vprintf( fmt, ap );
+    va_end( ap );
+
+    printf( "\n" );
+    exit( EXIT_FAILURE );
+  }
+
+
+  static FT_ULong
+  ft_mem_closest_prime( FT_ULong  num )
+  {
+    FT_UInt  i;
+
+
+    for ( i = 0;
+          i < sizeof ( ft_mem_primes ) / sizeof ( ft_mem_primes[0] ); i++ )
+      if ( ft_mem_primes[i] > num )
+        return ft_mem_primes[i];
+
+    return FT_MEM_SIZE_MAX;
+  }
+
+
+  static FT_Pointer
+  ft_mem_table_alloc( FT_MemTable  table,
+                      FT_Long      size )
+  {
+    FT_Memory   memory = table->memory;
+    FT_Pointer  block;
+
+
+    memory->user = table->memory_user;
+    block = table->alloc( memory, size );
+    memory->user = table;
+
+   return block;
+  }
+
+
+  static void
+  ft_mem_table_free( FT_MemTable  table,
+                     FT_Pointer   block )
+  {
+    FT_Memory  memory = table->memory;
+
+
+    memory->user = table->memory_user;
+    table->free( memory, block );
+    memory->user = table;
+  }
+
+
+  static void
+  ft_mem_table_resize( FT_MemTable  table )
+  {
+    FT_ULong  new_size;
+
+
+    new_size = ft_mem_closest_prime( table->nodes );
+    if ( new_size != table->size )
+    {
+      FT_MemNode*  new_buckets ;
+      FT_ULong     i;
+
+
+      new_buckets = (FT_MemNode *)
+                    ft_mem_table_alloc( table,
+                                        new_size * sizeof ( FT_MemNode ) );
+      if ( new_buckets == NULL )
+        return;
+
+      FT_MEM_ZERO( new_buckets, sizeof ( FT_MemNode ) * new_size );
+
+      for ( i = 0; i < table->size; i++ )
+      {
+        FT_MemNode  node, next, *pnode;
+        FT_ULong    hash;
+
+
+        node = table->buckets[i];
+        while ( node )
+        {
+          next  = node->link;
+          hash  = FT_MEM_VAL( node->address ) % new_size;
+          pnode = new_buckets + hash;
+
+          node->link = pnode[0];
+          pnode[0]   = node;
+
+          node = next;
+        }
+      }
+
+      if ( table->buckets )
+        ft_mem_table_free( table, table->buckets );
+
+      table->buckets = new_buckets;
+      table->size    = new_size;
+    }
+  }
+
+
+  static FT_MemTable
+  ft_mem_table_new( FT_Memory  memory )
+  {
+    FT_MemTable  table;
+
+
+    table = (FT_MemTable)memory->alloc( memory, sizeof ( *table ) );
+    if ( table == NULL )
+      goto Exit;
+
+    FT_MEM_ZERO( table, sizeof ( *table ) );
+
+    table->size  = FT_MEM_SIZE_MIN;
+    table->nodes = 0;
+
+    table->memory = memory;
+
+    table->memory_user = memory->user;
+
+    table->alloc   = memory->alloc;
+    table->realloc = memory->realloc;
+    table->free    = memory->free;
+
+    table->buckets = (FT_MemNode *)
+                     memory->alloc( memory,
+                                    table->size * sizeof ( FT_MemNode ) );
+    if ( table->buckets )
+      FT_MEM_ZERO( table->buckets, sizeof ( FT_MemNode ) * table->size );
+    else
+    {
+      memory->free( memory, table );
+      table = NULL;
+    }
+
+  Exit:
+    return table;
+  }
+
+
+  static void
+  ft_mem_table_destroy( FT_MemTable  table )
+  {
+    FT_ULong  i;
+
+
+    if ( table )
+    {
+      FT_Long    leak_count = 0;
+      FT_ULong   leaks = 0;
+
+
+      for ( i = 0; i < table->size; i++ )
+      {
+        FT_MemNode  *pnode = table->buckets + i, next, node = *pnode;
+
+
+        while ( node )
+        {
+          next       = node->link;
+          node->link = 0;
+
+          if ( node->size > 0 )
+          {
+            printf(
+              "leaked memory block at address %p, size %8ld in (%s:%ld)\n",
+              node->address, node->size,
+              FT_FILENAME( node->alloc_file_name ),
+              node->alloc_line_no );
+
+            leak_count++;
+            leaks += node->size;
+
+            ft_mem_table_free( table, node->address );
+          }
+
+          node->address = NULL;
+          node->size    = 0;
+
+          free( node );
+          node = next;
+        }
+        table->buckets[i] = 0;
+      }
+      ft_mem_table_free( table, table->buckets );
+      table->buckets = NULL;
+
+      table->size   = 0;
+      table->nodes  = 0;
+
+      printf(
+        "FreeType: total memory allocations = %ld\n", table->alloc_total );
+      printf(
+        "FreeType: maximum memory footprint = %ld\n", table->alloc_max );
+
+      free( table );
+
+      if ( leak_count > 0 )
+        ft_mem_debug_panic(
+          "FreeType: %ld bytes of memory leaked in %ld blocks\n",
+          leaks, leak_count );
+      printf( "FreeType: No memory leaks detected!\n" );
+    }
+  }
+
+
+  static FT_MemNode*
+  ft_mem_table_get_nodep( FT_MemTable  table,
+                          FT_Byte*     address )
+  {
+    FT_ULong     hash;
+    FT_MemNode  *pnode, node;
+
+
+    hash  = FT_MEM_VAL( address );
+    pnode = table->buckets + ( hash % table->size );
+
+    for (;;)
+    {
+      node = pnode[0];
+      if ( !node )
+        break;
+
+      if ( node->address == address )
+        break;
+
+      pnode = &node->link;
+    }
+    return pnode;
+  }
+
+
+  static void
+  ft_mem_table_set( FT_MemTable  table,
+                    FT_Byte*     address,
+                    FT_ULong     size )
+  {
+    FT_MemNode  *pnode, node;
+
+
+    if ( table )
+    {
+      pnode = ft_mem_table_get_nodep( table, address );
+      node  = *pnode;
+      if ( node )
+      {
+        if ( node->size < 0 )
+        {
+          /* this block was already freed.  This means that our memory is */
+          /* now completely corrupted!                                    */
+          ft_mem_debug_panic(
+            "memory heap corrupted (allocating freed block)" );
+        }
+        else
+        {
+          /* this block was already allocated.  This means that our memory */
+          /* is also corrupted!                                            */
+          ft_mem_debug_panic(
+            "memory heap corrupted (re-allocating allocated block)" );
+        }
+      }
+
+      /* we need to create a new node in this table */
+      node = (FT_MemNode)ft_mem_table_alloc( table, sizeof ( *node ) );
+      if ( node == NULL )
+        ft_mem_debug_panic( "not enough memory to run memory tests" );
+
+      node->address = address;
+      node->size    = size;
+
+      node->alloc_file_name = table->file_name;
+      node->alloc_line_no   = table->line_no;
+
+      node->free_file_name = NULL;
+      node->free_line_no   = 0;
+
+      node->link = pnode[0];
+
+      pnode[0] = node;
+      table->nodes++;
+
+      table->alloc_total   += size;
+      table->alloc_current += size;
+      if ( table->alloc_current > table->alloc_max )
+        table->alloc_max = table->alloc_current;
+
+      if ( table->nodes * 3 < table->size  ||
+           table->size  * 3 < table->nodes )
+        ft_mem_table_resize( table );
+    }
+  }
+
+
+  static void
+  ft_mem_table_remove( FT_MemTable  table,
+                       FT_Byte*     address )
+  {
+    if ( table )
+    {
+      FT_MemNode  *pnode, node;
+
+
+      pnode = ft_mem_table_get_nodep( table, address );
+      node  = *pnode;
+      if ( node )
+      {
+        if ( node->size < 0 )
+          ft_mem_debug_panic(
+            "freeing memory block at %p more than once at (%s:%ld)\n"
+            "block allocated at (%s:%ld) and released at (%s:%ld)",
+            address,
+            FT_FILENAME( table->file_name ), table->line_no,
+            FT_FILENAME( node->alloc_file_name ), node->alloc_line_no,
+            FT_FILENAME( node->free_file_name ), node->free_line_no );
+
+        /* we simply invert the node's size to indicate that the node */
+        /* was freed.  We also change its contents.                   */
+        FT_MEM_SET( address, 0xF3, node->size );
+
+        table->alloc_current -= node->size;
+        node->size            = -node->size;
+        node->free_file_name  = table->file_name;
+        node->free_line_no    = table->line_no;
+      }
+      else
+        ft_mem_debug_panic(
+          "trying to free unknown block at %p in (%s:%ld)\n",
+          address,
+          FT_FILENAME( table->file_name ), table->line_no );
+    }
+  }
+
+
+  extern FT_Pointer
+  ft_mem_debug_alloc( FT_Memory  memory,
+                      FT_Long    size )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+    FT_Byte*     block;
+
+
+    if ( size <= 0 )
+      ft_mem_debug_panic( "negative block size allocation (%ld)", size );
+
+    /* return NULL if the maximum number of allocations was reached */
+    if ( table->bound_count &&
+         table->alloc_count >= table->alloc_count_max )
+      return NULL;
+
+    /* return NULL if this allocation would overflow the maximum heap size */
+    if ( table->bound_total && 
+         table->alloc_current + (FT_ULong)size > table->alloc_total_max )
+      return NULL;         
+
+    block = (FT_Byte *)ft_mem_table_alloc( table, size );
+    if ( block )
+      ft_mem_table_set( table, block, (FT_ULong)size );
+
+    table->alloc_count++;
+
+    table->file_name = NULL;
+    table->line_no   = 0;
+
+    return (FT_Pointer) block;
+  }
+
+
+  extern void
+  ft_mem_debug_free( FT_Memory   memory,
+                     FT_Pointer  block )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+
+
+    if ( block == NULL )
+      ft_mem_debug_panic( "trying to free NULL in (%s:%ld)",
+                          FT_FILENAME( table->file_name ),
+                          table->line_no );
+
+    ft_mem_table_remove( table, (FT_Byte*)block );
+
+    /* we never really free the block */
+    table->file_name = NULL;
+    table->line_no   = 0;
+  }
+
+
+  extern FT_Pointer
+  ft_mem_debug_realloc( FT_Memory   memory,
+                        FT_Long     cur_size,
+                        FT_Long     new_size,
+                        FT_Pointer  block )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+    FT_MemNode   node, *pnode;
+    FT_Pointer   new_block;
+
+    const char*  file_name = FT_FILENAME( table->file_name );
+    FT_Long      line_no   = table->line_no;
+
+
+    /* the following is valid according to ANSI C */
+#if 0
+    if ( block == NULL || cur_size == 0 )
+      ft_mem_debug_panic( "trying to reallocate NULL in (%s:%ld)",
+                          file_name, line_no );
+#endif
+
+    /* while the following is allowed in ANSI C also, we abort since */
+    /* such code shouldn't be in FreeType...                         */
+    if ( new_size <= 0 )
+      ft_mem_debug_panic(
+        "trying to reallocate %p to size 0 (current is %ld) in (%s:%ld)",
+        block, cur_size, file_name, line_no );
+
+    /* check 'cur_size' value */
+    pnode = ft_mem_table_get_nodep( table, (FT_Byte*)block );
+    node  = *pnode;
+    if ( !node )
+      ft_mem_debug_panic(
+        "trying to reallocate unknown block at %p in (%s:%ld)",
+        block, file_name, line_no );
+
+    if ( node->size <= 0 )
+      ft_mem_debug_panic(
+        "trying to reallocate freed block at %p in (%s:%ld)",
+        block, file_name, line_no );
+
+    if ( node->size != cur_size )
+      ft_mem_debug_panic( "invalid ft_realloc request for %p. cur_size is "
+                          "%ld instead of %ld in (%s:%ld)",
+                          block, cur_size, node->size, file_name, line_no );
+
+    new_block = ft_mem_debug_alloc( memory, new_size );
+    if ( new_block == NULL )
+      return NULL;
+
+    ft_memcpy( new_block, block, cur_size < new_size ? cur_size : new_size );
+
+    table->file_name = file_name;
+    table->line_no   = line_no;
+
+    ft_mem_debug_free( memory, (FT_Byte*)block );
+
+    return new_block;
+  }
+
+
+  extern FT_Int
+  ft_mem_debug_init( FT_Memory  memory )
+  {
+    FT_MemTable  table;
+    FT_Int       result = 0;
+
+
+    if ( getenv( "FT2_DEBUG_MEMORY" ) )
+    {
+      table = ft_mem_table_new( memory );
+      if ( table )
+      {
+        const char*  p;
+        
+        memory->user    = table;
+        memory->alloc   = ft_mem_debug_alloc;
+        memory->realloc = ft_mem_debug_realloc;
+        memory->free    = ft_mem_debug_free;
+        
+        p = getenv( "FT2_ALLOC_TOTAL_MAX" );
+        if ( p != NULL )
+        {
+          FT_Long   total_max = ft_atol(p);
+          
+          if ( total_max > 0 )
+          {
+            table->bound_total     = 1;
+            table->alloc_total_max = (FT_ULong) total_max;
+          }
+        }
+        
+        p = getenv( "FT2_ALLOC_COUNT_MAX" );
+        if ( p != NULL )
+        {
+          FT_Long  total_count = ft_atol(p);
+          
+          if ( total_count > 0 )
+          {
+            table->bound_count     = 1;
+            table->alloc_count_max = (FT_ULong) total_count;
+          }
+        }
+
+        result = 1;
+      }
+    }
+    return result;
+  }
+
+
+  extern void
+  ft_mem_debug_done( FT_Memory  memory )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+
+
+    if ( table )
+    {
+      memory->free    = table->free;
+      memory->realloc = table->realloc;
+      memory->alloc   = table->alloc;
+
+      ft_mem_table_destroy( table );
+      memory->user = NULL;
+    }
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Alloc_Debug( FT_Memory    memory,
+                  FT_Long      size,
+                  void*       *P,
+                  const char*  file_name,
+                  FT_Long      line_no )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+
+
+    if ( table )
+    {
+      table->file_name = file_name;
+      table->line_no   = line_no;
+    }
+    return FT_Alloc( memory, size, P );
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Realloc_Debug( FT_Memory    memory,
+                    FT_Long      current,
+                    FT_Long      size,
+                    void*       *P,
+                    const char*  file_name,
+                    FT_Long      line_no )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+
+
+    if ( table )
+    {
+      table->file_name = file_name;
+      table->line_no   = line_no;
+    }
+    return FT_Realloc( memory, current, size, P );
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_QAlloc_Debug( FT_Memory    memory,
+                   FT_Long      size,
+                   void*       *P,
+                   const char*  file_name,
+                   FT_Long      line_no )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+
+
+    if ( table )
+    {
+      table->file_name = file_name;
+      table->line_no   = line_no;
+    }
+
+    return FT_QAlloc( memory, size, P );
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_QRealloc_Debug( FT_Memory    memory,
+                     FT_Long      current,
+                     FT_Long      size,
+                     void*       *P,
+                     const char*  file_name,
+                     FT_Long      line_no )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+
+
+    if ( table )
+    {
+      table->file_name = file_name;
+      table->line_no   = line_no;
+    }
+    return FT_QRealloc( memory, current, size, P );
+  }
+
+  
+  FT_BASE_DEF( void )
+  FT_Free_Debug( FT_Memory    memory,
+                 FT_Pointer   block,
+                 const char*  file_name,
+                 FT_Long      line_no )
+  {
+    FT_MemTable  table = (FT_MemTable)memory->user;
+
+
+    if ( table )
+    {
+      table->file_name = file_name;
+      table->line_no   = line_no;
+    }
+    FT_Free( memory, (void **)block );
+  }
+
+
+#else  /* !FT_DEBUG_MEMORY */
+
+  /* ANSI C doesn't like empty source files */
+  const FT_Byte  _debug_mem_dummy = 0;
+
+#endif /* !FT_DEBUG_MEMORY */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftdebug.c b/nx-X11/extras/freetype2/src/base/ftdebug.c
new file mode 100644
index 000000000..a6c18412b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftdebug.c
@@ -0,0 +1,242 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftdebug.c                                                              */
+/*                                                                         */
+/*    Debugging and logging component (body).                              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2004 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 component contains various macros and functions used to ease the */
+  /* debugging of the FreeType engine.  Its main purpose is in assertion   */
+  /* checking, tracing, and error detection.                               */
+  /*                                                                       */
+  /* There are now three debugging modes:                                  */
+  /*                                                                       */
+  /* - trace mode                                                          */
+  /*                                                                       */
+  /*   Error and trace messages are sent to the log file (which can be the */
+  /*   standard error output).                                             */
+  /*                                                                       */
+  /* - error mode                                                          */
+  /*                                                                       */
+  /*   Only error messages are generated.                                  */
+  /*                                                                       */
+  /* - release mode:                                                       */
+  /*                                                                       */
+  /*   No error message is sent or generated.  The code is free from any   */
+  /*   debugging parts.                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_INTERNAL_DEBUG_H
+
+
+#if defined( FT_DEBUG_LEVEL_ERROR )
+
+  FT_EXPORT_DEF( void )
+  FT_Message( const char*  fmt, ... )
+  {
+    va_list  ap;
+
+
+    va_start( ap, fmt );
+    vprintf( fmt, ap );
+    va_end( ap );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FT_Panic( const char*  fmt, ... )
+  {
+    va_list  ap;
+
+
+    va_start( ap, fmt );
+    vprintf( fmt, ap );
+    va_end( ap );
+
+    exit( EXIT_FAILURE );
+  }
+
+#endif /* FT_DEBUG_LEVEL_ERROR */
+
+
+
+#ifdef FT_DEBUG_LEVEL_TRACE
+
+  /* array of trace levels, initialized to 0 */
+  int  ft_trace_levels[trace_count];
+
+
+  /* define array of trace toggle names */
+#define FT_TRACE_DEF( x )  #x ,
+
+  static const char*  ft_trace_toggles[trace_count + 1] =
+  {
+#include FT_INTERNAL_TRACE_H
+    NULL
+  };
+
+#undef FT_TRACE_DEF
+
+
+  /* documentation is in ftdebug.h */
+
+  FT_EXPORT_DEF( FT_Int )
+  FT_Trace_Get_Count( void )
+  {
+    return trace_count;
+  }
+
+
+  /* documentation is in ftdebug.h */
+
+  FT_EXPORT_DEF( const char * )
+  FT_Trace_Get_Name( FT_Int  idx )
+  {
+    int  max = FT_Trace_Get_Count();
+
+
+    if ( idx < max )
+      return ft_trace_toggles[idx];
+    else
+      return NULL;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Initialize the tracing sub-system.  This is done by retrieving the    */
+  /* value of the `FT2_DEBUG' environment variable.  It must be a list of  */
+  /* toggles, separated by spaces, `;', or `,'.  Example:                  */
+  /*                                                                       */
+  /*    export FT2_DEBUG="any:3 memory:6 stream:5"                         */
+  /*                                                                       */
+  /* This requests that all levels be set to 3, except the trace level for */
+  /* the memory and stream components which are set to 6 and 5,            */
+  /* respectively.                                                         */
+  /*                                                                       */
+  /* See the file <include/freetype/internal/fttrace.h> for details of the */
+  /* available toggle names.                                               */
+  /*                                                                       */
+  /* The level must be between 0 and 6; 0 means quiet (except for serious  */
+  /* runtime errors), and 6 means _very_ verbose.                          */
+  /*                                                                       */
+  FT_BASE_DEF( void )
+  ft_debug_init( void )
+  {
+    const char*  ft2_debug = getenv( "FT2_DEBUG" );
+
+
+    if ( ft2_debug )
+    {
+      const char*  p = ft2_debug;
+      const char*  q;
+
+
+      for ( ; *p; p++ )
+      {
+        /* skip leading whitespace and separators */
+        if ( *p == ' ' || *p == '\t' || *p == ',' || *p == ';' || *p == '=' )
+          continue;
+
+        /* read toggle name, followed by ':' */
+        q = p;
+        while ( *p && *p != ':' )
+          p++;
+
+        if ( *p == ':' && p > q )
+        {
+          FT_Int  n, i, len = (FT_Int)( p - q );
+          FT_Int  level = -1, found = -1;
+
+
+          for ( n = 0; n < trace_count; n++ )
+          {
+            const char*  toggle = ft_trace_toggles[n];
+
+
+            for ( i = 0; i < len; i++ )
+            {
+              if ( toggle[i] != q[i] )
+                break;
+            }
+
+            if ( i == len && toggle[i] == 0 )
+            {
+              found = n;
+              break;
+            }
+          }
+
+          /* read level */
+          p++;
+          if ( *p )
+          {
+            level = *p++ - '0';
+            if ( level < 0 || level > 6 )
+              level = -1;
+          }
+
+          if ( found >= 0 && level >= 0 )
+          {
+            if ( found == trace_any )
+            {
+              /* special case for `any' */
+              for ( n = 0; n < trace_count; n++ )
+                ft_trace_levels[n] = level;
+            }
+            else
+              ft_trace_levels[found] = level;
+          }
+        }
+      }
+    }
+  }
+
+
+#else  /* !FT_DEBUG_LEVEL_TRACE */
+
+
+  FT_BASE_DEF( void )
+  ft_debug_init( void )
+  {
+    /* nothing */
+  }
+
+
+  FT_EXPORT_DEF( FT_Int )
+  FT_Trace_Get_Count( void )
+  {
+    return 0;
+  }
+
+
+  FT_EXPORT_DEF( const char * )
+  FT_Trace_Get_Name( FT_Int  idx )
+  {
+    FT_UNUSED( idx );
+
+    return NULL;
+  }
+
+
+#endif /* !FT_DEBUG_LEVEL_TRACE */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftgloadr.c b/nx-X11/extras/freetype2/src/base/ftgloadr.c
new file mode 100644
index 000000000..94a070673
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftgloadr.c
@@ -0,0 +1,362 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgloadr.c                                                             */
+/*                                                                         */
+/*    The FreeType glyph loader (body).                                    */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 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_GLYPH_LOADER_H
+#include FT_INTERNAL_MEMORY_H
+#include FT_INTERNAL_OBJECTS_H
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_gloader
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*****                    G L Y P H   L O A D E R                    *****/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The glyph loader is a simple object which is used to load a set of    */
+  /* glyphs easily.  It is critical for the correct loading of composites. */
+  /*                                                                       */
+  /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
+  /*                                                                       */
+  /*   loader.base     Is really the bottom of the stack.  It describes a  */
+  /*                   single glyph image made of the juxtaposition of     */
+  /*                   several glyphs (those `in the stack').              */
+  /*                                                                       */
+  /*   loader.current  Describes the top of the stack, on which a new      */
+  /*                   glyph can be loaded.                                */
+  /*                                                                       */
+  /*   Rewind          Clears the stack.                                   */
+  /*   Prepare         Set up `loader.current' for addition of a new glyph */
+  /*                   image.                                              */
+  /*   Add             Add the `current' glyph image to the `base' one,    */
+  /*                   and prepare for another one.                        */
+  /*                                                                       */
+  /* The glyph loader is now a base object.  Each driver used to           */
+  /* re-implement it in one way or the other, which wasted code and        */
+  /* energy.                                                               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* create a new glyph loader */
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_New( FT_Memory        memory,
+                      FT_GlyphLoader  *aloader )
+  {
+    FT_GlyphLoader  loader;
+    FT_Error        error;
+
+
+    if ( !FT_NEW( loader ) )
+    {
+      loader->memory = memory;
+      *aloader       = loader;
+    }
+    return error;
+  }
+
+
+  /* rewind the glyph loader - reset counters to 0 */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Rewind( FT_GlyphLoader  loader )
+  {
+    FT_GlyphLoad  base    = &loader->base;
+    FT_GlyphLoad  current = &loader->current;
+
+
+    base->outline.n_points   = 0;
+    base->outline.n_contours = 0;
+    base->num_subglyphs      = 0;
+
+    *current = *base;
+  }
+
+
+  /* reset the glyph loader, frees all allocated tables */
+  /* and starts from zero                               */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Reset( FT_GlyphLoader  loader )
+  {
+    FT_Memory memory = loader->memory;
+
+
+    FT_FREE( loader->base.outline.points );
+    FT_FREE( loader->base.outline.tags );
+    FT_FREE( loader->base.outline.contours );
+    FT_FREE( loader->base.extra_points );
+    FT_FREE( loader->base.subglyphs );
+
+    loader->max_points    = 0;
+    loader->max_contours  = 0;
+    loader->max_subglyphs = 0;
+
+    FT_GlyphLoader_Rewind( loader );
+  }
+
+
+  /* delete a glyph loader */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Done( FT_GlyphLoader  loader )
+  {
+    if ( loader )
+    {
+      FT_Memory memory = loader->memory;
+
+
+      FT_GlyphLoader_Reset( loader );
+      FT_FREE( loader );
+    }
+  }
+
+
+  /* re-adjust the `current' outline fields */
+  static void
+  FT_GlyphLoader_Adjust_Points( FT_GlyphLoader  loader )
+  {
+    FT_Outline*  base    = &loader->base.outline;
+    FT_Outline*  current = &loader->current.outline;
+
+
+    current->points   = base->points   + base->n_points;
+    current->tags     = base->tags     + base->n_points;
+    current->contours = base->contours + base->n_contours;
+
+    /* handle extra points table - if any */
+    if ( loader->use_extra )
+      loader->current.extra_points =
+        loader->base.extra_points + base->n_points;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_CreateExtra( FT_GlyphLoader  loader )
+  {
+    FT_Error   error;
+    FT_Memory  memory = loader->memory;
+
+
+    if ( !FT_NEW_ARRAY( loader->base.extra_points, loader->max_points ) )
+    {
+      loader->use_extra = 1;
+      FT_GlyphLoader_Adjust_Points( loader );
+    }
+    return error;
+  }
+
+
+  /* re-adjust the `current' subglyphs field */
+  static void
+  FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader  loader )
+  {
+    FT_GlyphLoad  base    = &loader->base;
+    FT_GlyphLoad  current = &loader->current;
+
+
+    current->subglyphs = base->subglyphs + base->num_subglyphs;
+  }
+
+
+  /* Ensure that we can add `n_points' and `n_contours' to our glyph.      */
+  /* This function reallocates its outline tables if necessary.  Note that */
+  /* it DOESN'T change the number of points within the loader!             */
+  /*                                                                       */
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_CheckPoints( FT_GlyphLoader  loader,
+                              FT_UInt         n_points,
+                              FT_UInt         n_contours )
+  {
+    FT_Memory    memory  = loader->memory;
+    FT_Error     error   = FT_Err_Ok;
+    FT_Outline*  base    = &loader->base.outline;
+    FT_Outline*  current = &loader->current.outline;
+    FT_Bool      adjust  = 1;
+
+    FT_UInt      new_max, old_max;
+
+
+    /* check points & tags */
+    new_max = base->n_points + current->n_points + n_points;
+    old_max = loader->max_points;
+
+    if ( new_max > old_max )
+    {
+      new_max = FT_PAD_CEIL( new_max, 8 );
+
+      if ( FT_RENEW_ARRAY( base->points, old_max, new_max ) ||
+           FT_RENEW_ARRAY( base->tags,   old_max, new_max ) )
+        goto Exit;
+
+      if ( loader->use_extra &&
+           FT_RENEW_ARRAY( loader->base.extra_points, old_max, new_max ) )
+        goto Exit;
+
+      adjust = 1;
+      loader->max_points = new_max;
+    }
+
+    /* check contours */
+    old_max = loader->max_contours;
+    new_max = base->n_contours + current->n_contours +
+              n_contours;
+    if ( new_max > old_max )
+    {
+      new_max = FT_PAD_CEIL( new_max, 4 );
+      if ( FT_RENEW_ARRAY( base->contours, old_max, new_max ) )
+        goto Exit;
+
+      adjust = 1;
+      loader->max_contours = new_max;
+    }
+
+    if ( adjust )
+      FT_GlyphLoader_Adjust_Points( loader );
+
+  Exit:
+    return error;
+  }
+
+
+  /* Ensure that we can add `n_subglyphs' to our glyph. this function */
+  /* reallocates its subglyphs table if necessary.  Note that it DOES */
+  /* NOT change the number of subglyphs within the loader!            */
+  /*                                                                  */
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_CheckSubGlyphs( FT_GlyphLoader  loader,
+                                 FT_UInt         n_subs )
+  {
+    FT_Memory     memory = loader->memory;
+    FT_Error      error  = FT_Err_Ok;
+    FT_UInt       new_max, old_max;
+
+    FT_GlyphLoad  base    = &loader->base;
+    FT_GlyphLoad  current = &loader->current;
+
+
+    new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
+    old_max = loader->max_subglyphs;
+    if ( new_max > old_max )
+    {
+      new_max = FT_PAD_CEIL( new_max, 2 );
+      if ( FT_RENEW_ARRAY( base->subglyphs, old_max, new_max ) )
+        goto Exit;
+
+      loader->max_subglyphs = new_max;
+
+      FT_GlyphLoader_Adjust_Subglyphs( loader );
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* prepare loader for the addition of a new glyph on top of the base one */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Prepare( FT_GlyphLoader  loader )
+  {
+    FT_GlyphLoad  current = &loader->current;
+
+
+    current->outline.n_points   = 0;
+    current->outline.n_contours = 0;
+    current->num_subglyphs      = 0;
+
+    FT_GlyphLoader_Adjust_Points   ( loader );
+    FT_GlyphLoader_Adjust_Subglyphs( loader );
+  }
+
+
+  /* add current glyph to the base image - and prepare for another */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Add( FT_GlyphLoader  loader )
+  {
+    FT_GlyphLoad  base    = &loader->base;
+    FT_GlyphLoad  current = &loader->current;
+
+    FT_UInt       n_curr_contours = current->outline.n_contours;
+    FT_UInt       n_base_points   = base->outline.n_points;
+    FT_UInt       n;
+
+
+    base->outline.n_points =
+      (short)( base->outline.n_points + current->outline.n_points );
+    base->outline.n_contours =
+      (short)( base->outline.n_contours + current->outline.n_contours );
+
+    base->num_subglyphs += current->num_subglyphs;
+
+    /* adjust contours count in newest outline */
+    for ( n = 0; n < n_curr_contours; n++ )
+      current->outline.contours[n] =
+        (short)( current->outline.contours[n] + n_base_points );
+
+    /* prepare for another new glyph image */
+    FT_GlyphLoader_Prepare( loader );
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_CopyPoints( FT_GlyphLoader  target,
+                             FT_GlyphLoader  source )
+  {
+    FT_Error  error;
+    FT_UInt   num_points   = source->base.outline.n_points;
+    FT_UInt   num_contours = source->base.outline.n_contours;
+
+
+    error = FT_GlyphLoader_CheckPoints( target, num_points, num_contours );
+    if ( !error )
+    {
+      FT_Outline*  out = &target->base.outline;
+      FT_Outline*  in  = &source->base.outline;
+
+
+      FT_ARRAY_COPY( out->points, in->points,
+                     num_points );
+      FT_ARRAY_COPY( out->tags, in->tags,
+                     num_points );
+      FT_ARRAY_COPY( out->contours, in->contours,
+                     num_contours );
+
+      /* do we need to copy the extra points? */
+      if ( target->use_extra && source->use_extra )
+        FT_ARRAY_COPY( target->base.extra_points, source->base.extra_points,
+                       num_points );
+
+      out->n_points   = (short)num_points;
+      out->n_contours = (short)num_contours;
+
+      FT_GlyphLoader_Adjust_Points( target );
+    }
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftglyph.c b/nx-X11/extras/freetype2/src/base/ftglyph.c
new file mode 100644
index 000000000..1b22ab6b3
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftglyph.c
@@ -0,0 +1,712 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftglyph.c                                                              */
+/*                                                                         */
+/*    FreeType convenience functions to handle glyphs (body).              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 contains the definition of several convenience functions   */
+  /*  that can be used by client applications to easily retrieve glyph     */
+  /*  bitmaps and outlines from a given face.                              */
+  /*                                                                       */
+  /*  These functions should be optional if you are writing a font server  */
+  /*  or text layout engine on top of FreeType.  However, they are pretty  */
+  /*  handy for many other simple uses of the library.                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_GLYPH_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_OBJECTS_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_glyph
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****   Convenience functions                                         ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* documentation is in ftglyph.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Matrix_Multiply( const FT_Matrix*  a,
+                      FT_Matrix        *b )
+  {
+    FT_Fixed  xx, xy, yx, yy;
+
+
+    if ( !a || !b )
+      return;
+
+    xx = FT_MulFix( a->xx, b->xx ) + FT_MulFix( a->xy, b->yx );
+    xy = FT_MulFix( a->xx, b->xy ) + FT_MulFix( a->xy, b->yy );
+    yx = FT_MulFix( a->yx, b->xx ) + FT_MulFix( a->yy, b->yx );
+    yy = FT_MulFix( a->yx, b->xy ) + FT_MulFix( a->yy, b->yy );
+
+    b->xx = xx;  b->xy = xy;
+    b->yx = yx;  b->yy = yy;
+  }
+
+
+  /* documentation is in ftglyph.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Matrix_Invert( FT_Matrix*  matrix )
+  {
+    FT_Pos  delta, xx, yy;
+
+
+    if ( !matrix )
+      return FT_Err_Invalid_Argument;
+
+    /* compute discriminant */
+    delta = FT_MulFix( matrix->xx, matrix->yy ) -
+            FT_MulFix( matrix->xy, matrix->yx );
+
+    if ( !delta )
+      return FT_Err_Invalid_Argument;  /* matrix can't be inverted */
+
+    matrix->xy = - FT_DivFix( matrix->xy, delta );
+    matrix->yx = - FT_DivFix( matrix->yx, delta );
+
+    xx = matrix->xx;
+    yy = matrix->yy;
+
+    matrix->xx = FT_DivFix( yy, delta );
+    matrix->yy = FT_DivFix( xx, delta );
+
+    return FT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****   FT_BitmapGlyph support                                        ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static FT_Error
+  ft_bitmap_copy( FT_Memory   memory,
+                  FT_Bitmap*  source,
+                  FT_Bitmap*  target )
+  {
+    FT_Error  error;
+    FT_Int    pitch = source->pitch;
+    FT_ULong  size;
+
+
+    *target = *source;
+
+    if ( pitch < 0 )
+      pitch = -pitch;
+
+    size = (FT_ULong)( pitch * source->rows );
+
+    if ( !FT_ALLOC( target->buffer, size ) )
+      FT_MEM_COPY( target->buffer, source->buffer, size );
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ft_bitmap_glyph_init( FT_Glyph      bitmap_glyph,
+                        FT_GlyphSlot  slot )
+  {
+    FT_BitmapGlyph  glyph   = (FT_BitmapGlyph)bitmap_glyph;
+    FT_Error        error   = FT_Err_Ok;
+    FT_Library      library = FT_GLYPH( glyph )->library;
+    FT_Memory       memory  = library->memory;
+
+
+    if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
+    {
+      error = FT_Err_Invalid_Glyph_Format;
+      goto Exit;
+    }
+
+    /* grab the bitmap in the slot - do lazy copying whenever possible */
+    glyph->bitmap = slot->bitmap;
+    glyph->left   = slot->bitmap_left;
+    glyph->top    = slot->bitmap_top;
+
+    if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
+      slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
+    else
+    {
+      /* copy the bitmap into a new buffer */
+      error = ft_bitmap_copy( memory, &slot->bitmap, &glyph->bitmap );
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ft_bitmap_glyph_copy( FT_Glyph  bitmap_source,
+                        FT_Glyph  bitmap_target )
+  {
+    FT_BitmapGlyph  source = (FT_BitmapGlyph)bitmap_source;
+    FT_BitmapGlyph  target = (FT_BitmapGlyph)bitmap_target;
+    FT_Memory       memory = bitmap_source->library->memory;
+
+
+    target->left = source->left;
+    target->top  = source->top;
+
+    return ft_bitmap_copy( memory, &source->bitmap, &target->bitmap );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_bitmap_glyph_done( FT_Glyph  bitmap_glyph )
+  {
+    FT_BitmapGlyph  glyph  = (FT_BitmapGlyph)bitmap_glyph;
+    FT_Memory       memory = FT_GLYPH( glyph )->library->memory;
+
+
+    FT_FREE( glyph->bitmap.buffer );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_bitmap_glyph_bbox( FT_Glyph  bitmap_glyph,
+                        FT_BBox*  cbox )
+  {
+    FT_BitmapGlyph  glyph = (FT_BitmapGlyph)bitmap_glyph;
+
+
+    cbox->xMin = glyph->left << 6;
+    cbox->xMax = cbox->xMin + ( glyph->bitmap.width << 6 );
+    cbox->yMax = glyph->top << 6;
+    cbox->yMin = cbox->yMax - ( glyph->bitmap.rows << 6 );
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Glyph_Class  ft_bitmap_glyph_class =
+  {
+    sizeof ( FT_BitmapGlyphRec ),
+    FT_GLYPH_FORMAT_BITMAP,
+
+    ft_bitmap_glyph_init,
+    ft_bitmap_glyph_done,
+    ft_bitmap_glyph_copy,
+    0,                          /* FT_Glyph_TransformFunc */
+    ft_bitmap_glyph_bbox,
+    0                           /* FT_Glyph_PrepareFunc   */
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****   FT_OutlineGlyph support                                       ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ft_outline_glyph_init( FT_Glyph      outline_glyph,
+                         FT_GlyphSlot  slot )
+  {
+    FT_OutlineGlyph  glyph   = (FT_OutlineGlyph)outline_glyph;
+    FT_Error         error   = FT_Err_Ok;
+    FT_Library       library = FT_GLYPH( glyph )->library;
+    FT_Outline*      source  = &slot->outline;
+    FT_Outline*      target  = &glyph->outline;
+
+
+    /* check format in glyph slot */
+    if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )
+    {
+      error = FT_Err_Invalid_Glyph_Format;
+      goto Exit;
+    }
+
+    /* allocate new outline */
+    error = FT_Outline_New( library, source->n_points, source->n_contours,
+                            &glyph->outline );
+    if ( error )
+      goto Exit;
+
+    /* copy it */
+    FT_ARRAY_COPY( target->points, source->points, source->n_points );
+
+    FT_ARRAY_COPY( target->tags, source->tags, source->n_points );
+
+    FT_ARRAY_COPY( target->contours, source->contours, source->n_contours );
+
+    /* copy all flags, except the `FT_OUTLINE_OWNER' one */
+    target->flags = source->flags | FT_OUTLINE_OWNER;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_outline_glyph_done( FT_Glyph  outline_glyph )
+  {
+    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
+
+
+    FT_Outline_Done( FT_GLYPH( glyph )->library, &glyph->outline );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ft_outline_glyph_copy( FT_Glyph  outline_source,
+                         FT_Glyph  outline_target )
+  {
+    FT_OutlineGlyph  source  = (FT_OutlineGlyph)outline_source;
+    FT_OutlineGlyph  target  = (FT_OutlineGlyph)outline_target;
+    FT_Error         error;
+    FT_Library       library = FT_GLYPH( source )->library;
+
+
+    error = FT_Outline_New( library, source->outline.n_points,
+                            source->outline.n_contours, &target->outline );
+    if ( !error )
+      FT_Outline_Copy( &source->outline, &target->outline );
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_outline_glyph_transform( FT_Glyph    outline_glyph,
+                              FT_Matrix*  matrix,
+                              FT_Vector*  delta )
+  {
+    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
+
+
+    if ( matrix )
+      FT_Outline_Transform( &glyph->outline, matrix );
+
+    if ( delta )
+      FT_Outline_Translate( &glyph->outline, delta->x, delta->y );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ft_outline_glyph_bbox( FT_Glyph  outline_glyph,
+                         FT_BBox*  bbox )
+  {
+    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
+
+
+    FT_Outline_Get_CBox( &glyph->outline, bbox );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ft_outline_glyph_prepare( FT_Glyph      outline_glyph,
+                            FT_GlyphSlot  slot )
+  {
+    FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
+
+
+    slot->format         = FT_GLYPH_FORMAT_OUTLINE;
+    slot->outline        = glyph->outline;
+    slot->outline.flags &= ~FT_OUTLINE_OWNER;
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Glyph_Class  ft_outline_glyph_class =
+  {
+    sizeof ( FT_OutlineGlyphRec ),
+    FT_GLYPH_FORMAT_OUTLINE,
+
+    ft_outline_glyph_init,
+    ft_outline_glyph_done,
+    ft_outline_glyph_copy,
+    ft_outline_glyph_transform,
+    ft_outline_glyph_bbox,
+    ft_outline_glyph_prepare
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****   FT_Glyph class and API                                        ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+   static FT_Error
+   ft_new_glyph( FT_Library             library,
+                 const FT_Glyph_Class*  clazz,
+                 FT_Glyph*              aglyph )
+   {
+     FT_Memory  memory = library->memory;
+     FT_Error   error;
+     FT_Glyph   glyph;
+
+
+     *aglyph = 0;
+
+     if ( !FT_ALLOC( glyph, clazz->glyph_size ) )
+     {
+       glyph->library = library;
+       glyph->clazz   = clazz;
+       glyph->format  = clazz->glyph_format;
+
+       *aglyph = glyph;
+     }
+
+     return error;
+   }
+
+
+  /* documentation is in ftglyph.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Glyph_Copy( FT_Glyph   source,
+                 FT_Glyph  *target )
+  {
+    FT_Glyph               copy;
+    FT_Error               error;
+    const FT_Glyph_Class*  clazz;
+
+
+    /* check arguments */
+    if ( !target || !source || !source->clazz )
+    {
+      error = FT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    *target = 0;
+
+    clazz = source->clazz;
+    error = ft_new_glyph( source->library, clazz, &copy );
+    if ( error )
+      goto Exit;
+
+    copy->advance = source->advance;
+    copy->format  = source->format;
+
+    if ( clazz->glyph_copy )
+      error = clazz->glyph_copy( source, copy );
+
+    if ( error )
+      FT_Done_Glyph( copy );
+    else
+      *target = copy;
+
+  Exit:
+    return error;
+  }
+
+
+  /* documentation is in ftglyph.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_Glyph( FT_GlyphSlot  slot,
+                FT_Glyph     *aglyph )
+  {
+    FT_Library  library;
+    FT_Error    error;
+    FT_Glyph    glyph;
+
+    const FT_Glyph_Class*  clazz = 0;
+
+
+    if ( !slot )
+      return FT_Err_Invalid_Slot_Handle;
+
+    library = slot->library;
+
+    if ( !aglyph )
+      return FT_Err_Invalid_Argument;
+
+    /* if it is a bitmap, that's easy :-) */
+    if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
+      clazz = &ft_bitmap_glyph_class;
+
+    /* it it is an outline too */
+    else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
+      clazz = &ft_outline_glyph_class;
+
+    else
+    {
+      /* try to find a renderer that supports the glyph image format */
+      FT_Renderer  render = FT_Lookup_Renderer( library, slot->format, 0 );
+
+
+      if ( render )
+        clazz = &render->glyph_class;
+    }
+
+    if ( !clazz )
+    {
+      error = FT_Err_Invalid_Glyph_Format;
+      goto Exit;
+    }
+
+    /* create FT_Glyph object */
+    error = ft_new_glyph( library, clazz, &glyph );
+    if ( error )
+      goto Exit;
+
+    /* copy advance while converting it to 16.16 format */
+    glyph->advance.x = slot->advance.x << 10;
+    glyph->advance.y = slot->advance.y << 10;
+
+    /* now import the image from the glyph slot */
+    error = clazz->glyph_init( glyph, slot );
+
+    /* if an error occurred, destroy the glyph */
+    if ( error )
+      FT_Done_Glyph( glyph );
+    else
+      *aglyph = glyph;
+
+  Exit:
+    return error;
+  }
+
+
+  /* documentation is in ftglyph.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Glyph_Transform( FT_Glyph    glyph,
+                      FT_Matrix*  matrix,
+                      FT_Vector*  delta )
+  {
+    const FT_Glyph_Class*  clazz;
+    FT_Error               error = FT_Err_Ok;
+
+
+    if ( !glyph || !glyph->clazz )
+      error = FT_Err_Invalid_Argument;
+    else
+    {
+      clazz = glyph->clazz;
+      if ( clazz->glyph_transform )
+      {
+        /* transform glyph image */
+        clazz->glyph_transform( glyph, matrix, delta );
+
+        /* transform advance vector */
+        if ( matrix )
+          FT_Vector_Transform( &glyph->advance, matrix );
+      }
+      else
+        error = FT_Err_Invalid_Glyph_Format;
+    }
+    return error;
+  }
+
+
+  /* documentation is in ftglyph.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Glyph_Get_CBox( FT_Glyph  glyph,
+                     FT_UInt   bbox_mode,
+                     FT_BBox  *acbox )
+  {
+    const FT_Glyph_Class*  clazz;
+
+
+    if ( !acbox )
+      return;
+
+    acbox->xMin = acbox->yMin = acbox->xMax = acbox->yMax = 0;
+
+    if ( !glyph || !glyph->clazz )
+      return;
+    else
+    {
+      clazz = glyph->clazz;
+      if ( !clazz->glyph_bbox )
+        return;
+      else
+      {
+        /* retrieve bbox in 26.6 coordinates */
+        clazz->glyph_bbox( glyph, acbox );
+
+        /* perform grid fitting if needed */
+        if ( bbox_mode == FT_GLYPH_BBOX_GRIDFIT ||
+             bbox_mode == FT_GLYPH_BBOX_PIXELS  )
+        {
+          acbox->xMin = FT_PIX_FLOOR( acbox->xMin );
+          acbox->yMin = FT_PIX_FLOOR( acbox->yMin );
+          acbox->xMax = FT_PIX_CEIL( acbox->xMax );
+          acbox->yMax = FT_PIX_CEIL( acbox->yMax );
+        }
+
+        /* convert to integer pixels if needed */
+        if ( bbox_mode == FT_GLYPH_BBOX_TRUNCATE ||
+             bbox_mode == FT_GLYPH_BBOX_PIXELS   )
+        {
+          acbox->xMin >>= 6;
+          acbox->yMin >>= 6;
+          acbox->xMax >>= 6;
+          acbox->yMax >>= 6;
+        }
+      }
+    }
+    return;
+  }
+
+
+  /* documentation is in ftglyph.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Glyph_To_Bitmap( FT_Glyph*       the_glyph,
+                      FT_Render_Mode  render_mode,
+                      FT_Vector*      origin,
+                      FT_Bool         destroy )
+  {
+    FT_GlyphSlotRec           dummy;
+    FT_GlyphSlot_InternalRec  dummy_internal;
+    FT_Error                  error = FT_Err_Ok;
+    FT_Glyph                  glyph;
+    FT_BitmapGlyph            bitmap = NULL;
+
+    const FT_Glyph_Class*     clazz;
+
+
+    /* check argument */
+    if ( !the_glyph )
+      goto Bad;
+
+    /* we render the glyph into a glyph bitmap using a `dummy' glyph slot */
+    /* then calling FT_Render_Glyph_Internal()                            */
+
+    glyph = *the_glyph;
+    if ( !glyph )
+      goto Bad;
+
+    clazz = glyph->clazz;
+
+    /* when called with a bitmap glyph, do nothing and return successfully */
+    if ( clazz == &ft_bitmap_glyph_class )
+      goto Exit;
+
+    if ( !clazz || !clazz->glyph_prepare )
+      goto Bad;
+
+    FT_MEM_ZERO( &dummy, sizeof ( dummy ) );
+    FT_MEM_ZERO( &dummy_internal, sizeof ( dummy_internal ) );
+    dummy.internal = &dummy_internal;
+    dummy.library  = glyph->library;
+    dummy.format   = clazz->glyph_format;
+
+    /* create result bitmap glyph */
+    error = ft_new_glyph( glyph->library, &ft_bitmap_glyph_class,
+                          (FT_Glyph*)&bitmap );
+    if ( error )
+      goto Exit;
+
+#if 1
+    /* if `origin' is set, translate the glyph image */
+    if ( origin )
+      FT_Glyph_Transform( glyph, 0, origin );
+#else
+    FT_UNUSED( origin );
+#endif
+
+    /* prepare dummy slot for rendering */
+    error = clazz->glyph_prepare( glyph, &dummy );
+    if ( !error )
+      error = FT_Render_Glyph_Internal( glyph->library, &dummy, render_mode );
+
+#if 1
+    if ( !destroy && origin )
+    {
+      FT_Vector  v;
+
+
+      v.x = -origin->x;
+      v.y = -origin->y;
+      FT_Glyph_Transform( glyph, 0, &v );
+    }
+#endif
+
+    if ( error )
+      goto Exit;
+
+    /* in case of success, copy the bitmap to the glyph bitmap */
+    error = ft_bitmap_glyph_init( (FT_Glyph)bitmap, &dummy );
+    if ( error )
+      goto Exit;
+
+    /* copy advance */
+    bitmap->root.advance = glyph->advance;
+
+    if ( destroy )
+      FT_Done_Glyph( glyph );
+
+    *the_glyph = FT_GLYPH( bitmap );
+
+  Exit:
+    if ( error && bitmap )
+      FT_Done_Glyph( FT_GLYPH( bitmap ) );
+
+    return error;
+
+  Bad:
+    error = FT_Err_Invalid_Argument;
+    goto Exit;
+  }
+
+
+  /* documentation is in ftglyph.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Done_Glyph( FT_Glyph  glyph )
+  {
+    if ( glyph )
+    {
+      FT_Memory              memory = glyph->library->memory;
+      const FT_Glyph_Class*  clazz  = glyph->clazz;
+
+
+      if ( clazz->glyph_done )
+        clazz->glyph_done( glyph );
+
+      FT_FREE( glyph );
+    }
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftinit.c b/nx-X11/extras/freetype2/src/base/ftinit.c
new file mode 100644
index 000000000..79ba9f0bd
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftinit.c
@@ -0,0 +1,161 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftinit.c                                                               */
+/*                                                                         */
+/*    FreeType initialization layer (body).                                */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  The purpose of this file is to implement the following two           */
+  /*  functions:                                                           */
+  /*                                                                       */
+  /*  FT_Add_Default_Modules():                                            */
+  /*     This function is used to add the set of default modules to a      */
+  /*     fresh new library object.  The set is taken from the header file  */
+  /*     `freetype/config/ftmodule.h'.  See the document `FreeType 2.0     */
+  /*     Build System' for more information.                               */
+  /*                                                                       */
+  /*  FT_Init_FreeType():                                                  */
+  /*     This function creates a system object for the current platform,   */
+  /*     builds a library out of it, then calls FT_Default_Drivers().      */
+  /*                                                                       */
+  /*  Note that even if FT_Init_FreeType() uses the implementation of the  */
+  /*  system object defined at build time, client applications are still   */
+  /*  able to provide their own `ftsystem.c'.                              */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_MODULE_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_init
+
+#undef  FT_USE_MODULE
+#ifdef __cplusplus
+#define FT_USE_MODULE( x )  extern "C" const FT_Module_Class*  x;
+#else
+#define FT_USE_MODULE( x )  extern const FT_Module_Class*  x;
+#endif
+
+
+#include FT_CONFIG_MODULES_H
+
+
+#undef  FT_USE_MODULE
+#define FT_USE_MODULE( x )  (const FT_Module_Class*)&x,
+
+  static
+  const FT_Module_Class*  const ft_default_modules[] =
+  {
+#include FT_CONFIG_MODULES_H
+    0
+  };
+
+
+  /* documentation is in ftmodule.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Add_Default_Modules( FT_Library  library )
+  {
+    FT_Error                       error;
+    const FT_Module_Class* const*  cur;
+
+
+    /* test for valid `library' delayed to FT_Add_Module() */
+
+    cur = ft_default_modules;
+    while ( *cur )
+    {
+      error = FT_Add_Module( library, *cur );
+      /* notify errors, but don't stop */
+      if ( error )
+      {
+        FT_ERROR(( "FT_Add_Default_Module: Cannot install `%s', error = 0x%x\n",
+                   (*cur)->module_name, error ));
+      }
+      cur++;
+    }
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Init_FreeType( FT_Library  *alibrary )
+  {
+    FT_Error   error;
+    FT_Memory  memory;
+
+
+    /* First of all, allocate a new system object -- this function is part */
+    /* of the system-specific component, i.e. `ftsystem.c'.                */
+
+    memory = FT_New_Memory();
+    if ( !memory )
+    {
+      FT_ERROR(( "FT_Init_FreeType: cannot find memory manager\n" ));
+      return FT_Err_Unimplemented_Feature;
+    }
+
+    /* build a library out of it, then fill it with the set of */
+    /* default drivers.                                        */
+
+    error = FT_New_Library( memory, alibrary );
+    if ( !error )
+    {
+      (*alibrary)->version_major = FREETYPE_MAJOR;
+      (*alibrary)->version_minor = FREETYPE_MINOR;
+      (*alibrary)->version_patch = FREETYPE_PATCH;
+
+      FT_Add_Default_Modules( *alibrary );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Done_FreeType( FT_Library  library )
+  {
+    if ( library )
+    {
+      FT_Memory  memory = library->memory;
+
+
+      /* Discard the library object */
+      FT_Done_Library( library );
+
+      /* discard memory manager */
+      FT_Done_Memory( memory );
+    }
+
+    return FT_Err_Ok;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftmac.c b/nx-X11/extras/freetype2/src/base/ftmac.c
new file mode 100644
index 000000000..c71475382
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftmac.c
@@ -0,0 +1,1092 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmac.c                                                                */
+/*                                                                         */
+/*    Mac FOND support.  Written by just@letterror.com.                    */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 by                               */
+/*  Just van Rossum, 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*
+    Notes
+
+    Mac suitcase files can (and often do!) contain multiple fonts.  To
+    support this I use the face_index argument of FT_(Open|New)_Face()
+    functions, and pretend the suitcase file is a collection.
+
+    Warning: Although the FOND driver sets face->num_faces field to the
+    number of available fonts, but the Type 1 driver sets it to 1 anyway.
+    So this field is currently not reliable, and I don't see a clean way
+    to  resolve that.  The face_index argument translates to
+
+      Get1IndResource( 'FOND', face_index + 1 );
+
+    so clients should figure out the resource index of the FOND.
+    (I'll try to provide some example code for this at some point.)
+
+    The Mac FOND support works roughly like this:
+
+    - Check whether the offered stream points to a Mac suitcase file.
+      This is done by checking the file type: it has to be 'FFIL' or 'tfil'.
+      The stream that gets passed to our init_face() routine is a stdio
+      stream, which isn't usable for us, since the FOND resources live
+      in the resource fork.  So we just grab the stream->pathname field.
+
+    - Read the FOND resource into memory, then check whether there is
+      a TrueType font and/or(!) a Type 1 font available.
+
+    - If there is a Type 1 font available (as a separate 'LWFN' file),
+      read its data into memory, massage it slightly so it becomes
+      PFB data, wrap it into a memory stream, load the Type 1 driver
+      and delegate the rest of the work to it by calling FT_Open_Face().
+      (XXX TODO: after this has been done, the kerning data from the FOND
+      resource should be appended to the face: On the Mac there are usually
+      no AFM files available.  However, this is tricky since we need to map
+      Mac char codes to ps glyph names to glyph ID's...)
+
+    - If there is a TrueType font (an 'sfnt' resource), read it into
+      memory, wrap it into a memory stream, load the TrueType driver
+      and delegate the rest of the work to it, by calling FT_Open_Face().
+  */
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_INTERNAL_STREAM_H
+
+#ifdef __GNUC__
+#include "../truetype/ttobjs.h"
+#include "../type1/t1objs.h"
+  /* This is for Mac OS X.  Without redefinition, OS_INLINE */
+  /* expands to `static inline' which doesn't survive the   */
+  /* -ansi compilation flag of GCC.                         */
+#define OS_INLINE  static __inline__
+#include <Carbon/Carbon.h>
+#else
+#include "truetype/ttobjs.h"
+#include "type1/t1objs.h"
+#include <Resources.h>
+#include <Fonts.h>
+#include <Errors.h>
+#include <Files.h>
+#include <TextUtils.h>
+#endif
+
+#if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
+#include <FSp_fopen.h>
+#endif
+
+#include FT_MAC_H
+
+
+  /* Set PREFER_LWFN to 1 if LWFN (Type 1) is preferred over
+     TrueType in case *both* are available (this is not common,
+     but it *is* possible). */
+#ifndef PREFER_LWFN
+#define PREFER_LWFN 1
+#endif
+
+
+#if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
+
+#define STREAM_FILE( stream )  ( (FILE*)stream->descriptor.pointer )
+
+
+  FT_CALLBACK_DEF( void )
+  ft_FSp_stream_close( FT_Stream  stream )
+  {
+    fclose( STREAM_FILE( stream ) );
+
+    stream->descriptor.pointer = NULL;
+    stream->size               = 0;
+    stream->base               = 0;
+  }
+
+
+  FT_CALLBACK_DEF( unsigned long )
+  ft_FSp_stream_io( FT_Stream       stream,
+                    unsigned long   offset,
+                    unsigned char*  buffer,
+                    unsigned long   count )
+  {
+    FILE*  file;
+
+
+    file = STREAM_FILE( stream );
+
+    fseek( file, offset, SEEK_SET );
+
+    return (unsigned long)fread( buffer, 1, count, file );
+  }
+
+#endif  /* __MWERKS__ && !TARGET_RT_MAC_MACHO */
+
+
+  /* Given a pathname, fill in a file spec. */
+  static int
+  file_spec_from_path( const char*  pathname,
+                       FSSpec*      spec )
+  {
+
+#if !TARGET_API_MAC_OS8 && \
+    !( defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO )
+
+    OSErr  e;
+    FSRef  ref;
+
+
+    e = FSPathMakeRef( (UInt8 *)pathname, &ref, false /* not a directory */ );
+    if ( e == noErr )
+      e = FSGetCatalogInfo( &ref, kFSCatInfoNone, NULL, NULL, spec, NULL );
+
+    return ( e == noErr ) ? 0 : (-1);
+
+#else
+
+    Str255    p_path;
+    FT_ULong  path_len;
+
+
+    /* convert path to a pascal string */
+    path_len = ft_strlen( pathname );
+    if ( path_len > 255 )
+      return -1;
+    p_path[0] = (unsigned char)path_len;
+    ft_strncpy( (char*)p_path + 1, pathname, path_len );
+
+    if ( FSMakeFSSpec( 0, 0, p_path, spec ) != noErr )
+      return -1;
+    else
+      return 0;
+
+#endif
+
+  }
+
+
+  /* Return the file type of the file specified by spec. */
+  static OSType
+  get_file_type( const FSSpec*  spec )
+  {
+    FInfo  finfo;
+
+
+    if ( FSpGetFInfo( spec, &finfo ) != noErr )
+      return 0;  /* file might not exist */
+
+    return finfo.fdType;
+  }
+
+
+  /* Given a PostScript font name, create the Macintosh LWFN file name. */
+  static void
+  create_lwfn_name( char*   ps_name,
+                    Str255  lwfn_file_name )
+  {
+    int       max = 5, count = 0;
+    FT_Byte*  p = lwfn_file_name;
+    FT_Byte*  q = (FT_Byte*)ps_name;
+
+
+    lwfn_file_name[0] = 0;
+
+    while ( *q )
+    {
+      if ( ft_isupper( *q ) )
+      {
+        if ( count )
+          max = 3;
+        count = 0;
+      }
+      if ( count < max && ( ft_isalnum( *q ) || *q == '_' ) )
+      {
+        *++p = *q;
+        lwfn_file_name[0]++;
+        count++;
+      }
+      q++;
+    }
+  }
+
+
+  /* Given a file reference, answer its location as a vRefNum
+     and a dirID. */
+  static FT_Error
+  get_file_location( short           ref_num,
+                     short*          v_ref_num,
+                     long*           dir_id,
+                     unsigned char*  file_name )
+  {
+    FCBPBRec  pb;
+    OSErr     error;
+
+
+    pb.ioNamePtr = file_name;
+    pb.ioVRefNum = 0;
+    pb.ioRefNum  = ref_num;
+    pb.ioFCBIndx = 0;
+
+    error = PBGetFCBInfoSync( &pb );
+    if ( error == noErr )
+    {
+      *v_ref_num = pb.ioFCBVRefNum;
+      *dir_id    = pb.ioFCBParID;
+    }
+    return error;
+  }
+
+
+  /* Make a file spec for an LWFN file from a FOND resource and
+     a file name. */
+  static FT_Error
+  make_lwfn_spec( Handle               fond,
+                  const unsigned char* file_name,
+                  FSSpec*              spec )
+  {
+    FT_Error  error;
+    short     ref_num, v_ref_num;
+    long      dir_id;
+    Str255    fond_file_name;
+
+
+    ref_num = HomeResFile( fond );
+
+    error = ResError();
+    if ( !error )
+      error = get_file_location( ref_num, &v_ref_num,
+                                 &dir_id, fond_file_name );
+    if ( !error )
+      error = FSMakeFSSpec( v_ref_num, dir_id, file_name, spec );
+
+    return error;
+  }
+
+
+  static short
+  count_faces_sfnt( char *fond_data )
+  {
+    /* The count is 1 greater than the value in the FOND.  */
+    /* Isn't that cute? :-)                                */
+
+    return 1 + *( (short *)( fond_data + sizeof ( FamRec ) ) );
+  }
+
+
+  /* Look inside the FOND data, answer whether there should be an SFNT
+     resource, and answer the name of a possible LWFN Type 1 file.
+
+     Thanks to Paul Miller (paulm@profoundeffects.com) for the fix
+     to load a face OTHER than the first one in the FOND!
+  */
+
+
+  static void
+  parse_fond( char*   fond_data,
+              short*  have_sfnt,
+              short*  sfnt_id,
+              Str255  lwfn_file_name,
+              short   face_index )
+  {
+    AsscEntry*  assoc;
+    AsscEntry*  base_assoc;
+    FamRec*     fond;
+
+
+    *sfnt_id          = 0;
+    *have_sfnt        = 0;
+    lwfn_file_name[0] = 0;
+
+    fond       = (FamRec*)fond_data;
+    assoc      = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );
+    base_assoc = assoc;
+
+    /* Let's do a little range checking before we get too excited here */
+    if ( face_index < count_faces_sfnt( fond_data ) )
+    {
+      assoc += face_index;        /* add on the face_index! */
+
+      /* if the face at this index is not scalable,
+         fall back to the first one (old behavior) */
+      if ( assoc->fontSize == 0 )
+      {
+        *have_sfnt = 1;
+        *sfnt_id   = assoc->fontID;
+      }
+      else if ( base_assoc->fontSize == 0 )
+      {
+        *have_sfnt = 1;
+        *sfnt_id   = base_assoc->fontID;
+      }
+    }
+
+    if ( fond->ffStylOff )
+    {
+      unsigned char*  p = (unsigned char*)fond_data;
+      StyleTable*     style;
+      unsigned short  string_count;
+      char            ps_name[256];
+      unsigned char*  names[64];
+      int             i;
+
+
+      p += fond->ffStylOff;
+      style = (StyleTable*)p;
+      p += sizeof ( StyleTable );
+      string_count = *(unsigned short*)(p);
+      p += sizeof ( short );
+
+      for ( i = 0 ; i < string_count && i < 64; i++ )
+      {
+        names[i] = p;
+        p += names[i][0];
+        p++;
+      }
+
+      {
+        size_t  ps_name_len = (size_t)names[0][0];
+
+
+        if ( ps_name_len != 0 )
+        {
+          ft_memcpy(ps_name, names[0] + 1, ps_name_len);
+          ps_name[ps_name_len] = 0;
+        }
+        if ( style->indexes[0] > 1 )
+        {
+          unsigned char*  suffixes = names[style->indexes[0] - 1];
+
+
+          for ( i = 1; i <= suffixes[0]; i++ )
+          {
+            unsigned char*  s;
+            size_t          j = suffixes[i] - 1;
+
+
+            if ( j < string_count && ( s = names[j] ) != NULL )
+            {
+              size_t  s_len = (size_t)s[0];
+
+
+              if ( s_len != 0 && ps_name_len + s_len < sizeof ( ps_name ) )
+              {
+                ft_memcpy( ps_name + ps_name_len, s + 1, s_len );
+                ps_name_len += s_len;
+                ps_name[ps_name_len] = 0;
+              }
+            }
+          }
+        }
+      }
+
+      create_lwfn_name( ps_name, lwfn_file_name );
+    }
+  }
+
+
+  static short
+  count_faces( Handle  fond )
+  {
+    short   sfnt_id, have_sfnt, have_lwfn = 0;
+    Str255  lwfn_file_name;
+    FSSpec  lwfn_spec;
+
+
+    HLock( fond );
+    parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, 0 );
+    HUnlock( fond );
+
+    if ( lwfn_file_name[0] )
+    {
+      if ( make_lwfn_spec( fond, lwfn_file_name, &lwfn_spec ) == FT_Err_Ok )
+        have_lwfn = 1;  /* yeah, we got one! */
+      else
+        have_lwfn = 0;  /* no LWFN file found */
+    }
+
+    if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
+      return 1;
+    else
+      return count_faces_sfnt( *fond );
+  }
+
+
+  /* Read Type 1 data from the POST resources inside the LWFN file,
+     return a PFB buffer. This is somewhat convoluted because the FT2
+     PFB parser wants the ASCII header as one chunk, and the LWFN
+     chunks are often not organized that way, so we'll glue chunks
+     of the same type together. */
+  static FT_Error
+  read_lwfn( FT_Memory  memory,
+             short      res_ref,
+             FT_Byte**  pfb_data,
+             FT_ULong*  size )
+  {
+    FT_Error       error = FT_Err_Ok;
+    short          res_id;
+    unsigned char  *buffer, *p, *size_p = NULL;
+    FT_ULong       total_size = 0;
+    FT_ULong       post_size, pfb_chunk_size;
+    Handle         post_data;
+    char           code, last_code;
+
+
+    UseResFile( res_ref );
+
+    /* First pass: load all POST resources, and determine the size of */
+    /* the output buffer.                                             */
+    res_id    = 501;
+    last_code = -1;
+
+    for (;;)
+    {
+      post_data = Get1Resource( 'POST', res_id++ );
+      if ( post_data == NULL )
+        break;  /* we're done */
+
+      code = (*post_data)[0];
+
+      if ( code != last_code )
+      {
+        if ( code == 5 )
+          total_size += 2; /* just the end code */
+        else
+          total_size += 6; /* code + 4 bytes chunk length */
+      }
+
+      total_size += GetHandleSize( post_data ) - 2;
+      last_code = code;
+    }
+
+    if ( FT_ALLOC( buffer, (FT_Long)total_size ) )
+      goto Error;
+
+    /* Second pass: append all POST data to the buffer, add PFB fields. */
+    /* Glue all consecutive chunks of the same type together.           */
+    p              = buffer;
+    res_id         = 501;
+    last_code      = -1;
+    pfb_chunk_size = 0;
+
+    for (;;)
+    {
+      post_data = Get1Resource( 'POST', res_id++ );
+      if ( post_data == NULL )
+        break;  /* we're done */
+
+      post_size = (FT_ULong)GetHandleSize( post_data ) - 2;
+      code = (*post_data)[0];
+
+      if ( code != last_code )
+      {
+        if ( last_code != -1 )
+        {
+          /* we're done adding a chunk, fill in the size field */
+          if ( size_p != NULL )
+          {
+            *size_p++ = (FT_Byte)(   pfb_chunk_size         & 0xFF );
+            *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 8  ) & 0xFF );
+            *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 16 ) & 0xFF );
+            *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 24 ) & 0xFF );
+          }
+          pfb_chunk_size = 0;
+        }
+
+        *p++ = 0x80;
+        if ( code == 5 )
+          *p++ = 0x03;  /* the end */
+        else if ( code == 2 )
+          *p++ = 0x02;  /* binary segment */
+        else
+          *p++ = 0x01;  /* ASCII segment */
+
+        if ( code != 5 )
+        {
+          size_p = p;   /* save for later */
+          p += 4;       /* make space for size field */
+        }
+      }
+
+      ft_memcpy( p, *post_data + 2, post_size );
+      pfb_chunk_size += post_size;
+      p += post_size;
+      last_code = code;
+    }
+
+    *pfb_data = buffer;
+    *size = total_size;
+
+  Error:
+    CloseResFile( res_ref );
+    return error;
+  }
+
+
+  /* Finalizer for a memory stream; gets called by FT_Done_Face().
+     It frees the memory it uses. */
+  static void
+  memory_stream_close( FT_Stream  stream )
+  {
+    FT_Memory  memory = stream->memory;
+
+
+    FT_FREE( stream->base );
+
+    stream->size  = 0;
+    stream->base  = 0;
+    stream->close = 0;
+  }
+
+
+  /* Create a new memory stream from a buffer and a size. */
+  static FT_Error
+  new_memory_stream( FT_Library           library,
+                     FT_Byte*             base,
+                     FT_ULong             size,
+                     FT_Stream_CloseFunc  close,
+                     FT_Stream           *astream )
+  {
+    FT_Error   error;
+    FT_Memory  memory;
+    FT_Stream  stream;
+
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    if ( !base )
+      return FT_Err_Invalid_Argument;
+
+    *astream = 0;
+    memory = library->memory;
+    if ( FT_NEW( stream ) )
+      goto Exit;
+
+    FT_Stream_OpenMemory( stream, base, size );
+
+    stream->close = close;
+
+    *astream = stream;
+
+  Exit:
+    return error;
+  }
+
+
+  /* Create a new FT_Face given a buffer and a driver name. */
+  static FT_Error
+  open_face_from_buffer( FT_Library  library,
+                         FT_Byte*    base,
+                         FT_ULong    size,
+                         FT_Long     face_index,
+                         char*       driver_name,
+                         FT_Face    *aface )
+  {
+    FT_Open_Args  args;
+    FT_Error      error;
+    FT_Stream     stream;
+    FT_Memory     memory = library->memory;
+
+
+    error = new_memory_stream( library,
+                               base,
+                               size,
+                               memory_stream_close,
+                               &stream );
+    if ( error )
+    {
+      FT_FREE( base );
+      return error;
+    }
+
+    args.flags = FT_OPEN_STREAM;
+    args.stream = stream;
+    if ( driver_name )
+    {
+      args.flags = args.flags | FT_OPEN_DRIVER;
+      args.driver = FT_Get_Module( library, driver_name );
+    }
+
+    /* At this point, face_index has served its purpose;      */
+    /* whoever calls this function has already used it to     */
+    /* locate the correct font data.  We should not propagate */
+    /* this index to FT_Open_Face() (unless it is negative).  */
+
+    if ( face_index > 0 )
+      face_index = 0;
+
+    error = FT_Open_Face( library, &args, face_index, aface );
+    if ( error == FT_Err_Ok )
+      (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
+
+    return error;
+  }
+
+
+  static FT_Error
+  OpenFileAsResource( const FSSpec*  spec,
+                      short         *p_res_ref )
+  {
+    FT_Error  error;
+
+#if !TARGET_API_MAC_OS8
+
+    FSRef     hostContainerRef;
+
+
+    error = FSpMakeFSRef( spec, &hostContainerRef );
+    if ( error == noErr )
+      error = FSOpenResourceFile( &hostContainerRef,
+                                  0, NULL, fsRdPerm, p_res_ref );
+
+    /* If the above fails, then it is probably not a resource file       */
+    /* However, it has been reported that FSOpenResourceFile() sometimes */
+    /* fails on some old resource-fork files, which FSpOpenResFile() can */
+    /* open.  So, just try again with FSpOpenResFile() and see what      */
+    /* happens :-)                                                       */
+
+    if ( error != noErr )
+
+#endif  /* !TARGET_API_MAC_OS8 */
+
+    {
+      *p_res_ref = FSpOpenResFile( spec, fsRdPerm );
+      error = ResError();
+    }
+
+    return error ? FT_Err_Cannot_Open_Resource : FT_Err_Ok;
+  }
+
+
+  /* Create a new FT_Face from a file spec to an LWFN file. */
+  static FT_Error
+  FT_New_Face_From_LWFN( FT_Library     library,
+                         const FSSpec*  lwfn_spec,
+                         FT_Long        face_index,
+                         FT_Face       *aface )
+  {
+    FT_Byte*  pfb_data;
+    FT_ULong  pfb_size;
+    FT_Error  error;
+    short     res_ref;
+
+
+    error = OpenFileAsResource( lwfn_spec, &res_ref );
+    if ( error )
+      return error;
+
+    error = read_lwfn( library->memory, res_ref, &pfb_data, &pfb_size );
+    if ( error )
+      return error;
+
+    return open_face_from_buffer( library,
+                                  pfb_data,
+                                  pfb_size,
+                                  face_index,
+                                  "type1",
+                                  aface );
+  }
+
+
+  /* Create a new FT_Face from an SFNT resource, specified by res ID. */
+  static FT_Error
+  FT_New_Face_From_SFNT( FT_Library  library,
+                         short       sfnt_id,
+                         FT_Long     face_index,
+                         FT_Face    *aface )
+  {
+    Handle     sfnt = NULL;
+    FT_Byte*   sfnt_data;
+    size_t     sfnt_size;
+    FT_Error   error = 0;
+    FT_Memory  memory = library->memory;
+    int        is_cff;
+
+
+    sfnt = GetResource( 'sfnt', sfnt_id );
+    if ( ResError() )
+      return FT_Err_Invalid_Handle;
+
+    sfnt_size = (FT_ULong)GetHandleSize( sfnt );
+    if ( FT_ALLOC( sfnt_data, (FT_Long)sfnt_size ) )
+    {
+      ReleaseResource( sfnt );
+      return error;
+    }
+
+    HLock( sfnt );
+    ft_memcpy( sfnt_data, *sfnt, sfnt_size );
+    HUnlock( sfnt );
+    ReleaseResource( sfnt );
+
+    is_cff = sfnt_size > 4 && sfnt_data[0] == 'O' &&
+                              sfnt_data[1] == 'T' &&
+                              sfnt_data[2] == 'T' &&
+                              sfnt_data[3] == 'O';
+
+    return open_face_from_buffer( library,
+                                  sfnt_data,
+                                  sfnt_size,
+                                  face_index,
+                                  is_cff ? "cff" : "truetype",
+                                  aface );
+  }
+
+
+  /* Create a new FT_Face from a file spec to a suitcase file. */
+  static FT_Error
+  FT_New_Face_From_Suitcase( FT_Library  library,
+                             short       res_ref,
+                             FT_Long     face_index,
+                             FT_Face    *aface )
+  {
+    FT_Error  error = FT_Err_Ok;
+    short     res_index;
+    Handle    fond;
+    short     num_faces;
+
+
+    UseResFile( res_ref );
+
+    for ( res_index = 1; ; ++res_index )
+    {
+      fond = Get1IndResource( 'FOND', res_index );
+      if ( ResError() )
+      {
+        error = FT_Err_Cannot_Open_Resource;
+        goto Error;
+      }
+      if ( face_index < 0 )
+        break;
+
+      num_faces = count_faces( fond );
+      if ( face_index < num_faces )
+        break;
+
+      face_index -= num_faces;
+    }
+
+    error = FT_New_Face_From_FOND( library, fond, face_index, aface );
+
+  Error:
+    CloseResFile( res_ref );
+    return error;
+  }
+
+
+  /* documentation is in ftmac.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_New_Face_From_FOND( FT_Library  library,
+                         Handle      fond,
+                         FT_Long     face_index,
+                         FT_Face    *aface )
+  {
+    short   sfnt_id, have_sfnt, have_lwfn = 0;
+    Str255  lwfn_file_name;
+    short   fond_id;
+    OSType  fond_type;
+    Str255  fond_name;
+    FSSpec  lwfn_spec;
+
+
+    GetResInfo( fond, &fond_id, &fond_type, fond_name );
+    if ( ResError() != noErr || fond_type != 'FOND' )
+      return FT_Err_Invalid_File_Format;
+
+    HLock( fond );
+    parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, face_index );
+    HUnlock( fond );
+
+    if ( lwfn_file_name[0] )
+    {
+      if ( make_lwfn_spec( fond, lwfn_file_name, &lwfn_spec ) == FT_Err_Ok )
+        have_lwfn = 1;  /* yeah, we got one! */
+      else
+        have_lwfn = 0;  /* no LWFN file found */
+    }
+
+    if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
+      return FT_New_Face_From_LWFN( library,
+                                    &lwfn_spec,
+                                    face_index,
+                                    aface );
+    else if ( have_sfnt )
+      return FT_New_Face_From_SFNT( library,
+                                    sfnt_id,
+                                    face_index,
+                                    aface );
+
+    return FT_Err_Unknown_File_Format;
+  }
+
+
+  /* documentation is in ftmac.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_GetFile_From_Mac_Name( const char* fontName,
+                            FSSpec*     pathSpec,
+                            FT_Long*    face_index )
+  {
+    OptionBits            options = kFMUseGlobalScopeOption;
+
+    FMFontFamilyIterator  famIter;
+    OSStatus              status = FMCreateFontFamilyIterator( NULL, NULL,
+                                                               options,
+                                                               &famIter );
+    FMFont                the_font = NULL;
+    FMFontFamily          family   = NULL;
+
+
+    *face_index = 0;
+    while ( status == 0 && !the_font )
+    {
+      status = FMGetNextFontFamily( &famIter, &family );
+      if ( status == 0 )
+      {
+        int                           stat2;
+        FMFontFamilyInstanceIterator  instIter;
+        Str255                        famNameStr;
+        char                          famName[256];
+
+
+        /* get the family name */
+        FMGetFontFamilyName( family, famNameStr );
+        CopyPascalStringToC( famNameStr, famName );
+
+        /* iterate through the styles */
+        FMCreateFontFamilyInstanceIterator( family, &instIter );
+
+        *face_index = 0;
+        stat2 = 0;
+        while ( stat2 == 0 && !the_font )
+        {
+          FMFontStyle  style;
+          FMFontSize   size;
+          FMFont       font;
+
+
+          stat2 = FMGetNextFontFamilyInstance( &instIter, &font,
+                                               &style, &size );
+          if ( stat2 == 0 && size == 0 )
+          {
+            char  fullName[256];
+
+
+            /* build up a complete face name */
+            ft_strcpy( fullName, famName );
+            if ( style & bold )
+              strcat( fullName, " Bold" );
+            if ( style & italic )
+              strcat( fullName, " Italic" );
+
+            /* compare with the name we are looking for */
+            if ( ft_strcmp( fullName, fontName ) == 0 )
+            {
+              /* found it! */
+              the_font = font;
+            }
+            else
+              ++(*face_index);
+          }
+        }
+
+        FMDisposeFontFamilyInstanceIterator( &instIter );
+      }
+    }
+
+    FMDisposeFontFamilyIterator( &famIter );
+
+    if ( the_font )
+    {
+      FMGetFontContainer( the_font, pathSpec );
+      return FT_Err_Ok;
+    }
+    else
+      return FT_Err_Unknown_File_Format;
+  }
+
+  /* Common function to load a new FT_Face from a resource file. */
+
+  static FT_Error
+  FT_New_Face_From_Resource( FT_Library     library,
+                             const FSSpec  *spec,
+                             FT_Long        face_index,
+                             FT_Face       *aface )
+  {
+    OSType    file_type;
+    short     res_ref;
+    FT_Error  error;
+
+
+    if ( OpenFileAsResource( spec, &res_ref ) == FT_Err_Ok )
+    {
+      /* LWFN is a (very) specific file format, check for it explicitly */
+
+      file_type = get_file_type( spec );
+      if ( file_type == 'LWFN' )
+        return FT_New_Face_From_LWFN( library, spec, face_index, aface );
+    
+      /* Otherwise the file type doesn't matter (there are more than  */
+      /* `FFIL' and `tfil').  Just try opening it as a font suitcase; */
+      /* if it works, fine.                                           */
+
+      error = FT_New_Face_From_Suitcase( library, res_ref,
+                                         face_index, aface );
+      if ( error == 0 )
+        return error;
+
+      /* else forget about the resource fork and fall through to */
+      /* data fork formats                                       */
+
+      CloseResFile( res_ref );
+    }
+
+    /* let it fall through to normal loader (.ttf, .otf, etc.); */
+    /* we signal this by returning no error and no FT_Face      */
+    *aface = NULL;
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This is the Mac-specific implementation of FT_New_Face.  In        */
+  /*    addition to the standard FT_New_Face() functionality, it also      */
+  /*    accepts pathnames to Mac suitcase files.  For further              */
+  /*    documentation see the original FT_New_Face() in freetype.h.        */
+  /*                                                                       */
+  FT_EXPORT_DEF( FT_Error )
+  FT_New_Face( FT_Library   library,
+               const char*  pathname,
+               FT_Long      face_index,
+               FT_Face     *aface )
+  {
+    FT_Open_Args  args;
+    FSSpec        spec;
+    FT_Error      error;
+
+
+    /* test for valid `library' and `aface' delayed to FT_Open_Face() */
+    if ( !pathname )
+      return FT_Err_Invalid_Argument;
+
+    if ( file_spec_from_path( pathname, &spec ) )
+      return FT_Err_Invalid_Argument;
+
+    error = FT_New_Face_From_Resource( library, &spec, face_index, aface );
+    if ( error != 0 || *aface != NULL )
+      return error;
+
+    /* let it fall through to normal loader (.ttf, .otf, etc.) */
+    args.flags    = FT_OPEN_PATHNAME;
+    args.pathname = (char*)pathname;
+    return FT_Open_Face( library, &args, face_index, aface );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face_From_FSSpec                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FT_New_Face_From_FSSpec is identical to FT_New_Face except it      */
+  /*    accepts an FSSpec instead of a path.                               */
+  /*                                                                       */
+  FT_EXPORT_DEF( FT_Error )
+  FT_New_Face_From_FSSpec( FT_Library    library,
+                           const FSSpec *spec,
+                           FT_Long       face_index,
+                           FT_Face      *aface )
+  {
+    FT_Open_Args  args;
+    FT_Error      error;
+    FT_Stream     stream;
+    FILE*         file;
+    FT_Memory     memory;
+
+
+    /* test for valid `library' and `aface' delayed to FT_Open_Face() */
+    if ( !spec )
+      return FT_Err_Invalid_Argument;
+
+    error = FT_New_Face_From_Resource( library, spec, face_index, aface );
+    if ( error != 0 || *aface != NULL )
+      return error;
+
+    /* let it fall through to normal loader (.ttf, .otf, etc.) */
+
+#if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
+
+    /* Codewarrior's C library can open a FILE from a FSSpec */
+    /* but we must compile with FSp_fopen.c in addition to   */
+    /* runtime libraries.                                    */
+
+    memory = library->memory;
+
+    if ( FT_NEW( stream ) )
+      return error;
+    stream->memory = memory;
+
+    file = FSp_fopen( spec, "rb" );
+    if ( !file )
+      return FT_Err_Cannot_Open_Resource;
+
+    fseek( file, 0, SEEK_END );
+    stream->size = ftell( file );
+    fseek( file, 0, SEEK_SET );
+
+    stream->descriptor.pointer = file;
+    stream->pathname.pointer   = NULL;
+    stream->pos                = 0;
+
+    stream->read  = ft_FSp_stream_io;
+    stream->close = ft_FSp_stream_close;
+
+    args.flags    = FT_OPEN_STREAM;
+    args.stream   = stream;
+
+    error = FT_Open_Face( library, &args, face_index, aface );
+    if ( error == FT_Err_Ok )
+      (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
+
+#else  /* !(__MWERKS__ && !TARGET_RT_MAC_MACHO) */
+
+    {
+      FSRef  ref;
+      UInt8  path[256];
+      OSErr  err;
+
+
+      err = FSpMakeFSRef(spec, &ref);
+      if ( !err )
+      {
+        err = FSRefMakePath( &ref, path, sizeof ( path ) );
+        if ( !err )
+          error = FT_New_Face( library, (const char*)path,
+                               face_index, aface );
+      }
+      if ( err )
+        error = FT_Err_Cannot_Open_Resource;
+    }
+
+#endif  /* !(__MWERKS__ && !TARGET_RT_MAC_MACHO) */
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftmm.c b/nx-X11/extras/freetype2/src/base/ftmm.c
new file mode 100644
index 000000000..940f8640a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftmm.c
@@ -0,0 +1,202 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmm.c                                                                 */
+/*                                                                         */
+/*    Multiple Master font support (body).                                 */
+/*                                                                         */
+/*  Copyright 1996-2001, 2003, 2004 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_MULTIPLE_MASTERS_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_SERVICE_MULTIPLE_MASTERS_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_mm
+
+
+  static FT_Error
+  ft_face_get_mm_service( FT_Face                   face,
+                          FT_Service_MultiMasters  *aservice )
+  {
+    FT_Error  error;
+
+
+    *aservice = NULL;
+
+    if ( !face )
+      return FT_Err_Invalid_Face_Handle;
+
+    error = FT_Err_Invalid_Argument;
+
+    if ( FT_HAS_MULTIPLE_MASTERS( face ) )
+    {
+      FT_FACE_LOOKUP_SERVICE( face,
+                              *aservice,
+                              MULTI_MASTERS );
+
+      if ( aservice )
+        error = FT_Err_Ok;
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftmm.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_Multi_Master( FT_Face           face,
+                       FT_Multi_Master  *amaster )
+  {
+    FT_Error                 error;
+    FT_Service_MultiMasters  service;
+
+
+    error = ft_face_get_mm_service( face, &service );
+    if ( !error )
+    {
+      error = FT_Err_Invalid_Argument;
+      if ( service->get_mm )
+        error = service->get_mm( face, amaster );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftmm.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_MM_Var( FT_Face      face,
+                 FT_MM_Var*  *amaster )
+  {
+    FT_Error                 error;
+    FT_Service_MultiMasters  service;
+
+
+    error = ft_face_get_mm_service( face, &service );
+    if ( !error )
+    {
+      error = FT_Err_Invalid_Argument;
+      if ( service->get_mm_var )
+        error = service->get_mm_var( face, amaster );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftmm.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Set_MM_Design_Coordinates( FT_Face   face,
+                                FT_UInt   num_coords,
+                                FT_Long*  coords )
+  {
+    FT_Error                 error;
+    FT_Service_MultiMasters  service;
+
+
+    error = ft_face_get_mm_service( face, &service );
+    if ( !error )
+    {
+      error = FT_Err_Invalid_Argument;
+      if ( service->set_mm_design )
+        error = service->set_mm_design( face, num_coords, coords );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftmm.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Set_Var_Design_Coordinates( FT_Face    face,
+                                 FT_UInt    num_coords,
+                                 FT_Fixed*  coords )
+  {
+    FT_Error                 error;
+    FT_Service_MultiMasters  service;
+
+
+    error = ft_face_get_mm_service( face, &service );
+    if ( !error )
+    {
+      error = FT_Err_Invalid_Argument;
+      if ( service->set_var_design )
+        error = service->set_var_design( face, num_coords, coords );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftmm.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Set_MM_Blend_Coordinates( FT_Face    face,
+                               FT_UInt    num_coords,
+                               FT_Fixed*  coords )
+  {
+    FT_Error                 error;
+    FT_Service_MultiMasters  service;
+
+
+    error = ft_face_get_mm_service( face, &service );
+    if ( !error )
+    {
+      error = FT_Err_Invalid_Argument;
+      if ( service->set_mm_blend )
+         error = service->set_mm_blend( face, num_coords, coords );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftmm.h */
+  
+  /* This is exactly the same as the previous function.  It exists for */
+  /* orthogonality.                                                    */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Set_Var_Blend_Coordinates( FT_Face    face,
+                                FT_UInt    num_coords,
+                                FT_Fixed*  coords )
+  {
+    FT_Error                 error;
+    FT_Service_MultiMasters  service;
+
+
+    error = ft_face_get_mm_service( face, &service );
+    if ( !error )
+    {
+      error = FT_Err_Invalid_Argument;
+      if ( service->set_mm_blend )
+         error = service->set_mm_blend( face, num_coords, coords );
+    }
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftnames.c b/nx-X11/extras/freetype2/src/base/ftnames.c
new file mode 100644
index 000000000..7fde5c40b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftnames.c
@@ -0,0 +1,94 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftnames.c                                                              */
+/*                                                                         */
+/*    Simple interface to access SFNT name tables (which are used          */
+/*    to hold font names, copyright info, notices, etc.) (body).           */
+/*                                                                         */
+/*    This is _not_ used to retrieve glyph names!                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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_SFNT_NAMES_H
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+#include FT_INTERNAL_STREAM_H
+
+
+#ifdef TT_CONFIG_OPTION_SFNT_NAMES
+
+
+  /* documentation is in ftnames.h */
+
+  FT_EXPORT_DEF( FT_UInt )
+  FT_Get_Sfnt_Name_Count( FT_Face  face )
+  {
+    return (face && FT_IS_SFNT( face )) ? ((TT_Face)face)->num_names : 0;
+  }
+
+
+  /* documentation is in ftnames.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_Sfnt_Name( FT_Face       face,
+                    FT_UInt       idx,
+                    FT_SfntName  *aname )
+  {
+    FT_Error  error = FT_Err_Invalid_Argument;
+
+
+    if ( aname && face && FT_IS_SFNT( face ) )
+    {
+      TT_Face  ttface = (TT_Face)face;
+
+
+      if ( idx < (FT_UInt)ttface->num_names )
+      {
+        TT_NameEntryRec*  entry = ttface->name_table.names + idx;
+
+
+        /* load name on demand */
+        if ( entry->stringLength > 0 && entry->string == NULL )
+        {
+          FT_Memory  memory = face->memory;
+          FT_Stream  stream = face->stream;
+
+
+          if ( FT_NEW_ARRAY  ( entry->string, entry->stringLength ) ||
+               FT_STREAM_SEEK( entry->stringOffset )                ||
+               FT_STREAM_READ( entry->string, entry->stringLength ) )
+          {
+            FT_FREE( entry->string );
+            entry->stringLength = 0;
+          }
+        }
+
+        aname->platform_id = entry->platformID;
+        aname->encoding_id = entry->encodingID;
+        aname->language_id = entry->languageID;
+        aname->name_id     = entry->nameID;
+        aname->string      = (FT_Byte*)entry->string;
+        aname->string_len  = entry->stringLength;
+
+        error = FT_Err_Ok;
+      }
+    }
+
+    return error;
+  }
+
+
+#endif /* TT_CONFIG_OPTION_SFNT_NAMES */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftobjs.c b/nx-X11/extras/freetype2/src/base/ftobjs.c
new file mode 100644
index 000000000..bbd6ce6be
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftobjs.c
@@ -0,0 +1,3311 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftobjs.c                                                               */
+/*                                                                         */
+/*    The FreeType private base classes (body).                            */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_LIST_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_RFORK_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_SFNT_H    /* for SFNT_Load_Table_Func */
+#include FT_TRUETYPE_TABLES_H
+#include FT_TRUETYPE_IDS_H
+#include FT_OUTLINE_H
+
+#include FT_SERVICE_SFNT_H
+#include FT_SERVICE_POSTSCRIPT_NAME_H
+#include FT_SERVICE_GLYPH_DICT_H
+#include FT_SERVICE_TT_CMAP_H
+
+
+  FT_BASE_DEF( FT_Pointer )
+  ft_service_list_lookup( FT_ServiceDesc  service_descriptors,
+                          const char*     service_id )
+  {
+    FT_Pointer      result = NULL;
+    FT_ServiceDesc  desc   = service_descriptors;
+
+
+    if ( desc && service_id )
+    {
+      for ( ; desc->serv_id != NULL; desc++ )
+      {
+        if ( ft_strcmp( desc->serv_id, service_id ) == 0 )
+        {
+          result = (FT_Pointer)desc->serv_data;
+          break;
+        }
+      }
+    }
+
+    return result;
+  }
+
+
+  FT_BASE_DEF( void )
+  ft_validator_init( FT_Validator        valid,
+                     const FT_Byte*      base,
+                     const FT_Byte*      limit,
+                     FT_ValidationLevel  level )
+  {
+    valid->base  = base;
+    valid->limit = limit;
+    valid->level = level;
+    valid->error = 0;
+  }
+
+
+  FT_BASE_DEF( FT_Int )
+  ft_validator_run( FT_Validator  valid )
+  {
+    int  result;
+
+
+    result = ft_setjmp( valid->jump_buffer );
+    return result;
+  }
+
+
+  FT_BASE_DEF( void )
+  ft_validator_error( FT_Validator  valid,
+                      FT_Error      error )
+  {
+    valid->error = error;
+    ft_longjmp( valid->jump_buffer, 1 );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                           S T R E A M                           ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* create a new input stream from an FT_Open_Args structure */
+  /*                                                          */
+  FT_BASE_DEF( FT_Error )
+  FT_Stream_New( FT_Library           library,
+                 const FT_Open_Args*  args,
+                 FT_Stream           *astream )
+  {
+    FT_Error   error;
+    FT_Memory  memory;
+    FT_Stream  stream;
+
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    if ( !args )
+      return FT_Err_Invalid_Argument;
+
+    *astream = 0;
+    memory   = library->memory;
+
+    if ( FT_NEW( stream ) )
+      goto Exit;
+
+    stream->memory = memory;
+
+    if ( args->flags & FT_OPEN_MEMORY )
+    {
+      /* create a memory-based stream */
+      FT_Stream_OpenMemory( stream,
+                            (const FT_Byte*)args->memory_base,
+                            args->memory_size );
+    }
+    else if ( args->flags & FT_OPEN_PATHNAME )
+    {
+      /* create a normal system stream */
+      error = FT_Stream_Open( stream, args->pathname );
+      stream->pathname.pointer = args->pathname;
+    }
+    else if ( ( args->flags & FT_OPEN_STREAM ) && args->stream )
+    {
+      /* use an existing, user-provided stream */
+
+      /* in this case, we do not need to allocate a new stream object */
+      /* since the caller is responsible for closing it himself       */
+      FT_FREE( stream );
+      stream = args->stream;
+    }
+    else
+      error = FT_Err_Invalid_Argument;
+
+    if ( error )
+      FT_FREE( stream );
+    else
+      stream->memory = memory;  /* just to be certain */
+
+    *astream = stream;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_BASE_DEF( void )
+  FT_Stream_Free( FT_Stream  stream,
+                  FT_Int     external )
+  {
+    if ( stream )
+    {
+      FT_Memory  memory = stream->memory;
+
+
+      FT_Stream_Close( stream );
+
+      if ( !external )
+        FT_FREE( stream );
+    }
+  }
+
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_objs
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****               FACE, SIZE & GLYPH SLOT OBJECTS                   ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  static FT_Error
+  ft_glyphslot_init( FT_GlyphSlot  slot )
+  {
+    FT_Driver         driver = slot->face->driver;
+    FT_Driver_Class   clazz  = driver->clazz;
+    FT_Memory         memory = driver->root.memory;
+    FT_Error          error  = FT_Err_Ok;
+    FT_Slot_Internal  internal;
+
+
+    slot->library = driver->root.library;
+
+    if ( FT_NEW( internal ) )
+      goto Exit;
+
+    slot->internal = internal;
+
+    if ( FT_DRIVER_USES_OUTLINES( driver ) )
+      error = FT_GlyphLoader_New( memory, &internal->loader );
+
+    if ( !error && clazz->init_slot )
+      error = clazz->init_slot( slot );
+
+  Exit:
+    return error;
+  }
+
+
+  FT_BASE_DEF( void )
+  ft_glyphslot_free_bitmap( FT_GlyphSlot  slot )
+  {
+    if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
+    {
+      FT_Memory  memory = FT_FACE_MEMORY( slot->face );
+
+
+      FT_FREE( slot->bitmap.buffer );
+      slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
+    }
+    else
+    {
+      /* assume that the bitmap buffer was stolen or not */
+      /* allocated from the heap                         */
+      slot->bitmap.buffer = NULL;
+    }
+  }
+
+
+  FT_BASE_DEF( void )
+  ft_glyphslot_set_bitmap( FT_GlyphSlot  slot,
+                           FT_Byte*      buffer )
+  {
+    ft_glyphslot_free_bitmap( slot );
+
+    slot->bitmap.buffer = buffer;
+
+    FT_ASSERT( (slot->internal->flags & FT_GLYPH_OWN_BITMAP) == 0 );
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  ft_glyphslot_alloc_bitmap( FT_GlyphSlot  slot,
+                             FT_ULong      size )
+  {
+    FT_Memory  memory = FT_FACE_MEMORY( slot->face );
+
+
+    if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
+      FT_FREE( slot->bitmap.buffer );
+    else
+      slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
+
+    return FT_MEM_ALLOC( slot->bitmap.buffer, size );
+  }
+
+
+  static void
+  ft_glyphslot_clear( FT_GlyphSlot  slot )
+  {
+    /* free bitmap if needed */
+    ft_glyphslot_free_bitmap( slot );
+
+    /* clear all public fields in the glyph slot */
+    FT_ZERO( &slot->metrics );
+    FT_ZERO( &slot->outline );
+
+    slot->bitmap.width = 0;
+    slot->bitmap.rows  = 0;
+    slot->bitmap.pitch = 0;
+    slot->bitmap.pixel_mode = 0;
+    /* don't touch 'slot->bitmap.buffer'! */
+
+    slot->bitmap_left   = 0;
+    slot->bitmap_top    = 0;
+    slot->num_subglyphs = 0;
+    slot->subglyphs     = 0;
+    slot->control_data  = 0;
+    slot->control_len   = 0;
+    slot->other         = 0;
+    slot->format        = FT_GLYPH_FORMAT_NONE;
+
+    slot->linearHoriAdvance = 0;
+    slot->linearVertAdvance = 0;
+  }
+
+
+  static void
+  ft_glyphslot_done( FT_GlyphSlot  slot )
+  {
+    FT_Driver         driver = slot->face->driver;
+    FT_Driver_Class   clazz  = driver->clazz;
+    FT_Memory         memory = driver->root.memory;
+
+
+    if ( clazz->done_slot )
+      clazz->done_slot( slot );
+
+    /* free bitmap buffer if needed */
+    ft_glyphslot_free_bitmap( slot );
+
+    /* free glyph loader */
+    if ( FT_DRIVER_USES_OUTLINES( driver ) )
+    {
+      FT_GlyphLoader_Done( slot->internal->loader );
+      slot->internal->loader = 0;
+    }
+
+    FT_FREE( slot->internal );
+  }
+
+
+  /* documentation is in ftobjs.h */
+
+  FT_BASE_DEF( FT_Error )
+  FT_New_GlyphSlot( FT_Face        face,
+                    FT_GlyphSlot  *aslot )
+  {
+    FT_Error          error;
+    FT_Driver         driver;
+    FT_Driver_Class   clazz;
+    FT_Memory         memory;
+    FT_GlyphSlot      slot;
+
+
+    if ( !face || !aslot || !face->driver )
+      return FT_Err_Invalid_Argument;
+
+    *aslot = 0;
+
+    driver = face->driver;
+    clazz  = driver->clazz;
+    memory = driver->root.memory;
+
+    FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" ));
+    if ( !FT_ALLOC( slot, clazz->slot_object_size ) )
+    {
+      slot->face = face;
+
+      error = ft_glyphslot_init( slot );
+      if ( error )
+      {
+        ft_glyphslot_done( slot );
+        FT_FREE( slot );
+        goto Exit;
+      }
+
+      *aslot = slot;
+    }
+
+  Exit:
+    FT_TRACE4(( "FT_New_GlyphSlot: Return %d\n", error ));
+    return error;
+  }
+
+
+  /* documentation is in ftobjs.h */
+
+  FT_BASE_DEF( void )
+  FT_Done_GlyphSlot( FT_GlyphSlot  slot )
+  {
+    if ( slot )
+    {
+      FT_Driver      driver = slot->face->driver;
+      FT_Memory      memory = driver->root.memory;
+      FT_GlyphSlot*  parent;
+      FT_GlyphSlot   cur;
+
+
+      /* Remove slot from its parent face's list */
+      parent = &slot->face->glyph;
+      cur    = *parent;
+
+      while ( cur )
+      {
+        if ( cur == slot )
+        {
+          *parent = cur->next;
+          ft_glyphslot_done( slot );
+          FT_FREE( slot );
+          break;
+        }
+        cur = cur->next;
+      }
+    }
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Set_Transform( FT_Face     face,
+                    FT_Matrix*  matrix,
+                    FT_Vector*  delta )
+  {
+    FT_Face_Internal  internal;
+
+
+    if ( !face )
+      return;
+
+    internal = face->internal;
+
+    internal->transform_flags = 0;
+
+    if ( !matrix )
+    {
+      internal->transform_matrix.xx = 0x10000L;
+      internal->transform_matrix.xy = 0;
+      internal->transform_matrix.yx = 0;
+      internal->transform_matrix.yy = 0x10000L;
+      matrix = &internal->transform_matrix;
+    }
+    else
+      internal->transform_matrix = *matrix;
+
+    /* set transform_flags bit flag 0 if `matrix' isn't the identity */
+    if ( ( matrix->xy | matrix->yx ) ||
+         matrix->xx != 0x10000L      ||
+         matrix->yy != 0x10000L      )
+      internal->transform_flags |= 1;
+
+    if ( !delta )
+    {
+      internal->transform_delta.x = 0;
+      internal->transform_delta.y = 0;
+      delta = &internal->transform_delta;
+    }
+    else
+      internal->transform_delta = *delta;
+
+    /* set transform_flags bit flag 1 if `delta' isn't the null vector */
+    if ( delta->x | delta->y )
+      internal->transform_flags |= 2;
+  }
+
+
+  static FT_Renderer
+  ft_lookup_glyph_renderer( FT_GlyphSlot  slot );
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Load_Glyph( FT_Face   face,
+                 FT_UInt   glyph_index,
+                 FT_Int32  load_flags )
+  {
+    FT_Error      error;
+    FT_Driver     driver;
+    FT_GlyphSlot  slot;
+    FT_Library    library;
+    FT_Bool       autohint;
+    FT_Module     hinter;
+
+
+    if ( !face || !face->size || !face->glyph )
+      return FT_Err_Invalid_Face_Handle;
+
+    if ( glyph_index >= (FT_UInt)face->num_glyphs )
+      return FT_Err_Invalid_Argument;
+
+    slot = face->glyph;
+    ft_glyphslot_clear( slot );
+
+    driver = face->driver;
+
+    /* if the flag NO_RECURSE is set, we disable hinting and scaling */
+    if ( load_flags & FT_LOAD_NO_RECURSE )
+    {
+      /* disable scaling, hinting, and transformation */
+      load_flags |= FT_LOAD_NO_SCALE         |
+                    FT_LOAD_NO_HINTING       |
+                    FT_LOAD_NO_BITMAP        |
+                    FT_LOAD_IGNORE_TRANSFORM;
+
+      /* disable bitmap rendering */
+      load_flags &= ~FT_LOAD_RENDER;
+    }
+
+    /* do we need to load the glyph through the auto-hinter? */
+    library  = driver->root.library;
+    hinter   = library->auto_hinter;
+    autohint =
+      FT_BOOL( hinter                                      &&
+               !( load_flags & ( FT_LOAD_NO_SCALE    |
+                                 FT_LOAD_NO_HINTING  |
+                                 FT_LOAD_NO_AUTOHINT ) )   &&
+               FT_DRIVER_IS_SCALABLE( driver )             &&
+               FT_DRIVER_USES_OUTLINES( driver )           );
+    if ( autohint )
+    {
+      if ( FT_DRIVER_HAS_HINTER( driver ) &&
+           !( load_flags & FT_LOAD_FORCE_AUTOHINT ) )
+        autohint = 0;
+    }
+
+    /* don't apply autohinting if glyph is vertically distorted or */
+    /* mirrored                                                    */
+    if ( autohint && !( face->internal->transform_matrix.yy <= 0 ||
+                        face->internal->transform_matrix.yx != 0 ) )
+    {
+      FT_AutoHinter_Service  hinting;
+
+
+      /* try to load embedded bitmaps first if available            */
+      /*                                                            */
+      /* XXX: This is really a temporary hack that should disappear */
+      /*      promptly with FreeType 2.1!                           */
+      /*                                                            */
+      if ( FT_HAS_FIXED_SIZES( face )             &&
+          ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
+      {
+        error = driver->clazz->load_glyph( slot, face->size,
+                                           glyph_index,
+                                           load_flags | FT_LOAD_SBITS_ONLY );
+
+        if ( !error && slot->format == FT_GLYPH_FORMAT_BITMAP )
+          goto Load_Ok;
+      }
+
+      /* load auto-hinted outline */
+      hinting = (FT_AutoHinter_Service)hinter->clazz->module_interface;
+
+      error   = hinting->load_glyph( (FT_AutoHinter)hinter,
+                                     slot, face->size,
+                                     glyph_index, load_flags );
+    }
+    else
+    {
+      error = driver->clazz->load_glyph( slot,
+                                         face->size,
+                                         glyph_index,
+                                         load_flags );
+      if ( error )
+        goto Exit;
+
+      /* check that the loaded outline is correct */
+      error = FT_Outline_Check( &slot->outline );
+      if ( error )
+        goto Exit;
+    }
+
+  Load_Ok:
+    /* compute the advance */
+    if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
+    {
+      slot->advance.x = 0;
+      slot->advance.y = slot->metrics.vertAdvance;
+    }
+    else
+    {
+      slot->advance.x = slot->metrics.horiAdvance;
+      slot->advance.y = 0;
+    }
+
+    /* compute the linear advance in 16.16 pixels */
+    if ( ( load_flags & FT_LOAD_LINEAR_DESIGN ) == 0  &&
+         ( face->face_flags & FT_FACE_FLAG_SCALABLE ) )
+    {
+      FT_Size_Metrics*  metrics = &face->size->metrics;
+
+
+      slot->linearHoriAdvance = FT_MulDiv( slot->linearHoriAdvance,
+                                           metrics->x_scale, 64 );
+
+      slot->linearVertAdvance = FT_MulDiv( slot->linearVertAdvance,
+                                           metrics->y_scale, 64 );
+    }
+
+    if ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) == 0 )
+    {
+      FT_Face_Internal  internal = face->internal;
+
+
+      /* now, transform the glyph image if needed */
+      if ( internal->transform_flags )
+      {
+        /* get renderer */
+        FT_Renderer  renderer = ft_lookup_glyph_renderer( slot );
+
+
+        if ( renderer )
+          error = renderer->clazz->transform_glyph(
+                                     renderer, slot,
+                                     &internal->transform_matrix,
+                                     &internal->transform_delta );
+        /* transform advance */
+        FT_Vector_Transform( &slot->advance, &internal->transform_matrix );
+      }
+    }
+
+    /* do we need to render the image now? */
+    if ( !error                                    &&
+         slot->format != FT_GLYPH_FORMAT_BITMAP    &&
+         slot->format != FT_GLYPH_FORMAT_COMPOSITE &&
+         load_flags & FT_LOAD_RENDER )
+    {
+      FT_Render_Mode  mode = FT_LOAD_TARGET_MODE( load_flags );
+
+
+      if ( mode == FT_RENDER_MODE_NORMAL      &&
+           (load_flags & FT_LOAD_MONOCHROME ) )
+        mode = FT_RENDER_MODE_MONO;
+
+      error = FT_Render_Glyph( slot, mode );
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Load_Char( FT_Face   face,
+                FT_ULong  char_code,
+                FT_Int32  load_flags )
+  {
+    FT_UInt  glyph_index;
+
+
+    if ( !face )
+      return FT_Err_Invalid_Face_Handle;
+
+    glyph_index = (FT_UInt)char_code;
+    if ( face->charmap )
+      glyph_index = FT_Get_Char_Index( face, char_code );
+
+    return FT_Load_Glyph( face, glyph_index, load_flags );
+  }
+
+
+  /* destructor for sizes list */
+  static void
+  destroy_size( FT_Memory  memory,
+                FT_Size    size,
+                FT_Driver  driver )
+  {
+    /* finalize client-specific data */
+    if ( size->generic.finalizer )
+      size->generic.finalizer( size );
+
+    /* finalize format-specific stuff */
+    if ( driver->clazz->done_size )
+      driver->clazz->done_size( size );
+
+    FT_FREE( size->internal );
+    FT_FREE( size );
+  }
+
+
+  static void
+  destroy_charmaps( FT_Face    face,
+                    FT_Memory  memory )
+  {
+    FT_Int  n;
+
+
+    for ( n = 0; n < face->num_charmaps; n++ )
+    {
+      FT_CMap  cmap = FT_CMAP( face->charmaps[n] );
+
+
+      FT_CMap_Done( cmap );
+
+      face->charmaps[n] = NULL;
+    }
+
+    FT_FREE( face->charmaps );
+    face->num_charmaps = 0;
+  }
+
+
+  /* destructor for faces list */
+  static void
+  destroy_face( FT_Memory  memory,
+                FT_Face    face,
+                FT_Driver  driver )
+  {
+    FT_Driver_Class  clazz = driver->clazz;
+
+
+    /* discard auto-hinting data */
+    if ( face->autohint.finalizer )
+      face->autohint.finalizer( face->autohint.data );
+
+    /* Discard glyph slots for this face.                           */
+    /* Beware!  FT_Done_GlyphSlot() changes the field `face->glyph' */
+    while ( face->glyph )
+      FT_Done_GlyphSlot( face->glyph );
+
+    /* discard all sizes for this face */
+    FT_List_Finalize( &face->sizes_list,
+                      (FT_List_Destructor)destroy_size,
+                      memory,
+                      driver );
+    face->size = 0;
+
+    /* now discard client data */
+    if ( face->generic.finalizer )
+      face->generic.finalizer( face );
+
+    /* discard charmaps */
+    destroy_charmaps( face, memory );
+
+    /* finalize format-specific stuff */
+    if ( clazz->done_face )
+      clazz->done_face( face );
+
+    /* close the stream for this face if needed */
+    FT_Stream_Free(
+      face->stream,
+      ( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );
+
+    face->stream = 0;
+
+    /* get rid of it */
+    if ( face->internal )
+    {
+      FT_FREE( face->internal );
+    }
+    FT_FREE( face );
+  }
+
+
+  static void
+  Destroy_Driver( FT_Driver  driver )
+  {
+    FT_List_Finalize( &driver->faces_list,
+                      (FT_List_Destructor)destroy_face,
+                      driver->root.memory,
+                      driver );
+
+    /* check whether we need to drop the driver's glyph loader */
+    if ( FT_DRIVER_USES_OUTLINES( driver ) )
+      FT_GlyphLoader_Done( driver->glyph_loader );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    find_unicode_charmap                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function finds a Unicode charmap, if there is one.            */
+  /*    And if there is more than one, it tries to favour the more         */
+  /*    extensive one, i.e., one that supports UCS-4 against those which   */
+  /*    are limited to the BMP (said UCS-2 encoding.)                      */
+  /*                                                                       */
+  /*    This function is called from open_face() (just below), and also    */
+  /*    from FT_Select_Charmap( ..., FT_ENCODING_UNICODE).                 */
+  /*                                                                       */
+  static FT_Error
+  find_unicode_charmap( FT_Face  face )
+  {
+    FT_CharMap*  first;
+    FT_CharMap*  cur;
+    FT_CharMap*  unicmap = NULL;  /* some UCS-2 map, if we found it */
+
+
+    /* caller should have already checked that `face' is valid */
+    FT_ASSERT( face );
+
+    first = face->charmaps;
+
+    if ( !first )
+      return FT_Err_Invalid_CharMap_Handle;
+
+    /*
+     *  The original TrueType specification(s) only specified charmap
+     *  formats that are capable of mapping 8 or 16 bit character codes to
+     *  glyph indices.
+     *
+     *  However, recent updates to the Apple and OpenType specifications
+     *  introduced new formats that are capable of mapping 32-bit character
+     *  codes as well.  And these are already used on some fonts, mainly to
+     *  map non-BMP Asian ideographs as defined in Unicode.
+     *
+     *  For compatibility purposes, these fonts generally come with
+     *  *several* Unicode charmaps:
+     *
+     *   - One of them in the "old" 16-bit format, that cannot access
+     *     all glyphs in the font.
+     *
+     *   - Another one in the "new" 32-bit format, that can access all
+     *     the glyphs.
+     *
+     *  This function has been written to always favor a 32-bit charmap
+     *  when found.  Otherwise, a 16-bit one is returned when found.
+     */
+
+    /* since the `interesting' table, with id's 3,10, is normally the */
+    /* last one, we loop backwards. This looses with type1 fonts with */
+    /* non-BMP characters (<.0001%), this wins with .ttf with non-BMP */
+    /* chars (.01% ?), and this is the same about 99.99% of the time! */
+
+    cur = first + face->num_charmaps;  /* points after the last one */
+
+    for ( ; --cur >= first; )
+    {
+      if ( cur[0]->encoding == FT_ENCODING_UNICODE )
+      {
+        unicmap = cur;  /* record we found a Unicode charmap */
+
+        /* XXX If some new encodings to represent UCS-4 are added,  */
+        /*     they should be added here.                           */
+        if ( ( cur[0]->platform_id == TT_PLATFORM_MICROSOFT &&
+               cur[0]->encoding_id == TT_MS_ID_UCS_4        )          ||
+             ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE &&
+               cur[0]->encoding_id == TT_APPLE_ID_UNICODE_32    )      )
+
+        /* Hurray! We found a UCS-4 charmap. We can stop the scan! */
+        {
+          face->charmap = cur[0];
+          return 0;
+        }
+      }
+    }
+
+    /* We do not have any UCS-4 charmap. Sigh.                           */
+    /* Let's see if we have  some other kind of Unicode charmap, though. */
+    if ( unicmap != NULL )
+    {
+      face->charmap = unicmap[0];
+      return 0;
+    }
+
+    /* Chou blanc! */
+    return FT_Err_Invalid_CharMap_Handle;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    open_face                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function does some work for FT_Open_Face().                   */
+  /*                                                                       */
+  static FT_Error
+  open_face( FT_Driver      driver,
+             FT_Stream      stream,
+             FT_Long        face_index,
+             FT_Int         num_params,
+             FT_Parameter*  params,
+             FT_Face       *aface )
+  {
+    FT_Memory         memory;
+    FT_Driver_Class   clazz;
+    FT_Face           face = 0;
+    FT_Error          error, error2;
+    FT_Face_Internal  internal;
+
+
+    clazz  = driver->clazz;
+    memory = driver->root.memory;
+
+    /* allocate the face object and perform basic initialization */
+    if ( FT_ALLOC( face, clazz->face_object_size ) )
+      goto Fail;
+
+    if ( FT_NEW( internal ) )
+      goto Fail;
+
+    face->internal = internal;
+
+    face->driver   = driver;
+    face->memory   = memory;
+    face->stream   = stream;
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    {
+      int  i;
+
+
+      face->internal->incremental_interface = 0;
+      for ( i = 0; i < num_params && !face->internal->incremental_interface;
+            i++ )
+        if ( params[i].tag == FT_PARAM_TAG_INCREMENTAL )
+          face->internal->incremental_interface = params[i].data;
+    }
+#endif
+
+    error = clazz->init_face( stream,
+                              face,
+                              (FT_Int)face_index,
+                              num_params,
+                              params );
+    if ( error )
+      goto Fail;
+
+    /* select Unicode charmap by default */
+    error2 = find_unicode_charmap( face );
+
+    /* if no Unicode charmap can be found, FT_Err_Invalid_CharMap_Handle */
+    /* is returned.                                                      */
+
+    /* no error should happen, but we want to play safe */
+    if ( error2 && error2 != FT_Err_Invalid_CharMap_Handle )
+    {
+      error = error2;
+      goto Fail;
+    }
+
+    *aface = face;
+
+  Fail:
+    if ( error )
+    {
+      destroy_charmaps( face, memory );
+      clazz->done_face( face );
+      FT_FREE( internal );
+      FT_FREE( face );
+      *aface = 0;
+    }
+
+    return error;
+  }
+
+
+  /* there's a Mac-specific extended implementation of FT_New_Face() */
+  /* in src/base/ftmac.c                                             */
+
+#ifndef FT_MACINTOSH
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_New_Face( FT_Library   library,
+               const char*  pathname,
+               FT_Long      face_index,
+               FT_Face     *aface )
+  {
+    FT_Open_Args  args;
+
+
+    /* test for valid `library' and `aface' delayed to FT_Open_Face() */
+    if ( !pathname )
+      return FT_Err_Invalid_Argument;
+
+    args.flags    = FT_OPEN_PATHNAME;
+    args.pathname = (char*)pathname;
+
+    return FT_Open_Face( library, &args, face_index, aface );
+  }
+
+#endif  /* !FT_MACINTOSH */
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_New_Memory_Face( FT_Library      library,
+                      const FT_Byte*  file_base,
+                      FT_Long         file_size,
+                      FT_Long         face_index,
+                      FT_Face        *aface )
+  {
+    FT_Open_Args  args;
+
+
+    /* test for valid `library' and `face' delayed to FT_Open_Face() */
+    if ( !file_base )
+      return FT_Err_Invalid_Argument;
+
+    args.flags       = FT_OPEN_MEMORY;
+    args.memory_base = file_base;
+    args.memory_size = file_size;
+
+    return FT_Open_Face( library, &args, face_index, aface );
+  }
+
+
+#if !defined( FT_MACINTOSH ) && defined( FT_CONFIG_OPTION_MAC_FONTS )
+
+  /* The behavior here is very similar to that in base/ftmac.c, but it     */
+  /* is designed to work on non-mac systems, so no mac specific calls.     */
+  /*                                                                       */
+  /* We look at the file and determine if it is a mac dfont file or a mac  */
+  /* resource file, or a macbinary file containing a mac resource file.    */
+  /*                                                                       */
+  /* Unlike ftmac I'm not going to look at a `FOND'.  I don't really see   */
+  /* the point, especially since there may be multiple `FOND' resources.   */
+  /* Instead I'll just look for `sfnt' and `POST' resources, ordered as    */
+  /* they occur in the file.                                               */
+  /*                                                                       */
+  /* Note that multiple `POST' resources do not mean multiple postscript   */
+  /* fonts; they all get jammed together to make what is essentially a     */
+  /* pfb file.                                                             */
+  /*                                                                       */
+  /* We aren't interested in `NFNT' or `FONT' bitmap resources.            */
+  /*                                                                       */
+  /* As soon as we get an `sfnt' load it into memory and pass it off to    */
+  /* FT_Open_Face.                                                         */
+  /*                                                                       */
+  /* If we have a (set of) `POST' resources, massage them into a (memory)  */
+  /* pfb file and pass that to FT_Open_Face.  (As with ftmac.c I'm not     */
+  /* going to try to save the kerning info.  After all that lives in the   */
+  /* `FOND' which isn't in the file containing the `POST' resources so     */
+  /* we don't really have access to it.                                    */
+
+
+  /* Finalizer for a memory stream; gets called by FT_Done_Face().
+     It frees the memory it uses. */
+  /* from ftmac.c */
+  static void
+  memory_stream_close( FT_Stream  stream )
+  {
+    FT_Memory  memory = stream->memory;
+
+
+    FT_FREE( stream->base );
+
+    stream->size  = 0;
+    stream->base  = 0;
+    stream->close = 0;
+  }
+
+
+  /* Create a new memory stream from a buffer and a size. */
+  /* from ftmac.c */
+  static FT_Error
+  new_memory_stream( FT_Library           library,
+                     FT_Byte*             base,
+                     FT_ULong             size,
+                     FT_Stream_CloseFunc  close,
+                     FT_Stream           *astream )
+  {
+    FT_Error   error;
+    FT_Memory  memory;
+    FT_Stream  stream;
+
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    if ( !base )
+      return FT_Err_Invalid_Argument;
+
+    *astream = 0;
+    memory = library->memory;
+    if ( FT_NEW( stream ) )
+      goto Exit;
+
+    FT_Stream_OpenMemory( stream, base, size );
+
+    stream->close = close;
+
+    *astream = stream;
+
+  Exit:
+    return error;
+  }
+
+
+  /* Create a new FT_Face given a buffer and a driver name. */
+  /* from ftmac.c */
+  static FT_Error
+  open_face_from_buffer( FT_Library   library,
+                         FT_Byte*     base,
+                         FT_ULong     size,
+                         FT_Long      face_index,
+                         const char*  driver_name,
+                         FT_Face     *aface )
+  {
+    FT_Open_Args  args;
+    FT_Error      error;
+    FT_Stream     stream;
+    FT_Memory     memory = library->memory;
+
+
+    error = new_memory_stream( library,
+                               base,
+                               size,
+                               memory_stream_close,
+                               &stream );
+    if ( error )
+    {
+      FT_FREE( base );
+      return error;
+    }
+
+    args.flags = FT_OPEN_STREAM;
+    args.stream = stream;
+    if ( driver_name )
+    {
+      args.flags = args.flags | FT_OPEN_DRIVER;
+      args.driver = FT_Get_Module( library, driver_name );
+    }
+
+    error = FT_Open_Face( library, &args, face_index, aface );
+
+    if ( error == FT_Err_Ok )
+      (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
+    else
+    {
+      FT_Stream_Close( stream );
+      FT_FREE( stream );
+    }
+
+    return error;
+  }
+
+
+  /* The resource header says we've got resource_cnt `POST' (type1) */
+  /* resources in this file.  They all need to be coalesced into    */
+  /* one lump which gets passed on to the type1 driver.             */
+  /* Here can be only one PostScript font in a file so face_index   */
+  /* must be 0 (or -1).                                             */
+  /*                                                                */
+  static FT_Error
+  Mac_Read_POST_Resource( FT_Library  library,
+                          FT_Stream   stream,
+                          FT_Long    *offsets,
+                          FT_Long     resource_cnt,
+                          FT_Long     face_index,
+                          FT_Face    *aface )
+  {
+    FT_Error   error  = FT_Err_Cannot_Open_Resource;
+    FT_Memory  memory = library->memory;
+    FT_Byte*   pfb_data;
+    int        i, type, flags;
+    FT_Long    len;
+    FT_Long    pfb_len, pfb_pos, pfb_lenpos;
+    FT_Long    rlen, temp;
+
+
+    if ( face_index == -1 )
+      face_index = 0;
+    if ( face_index != 0 )
+      return error;
+
+    /* Find the length of all the POST resources, concatenated.  Assume */
+    /* worst case (each resource in its own section).                   */
+    pfb_len = 0;
+    for ( i = 0; i < resource_cnt; ++i )
+    {
+      error = FT_Stream_Seek( stream, offsets[i] );
+      if ( error )
+        goto Exit;
+      if ( FT_READ_LONG( temp ) )
+        goto Exit;
+      pfb_len += temp + 6;
+    }
+
+    if ( FT_ALLOC( pfb_data, (FT_Long)pfb_len + 2 ) )
+      goto Exit;
+
+    pfb_data[0] = 0x80;
+    pfb_data[1] = 1;            /* Ascii section */
+    pfb_data[2] = 0;            /* 4-byte length, fill in later */
+    pfb_data[3] = 0;
+    pfb_data[4] = 0;
+    pfb_data[5] = 0;
+    pfb_pos     = 7;
+    pfb_lenpos  = 2;
+
+    len = 0;
+    type = 1;
+    for ( i = 0; i < resource_cnt; ++i )
+    {
+      error = FT_Stream_Seek( stream, offsets[i] );
+      if ( error )
+        goto Exit2;
+      if ( FT_READ_LONG( rlen ) )
+        goto Exit;
+      if ( FT_READ_USHORT( flags ) )
+        goto Exit;
+      rlen -= 2;                    /* the flags are part of the resource */
+      if ( ( flags >> 8 ) == type )
+        len += rlen;
+      else
+      {
+        pfb_data[pfb_lenpos    ] = (FT_Byte)( len );
+        pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 );
+        pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 );
+        pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 );
+
+        if ( ( flags >> 8 ) == 5 )      /* End of font mark */
+          break;
+
+        pfb_data[pfb_pos++] = 0x80;
+
+        type = flags >> 8;
+        len = rlen;
+
+        pfb_data[pfb_pos++] = (FT_Byte)type;
+        pfb_lenpos          = (FT_Byte)pfb_pos;
+        pfb_data[pfb_pos++] = 0;        /* 4-byte length, fill in later */
+        pfb_data[pfb_pos++] = 0;
+        pfb_data[pfb_pos++] = 0;
+        pfb_data[pfb_pos++] = 0;
+      }
+
+      error = FT_Stream_Read( stream, (FT_Byte *)pfb_data + pfb_pos, rlen );
+      pfb_pos += rlen;
+    }
+
+    pfb_data[pfb_pos++] = 0x80;
+    pfb_data[pfb_pos++] = 3;
+
+    pfb_data[pfb_lenpos    ] = (FT_Byte)( len );
+    pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 );
+    pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 );
+    pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 );
+
+    return open_face_from_buffer( library,
+                                  pfb_data,
+                                  pfb_pos,
+                                  face_index,
+                                  "type1",
+                                  aface );
+
+  Exit2:
+    FT_FREE( pfb_data );
+
+  Exit:
+    return error;
+  }
+
+
+  /* The resource header says we've got resource_cnt `sfnt'      */
+  /* (TrueType/OpenType) resources in this file.  Look through   */
+  /* them for the one indicated by face_index, load it into mem, */
+  /* pass it on the the truetype driver and return it.           */
+  /*                                                             */
+  static FT_Error
+  Mac_Read_sfnt_Resource( FT_Library  library,
+                          FT_Stream   stream,
+                          FT_Long    *offsets,
+                          FT_Long     resource_cnt,
+                          FT_Long     face_index,
+                          FT_Face    *aface )
+  {
+    FT_Memory  memory = library->memory;
+    FT_Byte*   sfnt_data;
+    FT_Error   error;
+    FT_Long    flag_offset;
+    FT_Long    rlen;
+    int        is_cff;
+
+
+    if ( face_index == -1 )
+      face_index = 0;
+    if ( face_index >= resource_cnt )
+      return FT_Err_Cannot_Open_Resource;
+
+    flag_offset = offsets[face_index];
+    error = FT_Stream_Seek( stream, flag_offset );
+    if ( error )
+      goto Exit;
+
+    if ( FT_READ_LONG( rlen ) )
+      goto Exit;
+    if ( rlen == -1 )
+      return FT_Err_Cannot_Open_Resource;
+
+    if ( FT_ALLOC( sfnt_data, (FT_Long)rlen ) )
+      return error;
+    error = FT_Stream_Read( stream, (FT_Byte *)sfnt_data, rlen );
+    if ( error )
+      goto Exit;
+
+    is_cff = rlen > 4 && sfnt_data[0] == 'O' &&
+                         sfnt_data[1] == 'T' &&
+                         sfnt_data[2] == 'T' &&
+                         sfnt_data[3] == 'O';
+
+    error = open_face_from_buffer( library,
+                                   sfnt_data,
+                                   rlen,
+                                   face_index,
+                                   is_cff ? "cff" : "truetype",
+                                   aface );
+
+  Exit:
+    return error;
+  }
+
+
+  /* Check for a valid resource fork header, or a valid dfont    */
+  /* header.  In a resource fork the first 16 bytes are repeated */
+  /* at the location specified by bytes 4-7.  In a dfont bytes   */
+  /* 4-7 point to 16 bytes of zeroes instead.                    */
+  /*                                                             */
+  static FT_Error
+  IsMacResource( FT_Library  library,
+                 FT_Stream   stream,
+                 FT_Long     resource_offset,
+                 FT_Long     face_index,
+                 FT_Face    *aface )
+  {
+    FT_Memory  memory = library->memory;
+    FT_Error   error;
+    FT_Long    map_offset, rdara_pos;
+    FT_Long    *data_offsets;
+    FT_Long    count;
+
+
+    error = FT_Raccess_Get_HeaderInfo( library, stream, resource_offset,
+                                       &map_offset, &rdara_pos );
+    if ( error )
+      return error;
+
+    error = FT_Raccess_Get_DataOffsets( library, stream,
+                                        map_offset, rdara_pos,
+                                        FT_MAKE_TAG( 'P', 'O', 'S', 'T' ),
+                                        &data_offsets, &count );
+    if ( !error )
+    {
+      error = Mac_Read_POST_Resource( library, stream, data_offsets, count,
+                                      face_index, aface );
+      FT_FREE( data_offsets );
+      return error;
+    }
+
+    error = FT_Raccess_Get_DataOffsets( library, stream,
+                                        map_offset, rdara_pos,
+                                        FT_MAKE_TAG( 's', 'f', 'n', 't' ),
+                                        &data_offsets, &count );
+    if ( !error )
+    {
+      error = Mac_Read_sfnt_Resource( library, stream, data_offsets, count,
+                                      face_index, aface );
+      FT_FREE( data_offsets );
+    }
+
+    return error;
+  }
+
+
+  /* Check for a valid macbinary header, and if we find one   */
+  /* check that the (flattened) resource fork in it is valid. */
+  /*                                                          */
+  static FT_Error
+  IsMacBinary( FT_Library  library,
+               FT_Stream   stream,
+               FT_Long     face_index,
+               FT_Face    *aface )
+  {
+    unsigned char  header[128];
+    FT_Error       error;
+    FT_Long        dlen, offset;
+
+
+    error = FT_Stream_Seek( stream, 0 );
+    if ( error )
+      goto Exit;
+
+    error = FT_Stream_Read( stream, (FT_Byte*)header, 128 );
+    if ( error )
+      goto Exit;
+
+    if (            header[ 0] !=  0 ||
+                    header[74] !=  0 ||
+                    header[82] !=  0 ||
+                    header[ 1] ==  0 ||
+                    header[ 1] >  33 ||
+                    header[63] !=  0 ||
+         header[2 + header[1]] !=  0 )
+      return FT_Err_Unknown_File_Format;
+
+    dlen = ( header[0x53] << 24 ) |
+           ( header[0x54] << 16 ) |
+           ( header[0x55] <<  8 ) |
+             header[0x56];
+#if 0
+    rlen = ( header[0x57] << 24 ) |
+           ( header[0x58] << 16 ) |
+           ( header[0x59] <<  8 ) |
+             header[0x5a];
+#endif /* 0 */
+    offset = 128 + ( ( dlen + 127 ) & ~127 );
+
+    return IsMacResource( library, stream, offset, face_index, aface );
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  load_face_in_embedded_rfork( FT_Library           library,
+                               FT_Stream            stream,
+                               FT_Long              face_index,
+                               FT_Face             *aface,
+                               const FT_Open_Args  *args )
+  {
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_raccess
+
+    FT_Memory  memory = library->memory;
+    FT_Error   error  = FT_Err_Unknown_File_Format;
+    int        i;
+
+    char *     file_names[FT_RACCESS_N_RULES];
+    FT_Long    offsets[FT_RACCESS_N_RULES];
+    FT_Error   errors[FT_RACCESS_N_RULES];
+
+    FT_Open_Args  args2;
+    FT_Stream     stream2;
+
+
+    FT_Raccess_Guess( library, stream,
+                      args->pathname, file_names, offsets, errors );
+
+    for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
+    {
+      if ( errors[i] )
+      {
+        FT_TRACE3(( "Error[%d] has occurred in rule %d\n", errors[i], i ));
+        continue;
+      }
+
+      args2.flags    = FT_OPEN_PATHNAME;
+      args2.pathname = file_names[i] ? file_names[i] : args->pathname;
+
+      FT_TRACE3(( "Try rule %d: %s (offset=%d) ...",
+                  i, args2.pathname, offsets[i] ));
+
+      error = FT_Stream_New( library, &args2, &stream2 );
+      if ( error )
+      {
+        FT_TRACE3(( "failed\n" ));
+        continue;
+      }
+
+      error = IsMacResource( library, stream2, offsets[i],
+                             face_index, aface );
+      FT_Stream_Close( stream2 );
+
+      FT_TRACE3(( "%s\n", error ? "failed": "successful" ));
+
+      if ( !error )
+          break;
+    }
+
+    for (i = 0; i < FT_RACCESS_N_RULES; i++)
+    {
+      if ( file_names[i] )
+        FT_FREE( file_names[i] );
+    }
+
+    /* Caller (load_mac_face) requires FT_Err_Unknown_File_Format. */
+    if ( error )
+      error = FT_Err_Unknown_File_Format;
+
+    return error;
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_objs
+
+  }
+
+
+  /* Check for some macintosh formats.                             */
+  /* Is this a macbinary file?  If so look at the resource fork.   */
+  /* Is this a mac dfont file?                                     */
+  /* Is this an old style resource fork? (in data)                 */
+  /* Else call load_face_in_embedded_rfork to try extra rules      */
+  /* (defined in `ftrfork.c').                                     */
+  /*                                                               */
+  static FT_Error
+  load_mac_face( FT_Library           library,
+                 FT_Stream            stream,
+                 FT_Long              face_index,
+                 FT_Face             *aface,
+                 const FT_Open_Args  *args )
+  {
+    FT_Error error;
+    FT_UNUSED( args );
+
+
+    error = IsMacBinary( library, stream, face_index, aface );
+    if ( FT_ERROR_BASE( error ) == FT_Err_Unknown_File_Format )
+    {
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_raccess
+
+      FT_TRACE3(( "Try as dfont: %s ...", args->pathname ));
+
+      error = IsMacResource( library, stream, 0, face_index, aface );
+
+      FT_TRACE3(( "%s\n", error ? "failed" : "successful" ));
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_objs
+
+    }
+
+    if ( ( FT_ERROR_BASE( error ) == FT_Err_Unknown_File_Format      ||
+           FT_ERROR_BASE( error ) == FT_Err_Invalid_Stream_Operation ) &&
+         ( args->flags & FT_OPEN_PATHNAME )                            )
+      error = load_face_in_embedded_rfork( library, stream,
+                                           face_index, aface, args );
+    return error;
+  }
+
+#endif  /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Open_Face( FT_Library           library,
+                const FT_Open_Args*  args,
+                FT_Long              face_index,
+                FT_Face             *aface )
+  {
+    FT_Error     error;
+    FT_Driver    driver;
+    FT_Memory    memory;
+    FT_Stream    stream;
+    FT_Face      face = 0;
+    FT_ListNode  node = 0;
+    FT_Bool      external_stream;
+
+
+    /* test for valid `library' delayed to */
+    /* FT_Stream_New()                     */
+
+    if ( !aface || !args )
+      return FT_Err_Invalid_Argument;
+
+    *aface = 0;
+
+    external_stream = FT_BOOL( ( args->flags & FT_OPEN_STREAM ) &&
+                               args->stream                     );
+
+    /* create input stream */
+    error = FT_Stream_New( library, args, &stream );
+    if ( error )
+      goto Exit;
+
+    memory = library->memory;
+
+    /* If the font driver is specified in the `args' structure, use */
+    /* it.  Otherwise, we scan the list of registered drivers.      */
+    if ( ( args->flags & FT_OPEN_DRIVER ) && args->driver )
+    {
+      driver = FT_DRIVER( args->driver );
+
+      /* not all modules are drivers, so check... */
+      if ( FT_MODULE_IS_DRIVER( driver ) )
+      {
+        FT_Int         num_params = 0;
+        FT_Parameter*  params     = 0;
+
+
+        if ( args->flags & FT_OPEN_PARAMS )
+        {
+          num_params = args->num_params;
+          params     = args->params;
+        }
+
+        error = open_face( driver, stream, face_index,
+                           num_params, params, &face );
+        if ( !error )
+          goto Success;
+      }
+      else
+        error = FT_Err_Invalid_Handle;
+
+      FT_Stream_Free( stream, external_stream );
+      goto Fail;
+    }
+    else
+    {
+      /* check each font driver for an appropriate format */
+      FT_Module*  cur   = library->modules;
+      FT_Module*  limit = cur + library->num_modules;
+
+
+      for ( ; cur < limit; cur++ )
+      {
+        /* not all modules are font drivers, so check... */
+        if ( FT_MODULE_IS_DRIVER( cur[0] ) )
+        {
+          FT_Int         num_params = 0;
+          FT_Parameter*  params     = 0;
+
+
+          driver = FT_DRIVER( cur[0] );
+
+          if ( args->flags & FT_OPEN_PARAMS )
+          {
+            num_params = args->num_params;
+            params     = args->params;
+          }
+
+          error = open_face( driver, stream, face_index,
+                             num_params, params, &face );
+          if ( !error )
+            goto Success;
+
+          if ( FT_ERROR_BASE( error ) != FT_Err_Unknown_File_Format )
+            goto Fail3;
+        }
+      }
+
+  Fail3:
+    /* If we are on the mac, and we get an FT_Err_Invalid_Stream_Operation */
+    /* it may be because we have an empty data fork, so we need to check   */
+    /* the resource fork.                                                  */
+    if ( FT_ERROR_BASE( error ) != FT_Err_Unknown_File_Format      &&
+         FT_ERROR_BASE( error ) != FT_Err_Invalid_Stream_Operation )
+      goto Fail2;
+
+#if !defined( FT_MACINTOSH ) && defined( FT_CONFIG_OPTION_MAC_FONTS )
+    error = load_mac_face( library, stream, face_index, aface, args );
+    if ( !error )
+    {
+      /* We don't want to go to Success here.  We've already done that. */
+      /* On the other hand, if we succeeded we still need to close this */
+      /* stream (we opened a different stream which extracted the       */
+      /* interesting information out of this stream here.  That stream  */
+      /* will still be open and the face will point to it).             */
+      FT_Stream_Free( stream, external_stream );
+      return error;
+    }
+
+    if ( FT_ERROR_BASE( error ) != FT_Err_Unknown_File_Format )
+      goto Fail2;
+#endif  /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */
+
+      /* no driver is able to handle this format */
+      error = FT_Err_Unknown_File_Format;
+
+  Fail2:
+      FT_Stream_Free( stream, external_stream );
+      goto Fail;
+    }
+
+  Success:
+    FT_TRACE4(( "FT_Open_Face: New face object, adding to list\n" ));
+
+    /* set the FT_FACE_FLAG_EXTERNAL_STREAM bit for FT_Done_Face */
+    if ( external_stream )
+      face->face_flags |= FT_FACE_FLAG_EXTERNAL_STREAM;
+
+    /* add the face object to its driver's list */
+    if ( FT_NEW( node ) )
+      goto Fail;
+
+    node->data = face;
+    /* don't assume driver is the same as face->driver, so use */
+    /* face->driver instead.                                   */
+    FT_List_Add( &face->driver->faces_list, node );
+
+    /* now allocate a glyph slot object for the face */
+    {
+      FT_GlyphSlot  slot;
+
+
+      FT_TRACE4(( "FT_Open_Face: Creating glyph slot\n" ));
+
+      error = FT_New_GlyphSlot( face, &slot );
+      if ( error )
+        goto Fail;
+
+      face->glyph = slot;
+    }
+
+    /* finally, allocate a size object for the face */
+    {
+      FT_Size  size;
+
+
+      FT_TRACE4(( "FT_Open_Face: Creating size object\n" ));
+
+      error = FT_New_Size( face, &size );
+      if ( error )
+        goto Fail;
+
+      face->size = size;
+    }
+
+    /* initialize internal face data */
+    {
+      FT_Face_Internal  internal = face->internal;
+
+
+      internal->transform_matrix.xx = 0x10000L;
+      internal->transform_matrix.xy = 0;
+      internal->transform_matrix.yx = 0;
+      internal->transform_matrix.yy = 0x10000L;
+
+      internal->transform_delta.x = 0;
+      internal->transform_delta.y = 0;
+    }
+
+    *aface = face;
+    goto Exit;
+
+  Fail:
+    FT_Done_Face( face );
+
+  Exit:
+    FT_TRACE4(( "FT_Open_Face: Return %d\n", error ));
+
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Attach_File( FT_Face      face,
+                  const char*  filepathname )
+  {
+    FT_Open_Args  open;
+
+
+    /* test for valid `face' delayed to FT_Attach_Stream() */
+
+    if ( !filepathname )
+      return FT_Err_Invalid_Argument;
+
+    open.flags    = FT_OPEN_PATHNAME;
+    open.pathname = (char*)filepathname;
+
+    return FT_Attach_Stream( face, &open );
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Attach_Stream( FT_Face        face,
+                    FT_Open_Args*  parameters )
+  {
+    FT_Stream  stream;
+    FT_Error   error;
+    FT_Driver  driver;
+
+    FT_Driver_Class  clazz;
+
+
+    /* test for valid `parameters' delayed to FT_Stream_New() */
+
+    if ( !face )
+      return FT_Err_Invalid_Face_Handle;
+
+    driver = face->driver;
+    if ( !driver )
+      return FT_Err_Invalid_Driver_Handle;
+
+    error = FT_Stream_New( driver->root.library, parameters, &stream );
+    if ( error )
+      goto Exit;
+
+    /* we implement FT_Attach_Stream in each driver through the */
+    /* `attach_file' interface                                  */
+
+    error = FT_Err_Unimplemented_Feature;
+    clazz = driver->clazz;
+    if ( clazz->attach_file )
+      error = clazz->attach_file( face, stream );
+
+    /* close the attached stream */
+    FT_Stream_Free( stream,
+                    (FT_Bool)( parameters->stream &&
+                               ( parameters->flags & FT_OPEN_STREAM ) ) );
+
+  Exit:
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Done_Face( FT_Face  face )
+  {
+    FT_Error     error;
+    FT_Driver    driver;
+    FT_Memory    memory;
+    FT_ListNode  node;
+
+
+    error = FT_Err_Invalid_Face_Handle;
+    if ( face && face->driver )
+    {
+      driver = face->driver;
+      memory = driver->root.memory;
+
+      /* find face in driver's list */
+      node = FT_List_Find( &driver->faces_list, face );
+      if ( node )
+      {
+        /* remove face object from the driver's list */
+        FT_List_Remove( &driver->faces_list, node );
+        FT_FREE( node );
+
+        /* now destroy the object proper */
+        destroy_face( memory, face, driver );
+        error = FT_Err_Ok;
+      }
+    }
+    return error;
+  }
+
+
+  /* documentation is in ftobjs.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_New_Size( FT_Face   face,
+               FT_Size  *asize )
+  {
+    FT_Error         error;
+    FT_Memory        memory;
+    FT_Driver        driver;
+    FT_Driver_Class  clazz;
+
+    FT_Size          size = 0;
+    FT_ListNode      node = 0;
+
+
+    if ( !face )
+      return FT_Err_Invalid_Face_Handle;
+
+    if ( !asize )
+      return FT_Err_Invalid_Size_Handle;
+
+    if ( !face->driver )
+      return FT_Err_Invalid_Driver_Handle;
+
+    *asize = 0;
+
+    driver = face->driver;
+    clazz  = driver->clazz;
+    memory = face->memory;
+
+    /* Allocate new size object and perform basic initialisation */
+    if ( FT_ALLOC( size, clazz->size_object_size ) || FT_NEW( node ) )
+      goto Exit;
+
+    size->face = face;
+
+    /* for now, do not use any internal fields in size objects */
+    size->internal = 0;
+
+    if ( clazz->init_size )
+      error = clazz->init_size( size );
+
+    /* in case of success, add to the face's list */
+    if ( !error )
+    {
+      *asize     = size;
+      node->data = size;
+      FT_List_Add( &face->sizes_list, node );
+    }
+
+  Exit:
+    if ( error )
+    {
+      FT_FREE( node );
+      FT_FREE( size );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftobjs.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Done_Size( FT_Size  size )
+  {
+    FT_Error     error;
+    FT_Driver    driver;
+    FT_Memory    memory;
+    FT_Face      face;
+    FT_ListNode  node;
+
+
+    if ( !size )
+      return FT_Err_Invalid_Size_Handle;
+
+    face = size->face;
+    if ( !face )
+      return FT_Err_Invalid_Face_Handle;
+
+    driver = face->driver;
+    if ( !driver )
+      return FT_Err_Invalid_Driver_Handle;
+
+    memory = driver->root.memory;
+
+    error = FT_Err_Ok;
+    node  = FT_List_Find( &face->sizes_list, size );
+    if ( node )
+    {
+      FT_List_Remove( &face->sizes_list, node );
+      FT_FREE( node );
+
+      if ( face->size == size )
+      {
+        face->size = 0;
+        if ( face->sizes_list.head )
+          face->size = (FT_Size)(face->sizes_list.head->data);
+      }
+
+      destroy_size( memory, size, driver );
+    }
+    else
+      error = FT_Err_Invalid_Size_Handle;
+
+    return error;
+  }
+
+
+  static void
+  ft_recompute_scaled_metrics( FT_Face           face,
+                               FT_Size_Metrics*  metrics )
+  {
+    /* Compute root ascender, descender, test height, and max_advance */
+
+    metrics->ascender    = FT_PIX_CEIL( FT_MulFix( face->ascender,
+                                                   metrics->y_scale ) );
+
+    metrics->descender   = FT_PIX_FLOOR( FT_MulFix( face->descender,
+                                                    metrics->y_scale ) );
+
+    metrics->height      = FT_PIX_ROUND( FT_MulFix( face->height,
+                                                    metrics->y_scale ) );
+
+    metrics->max_advance = FT_PIX_ROUND( FT_MulFix( face->max_advance_width,
+                                                    metrics->x_scale ) );
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Set_Char_Size( FT_Face     face,
+                    FT_F26Dot6  char_width,
+                    FT_F26Dot6  char_height,
+                    FT_UInt     horz_resolution,
+                    FT_UInt     vert_resolution )
+  {
+    FT_Error          error = FT_Err_Ok;
+    FT_Driver         driver;
+    FT_Driver_Class   clazz;
+    FT_Size_Metrics*  metrics;
+    FT_Long           dim_x, dim_y;
+
+
+    if ( !face || !face->size || !face->driver )
+      return FT_Err_Invalid_Face_Handle;
+
+    driver  = face->driver;
+    metrics = &face->size->metrics;
+    clazz   = driver->clazz;
+
+    if ( !char_width )
+      char_width = char_height;
+
+    else if ( !char_height )
+      char_height = char_width;
+
+    if ( !horz_resolution )
+      horz_resolution = 72;
+
+    if ( !vert_resolution )
+      vert_resolution = 72;
+
+    /* default processing -- this can be overridden by the driver */
+    if ( char_width  < 1 * 64 )
+      char_width  = 1 * 64;
+    if ( char_height < 1 * 64 )
+      char_height = 1 * 64;
+
+    /* Compute pixel sizes in 26.6 units */
+    dim_x = ( char_width  * horz_resolution + 36 ) / 72;
+    dim_y = ( char_height * vert_resolution + 36 ) / 72;
+
+    {
+      FT_UShort  x_ppem = (FT_UShort)( ( dim_x + 32 ) >> 6 );
+      FT_UShort  y_ppem = (FT_UShort)( ( dim_y + 32 ) >> 6 );
+
+      if ( x_ppem == metrics->x_ppem && y_ppem == metrics->y_ppem )
+        return FT_Err_Ok;
+
+      metrics->x_ppem = x_ppem;
+      metrics->y_ppem = y_ppem;
+    }
+
+    metrics->x_scale = 0x10000L;
+    metrics->y_scale = 0x10000L;
+
+    if ( face->face_flags & FT_FACE_FLAG_SCALABLE )
+    {
+      metrics->x_scale = FT_DivFix( dim_x, face->units_per_EM );
+      metrics->y_scale = FT_DivFix( dim_y, face->units_per_EM );
+
+      ft_recompute_scaled_metrics( face, metrics );
+    }
+
+    if ( clazz->set_char_sizes )
+      error = clazz->set_char_sizes( face->size,
+                                     char_width,
+                                     char_height,
+                                     horz_resolution,
+                                     vert_resolution );
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Set_Pixel_Sizes( FT_Face  face,
+                      FT_UInt  pixel_width,
+                      FT_UInt  pixel_height )
+  {
+    FT_Error          error = FT_Err_Ok;
+    FT_Driver         driver;
+    FT_Driver_Class   clazz;
+    FT_Size_Metrics*  metrics;
+
+
+    if ( !face || !face->size || !face->driver )
+      return FT_Err_Invalid_Face_Handle;
+
+    driver  = face->driver;
+    metrics = &face->size->metrics;
+    clazz   = driver->clazz;
+
+    if ( pixel_width == 0 )
+      pixel_width = pixel_height;
+
+    else if ( pixel_height == 0 )
+      pixel_height = pixel_width;
+
+    if ( pixel_width  < 1 )
+      pixel_width  = 1;
+    if ( pixel_height < 1 )
+      pixel_height = 1;
+
+    /* use `>=' to avoid potention compiler warning on 16bit platforms */
+    if ( pixel_width  >= 0xFFFFU )
+      pixel_width  = 0xFFFFU;
+    if ( pixel_height >= 0xFFFFU )
+      pixel_height = 0xFFFFU;
+
+    metrics->x_ppem = (FT_UShort)pixel_width;
+    metrics->y_ppem = (FT_UShort)pixel_height;
+
+    if ( face->face_flags & FT_FACE_FLAG_SCALABLE )
+    {
+      metrics->x_scale = FT_DivFix( metrics->x_ppem << 6,
+                                    face->units_per_EM );
+
+      metrics->y_scale = FT_DivFix( metrics->y_ppem << 6,
+                                    face->units_per_EM );
+
+      ft_recompute_scaled_metrics( face, metrics );
+    }
+
+    if ( clazz->set_pixel_sizes )
+      error = clazz->set_pixel_sizes( face->size,
+                                      pixel_width,
+                                      pixel_height );
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_Kerning( FT_Face     face,
+                  FT_UInt     left_glyph,
+                  FT_UInt     right_glyph,
+                  FT_UInt     kern_mode,
+                  FT_Vector  *akerning )
+  {
+    FT_Error   error = FT_Err_Ok;
+    FT_Driver  driver;
+
+
+    if ( !face )
+      return FT_Err_Invalid_Face_Handle;
+
+    if ( !akerning )
+      return FT_Err_Invalid_Argument;
+
+    driver = face->driver;
+
+    akerning->x = 0;
+    akerning->y = 0;
+
+    if ( driver->clazz->get_kerning )
+    {
+      error = driver->clazz->get_kerning( face,
+                                          left_glyph,
+                                          right_glyph,
+                                          akerning );
+      if ( !error )
+      {
+        if ( kern_mode != FT_KERNING_UNSCALED )
+        {
+          akerning->x = FT_MulFix( akerning->x, face->size->metrics.x_scale );
+          akerning->y = FT_MulFix( akerning->y, face->size->metrics.y_scale );
+
+          if ( kern_mode != FT_KERNING_UNFITTED )
+          {
+            akerning->x = FT_PIX_ROUND( akerning->x );
+            akerning->y = FT_PIX_ROUND( akerning->y );
+          }
+        }
+      }
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Select_Charmap( FT_Face      face,
+                     FT_Encoding  encoding )
+  {
+    FT_CharMap*  cur;
+    FT_CharMap*  limit;
+
+
+    if ( !face )
+      return FT_Err_Invalid_Face_Handle;
+
+    /* FT_ENCODING_UNICODE is special.  We try to find the `best' Unicode */
+    /* charmap available, i.e., one with UCS-4 characters, if possible.   */
+    /*                                                                    */
+    /* This is done by find_unicode_charmap() above, to share code.       */
+    if ( encoding == FT_ENCODING_UNICODE )
+      return find_unicode_charmap( face );
+
+    cur = face->charmaps;
+    if ( !cur )
+      return FT_Err_Invalid_CharMap_Handle;
+
+    limit = cur + face->num_charmaps;
+
+    for ( ; cur < limit; cur++ )
+    {
+      if ( cur[0]->encoding == encoding )
+      {
+        face->charmap = cur[0];
+        return 0;
+      }
+    }
+
+    return FT_Err_Invalid_Argument;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Set_Charmap( FT_Face     face,
+                  FT_CharMap  charmap )
+  {
+    FT_CharMap*  cur;
+    FT_CharMap*  limit;
+
+
+    if ( !face )
+      return FT_Err_Invalid_Face_Handle;
+
+    cur = face->charmaps;
+    if ( !cur )
+      return FT_Err_Invalid_CharMap_Handle;
+
+    limit = cur + face->num_charmaps;
+
+    for ( ; cur < limit; cur++ )
+    {
+      if ( cur[0] == charmap )
+      {
+        face->charmap = cur[0];
+        return 0;
+      }
+    }
+    return FT_Err_Invalid_Argument;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Int )
+  FT_Get_Charmap_Index( FT_CharMap  charmap )
+  {
+    FT_Int  i;
+
+
+    for ( i = 0; i < charmap->face->num_charmaps; i++ )
+      if ( charmap->face->charmaps[i] == charmap )
+        break;
+
+    FT_ASSERT( i < charmap->face->num_charmaps );
+
+    return i;
+  }
+
+
+  FT_BASE_DEF( void )
+  FT_CMap_Done( FT_CMap  cmap )
+  {
+    if ( cmap )
+    {
+      FT_CMap_Class  clazz  = cmap->clazz;
+      FT_Face        face   = cmap->charmap.face;
+      FT_Memory      memory = FT_FACE_MEMORY(face);
+
+
+      if ( clazz->done )
+        clazz->done( cmap );
+
+      FT_FREE( cmap );
+    }
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_CMap_New( FT_CMap_Class   clazz,
+               FT_Pointer      init_data,
+               FT_CharMap      charmap,
+               FT_CMap        *acmap )
+  {
+    FT_Error   error = 0;
+    FT_Face    face;
+    FT_Memory  memory;
+    FT_CMap    cmap;
+
+
+    if ( clazz == NULL || charmap == NULL || charmap->face == NULL )
+      return FT_Err_Invalid_Argument;
+
+    face   = charmap->face;
+    memory = FT_FACE_MEMORY( face );
+
+    if ( !FT_ALLOC( cmap, clazz->size ) )
+    {
+      cmap->charmap = *charmap;
+      cmap->clazz   = clazz;
+
+      if ( clazz->init )
+      {
+        error = clazz->init( cmap, init_data );
+        if ( error )
+          goto Fail;
+      }
+
+      /* add it to our list of charmaps */
+      if ( FT_RENEW_ARRAY( face->charmaps,
+                           face->num_charmaps,
+                           face->num_charmaps+1 ) )
+        goto Fail;
+
+      face->charmaps[face->num_charmaps++] = (FT_CharMap)cmap;
+    }
+
+  Exit:
+    if ( acmap )
+      *acmap = cmap;
+
+    return error;
+
+  Fail:
+    FT_CMap_Done( cmap );
+    cmap = NULL;
+    goto Exit;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_UInt )
+  FT_Get_Char_Index( FT_Face   face,
+                     FT_ULong  charcode )
+  {
+    FT_UInt  result = 0;
+
+
+    if ( face && face->charmap )
+    {
+      FT_CMap  cmap = FT_CMAP( face->charmap );
+
+
+      result = cmap->clazz->char_index( cmap, charcode );
+    }
+    return  result;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_ULong )
+  FT_Get_First_Char( FT_Face   face,
+                     FT_UInt  *agindex )
+  {
+    FT_ULong  result = 0;
+    FT_UInt   gindex = 0;
+
+
+    if ( face && face->charmap )
+    {
+      gindex = FT_Get_Char_Index( face, 0 );
+      if ( gindex == 0 )
+        result = FT_Get_Next_Char( face, 0, &gindex );
+    }
+
+    if ( agindex  )
+      *agindex = gindex;
+
+    return result;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_ULong )
+  FT_Get_Next_Char( FT_Face   face,
+                    FT_ULong  charcode,
+                    FT_UInt  *agindex )
+  {
+    FT_ULong  result = 0;
+    FT_UInt   gindex = 0;
+
+
+    if ( face && face->charmap )
+    {
+      FT_UInt32  code = (FT_UInt32)charcode;
+      FT_CMap    cmap = FT_CMAP( face->charmap );
+
+
+      gindex = cmap->clazz->char_next( cmap, &code );
+      result = ( gindex == 0 ) ? 0 : code;
+    }
+
+    if ( agindex )
+      *agindex = gindex;
+
+    return result;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_UInt )
+  FT_Get_Name_Index( FT_Face     face,
+                     FT_String*  glyph_name )
+  {
+    FT_UInt  result = 0;
+
+
+    if ( face && FT_HAS_GLYPH_NAMES( face ) )
+    {
+      FT_Service_GlyphDict  service;
+
+
+      FT_FACE_LOOKUP_SERVICE( face,
+                              service,
+                              GLYPH_DICT );
+
+      if ( service && service->name_index )
+        result = service->name_index( face, glyph_name );
+    }
+
+    return result;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_Glyph_Name( FT_Face     face,
+                     FT_UInt     glyph_index,
+                     FT_Pointer  buffer,
+                     FT_UInt     buffer_max )
+  {
+    FT_Error  error = FT_Err_Invalid_Argument;
+
+
+    /* clean up buffer */
+    if ( buffer && buffer_max > 0 )
+      ((FT_Byte*)buffer)[0] = 0;
+
+    if ( face                                     &&
+         glyph_index <= (FT_UInt)face->num_glyphs &&
+         FT_HAS_GLYPH_NAMES( face )               )
+    {
+      FT_Service_GlyphDict  service;
+
+
+      FT_FACE_LOOKUP_SERVICE( face,
+                              service,
+                              GLYPH_DICT );
+
+      if ( service && service->get_name )
+        error = service->get_name( face, glyph_index, buffer, buffer_max );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( const char* )
+  FT_Get_Postscript_Name( FT_Face  face )
+  {
+    const char*  result = NULL;
+
+
+    if ( !face )
+      goto Exit;
+
+    if ( !result )
+    {
+      FT_Service_PsFontName  service;
+
+
+      FT_FACE_LOOKUP_SERVICE( face,
+                              service,
+                              POSTSCRIPT_FONT_NAME );
+
+      if ( service && service->get_ps_font_name )
+        result = service->get_ps_font_name( face );
+    }
+
+  Exit:
+    return result;
+  }
+
+
+  /* documentation is in tttables.h */
+
+  FT_EXPORT_DEF( void* )
+  FT_Get_Sfnt_Table( FT_Face      face,
+                     FT_Sfnt_Tag  tag )
+  {
+    void*                  table = 0;
+    FT_Service_SFNT_Table  service;
+
+
+    if ( face && FT_IS_SFNT( face ) )
+    {
+      FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
+      if ( service != NULL )
+        table = service->get_table( face, tag );
+    }
+
+    return table;
+  }
+
+
+  /* documentation is in tttables.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Load_Sfnt_Table( FT_Face    face,
+                      FT_ULong   tag,
+                      FT_Long    offset,
+                      FT_Byte*   buffer,
+                      FT_ULong*  length )
+  {
+    FT_Service_SFNT_Table  service;
+
+
+    if ( !face || !FT_IS_SFNT( face ) )
+      return FT_Err_Invalid_Face_Handle;
+
+    FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
+    if ( service == NULL )
+      return FT_Err_Unimplemented_Feature;
+
+    return service->load_table( face, tag, offset, buffer, length );
+  }
+
+
+  FT_EXPORT_DEF( FT_ULong )
+  FT_Get_CMap_Language_ID( FT_CharMap  charmap )
+  {
+    FT_Service_TTCMaps  service;
+    FT_Face             face;
+    TT_CMapInfo         cmap_info;
+
+
+    if ( !charmap || !charmap->face )
+      return 0;
+
+    face = charmap->face;
+    FT_FACE_FIND_SERVICE( face, service, TT_CMAP );
+    if ( service == NULL )
+      return 0;
+    if ( service->get_cmap_info( charmap, &cmap_info ))
+      return 0;
+
+    return cmap_info.language;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Activate_Size( FT_Size  size )
+  {
+    FT_Face  face;
+
+
+    if ( size == NULL )
+      return FT_Err_Bad_Argument;
+
+    face = size->face;
+    if ( face == NULL || face->driver == NULL )
+      return FT_Err_Bad_Argument;
+
+    /* we don't need anything more complex than that; all size objects */
+    /* are already listed by the face                                  */
+    face->size = size;
+
+    return FT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                        R E N D E R E R S                        ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* lookup a renderer by glyph format in the library's list */
+  FT_BASE_DEF( FT_Renderer )
+  FT_Lookup_Renderer( FT_Library       library,
+                      FT_Glyph_Format  format,
+                      FT_ListNode*     node )
+  {
+    FT_ListNode  cur;
+    FT_Renderer  result = 0;
+
+
+    if ( !library )
+      goto Exit;
+
+    cur = library->renderers.head;
+
+    if ( node )
+    {
+      if ( *node )
+        cur = (*node)->next;
+      *node = 0;
+    }
+
+    while ( cur )
+    {
+      FT_Renderer  renderer = FT_RENDERER( cur->data );
+
+
+      if ( renderer->glyph_format == format )
+      {
+        if ( node )
+          *node = cur;
+
+        result = renderer;
+        break;
+      }
+      cur = cur->next;
+    }
+
+  Exit:
+    return result;
+  }
+
+
+  static FT_Renderer
+  ft_lookup_glyph_renderer( FT_GlyphSlot  slot )
+  {
+    FT_Face      face    = slot->face;
+    FT_Library   library = FT_FACE_LIBRARY( face );
+    FT_Renderer  result  = library->cur_renderer;
+
+
+    if ( !result || result->glyph_format != slot->format )
+      result = FT_Lookup_Renderer( library, slot->format, 0 );
+
+    return result;
+  }
+
+
+  static void
+  ft_set_current_renderer( FT_Library  library )
+  {
+    FT_Renderer  renderer;
+
+
+    renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE, 0 );
+    library->cur_renderer = renderer;
+  }
+
+
+  static FT_Error
+  ft_add_renderer( FT_Module  module )
+  {
+    FT_Library   library = module->library;
+    FT_Memory    memory  = library->memory;
+    FT_Error     error;
+    FT_ListNode  node;
+
+
+    if ( FT_NEW( node ) )
+      goto Exit;
+
+    {
+      FT_Renderer         render = FT_RENDERER( module );
+      FT_Renderer_Class*  clazz  = (FT_Renderer_Class*)module->clazz;
+
+
+      render->clazz        = clazz;
+      render->glyph_format = clazz->glyph_format;
+
+      /* allocate raster object if needed */
+      if ( clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE &&
+           clazz->raster_class->raster_new )
+      {
+        error = clazz->raster_class->raster_new( memory, &render->raster );
+        if ( error )
+          goto Fail;
+
+        render->raster_render = clazz->raster_class->raster_render;
+        render->render        = clazz->render_glyph;
+      }
+
+      /* add to list */
+      node->data = module;
+      FT_List_Add( &library->renderers, node );
+
+      ft_set_current_renderer( library );
+    }
+
+  Fail:
+    if ( error )
+      FT_FREE( node );
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  ft_remove_renderer( FT_Module  module )
+  {
+    FT_Library   library = module->library;
+    FT_Memory    memory  = library->memory;
+    FT_ListNode  node;
+
+
+    node = FT_List_Find( &library->renderers, module );
+    if ( node )
+    {
+      FT_Renderer  render = FT_RENDERER( module );
+
+
+      /* release raster object, if any */
+      if ( render->raster )
+        render->clazz->raster_class->raster_done( render->raster );
+
+      /* remove from list */
+      FT_List_Remove( &library->renderers, node );
+      FT_FREE( node );
+
+      ft_set_current_renderer( library );
+    }
+  }
+
+
+  /* documentation is in ftrender.h */
+
+  FT_EXPORT_DEF( FT_Renderer )
+  FT_Get_Renderer( FT_Library       library,
+                   FT_Glyph_Format  format )
+  {
+    /* test for valid `library' delayed to FT_Lookup_Renderer() */
+
+    return FT_Lookup_Renderer( library, format, 0 );
+  }
+
+
+  /* documentation is in ftrender.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Set_Renderer( FT_Library     library,
+                   FT_Renderer    renderer,
+                   FT_UInt        num_params,
+                   FT_Parameter*  parameters )
+  {
+    FT_ListNode  node;
+    FT_Error     error = FT_Err_Ok;
+
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    if ( !renderer )
+      return FT_Err_Invalid_Argument;
+
+    node = FT_List_Find( &library->renderers, renderer );
+    if ( !node )
+    {
+      error = FT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    FT_List_Up( &library->renderers, node );
+
+    if ( renderer->glyph_format == FT_GLYPH_FORMAT_OUTLINE )
+      library->cur_renderer = renderer;
+
+    if ( num_params > 0 )
+    {
+      FT_Renderer_SetModeFunc  set_mode = renderer->clazz->set_mode;
+
+
+      for ( ; num_params > 0; num_params-- )
+      {
+        error = set_mode( renderer, parameters->tag, parameters->data );
+        if ( error )
+          break;
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Render_Glyph_Internal( FT_Library      library,
+                            FT_GlyphSlot    slot,
+                            FT_Render_Mode  render_mode )
+  {
+    FT_Error     error = FT_Err_Ok;
+    FT_Renderer  renderer;
+
+
+    /* if it is already a bitmap, no need to do anything */
+    switch ( slot->format )
+    {
+    case FT_GLYPH_FORMAT_BITMAP:   /* already a bitmap, don't do anything */
+      break;
+
+    default:
+      {
+        FT_ListNode  node   = 0;
+        FT_Bool      update = 0;
+
+
+        /* small shortcut for the very common case */
+        if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
+        {
+          renderer = library->cur_renderer;
+          node     = library->renderers.head;
+        }
+        else
+          renderer = FT_Lookup_Renderer( library, slot->format, &node );
+
+        error = FT_Err_Unimplemented_Feature;
+        while ( renderer )
+        {
+          error = renderer->render( renderer, slot, render_mode, NULL );
+          if ( !error ||
+               FT_ERROR_BASE( error ) != FT_Err_Cannot_Render_Glyph )
+            break;
+
+          /* FT_Err_Cannot_Render_Glyph is returned if the render mode   */
+          /* is unsupported by the current renderer for this glyph image */
+          /* format.                                                     */
+
+          /* now, look for another renderer that supports the same */
+          /* format.                                               */
+          renderer = FT_Lookup_Renderer( library, slot->format, &node );
+          update   = 1;
+        }
+
+        /* if we changed the current renderer for the glyph image format */
+        /* we need to select it as the next current one                  */
+        if ( !error && update && renderer )
+          FT_Set_Renderer( library, renderer, 0, 0 );
+      }
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Render_Glyph( FT_GlyphSlot    slot,
+                   FT_Render_Mode  render_mode )
+  {
+    FT_Library  library;
+
+
+    if ( !slot )
+      return FT_Err_Invalid_Argument;
+
+    library = FT_FACE_LIBRARY( slot->face );
+
+    return FT_Render_Glyph_Internal( library, slot, render_mode );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                         M O D U L E S                           ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Destroy_Module                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a given module object.  For drivers, this also destroys   */
+  /*    all child faces.                                                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*     module :: A handle to the target driver object.                   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*     The driver _must_ be LOCKED!                                      */
+  /*                                                                       */
+  static void
+  Destroy_Module( FT_Module  module )
+  {
+    FT_Memory         memory  = module->memory;
+    FT_Module_Class*  clazz   = module->clazz;
+    FT_Library        library = module->library;
+
+
+    /* finalize client-data - before anything else */
+    if ( module->generic.finalizer )
+      module->generic.finalizer( module );
+
+    if ( library && library->auto_hinter == module )
+      library->auto_hinter = 0;
+
+    /* if the module is a renderer */
+    if ( FT_MODULE_IS_RENDERER( module ) )
+      ft_remove_renderer( module );
+
+    /* if the module is a font driver, add some steps */
+    if ( FT_MODULE_IS_DRIVER( module ) )
+      Destroy_Driver( FT_DRIVER( module ) );
+
+    /* finalize the module object */
+    if ( clazz->module_done )
+      clazz->module_done( module );
+
+    /* discard it */
+    FT_FREE( module );
+  }
+
+
+  /* documentation is in ftmodule.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Add_Module( FT_Library              library,
+                 const FT_Module_Class*  clazz )
+  {
+    FT_Error   error;
+    FT_Memory  memory;
+    FT_Module  module;
+    FT_UInt    nn;
+
+
+#define FREETYPE_VER_FIXED  ( ( (FT_Long)FREETYPE_MAJOR << 16 ) | \
+                                FREETYPE_MINOR                  )
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    if ( !clazz )
+      return FT_Err_Invalid_Argument;
+
+    /* check freetype version */
+    if ( clazz->module_requires > FREETYPE_VER_FIXED )
+      return FT_Err_Invalid_Version;
+
+    /* look for a module with the same name in the library's table */
+    for ( nn = 0; nn < library->num_modules; nn++ )
+    {
+      module = library->modules[nn];
+      if ( ft_strcmp( module->clazz->module_name, clazz->module_name ) == 0 )
+      {
+        /* this installed module has the same name, compare their versions */
+        if ( clazz->module_version <= module->clazz->module_version )
+          return FT_Err_Lower_Module_Version;
+
+        /* remove the module from our list, then exit the loop to replace */
+        /* it by our new version..                                        */
+        FT_Remove_Module( library, module );
+        break;
+      }
+    }
+
+    memory = library->memory;
+    error  = FT_Err_Ok;
+
+    if ( library->num_modules >= FT_MAX_MODULES )
+    {
+      error = FT_Err_Too_Many_Drivers;
+      goto Exit;
+    }
+
+    /* allocate module object */
+    if ( FT_ALLOC( module, clazz->module_size ) )
+      goto Exit;
+
+    /* base initialization */
+    module->library = library;
+    module->memory  = memory;
+    module->clazz   = (FT_Module_Class*)clazz;
+
+    /* check whether the module is a renderer - this must be performed */
+    /* before the normal module initialization                         */
+    if ( FT_MODULE_IS_RENDERER( module ) )
+    {
+      /* add to the renderers list */
+      error = ft_add_renderer( module );
+      if ( error )
+        goto Fail;
+    }
+
+    /* is the module a auto-hinter? */
+    if ( FT_MODULE_IS_HINTER( module ) )
+      library->auto_hinter = module;
+
+    /* if the module is a font driver */
+    if ( FT_MODULE_IS_DRIVER( module ) )
+    {
+      /* allocate glyph loader if needed */
+      FT_Driver  driver = FT_DRIVER( module );
+
+
+      driver->clazz = (FT_Driver_Class)module->clazz;
+      if ( FT_DRIVER_USES_OUTLINES( driver ) )
+      {
+        error = FT_GlyphLoader_New( memory, &driver->glyph_loader );
+        if ( error )
+          goto Fail;
+      }
+    }
+
+    if ( clazz->module_init )
+    {
+      error = clazz->module_init( module );
+      if ( error )
+        goto Fail;
+    }
+
+    /* add module to the library's table */
+    library->modules[library->num_modules++] = module;
+
+  Exit:
+    return error;
+
+  Fail:
+    if ( FT_MODULE_IS_DRIVER( module ) )
+    {
+      FT_Driver  driver = FT_DRIVER( module );
+
+
+      if ( FT_DRIVER_USES_OUTLINES( driver ) )
+        FT_GlyphLoader_Done( driver->glyph_loader );
+    }
+
+    if ( FT_MODULE_IS_RENDERER( module ) )
+    {
+      FT_Renderer  renderer = FT_RENDERER( module );
+
+
+      if ( renderer->raster )
+        renderer->clazz->raster_class->raster_done( renderer->raster );
+    }
+
+    FT_FREE( module );
+    goto Exit;
+  }
+
+
+  /* documentation is in ftmodule.h */
+
+  FT_EXPORT_DEF( FT_Module )
+  FT_Get_Module( FT_Library   library,
+                 const char*  module_name )
+  {
+    FT_Module   result = 0;
+    FT_Module*  cur;
+    FT_Module*  limit;
+
+
+    if ( !library || !module_name )
+      return result;
+
+    cur   = library->modules;
+    limit = cur + library->num_modules;
+
+    for ( ; cur < limit; cur++ )
+      if ( ft_strcmp( cur[0]->clazz->module_name, module_name ) == 0 )
+      {
+        result = cur[0];
+        break;
+      }
+
+    return result;
+  }
+
+
+  /* documentation is in ftobjs.h */
+
+  FT_BASE_DEF( const void* )
+  FT_Get_Module_Interface( FT_Library   library,
+                           const char*  mod_name )
+  {
+    FT_Module  module;
+
+
+    /* test for valid `library' delayed to FT_Get_Module() */
+
+    module = FT_Get_Module( library, mod_name );
+
+    return module ? module->clazz->module_interface : 0;
+  }
+
+
+  FT_BASE_DEF( FT_Pointer )
+  ft_module_get_service( FT_Module    module,
+                         const char*  service_id )
+  {
+    FT_Pointer  result = NULL;
+
+    if ( module )
+    {
+      FT_ASSERT( module->clazz && module->clazz->get_interface );
+
+     /* first, look for the service in the module
+      */
+      if ( module->clazz->get_interface )
+        result = module->clazz->get_interface( module, service_id );
+
+      if ( result == NULL )
+      {
+       /* we didn't find it, look in all other modules then
+        */
+        FT_Library  library = module->library;
+        FT_Module*  cur     = library->modules;
+        FT_Module*  limit   = cur + library->num_modules;
+
+        for ( ; cur < limit; cur++ )
+        {
+          if ( cur[0] != module )
+          {
+            FT_ASSERT( cur[0]->clazz );
+
+            if ( cur[0]->clazz->get_interface )
+            {
+              result = cur[0]->clazz->get_interface( cur[0], service_id );
+              if ( result != NULL )
+                break;
+            }
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+
+  /* documentation is in ftmodule.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Remove_Module( FT_Library  library,
+                    FT_Module   module )
+  {
+    /* try to find the module from the table, then remove it from there */
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    if ( module )
+    {
+      FT_Module*  cur   = library->modules;
+      FT_Module*  limit = cur + library->num_modules;
+
+
+      for ( ; cur < limit; cur++ )
+      {
+        if ( cur[0] == module )
+        {
+          /* remove it from the table */
+          library->num_modules--;
+          limit--;
+          while ( cur < limit )
+          {
+            cur[0] = cur[1];
+            cur++;
+          }
+          limit[0] = 0;
+
+          /* destroy the module */
+          Destroy_Module( module );
+
+          return FT_Err_Ok;
+        }
+      }
+    }
+    return FT_Err_Invalid_Driver_Handle;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                         L I B R A R Y                           ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* documentation is in ftmodule.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_New_Library( FT_Memory    memory,
+                  FT_Library  *alibrary )
+  {
+    FT_Library  library = 0;
+    FT_Error    error;
+
+
+    if ( !memory )
+      return FT_Err_Invalid_Argument;
+
+#ifdef FT_DEBUG_LEVEL_ERROR
+    /* init debugging support */
+    ft_debug_init();
+#endif
+
+    /* first of all, allocate the library object */
+    if ( FT_NEW( library ) )
+      return error;
+
+    library->memory = memory;
+
+    /* allocate the render pool */
+    library->raster_pool_size = FT_RENDER_POOL_SIZE;
+    if ( FT_ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) )
+      goto Fail;
+
+    /* That's ok now */
+    *alibrary = library;
+
+    return FT_Err_Ok;
+
+  Fail:
+    FT_FREE( library );
+    return error;
+  }
+
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Library_Version( FT_Library   library,
+                      FT_Int      *amajor,
+                      FT_Int      *aminor,
+                      FT_Int      *apatch )
+  {
+    FT_Int  major = 0;
+    FT_Int  minor = 0;
+    FT_Int  patch = 0;
+
+
+    if ( library )
+    {
+      major = library->version_major;
+      minor = library->version_minor;
+      patch = library->version_patch;
+    }
+
+    if ( amajor )
+      *amajor = major;
+
+    if ( aminor )
+      *aminor = minor;
+
+    if ( apatch )
+      *apatch = patch;
+  }
+
+
+  /* documentation is in ftmodule.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Done_Library( FT_Library  library )
+  {
+    FT_Memory  memory;
+
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    memory = library->memory;
+
+    /* Discard client-data */
+    if ( library->generic.finalizer )
+      library->generic.finalizer( library );
+
+    /* Close all modules in the library */
+#if 1
+    while ( library->num_modules > 0 )
+      FT_Remove_Module( library, library->modules[0] );
+#else
+    {
+      FT_UInt  n;
+
+
+      for ( n = 0; n < library->num_modules; n++ )
+      {
+        FT_Module  module = library->modules[n];
+
+
+        if ( module )
+        {
+          Destroy_Module( module );
+          library->modules[n] = 0;
+        }
+      }
+    }
+#endif
+
+    /* Destroy raster objects */
+    FT_FREE( library->raster_pool );
+    library->raster_pool_size = 0;
+
+    FT_FREE( library );
+    return FT_Err_Ok;
+  }
+
+
+  /* documentation is in ftmodule.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Set_Debug_Hook( FT_Library         library,
+                     FT_UInt            hook_index,
+                     FT_DebugHook_Func  debug_hook )
+  {
+    if ( library && debug_hook &&
+         hook_index <
+           ( sizeof ( library->debug_hooks ) / sizeof ( void* ) ) )
+      library->debug_hooks[hook_index] = debug_hook;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftoutln.c b/nx-X11/extras/freetype2/src/base/ftoutln.c
new file mode 100644
index 000000000..5cae931f6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftoutln.c
@@ -0,0 +1,795 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftoutln.c                                                              */
+/*                                                                         */
+/*    FreeType outline management (body).                                  */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* All functions are declared in freetype.h.                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_OUTLINE_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_TRIGONOMETRY_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_outline
+
+
+  static
+  const FT_Outline  null_outline = { 0, 0, 0, 0, 0, 0 };
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_Decompose( FT_Outline*              outline,
+                        const FT_Outline_Funcs*  func_interface,
+                        void*                    user )
+  {
+#undef SCALED
+#define SCALED( x )  ( ( (x) << shift ) - delta )
+
+    FT_Vector   v_last;
+    FT_Vector   v_control;
+    FT_Vector   v_start;
+
+    FT_Vector*  point;
+    FT_Vector*  limit;
+    char*       tags;
+
+    FT_Error    error;
+
+    FT_Int   n;         /* index of contour in outline     */
+    FT_UInt  first;     /* index of first point in contour */
+    FT_Int   tag;       /* current point's state           */
+
+    FT_Int   shift;
+    FT_Pos   delta;
+
+
+    if ( !outline || !func_interface )
+      return FT_Err_Invalid_Argument;
+
+    shift = func_interface->shift;
+    delta = func_interface->delta;
+    first = 0;
+
+    for ( n = 0; n < outline->n_contours; n++ )
+    {
+      FT_Int  last;  /* index of last point in contour */
+
+
+      last  = outline->contours[n];
+      limit = outline->points + last;
+
+      v_start = outline->points[first];
+      v_last  = outline->points[last];
+
+      v_start.x = SCALED( v_start.x ); v_start.y = SCALED( v_start.y );
+      v_last.x  = SCALED( v_last.x );  v_last.y  = SCALED( v_last.y );
+
+      v_control = v_start;
+
+      point = outline->points + first;
+      tags  = outline->tags  + first;
+      tag   = FT_CURVE_TAG( tags[0] );
+
+      /* A contour cannot start with a cubic control point! */
+      if ( tag == FT_CURVE_TAG_CUBIC )
+        goto Invalid_Outline;
+
+      /* check first point to determine origin */
+      if ( tag == FT_CURVE_TAG_CONIC )
+      {
+        /* first point is conic control.  Yes, this happens. */
+        if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON )
+        {
+          /* start at last point if it is on the curve */
+          v_start = v_last;
+          limit--;
+        }
+        else
+        {
+          /* if both first and last points are conic,         */
+          /* start at their middle and record its position    */
+          /* for closure                                      */
+          v_start.x = ( v_start.x + v_last.x ) / 2;
+          v_start.y = ( v_start.y + v_last.y ) / 2;
+
+          v_last = v_start;
+        }
+        point--;
+        tags--;
+      }
+
+      error = func_interface->move_to( &v_start, user );
+      if ( error )
+        goto Exit;
+
+      while ( point < limit )
+      {
+        point++;
+        tags++;
+
+        tag = FT_CURVE_TAG( tags[0] );
+        switch ( tag )
+        {
+        case FT_CURVE_TAG_ON:  /* emit a single line_to */
+          {
+            FT_Vector  vec;
+
+
+            vec.x = SCALED( point->x );
+            vec.y = SCALED( point->y );
+
+            error = func_interface->line_to( &vec, user );
+            if ( error )
+              goto Exit;
+            continue;
+          }
+
+        case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
+          v_control.x = SCALED( point->x );
+          v_control.y = SCALED( point->y );
+
+        Do_Conic:
+          if ( point < limit )
+          {
+            FT_Vector  vec;
+            FT_Vector  v_middle;
+
+
+            point++;
+            tags++;
+            tag = FT_CURVE_TAG( tags[0] );
+
+            vec.x = SCALED( point->x );
+            vec.y = SCALED( point->y );
+
+            if ( tag == FT_CURVE_TAG_ON )
+            {
+              error = func_interface->conic_to( &v_control, &vec, user );
+              if ( error )
+                goto Exit;
+              continue;
+            }
+
+            if ( tag != FT_CURVE_TAG_CONIC )
+              goto Invalid_Outline;
+
+            v_middle.x = ( v_control.x + vec.x ) / 2;
+            v_middle.y = ( v_control.y + vec.y ) / 2;
+
+            error = func_interface->conic_to( &v_control, &v_middle, user );
+            if ( error )
+              goto Exit;
+
+            v_control = vec;
+            goto Do_Conic;
+          }
+
+          error = func_interface->conic_to( &v_control, &v_start, user );
+          goto Close;
+
+        default:  /* FT_CURVE_TAG_CUBIC */
+          {
+            FT_Vector  vec1, vec2;
+
+
+            if ( point + 1 > limit                             ||
+                 FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
+              goto Invalid_Outline;
+
+            point += 2;
+            tags  += 2;
+
+            vec1.x = SCALED( point[-2].x ); vec1.y = SCALED( point[-2].y );
+            vec2.x = SCALED( point[-1].x ); vec2.y = SCALED( point[-1].y );
+
+            if ( point <= limit )
+            {
+              FT_Vector  vec;
+
+
+              vec.x = SCALED( point->x );
+              vec.y = SCALED( point->y );
+
+              error = func_interface->cubic_to( &vec1, &vec2, &vec, user );
+              if ( error )
+                goto Exit;
+              continue;
+            }
+
+            error = func_interface->cubic_to( &vec1, &vec2, &v_start, user );
+            goto Close;
+          }
+        }
+      }
+
+      /* close the contour with a line segment */
+      error = func_interface->line_to( &v_start, user );
+
+    Close:
+      if ( error )
+        goto Exit;
+
+      first = last + 1;
+    }
+
+    return 0;
+
+  Exit:
+    return error;
+
+  Invalid_Outline:
+    return FT_Err_Invalid_Outline;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_New_Internal( FT_Memory    memory,
+                           FT_UInt      numPoints,
+                           FT_Int       numContours,
+                           FT_Outline  *anoutline )
+  {
+    FT_Error  error;
+
+
+    if ( !anoutline || !memory )
+      return FT_Err_Invalid_Argument;
+
+    *anoutline = null_outline;
+
+    if ( FT_NEW_ARRAY( anoutline->points,   numPoints * 2L ) ||
+         FT_NEW_ARRAY( anoutline->tags,     numPoints      ) ||
+         FT_NEW_ARRAY( anoutline->contours, numContours    ) )
+      goto Fail;
+
+    anoutline->n_points    = (FT_UShort)numPoints;
+    anoutline->n_contours  = (FT_Short)numContours;
+    anoutline->flags      |= FT_OUTLINE_OWNER;
+
+    return FT_Err_Ok;
+
+  Fail:
+    anoutline->flags |= FT_OUTLINE_OWNER;
+    FT_Outline_Done_Internal( memory, anoutline );
+
+    return error;
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_New( FT_Library   library,
+                  FT_UInt      numPoints,
+                  FT_Int       numContours,
+                  FT_Outline  *anoutline )
+  {
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    return FT_Outline_New_Internal( library->memory, numPoints,
+                                    numContours, anoutline );
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_Check( FT_Outline*  outline )
+  {
+    if ( outline )
+    {
+      FT_Int  n_points   = outline->n_points;
+      FT_Int  n_contours = outline->n_contours;
+      FT_Int  end0, end;
+      FT_Int  n;
+
+
+      /* empty glyph? */
+      if ( n_points == 0 && n_contours == 0 )
+        return 0;
+
+      /* check point and contour counts */
+      if ( n_points <= 0 || n_contours <= 0 )
+        goto Bad;
+
+      end0 = end = -1;
+      for ( n = 0; n < n_contours; n++ )
+      {
+        end = outline->contours[n];
+
+        /* note that we don't accept empty contours */
+        if ( end <= end0 || end >= n_points )
+          goto Bad;
+
+        end0 = end;
+      }
+
+      if ( end != n_points - 1 )
+        goto Bad;
+
+      /* XXX: check the tags array */
+      return 0;
+    }
+
+  Bad:
+    return FT_Err_Invalid_Argument;
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_Copy( FT_Outline*  source,
+                   FT_Outline  *target )
+  {
+    FT_Int  is_owner;
+
+
+    if ( !source            || !target            ||
+         source->n_points   != target->n_points   ||
+         source->n_contours != target->n_contours )
+      return FT_Err_Invalid_Argument;
+
+    FT_ARRAY_COPY( target->points, source->points, source->n_points );
+
+    FT_ARRAY_COPY( target->tags, source->tags, source->n_points );
+
+    FT_ARRAY_COPY( target->contours, source->contours, source->n_contours );
+
+    /* copy all flags, except the `FT_OUTLINE_OWNER' one */
+    is_owner      = target->flags & FT_OUTLINE_OWNER;
+    target->flags = source->flags;
+
+    target->flags &= ~FT_OUTLINE_OWNER;
+    target->flags |= is_owner;
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_Done_Internal( FT_Memory    memory,
+                            FT_Outline*  outline )
+  {
+    if ( outline )
+    {
+      if ( outline->flags & FT_OUTLINE_OWNER )
+      {
+        FT_FREE( outline->points   );
+        FT_FREE( outline->tags     );
+        FT_FREE( outline->contours );
+      }
+      *outline = null_outline;
+
+      return FT_Err_Ok;
+    }
+    else
+      return FT_Err_Invalid_Argument;
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_Done( FT_Library   library,
+                   FT_Outline*  outline )
+  {
+    /* check for valid `outline' in FT_Outline_Done_Internal() */
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    return FT_Outline_Done_Internal( library->memory, outline );
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Outline_Get_CBox( FT_Outline*  outline,
+                       FT_BBox     *acbox )
+  {
+    FT_Pos  xMin, yMin, xMax, yMax;
+
+
+    if ( outline && acbox )
+    {
+      if ( outline->n_points == 0 )
+      {
+        xMin = 0;
+        yMin = 0;
+        xMax = 0;
+        yMax = 0;
+      }
+      else
+      {
+        FT_Vector*  vec   = outline->points;
+        FT_Vector*  limit = vec + outline->n_points;
+
+
+        xMin = xMax = vec->x;
+        yMin = yMax = vec->y;
+        vec++;
+
+        for ( ; vec < limit; vec++ )
+        {
+          FT_Pos  x, y;
+
+
+          x = vec->x;
+          if ( x < xMin ) xMin = x;
+          if ( x > xMax ) xMax = x;
+
+          y = vec->y;
+          if ( y < yMin ) yMin = y;
+          if ( y > yMax ) yMax = y;
+        }
+      }
+      acbox->xMin = xMin;
+      acbox->xMax = xMax;
+      acbox->yMin = yMin;
+      acbox->yMax = yMax;
+    }
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Outline_Translate( FT_Outline*  outline,
+                        FT_Pos       xOffset,
+                        FT_Pos       yOffset )
+  {
+    FT_UShort   n;
+    FT_Vector*  vec = outline->points;
+
+
+    for ( n = 0; n < outline->n_points; n++ )
+    {
+      vec->x += xOffset;
+      vec->y += yOffset;
+      vec++;
+    }
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Outline_Reverse( FT_Outline*  outline )
+  {
+    FT_UShort  n;
+    FT_Int     first, last;
+
+
+    first = 0;
+
+    for ( n = 0; n < outline->n_contours; n++ )
+    {
+      last  = outline->contours[n];
+
+      /* reverse point table */
+      {
+        FT_Vector*  p = outline->points + first;
+        FT_Vector*  q = outline->points + last;
+        FT_Vector   swap;
+
+
+        while ( p < q )
+        {
+          swap = *p;
+          *p   = *q;
+          *q   = swap;
+          p++;
+          q--;
+        }
+      }
+
+      /* reverse tags table */
+      {
+        char*  p = outline->tags + first;
+        char*  q = outline->tags + last;
+        char   swap;
+
+
+        while ( p < q )
+        {
+          swap = *p;
+          *p   = *q;
+          *q   = swap;
+          p++;
+          q--;
+        }
+      }
+
+      first = last + 1;
+    }
+
+    outline->flags ^= FT_OUTLINE_REVERSE_FILL;
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_Render( FT_Library         library,
+                     FT_Outline*        outline,
+                     FT_Raster_Params*  params )
+  {
+    FT_Error     error;
+    FT_Bool      update = 0;
+    FT_Renderer  renderer;
+    FT_ListNode  node;
+
+
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
+
+    if ( !params )
+      return FT_Err_Invalid_Argument;
+
+    renderer = library->cur_renderer;
+    node     = library->renderers.head;
+
+    params->source = (void*)outline;
+
+    error = FT_Err_Cannot_Render_Glyph;
+    while ( renderer )
+    {
+      error = renderer->raster_render( renderer->raster, params );
+      if ( !error || FT_ERROR_BASE( error ) != FT_Err_Cannot_Render_Glyph )
+        break;
+
+      /* FT_Err_Cannot_Render_Glyph is returned if the render mode   */
+      /* is unsupported by the current renderer for this glyph image */
+      /* format                                                      */
+
+      /* now, look for another renderer that supports the same */
+      /* format                                                */
+      renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE,
+                                     &node );
+      update   = 1;
+    }
+
+    /* if we changed the current renderer for the glyph image format */
+    /* we need to select it as the next current one                  */
+    if ( !error && update && renderer )
+      FT_Set_Renderer( library, renderer, 0, 0 );
+
+    return error;
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Outline_Get_Bitmap( FT_Library   library,
+                         FT_Outline*  outline,
+                         FT_Bitmap   *abitmap )
+  {
+    FT_Raster_Params  params;
+
+
+    if ( !abitmap )
+      return FT_Err_Invalid_Argument;
+
+    /* other checks are delayed to FT_Outline_Render() */
+
+    params.target = abitmap;
+    params.flags  = 0;
+
+    if ( abitmap->pixel_mode == FT_PIXEL_MODE_GRAY  ||
+         abitmap->pixel_mode == FT_PIXEL_MODE_LCD   ||
+         abitmap->pixel_mode == FT_PIXEL_MODE_LCD_V )
+      params.flags |= FT_RASTER_FLAG_AA;
+
+    return FT_Outline_Render( library, outline, &params );
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Vector_Transform( FT_Vector*  vector,
+                       FT_Matrix*  matrix )
+  {
+    FT_Pos xz, yz;
+
+
+    if ( !vector || !matrix )
+      return;
+
+    xz = FT_MulFix( vector->x, matrix->xx ) +
+         FT_MulFix( vector->y, matrix->xy );
+
+    yz = FT_MulFix( vector->x, matrix->yx ) +
+         FT_MulFix( vector->y, matrix->yy );
+
+    vector->x = xz;
+    vector->y = yz;
+  }
+
+
+  /* documentation is in ftoutln.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Outline_Transform( FT_Outline*  outline,
+                        FT_Matrix*   matrix )
+  {
+    FT_Vector*  vec = outline->points;
+    FT_Vector*  limit = vec + outline->n_points;
+
+
+    for ( ; vec < limit; vec++ )
+      FT_Vector_Transform( vec, matrix );
+  }
+
+
+  typedef struct  FT_OrientationExtremumRec_
+  {
+    FT_Int   index;
+    FT_Long  pos;
+    FT_Int   first;
+    FT_Int   last;
+
+  } FT_OrientationExtremumRec;
+
+
+  static FT_Orientation
+  ft_orientation_extremum_compute( FT_OrientationExtremumRec*  extremum,
+                                   FT_Outline*                 outline )
+  {
+    FT_Vector  *point, *first, *last, *prev, *next;
+    FT_Vector*  points = outline->points;
+    FT_Angle    angle_in, angle_out;
+
+
+    /* compute the previous and next points in the same contour */
+    point = points + extremum->index;
+    first = points + extremum->first;
+    last  = points + extremum->last;
+
+    prev = point;
+    next = point;
+
+    do
+    {
+      prev = ( prev == first ) ? last : prev - 1;
+      if ( prev == point )
+        return FT_ORIENTATION_TRUETYPE;  /* degenerate case */
+
+    } while ( prev->x != point->x || prev->y != point->y );
+
+    do
+    {
+      next = ( next == last ) ? first : next + 1;
+      if ( next == point )
+        return FT_ORIENTATION_TRUETYPE;  /* shouldn't happen */
+
+    } while ( next->x != point->x || next->y != point->y );
+
+    /* now compute the orientation of the `out' vector relative */
+    /* to the `in' vector.                                      */
+    angle_in  = FT_Atan2( point->x - prev->x,  point->y - prev->y );
+    angle_out = FT_Atan2( next->x  - point->x, next->y  - point->y );
+
+    return ( FT_Angle_Diff( angle_in, angle_out ) >= 0 )
+             ? FT_ORIENTATION_TRUETYPE
+             : FT_ORIENTATION_POSTSCRIPT;
+  }
+
+
+  FT_EXPORT_DEF( FT_Orientation )
+  FT_Outline_Get_Orientation( FT_Outline*  outline )
+  {
+    FT_Orientation  result = FT_ORIENTATION_TRUETYPE;
+
+
+    if ( outline && outline->n_points > 0 )
+    {
+      FT_OrientationExtremumRec  xmin, ymin, xmax, ymax;
+      FT_Int                     n;
+      FT_Int                     first, last;
+      FT_Vector*                 points = outline->points;
+
+
+      xmin.pos = ymin.pos = +32768L;
+      xmax.pos = ymax.pos = -32768L;
+
+      xmin.index = ymin.index = xmax.index = ymax.index = -1;
+
+      first = 0;
+      for ( n = 0; n < outline->n_contours; n++, first = last + 1 )
+      {
+        last = outline->contours[n];
+
+        /* skip single-point contours; these are degenerated cases */
+        if ( last > first + 1 )
+        {
+          FT_Int  i;
+
+
+          for ( i = first; i < last; i++ )
+          {
+            FT_Pos  x = points[i].x;
+            FT_Pos  y = points[i].y;
+
+
+            if ( x < xmin.pos )
+            {
+              xmin.pos   = x;
+              xmin.index = i;
+              xmin.first = first;
+              xmin.last  = last;
+            }
+            if ( x > xmax.pos )
+            {
+              xmax.pos   = x;
+              xmax.index = i;
+              xmax.first = first;
+              xmax.last  = last;
+            }
+            if ( y < ymin.pos )
+            {
+              ymin.pos   = y;
+              ymin.index = i;
+              ymin.first = first;
+              ymin.last  = last;
+            }
+            if ( y > ymax.pos )
+            {
+              ymax.pos   = y;
+              ymax.index = i;
+              ymax.first = first;
+              ymax.last  = last;
+            }
+          }
+        }
+
+        if ( xmin.index >= 0 )
+          result = ft_orientation_extremum_compute( &xmin, outline );
+
+        else if ( xmax.index >= 0 )
+          result = ft_orientation_extremum_compute( &xmax, outline );
+
+        else if ( ymin.index >= 0 )
+          result = ft_orientation_extremum_compute( &ymin, outline );
+
+        else if ( ymax.index >= 0 )
+          result = ft_orientation_extremum_compute( &ymax, outline );
+      }
+    }
+
+    return result;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftpfr.c b/nx-X11/extras/freetype2/src/base/ftpfr.c
new file mode 100644
index 000000000..fb959e37f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftpfr.c
@@ -0,0 +1,126 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftpfr.c                                                                */
+/*                                                                         */
+/*    FreeType API for accessing PFR-specific data (body).                 */
+/*                                                                         */
+/*  Copyright 2002, 2003 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_OBJECTS_H
+#include FT_SERVICE_PFR_H
+
+
+  /* check the format */
+  static FT_Service_PfrMetrics
+  ft_pfr_check( FT_Face  face )
+  {
+    FT_Service_PfrMetrics  service;
+
+
+    FT_FACE_LOOKUP_SERVICE( face, service, PFR_METRICS );
+
+    return service;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_PFR_Metrics( FT_Face    face,
+                      FT_UInt   *aoutline_resolution,
+                      FT_UInt   *ametrics_resolution,
+                      FT_Fixed  *ametrics_x_scale,
+                      FT_Fixed  *ametrics_y_scale )
+  {
+    FT_Error               error = FT_Err_Ok;
+    FT_Service_PfrMetrics  service;
+
+
+    service = ft_pfr_check( face );
+    if ( service )
+    {
+      error = service->get_metrics( face,
+                                    aoutline_resolution,
+                                    ametrics_resolution,
+                                    ametrics_x_scale,
+                                    ametrics_y_scale );
+    }
+    else if ( face )
+    {
+      FT_Fixed  x_scale, y_scale;
+
+
+      /* this is not a PFR font */
+      *aoutline_resolution = face->units_per_EM;
+      *ametrics_resolution = face->units_per_EM;
+
+      x_scale = y_scale = 0x10000L;
+      if ( face->size )
+      {
+        x_scale = face->size->metrics.x_scale;
+        y_scale = face->size->metrics.y_scale;
+      }
+      *ametrics_x_scale = x_scale;
+      *ametrics_y_scale = y_scale;
+    }
+    else
+      error = FT_Err_Invalid_Argument;
+
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_PFR_Kerning( FT_Face     face,
+                      FT_UInt     left,
+                      FT_UInt     right,
+                      FT_Vector  *avector )
+  {
+    FT_Error               error;
+    FT_Service_PfrMetrics  service;
+
+
+    service = ft_pfr_check( face );
+    if ( service )
+      error = service->get_kerning( face, left, right, avector );
+    else if ( face )
+      error = FT_Get_Kerning( face, left, right,
+                              FT_KERNING_UNSCALED, avector );
+    else
+      error = FT_Err_Invalid_Argument;
+
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_PFR_Advance( FT_Face   face,
+                      FT_UInt   gindex,
+                      FT_Pos   *aadvance )
+  {
+    FT_Error               error;
+    FT_Service_PfrMetrics  service;
+
+
+    service = ft_pfr_check( face );
+    if ( service )
+    {
+      error = service->get_advance( face, gindex, aadvance );
+    }
+    else
+      /* XXX: TODO: PROVIDE ADVANCE-LOADING METHOD TO ALL FONT DRIVERS */
+      error = FT_Err_Invalid_Argument;
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftrfork.c b/nx-X11/extras/freetype2/src/base/ftrfork.c
new file mode 100644
index 000000000..cf790ccc0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftrfork.c
@@ -0,0 +1,717 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftrfork.c                                                              */
+/*                                                                         */
+/*    Embedded resource forks accessor (body).                             */
+/*                                                                         */
+/*  Copyright 2004 by                                                      */
+/*  Masatake YAMATO and Redhat K.K.                                        */
+/*                                                                         */
+/*  FT_Raccess_Get_HeaderInfo() and raccess_guess_darwin_hfsplus() are     */
+/*  derived from ftobjs.c.                                                 */
+/*                                                                         */
+/*  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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+/***************************************************************************/
+/* Development of the code in this file is support of                      */
+/* Information-technology Promotion Agency, Japan.                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_RFORK_H
+
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_raccess
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****               Resource fork directory access                    ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_BASE_DEF( FT_Error )
+  FT_Raccess_Get_HeaderInfo( FT_Library  library,
+                             FT_Stream   stream,
+                             FT_Long     rfork_offset,
+                             FT_Long    *map_offset,
+                             FT_Long    *rdata_pos )
+  {
+    FT_Error       error;
+    unsigned char  head[16], head2[16];
+    FT_Long        map_pos, rdata_len;
+    int            allzeros, allmatch, i;
+    FT_Long        type_list;
+
+    FT_UNUSED( library );
+
+
+    error = FT_Stream_Seek( stream, rfork_offset );
+    if ( error )
+      return error;
+
+    error = FT_Stream_Read( stream, (FT_Byte *)head, 16 );
+    if ( error )
+      return error;
+
+    *rdata_pos = rfork_offset + ( ( head[0] << 24 ) |
+                                  ( head[1] << 16 ) |
+                                  ( head[2] <<  8 ) |
+                                    head[3]         );
+    map_pos    = rfork_offset + ( ( head[4] << 24 ) |
+                                  ( head[5] << 16 ) |
+                                  ( head[6] <<  8 ) |
+                                    head[7]         );
+    rdata_len = ( head[ 8] << 24 ) |
+                ( head[ 9] << 16 ) |
+                ( head[10] <<  8 ) |
+                  head[11];
+
+    /* map_len = head[12] .. head[15] */
+
+    if ( *rdata_pos + rdata_len != map_pos || map_pos == rfork_offset )
+      return FT_Err_Unknown_File_Format;
+
+    error = FT_Stream_Seek( stream, map_pos );
+    if ( error )
+      return error;
+
+    head2[15] = (FT_Byte)( head[15] + 1 );       /* make it be different */
+
+    error = FT_Stream_Read( stream, (FT_Byte*)head2, 16 );
+    if ( error )
+      return error;
+
+    allzeros = 1;
+    allmatch = 1;
+    for ( i = 0; i < 16; ++i )
+    {
+      if ( head2[i] != 0 )
+        allzeros = 0;
+      if ( head2[i] != head[i] )
+        allmatch = 0;
+    }
+    if ( !allzeros && !allmatch )
+      return FT_Err_Unknown_File_Format;
+
+    /* If we have reached this point then it is probably a mac resource */
+    /* file.  Now, does it contain any interesting resources?           */
+    /* Skip handle to next resource map, the file resource number, and  */
+    /* attributes.                                                      */
+    (void)FT_STREAM_SKIP( 4        /* skip handle to next resource map */
+                          + 2      /* skip file resource number */
+                          + 2 );   /* skip attributes */
+
+    if ( FT_READ_USHORT( type_list ) )
+      return error;
+    if ( type_list == -1 )
+      return FT_Err_Unknown_File_Format;
+
+    error = FT_Stream_Seek( stream, map_pos + type_list );
+    if ( error )
+      return error;
+
+    *map_offset = map_pos + type_list;
+    return FT_Err_Ok;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Raccess_Get_DataOffsets( FT_Library  library,
+                              FT_Stream   stream,
+                              FT_Long     map_offset,
+                              FT_Long     rdata_pos,
+                              FT_Long     tag,
+                              FT_Long   **offsets,
+                              FT_Long    *count )
+  {
+    FT_Error   error;
+    int        i, j, cnt, subcnt;
+    FT_Long    tag_internal, rpos;
+    FT_Memory  memory = library->memory;
+    FT_Long    temp;
+    FT_Long    *offsets_internal;
+
+
+    error = FT_Stream_Seek( stream, map_offset );
+    if ( error )
+      return error;
+
+    if ( FT_READ_USHORT( cnt ) )
+      return error;
+    cnt++;
+
+    for ( i = 0; i < cnt; ++i )
+    {
+      if ( FT_READ_LONG( tag_internal ) ||
+           FT_READ_USHORT( subcnt )     ||
+           FT_READ_USHORT( rpos )       )
+        return error;
+
+      FT_TRACE2(( "Resource tags: %c%c%c%c\n",
+                  (char)( 0xff & ( tag_internal >> 24 ) ),
+                  (char)( 0xff & ( tag_internal >> 16 ) ),
+                  (char)( 0xff & ( tag_internal >>  8 ) ),
+                  (char)( 0xff & ( tag_internal >>  0 ) ) ));
+
+      if ( tag_internal == tag )
+      {
+        *count = subcnt + 1;
+        rpos  += map_offset;
+
+        error = FT_Stream_Seek( stream, rpos );
+        if ( error )
+          return error;
+
+        if ( FT_ALLOC( offsets_internal, *count * sizeof( FT_Long ) ) )
+          return error;
+
+        for ( j = 0; j < *count; ++j )
+        {
+          (void)FT_STREAM_SKIP( 2 ); /* resource id */
+          (void)FT_STREAM_SKIP( 2 ); /* rsource name */
+
+          if ( FT_READ_LONG( temp ) )
+          {
+            FT_FREE( offsets_internal );
+            return error;
+          }
+
+          offsets_internal[j] = rdata_pos + ( temp & 0xFFFFFFL );
+
+          (void)FT_STREAM_SKIP( 4 ); /* mbz */
+        }
+
+        *offsets = offsets_internal;
+
+        return FT_Err_Ok;
+      }
+    }
+
+    return FT_Err_Cannot_Open_Resource;
+  }
+
+
+#ifdef FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                     Guessing functions                          ****/
+  /****                                                                 ****/
+  /****            When you add a new guessing function,                ****/
+  /****           update FT_RACCESS_N_RULES in ftrfork.h.               ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef FT_Error
+  (*raccess_guess_func)( FT_Library  library,
+                         FT_Stream   stream,
+                         char *      base_file_name,
+                         char      **result_file_name,
+                         FT_Long    *result_offset );
+
+
+  static FT_Error
+  raccess_guess_apple_double( FT_Library  library,
+                              FT_Stream   stream,
+                              char *      base_file_name,
+                              char      **result_file_name,
+                              FT_Long    *result_offset );
+
+  static FT_Error
+  raccess_guess_apple_single( FT_Library  library,
+                              FT_Stream   stream,
+                              char *      base_file_name,
+                              char      **result_file_name,
+                              FT_Long    *result_offset );
+
+  static FT_Error
+  raccess_guess_darwin_ufs_export( FT_Library  library,
+                                   FT_Stream   stream,
+                                   char *      base_file_name,
+                                   char      **result_file_name,
+                                   FT_Long    *result_offset );
+
+  static FT_Error
+  raccess_guess_darwin_hfsplus( FT_Library  library,
+                                FT_Stream   stream,
+                                char *      base_file_name,
+                                char      **result_file_name,
+                                FT_Long    *result_offset );
+
+  static FT_Error
+  raccess_guess_vfat( FT_Library  library,
+                      FT_Stream   stream,
+                      char *      base_file_name,
+                      char      **result_file_name,
+                      FT_Long    *result_offset );
+
+  static FT_Error
+  raccess_guess_linux_cap( FT_Library  library,
+                           FT_Stream   stream,
+                           char *      base_file_name,
+                           char      **result_file_name,
+                           FT_Long    *result_offset );
+
+  static FT_Error
+  raccess_guess_linux_double( FT_Library  library,
+                              FT_Stream   stream,
+                              char *      base_file_name,
+                              char      **result_file_name,
+                              FT_Long    *result_offset );
+
+  static FT_Error
+  raccess_guess_linux_netatalk( FT_Library  library,
+                                FT_Stream   stream,
+                                char *      base_file_name,
+                                char      **result_file_name,
+                                FT_Long    *result_offset );
+
+
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                       Helper functions                          ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+
+  static FT_Error
+  raccess_guess_apple_generic( FT_Library  library,
+                               FT_Stream   stream,
+                               char *      base_file_name,
+                               FT_Int32    magic,
+                               FT_Long    *result_offset );
+
+  static FT_Error
+  raccess_guess_linux_double_from_file_name( FT_Library  library,
+                                             char *      file_name,
+                                             FT_Long    *result_offset );
+
+  static char *
+  raccess_make_file_name( FT_Memory    memory,
+                          const char  *original_name,
+                          const char  *insertion );
+
+
+  FT_BASE_DEF( void )
+  FT_Raccess_Guess( FT_Library  library,
+                    FT_Stream   stream,
+                    char*       base_name,
+                    char      **new_names,
+                    FT_Long    *offsets,
+                    FT_Error   *errors )
+  {
+    FT_Long  i;
+
+
+    raccess_guess_func  funcs[FT_RACCESS_N_RULES] =
+    {
+      raccess_guess_apple_double,
+      raccess_guess_apple_single,
+      raccess_guess_darwin_ufs_export,
+      raccess_guess_darwin_hfsplus,
+      raccess_guess_vfat,
+      raccess_guess_linux_cap,
+      raccess_guess_linux_double,
+      raccess_guess_linux_netatalk,
+    };
+
+    for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
+    {
+      new_names[i] = NULL;
+      errors[i] = FT_Stream_Seek( stream, 0 );
+      if ( errors[i] )
+        continue ;
+
+      errors[i] = (funcs[i])( library, stream, base_name,
+                              &(new_names[i]), &(offsets[i]) );
+    }
+
+    return;
+  }
+
+
+  static FT_Error
+  raccess_guess_apple_double( FT_Library  library,
+                              FT_Stream   stream,
+                              char *      base_file_name,
+                              char      **result_file_name,
+                              FT_Long    *result_offset )
+  {
+    FT_Int32  magic = ( 0x00 << 24 | 0x05 << 16 | 0x16 << 8 | 0x07 );
+
+
+    *result_file_name = NULL;
+    return raccess_guess_apple_generic( library, stream, base_file_name,
+                                        magic, result_offset );
+  }
+
+
+  static FT_Error
+  raccess_guess_apple_single( FT_Library  library,
+                              FT_Stream   stream,
+                              char *      base_file_name,
+                              char      **result_file_name,
+                              FT_Long    *result_offset )
+  {
+    FT_Int32  magic = (0x00 << 24 | 0x05 << 16 | 0x16 << 8 | 0x00);
+
+
+    *result_file_name = NULL;
+    return raccess_guess_apple_generic( library, stream, base_file_name,
+                                        magic, result_offset );
+  }
+
+
+  static FT_Error
+  raccess_guess_darwin_ufs_export( FT_Library  library,
+                                   FT_Stream   stream,
+                                   char *      base_file_name,
+                                   char      **result_file_name,
+                                   FT_Long    *result_offset )
+  {
+    char*      newpath;
+    FT_Error   error;
+    FT_Memory  memory;
+
+    FT_UNUSED( stream );
+
+
+    memory  = library->memory;
+    newpath = raccess_make_file_name( memory, base_file_name, "._" );
+    if ( !newpath )
+      return FT_Err_Out_Of_Memory;
+
+    error = raccess_guess_linux_double_from_file_name( library, newpath,
+                                                       result_offset );
+    if ( !error )
+      *result_file_name = newpath;
+    else
+      FT_FREE( newpath );
+
+    return error;
+  }
+
+
+  static FT_Error
+  raccess_guess_darwin_hfsplus( FT_Library  library,
+                                FT_Stream   stream,
+                                char *      base_file_name,
+                                char      **result_file_name,
+                                FT_Long    *result_offset )
+  {
+    /*
+      Only meaningful on systems with hfs+ drivers (or Macs).
+     */
+    FT_Error   error;
+    char*      newpath;
+    FT_Memory  memory;
+
+    FT_UNUSED( stream );
+
+
+    memory = library->memory;
+
+    if ( FT_ALLOC( newpath,
+                   ft_strlen( base_file_name ) + ft_strlen( "/rsrc" ) + 1 ) )
+      return error;
+
+    ft_strcpy( newpath, base_file_name );
+    ft_strcat( newpath, "/rsrc" );
+    *result_file_name = newpath;
+    *result_offset = 0;
+    return FT_Err_Ok;
+  }
+
+
+  static FT_Error
+  raccess_guess_vfat( FT_Library  library,
+                      FT_Stream   stream,
+                      char *      base_file_name,
+                      char      **result_file_name,
+                      FT_Long    *result_offset )
+  {
+    char*      newpath;
+    FT_Memory  memory;
+
+    FT_UNUSED( stream );
+
+
+    memory = library->memory;
+
+    newpath = raccess_make_file_name( memory, base_file_name,
+                                      "resource.frk/" );
+    if ( !newpath )
+      return FT_Err_Out_Of_Memory;
+
+    *result_file_name = newpath;
+    *result_offset    = 0;
+
+    return FT_Err_Ok;
+  }
+
+
+  static FT_Error
+  raccess_guess_linux_cap( FT_Library  library,
+                           FT_Stream   stream,
+                           char *      base_file_name,
+                           char      **result_file_name,
+                           FT_Long    *result_offset )
+  {
+    char*      newpath;
+    FT_Memory  memory;
+
+    FT_UNUSED( stream );
+
+
+    memory = library->memory;
+
+    newpath = raccess_make_file_name( memory, base_file_name, ".resource/" );
+    if ( !newpath )
+      return FT_Err_Out_Of_Memory;
+
+    *result_file_name = newpath;
+    *result_offset    = 0;
+
+    return FT_Err_Ok;
+  }
+
+
+  static FT_Error
+  raccess_guess_linux_double( FT_Library  library,
+                              FT_Stream   stream,
+                              char *      base_file_name,
+                              char      **result_file_name,
+                              FT_Long    *result_offset )
+  {
+    char*      newpath;
+    FT_Error   error;
+    FT_Memory  memory;
+
+    FT_UNUSED( stream );
+
+
+    memory = library->memory;
+
+    newpath = raccess_make_file_name( memory, base_file_name, "%" );
+    if ( !newpath )
+      return FT_Err_Out_Of_Memory;
+
+    error = raccess_guess_linux_double_from_file_name( library, newpath,
+                                                       result_offset );
+    if ( !error )
+      *result_file_name = newpath;
+    else
+      FT_FREE( newpath );
+
+    return error;
+  }
+
+
+  static FT_Error
+  raccess_guess_linux_netatalk( FT_Library  library,
+                                FT_Stream   stream,
+                                char *      base_file_name,
+                                char      **result_file_name,
+                                FT_Long    *result_offset )
+  {
+    char*      newpath;
+    FT_Error   error;
+    FT_Memory  memory;
+
+    FT_UNUSED( stream );
+
+
+    memory = library->memory;
+
+    newpath = raccess_make_file_name( memory, base_file_name,
+                                      ".AppleDouble/" );
+    if ( !newpath )
+      return FT_Err_Out_Of_Memory;
+
+    error = raccess_guess_linux_double_from_file_name( library, newpath,
+                                                       result_offset );
+    if ( !error )
+      *result_file_name = newpath;
+    else
+      FT_FREE( newpath );
+
+    return error;
+  }
+
+
+  static FT_Error
+  raccess_guess_apple_generic( FT_Library  library,
+                               FT_Stream   stream,
+                               char *      base_file_name,
+                               FT_Int32    magic,
+                               FT_Long    *result_offset )
+  {
+    FT_Int32   magic_from_stream;
+    FT_Error   error;
+    FT_Int32   version_number;
+    FT_UShort  n_of_entries;
+
+    int        i;
+    FT_UInt32  entry_id, entry_offset, entry_length;
+
+    const FT_UInt32  resource_fork_entry_id = 0x2;
+
+    FT_UNUSED( library );
+    FT_UNUSED( base_file_name );
+
+
+    if ( FT_READ_LONG ( magic_from_stream ) )
+      return error;
+    if ( magic_from_stream != magic )
+      return FT_Err_Unknown_File_Format;
+
+    if ( FT_READ_LONG( version_number ) )
+      return error;
+
+    /* filler */
+    error = FT_Stream_Skip( stream, 16 );
+    if ( error )
+      return error;
+
+    if ( FT_READ_USHORT( n_of_entries ) )
+      return error;
+    if ( n_of_entries == 0 )
+      return FT_Err_Unknown_File_Format;
+
+    for ( i = 0; i < n_of_entries; i++ )
+    {
+      if ( FT_READ_LONG( entry_id ) )
+        return error;
+      if ( entry_id == resource_fork_entry_id )
+      {
+        if ( FT_READ_LONG( entry_offset ) ||
+             FT_READ_LONG( entry_length ) )
+          continue;
+        *result_offset = entry_offset;
+
+        return FT_Err_Ok;
+      }
+      else
+        FT_Stream_Skip( stream, 4 + 4 );    /* offset + length */
+      }
+
+    return FT_Err_Unknown_File_Format;
+  }
+
+
+  static FT_Error
+  raccess_guess_linux_double_from_file_name( FT_Library  library,
+                                             char *      file_name,
+                                             FT_Long    *result_offset )
+  {
+    FT_Memory     memory;
+    FT_Open_Args  args2;
+    FT_Stream     stream2;
+    char *        nouse = NULL;
+    FT_Error      error;
+
+
+    memory = library->memory;
+
+    args2.flags    = FT_OPEN_PATHNAME;
+    args2.pathname = file_name;
+    error = FT_Stream_New( library, &args2, &stream2 );
+    if ( error )
+      return error;
+
+    error = raccess_guess_apple_double( library, stream2, file_name,
+                                        &nouse, result_offset );
+
+    FT_Stream_Close( stream2 );
+
+    return error;
+  }
+
+
+  static char*
+  raccess_make_file_name( FT_Memory    memory,
+                          const char  *original_name,
+                          const char  *insertion )
+  {
+    char*        new_name;
+    char*        tmp;
+    const char*  slash;
+    unsigned     new_length;
+    FT_ULong     error;
+
+    new_length = ft_strlen( original_name ) + ft_strlen( insertion );
+    if ( FT_ALLOC( new_name, new_length + 1 ) )
+      return NULL;
+
+    tmp = ft_strrchr( original_name, '/' );
+    if ( tmp )
+    {
+      ft_strncpy( new_name, original_name, tmp - original_name + 1 );
+      new_name[tmp - original_name + 1] = '\0';
+      slash = tmp + 1;
+    }
+    else
+    {
+      slash       = original_name;
+      new_name[0] = '\0';
+    }
+
+    ft_strcat( new_name, insertion );
+    ft_strcat( new_name, slash );
+
+    return new_name;
+  }
+
+
+#else   /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
+
+
+  /*************************************************************************/
+  /*                  Dummy function; just sets errors                     */
+  /*************************************************************************/
+
+  FT_BASE_DEF( void )
+  FT_Raccess_Guess( FT_Library  library,
+                    FT_Stream   stream,
+                    char*       base_name,
+                    char      **new_names,
+                    FT_Long    *offsets,
+                    FT_Error   *errors )
+  {
+    int  i;
+
+
+    for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
+    {
+      new_names[i] = NULL;
+      offsets[i]   = 0;
+      errors[i]    = FT_Err_Unimplemented_Feature;
+    }
+  }
+
+
+#endif  /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftstream.c b/nx-X11/extras/freetype2/src/base/ftstream.c
new file mode 100644
index 000000000..932fe1b40
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftstream.c
@@ -0,0 +1,803 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftstream.c                                                             */
+/*                                                                         */
+/*    I/O stream support (body).                                           */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2004 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_STREAM_H
+#include FT_INTERNAL_DEBUG_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_stream
+
+
+  FT_BASE_DEF( void )
+  FT_Stream_OpenMemory( FT_Stream       stream,
+                        const FT_Byte*  base,
+                        FT_ULong        size )
+  {
+    stream->base   = (FT_Byte*) base;
+    stream->size   = size;
+    stream->pos    = 0;
+    stream->cursor = 0;
+    stream->read   = 0;
+    stream->close  = 0;
+  }
+
+
+  FT_BASE_DEF( void )
+  FT_Stream_Close( FT_Stream  stream )
+  {
+    if ( stream && stream->close )
+    {
+      stream->close( stream );
+      stream->close = NULL;
+    }
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Stream_Seek( FT_Stream  stream,
+                  FT_ULong   pos )
+  {
+    FT_Error  error = FT_Err_Ok;
+
+
+    stream->pos = pos;
+
+    if ( stream->read )
+    {
+      if ( stream->read( stream, pos, 0, 0 ) )
+      {
+        FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+                   pos, stream->size ));
+
+        error = FT_Err_Invalid_Stream_Operation;
+      }
+    }
+    /* note that seeking to the first position after the file is valid */
+    else if ( pos > stream->size )
+    {
+      FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+                 pos, stream->size ));
+
+      error = FT_Err_Invalid_Stream_Operation;
+    }
+
+    return error;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Stream_Skip( FT_Stream  stream,
+                  FT_Long    distance )
+  {
+    return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );
+  }
+
+
+  FT_BASE_DEF( FT_Long )
+  FT_Stream_Pos( FT_Stream  stream )
+  {
+    return stream->pos;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Stream_Read( FT_Stream  stream,
+                  FT_Byte*   buffer,
+                  FT_ULong   count )
+  {
+    return FT_Stream_ReadAt( stream, stream->pos, buffer, count );
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Stream_ReadAt( FT_Stream  stream,
+                    FT_ULong   pos,
+                    FT_Byte*   buffer,
+                    FT_ULong   count )
+  {
+    FT_Error  error = FT_Err_Ok;
+    FT_ULong  read_bytes;
+
+
+    if ( pos >= stream->size )
+    {
+      FT_ERROR(( "FT_Stream_ReadAt: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+                 pos, stream->size ));
+
+      return FT_Err_Invalid_Stream_Operation;
+    }
+
+    if ( stream->read )
+      read_bytes = stream->read( stream, pos, buffer, count );
+    else
+    {
+      read_bytes = stream->size - pos;
+      if ( read_bytes > count )
+        read_bytes = count;
+
+      FT_MEM_COPY( buffer, stream->base + pos, read_bytes );
+    }
+
+    stream->pos = pos + read_bytes;
+
+    if ( read_bytes < count )
+    {
+      FT_ERROR(( "FT_Stream_ReadAt:" ));
+      FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
+                 count, read_bytes ));
+
+      error = FT_Err_Invalid_Stream_Operation;
+    }
+
+    return error;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Stream_ExtractFrame( FT_Stream  stream,
+                          FT_ULong   count,
+                          FT_Byte**  pbytes )
+  {
+    FT_Error  error;
+
+
+    error = FT_Stream_EnterFrame( stream, count );
+    if ( !error )
+    {
+      *pbytes = (FT_Byte*)stream->cursor;
+
+      /* equivalent to FT_Stream_ExitFrame(), with no memory block release */
+      stream->cursor = 0;
+      stream->limit  = 0;
+    }
+
+    return error;
+  }
+
+
+  FT_BASE_DEF( void )
+  FT_Stream_ReleaseFrame( FT_Stream  stream,
+                          FT_Byte**  pbytes )
+  {
+    if ( stream->read )
+    {
+      FT_Memory  memory = stream->memory;
+
+
+      FT_FREE( *pbytes );
+    }
+    *pbytes = 0;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Stream_EnterFrame( FT_Stream  stream,
+                        FT_ULong   count )
+  {
+    FT_Error  error = FT_Err_Ok;
+    FT_ULong  read_bytes;
+
+
+    /* check for nested frame access */
+    FT_ASSERT( stream && stream->cursor == 0 );
+
+    if ( stream->read )
+    {
+      /* allocate the frame in memory */
+      FT_Memory  memory = stream->memory;
+
+
+      if ( FT_QALLOC( stream->base, count ) )
+        goto Exit;
+
+      /* read it */
+      read_bytes = stream->read( stream, stream->pos,
+                                 stream->base, count );
+      if ( read_bytes < count )
+      {
+        FT_ERROR(( "FT_Stream_EnterFrame:" ));
+        FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
+                   count, read_bytes ));
+
+        FT_FREE( stream->base );
+        error = FT_Err_Invalid_Stream_Operation;
+      }
+      stream->cursor = stream->base;
+      stream->limit  = stream->cursor + count;
+      stream->pos   += read_bytes;
+    }
+    else
+    {
+      /* check current and new position */
+      if ( stream->pos >= stream->size        ||
+           stream->pos + count > stream->size )
+      {
+        FT_ERROR(( "FT_Stream_EnterFrame:" ));
+        FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
+                   stream->pos, count, stream->size ));
+
+        error = FT_Err_Invalid_Stream_Operation;
+        goto Exit;
+      }
+
+      /* set cursor */
+      stream->cursor = stream->base + stream->pos;
+      stream->limit  = stream->cursor + count;
+      stream->pos   += count;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  FT_BASE_DEF( void )
+  FT_Stream_ExitFrame( FT_Stream  stream )
+  {
+    /* IMPORTANT: The assertion stream->cursor != 0 was removed, given    */
+    /*            that it is possible to access a frame of length 0 in    */
+    /*            some weird fonts (usually, when accessing an array of   */
+    /*            0 records, like in some strange kern tables).           */
+    /*                                                                    */
+    /*  In this case, the loader code handles the 0-length table          */
+    /*  gracefully; however, stream.cursor is really set to 0 by the      */
+    /*  FT_Stream_EnterFrame() call, and this is not an error.            */
+    /*                                                                    */
+    FT_ASSERT( stream );
+
+    if ( stream->read )
+    {
+      FT_Memory  memory = stream->memory;
+
+
+      FT_FREE( stream->base );
+    }
+    stream->cursor = 0;
+    stream->limit  = 0;
+  }
+
+
+  FT_BASE_DEF( FT_Char )
+  FT_Stream_GetChar( FT_Stream  stream )
+  {
+    FT_Char  result;
+
+
+    FT_ASSERT( stream && stream->cursor );
+
+    result = 0;
+    if ( stream->cursor < stream->limit )
+      result = *stream->cursor++;
+
+    return result;
+  }
+
+
+  FT_BASE_DEF( FT_Short )
+  FT_Stream_GetShort( FT_Stream  stream )
+  {
+    FT_Byte*  p;
+    FT_Short  result;
+
+
+    FT_ASSERT( stream && stream->cursor );
+
+    result         = 0;
+    p              = stream->cursor;
+    if ( p + 1 < stream->limit )
+      result       = FT_NEXT_SHORT( p );
+    stream->cursor = p;
+
+    return result;
+  }
+
+
+  FT_BASE_DEF( FT_Short )
+  FT_Stream_GetShortLE( FT_Stream  stream )
+  {
+    FT_Byte*  p;
+    FT_Short  result;
+
+
+    FT_ASSERT( stream && stream->cursor );
+
+    result         = 0;
+    p              = stream->cursor;
+    if ( p + 1 < stream->limit )
+      result       = FT_NEXT_SHORT_LE( p );
+    stream->cursor = p;
+
+    return result;
+  }
+
+
+  FT_BASE_DEF( FT_Long )
+  FT_Stream_GetOffset( FT_Stream  stream )
+  {
+    FT_Byte*  p;
+    FT_Long   result;
+
+
+    FT_ASSERT( stream && stream->cursor );
+
+    result         = 0;
+    p              = stream->cursor;
+    if ( p + 2 < stream->limit )
+      result       = FT_NEXT_OFF3( p );
+    stream->cursor = p;
+    return result;
+  }
+
+
+  FT_BASE_DEF( FT_Long )
+  FT_Stream_GetLong( FT_Stream  stream )
+  {
+    FT_Byte*  p;
+    FT_Long   result;
+
+
+    FT_ASSERT( stream && stream->cursor );
+
+    result         = 0;
+    p              = stream->cursor;
+    if ( p + 3 < stream->limit )
+      result       = FT_NEXT_LONG( p );
+    stream->cursor = p;
+    return result;
+  }
+
+
+  FT_BASE_DEF( FT_Long )
+  FT_Stream_GetLongLE( FT_Stream  stream )
+  {
+    FT_Byte*  p;
+    FT_Long   result;
+
+
+    FT_ASSERT( stream && stream->cursor );
+
+    result         = 0;
+    p              = stream->cursor;
+    if ( p + 3 < stream->limit )
+      result       = FT_NEXT_LONG_LE( p );
+    stream->cursor = p;
+    return result;
+  }
+
+
+  FT_BASE_DEF( FT_Char )
+  FT_Stream_ReadChar( FT_Stream  stream,
+                      FT_Error*  error )
+  {
+    FT_Byte  result = 0;
+
+
+    FT_ASSERT( stream );
+
+    *error = FT_Err_Ok;
+
+    if ( stream->read )
+    {
+      if ( stream->read( stream, stream->pos, &result, 1L ) != 1L )
+        goto Fail;
+    }
+    else
+    {
+      if ( stream->pos < stream->size )
+        result = stream->base[stream->pos];
+      else
+        goto Fail;
+    }
+    stream->pos++;
+
+    return result;
+
+  Fail:
+    *error = FT_Err_Invalid_Stream_Operation;
+    FT_ERROR(( "FT_Stream_ReadChar: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+               stream->pos, stream->size ));
+
+    return 0;
+  }
+
+
+  FT_BASE_DEF( FT_Short )
+  FT_Stream_ReadShort( FT_Stream  stream,
+                       FT_Error*  error )
+  {
+    FT_Byte   reads[2];
+    FT_Byte*  p = 0;
+    FT_Short  result = 0;
+
+
+    FT_ASSERT( stream );
+
+    *error = FT_Err_Ok;
+
+    if ( stream->pos + 1 < stream->size )
+    {
+      if ( stream->read )
+      {
+        if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
+          goto Fail;
+
+        p = reads;
+      }
+      else
+      {
+        p = stream->base + stream->pos;
+      }
+
+      if ( p )
+        result = FT_NEXT_SHORT( p );
+    }
+    else
+      goto Fail;
+
+    stream->pos += 2;
+
+    return result;
+
+  Fail:
+    *error = FT_Err_Invalid_Stream_Operation;
+    FT_ERROR(( "FT_Stream_ReadShort:" ));
+    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+               stream->pos, stream->size ));
+
+    return 0;
+  }
+
+
+  FT_BASE_DEF( FT_Short )
+  FT_Stream_ReadShortLE( FT_Stream  stream,
+                         FT_Error*  error )
+  {
+    FT_Byte   reads[2];
+    FT_Byte*  p = 0;
+    FT_Short  result = 0;
+
+
+    FT_ASSERT( stream );
+
+    *error = FT_Err_Ok;
+
+    if ( stream->pos + 1 < stream->size )
+    {
+      if ( stream->read )
+      {
+        if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
+          goto Fail;
+
+        p = reads;
+      }
+      else
+      {
+        p = stream->base + stream->pos;
+      }
+
+      if ( p )
+        result = FT_NEXT_SHORT_LE( p );
+    }
+    else
+      goto Fail;
+
+    stream->pos += 2;
+
+    return result;
+
+  Fail:
+    *error = FT_Err_Invalid_Stream_Operation;
+    FT_ERROR(( "FT_Stream_ReadShortLE:" ));
+    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+               stream->pos, stream->size ));
+
+    return 0;
+  }
+
+
+  FT_BASE_DEF( FT_Long )
+  FT_Stream_ReadOffset( FT_Stream  stream,
+                        FT_Error*  error )
+  {
+    FT_Byte   reads[3];
+    FT_Byte*  p = 0;
+    FT_Long   result = 0;
+
+
+    FT_ASSERT( stream );
+
+    *error = FT_Err_Ok;
+
+    if ( stream->pos + 2 < stream->size )
+    {
+      if ( stream->read )
+      {
+        if (stream->read( stream, stream->pos, reads, 3L ) != 3L )
+          goto Fail;
+
+        p = reads;
+      }
+      else
+      {
+        p = stream->base + stream->pos;
+      }
+
+      if ( p )
+        result = FT_NEXT_OFF3( p );
+    }
+    else
+      goto Fail;
+
+    stream->pos += 3;
+
+    return result;
+
+  Fail:
+    *error = FT_Err_Invalid_Stream_Operation;
+    FT_ERROR(( "FT_Stream_ReadOffset:" ));
+    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+               stream->pos, stream->size ));
+
+    return 0;
+  }
+
+
+  FT_BASE_DEF( FT_Long )
+  FT_Stream_ReadLong( FT_Stream  stream,
+                      FT_Error*  error )
+  {
+    FT_Byte   reads[4];
+    FT_Byte*  p = 0;
+    FT_Long   result = 0;
+
+
+    FT_ASSERT( stream );
+
+    *error = FT_Err_Ok;
+
+    if ( stream->pos + 3 < stream->size )
+    {
+      if ( stream->read )
+      {
+        if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
+          goto Fail;
+
+        p = reads;
+      }
+      else
+      {
+        p = stream->base + stream->pos;
+      }
+
+      if ( p )
+        result = FT_NEXT_LONG( p );
+    }
+    else
+      goto Fail;
+
+    stream->pos += 4;
+
+    return result;
+
+  Fail:
+    FT_ERROR(( "FT_Stream_ReadLong: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+               stream->pos, stream->size ));
+    *error = FT_Err_Invalid_Stream_Operation;
+
+    return 0;
+  }
+
+
+  FT_BASE_DEF( FT_Long )
+  FT_Stream_ReadLongLE( FT_Stream  stream,
+                        FT_Error*  error )
+  {
+    FT_Byte   reads[4];
+    FT_Byte*  p = 0;
+    FT_Long   result = 0;
+
+
+    FT_ASSERT( stream );
+
+    *error = FT_Err_Ok;
+
+    if ( stream->pos + 3 < stream->size )
+    {
+      if ( stream->read )
+      {
+        if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
+          goto Fail;
+
+        p = reads;
+      }
+      else
+      {
+        p = stream->base + stream->pos;
+      }
+
+      if ( p )
+        result = FT_NEXT_LONG_LE( p );
+    }
+    else
+      goto Fail;
+
+    stream->pos += 4;
+
+    return result;
+
+  Fail:
+    FT_ERROR(( "FT_Stream_ReadLongLE:" ));
+    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+               stream->pos, stream->size ));
+    *error = FT_Err_Invalid_Stream_Operation;
+
+    return 0;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Stream_ReadFields( FT_Stream              stream,
+                        const FT_Frame_Field*  fields,
+                        void*                  structure )
+  {
+    FT_Error  error;
+    FT_Bool   frame_accessed = 0;
+    FT_Byte*  cursor = stream->cursor;
+
+
+    if ( !fields || !stream )
+      return FT_Err_Invalid_Argument;
+
+    error = FT_Err_Ok;
+    do
+    {
+      FT_ULong  value;
+      FT_Int    sign_shift;
+      FT_Byte*  p;
+
+
+      switch ( fields->value )
+      {
+      case ft_frame_start:  /* access a new frame */
+        error = FT_Stream_EnterFrame( stream, fields->offset );
+        if ( error )
+          goto Exit;
+
+        frame_accessed = 1;
+        cursor         = stream->cursor;
+        fields++;
+        continue;  /* loop! */
+
+      case ft_frame_bytes:  /* read a byte sequence */
+      case ft_frame_skip:   /* skip some bytes      */
+        {
+          FT_UInt  len = fields->size;
+
+
+          if ( cursor + len > stream->limit )
+          {
+            error = FT_Err_Invalid_Stream_Operation;
+            goto Exit;
+          }
+
+          if ( fields->value == ft_frame_bytes )
+          {
+            p = (FT_Byte*)structure + fields->offset;
+            FT_MEM_COPY( p, cursor, len );
+          }
+          cursor += len;
+          fields++;
+          continue;
+        }
+
+      case ft_frame_byte:
+      case ft_frame_schar:  /* read a single byte */
+        value = FT_NEXT_BYTE(cursor);
+        sign_shift = 24;
+        break;
+
+      case ft_frame_short_be:
+      case ft_frame_ushort_be:  /* read a 2-byte big-endian short */
+        value = FT_NEXT_USHORT(cursor);
+        sign_shift = 16;
+        break;
+
+      case ft_frame_short_le:
+      case ft_frame_ushort_le:  /* read a 2-byte little-endian short */
+        value = FT_NEXT_USHORT_LE(cursor);
+        sign_shift = 16;
+        break;
+
+      case ft_frame_long_be:
+      case ft_frame_ulong_be:  /* read a 4-byte big-endian long */
+        value = FT_NEXT_ULONG(cursor);
+        sign_shift = 0;
+        break;
+
+      case ft_frame_long_le:
+      case ft_frame_ulong_le:  /* read a 4-byte little-endian long */
+        value = FT_NEXT_ULONG_LE(cursor);
+        sign_shift = 0;
+        break;
+
+      case ft_frame_off3_be:
+      case ft_frame_uoff3_be:  /* read a 3-byte big-endian long */
+        value = FT_NEXT_UOFF3(cursor);
+        sign_shift = 8;
+        break;
+
+      case ft_frame_off3_le:
+      case ft_frame_uoff3_le:  /* read a 3-byte little-endian long */
+        value = FT_NEXT_UOFF3_LE(cursor);
+        sign_shift = 8;
+        break;
+
+      default:
+        /* otherwise, exit the loop */
+        stream->cursor = cursor;
+        goto Exit;
+      }
+
+      /* now, compute the signed value is necessary */
+      if ( fields->value & FT_FRAME_OP_SIGNED )
+        value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift );
+
+      /* finally, store the value in the object */
+
+      p = (FT_Byte*)structure + fields->offset;
+      switch ( fields->size )
+      {
+      case (8 / FT_CHAR_BIT):
+        *(FT_Byte*)p = (FT_Byte)value;
+        break;
+
+      case (16 / FT_CHAR_BIT):
+        *(FT_UShort*)p = (FT_UShort)value;
+        break;
+
+      case (32 / FT_CHAR_BIT):
+        *(FT_UInt32*)p = (FT_UInt32)value;
+        break;
+
+      default:  /* for 64-bit systems */
+        *(FT_ULong*)p = (FT_ULong)value;
+      }
+
+      /* go to next field */
+      fields++;
+    }
+    while ( 1 );
+
+  Exit:
+    /* close the frame if it was opened by this read */
+    if ( frame_accessed )
+      FT_Stream_ExitFrame( stream );
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftstroke.c b/nx-X11/extras/freetype2/src/base/ftstroke.c
new file mode 100644
index 000000000..10aad2db8
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftstroke.c
@@ -0,0 +1,1906 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftstroke.c                                                             */
+/*                                                                         */
+/*    FreeType path stroker (body).                                        */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 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_STROKER_H
+#include FT_TRIGONOMETRY_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_MEMORY_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_OBJECTS_H
+
+  FT_EXPORT_DEF( FT_StrokerBorder )
+  FT_Outline_GetInsideBorder( FT_Outline*  outline )
+  {
+    FT_Orientation  o = FT_Outline_Get_Orientation( outline );
+
+
+    return o == FT_ORIENTATION_TRUETYPE ? FT_STROKER_BORDER_RIGHT
+                                        : FT_STROKER_BORDER_LEFT ;
+  }
+
+
+  FT_EXPORT_DEF( FT_StrokerBorder )
+  FT_Outline_GetOutsideBorder( FT_Outline*  outline )
+  {
+    FT_Orientation  o = FT_Outline_Get_Orientation( outline );
+
+
+    return o == FT_ORIENTATION_TRUETYPE ? FT_STROKER_BORDER_LEFT
+                                        : FT_STROKER_BORDER_RIGHT ;
+  }
+
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****                       BEZIER COMPUTATIONS                       *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+#define FT_SMALL_CONIC_THRESHOLD  ( FT_ANGLE_PI / 6 )
+#define FT_SMALL_CUBIC_THRESHOLD  ( FT_ANGLE_PI / 6 )
+#define FT_EPSILON  2
+
+#define FT_IS_SMALL( x )  ( (x) > -FT_EPSILON && (x) < FT_EPSILON )
+
+
+  static FT_Pos
+  ft_pos_abs( FT_Pos  x )
+  {
+    return x >= 0 ? x : -x ;
+  }
+
+
+  static void
+  ft_conic_split( FT_Vector*  base )
+  {
+    FT_Pos  a, b;
+
+
+    base[4].x = base[2].x;
+    b = base[1].x;
+    a = base[3].x = ( base[2].x + b ) / 2;
+    b = base[1].x = ( base[0].x + b ) / 2;
+    base[2].x = ( a + b ) / 2;
+
+    base[4].y = base[2].y;
+    b = base[1].y;
+    a = base[3].y = ( base[2].y + b ) / 2;
+    b = base[1].y = ( base[0].y + b ) / 2;
+    base[2].y = ( a + b ) / 2;
+  }
+
+
+  static FT_Bool
+  ft_conic_is_small_enough( FT_Vector*  base,
+                            FT_Angle   *angle_in,
+                            FT_Angle   *angle_out )
+  {
+    FT_Vector  d1, d2;
+    FT_Angle   theta;
+    FT_Int     close1, close2;
+
+
+    d1.x = base[1].x - base[2].x;
+    d1.y = base[1].y - base[2].y;
+    d2.x = base[0].x - base[1].x;
+    d2.y = base[0].y - base[1].y;
+
+    close1 = FT_IS_SMALL( d1.x ) && FT_IS_SMALL( d1.y );
+    close2 = FT_IS_SMALL( d2.x ) && FT_IS_SMALL( d2.y );
+
+    if ( close1 )
+    {
+      if ( close2 )
+        *angle_in = *angle_out = 0;
+      else
+        *angle_in = *angle_out = FT_Atan2( d2.x, d2.y );
+    }
+    else if ( close2 )
+    {
+      *angle_in = *angle_out = FT_Atan2( d1.x, d1.y );
+    }
+    else
+    {
+      *angle_in  = FT_Atan2( d1.x, d1.y );
+      *angle_out = FT_Atan2( d2.x, d2.y );
+    }
+
+    theta = ft_pos_abs( FT_Angle_Diff( *angle_in, *angle_out ) );
+
+    return FT_BOOL( theta < FT_SMALL_CONIC_THRESHOLD );
+  }
+
+
+  static void
+  ft_cubic_split( FT_Vector*  base )
+  {
+    FT_Pos  a, b, c, d;
+
+
+    base[6].x = base[3].x;
+    c = base[1].x;
+    d = base[2].x;
+    base[1].x = a = ( base[0].x + c ) / 2;
+    base[5].x = b = ( base[3].x + d ) / 2;
+    c = ( c + d ) / 2;
+    base[2].x = a = ( a + c ) / 2;
+    base[4].x = b = ( b + c ) / 2;
+    base[3].x = ( a + b ) / 2;
+
+    base[6].y = base[3].y;
+    c = base[1].y;
+    d = base[2].y;
+    base[1].y = a = ( base[0].y + c ) / 2;
+    base[5].y = b = ( base[3].y + d ) / 2;
+    c = ( c + d ) / 2;
+    base[2].y = a = ( a + c ) / 2;
+    base[4].y = b = ( b + c ) / 2;
+    base[3].y = ( a + b ) / 2;
+  }
+
+
+  static FT_Bool
+  ft_cubic_is_small_enough( FT_Vector*  base,
+                            FT_Angle   *angle_in,
+                            FT_Angle   *angle_mid,
+                            FT_Angle   *angle_out )
+  {
+    FT_Vector  d1, d2, d3;
+    FT_Angle   theta1, theta2;
+    FT_Int     close1, close2, close3;
+
+
+    d1.x = base[2].x - base[3].x;
+    d1.y = base[2].y - base[3].y;
+    d2.x = base[1].x - base[2].x;
+    d2.y = base[1].y - base[2].y;
+    d3.x = base[0].x - base[1].x;
+    d3.y = base[0].y - base[1].y;
+
+    close1 = FT_IS_SMALL( d1.x ) && FT_IS_SMALL( d1.y );
+    close2 = FT_IS_SMALL( d2.x ) && FT_IS_SMALL( d2.y );
+    close3 = FT_IS_SMALL( d3.x ) && FT_IS_SMALL( d3.y );
+
+    if ( close1 || close3 )
+    {
+      if ( close2 )
+      {
+        /* basically a point */
+        *angle_in = *angle_out = *angle_mid = 0;
+      }
+      else if ( close1 )
+      {
+        *angle_in  = *angle_mid = FT_Atan2( d2.x, d2.y );
+        *angle_out = FT_Atan2( d3.x, d3.y );
+      }
+      else  /* close2 */
+      {
+        *angle_in  = FT_Atan2( d1.x, d1.y );
+        *angle_mid = *angle_out = FT_Atan2( d2.x, d2.y );
+      }
+    }
+    else if ( close2 )
+    {
+      *angle_in  = *angle_mid = FT_Atan2( d1.x, d1.y );
+      *angle_out = FT_Atan2( d3.x, d3.y );
+    }
+    else
+    {
+      *angle_in  = FT_Atan2( d1.x, d1.y );
+      *angle_mid = FT_Atan2( d2.x, d2.y );
+      *angle_out = FT_Atan2( d3.x, d3.y );
+    }
+
+    theta1 = ft_pos_abs( FT_Angle_Diff( *angle_in,  *angle_mid ) );
+    theta2 = ft_pos_abs( FT_Angle_Diff( *angle_mid, *angle_out ) );
+
+    return FT_BOOL( theta1 < FT_SMALL_CUBIC_THRESHOLD &&
+                    theta2 < FT_SMALL_CUBIC_THRESHOLD );
+  }
+
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****                       STROKE BORDERS                            *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+  typedef enum
+  {
+    FT_STROKE_TAG_ON    = 1,   /* on-curve point  */
+    FT_STROKE_TAG_CUBIC = 2,   /* cubic off-point */
+    FT_STROKE_TAG_BEGIN = 4,   /* sub-path start  */
+    FT_STROKE_TAG_END   = 8    /* sub-path end    */
+
+  } FT_StrokeTags;
+
+
+  typedef struct  FT_StrokeBorderRec_
+  {
+    FT_UInt     num_points;
+    FT_UInt     max_points;
+    FT_Vector*  points;
+    FT_Byte*    tags;
+    FT_Bool     movable;
+    FT_Int      start;    /* index of current sub-path start point */
+    FT_Memory   memory;
+    FT_Bool     valid;
+
+  } FT_StrokeBorderRec, *FT_StrokeBorder;
+
+
+  static FT_Error
+  ft_stroke_border_grow( FT_StrokeBorder  border,
+                         FT_UInt          new_points )
+  {
+    FT_UInt   old_max = border->max_points;
+    FT_UInt   new_max = border->num_points + new_points;
+    FT_Error  error   = 0;
+
+
+    if ( new_max > old_max )
+    {
+      FT_UInt    cur_max = old_max;
+      FT_Memory  memory  = border->memory;
+
+
+      while ( cur_max < new_max )
+        cur_max += ( cur_max >> 1 ) + 16;
+
+      if ( FT_RENEW_ARRAY( border->points, old_max, cur_max ) ||
+           FT_RENEW_ARRAY( border->tags,   old_max, cur_max ) )
+        goto Exit;
+
+      border->max_points = cur_max;
+    }
+  Exit:
+    return error;
+  }
+
+
+  static void
+  ft_stroke_border_close( FT_StrokeBorder  border )
+  {
+    FT_ASSERT( border->start >= 0 );
+
+    /* don't record empty paths! */
+    if ( border->num_points > (FT_UInt)border->start )
+    {
+      border->tags[border->start         ] |= FT_STROKE_TAG_BEGIN;
+      border->tags[border->num_points - 1] |= FT_STROKE_TAG_END;
+    }
+
+    border->start   = -1;
+    border->movable = 0;
+  }
+
+
+  static FT_Error
+  ft_stroke_border_lineto( FT_StrokeBorder  border,
+                           FT_Vector*       to,
+                           FT_Bool          movable )
+  {
+    FT_Error  error = 0;
+
+
+    FT_ASSERT( border->start >= 0 );
+
+    if ( border->movable )
+    {
+      /* move last point */
+      border->points[border->num_points - 1] = *to;
+    }
+    else
+    {
+      /* add one point */
+      error = ft_stroke_border_grow( border, 1 );
+      if ( !error )
+      {
+        FT_Vector*  vec = border->points + border->num_points;
+        FT_Byte*    tag = border->tags   + border->num_points;
+
+
+        vec[0] = *to;
+        tag[0] = FT_STROKE_TAG_ON;
+
+        border->num_points += 1;
+      }
+    }
+    border->movable = movable;
+    return error;
+  }
+
+
+  static FT_Error
+  ft_stroke_border_conicto( FT_StrokeBorder  border,
+                            FT_Vector*       control,
+                            FT_Vector*       to )
+  {
+    FT_Error  error;
+
+
+    FT_ASSERT( border->start >= 0 );
+
+    error = ft_stroke_border_grow( border, 2 );
+    if ( !error )
+    {
+      FT_Vector*  vec = border->points + border->num_points;
+      FT_Byte*    tag = border->tags   + border->num_points;
+
+      vec[0] = *control;
+      vec[1] = *to;
+
+      tag[0] = 0;
+      tag[1] = FT_STROKE_TAG_ON;
+
+      border->num_points += 2;
+    }
+    border->movable = 0;
+    return error;
+  }
+
+
+  static FT_Error
+  ft_stroke_border_cubicto( FT_StrokeBorder  border,
+                            FT_Vector*       control1,
+                            FT_Vector*       control2,
+                            FT_Vector*       to )
+  {
+    FT_Error  error;
+
+
+    FT_ASSERT( border->start >= 0 );
+
+    error = ft_stroke_border_grow( border, 3 );
+    if ( !error )
+    {
+      FT_Vector*  vec = border->points + border->num_points;
+      FT_Byte*    tag = border->tags   + border->num_points;
+
+
+      vec[0] = *control1;
+      vec[1] = *control2;
+      vec[2] = *to;
+
+      tag[0] = FT_STROKE_TAG_CUBIC;
+      tag[1] = FT_STROKE_TAG_CUBIC;
+      tag[2] = FT_STROKE_TAG_ON;
+
+      border->num_points += 3;
+    }
+    border->movable = 0;
+    return error;
+  }
+
+
+#define FT_ARC_CUBIC_ANGLE  ( FT_ANGLE_PI / 2 )
+
+
+  static FT_Error
+  ft_stroke_border_arcto( FT_StrokeBorder  border,
+                          FT_Vector*       center,
+                          FT_Fixed         radius,
+                          FT_Angle         angle_start,
+                          FT_Angle         angle_diff )
+  {
+    FT_Angle   total, angle, step, rotate, next, theta;
+    FT_Vector  a, b, a2, b2;
+    FT_Fixed   length;
+    FT_Error   error = 0;
+
+
+    /* compute start point */
+    FT_Vector_From_Polar( &a, radius, angle_start );
+    a.x += center->x;
+    a.y += center->y;
+
+    total  = angle_diff;
+    angle  = angle_start;
+    rotate = ( angle_diff >= 0 ) ? FT_ANGLE_PI2 : -FT_ANGLE_PI2;
+
+    while ( total != 0 )
+    {
+      step = total;
+      if ( step > FT_ARC_CUBIC_ANGLE )
+        step = FT_ARC_CUBIC_ANGLE;
+
+      else if ( step < -FT_ARC_CUBIC_ANGLE )
+        step = -FT_ARC_CUBIC_ANGLE;
+
+      next  = angle + step;
+      theta = step;
+      if ( theta < 0 )
+        theta = -theta;
+
+      theta >>= 1;
+
+      /* compute end point */
+      FT_Vector_From_Polar( &b, radius, next );
+      b.x += center->x;
+      b.y += center->y;
+
+      /* compute first and second control points */
+      length = FT_MulDiv( radius, FT_Sin( theta ) * 4,
+                          ( 0x10000L + FT_Cos( theta ) ) * 3 );
+
+      FT_Vector_From_Polar( &a2, length, angle + rotate );
+      a2.x += a.x;
+      a2.y += a.y;
+
+      FT_Vector_From_Polar( &b2, length, next - rotate );
+      b2.x += b.x;
+      b2.y += b.y;
+
+      /* add cubic arc */
+      error = ft_stroke_border_cubicto( border, &a2, &b2, &b );
+      if ( error )
+        break;
+
+      /* process the rest of the arc ?? */
+      a      = b;
+      total -= step;
+      angle  = next;
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  ft_stroke_border_moveto( FT_StrokeBorder  border,
+                           FT_Vector*       to )
+  {
+    /* close current open path if any ? */
+    if ( border->start >= 0 )
+      ft_stroke_border_close( border );
+
+    border->start   = border->num_points;
+    border->movable = 0;
+
+    return ft_stroke_border_lineto( border, to, 0 );
+  }
+
+
+  static void
+  ft_stroke_border_init( FT_StrokeBorder  border,
+                         FT_Memory        memory )
+  {
+    border->memory = memory;
+    border->points = NULL;
+    border->tags   = NULL;
+
+    border->num_points = 0;
+    border->max_points = 0;
+    border->start      = -1;
+    border->valid      = 0;
+  }
+
+
+  static void
+  ft_stroke_border_reset( FT_StrokeBorder  border )
+  {
+    border->num_points = 0;
+    border->start      = -1;
+    border->valid      = 0;
+  }
+
+
+  static void
+  ft_stroke_border_done( FT_StrokeBorder  border )
+  {
+    FT_Memory  memory = border->memory;
+
+
+    FT_FREE( border->points );
+    FT_FREE( border->tags );
+
+    border->num_points = 0;
+    border->max_points = 0;
+    border->start      = -1;
+    border->valid      = 0;
+  }
+
+
+  static FT_Error
+  ft_stroke_border_get_counts( FT_StrokeBorder  border,
+                               FT_UInt         *anum_points,
+                               FT_UInt         *anum_contours )
+  {
+    FT_Error  error        = 0;
+    FT_UInt   num_points   = 0;
+    FT_UInt   num_contours = 0;
+
+    FT_UInt     count      = border->num_points;
+    FT_Vector*  point      = border->points;
+    FT_Byte*    tags       = border->tags;
+    FT_Int      in_contour = 0;
+
+
+    for ( ; count > 0; count--, num_points++, point++, tags++ )
+    {
+      if ( tags[0] & FT_STROKE_TAG_BEGIN )
+      {
+        if ( in_contour != 0 )
+          goto Fail;
+
+        in_contour = 1;
+      }
+      else if ( in_contour == 0 )
+        goto Fail;
+
+      if ( tags[0] & FT_STROKE_TAG_END )
+      {
+        if ( in_contour == 0 )
+          goto Fail;
+
+        in_contour = 0;
+        num_contours++;
+      }
+    }
+
+    if ( in_contour != 0 )
+      goto Fail;
+
+    border->valid = 1;
+
+  Exit:
+    *anum_points   = num_points;
+    *anum_contours = num_contours;
+    return error;
+
+  Fail:
+    num_points   = 0;
+    num_contours = 0;
+    goto Exit;
+  }
+
+
+  static void
+  ft_stroke_border_export( FT_StrokeBorder  border,
+                           FT_Outline*      outline )
+  {
+    /* copy point locations */
+    FT_ARRAY_COPY( outline->points + outline->n_points,
+                   border->points,
+                   border->num_points );
+
+    /* copy tags */
+    {
+      FT_UInt   count = border->num_points;
+      FT_Byte*  read  = border->tags;
+      FT_Byte*  write = (FT_Byte*)outline->tags + outline->n_points;
+
+
+      for ( ; count > 0; count--, read++, write++ )
+      {
+        if ( *read & FT_STROKE_TAG_ON )
+          *write = FT_CURVE_TAG_ON;
+        else if ( *read & FT_STROKE_TAG_CUBIC )
+          *write = FT_CURVE_TAG_CUBIC;
+        else
+          *write = FT_CURVE_TAG_CONIC;
+      }
+    }
+
+    /* copy contours */
+    {
+      FT_UInt    count = border->num_points;
+      FT_Byte*   tags  = border->tags;
+      FT_Short*  write = outline->contours + outline->n_contours;
+      FT_Short   idx   = (FT_Short)outline->n_points;
+
+
+      for ( ; count > 0; count--, tags++, idx++ )
+      {
+        if ( *tags & FT_STROKE_TAG_END )
+        {
+          *write++ = idx;
+          outline->n_contours++;
+        }
+      }
+    }
+
+    outline->n_points  = (short)( outline->n_points + border->num_points );
+
+    FT_ASSERT( FT_Outline_Check( outline ) == 0 );
+  }
+
+
+ /***************************************************************************/
+ /***************************************************************************/
+ /*****                                                                 *****/
+ /*****                           STROKER                               *****/
+ /*****                                                                 *****/
+ /***************************************************************************/
+ /***************************************************************************/
+
+#define FT_SIDE_TO_ROTATE( s )   ( FT_ANGLE_PI2 - (s) * FT_ANGLE_PI )
+
+  typedef struct  FT_StrokerRec_
+  {
+    FT_Angle             angle_in;
+    FT_Angle             angle_out;
+    FT_Vector            center;
+    FT_Bool              first_point;
+    FT_Bool              subpath_open;
+    FT_Angle             subpath_angle;
+    FT_Vector            subpath_start;
+
+    FT_Stroker_LineCap   line_cap;
+    FT_Stroker_LineJoin  line_join;
+    FT_Fixed             miter_limit;
+    FT_Fixed             radius;
+
+    FT_Bool              valid;
+    FT_StrokeBorderRec   borders[2];
+    FT_Memory            memory;
+
+  } FT_StrokerRec;
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_New( FT_Memory    memory,
+                  FT_Stroker  *astroker )
+  {
+    FT_Error    error;
+    FT_Stroker  stroker;
+
+
+    if ( !FT_NEW( stroker ) )
+    {
+      stroker->memory = memory;
+
+      ft_stroke_border_init( &stroker->borders[0], memory );
+      ft_stroke_border_init( &stroker->borders[1], memory );
+    }
+    *astroker = stroker;
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FT_Stroker_Set( FT_Stroker           stroker,
+                  FT_Fixed             radius,
+                  FT_Stroker_LineCap   line_cap,
+                  FT_Stroker_LineJoin  line_join,
+                  FT_Fixed             miter_limit )
+  {
+    stroker->radius      = radius;
+    stroker->line_cap    = line_cap;
+    stroker->line_join   = line_join;
+    stroker->miter_limit = miter_limit;
+
+    FT_Stroker_Rewind( stroker );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FT_Stroker_Rewind( FT_Stroker  stroker )
+  {
+    if ( stroker )
+    {
+      ft_stroke_border_reset( &stroker->borders[0] );
+      ft_stroke_border_reset( &stroker->borders[1] );
+    }
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FT_Stroker_Done( FT_Stroker  stroker )
+  {
+    if ( stroker )
+    {
+      FT_Memory  memory = stroker->memory;
+
+
+      ft_stroke_border_done( &stroker->borders[0] );
+      ft_stroke_border_done( &stroker->borders[1] );
+
+      stroker->memory = NULL;
+      FT_FREE( stroker );
+    }
+  }
+
+
+  /* creates a circular arc at a corner or cap */
+  static FT_Error
+  ft_stroker_arcto( FT_Stroker  stroker,
+                    FT_Int      side )
+  {
+    FT_Angle         total, rotate;
+    FT_Fixed         radius = stroker->radius;
+    FT_Error         error  = 0;
+    FT_StrokeBorder  border = stroker->borders + side;
+
+
+    rotate = FT_SIDE_TO_ROTATE( side );
+
+    total = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
+    if ( total == FT_ANGLE_PI )
+      total = -rotate * 2;
+
+    error = ft_stroke_border_arcto( border,
+                                    &stroker->center,
+                                    radius,
+                                    stroker->angle_in + rotate,
+                                    total );
+    border->movable = 0;
+    return error;
+  }
+
+
+  /* adds a cap at the end of an opened path */
+  static FT_Error
+  ft_stroker_cap( FT_Stroker  stroker,
+                  FT_Angle    angle,
+                  FT_Int      side )
+  {
+    FT_Error  error  = 0;
+
+
+    if ( stroker->line_cap == FT_STROKER_LINECAP_ROUND )
+    {
+      /* add a round cap */
+      stroker->angle_in  = angle;
+      stroker->angle_out = angle + FT_ANGLE_PI;
+      error = ft_stroker_arcto( stroker, side );
+    }
+    else if ( stroker->line_cap == FT_STROKER_LINECAP_SQUARE )
+    {
+      /* add a square cap */
+      FT_Vector        delta, delta2;
+      FT_Angle         rotate = FT_SIDE_TO_ROTATE( side );
+      FT_Fixed         radius = stroker->radius;
+      FT_StrokeBorder  border = stroker->borders + side;
+
+
+      FT_Vector_From_Polar( &delta2, radius, angle + rotate );
+      FT_Vector_From_Polar( &delta,  radius, angle );
+
+      delta.x += stroker->center.x + delta2.x;
+      delta.y += stroker->center.y + delta2.y;
+
+      error = ft_stroke_border_lineto( border, &delta, 0 );
+      if ( error )
+        goto Exit;
+
+      FT_Vector_From_Polar( &delta2, radius, angle - rotate );
+      FT_Vector_From_Polar( &delta,  radius, angle );
+
+      delta.x += delta2.x + stroker->center.x;
+      delta.y += delta2.y + stroker->center.y;
+
+      error = ft_stroke_border_lineto( border, &delta, 0 );
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* process an inside corner, i.e. compute intersection */
+  static FT_Error
+  ft_stroker_inside( FT_Stroker  stroker,
+                     FT_Int      side)
+  {
+    FT_StrokeBorder  border = stroker->borders + side;
+    FT_Angle         phi, theta, rotate;
+    FT_Fixed         length, thcos, sigma;
+    FT_Vector        delta;
+    FT_Error         error = 0;
+
+
+    rotate = FT_SIDE_TO_ROTATE( side );
+
+    /* compute median angle */
+    theta = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
+    if ( theta == FT_ANGLE_PI )
+      theta = rotate;
+    else
+      theta = theta / 2;
+
+    phi = stroker->angle_in + theta;
+
+    thcos  = FT_Cos( theta );
+    sigma  = FT_MulFix( stroker->miter_limit, thcos );
+
+    if ( sigma < 0x10000L )
+    {
+      FT_Vector_From_Polar( &delta, stroker->radius,
+                            stroker->angle_out + rotate );
+      delta.x += stroker->center.x;
+      delta.y += stroker->center.y;
+      border->movable = 0;
+    }
+    else
+    {
+      length = FT_DivFix( stroker->radius, thcos );
+
+      FT_Vector_From_Polar( &delta, length, phi + rotate );
+      delta.x += stroker->center.x;
+      delta.y += stroker->center.y;
+    }
+
+    error = ft_stroke_border_lineto( border, &delta, 0 );
+
+    return error;
+  }
+
+
+  /* process an outside corner, i.e. compute bevel/miter/round */
+  static FT_Error
+  ft_stroker_outside( FT_Stroker  stroker,
+                      FT_Int      side )
+  {
+    FT_StrokeBorder  border = stroker->borders + side;
+    FT_Error         error;
+    FT_Angle         rotate;
+
+
+    if ( stroker->line_join == FT_STROKER_LINEJOIN_ROUND )
+    {
+      error = ft_stroker_arcto( stroker, side );
+    }
+    else
+    {
+      /* this is a mitered or beveled corner */
+      FT_Fixed  sigma, radius = stroker->radius;
+      FT_Angle  theta, phi;
+      FT_Fixed  thcos;
+      FT_Bool   miter;
+
+
+      rotate = FT_SIDE_TO_ROTATE( side );
+      miter  = FT_BOOL( stroker->line_join == FT_STROKER_LINEJOIN_MITER );
+
+      theta  = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
+      if ( theta == FT_ANGLE_PI )
+      {
+        theta = rotate;
+        phi   = stroker->angle_in;
+      }
+      else
+      {
+        theta = theta / 2;
+        phi   = stroker->angle_in + theta + rotate;
+      }
+
+      thcos = FT_Cos( theta );
+      sigma = FT_MulFix( stroker->miter_limit, thcos );
+
+      if ( sigma >= 0x10000L )
+        miter = 0;
+
+      if ( miter )  /* this is a miter (broken angle) */
+      {
+        FT_Vector  middle, delta;
+        FT_Fixed   length;
+
+
+        /* compute middle point */
+        FT_Vector_From_Polar( &middle,
+                              FT_MulFix( radius, stroker->miter_limit ),
+                              phi );
+        middle.x += stroker->center.x;
+        middle.y += stroker->center.y;
+
+        /* compute first angle point */
+        length = FT_MulFix( radius,
+                            FT_DivFix( 0x10000L - sigma,
+                                       ft_pos_abs( FT_Sin( theta ) ) ) );
+
+        FT_Vector_From_Polar( &delta, length, phi + rotate );
+        delta.x += middle.x;
+        delta.y += middle.y;
+
+        error = ft_stroke_border_lineto( border, &delta, 0 );
+        if ( error )
+          goto Exit;
+
+        /* compute second angle point */
+        FT_Vector_From_Polar( &delta, length, phi - rotate );
+        delta.x += middle.x;
+        delta.y += middle.y;
+
+        error = ft_stroke_border_lineto( border, &delta, 0 );
+        if ( error )
+          goto Exit;
+
+        /* finally, add a movable end point */
+        FT_Vector_From_Polar( &delta, radius, stroker->angle_out + rotate );
+        delta.x += stroker->center.x;
+        delta.y += stroker->center.y;
+
+        error = ft_stroke_border_lineto( border, &delta, 1 );
+      }
+
+      else /* this is a bevel (intersection) */
+      {
+        FT_Fixed   length;
+        FT_Vector  delta;
+
+
+        length = FT_DivFix( stroker->radius, thcos );
+
+        FT_Vector_From_Polar( &delta, length, phi );
+        delta.x += stroker->center.x;
+        delta.y += stroker->center.y;
+
+        error = ft_stroke_border_lineto( border, &delta, 0 );
+        if (error) goto Exit;
+
+        /* now add end point */
+        FT_Vector_From_Polar( &delta, stroker->radius,
+                              stroker->angle_out + rotate );
+        delta.x += stroker->center.x;
+        delta.y += stroker->center.y;
+
+        error = ft_stroke_border_lineto( border, &delta, 1 );
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  ft_stroker_process_corner( FT_Stroker  stroker )
+  {
+    FT_Error  error = 0;
+    FT_Angle  turn;
+    FT_Int    inside_side;
+
+
+    turn = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
+
+    /* no specific corner processing is required if the turn is 0 */
+    if ( turn == 0 )
+      goto Exit;
+
+    /* when we turn to the right, the inside side is 0 */
+    inside_side = 0;
+
+    /* otherwise, the inside side is 1 */
+    if ( turn < 0 )
+      inside_side = 1;
+
+    /* process the inside side */
+    error = ft_stroker_inside( stroker, inside_side );
+    if ( error )
+      goto Exit;
+
+    /* process the outside side */
+    error = ft_stroker_outside( stroker, 1 - inside_side );
+
+  Exit:
+    return error;
+  }
+
+
+  /* add two points to the left and right borders corresponding to the */
+  /* start of the subpath..                                            */
+  static FT_Error
+  ft_stroker_subpath_start( FT_Stroker  stroker,
+                            FT_Angle    start_angle )
+  {
+    FT_Vector        delta;
+    FT_Vector        point;
+    FT_Error         error;
+    FT_StrokeBorder  border;
+
+
+    FT_Vector_From_Polar( &delta, stroker->radius,
+                          start_angle + FT_ANGLE_PI2 );
+
+    point.x = stroker->center.x + delta.x;
+    point.y = stroker->center.y + delta.y;
+
+    border = stroker->borders;
+    error = ft_stroke_border_moveto( border, &point );
+    if ( error )
+      goto Exit;
+
+    point.x = stroker->center.x - delta.x;
+    point.y = stroker->center.y - delta.y;
+
+    border++;
+    error = ft_stroke_border_moveto( border, &point );
+
+    /* save angle for last cap */
+    stroker->subpath_angle = start_angle;
+    stroker->first_point   = 0;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_LineTo( FT_Stroker  stroker,
+                     FT_Vector*  to )
+  {
+    FT_Error         error = 0;
+    FT_StrokeBorder  border;
+    FT_Vector        delta;
+    FT_Angle         angle;
+    FT_Int           side;
+
+    delta.x = to->x - stroker->center.x;
+    delta.y = to->y - stroker->center.y;
+
+    angle = FT_Atan2( delta.x, delta.y );
+    FT_Vector_From_Polar( &delta, stroker->radius, angle + FT_ANGLE_PI2 );
+
+    /* process corner if necessary */
+    if ( stroker->first_point )
+    {
+      /* This is the first segment of a subpath.  We need to     */
+      /* add a point to each border at their respective starting */
+      /* point locations.                                        */
+      error = ft_stroker_subpath_start( stroker, angle );
+      if ( error )
+        goto Exit;
+    }
+    else
+    {
+      /* process the current corner */
+      stroker->angle_out = angle;
+      error = ft_stroker_process_corner( stroker );
+      if ( error )
+        goto Exit;
+    }
+
+    /* now add a line segment to both the "inside" and "outside" paths */
+
+    for ( border = stroker->borders, side = 1; side >= 0; side--, border++ )
+    {
+      FT_Vector  point;
+
+
+      point.x = to->x + delta.x;
+      point.y = to->y + delta.y;
+
+      error = ft_stroke_border_lineto( border, &point, 1 );
+      if ( error )
+        goto Exit;
+
+      delta.x = -delta.x;
+      delta.y = -delta.y;
+    }
+
+    stroker->angle_in = angle;
+    stroker->center   = *to;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_ConicTo( FT_Stroker  stroker,
+                      FT_Vector*  control,
+                      FT_Vector*  to )
+  {
+    FT_Error    error = 0;
+    FT_Vector   bez_stack[34];
+    FT_Vector*  arc;
+    FT_Vector*  limit = bez_stack + 30;
+    FT_Angle    start_angle;
+    FT_Bool     first_arc = 1;
+
+
+    arc    = bez_stack;
+    arc[0] = *to;
+    arc[1] = *control;
+    arc[2] = stroker->center;
+
+    while ( arc >= bez_stack )
+    {
+      FT_Angle  angle_in, angle_out;
+
+
+      angle_in = angle_out = 0;  /* remove compiler warnings */
+
+      if ( arc < limit                                             &&
+           !ft_conic_is_small_enough( arc, &angle_in, &angle_out ) )
+      {
+        ft_conic_split( arc );
+        arc += 2;
+        continue;
+      }
+
+      if ( first_arc )
+      {
+        first_arc = 0;
+
+        start_angle = angle_in;
+
+        /* process corner if necessary */
+        if ( stroker->first_point )
+          error = ft_stroker_subpath_start( stroker, start_angle );
+        else
+        {
+          stroker->angle_out = start_angle;
+          error = ft_stroker_process_corner( stroker );
+        }
+      }
+
+      /* the arc's angle is small enough; we can add it directly to each */
+      /* border                                                          */
+      {
+        FT_Vector  ctrl, end;
+        FT_Angle   theta, phi, rotate;
+        FT_Fixed   length;
+        FT_Int     side;
+
+
+        theta  = FT_Angle_Diff( angle_in, angle_out ) / 2;
+        phi    = angle_in + theta;
+        length = FT_DivFix( stroker->radius, FT_Cos( theta ) );
+
+        for ( side = 0; side <= 1; side++ )
+        {
+          rotate = FT_SIDE_TO_ROTATE( side );
+
+          /* compute control point */
+          FT_Vector_From_Polar( &ctrl, length, phi + rotate );
+          ctrl.x += arc[1].x;
+          ctrl.y += arc[1].y;
+
+          /* compute end point */
+          FT_Vector_From_Polar( &end, stroker->radius, angle_out + rotate );
+          end.x += arc[0].x;
+          end.y += arc[0].y;
+
+          error = ft_stroke_border_conicto( stroker->borders + side,
+                                            &ctrl, &end );
+          if ( error )
+            goto Exit;
+        }
+      }
+
+      arc -= 2;
+
+      if ( arc < bez_stack )
+        stroker->angle_in = angle_out;
+    }
+
+    stroker->center = *to;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_CubicTo( FT_Stroker  stroker,
+                      FT_Vector*  control1,
+                      FT_Vector*  control2,
+                      FT_Vector*  to )
+  {
+    FT_Error    error = 0;
+    FT_Vector   bez_stack[37];
+    FT_Vector*  arc;
+    FT_Vector*  limit = bez_stack + 32;
+    FT_Angle    start_angle;
+    FT_Bool     first_arc = 1;
+
+
+    arc    = bez_stack;
+    arc[0] = *to;
+    arc[1] = *control2;
+    arc[2] = *control1;
+    arc[3] = stroker->center;
+
+    while ( arc >= bez_stack )
+    {
+      FT_Angle  angle_in, angle_mid, angle_out;
+
+
+      /* remove compiler warnings */
+      angle_in = angle_out = angle_mid = 0;
+
+      if ( arc < limit                                         &&
+           !ft_cubic_is_small_enough( arc, &angle_in,
+                                      &angle_mid, &angle_out ) )
+      {
+        ft_cubic_split( arc );
+        arc += 3;
+        continue;
+      }
+
+      if ( first_arc )
+      {
+        first_arc = 0;
+
+        /* process corner if necessary */
+        start_angle = angle_in;
+
+        if ( stroker->first_point )
+          error = ft_stroker_subpath_start( stroker, start_angle );
+        else
+        {
+          stroker->angle_out = start_angle;
+          error = ft_stroker_process_corner( stroker );
+        }
+        if ( error )
+          goto Exit;
+      }
+
+      /* the arc's angle is small enough; we can add it directly to each */
+      /* border                                                          */
+      {
+        FT_Vector  ctrl1, ctrl2, end;
+        FT_Angle   theta1, phi1, theta2, phi2, rotate;
+        FT_Fixed   length1, length2;
+        FT_Int     side;
+
+
+        theta1  = ft_pos_abs( angle_mid - angle_in ) / 2;
+        theta2  = ft_pos_abs( angle_out - angle_mid ) / 2;
+        phi1    = (angle_mid + angle_in ) / 2;
+        phi2    = (angle_mid + angle_out ) / 2;
+        length1 = FT_DivFix( stroker->radius, FT_Cos( theta1 ) );
+        length2 = FT_DivFix( stroker->radius, FT_Cos(theta2) );
+
+        for ( side = 0; side <= 1; side++ )
+        {
+          rotate = FT_SIDE_TO_ROTATE( side );
+
+          /* compute control points */
+          FT_Vector_From_Polar( &ctrl1, length1, phi1 + rotate );
+          ctrl1.x += arc[2].x;
+          ctrl1.y += arc[2].y;
+
+          FT_Vector_From_Polar( &ctrl2, length2, phi2 + rotate );
+          ctrl2.x += arc[1].x;
+          ctrl2.y += arc[1].y;
+
+          /* compute end point */
+          FT_Vector_From_Polar( &end, stroker->radius, angle_out + rotate );
+          end.x += arc[0].x;
+          end.y += arc[0].y;
+
+          error = ft_stroke_border_cubicto( stroker->borders + side,
+                                            &ctrl1, &ctrl2, &end );
+          if ( error )
+            goto Exit;
+        }
+      }
+
+      arc -= 3;
+      if ( arc < bez_stack )
+        stroker->angle_in = angle_out;
+    }
+
+    stroker->center = *to;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_BeginSubPath( FT_Stroker  stroker,
+                           FT_Vector*  to,
+                           FT_Bool     open )
+  {
+    /* We cannot process the first point, because there is not enough      */
+    /* information regarding its corner/cap.  The latter will be processed */
+    /* in the "end_subpath" routine.                                       */
+    /*                                                                     */
+    stroker->first_point   = 1;
+    stroker->center        = *to;
+    stroker->subpath_open  = open;
+
+    /* record the subpath start point index for each border */
+    stroker->subpath_start = *to;
+    return 0;
+  }
+
+
+  static FT_Error
+  ft_stroker_add_reverse_left( FT_Stroker  stroker,
+                               FT_Bool     open )
+  {
+    FT_StrokeBorder  right  = stroker->borders + 0;
+    FT_StrokeBorder  left   = stroker->borders + 1;
+    FT_Int           new_points;
+    FT_Error         error  = 0;
+
+
+    FT_ASSERT( left->start >= 0 );
+
+    new_points = left->num_points - left->start;
+    if ( new_points > 0 )
+    {
+      error = ft_stroke_border_grow( right, (FT_UInt)new_points );
+      if ( error )
+        goto Exit;
+
+      {
+        FT_Vector*  dst_point = right->points + right->num_points;
+        FT_Byte*    dst_tag   = right->tags   + right->num_points;
+        FT_Vector*  src_point = left->points  + left->num_points - 1;
+        FT_Byte*    src_tag   = left->tags    + left->num_points - 1;
+
+        while ( src_point >= left->points + left->start )
+        {
+          *dst_point = *src_point;
+          *dst_tag   = *src_tag;
+
+          if ( open )
+            dst_tag[0] &= ~( FT_STROKE_TAG_BEGIN | FT_STROKE_TAG_END );
+          else
+          {
+            /* switch begin/end tags if necessary.. */
+            if ( dst_tag[0] & ( FT_STROKE_TAG_BEGIN | FT_STROKE_TAG_END ) )
+              dst_tag[0] ^= ( FT_STROKE_TAG_BEGIN | FT_STROKE_TAG_END );
+          }
+
+          src_point--;
+          src_tag--;
+          dst_point++;
+          dst_tag++;
+        }
+      }
+
+      left->num_points   = left->start;
+      right->num_points += new_points;
+
+      right->movable = 0;
+      left->movable  = 0;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* there's a lot of magic in this function! */
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_EndSubPath( FT_Stroker  stroker )
+  {
+    FT_Error  error  = 0;
+
+    if ( stroker->subpath_open )
+    {
+      FT_StrokeBorder  right = stroker->borders;
+
+      /* All right, this is an opened path, we need to add a cap between */
+      /* right & left, add the reverse of left, then add a final cap     */
+      /* between left & right.                                           */
+      error = ft_stroker_cap( stroker, stroker->angle_in, 0 );
+      if ( error )
+        goto Exit;
+
+      /* add reversed points from "left" to "right" */
+      error = ft_stroker_add_reverse_left( stroker, 1 );
+      if ( error )
+        goto Exit;
+
+      /* now add the final cap */
+      stroker->center = stroker->subpath_start;
+      error = ft_stroker_cap( stroker,
+                              stroker->subpath_angle + FT_ANGLE_PI, 0 );
+      if ( error )
+        goto Exit;
+
+      /* Now end the right subpath accordingly.  The left one is */
+      /* rewind and doesn't need further processing.             */
+      ft_stroke_border_close( right );
+    }
+    else
+    {
+      FT_Angle  turn;
+      FT_Int    inside_side;
+
+      /* close the path if needed */
+      if ( stroker->center.x != stroker->subpath_start.x ||
+           stroker->center.y != stroker->subpath_start.y )
+      {
+        error = FT_Stroker_LineTo( stroker, &stroker->subpath_start );
+        if ( error )
+          goto Exit;
+      }
+
+      /* process the corner */
+      stroker->angle_out = stroker->subpath_angle;
+      turn               = FT_Angle_Diff( stroker->angle_in,
+                                          stroker->angle_out );
+
+      /* no specific corner processing is required if the turn is 0 */
+      if ( turn != 0 )
+      {
+        /* when we turn to the right, the inside side is 0 */
+        inside_side = 0;
+
+        /* otherwise, the inside side is 1 */
+        if ( turn < 0 )
+          inside_side = 1;
+
+        /* IMPORTANT: WE DO NOT PROCESS THE INSIDE BORDER HERE! */
+        /* process the inside side                              */
+        /* error = ft_stroker_inside( stroker, inside_side );   */
+        /* if ( error )                                         */
+        /*   goto Exit;                                         */
+
+        /* process the outside side */
+        error = ft_stroker_outside( stroker, 1 - inside_side );
+        if ( error )
+          goto Exit;
+      }
+
+      /* then end our two subpaths */
+      ft_stroke_border_close( stroker->borders + 0 );
+      ft_stroke_border_close( stroker->borders + 1 );
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_GetBorderCounts( FT_Stroker        stroker,
+                              FT_StrokerBorder  border,
+                              FT_UInt          *anum_points,
+                              FT_UInt          *anum_contours )
+  {
+    FT_UInt   num_points = 0, num_contours = 0;
+    FT_Error  error;
+
+
+    if ( !stroker || border > 1 )
+    {
+      error = FT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    error = ft_stroke_border_get_counts( stroker->borders + border,
+                                         &num_points, &num_contours );
+  Exit:
+    if ( anum_points )
+      *anum_points = num_points;
+
+    if ( anum_contours )
+      *anum_contours = num_contours;
+
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_GetCounts( FT_Stroker  stroker,
+                        FT_UInt    *anum_points,
+                        FT_UInt    *anum_contours )
+  {
+    FT_UInt   count1, count2, num_points   = 0;
+    FT_UInt   count3, count4, num_contours = 0;
+    FT_Error  error;
+
+
+    error = ft_stroke_border_get_counts( stroker->borders + 0,
+                                         &count1, &count2 );
+    if ( error )
+      goto Exit;
+
+    error = ft_stroke_border_get_counts( stroker->borders + 1,
+                                         &count3, &count4 );
+    if ( error )
+      goto Exit;
+
+    num_points   = count1 + count3;
+    num_contours = count2 + count4;
+
+  Exit:
+    *anum_points   = num_points;
+    *anum_contours = num_contours;
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FT_Stroker_ExportBorder( FT_Stroker        stroker,
+                           FT_StrokerBorder  border,
+                           FT_Outline*       outline )
+  {
+    if ( border == FT_STROKER_BORDER_LEFT  ||
+         border == FT_STROKER_BORDER_RIGHT )
+    {
+      FT_StrokeBorder  sborder = & stroker->borders[border];
+
+
+      if ( sborder->valid )
+        ft_stroke_border_export( sborder, outline );
+    }
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FT_Stroker_Export( FT_Stroker   stroker,
+                     FT_Outline*  outline )
+  {
+    FT_Stroker_ExportBorder( stroker, FT_STROKER_BORDER_LEFT, outline );
+    FT_Stroker_ExportBorder( stroker, FT_STROKER_BORDER_RIGHT, outline );
+  }
+
+
+  /*
+   *  The following is very similar to FT_Outline_Decompose, except
+   *  that we do support opened paths, and do not scale the outline.
+   */
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stroker_ParseOutline( FT_Stroker   stroker,
+                           FT_Outline*  outline,
+                           FT_Bool      opened )
+  {
+    FT_Vector   v_last;
+    FT_Vector   v_control;
+    FT_Vector   v_start;
+
+    FT_Vector*  point;
+    FT_Vector*  limit;
+    char*       tags;
+
+    FT_Error    error;
+
+    FT_Int   n;         /* index of contour in outline     */
+    FT_UInt  first;     /* index of first point in contour */
+    FT_Int   tag;       /* current point's state           */
+
+
+    if ( !outline || !stroker )
+      return FT_Err_Invalid_Argument;
+
+    FT_Stroker_Rewind( stroker );
+
+    first = 0;
+
+    for ( n = 0; n < outline->n_contours; n++ )
+    {
+      FT_Int  last;  /* index of last point in contour */
+
+
+      last  = outline->contours[n];
+      limit = outline->points + last;
+
+      v_start = outline->points[first];
+      v_last  = outline->points[last];
+
+      v_control = v_start;
+
+      point = outline->points + first;
+      tags  = outline->tags  + first;
+      tag   = FT_CURVE_TAG( tags[0] );
+
+      /* A contour cannot start with a cubic control point! */
+      if ( tag == FT_CURVE_TAG_CUBIC )
+        goto Invalid_Outline;
+
+      /* check first point to determine origin */
+      if ( tag == FT_CURVE_TAG_CONIC )
+      {
+        /* First point is conic control.  Yes, this happens. */
+        if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON )
+        {
+          /* start at last point if it is on the curve */
+          v_start = v_last;
+          limit--;
+        }
+        else
+        {
+          /* if both first and last points are conic,         */
+          /* start at their middle and record its position    */
+          /* for closure                                      */
+          v_start.x = ( v_start.x + v_last.x ) / 2;
+          v_start.y = ( v_start.y + v_last.y ) / 2;
+
+          v_last = v_start;
+        }
+        point--;
+        tags--;
+      }
+
+      error = FT_Stroker_BeginSubPath( stroker, &v_start, opened );
+      if ( error )
+        goto Exit;
+
+      while ( point < limit )
+      {
+        point++;
+        tags++;
+
+        tag = FT_CURVE_TAG( tags[0] );
+        switch ( tag )
+        {
+        case FT_CURVE_TAG_ON:  /* emit a single line_to */
+          {
+            FT_Vector  vec;
+
+
+            vec.x = point->x;
+            vec.y = point->y;
+
+            error = FT_Stroker_LineTo( stroker, &vec );
+            if ( error )
+              goto Exit;
+            continue;
+          }
+
+        case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
+          v_control.x = point->x;
+          v_control.y = point->y;
+
+        Do_Conic:
+          if ( point < limit )
+          {
+            FT_Vector  vec;
+            FT_Vector  v_middle;
+
+
+            point++;
+            tags++;
+            tag = FT_CURVE_TAG( tags[0] );
+
+            vec = point[0];
+
+            if ( tag == FT_CURVE_TAG_ON )
+            {
+              error = FT_Stroker_ConicTo( stroker, &v_control, &vec );
+              if ( error )
+                goto Exit;
+              continue;
+            }
+
+            if ( tag != FT_CURVE_TAG_CONIC )
+              goto Invalid_Outline;
+
+            v_middle.x = ( v_control.x + vec.x ) / 2;
+            v_middle.y = ( v_control.y + vec.y ) / 2;
+
+            error = FT_Stroker_ConicTo( stroker, &v_control, &v_middle );
+            if ( error )
+              goto Exit;
+
+            v_control = vec;
+            goto Do_Conic;
+          }
+
+          error = FT_Stroker_ConicTo( stroker, &v_control, &v_start );
+          goto Close;
+
+        default:  /* FT_CURVE_TAG_CUBIC */
+          {
+            FT_Vector  vec1, vec2;
+
+
+            if ( point + 1 > limit                             ||
+                 FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
+              goto Invalid_Outline;
+
+            point += 2;
+            tags  += 2;
+
+            vec1 = point[-2];
+            vec2 = point[-1];
+
+            if ( point <= limit )
+            {
+              FT_Vector  vec;
+
+
+              vec = point[0];
+
+              error = FT_Stroker_CubicTo( stroker, &vec1, &vec2, &vec );
+              if ( error )
+                goto Exit;
+              continue;
+            }
+
+            error = FT_Stroker_CubicTo( stroker, &vec1, &vec2, &v_start );
+            goto Close;
+          }
+        }
+      }
+
+    Close:
+      if ( error )
+        goto Exit;
+
+      error = FT_Stroker_EndSubPath( stroker );
+      if ( error )
+        goto Exit;
+
+      first = last + 1;
+    }
+
+    return 0;
+
+  Exit:
+    return error;
+
+  Invalid_Outline:
+    return FT_Err_Invalid_Outline;
+  }
+
+
+  extern const FT_Glyph_Class  ft_outline_glyph_class;
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Glyph_Stroke( FT_Glyph    *pglyph,
+                   FT_Stroker   stroker,
+                   FT_Bool      destroy )
+  {
+    FT_Error  error = FT_Err_Invalid_Argument;
+    FT_Glyph  glyph = NULL;
+
+
+    if ( pglyph == NULL )
+      goto Exit;
+
+    glyph = *pglyph;
+    if ( glyph == NULL || glyph->clazz != &ft_outline_glyph_class )
+      goto Exit;
+
+    {
+      FT_Glyph  copy;
+
+
+      error = FT_Glyph_Copy( glyph, &copy );
+      if ( error )
+        goto Exit;
+
+      glyph = copy;
+    }
+
+    {
+      FT_OutlineGlyph  oglyph  = (FT_OutlineGlyph) glyph;
+      FT_Outline*      outline = &oglyph->outline;
+      FT_UInt          num_points, num_contours;
+
+
+      error = FT_Stroker_ParseOutline( stroker, outline, 0 );
+      if ( error )
+        goto Fail;
+
+      (void)FT_Stroker_GetCounts( stroker, &num_points, &num_contours );
+
+      FT_Outline_Done( glyph->library, outline );
+
+      error = FT_Outline_New( glyph->library,
+                              num_points, num_contours, outline );
+      if ( error )
+        goto Fail;
+
+      outline->n_points   = 0;
+      outline->n_contours = 0;
+
+      FT_Stroker_Export( stroker, outline );
+    }
+
+    if ( destroy )
+      FT_Done_Glyph( *pglyph );
+
+    *pglyph = glyph;
+    goto Exit;
+
+  Fail:
+    FT_Done_Glyph( glyph );
+    glyph = NULL;
+
+    if ( !destroy )
+      *pglyph = NULL;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Glyph_StrokeBorder( FT_Glyph    *pglyph,
+                         FT_Stroker   stroker,
+                         FT_Bool      inside,
+                         FT_Bool      destroy )
+  {
+    FT_Error  error = FT_Err_Invalid_Argument;
+    FT_Glyph  glyph = NULL;
+
+
+    if ( pglyph == NULL )
+      goto Exit;
+
+    glyph = *pglyph;
+    if ( glyph == NULL || glyph->clazz != &ft_outline_glyph_class )
+      goto Exit;
+
+    {
+      FT_Glyph  copy;
+
+
+      error = FT_Glyph_Copy( glyph, &copy );
+      if ( error )
+        goto Exit;
+
+      glyph = copy;
+    }
+
+    {
+      FT_OutlineGlyph   oglyph  = (FT_OutlineGlyph) glyph;
+      FT_StrokerBorder  border;
+      FT_Outline*       outline = &oglyph->outline;
+      FT_UInt           num_points, num_contours;
+
+
+      border = FT_Outline_GetOutsideBorder( outline );
+      if ( inside )
+      {
+        if ( border == FT_STROKER_BORDER_LEFT )
+          border = FT_STROKER_BORDER_RIGHT;
+        else
+          border = FT_STROKER_BORDER_LEFT;
+      }
+
+      error = FT_Stroker_ParseOutline( stroker, outline, 0 );
+      if ( error )
+        goto Fail;
+
+      (void)FT_Stroker_GetBorderCounts( stroker, border,
+                                        &num_points, &num_contours );
+
+      FT_Outline_Done( glyph->library, outline );
+
+      error = FT_Outline_New( glyph->library,
+                              num_points,
+                              num_contours,
+                              outline );
+      if ( error )
+        goto Fail;
+
+      outline->n_points   = 0;
+      outline->n_contours = 0;
+
+      FT_Stroker_ExportBorder( stroker, border, outline );
+    }
+
+    if ( destroy )
+      FT_Done_Glyph( *pglyph );
+
+    *pglyph = glyph;
+    goto Exit;
+
+  Fail:
+    FT_Done_Glyph( glyph );
+    glyph = NULL;
+
+    if ( !destroy )
+      *pglyph = NULL;
+
+  Exit:
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftsynth.c b/nx-X11/extras/freetype2/src/base/ftsynth.c
new file mode 100644
index 000000000..cee36822f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftsynth.c
@@ -0,0 +1,287 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsynth.c                                                              */
+/*                                                                         */
+/*    FreeType synthesizing code for emboldening and slanting (body).      */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003 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_OBJECTS_H
+#include FT_INTERNAL_CALC_H
+#include FT_OUTLINE_H
+#include FT_TRIGONOMETRY_H
+#include FT_SYNTHESIS_H
+
+
+#define FT_BOLD_THRESHOLD  0x0100
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****   EXPERIMENTAL OBLIQUING SUPPORT                                ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_EXPORT_DEF( void )
+  FT_GlyphSlot_Oblique( FT_GlyphSlot  slot )
+  {
+    FT_Matrix    transform;
+    FT_Outline*  outline = &slot->outline;
+
+
+    /* only oblique outline glyphs */
+    if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )
+      return;
+
+    /* we don't touch the advance width */
+
+    /* For italic, simply apply a shear transform, with an angle */
+    /* of about 12 degrees.                                      */
+
+    transform.xx = 0x10000L;
+    transform.yx = 0x00000L;
+
+    transform.xy = 0x06000L;
+    transform.yy = 0x10000L;
+
+    FT_Outline_Transform( outline, &transform );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****   EXPERIMENTAL EMBOLDENING/OUTLINING SUPPORT                    ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+
+  static int
+  ft_test_extrema( FT_Outline*  outline,
+                   int          n )
+  {
+    FT_Vector  *prev, *cur, *next;
+    FT_Pos      product;
+    FT_Int      c, first, last;
+
+
+    /* we need to compute the `previous' and `next' point */
+    /* for these extrema.                                 */
+    cur  = outline->points + n;
+    prev = cur - 1;
+    next = cur + 1;
+
+    first = 0;
+    for ( c = 0; c < outline->n_contours; c++ )
+    {
+      last = outline->contours[c];
+
+      if ( n == first )
+        prev = outline->points + last;
+
+      if ( n == last )
+        next = outline->points + first;
+
+      first = last + 1;
+    }
+
+    product = FT_MulDiv( cur->x - prev->x,   /* in.x  */
+                         next->y - cur->y,   /* out.y */
+                         0x40 )
+              -
+              FT_MulDiv( cur->y - prev->y,   /* in.y  */
+                         next->x - cur->x,   /* out.x */
+                         0x40 );
+
+    if ( product )
+      product = product > 0 ? 1 : -1;
+
+    return product;
+  }
+
+
+  /* Compute the orientation of path filling.  It differs between TrueType */
+  /* and Type1 formats.  We could use the `FT_OUTLINE_REVERSE_FILL' flag,  */
+  /* but it is better to re-compute it directly (it seems that this flag   */
+  /* isn't correctly set for some weird composite glyphs currently).       */
+  /*                                                                       */
+  /* We do this by computing bounding box points, and computing their      */
+  /* curvature.                                                            */
+  /*                                                                       */
+  /* The function returns either 1 or -1.                                  */
+  /*                                                                       */
+  static int
+  ft_get_orientation( FT_Outline*  outline )
+  {
+    FT_BBox  box;
+    FT_BBox  indices;
+    int      n, last;
+
+
+    indices.xMin = -1;
+    indices.yMin = -1;
+    indices.xMax = -1;
+    indices.yMax = -1;
+
+    box.xMin = box.yMin =  32767;
+    box.xMax = box.yMax = -32768;
+
+    /* is it empty ? */
+    if ( outline->n_contours < 1 )
+      return 1;
+
+    last = outline->contours[outline->n_contours - 1];
+
+    for ( n = 0; n <= last; n++ )
+    {
+      FT_Pos  x, y;
+
+
+      x = outline->points[n].x;
+      if ( x < box.xMin )
+      {
+        box.xMin     = x;
+        indices.xMin = n;
+      }
+      if ( x > box.xMax )
+      {
+        box.xMax     = x;
+        indices.xMax = n;
+      }
+
+      y = outline->points[n].y;
+      if ( y < box.yMin )
+      {
+        box.yMin     = y;
+        indices.yMin = n;
+      }
+      if ( y > box.yMax )
+      {
+        box.yMax     = y;
+        indices.yMax = n;
+      }
+    }
+
+    /* test orientation of the xmin */
+    n = ft_test_extrema( outline, indices.xMin );
+    if ( n )
+      goto Exit;
+
+    n = ft_test_extrema( outline, indices.yMin );
+    if ( n )
+      goto Exit;
+
+    n = ft_test_extrema( outline, indices.xMax );
+    if ( n )
+      goto Exit;
+
+    n = ft_test_extrema( outline, indices.yMax );
+    if ( !n )
+      n = 1;
+
+  Exit:
+    return n;
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FT_GlyphSlot_Embolden( FT_GlyphSlot  slot )
+  {
+    FT_Vector*   points;
+    FT_Vector    v_prev, v_first, v_next, v_cur;
+    FT_Pos       distance;
+    FT_Outline*  outline = &slot->outline;
+    FT_Face      face = FT_SLOT_FACE( slot );
+    FT_Angle     rotate, angle_in, angle_out;
+    FT_Int       c, n, first, orientation;
+
+
+    /* only embolden outline glyph images */
+    if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )
+      return;
+
+    /* compute control distance */
+    distance = FT_MulFix( face->units_per_EM / 60,
+                          face->size->metrics.y_scale );
+
+    orientation = ft_get_orientation( outline );
+    rotate      = FT_ANGLE_PI2*orientation;
+
+    points = outline->points;
+
+    first = 0;
+    for ( c = 0; c < outline->n_contours; c++ )
+    {
+      int  last = outline->contours[c];
+
+
+      v_first = points[first];
+      v_prev  = points[last];
+      v_cur   = v_first;
+
+      for ( n = first; n <= last; n++ )
+      {
+        FT_Pos     d;
+        FT_Vector  in, out;
+        FT_Fixed   scale;
+        FT_Angle   angle_diff;
+
+
+        if ( n < last ) v_next = points[n + 1];
+        else            v_next = v_first;
+
+        /* compute the in and out vectors */
+        in.x  = v_cur.x - v_prev.x;
+        in.y  = v_cur.y - v_prev.y;
+
+        out.x = v_next.x - v_cur.x;
+        out.y = v_next.y - v_cur.y;
+
+        angle_in   = FT_Atan2( in.x, in.y );
+        angle_out  = FT_Atan2( out.x, out.y );
+        angle_diff = FT_Angle_Diff( angle_in, angle_out );
+        scale      = FT_Cos( angle_diff/2 );
+
+        if ( scale < 0x400L && scale > -0x400L )
+        {
+          if ( scale >= 0 )
+            scale = 0x400L;
+          else
+            scale = -0x400L;
+        }
+
+        d = FT_DivFix( distance, scale );
+
+        FT_Vector_From_Polar( &in, d, angle_in + angle_diff/2 - rotate );
+
+        outline->points[n].x = v_cur.x + distance + in.x;
+        outline->points[n].y = v_cur.y + distance + in.y;
+
+        v_prev = v_cur;
+        v_cur  = v_next;
+      }
+
+      first = last + 1;
+    }
+
+    slot->metrics.horiAdvance =
+      ( slot->metrics.horiAdvance + distance*4 ) & ~63;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftsystem.c b/nx-X11/extras/freetype2/src/base/ftsystem.c
new file mode 100644
index 000000000..2365de257
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftsystem.c
@@ -0,0 +1,303 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsystem.c                                                             */
+/*                                                                         */
+/*    ANSI-specific FreeType low-level system interface (body).            */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 contains the default interface used by FreeType to access   */
+  /* low-level, i.e. memory management, i/o access as well as thread       */
+  /* synchronisation.  It can be replaced by user-specific routines if     */
+  /* necessary.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_SYSTEM_H
+#include FT_ERRORS_H
+#include FT_TYPES_H
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                       MEMORY MANAGEMENT INTERFACE                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* It is not necessary to do any error checking for the                  */
+  /* allocation-related functions.  This will be done by the higher level  */
+  /* routines like FT_Alloc() or FT_Realloc().                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_alloc                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The memory allocation function.                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory :: A pointer to the memory object.                          */
+  /*                                                                       */
+  /*    size   :: The requested size in bytes.                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The address of newly allocated block.                              */
+  /*                                                                       */
+  FT_CALLBACK_DEF( void* )
+  ft_alloc( FT_Memory  memory,
+            long       size )
+  {
+    FT_UNUSED( memory );
+
+    return malloc( size );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_realloc                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The memory reallocation function.                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory   :: A pointer to the memory object.                        */
+  /*                                                                       */
+  /*    cur_size :: The current size of the allocated memory block.        */
+  /*                                                                       */
+  /*    new_size :: The newly requested size in bytes.                     */
+  /*                                                                       */
+  /*    block    :: The current address of the block in memory.            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The address of the reallocated memory block.                       */
+  /*                                                                       */
+  FT_CALLBACK_DEF( void* )
+  ft_realloc( FT_Memory  memory,
+              long       cur_size,
+              long       new_size,
+              void*      block )
+  {
+    FT_UNUSED( memory );
+    FT_UNUSED( cur_size );
+
+    return realloc( block, new_size );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_free                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The memory release function.                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory  :: A pointer to the memory object.                         */
+  /*                                                                       */
+  /*    block   :: The address of block in memory to be freed.             */
+  /*                                                                       */
+  FT_CALLBACK_DEF( void )
+  ft_free( FT_Memory  memory,
+           void*      block )
+  {
+    FT_UNUSED( memory );
+
+    free( block );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                     RESOURCE MANAGEMENT INTERFACE                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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_io
+
+  /* We use the macro STREAM_FILE for convenience to extract the       */
+  /* system-specific stream handle from a given FreeType stream object */
+#define STREAM_FILE( stream )  ( (FILE*)stream->descriptor.pointer )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_ansi_stream_close                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The function to close a stream.                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream :: A pointer to the stream object.                          */
+  /*                                                                       */
+  FT_CALLBACK_DEF( void )
+  ft_ansi_stream_close( FT_Stream  stream )
+  {
+    fclose( STREAM_FILE( stream ) );
+
+    stream->descriptor.pointer = NULL;
+    stream->size               = 0;
+    stream->base               = 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_ansi_stream_io                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The function to open a stream.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream :: A pointer to the stream object.                          */
+  /*                                                                       */
+  /*    offset :: The position in the data stream to start reading.        */
+  /*                                                                       */
+  /*    buffer :: The address of buffer to store the read data.            */
+  /*                                                                       */
+  /*    count  :: The number of bytes to read from the stream.             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The number of bytes actually read.                                 */
+  /*                                                                       */
+  FT_CALLBACK_DEF( unsigned long )
+  ft_ansi_stream_io( FT_Stream       stream,
+                     unsigned long   offset,
+                     unsigned char*  buffer,
+                     unsigned long   count )
+  {
+    FILE*  file;
+
+
+    file = STREAM_FILE( stream );
+
+    fseek( file, offset, SEEK_SET );
+
+    return (unsigned long)fread( buffer, 1, count, file );
+  }
+
+
+  /* documentation is in ftobjs.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stream_Open( FT_Stream    stream,
+                  const char*  filepathname )
+  {
+    FILE*  file;
+
+
+    if ( !stream )
+      return FT_Err_Invalid_Stream_Handle;
+
+    file = fopen( filepathname, "rb" );
+    if ( !file )
+    {
+      FT_ERROR(( "FT_Stream_Open:" ));
+      FT_ERROR(( " could not open `%s'\n", filepathname ));
+
+      return FT_Err_Cannot_Open_Resource;
+    }
+
+    fseek( file, 0, SEEK_END );
+    stream->size = ftell( file );
+    fseek( file, 0, SEEK_SET );
+
+    stream->descriptor.pointer = file;
+    stream->pathname.pointer   = (char*)filepathname;
+    stream->pos                = 0;
+
+    stream->read  = ft_ansi_stream_io;
+    stream->close = ft_ansi_stream_close;
+
+    FT_TRACE1(( "FT_Stream_Open:" ));
+    FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
+                filepathname, stream->size ));
+
+    return FT_Err_Ok;
+  }
+
+
+#ifdef FT_DEBUG_MEMORY
+
+  extern FT_Int
+  ft_mem_debug_init( FT_Memory  memory );
+
+  extern void
+  ft_mem_debug_done( FT_Memory  memory );
+
+#endif
+
+
+  /* documentation is in ftobjs.h */
+
+  FT_EXPORT_DEF( FT_Memory )
+  FT_New_Memory( void )
+  {
+    FT_Memory  memory;
+
+
+    memory = (FT_Memory)malloc( sizeof ( *memory ) );
+    if ( memory )
+    {
+      memory->user    = 0;
+      memory->alloc   = ft_alloc;
+      memory->realloc = ft_realloc;
+      memory->free    = ft_free;
+#ifdef FT_DEBUG_MEMORY
+      ft_mem_debug_init( memory );
+#endif
+    }
+
+    return memory;
+  }
+
+
+  /* documentation is in ftobjs.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Done_Memory( FT_Memory  memory )
+  {
+#ifdef FT_DEBUG_MEMORY
+    ft_mem_debug_done( memory );
+#endif
+    memory->free( memory, memory );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/fttrigon.c b/nx-X11/extras/freetype2/src/base/fttrigon.c
new file mode 100644
index 000000000..5347dd852
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/fttrigon.c
@@ -0,0 +1,499 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttrigon.c                                                             */
+/*                                                                         */
+/*    FreeType trigonometric functions (body).                             */
+/*                                                                         */
+/*  Copyright 2001, 2002, 2003 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_OBJECTS_H
+#include FT_TRIGONOMETRY_H
+
+
+  /* the following is 0.2715717684432231 * 2^30 */
+#define FT_TRIG_COSCALE  0x11616E8EUL
+
+  /* this table was generated for FT_PI = 180L << 16, i.e. degrees */
+#define FT_TRIG_MAX_ITERS  23
+
+  static const FT_Fixed
+  ft_trig_arctan_table[24] =
+  {
+    4157273L, 2949120L, 1740967L, 919879L, 466945L, 234379L, 117304L,
+    58666L, 29335L, 14668L, 7334L, 3667L, 1833L, 917L, 458L, 229L, 115L,
+    57L, 29L, 14L, 7L, 4L, 2L, 1L
+  };
+
+  /* the Cordic shrink factor, multiplied by 2^32 */
+#define FT_TRIG_SCALE    1166391785UL  /* 0x4585BA38UL */
+
+
+#ifdef FT_CONFIG_HAS_INT64
+
+  /* multiply a given value by the CORDIC shrink factor */
+  static FT_Fixed
+  ft_trig_downscale( FT_Fixed  val )
+  {
+    FT_Fixed  s;
+    FT_Int64  v;
+
+
+    s   = val;
+    val = ( val >= 0 ) ? val : -val;
+
+    v   = ( val * (FT_Int64)FT_TRIG_SCALE ) + 0x100000000UL;
+    val = (FT_Fixed)( v >> 32 );
+
+    return ( s >= 0 ) ? val : -val;
+  }
+
+#else /* !FT_CONFIG_HAS_INT64 */
+
+  /* multiply a given value by the CORDIC shrink factor */
+  static FT_Fixed
+  ft_trig_downscale( FT_Fixed  val )
+  {
+    FT_Fixed   s;
+    FT_UInt32  v1, v2, k1, k2, hi, lo1, lo2, lo3;
+
+
+    s   = val;
+    val = ( val >= 0 ) ? val : -val;
+
+    v1 = (FT_UInt32)val >> 16;
+    v2 = (FT_UInt32)val & 0xFFFFL;
+
+    k1 = FT_TRIG_SCALE >> 16;       /* constant */
+    k2 = FT_TRIG_SCALE & 0xFFFFL;   /* constant */
+
+    hi   = k1 * v1;
+    lo1  = k1 * v2 + k2 * v1;       /* can't overflow */
+
+    lo2  = ( k2 * v2 ) >> 16;
+    lo3  = ( lo1 >= lo2 ) ? lo1 : lo2;
+    lo1 += lo2;
+
+    hi  += lo1 >> 16;
+    if ( lo1 < lo3 )
+      hi += 0x10000UL;
+
+    val  = (FT_Fixed)hi;
+
+    return ( s >= 0 ) ? val : -val;
+  }
+
+#endif /* !FT_CONFIG_HAS_INT64 */
+
+
+  static FT_Int
+  ft_trig_prenorm( FT_Vector*  vec )
+  {
+    FT_Fixed  x, y, z;
+    FT_Int    shift;
+
+
+    x = vec->x;
+    y = vec->y;
+
+    z     = ( ( x >= 0 ) ? x : - x ) | ( (y >= 0) ? y : -y );
+    shift = 0;
+
+    if ( z < ( 1L << 27 ) )
+    {
+      do
+      {
+        shift++;
+        z <<= 1;
+      } while ( z < ( 1L << 27 ) );
+
+      vec->x = x << shift;
+      vec->y = y << shift;
+    }
+    else if ( z > ( 1L << 28 ) )
+    {
+      do
+      {
+        shift++;
+        z >>= 1;
+      } while ( z > ( 1L << 28 ) );
+
+      vec->x = x >> shift;
+      vec->y = y >> shift;
+      shift  = -shift;
+    }
+    return shift;
+  }
+
+
+  static void
+  ft_trig_pseudo_rotate( FT_Vector*  vec,
+                         FT_Angle    theta )
+  {
+    FT_Int           i;
+    FT_Fixed         x, y, xtemp;
+    const FT_Fixed  *arctanptr;
+
+
+    x = vec->x;
+    y = vec->y;
+
+    /* Get angle between -90 and 90 degrees */
+    while ( theta <= -FT_ANGLE_PI2 )
+    {
+      x = -x;
+      y = -y;
+      theta += FT_ANGLE_PI;
+    }
+
+    while ( theta > FT_ANGLE_PI2 )
+    {
+      x = -x;
+      y = -y;
+      theta -= FT_ANGLE_PI;
+    }
+
+    /* Initial pseudorotation, with left shift */
+    arctanptr = ft_trig_arctan_table;
+
+    if ( theta < 0 )
+    {
+      xtemp  = x + ( y << 1 );
+      y      = y - ( x << 1 );
+      x      = xtemp;
+      theta += *arctanptr++;
+    }
+    else
+    {
+      xtemp  = x - ( y << 1 );
+      y      = y + ( x << 1 );
+      x      = xtemp;
+      theta -= *arctanptr++;
+    }
+
+    /* Subsequent pseudorotations, with right shifts */
+    i = 0;
+    do
+    {
+      if ( theta < 0 )
+      {
+        xtemp  = x + ( y >> i );
+        y      = y - ( x >> i );
+        x      = xtemp;
+        theta += *arctanptr++;
+      }
+      else
+      {
+        xtemp  = x - ( y >> i );
+        y      = y + ( x >> i );
+        x      = xtemp;
+        theta -= *arctanptr++;
+      }
+    } while ( ++i < FT_TRIG_MAX_ITERS );
+
+    vec->x = x;
+    vec->y = y;
+  }
+
+
+  static void
+  ft_trig_pseudo_polarize( FT_Vector*  vec )
+  {
+    FT_Fixed         theta;
+    FT_Fixed         yi, i;
+    FT_Fixed         x, y;
+    const FT_Fixed  *arctanptr;
+
+
+    x = vec->x;
+    y = vec->y;
+
+    /* Get the vector into the right half plane */
+    theta = 0;
+    if ( x < 0 )
+    {
+      x = -x;
+      y = -y;
+      theta = 2 * FT_ANGLE_PI2;
+    }
+
+    if ( y > 0 )
+      theta = - theta;
+
+    arctanptr = ft_trig_arctan_table;
+
+    if ( y < 0 )
+    {
+      /* Rotate positive */
+      yi     = y + ( x << 1 );
+      x      = x - ( y << 1 );
+      y      = yi;
+      theta -= *arctanptr++;  /* Subtract angle */
+    }
+    else
+    {
+      /* Rotate negative */
+      yi     = y - ( x << 1 );
+      x      = x + ( y << 1 );
+      y      = yi;
+      theta += *arctanptr++;  /* Add angle */
+    }
+
+    i = 0;
+    do
+    {
+      if ( y < 0 )
+      {
+        /* Rotate positive */
+        yi     = y + ( x >> i );
+        x      = x - ( y >> i );
+        y      = yi;
+        theta -= *arctanptr++;
+      }
+      else
+      {
+        /* Rotate negative */
+        yi     = y - ( x >> i );
+        x      = x + ( y >> i );
+        y      = yi;
+        theta += *arctanptr++;
+      }
+    } while ( ++i < FT_TRIG_MAX_ITERS );
+
+    /* round theta */
+    if ( theta >= 0 )
+      theta = FT_PAD_ROUND( theta, 32 );
+    else
+      theta = - FT_PAD_ROUND( -theta, 32 );
+
+    vec->x = x;
+    vec->y = theta;
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( FT_Fixed )
+  FT_Cos( FT_Angle  angle )
+  {
+    FT_Vector  v;
+
+
+    v.x = FT_TRIG_COSCALE >> 2;
+    v.y = 0;
+    ft_trig_pseudo_rotate( &v, angle );
+
+    return v.x / ( 1 << 12 );
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( FT_Fixed )
+  FT_Sin( FT_Angle  angle )
+  {
+    return FT_Cos( FT_ANGLE_PI2 - angle );
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( FT_Fixed )
+  FT_Tan( FT_Angle  angle )
+  {
+    FT_Vector  v;
+
+
+    v.x = FT_TRIG_COSCALE >> 2;
+    v.y = 0;
+    ft_trig_pseudo_rotate( &v, angle );
+
+    return FT_DivFix( v.y, v.x );
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( FT_Angle )
+  FT_Atan2( FT_Fixed  dx,
+            FT_Fixed  dy )
+  {
+    FT_Vector  v;
+
+
+    if ( dx == 0 && dy == 0 )
+      return 0;
+
+    v.x = dx;
+    v.y = dy;
+    ft_trig_prenorm( &v );
+    ft_trig_pseudo_polarize( &v );
+
+    return v.y;
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Vector_Unit( FT_Vector*  vec,
+                  FT_Angle    angle )
+  {
+    vec->x = FT_TRIG_COSCALE >> 2;
+    vec->y = 0;
+    ft_trig_pseudo_rotate( vec, angle );
+    vec->x >>= 12;
+    vec->y >>= 12;
+  }
+
+
+  /* these macros return 0 for positive numbers,
+     and -1 for negative ones */
+#define FT_SIGN_LONG( x )   ( (x) >> ( FT_SIZEOF_LONG * 8 - 1 ) )
+#define FT_SIGN_INT( x )    ( (x) >> ( FT_SIZEOF_INT * 8 - 1 ) )
+#define FT_SIGN_INT32( x )  ( (x) >> 31 )
+#define FT_SIGN_INT16( x )  ( (x) >> 15 )
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Vector_Rotate( FT_Vector*  vec,
+                    FT_Angle    angle )
+  {
+    FT_Int     shift;
+    FT_Vector  v;
+
+
+    v.x   = vec->x;
+    v.y   = vec->y;
+
+    if ( angle && ( v.x != 0 || v.y != 0 ) )
+    {
+      shift = ft_trig_prenorm( &v );
+      ft_trig_pseudo_rotate( &v, angle );
+      v.x = ft_trig_downscale( v.x );
+      v.y = ft_trig_downscale( v.y );
+
+      if ( shift > 0 )
+      {
+        FT_Int32  half = 1L << ( shift - 1 );
+
+
+        vec->x = ( v.x + half + FT_SIGN_LONG( v.x ) ) >> shift;
+        vec->y = ( v.y + half + FT_SIGN_LONG( v.y ) ) >> shift;
+      }
+      else
+      {
+        shift  = -shift;
+        vec->x = v.x << shift;
+        vec->y = v.y << shift;
+      }
+    }
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( FT_Fixed )
+  FT_Vector_Length( FT_Vector*  vec )
+  {
+    FT_Int     shift;
+    FT_Vector  v;
+
+
+    v = *vec;
+
+    /* handle trivial cases */
+    if ( v.x == 0 )
+    {
+      return ( v.y >= 0 ) ? v.y : -v.y;
+    }
+    else if ( v.y == 0 )
+    {
+      return ( v.x >= 0 ) ? v.x : -v.x;
+    }
+
+    /* general case */
+    shift = ft_trig_prenorm( &v );
+    ft_trig_pseudo_polarize( &v );
+
+    v.x = ft_trig_downscale( v.x );
+
+    if ( shift > 0 )
+      return ( v.x + ( 1 << ( shift - 1 ) ) ) >> shift;
+
+    return v.x << -shift;
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Vector_Polarize( FT_Vector*  vec,
+                      FT_Fixed   *length,
+                      FT_Angle   *angle )
+  {
+    FT_Int     shift;
+    FT_Vector  v;
+
+
+    v = *vec;
+
+    if ( v.x == 0 && v.y == 0 )
+      return;
+
+    shift = ft_trig_prenorm( &v );
+    ft_trig_pseudo_polarize( &v );
+
+    v.x = ft_trig_downscale( v.x );
+
+    *length = ( shift >= 0 ) ? ( v.x >> shift ) : ( v.x << -shift );
+    *angle  = v.y;
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Vector_From_Polar( FT_Vector*  vec,
+                        FT_Fixed    length,
+                        FT_Angle    angle )
+  {
+    vec->x = length;
+    vec->y = 0;
+
+    FT_Vector_Rotate( vec, angle );
+  }
+
+
+  /* documentation is in fttrigon.h */
+
+  FT_EXPORT_DEF( FT_Angle )
+  FT_Angle_Diff( FT_Angle  angle1,
+                 FT_Angle  angle2 )
+  {
+    FT_Angle  delta = angle2 - angle1;
+
+    delta %= FT_ANGLE_2PI;
+    if ( delta < 0 )
+      delta += FT_ANGLE_2PI;
+
+    if ( delta > FT_ANGLE_PI )
+      delta -= FT_ANGLE_2PI;
+
+    return delta;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/fttype1.c b/nx-X11/extras/freetype2/src/base/fttype1.c
new file mode 100644
index 000000000..553b84f56
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/fttype1.c
@@ -0,0 +1,70 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttype1.c                                                              */
+/*                                                                         */
+/*    FreeType utility file for PS names support (body).                   */
+/*                                                                         */
+/*  Copyright 2002, 2003 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_OBJECTS_H
+#include FT_INTERNAL_SERVICE_H
+#include FT_SERVICE_POSTSCRIPT_INFO_H
+
+
+  /* documentation is in t1tables.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_PS_Font_Info( FT_Face          face,
+                       PS_FontInfoRec*  afont_info )
+  {
+    FT_Error  error = FT_Err_Invalid_Argument;
+
+
+    if ( face )
+    {
+      FT_Service_PsInfo  service = NULL;
+
+
+      FT_FACE_FIND_SERVICE( face, service, POSTSCRIPT_INFO );
+
+      if ( service && service->ps_get_font_info )
+        error = service->ps_get_font_info( face, afont_info );
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in t1tables.h */
+
+  FT_EXPORT_DEF( FT_Int )
+  FT_Has_PS_Glyph_Names( FT_Face  face )
+  {
+    FT_Int             result  = 0;
+    FT_Service_PsInfo  service = NULL;
+
+
+    if ( face )
+    {
+      FT_FACE_FIND_SERVICE( face, service, POSTSCRIPT_INFO );
+
+      if ( service && service->ps_has_glyph_names )
+        result = service->ps_has_glyph_names( face );
+    }
+
+    return result;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftutil.c b/nx-X11/extras/freetype2/src/base/ftutil.c
new file mode 100644
index 000000000..9d3ec43d7
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftutil.c
@@ -0,0 +1,397 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftutil.c                                                               */
+/*                                                                         */
+/*    FreeType utility file for memory and list management (body).         */
+/*                                                                         */
+/*  Copyright 2002, 2004 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_MEMORY_H
+#include FT_LIST_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_memory
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*****               M E M O R Y   M A N A G E M E N T               *****/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* documentation is in ftmemory.h */
+
+  FT_BASE_DEF( FT_Error )
+  FT_Alloc( FT_Memory  memory,
+            FT_Long    size,
+            void*     *P )
+  {
+    FT_ASSERT( P != 0 );
+
+    if ( size > 0 )
+    {
+      *P = memory->alloc( memory, size );
+      if ( !*P )
+      {
+        FT_ERROR(( "FT_Alloc:" ));
+        FT_ERROR(( " Out of memory? (%ld requested)\n",
+                   size ));
+
+        return FT_Err_Out_Of_Memory;
+      }
+      FT_MEM_ZERO( *P, size );
+    }
+    else
+      *P = NULL;
+
+    FT_TRACE7(( "FT_Alloc:" ));
+    FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
+                size, *P, P ));
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_QAlloc( FT_Memory  memory,
+             FT_Long    size,
+             void*     *P )
+  {
+    FT_ASSERT( P != 0 );
+
+    if ( size > 0 )
+    {
+      *P = memory->alloc( memory, size );
+      if ( !*P )
+      {
+        FT_ERROR(( "FT_QAlloc:" ));
+        FT_ERROR(( " Out of memory? (%ld requested)\n",
+                   size ));
+
+        return FT_Err_Out_Of_Memory;
+      }
+    }
+    else
+      *P = NULL;
+
+    FT_TRACE7(( "FT_QAlloc:" ));
+    FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
+                size, *P, P ));
+
+    return FT_Err_Ok;
+  }
+
+
+  /* documentation is in ftmemory.h */
+
+  FT_BASE_DEF( FT_Error )
+  FT_Realloc( FT_Memory  memory,
+              FT_Long    current,
+              FT_Long    size,
+              void**     P )
+  {
+    void*  Q;
+
+
+    FT_ASSERT( P != 0 );
+
+    /* if the original pointer is NULL, call FT_Alloc() */
+    if ( !*P )
+      return FT_Alloc( memory, size, P );
+
+    /* if the new block if zero-sized, clear the current one */
+    if ( size <= 0 )
+    {
+      FT_Free( memory, P );
+      return FT_Err_Ok;
+    }
+
+    Q = memory->realloc( memory, current, size, *P );
+    if ( !Q )
+      goto Fail;
+
+    if ( size > current )
+      FT_MEM_ZERO( (char*)Q + current, size - current );
+
+    *P = Q;
+    return FT_Err_Ok;
+
+  Fail:
+    FT_ERROR(( "FT_Realloc:" ));
+    FT_ERROR(( " Failed (current %ld, requested %ld)\n",
+               current, size ));
+    return FT_Err_Out_Of_Memory;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_QRealloc( FT_Memory  memory,
+               FT_Long    current,
+               FT_Long    size,
+               void**     P )
+  {
+    void*  Q;
+
+
+    FT_ASSERT( P != 0 );
+
+    /* if the original pointer is NULL, call FT_QAlloc() */
+    if ( !*P )
+      return FT_QAlloc( memory, size, P );
+
+    /* if the new block if zero-sized, clear the current one */
+    if ( size <= 0 )
+    {
+      FT_Free( memory, P );
+      return FT_Err_Ok;
+    }
+
+    Q = memory->realloc( memory, current, size, *P );
+    if ( !Q )
+      goto Fail;
+
+    *P = Q;
+    return FT_Err_Ok;
+
+  Fail:
+    FT_ERROR(( "FT_QRealloc:" ));
+    FT_ERROR(( " Failed (current %ld, requested %ld)\n",
+               current, size ));
+    return FT_Err_Out_Of_Memory;
+  }
+
+
+  /* documentation is in ftmemory.h */
+
+  FT_BASE_DEF( void )
+  FT_Free( FT_Memory  memory,
+           void**     P )
+  {
+    FT_TRACE7(( "FT_Free:" ));
+    FT_TRACE7(( " Freeing block 0x%08p, ref 0x%08p\n",
+                P, P ? *P : (void*)0 ));
+
+    if ( P && *P )
+    {
+      memory->free( memory, *P );
+      *P = 0;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*****            D O U B L Y   L I N K E D   L I S T S              *****/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_list
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( FT_ListNode )
+  FT_List_Find( FT_List  list,
+                void*    data )
+  {
+    FT_ListNode  cur;
+
+
+    cur = list->head;
+    while ( cur )
+    {
+      if ( cur->data == data )
+        return cur;
+
+      cur = cur->next;
+    }
+
+    return (FT_ListNode)0;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Add( FT_List      list,
+               FT_ListNode  node )
+  {
+    FT_ListNode  before = list->tail;
+
+
+    node->next = 0;
+    node->prev = before;
+
+    if ( before )
+      before->next = node;
+    else
+      list->head = node;
+
+    list->tail = node;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Insert( FT_List      list,
+                  FT_ListNode  node )
+  {
+    FT_ListNode  after = list->head;
+
+
+    node->next = after;
+    node->prev = 0;
+
+    if ( !after )
+      list->tail = node;
+    else
+      after->prev = node;
+
+    list->head = node;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Remove( FT_List      list,
+                  FT_ListNode  node )
+  {
+    FT_ListNode  before, after;
+
+
+    before = node->prev;
+    after  = node->next;
+
+    if ( before )
+      before->next = after;
+    else
+      list->head = after;
+
+    if ( after )
+      after->prev = before;
+    else
+      list->tail = before;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Up( FT_List      list,
+              FT_ListNode  node )
+  {
+    FT_ListNode  before, after;
+
+
+    before = node->prev;
+    after  = node->next;
+
+    /* check whether we are already on top of the list */
+    if ( !before )
+      return;
+
+    before->next = after;
+
+    if ( after )
+      after->prev = before;
+    else
+      list->tail = before;
+
+    node->prev       = 0;
+    node->next       = list->head;
+    list->head->prev = node;
+    list->head       = node;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_List_Iterate( FT_List            list,
+                   FT_List_Iterator   iterator,
+                   void*              user )
+  {
+    FT_ListNode  cur   = list->head;
+    FT_Error     error = FT_Err_Ok;
+
+
+    while ( cur )
+    {
+      FT_ListNode  next = cur->next;
+
+
+      error = iterator( cur, user );
+      if ( error )
+        break;
+
+      cur = next;
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Finalize( FT_List             list,
+                    FT_List_Destructor  destroy,
+                    FT_Memory           memory,
+                    void*               user )
+  {
+    FT_ListNode  cur;
+
+
+    cur = list->head;
+    while ( cur )
+    {
+      FT_ListNode  next = cur->next;
+      void*        data = cur->data;
+
+
+      if ( destroy )
+        destroy( memory, data, user );
+
+      FT_FREE( cur );
+      cur = next;
+    }
+
+    list->head = 0;
+    list->tail = 0;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftwinfnt.c b/nx-X11/extras/freetype2/src/base/ftwinfnt.c
new file mode 100644
index 000000000..46f618c51
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftwinfnt.c
@@ -0,0 +1,49 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftwinfnt.c                                                             */
+/*                                                                         */
+/*    FreeType API for accessing Windows FNT specific info (body).         */
+/*                                                                         */
+/*  Copyright 2003 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_WINFONTS_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_SERVICE_WINFNT_H
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_WinFNT_Header( FT_Face               face,
+                        FT_WinFNT_HeaderRec  *header )
+  {
+    FT_Service_WinFnt  service;
+    FT_Error           error;
+
+
+    error = FT_Err_Invalid_Argument;
+
+    if ( face != NULL )
+    {
+      FT_FACE_LOOKUP_SERVICE( face, service, WINFNT );
+
+      if ( service != NULL )
+      {
+        error = service->get_header( face, header );
+      }
+    }
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/ftxf86.c b/nx-X11/extras/freetype2/src/base/ftxf86.c
new file mode 100644
index 000000000..04e80236e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/ftxf86.c
@@ -0,0 +1,37 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftxf86.c                                                               */
+/*                                                                         */
+/*    FreeType utility file for X11 support (body).                        */
+/*                                                                         */
+/*  Copyright 2002, 2003 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_XFREE86_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_SERVICE_XFREE86_NAME_H
+
+  FT_EXPORT_DEF( const char* )
+  FT_Get_X11_Font_Format( FT_Face  face )
+  {
+    const char*  result = NULL;
+
+
+    if ( face )
+      FT_FACE_FIND_SERVICE( face, result, XF86_NAME );
+
+    return result;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/base/rules.mk b/nx-X11/extras/freetype2/src/base/rules.mk
new file mode 100644
index 000000000..8017e8589
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/base/rules.mk
@@ -0,0 +1,96 @@
+#
+# FreeType 2 base layer configuration rules
+#
+
+
+# Copyright 1996-2000, 2002, 2003, 2004 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.
+
+
+# It sets the following variables which are used by the master Makefile
+# after the call:
+#
+#   BASE_OBJ_S:   The single-object base layer.
+#   BASE_OBJ_M:   A list of all objects for a multiple-objects build.
+#   BASE_EXT_OBJ: A list of base layer extensions, i.e., components found
+#                 in `freetype/src/base' which are not compiled within the
+#                 base layer proper.
+#
+# BASE_H is defined in freetype.mk to simplify the dependency rules.
+
+
+BASE_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(SRC_DIR)/base)
+
+
+# Base layer sources
+#
+#   ftsystem, ftinit, and ftdebug are handled by freetype.mk
+#
+BASE_SRC := $(BASE_DIR)/ftapi.c    \
+            $(BASE_DIR)/ftcalc.c   \
+            $(BASE_DIR)/ftdbgmem.c \
+            $(BASE_DIR)/ftgloadr.c \
+            $(BASE_DIR)/ftnames.c  \
+            $(BASE_DIR)/ftobjs.c   \
+            $(BASE_DIR)/ftoutln.c  \
+            $(BASE_DIR)/ftrfork.c  \
+            $(BASE_DIR)/ftstream.c \
+            $(BASE_DIR)/fttrigon.c \
+            $(BASE_DIR)/ftutil.c
+
+# Base layer `extensions' sources
+#
+# An extension is added to the library file (.a or .lib) as a separate
+# object.  It will then be linked to the final executable only if one of its
+# symbols is used by the application.
+#
+BASE_EXT_SRC := $(BASE_DIR)/ftbbox.c   \
+                $(BASE_DIR)/ftbdf.c    \
+                $(BASE_DIR)/ftglyph.c  \
+                $(BASE_DIR)/ftmm.c     \
+                $(BASE_DIR)/ftpfr.c    \
+                $(BASE_DIR)/ftstroke.c \
+                $(BASE_DIR)/fttype1.c  \
+                $(BASE_DIR)/ftwinfnt.c \
+                $(BASE_DIR)/ftxf86.c
+
+# Default extensions objects
+#
+BASE_EXT_OBJ := $(BASE_EXT_SRC:$(BASE_DIR)/%.c=$(OBJ_DIR)/%.$O)
+
+
+# Base layer object(s)
+#
+#   BASE_OBJ_M is used during `multi' builds (each base source file compiles
+#   to a single object file).
+#
+#   BASE_OBJ_S is used during `single' builds (the whole base layer is
+#   compiled as a single object file using ftbase.c).
+#
+BASE_OBJ_M := $(BASE_SRC:$(BASE_DIR)/%.c=$(OBJ_DIR)/%.$O)
+BASE_OBJ_S := $(OBJ_DIR)/ftbase.$O
+
+# Base layer root source file for single build
+#
+BASE_SRC_S := $(BASE_DIR)/ftbase.c
+
+
+# Base layer - single object build
+#
+$(BASE_OBJ_S): $(BASE_SRC_S) $(BASE_SRC) $(FREETYPE_H)
+	$(BASE_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(BASE_SRC_S))
+
+
+# Multiple objects build + extensions
+#
+$(OBJ_DIR)/%.$O: $(BASE_DIR)/%.c $(FREETYPE_H)
+	$(BASE_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/bdf/Jamfile b/nx-X11/extras/freetype2/src/bdf/Jamfile
new file mode 100644
index 000000000..8b1714d98
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/bdf Jamfile (c) 2002 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) bdf ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = bdfdrivr bdflib ;
+  }
+  else
+  {
+    _sources = bdf ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/bdf Jamfile
diff --git a/nx-X11/extras/freetype2/src/bdf/README b/nx-X11/extras/freetype2/src/bdf/README
new file mode 100644
index 000000000..d45e4fb15
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/README
@@ -0,0 +1,148 @@
+                  FreeType font driver for BDF fonts
+
+                       Francesco Zappa Nardelli
+                  <francesco.zappa.nardelli@ens.fr>
+
+
+Introduction
+************
+
+BDF (Bitmap Distribution Format) is a bitmap font format defined by Adobe,
+which is intended to be easily understood by both humans and computers. 
+This code implements a BDF driver for the FreeType library, following the
+Adobe Specification V 2.2.  The specification of the BDF font format is
+available from Adobe's web site:
+
+  http://partners.adobe.com/asn/developer/PDFS/TN/5005.BDF_Spec.pdf
+
+Many good bitmap fonts in bdf format come with XFree86 (www.XFree86.org). 
+They do not define vertical metrics, because the X Consortium BDF
+specification has removed them.
+
+
+Encodings
+*********
+
+The variety of encodings that accompanies bdf fonts appears to encompass the
+small set defined in freetype.h.  On the other hand, two properties that
+specify encoding and registry are usually defined in bdf fonts.
+
+I decided to make these two properties directly accessible, leaving to the
+client application the work of interpreting them.  For instance:
+
+
+  #include FT_INTERNAL_BDF_TYPES_H
+
+  FT_Face          face;
+  BDF_Public_Face  bdfface;
+
+
+  FT_New_Face( library, ..., &face );
+
+  bdfface = (BDF_Public_Face)face;
+  
+  if ( ( bdfface->charset_registry == "ISO10646" ) && 
+       ( bdfface->charset_encoding == "1" )        )
+    [..]
+
+
+Thus the driver always exports `ft_encoding_none' as face->charmap.encoding. 
+FT_Get_Char_Index's behavior is unmodified, that is, it converts the ULong
+value given as argument into the corresponding glyph number.
+
+If the two properties are not available, Adobe Standard Encoding should be
+assumed.
+
+
+Anti-Aliased Bitmaps
+********************
+
+The driver supports an extension to the BDF format as used in Mark Leisher's
+xmbdfed bitmap font editor.  Microsoft's SBIT tool expects bitmap fonts in
+that format for adding anti-aliased them to TrueType fonts.  It introduces a
+fourth field to the `SIZE' keyword which gives the bpp value (bits per
+pixel) of the glyph data in the font.  Possible values are 1 (the default),
+2 (four gray levels), 4 (16 gray levels), and 8 (256 gray levels).  The
+driver returns either a bitmap with 1 bit per pixel or a pixmap with 8bits
+per pixel (using 4, 16, and 256 gray levels, respectively).
+
+
+Known problems
+**************
+
+- A font is entirely loaded into memory.  Obviously, this is not the Right
+  Thing(TM).  If you have big fonts I suggest you convert them into PCF
+  format (using the bdftopcf utility): the PCF font drive of FreeType can
+  perform incremental glyph loading.
+
+When I have some time, I will implement on-demand glyph parsing.
+
+- Except for encodings properties, client applications have no visibility of
+  the PCF_Face object.  This means that applications cannot directly access
+  font tables and must trust FreeType.
+
+- Currently, glyph names are ignored.
+
+  I plan to give full visibility of the BDF_Face object in an upcoming
+  revision of the driver, thus implementing also glyph names.
+
+- As I have never seen a BDF font that defines vertical metrics, vertical
+  metrics are (parsed and) discarded.  If you own a BDF font that defines
+  vertical metrics, please let me know (I will implement them in 5-10
+  minutes).
+
+
+License
+*******
+
+Copyright (C) 2001-2002 by Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*** Portions of the driver (that is, bdflib.c and bdf.h):
+
+Copyright 2000 Computing Research Labs, New Mexico State University
+Copyright 2001-2002 Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Credits
+*******
+
+This driver is based on excellent Mark Leisher's bdf library.  If you
+find something good in this driver you should probably thank him, not
+me.
diff --git a/nx-X11/extras/freetype2/src/bdf/bdf.c b/nx-X11/extras/freetype2/src/bdf/bdf.c
new file mode 100644
index 000000000..9c828853e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/bdf.c
@@ -0,0 +1,34 @@
+/*  bdf.c
+
+    FreeType font driver for bdf files
+
+    Copyright (C) 2001, 2002 by
+    Francesco Zappa Nardelli 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+
+#include <ft2build.h>
+#include "bdflib.c"
+#include "bdfdrivr.c"
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/bdf/bdf.h b/nx-X11/extras/freetype2/src/bdf/bdf.h
new file mode 100644
index 000000000..b42baa6e0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/bdf.h
@@ -0,0 +1,295 @@
+/*
+ * Copyright 2000 Computing Research Labs, New Mexico State University
+ * Copyright 2001, 2002, 2003, 2004 Francesco Zappa Nardelli
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#ifndef __BDF_H__
+#define __BDF_H__
+
+
+/*
+ * Based on bdf.h,v 1.16 2000/03/16 20:08:51 mleisher
+ */
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+
+
+FT_BEGIN_HEADER
+
+
+/* Imported from bdfP.h */
+
+#define _bdf_glyph_modified( map, e )                 \
+          ( (map)[(e) >> 5] & ( 1 << ( (e) & 31 ) ) )
+#define _bdf_set_glyph_modified( map, e )              \
+          ( (map)[(e) >> 5] |= ( 1 << ( (e) & 31 ) ) )
+#define _bdf_clear_glyph_modified( map, e )             \
+          ( (map)[(e) >> 5] &= ~( 1 << ( (e) & 31 ) ) )
+
+/* end of bdfP.h */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font options macros and types.                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define BDF_CORRECT_METRICS  0x01 /* Correct invalid metrics when loading. */
+#define BDF_KEEP_COMMENTS    0x02 /* Preserve the font comments.           */
+#define BDF_KEEP_UNENCODED   0x04 /* Keep the unencoded glyphs.            */
+#define BDF_PROPORTIONAL     0x08 /* Font has proportional spacing.        */
+#define BDF_MONOWIDTH        0x10 /* Font has mono width.                  */
+#define BDF_CHARCELL         0x20 /* Font has charcell spacing.            */
+
+#define BDF_ALL_SPACING  ( BDF_PROPORTIONAL | \
+                           BDF_MONOWIDTH    | \
+                           BDF_CHARCELL     )
+
+#define BDF_DEFAULT_LOAD_OPTIONS  ( BDF_CORRECT_METRICS | \
+                                    BDF_KEEP_COMMENTS   | \
+                                    BDF_KEEP_UNENCODED  | \
+                                    BDF_PROPORTIONAL    )
+
+
+  typedef struct  bdf_options_t_
+  {
+    int            correct_metrics;
+    int            keep_unencoded;
+    int            keep_comments;
+    int            font_spacing;
+
+  } bdf_options_t;
+
+
+  /* Callback function type for unknown configuration options. */
+  typedef int
+  (*bdf_options_callback_t)( bdf_options_t*  opts,
+                             char**          params,
+                             unsigned long   nparams,
+                             void*           client_data );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font property macros and types.                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define BDF_ATOM      1
+#define BDF_INTEGER   2
+#define BDF_CARDINAL  3
+
+
+  /* This structure represents a particular property of a font. */
+  /* There are a set of defaults and each font has their own.   */
+  typedef struct  bdf_property_t_
+  {
+    char*  name;         /* Name of the property.   */
+    int    format;       /* Format of the property. */
+    int    builtin;      /* A builtin property.     */
+    union
+    {
+      char*          atom;
+      long           int32;
+      unsigned long  card32;
+
+    } value;             /* Value of the property.  */
+
+  } bdf_property_t;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font metric and glyph types.                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  typedef struct  bdf_bbx_t_
+  {
+    unsigned short  width;
+    unsigned short  height;
+
+    short           x_offset;
+    short           y_offset;
+
+    short           ascent;
+    short           descent;
+
+  } bdf_bbx_t;
+
+
+  typedef struct  bdf_glyph_t_
+  {
+    char*           name;        /* Glyph name.                          */
+    long            encoding;    /* Glyph encoding.                      */
+    unsigned short  swidth;      /* Scalable width.                      */
+    unsigned short  dwidth;      /* Device width.                        */
+    bdf_bbx_t       bbx;         /* Glyph bounding box.                  */
+    unsigned char*  bitmap;      /* Glyph bitmap.                        */
+    unsigned long   bpr;         /* Number of bytes used per row.        */
+    unsigned short  bytes;       /* Number of bytes used for the bitmap. */
+
+  } bdf_glyph_t;
+
+
+  typedef struct  _hashnode_
+  {
+    const char*  key;
+    void*        data;
+  
+  } _hashnode, *hashnode;
+
+
+  typedef struct  hashtable_
+  {
+    int        limit;
+    int        size;
+    int        used;
+    hashnode*  table;
+
+  } hashtable;
+
+
+  typedef struct  bdf_glyphlist_t_
+  {
+    unsigned short  pad;          /* Pad to 4-byte boundary.              */
+    unsigned short  bpp;          /* Bits per pixel.                      */
+    long            start;        /* Beginning encoding value of glyphs.  */
+    long            end;          /* Ending encoding value of glyphs.     */
+    bdf_glyph_t*    glyphs;       /* Glyphs themselves.                   */
+    unsigned long   glyphs_size;  /* Glyph structures allocated.          */
+    unsigned long   glyphs_used;  /* Glyph structures used.               */
+    bdf_bbx_t       bbx;          /* Overall bounding box of glyphs.      */
+
+  } bdf_glyphlist_t;
+
+
+  typedef struct  bdf_font_t_
+  {
+    char*            name;           /* Name of the font.                   */
+    bdf_bbx_t        bbx;            /* Font bounding box.                  */
+
+    long             point_size;     /* Point size of the font.             */
+    unsigned long    resolution_x;   /* Font horizontal resolution.         */
+    unsigned long    resolution_y;   /* Font vertical resolution.           */
+
+    int              spacing;        /* Font spacing value.                 */
+
+    unsigned short   monowidth;      /* Logical width for monowidth font.   */
+
+    long             default_char;   /* Encoding of the default glyph.      */
+
+    long             font_ascent;    /* Font ascent.                        */
+    long             font_descent;   /* Font descent.                       */
+
+    unsigned long    glyphs_size;    /* Glyph structures allocated.         */
+    unsigned long    glyphs_used;    /* Glyph structures used.              */
+    bdf_glyph_t*     glyphs;         /* Glyphs themselves.                  */
+
+    unsigned long    unencoded_size; /* Unencoded glyph struct. allocated.  */
+    unsigned long    unencoded_used; /* Unencoded glyph struct. used.       */
+    bdf_glyph_t*     unencoded;      /* Unencoded glyphs themselves.        */
+
+    unsigned long    props_size;     /* Font properties allocated.          */
+    unsigned long    props_used;     /* Font properties used.               */
+    bdf_property_t*  props;          /* Font properties themselves.         */
+
+    char*            comments;       /* Font comments.                      */
+    unsigned long    comments_len;   /* Length of comment string.           */
+
+    bdf_glyphlist_t  overflow;       /* Storage used for glyph insertion.   */
+
+    void*            internal;       /* Internal data for the font.         */
+
+    unsigned long    nmod[2048];     /* Bitmap indicating modified glyphs.  */
+    unsigned long    umod[2048];     /* Bitmap indicating modified          */
+                                     /* unencoded glyphs.                   */
+    unsigned short   modified;       /* Boolean indicating font modified.   */
+    unsigned short   bpp;            /* Bits per pixel.                     */
+
+    FT_Memory        memory;
+
+    bdf_property_t*  user_props;
+    unsigned long    nuser_props;
+    hashtable        proptbl;
+
+  } bdf_font_t;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Types for load/save callbacks.                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Error codes. */
+#define BDF_MISSING_START       -1
+#define BDF_MISSING_FONTNAME    -2
+#define BDF_MISSING_SIZE        -3
+#define BDF_MISSING_CHARS       -4
+#define BDF_MISSING_STARTCHAR   -5
+#define BDF_MISSING_ENCODING    -6
+#define BDF_MISSING_BBX         -7
+
+#define BDF_OUT_OF_MEMORY      -20
+
+#define BDF_INVALID_LINE      -100
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font API.                                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+  FT_LOCAL( FT_Error )
+  bdf_load_font( FT_Stream       stream,
+                 FT_Memory       memory,
+                 bdf_options_t*  opts,
+                 bdf_font_t*    *font );
+
+  FT_LOCAL( void )
+  bdf_free_font( bdf_font_t*  font );
+
+  FT_LOCAL( bdf_property_t * )
+  bdf_get_property( char*        name,
+                    bdf_font_t*  font );
+
+  FT_LOCAL( bdf_property_t * )
+  bdf_get_font_property( bdf_font_t*  font,
+                         const char*  name );
+
+
+FT_END_HEADER
+
+
+#endif /* __BDF_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/bdf/bdfdrivr.c b/nx-X11/extras/freetype2/src/bdf/bdfdrivr.c
new file mode 100644
index 000000000..8f33d537e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/bdfdrivr.c
@@ -0,0 +1,915 @@
+/*  bdfdrivr.c
+
+    FreeType font driver for bdf files
+
+    Copyright (C) 2001, 2002, 2003, 2004 by
+    Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include <ft2build.h>
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_BDF_H
+
+#include FT_SERVICE_BDF_H
+#include FT_SERVICE_XFREE86_NAME_H
+
+#include "bdf.h"
+#include "bdfdrivr.h"
+
+#include "bdferror.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_bdfdriver
+
+
+  typedef struct  BDF_CMapRec_
+  {
+    FT_CMapRec        cmap;
+    FT_UInt           num_encodings;
+    BDF_encoding_el*  encodings;
+
+  } BDF_CMapRec, *BDF_CMap;
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  bdf_cmap_init( FT_CMap     bdfcmap,
+                 FT_Pointer  init_data )
+  {
+    BDF_CMap  cmap = (BDF_CMap)bdfcmap;
+    BDF_Face  face = (BDF_Face)FT_CMAP_FACE( cmap );
+    FT_UNUSED( init_data );
+
+
+    cmap->num_encodings = face->bdffont->glyphs_used;
+    cmap->encodings     = face->en_table;
+
+    return BDF_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  bdf_cmap_done( FT_CMap  bdfcmap )
+  {
+    BDF_CMap  cmap = (BDF_CMap)bdfcmap;
+
+
+    cmap->encodings     = NULL;
+    cmap->num_encodings = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  bdf_cmap_char_index( FT_CMap    bdfcmap,
+                       FT_UInt32  charcode )
+  {
+    BDF_CMap          cmap      = (BDF_CMap)bdfcmap;
+    BDF_encoding_el*  encodings = cmap->encodings;
+    FT_UInt           min, max, mid;
+    FT_UInt           result    = 0;
+
+
+    min = 0;
+    max = cmap->num_encodings;
+
+    while ( min < max )
+    {
+      FT_UInt32  code;
+
+
+      mid  = ( min + max ) >> 1;
+      code = encodings[mid].enc;
+
+      if ( charcode == code )
+      {
+        /* increase glyph index by 1 --              */
+        /* we reserve slot 0 for the undefined glyph */
+        result = encodings[mid].glyph + 1;
+        break;
+      }
+
+      if ( charcode < code )
+        max = mid;
+      else
+        min = mid + 1;
+    }
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  bdf_cmap_char_next( FT_CMap     bdfcmap,
+                      FT_UInt32  *acharcode )
+  {
+    BDF_CMap          cmap      = (BDF_CMap)bdfcmap;
+    BDF_encoding_el*  encodings = cmap->encodings;
+    FT_UInt           min, max, mid;
+    FT_UInt32         charcode = *acharcode + 1;
+    FT_UInt           result   = 0;
+
+
+    min = 0;
+    max = cmap->num_encodings;
+
+    while ( min < max )
+    {
+      FT_UInt32  code;
+
+
+      mid  = ( min + max ) >> 1;
+      code = encodings[mid].enc;
+
+      if ( charcode == code )
+      {
+        /* increase glyph index by 1 --              */
+        /* we reserve slot 0 for the undefined glyph */
+        result = encodings[mid].glyph + 1;
+        goto Exit;
+      }
+
+      if ( charcode < code )
+        max = mid;
+      else
+        min = mid + 1;
+    }
+
+    charcode = 0;
+    if ( min < cmap->num_encodings )
+    {
+      charcode = encodings[min].enc;
+      result   = encodings[min].glyph + 1;
+    }
+
+  Exit:
+    *acharcode = charcode;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_CMap_ClassRec  bdf_cmap_class =
+  {
+    sizeof ( BDF_CMapRec ),
+    bdf_cmap_init,
+    bdf_cmap_done,
+    bdf_cmap_char_index,
+    bdf_cmap_char_next
+  };
+
+
+  static FT_Error
+  bdf_interpret_style( BDF_Face  bdf )
+  {
+    FT_Error         error  = BDF_Err_Ok;
+    FT_Face          face   = FT_FACE( bdf );
+    FT_Memory        memory = face->memory;
+    bdf_font_t*      font   = bdf->bdffont;
+    bdf_property_t*  prop;
+
+    char  *istr = NULL, *bstr = NULL;
+    char  *sstr = NULL, *astr = NULL;
+
+    int  parts = 0, len = 0;
+
+
+    face->style_flags = 0;
+
+    prop = bdf_get_font_property( font, (char *)"SLANT" );
+    if ( prop && prop->format == BDF_ATOM                             &&
+         prop->value.atom                                             &&
+         ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' ||
+           *(prop->value.atom) == 'I' || *(prop->value.atom) == 'i' ) )
+    {
+      face->style_flags |= FT_STYLE_FLAG_ITALIC;
+      istr = ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' )
+               ? (char *)"Oblique"
+               : (char *)"Italic";
+      len += ft_strlen( istr );
+      parts++;
+    }
+
+    prop = bdf_get_font_property( font, (char *)"WEIGHT_NAME" );
+    if ( prop && prop->format == BDF_ATOM                             &&
+         prop->value.atom                                             &&
+         ( *(prop->value.atom) == 'B' || *(prop->value.atom) == 'b' ) )
+    {
+      face->style_flags |= FT_STYLE_FLAG_BOLD;
+      bstr = (char *)"Bold";
+      len += ft_strlen( bstr );
+      parts++;
+    }
+
+    prop = bdf_get_font_property( font, (char *)"SETWIDTH_NAME" );
+    if ( prop && prop->format == BDF_ATOM                              &&
+         prop->value.atom && *(prop->value.atom)                       &&
+         !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
+    {
+      sstr = (char *)(prop->value.atom);
+      len += ft_strlen( sstr );
+      parts++;
+    }
+
+    prop = bdf_get_font_property( font, (char *)"ADD_STYLE_NAME" );
+    if ( prop && prop->format == BDF_ATOM                              &&
+         prop->value.atom && *(prop->value.atom)                       &&
+         !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
+    {
+      astr = (char *)(prop->value.atom);
+      len += ft_strlen( astr );
+      parts++;
+    }
+
+    if ( !parts || !len )
+      face->style_name = (char *)"Regular";
+    else
+    {
+      char          *style, *s;
+      unsigned int  i;
+
+
+      if ( FT_ALLOC( style, len + parts ) )
+        return error;
+
+      s = style;
+
+      if ( astr )
+      {
+        ft_strcpy( s, astr );
+        for ( i = 0; i < ft_strlen( astr ); i++, s++ )
+          if ( *s == ' ' )
+            *s = '-';                     /* replace spaces with dashes */
+        *(s++) = ' ';
+      }
+      if ( bstr )
+      {
+        ft_strcpy( s, bstr );
+        s += ft_strlen( bstr );
+        *(s++) = ' ';
+      }
+      if ( istr )
+      {
+        ft_strcpy( s, istr );
+        s += ft_strlen( istr );
+        *(s++) = ' ';
+      }
+      if ( sstr )
+      {
+        ft_strcpy( s, sstr );
+        for ( i = 0; i < ft_strlen( sstr ); i++, s++ )
+          if ( *s == ' ' )
+            *s = '-';                     /* replace spaces with dashes */
+        *(s++) = ' ';
+      }
+      *(--s) = '\0';        /* overwrite last ' ', terminate the string */
+
+      face->style_name = style;                     /* allocated string */
+    }
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  BDF_Face_Done( FT_Face  bdfface )         /* BDF_Face */
+  {
+    BDF_Face   face   = (BDF_Face)bdfface;
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+
+    bdf_free_font( face->bdffont );
+
+    FT_FREE( face->en_table );
+
+    FT_FREE( face->charset_encoding );
+    FT_FREE( face->charset_registry );
+    FT_FREE( bdfface->family_name );
+
+    FT_FREE( bdfface->available_sizes );
+
+    FT_FREE( face->bdffont );
+
+    FT_TRACE4(( "BDF_Face_Done: done face\n" ));
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  BDF_Face_Init( FT_Stream      stream,
+                 FT_Face        bdfface,        /* BDF_Face */
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    FT_Error       error  = BDF_Err_Ok;
+    BDF_Face       face   = (BDF_Face)bdfface;
+    FT_Memory      memory = FT_FACE_MEMORY( face );
+
+    bdf_font_t*    font;
+    bdf_options_t  options;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( face_index );
+
+
+    if ( FT_STREAM_SEEK( 0 ) )
+      goto Exit;
+
+    options.correct_metrics = 1;   /* FZ XXX: options semantics */
+    options.keep_unencoded  = 1;
+    options.keep_comments   = 0;
+    options.font_spacing    = BDF_PROPORTIONAL;
+
+    error = bdf_load_font( stream, memory, &options, &font );
+    if ( error == BDF_Err_Missing_Startfont_Field )
+    {
+      FT_TRACE2(( "[not a valid BDF file]\n" ));
+      goto Fail;
+    }
+    else if ( error )
+      goto Exit;
+
+    /* we have a bdf font: let's construct the face object */
+    face->bdffont = font;
+    {
+      bdf_property_t*  prop = NULL;
+
+
+      FT_TRACE4(( "number of glyphs: %d (%d)\n",
+                  font->glyphs_size,
+                  font->glyphs_used ));
+      FT_TRACE4(( "number of unencoded glyphs: %d (%d)\n",
+                  font->unencoded_size,
+                  font->unencoded_used ));
+
+      bdfface->num_faces  = 1;
+      bdfface->face_index = 0;
+      bdfface->face_flags = FT_FACE_FLAG_FIXED_SIZES |
+                            FT_FACE_FLAG_HORIZONTAL  |
+                            FT_FACE_FLAG_FAST_GLYPHS;
+
+      prop = bdf_get_font_property( font, "SPACING" );
+      if ( prop && prop->format == BDF_ATOM                             &&
+           prop->value.atom                                             &&
+           ( *(prop->value.atom) == 'M' || *(prop->value.atom) == 'm' ||
+             *(prop->value.atom) == 'C' || *(prop->value.atom) == 'c' ) )
+        bdfface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      /* FZ XXX: TO DO: FT_FACE_FLAGS_VERTICAL   */
+      /* FZ XXX: I need a font to implement this */
+
+      prop = bdf_get_font_property( font, "FAMILY_NAME" );
+      if ( prop && prop->value.atom )
+      {
+        int  l = ft_strlen( prop->value.atom ) + 1;
+
+
+        if ( FT_NEW_ARRAY( bdfface->family_name, l ) )
+          goto Exit;
+        ft_strcpy( bdfface->family_name, prop->value.atom );
+      }
+      else
+        bdfface->family_name = 0;
+
+      if ( ( error = bdf_interpret_style( face ) ) != 0 )
+        goto Exit;
+
+      /* the number of glyphs (with one slot for the undefined glyph */
+      /* at position 0 and all unencoded glyphs)                     */
+      bdfface->num_glyphs = font->glyphs_size + 1;
+
+      bdfface->num_fixed_sizes = 1;
+      if ( FT_NEW_ARRAY( bdfface->available_sizes, 1 ) )
+        goto Exit;
+
+      {
+        FT_Bitmap_Size*  bsize = bdfface->available_sizes;
+        FT_Short         resolution_x = 0, resolution_y = 0;
+
+
+        FT_MEM_ZERO( bsize, sizeof ( FT_Bitmap_Size ) );
+
+        bsize->height = font->font_ascent + font->font_descent;
+
+        prop = bdf_get_font_property( font, "AVERAGE_WIDTH" );
+        if ( prop )
+          bsize->width = (FT_Short)( ( prop->value.int32 + 5 ) / 10 );
+        else
+          bsize->width = bsize->height * 2/3;
+
+        prop = bdf_get_font_property( font, "POINT_SIZE" );
+        if ( prop )
+          /* convert from 722.7 decipoints to 72 points per inch */
+          bsize->size =
+            (FT_Pos)( ( prop->value.int32 * 64 * 7200 + 36135L ) / 72270L );
+
+        prop = bdf_get_font_property( font, "PIXEL_SIZE" );
+        if ( prop )
+          bsize->y_ppem = (FT_Short)prop->value.int32 << 6;
+
+        prop = bdf_get_font_property( font, "RESOLUTION_X" );
+        if ( prop )
+          resolution_x = (FT_Short)prop->value.int32;
+
+        prop = bdf_get_font_property( font, "RESOLUTION_Y" );
+        if ( prop )
+          resolution_y = (FT_Short)prop->value.int32;
+
+        if ( bsize->y_ppem == 0 )
+        {
+          bsize->y_ppem = bsize->size;
+          if ( resolution_y )
+            bsize->y_ppem = bsize->y_ppem * resolution_y / 72;
+        }
+        if ( resolution_x && resolution_y )
+          bsize->x_ppem = bsize->y_ppem * resolution_x / resolution_y;
+        else
+          bsize->x_ppem = bsize->y_ppem;
+      }
+
+      /* encoding table */
+      {
+        bdf_glyph_t*   cur = font->glyphs;
+        unsigned long  n;
+
+
+        if ( FT_NEW_ARRAY( face->en_table, font->glyphs_size ) )
+          goto Exit;
+
+        face->default_glyph = 0;
+        for ( n = 0; n < font->glyphs_size; n++ )
+        {
+          (face->en_table[n]).enc = cur[n].encoding;
+          FT_TRACE4(( "idx %d, val 0x%lX\n", n, cur[n].encoding ));
+          (face->en_table[n]).glyph = (FT_Short)n;
+  
+          if ( cur[n].encoding == font->default_char )
+            face->default_glyph = n;
+        }
+      }
+
+      /* charmaps */
+      {
+        bdf_property_t  *charset_registry = 0, *charset_encoding = 0;
+        FT_Bool          unicode_charmap  = 0;
+
+
+        charset_registry =
+          bdf_get_font_property( font, "CHARSET_REGISTRY" );
+        charset_encoding =
+          bdf_get_font_property( font, "CHARSET_ENCODING" );
+        if ( charset_registry && charset_encoding )
+        {
+          if ( charset_registry->format == BDF_ATOM &&
+               charset_encoding->format == BDF_ATOM &&
+               charset_registry->value.atom         &&
+               charset_encoding->value.atom         )
+          {
+            const char*  s;
+
+
+            if ( FT_NEW_ARRAY( face->charset_encoding,
+                               ft_strlen( charset_encoding->value.atom ) + 1 ) )
+              goto Exit;
+            if ( FT_NEW_ARRAY( face->charset_registry,
+                               ft_strlen( charset_registry->value.atom ) + 1 ) )
+              goto Exit;
+
+            ft_strcpy( face->charset_registry, charset_registry->value.atom );
+            ft_strcpy( face->charset_encoding, charset_encoding->value.atom );
+
+            /* Uh, oh, compare first letters manually to avoid dependency
+               on locales. */
+            s = face->charset_registry;
+            if ( ( s[0] == 'i' || s[0] == 'I' ) &&
+                 ( s[1] == 's' || s[1] == 'S' ) &&
+                 ( s[2] == 'o' || s[2] == 'O' ) )
+            {
+              s += 3;
+              if ( !ft_strcmp( s, "10646" )                      ||
+                   ( !ft_strcmp( s, "8859" ) &&
+                     !ft_strcmp( face->charset_encoding, "1" ) ) )
+              unicode_charmap = 1;
+            }
+
+            {
+              FT_CharMapRec  charmap;
+
+
+              charmap.face        = FT_FACE( face );
+              charmap.encoding    = FT_ENCODING_NONE;
+              charmap.platform_id = 0;
+              charmap.encoding_id = 0;
+
+              if ( unicode_charmap )
+              {
+                charmap.encoding    = FT_ENCODING_UNICODE;
+                charmap.platform_id = 3;
+                charmap.encoding_id = 1;
+              }
+
+              error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
+
+#if 0
+              /* Select default charmap */
+              if ( bdfface->num_charmaps )
+                bdfface->charmap = bdfface->charmaps[0];
+#endif
+            }
+
+            goto Exit;
+          }
+        }
+
+        /* otherwise assume Adobe standard encoding */
+
+        {
+          FT_CharMapRec  charmap;
+
+
+          charmap.face        = FT_FACE( face );
+          charmap.encoding    = FT_ENCODING_ADOBE_STANDARD;
+          charmap.platform_id = 7;
+          charmap.encoding_id = 0;
+
+          error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
+
+          /* Select default charmap */
+          if ( bdfface->num_charmaps )
+            bdfface->charmap = bdfface->charmaps[0];
+        }
+      }
+    }
+
+  Exit:
+    return error;
+
+  Fail:
+    BDF_Face_Done( bdfface );
+    return BDF_Err_Unknown_File_Format;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  BDF_Set_Pixel_Size( FT_Size  size,
+                      FT_UInt  char_width,
+                      FT_UInt  char_height )
+  {
+    BDF_Face  face = (BDF_Face)FT_SIZE_FACE( size );
+    FT_Face   root = FT_FACE( face );
+
+    FT_UNUSED( char_width );
+    FT_UNUSED( char_height );
+
+
+    FT_TRACE4(( "rec %d - pres %d\n",
+                size->metrics.y_ppem, root->available_sizes->y_ppem ));
+
+    if ( size->metrics.y_ppem == root->available_sizes->y_ppem >> 6 )
+    {
+      size->metrics.ascender    = face->bdffont->font_ascent << 6;
+      size->metrics.descender   = -face->bdffont->font_descent << 6;
+      size->metrics.height      = ( face->bdffont->font_ascent +
+                                    face->bdffont->font_descent ) << 6;
+      size->metrics.max_advance = face->bdffont->bbx.width << 6;
+
+      return BDF_Err_Ok;
+    }
+    else
+      return BDF_Err_Invalid_Pixel_Size;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  BDF_Set_Point_Size( FT_Size     size,
+                      FT_F26Dot6  char_width,
+                      FT_F26Dot6  char_height,
+                      FT_UInt     horz_resolution,
+                      FT_UInt     vert_resolution )
+  {
+    FT_UNUSED( char_width );
+    FT_UNUSED( char_height );
+    FT_UNUSED( horz_resolution );
+    FT_UNUSED( vert_resolution );
+
+    return BDF_Set_Pixel_Size( size, 0, 0 );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  BDF_Glyph_Load( FT_GlyphSlot  slot,
+                  FT_Size       size,
+                  FT_UInt       glyph_index,
+                  FT_Int32      load_flags )
+  {
+    BDF_Face        face   = (BDF_Face)FT_SIZE_FACE( size );
+    FT_Error        error  = BDF_Err_Ok;
+    FT_Bitmap*      bitmap = &slot->bitmap;
+    bdf_glyph_t     glyph;
+    int             bpp    = face->bdffont->bpp;
+    int             i, j, count;
+    unsigned char   *p, *pp;
+
+    FT_UNUSED( load_flags );
+
+
+    if ( !face )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* index 0 is the undefined glyph */
+    if ( glyph_index == 0 )
+      glyph_index = face->default_glyph;
+    else
+      glyph_index--;
+
+    /* slot, bitmap => freetype, glyph => bdflib */
+    glyph = face->bdffont->glyphs[glyph_index];
+
+    bitmap->rows  = glyph.bbx.height;
+    bitmap->width = glyph.bbx.width;
+
+    if ( bpp == 1 )
+    {
+      bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
+      bitmap->pitch      = glyph.bpr;
+
+     /* note: we don't allocate a new array to hold the bitmap, we */
+     /*       can simply point to it                               */
+      ft_glyphslot_set_bitmap( slot, glyph.bitmap );
+    }
+    else
+    {
+      /* blow up pixmap to have 8 bits per pixel */
+      bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
+      bitmap->pitch      = bitmap->width;
+
+      error = ft_glyphslot_alloc_bitmap( slot, bitmap->rows * bitmap->pitch );
+      if ( error )
+        goto Exit;
+
+      switch ( bpp )
+      {
+      case 2:
+        bitmap->num_grays = 4;
+
+        count = 0;
+        p     = glyph.bitmap;
+
+        for ( i = 0; i < bitmap->rows; i++ )
+        {
+          pp = p;
+
+          /* get the full bytes */
+          for ( j = 0; j < ( bitmap->width >> 2 ); j++ )
+          {
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xC0 ) >> 6 );
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x30 ) >> 4 );
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x0C ) >> 2 );
+            bitmap->buffer[count++] = (FT_Byte)(   *pp & 0x03 );
+
+            pp++;
+          }
+
+          /* get remaining pixels (if any) */
+          switch ( bitmap->width & 3 )
+          {
+          case 3:
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xC0 ) >> 6 );
+            /* fall through */
+          case 2:
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x30 ) >> 4 );
+            /* fall through */
+          case 1:
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x0C ) >> 2 );
+            /* fall through */
+          case 0:
+            break;
+          }
+
+          p += glyph.bpr;
+        }
+        break;
+
+      case 4:
+        bitmap->num_grays = 16;
+
+        count = 0;
+        p     = glyph.bitmap;
+
+        for ( i = 0; i < bitmap->rows; i++ )
+        {
+          pp = p;
+
+          /* get the full bytes */
+          for ( j = 0; j < ( bitmap->width >> 1 ); j++ )
+          {
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xF0 ) >> 4 );
+            bitmap->buffer[count++] = (FT_Byte)(   *pp & 0x0F );
+
+            pp++;
+          }
+
+          /* get remaining pixel (if any) */
+          switch ( bitmap->width & 1 )
+          {
+          case 1:
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xF0 ) >> 4 );
+            /* fall through */
+          case 0:
+            break;
+          }
+
+          p += glyph.bpr;
+        }
+        break;
+
+      case 8:
+        bitmap->num_grays = 256;
+
+        FT_MEM_COPY( bitmap->buffer, glyph.bitmap,
+                     bitmap->rows * bitmap->pitch );
+        break;
+      }
+    }
+
+    slot->bitmap_left = glyph.bbx.x_offset;
+    slot->bitmap_top  = glyph.bbx.ascent;
+
+    /* FZ XXX: TODO: vertical metrics */
+    slot->metrics.horiAdvance  = glyph.dwidth << 6;
+    slot->metrics.horiBearingX = glyph.bbx.x_offset << 6;
+    slot->metrics.horiBearingY = glyph.bbx.ascent << 6;
+    slot->metrics.width        = bitmap->width << 6;
+    slot->metrics.height       = bitmap->rows << 6;
+
+    slot->linearHoriAdvance = (FT_Fixed)glyph.dwidth << 16;
+    slot->format            = FT_GLYPH_FORMAT_BITMAP;
+
+  Exit:
+    return error;
+  }
+
+
+ /*
+  *
+  *  BDF SERVICE
+  *
+  */
+
+  static FT_Error
+  bdf_get_bdf_property( BDF_Face          face,
+                        const char*       prop_name,
+                        BDF_PropertyRec  *aproperty )
+  {
+    bdf_property_t*  prop;
+
+
+    FT_ASSERT( face && face->bdffont );
+
+    prop = bdf_get_font_property( face->bdffont, prop_name );
+    if ( prop )
+    {
+      switch ( prop->format )
+      {
+      case BDF_ATOM:
+        aproperty->type   = BDF_PROPERTY_TYPE_ATOM;
+        aproperty->u.atom = prop->value.atom;
+        break;
+
+      case BDF_INTEGER:
+        aproperty->type      = BDF_PROPERTY_TYPE_INTEGER;
+        aproperty->u.integer = prop->value.int32;
+        break;
+
+      case BDF_CARDINAL:
+        aproperty->type       = BDF_PROPERTY_TYPE_CARDINAL;
+        aproperty->u.cardinal = prop->value.card32;
+        break;
+
+      default:
+        goto Fail;
+      }
+      return 0;
+    }
+
+  Fail:
+    return BDF_Err_Invalid_Argument;
+  }
+
+
+  static FT_Error
+  bdf_get_charset_id( BDF_Face      face,
+                      const char*  *acharset_encoding,
+                      const char*  *acharset_registry )
+  {
+    *acharset_encoding = face->charset_encoding;
+    *acharset_registry = face->charset_registry;
+
+    return 0;
+  }
+
+
+  static const FT_Service_BDFRec  bdf_service_bdf =
+  {
+    (FT_BDF_GetCharsetIdFunc)bdf_get_charset_id,
+    (FT_BDF_GetPropertyFunc) bdf_get_bdf_property
+  };
+
+
+ /*
+  *
+  *  SERVICES LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  bdf_services[] =
+  {
+    { FT_SERVICE_ID_BDF,       &bdf_service_bdf },
+    { FT_SERVICE_ID_XF86_NAME, FT_XF86_FORMAT_BDF },
+    { NULL, NULL }
+  };
+
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  bdf_driver_requester( FT_Module    module,
+                        const char*  name )
+  {
+    FT_UNUSED( module );
+
+    return ft_service_list_lookup( bdf_services, name );
+  }
+
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  bdf_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER         |
+      FT_MODULE_DRIVER_NO_OUTLINES,
+      sizeof ( FT_DriverRec ),
+
+      "bdf",
+      0x10000L,
+      0x20000L,
+
+      0,
+
+      (FT_Module_Constructor)0,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  bdf_driver_requester
+    },
+
+    sizeof ( BDF_FaceRec ),
+    sizeof ( FT_SizeRec ),
+    sizeof ( FT_GlyphSlotRec ),
+
+    BDF_Face_Init,
+    BDF_Face_Done,
+    0,                          /* FT_Size_InitFunc */
+    0,                          /* FT_Size_DoneFunc */
+    0,                          /* FT_Slot_InitFunc */
+    0,                          /* FT_Slot_DoneFunc */
+
+    BDF_Set_Point_Size,
+    BDF_Set_Pixel_Size,
+
+    BDF_Glyph_Load,
+
+    0,                          /* FT_Face_GetKerningFunc   */
+    0,                          /* FT_Face_AttachFunc       */
+    0,                          /* FT_Face_GetAdvancesFunc  */
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/bdf/bdfdrivr.h b/nx-X11/extras/freetype2/src/bdf/bdfdrivr.h
new file mode 100644
index 000000000..86f40ee4a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/bdfdrivr.h
@@ -0,0 +1,76 @@
+/*  bdfdrivr.h
+
+    FreeType font driver for bdf fonts
+
+  Copyright (C) 2001, 2002, 2003, 2004 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#ifndef __BDFDRIVR_H__
+#define __BDFDRIVR_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+#include "bdf.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  BDF_encoding_el_
+  {
+    FT_ULong   enc;
+    FT_UShort  glyph;
+
+  } BDF_encoding_el;
+
+
+  typedef struct  BDF_FaceRec_
+  {
+    FT_FaceRec        root;
+
+    char*             charset_encoding;
+    char*             charset_registry;
+
+    bdf_font_t*       bdffont;
+
+    BDF_encoding_el*  en_table;
+
+    FT_CharMap        charmap_handle;
+    FT_CharMapRec     charmap;  /* a single charmap per face */
+
+    FT_UInt           default_glyph;
+
+  } BDF_FaceRec, *BDF_Face;
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  bdf_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __BDFDRIVR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/bdf/bdferror.h b/nx-X11/extras/freetype2/src/bdf/bdferror.h
new file mode 100644
index 000000000..b27fa333b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/bdferror.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2001, 2002 Francesco Zappa Nardelli
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to define the BDF error enumeration constants.      */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __BDFERROR_H__
+#define __BDFERROR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  BDF_Err_
+#define FT_ERR_BASE    FT_Mod_Err_BDF
+
+#include FT_ERRORS_H
+
+#endif /* __BDFERROR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/bdf/bdflib.c b/nx-X11/extras/freetype2/src/bdf/bdflib.c
new file mode 100644
index 000000000..825385e1d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/bdflib.c
@@ -0,0 +1,2435 @@
+/*
+ * Copyright 2000 Computing Research Labs, New Mexico State University
+ * Copyright 2001, 2002, 2003, 2004 Francesco Zappa Nardelli
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+ * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  This file is based on bdf.c,v 1.22 2000/03/16 20:08:50               */
+  /*                                                                       */
+  /*  taken from Mark Leisher's xmbdfed package                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+
+#include FT_FREETYPE_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+
+#include "bdf.h"
+#include "bdferror.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_bdflib
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Default BDF font options.                                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static const bdf_options_t  _bdf_opts =
+  {
+    1,                /* Correct metrics.               */
+    1,                /* Preserve unencoded glyphs.     */
+    0,                /* Preserve comments.             */
+    BDF_PROPORTIONAL  /* Default spacing.               */
+  };
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Builtin BDF font properties.                                          */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* List of most properties that might appear in a font.  Doesn't include */
+  /* the RAW_* and AXIS_* properties in X11R6 polymorphic fonts.           */
+
+  static const bdf_property_t  _bdf_properties[] =
+  {
+    { (char *)"ADD_STYLE_NAME",          BDF_ATOM,     1, { 0 } },
+    { (char *)"AVERAGE_WIDTH",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"AVG_CAPITAL_WIDTH",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"AVG_LOWERCASE_WIDTH",     BDF_INTEGER,  1, { 0 } },
+    { (char *)"CAP_HEIGHT",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"CHARSET_COLLECTIONS",     BDF_ATOM,     1, { 0 } },
+    { (char *)"CHARSET_ENCODING",        BDF_ATOM,     1, { 0 } },
+    { (char *)"CHARSET_REGISTRY",        BDF_ATOM,     1, { 0 } },
+    { (char *)"COMMENT",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"COPYRIGHT",               BDF_ATOM,     1, { 0 } },
+    { (char *)"DEFAULT_CHAR",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"DESTINATION",             BDF_CARDINAL, 1, { 0 } },
+    { (char *)"DEVICE_FONT_NAME",        BDF_ATOM,     1, { 0 } },
+    { (char *)"END_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"FACE_NAME",               BDF_ATOM,     1, { 0 } },
+    { (char *)"FAMILY_NAME",             BDF_ATOM,     1, { 0 } },
+    { (char *)"FIGURE_WIDTH",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"FONT",                    BDF_ATOM,     1, { 0 } },
+    { (char *)"FONTNAME_REGISTRY",       BDF_ATOM,     1, { 0 } },
+    { (char *)"FONT_ASCENT",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"FONT_DESCENT",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"FOUNDRY",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"FULL_NAME",               BDF_ATOM,     1, { 0 } },
+    { (char *)"ITALIC_ANGLE",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"MAX_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"MIN_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"NORM_SPACE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"NOTICE",                  BDF_ATOM,     1, { 0 } },
+    { (char *)"PIXEL_SIZE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"POINT_SIZE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"QUAD_WIDTH",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_ASCENT",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVERAGE_WIDTH",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVG_CAPITAL_WIDTH",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVG_LOWERCASE_WIDTH", BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_CAP_HEIGHT",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_DESCENT",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_END_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_FIGURE_WIDTH",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_MAX_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_MIN_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_NORM_SPACE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_PIXEL_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_POINT_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_PIXELSIZE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_POINTSIZE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_QUAD_WIDTH",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SMALL_CAP_SIZE",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_STRIKEOUT_ASCENT",    BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_STRIKEOUT_DESCENT",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_SIZE",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_X",         BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_Y",         BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_SIZE",    BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_X",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_Y",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_UNDERLINE_POSITION",  BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_UNDERLINE_THICKNESS", BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_X_HEIGHT",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"RELATIVE_SETWIDTH",       BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RELATIVE_WEIGHT",         BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RESOLUTION",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RESOLUTION_X",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RESOLUTION_Y",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"SETWIDTH_NAME",           BDF_ATOM,     1, { 0 } },
+    { (char *)"SLANT",                   BDF_ATOM,     1, { 0 } },
+    { (char *)"SMALL_CAP_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"SPACING",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"STRIKEOUT_ASCENT",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"STRIKEOUT_DESCENT",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_X",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_Y",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_SIZE",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_X",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_Y",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"UNDERLINE_POSITION",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"UNDERLINE_THICKNESS",     BDF_INTEGER,  1, { 0 } },
+    { (char *)"WEIGHT",                  BDF_CARDINAL, 1, { 0 } },
+    { (char *)"WEIGHT_NAME",             BDF_ATOM,     1, { 0 } },
+    { (char *)"X_HEIGHT",                BDF_INTEGER,  1, { 0 } },
+    { (char *)"_MULE_BASELINE_OFFSET",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"_MULE_RELATIVE_COMPOSE",  BDF_INTEGER,  1, { 0 } },
+  };
+
+  static const unsigned long
+  _num_bdf_properties = sizeof ( _bdf_properties ) /
+                        sizeof ( _bdf_properties[0] );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Hash table utilities for the properties.                              */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* XXX: Replace this with FreeType's hash functions */
+
+
+#define INITIAL_HT_SIZE  241
+
+  typedef void
+  (*hash_free_func)( hashnode  node );
+
+  static hashnode*
+  hash_bucket( const char*  key,
+               hashtable*   ht )
+  {
+    const char*    kp  = key;
+    unsigned long  res = 0;
+    hashnode*      bp  = ht->table, *ndp;
+
+
+    /* Mocklisp hash function. */
+    while ( *kp )
+      res = ( res << 5 ) - res + *kp++;
+
+    ndp = bp + ( res % ht->size );
+    while ( *ndp )
+    {
+      kp = (*ndp)->key;
+      if ( kp[0] == key[0] && ft_strcmp( kp, key ) == 0 )
+        break;
+      ndp--;
+      if ( ndp < bp )
+        ndp = bp + ( ht->size - 1 );
+    }
+
+    return ndp;
+  }
+
+
+  static FT_Error
+  hash_rehash( hashtable*  ht,
+               FT_Memory   memory )
+  {
+    hashnode*  obp = ht->table, *bp, *nbp;
+    int        i, sz = ht->size;
+    FT_Error   error = BDF_Err_Ok;
+
+
+    ht->size <<= 1;
+    ht->limit  = ht->size / 3;
+
+    if ( FT_NEW_ARRAY( ht->table, ht->size ) )
+      goto Exit;
+    FT_MEM_ZERO( ht->table, sizeof ( hashnode ) * ht->size );
+
+    for ( i = 0, bp = obp; i < sz; i++, bp++ )
+    {
+      if ( *bp )
+      {
+        nbp = hash_bucket( (*bp)->key, ht );
+        *nbp = *bp;
+      }
+    }
+    FT_FREE( obp );
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  hash_init( hashtable*  ht,
+             FT_Memory   memory )
+  {
+    int       sz = INITIAL_HT_SIZE;
+    FT_Error  error = BDF_Err_Ok;
+
+
+    ht->size  = sz;
+    ht->limit = sz / 3;
+    ht->used  = 0;
+
+    if ( FT_NEW_ARRAY( ht->table, sz ) )
+      goto Exit;
+    FT_MEM_ZERO( ht->table, sizeof ( hashnode ) * sz );
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  hash_free( hashtable*  ht,
+             FT_Memory   memory )
+  {
+    if ( ht != 0 )
+    {
+      int        i, sz = ht->size;
+      hashnode*  bp = ht->table;
+
+
+      for ( i = 0; i < sz; i++, bp++ )
+        FT_FREE( *bp );
+
+      FT_FREE( ht->table );
+    }
+  }
+
+
+  static FT_Error
+  hash_insert( char*       key,
+               void*       data,
+               hashtable*  ht,
+               FT_Memory   memory )
+  {
+    hashnode  nn, *bp = hash_bucket( key, ht );
+    FT_Error  error = BDF_Err_Ok;
+
+
+    nn = *bp;
+    if ( !nn )
+    {
+      if ( FT_NEW( nn ) )
+        goto Exit;
+      *bp = nn;
+
+      nn->key  = key;
+      nn->data = data;
+
+      if ( ht->used >= ht->limit )
+      {
+        error = hash_rehash( ht, memory );
+        if ( error )
+          goto Exit;
+      }
+      ht->used++;
+    }
+    else
+      nn->data = data;
+
+  Exit:
+    return error;
+  }
+
+
+  static hashnode
+  hash_lookup( const char* key,
+               hashtable*  ht )
+  {
+    hashnode *np = hash_bucket( key, ht );
+
+
+    return *np;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Utility types and functions.                                          */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Function type for parsing lines of a BDF font. */
+
+  typedef FT_Error
+  (*_bdf_line_func_t)( char*          line,
+                       unsigned long  linelen,
+                       unsigned long  lineno,
+                       void*          call_data,
+                       void*          client_data );
+
+
+  /* List structure for splitting lines into fields. */
+
+  typedef struct  _bdf_list_t_
+  {
+    char**         field;
+    unsigned long  size;
+    unsigned long  used;
+
+  } _bdf_list_t;
+
+
+  /* Structure used while loading BDF fonts. */
+
+  typedef struct  _bdf_parse_t_
+  {
+    unsigned long   flags;
+    unsigned long   cnt;
+    unsigned long   row;
+
+    short           minlb;
+    short           maxlb;
+    short           maxrb;
+    short           maxas;
+    short           maxds;
+
+    short           rbearing;
+
+    char*           glyph_name;
+    long            glyph_enc;
+
+    bdf_font_t*     font;
+    bdf_options_t*  opts;
+
+    unsigned long   have[2048];
+    _bdf_list_t     list;
+
+    FT_Memory       memory;
+
+  } _bdf_parse_t;
+
+
+#define setsbit( m, cc )  ( m[(cc) >> 3] |= (FT_Byte)( 1 << ( (cc) & 7 ) ) )
+#define sbitset( m, cc )  ( m[(cc) >> 3]  & ( 1 << ( (cc) & 7 ) ) )
+
+
+  /* An empty string for empty fields. */
+
+  static const char  empty[1] = { 0 };      /* XXX eliminate this */
+
+
+  /* Assume the line is NULL-terminated and that the `list' parameter */
+  /* was initialized the first time it was used.                      */
+
+  static FT_Error
+  _bdf_split( char*          separators,
+              char*          line,
+              unsigned long  linelen,
+              _bdf_list_t*   list,
+              FT_Memory      memory )
+  {
+    int       mult, final_empty;
+    char      *sp, *ep, *end;
+    char      seps[32];
+    FT_Error  error = BDF_Err_Ok;
+
+
+    /* Initialize the list. */
+    list->used = 0;
+
+    /* If the line is empty, then simply return. */
+    if ( linelen == 0 || line[0] == 0 )
+      goto Exit;
+
+    /* In the original code, if the `separators' parameter is NULL or */
+    /* empty, the list is split into individual bytes.  We don't need */
+    /* this, so an error is signaled.                                 */
+    if ( separators == 0 || *separators == 0 )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* Prepare the separator bitmap. */
+    FT_MEM_ZERO( seps, 32 );
+
+    /* If the very last character of the separator string is a plus, then */
+    /* set the `mult' flag to indicate that multiple separators should be */
+    /* collapsed into one.                                                */
+    for ( mult = 0, sp = separators; sp && *sp; sp++ )
+    {
+      if ( *sp == '+' && *( sp + 1 ) == 0 )
+        mult = 1;
+      else
+        setsbit( seps, *sp );
+    }
+
+    /* Break the line up into fields. */
+    for ( final_empty = 0, sp = ep = line, end = sp + linelen;
+          sp < end && *sp; )
+    {
+      /* Collect everything that is not a separator. */
+      for ( ; *ep && !sbitset( seps, *ep ); ep++ )
+        ;
+
+      /* Resize the list if necessary. */
+      if ( list->used == list->size )
+      {
+        if ( list->size == 0 )
+        {
+          if ( FT_NEW_ARRAY( list->field, 5 ) )
+            goto Exit;
+        }
+        else
+        {
+          if ( FT_RENEW_ARRAY ( list->field ,
+                                list->size,
+                                list->size + 5 ) )
+            goto Exit;
+        }
+
+        list->size += 5;
+      }
+
+      /* Assign the field appropriately. */
+      list->field[list->used++] = ( ep > sp ) ? sp : (char*)empty;
+
+      sp = ep;
+
+      if ( mult )
+      {
+        /* If multiple separators should be collapsed, do it now by */
+        /* setting all the separator characters to 0.               */
+        for ( ; *ep && sbitset( seps, *ep ); ep++ )
+          *ep = 0;
+      }
+      else if ( *ep != 0 )
+        /* Don't collapse multiple separators by making them 0, so just */
+        /* make the one encountered 0.                                  */
+        *ep++ = 0;
+
+      final_empty = ( ep > sp && *ep == 0 );
+      sp = ep;
+    }
+
+    /* Finally, NULL-terminate the list. */
+    if ( list->used + final_empty + 1 >= list->size )
+    {
+      if ( list->used == list->size )
+      {
+        if ( list->size == 0 )
+        {
+          if ( FT_NEW_ARRAY( list->field, 5 ) )
+            goto Exit;
+        }
+        else
+        {
+          if ( FT_RENEW_ARRAY( list->field,
+                               list->size,
+                               list->size + 5 ) )
+            goto Exit;
+        }
+
+        list->size += 5;
+      }
+    }
+
+    if ( final_empty )
+      list->field[list->used++] = (char*)empty;
+
+    if ( list->used == list->size )
+    {
+      if ( list->size == 0 )
+      {
+        if ( FT_NEW_ARRAY( list->field, 5 ) )
+          goto Exit;
+      }
+      else
+      {
+        if ( FT_RENEW_ARRAY( list->field,
+                             list->size,
+                             list->size + 5 ) )
+          goto Exit;
+      }
+
+      list->size += 5;
+    }
+
+    list->field[list->used] = 0;
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  _bdf_shift( unsigned long  n,
+              _bdf_list_t*   list )
+  {
+    unsigned long  i, u;
+
+
+    if ( list == 0 || list->used == 0 || n == 0 )
+      return;
+
+    if ( n >= list->used )
+    {
+      list->used = 0;
+      return;
+    }
+
+    for ( u = n, i = 0; u < list->used; i++, u++ )
+      list->field[i] = list->field[u];
+    list->used -= n;
+  }
+
+
+  static char *
+  _bdf_join( int             c,
+             unsigned long*  len,
+             _bdf_list_t*    list )
+  {
+    unsigned long  i, j;
+    char           *fp, *dp;
+
+
+    if ( list == 0 || list->used == 0 )
+      return 0;
+
+    *len = 0;
+
+    dp = list->field[0];
+    for ( i = j = 0; i < list->used; i++ )
+    {
+      fp = list->field[i];
+      while ( *fp )
+        dp[j++] = *fp++;
+
+      if ( i + 1 < list->used )
+        dp[j++] = (char)c;
+    }
+    dp[j] = 0;
+
+    *len = j;
+    return dp;
+  }
+
+
+  /* High speed file reader that passes each line to a callback. */
+  static FT_Error
+  bdf_internal_readstream( FT_Stream  stream,
+                           char*      buffer,
+                           int        count,
+                           int       *read_bytes )
+  {
+    int            rbytes;
+    unsigned long  pos   = stream->pos;
+    FT_Error       error = BDF_Err_Ok;
+
+
+    if ( pos > stream->size )
+    {
+      FT_ERROR(( "bdf_internal_readstream:" ));
+      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+                 pos, stream->size ));
+      error = BDF_Err_Invalid_Stream_Operation;
+      goto Exit;
+    }
+
+    if ( stream->read )
+      rbytes = stream->read( stream, pos,
+                             (unsigned char *)buffer, count );
+    else
+    {
+      rbytes = stream->size - pos;
+      if ( rbytes > count )
+        rbytes = count;
+
+      FT_MEM_COPY( buffer, stream->base + pos, rbytes );
+    }
+
+    stream->pos = pos + rbytes;
+
+    *read_bytes = rbytes;
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  _bdf_readstream( FT_Stream         stream,
+                   _bdf_line_func_t  callback,
+                   void*             client_data,
+                   unsigned long    *lno )
+  {
+    _bdf_line_func_t  cb;
+    unsigned long     lineno;
+    int               n, done, refill, bytes, hold;
+    char              *ls, *le, *pp, *pe, *hp;
+    char              *buf = 0;
+    FT_Memory         memory = stream->memory;
+    FT_Error          error = BDF_Err_Ok;
+
+
+    if ( callback == 0 )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    if ( FT_NEW_ARRAY( buf, 65536L ) )
+      goto Exit;
+
+    cb     = callback;
+    lineno = 1;
+    buf[0] = 0;
+
+    done = 0;
+    pp = ls = le = buf;
+
+    bytes = 65536L;
+
+    while ( !done )
+    {
+      error = bdf_internal_readstream( stream, pp, bytes, &n );
+      if ( error )
+        goto Exit;
+
+      if ( n == 0 )
+        break;
+
+      /* Determine the new end of the buffer pages. */
+      pe = pp + n;
+
+      for ( refill = 0; done == 0 && refill == 0; )
+      {
+        while ( le < pe && *le != '\n' && *le != '\r' )
+          le++;
+
+        if ( le == pe )
+        {
+          /* Hit the end of the last page in the buffer.  Need to find */
+          /* out how many pages to shift and how many pages need to be */
+          /* read in.  Adjust the line start and end pointers down to  */
+          /* point to the right places in the pages.                   */
+
+          pp  = buf + ( ( ( ls - buf ) >> 13 ) << 13 );
+          n   = pp - buf;
+          ls -= n;
+          le -= n;
+          n   = pe - pp;
+
+          FT_MEM_MOVE( buf, pp, n );
+
+          pp     = buf + n;
+          bytes  = 65536L - n;
+          refill = 1;
+        }
+        else
+        {
+          /* Temporarily NULL-terminate the line. */
+          hp   = le;
+          hold = *le;
+          *le  = 0;
+
+          /* XXX: Use encoding independent value for 0x1a */
+          if ( *ls != '#' && *ls != 0x1a                          &&
+               le > ls                                            &&
+               ( error = (*cb)( ls, le - ls, lineno, (void *)&cb,
+                                client_data ) ) != BDF_Err_Ok     )
+            done = 1;
+          else
+          {
+            ls = ++le;
+            /* Handle the case of DOS crlf sequences. */
+            if ( le < pe && hold == '\n' && *le =='\r' )
+              ls = ++le;
+          }
+
+          /* Increment the line number. */
+          lineno++;
+
+          /* Restore the character at the end of the line. */
+          *hp = (char)hold;
+        }
+      }
+    }
+
+    *lno             = lineno;
+
+  Exit:
+    FT_FREE( buf );
+    return error;
+  }
+
+
+  /* XXX: make this work with EBCDIC also */
+
+  static const unsigned char  a2i[128] =
+  {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  };
+
+  static const unsigned char  odigits[32] =
+  {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  };
+
+  static const unsigned char  ddigits[32] =
+  {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  };
+
+  static const unsigned char  hdigits[32] =
+  {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
+    0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  };
+
+
+#define isdigok( m, d )  (m[(d) >> 3] & ( 1 << ( (d) & 7 ) ) )
+
+
+  /* Routine to convert an ASCII string into an unsigned long integer. */
+  static unsigned long
+  _bdf_atoul( char*   s,
+              char**  end,
+              int     base )
+  {
+    unsigned long         v;
+    const unsigned char*  dmap;
+
+
+    if ( s == 0 || *s == 0 )
+      return 0;
+
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
+    }
+
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
+      base = 16;
+      dmap = hdigits;
+      s   += 2;
+    }
+
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = v * base + a2i[(int)*s];
+
+    if ( end != 0 )
+      *end = s;
+
+    return v;
+  }
+
+
+  /* Routine to convert an ASCII string into an signed long integer. */
+  static long
+  _bdf_atol( char*   s,
+             char**  end,
+             int     base )
+  {
+    long                  v, neg;
+    const unsigned char*  dmap;
+
+
+    if ( s == 0 || *s == 0 )
+      return 0;
+
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
+    }
+
+    /* Check for a minus sign. */
+    neg = 0;
+    if ( *s == '-' )
+    {
+      s++;
+      neg = 1;
+    }
+
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
+      base = 16;
+      dmap = hdigits;
+      s   += 2;
+    }
+
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = v * base + a2i[(int)*s];
+
+    if ( end != 0 )
+      *end = s;
+
+    return ( !neg ) ? v : -v;
+  }
+
+
+  /* Routine to convert an ASCII string into an signed short integer. */
+  static short
+  _bdf_atos( char*   s,
+             char**  end,
+             int     base )
+  {
+    short                 v, neg;
+    const unsigned char*  dmap;
+
+
+    if ( s == 0 || *s == 0 )
+      return 0;
+
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
+    }
+
+    /* Check for a minus. */
+    neg = 0;
+    if ( *s == '-' )
+    {
+      s++;
+      neg = 1;
+    }
+
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
+      base = 16;
+      dmap = hdigits;
+      s   += 2;
+    }
+
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = (short)( v * base + a2i[(int)*s] );
+
+    if ( end != 0 )
+      *end = s;
+
+    return (short)( ( !neg ) ? v : -v );
+  }
+
+
+  /* Routine to compare two glyphs by encoding so they can be sorted. */
+  static int
+  by_encoding( const void*  a,
+               const void*  b )
+  {
+    bdf_glyph_t  *c1, *c2;
+
+
+    c1 = (bdf_glyph_t *)a;
+    c2 = (bdf_glyph_t *)b;
+
+    if ( c1->encoding < c2->encoding )
+      return -1;
+    else if ( c1->encoding > c2->encoding )
+      return 1;
+
+    return 0;
+  }
+
+
+  static FT_Error
+  bdf_create_property( char*        name,
+                       int          format,
+                       bdf_font_t*  font )
+  {
+    unsigned long    n;
+    bdf_property_t*  p;
+    FT_Memory        memory = font->memory;
+    FT_Error         error = BDF_Err_Ok;
+
+
+    /* First check to see if the property has      */
+    /* already been added or not.  If it has, then */
+    /* simply ignore it.                           */
+    if ( hash_lookup( name, &(font->proptbl) ) )
+      goto Exit;
+
+    if ( font->nuser_props == 0 )
+    {
+      if ( FT_NEW_ARRAY( font->user_props, 1 ) )
+        goto Exit;
+    }
+    else
+    {
+      if ( FT_RENEW_ARRAY( font->user_props,
+                           font->nuser_props,
+                           font->nuser_props + 1 ) )
+        goto Exit;
+    }
+
+    p = font->user_props + font->nuser_props;
+    FT_MEM_ZERO( p, sizeof ( bdf_property_t ) );
+
+    n = (unsigned long)( ft_strlen( name ) + 1 );
+    if ( FT_NEW_ARRAY( p->name, n ) )
+      goto Exit;
+
+    FT_MEM_COPY( (char *)p->name, name, n );
+
+    p->format  = format;
+    p->builtin = 0;
+
+    n = _num_bdf_properties + font->nuser_props;
+
+    error = hash_insert( p->name, (void *)n, &(font->proptbl), memory );
+    if ( error )
+      goto Exit;
+
+    font->nuser_props++;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( bdf_property_t * )
+  bdf_get_property( char*        name,
+                    bdf_font_t*  font )
+  {
+    hashnode       hn;
+    unsigned long  propid;
+
+
+    if ( name == 0 || *name == 0 )
+      return 0;
+
+    if ( ( hn = hash_lookup( name, &(font->proptbl) ) ) == 0 )
+      return 0;
+
+    propid = (unsigned long)hn->data;
+    if ( propid >= _num_bdf_properties )
+      return font->user_props + ( propid - _num_bdf_properties );
+
+    return (bdf_property_t*)_bdf_properties + propid;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font file parsing flags and functions.                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Parse flags. */
+
+#define _BDF_START      0x0001
+#define _BDF_FONT_NAME  0x0002
+#define _BDF_SIZE       0x0004
+#define _BDF_FONT_BBX   0x0008
+#define _BDF_PROPS      0x0010
+#define _BDF_GLYPHS     0x0020
+#define _BDF_GLYPH      0x0040
+#define _BDF_ENCODING   0x0080
+#define _BDF_SWIDTH     0x0100
+#define _BDF_DWIDTH     0x0200
+#define _BDF_BBX        0x0400
+#define _BDF_BITMAP     0x0800
+
+#define _BDF_SWIDTH_ADJ  0x1000
+
+#define _BDF_GLYPH_BITS ( _BDF_GLYPH    | \
+                          _BDF_ENCODING | \
+                          _BDF_SWIDTH   | \
+                          _BDF_DWIDTH   | \
+                          _BDF_BBX      | \
+                          _BDF_BITMAP   )
+
+#define _BDF_GLYPH_WIDTH_CHECK   0x40000000L
+#define _BDF_GLYPH_HEIGHT_CHECK  0x80000000L
+
+
+  /* Auto correction messages. */
+#define ACMSG1   "FONT_ASCENT property missing.  " \
+                 "Added \"FONT_ASCENT %hd\".\n"
+#define ACMSG2   "FONT_DESCENT property missing.  " \
+                 "Added \"FONT_DESCENT %hd\".\n"
+#define ACMSG3   "Font width != actual width.  Old: %hd New: %hd.\n"
+#define ACMSG4   "Font left bearing != actual left bearing.  " \
+                 "Old: %hd New: %hd.\n"
+#define ACMSG5   "Font ascent != actual ascent.  Old: %hd New: %hd.\n"
+#define ACMSG6   "Font descent != actual descent.  Old: %hd New: %hd.\n"
+#define ACMSG7   "Font height != actual height. Old: %hd New: %hd.\n"
+#define ACMSG8   "Glyph scalable width (SWIDTH) adjustments made.\n"
+#define ACMSG9   "SWIDTH field missing at line %ld.  Set automatically.\n"
+#define ACMSG10  "DWIDTH field missing at line %ld.  Set to glyph width.\n"
+#define ACMSG11  "SIZE bits per pixel field adjusted to %hd.\n"
+#define ACMSG12  "Duplicate encoding %ld (%s) changed to unencoded.\n"
+#define ACMSG13  "Glyph %ld extra rows removed.\n"
+#define ACMSG14  "Glyph %ld extra columns removed.\n"
+#define ACMSG15  "Incorrect glyph count: %ld indicated but %ld found.\n"
+
+  /* Error messages. */
+#define ERRMSG1  "[line %ld] Missing \"%s\" line.\n"
+#define ERRMSG2  "[line %ld] Font header corrupted or missing fields.\n"
+#define ERRMSG3  "[line %ld] Font glyphs corrupted or missing fields.\n"
+
+
+  static FT_Error
+  _bdf_add_comment( bdf_font_t*    font,
+                    char*          comment,
+                    unsigned long  len )
+  {
+    char*      cp;
+    FT_Memory  memory = font->memory;
+    FT_Error   error = BDF_Err_Ok;
+
+
+    if ( font->comments_len == 0 )
+    {
+      if ( FT_NEW_ARRAY( font->comments, len + 1 ) )
+        goto Exit;
+    }
+    else
+    {
+      if ( FT_RENEW_ARRAY( font->comments,
+                           font->comments_len,
+                           font->comments_len + len + 1 ) )
+        goto Exit;
+    }
+
+    cp = font->comments + font->comments_len;
+    FT_MEM_COPY( cp, comment, len );
+    cp   += len;
+    *cp++ = '\n';
+    font->comments_len += len + 1;
+
+  Exit:
+    return error;
+  }
+
+
+  /* Set the spacing from the font name if it exists, or set it to the */
+  /* default specified in the options.                                 */
+  static FT_Error
+  _bdf_set_default_spacing( bdf_font_t*     font,
+                            bdf_options_t*  opts )
+  {
+    unsigned long  len;
+    char           name[128];
+    _bdf_list_t    list;
+    FT_Memory      memory;
+    FT_Error       error = BDF_Err_Ok;
+
+
+    if ( font == 0 || font->name == 0 || font->name[0] == 0 )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    memory = font->memory;
+
+    font->spacing = opts->font_spacing;
+
+    len = (unsigned long)( ft_strlen( font->name ) + 1 );
+    FT_MEM_COPY( name, font->name, len );
+
+    list.size = list.used = 0;
+
+    error = _bdf_split( (char *)"-", name, len, &list, memory );
+    if ( error )
+      goto Exit;
+
+    if ( list.used == 15 )
+    {
+      switch ( list.field[11][0] )
+      {
+      case 'C':
+      case 'c':
+        font->spacing = BDF_CHARCELL;
+        break;
+      case 'M':
+      case 'm':
+        font->spacing = BDF_MONOWIDTH;
+        break;
+      case 'P':
+      case 'p':
+        font->spacing = BDF_PROPORTIONAL;
+        break;
+      }
+    }
+
+    FT_FREE( list.field );
+
+  Exit:
+    return error;
+  }
+
+
+  /* Determine whether the property is an atom or not.  If it is, then */
+  /* clean it up so the double quotes are removed if they exist.       */
+  static int
+  _bdf_is_atom( char*          line,
+                unsigned long  linelen,
+                char**         name,
+                char**         value,
+                bdf_font_t*    font )
+  {
+    int              hold;
+    char             *sp, *ep;
+    bdf_property_t*  p;
+
+
+    *name = sp = ep = line;
+
+    while ( *ep && *ep != ' ' && *ep != '\t' )
+      ep++;
+
+    hold = -1;
+    if ( *ep )
+    {
+      hold = *ep;
+      *ep  = 0;
+    }
+
+    p = bdf_get_property( sp, font );
+
+    /* Restore the character that was saved before any return can happen. */
+    if ( hold != -1 )
+      *ep = (char)hold;
+
+    /* If the property exists and is not an atom, just return here. */
+    if ( p && p->format != BDF_ATOM )
+      return 0;
+
+    /* The property is an atom.  Trim all leading and trailing whitespace */
+    /* and double quotes for the atom value.                              */
+    sp = ep;
+    ep = line + linelen;
+
+    /* Trim the leading whitespace if it exists. */
+    *sp++ = 0;
+    while ( *sp                           &&
+            ( *sp == ' ' || *sp == '\t' ) )
+      sp++;
+
+    /* Trim the leading double quote if it exists. */
+    if ( *sp == '"' )
+      sp++;
+    *value = sp;
+
+    /* Trim the trailing whitespace if it exists. */
+    while ( ep > sp                                       &&
+            ( *( ep - 1 ) == ' ' || *( ep - 1 ) == '\t' ) )
+      *--ep = 0;
+
+    /* Trim the trailing double quote if it exists. */
+    if ( ep > sp && *( ep - 1 ) == '"' )
+      *--ep = 0;
+
+    return 1;
+  }
+
+
+  static FT_Error
+  _bdf_add_property( bdf_font_t*  font,
+                     char*        name,
+                     char*        value )
+  {
+    unsigned long   propid;
+    hashnode        hn;
+    int             len;
+    bdf_property_t  *prop, *fp;
+    FT_Memory       memory = font->memory;
+    FT_Error        error = BDF_Err_Ok;
+
+
+    /* First, check to see if the property already exists in the font. */
+    if ( ( hn = hash_lookup( name, (hashtable *)font->internal ) ) != 0 )
+    {
+      /* The property already exists in the font, so simply replace */
+      /* the value of the property with the current value.          */
+      fp = font->props + (unsigned long)hn->data;
+
+      switch ( fp->format )
+      {
+      case BDF_ATOM:
+        /* Delete the current atom if it exists. */
+        FT_FREE( fp->value.atom );
+
+        if ( value == 0 )
+          len = 1;
+        else
+          len = ft_strlen( value ) + 1;
+
+        if ( len > 1 )
+        {
+          if ( FT_NEW_ARRAY( fp->value.atom, len ) )
+            goto Exit;
+          FT_MEM_COPY( fp->value.atom, value, len );
+        }
+        else
+          fp->value.atom = 0;
+        break;
+
+      case BDF_INTEGER:
+        fp->value.int32 = _bdf_atol( value, 0, 10 );
+        break;
+
+      case BDF_CARDINAL:
+        fp->value.card32 = _bdf_atoul( value, 0, 10 );
+        break;
+
+      default:
+        ;
+      }
+
+      goto Exit;
+    }
+
+    /* See whether this property type exists yet or not. */
+    /* If not, create it.                                */
+    hn = hash_lookup( name, &(font->proptbl) );
+    if ( hn == 0 )
+    {
+      error = bdf_create_property( name, BDF_ATOM, font );
+      if ( error )
+        goto Exit;
+      hn = hash_lookup( name, &(font->proptbl) );
+    }
+
+    /* Allocate another property if this is overflow. */
+    if ( font->props_used == font->props_size )
+    {
+      if ( font->props_size == 0 )
+      {
+        if ( FT_NEW_ARRAY( font->props, 1 ) )
+          goto Exit;
+      }
+      else
+      {
+        if ( FT_RENEW_ARRAY( font->props,
+                             font->props_size,
+                             font->props_size + 1 ) )
+          goto Exit;
+      }
+
+      fp = font->props + font->props_size;
+      FT_MEM_ZERO( fp, sizeof ( bdf_property_t ) );
+      font->props_size++;
+    }
+
+    propid = (unsigned long)hn->data;
+    if ( propid >= _num_bdf_properties )
+      prop = font->user_props + ( propid - _num_bdf_properties );
+    else
+      prop = (bdf_property_t*)_bdf_properties + propid;
+
+    fp = font->props + font->props_used;
+
+    fp->name    = prop->name;
+    fp->format  = prop->format;
+    fp->builtin = prop->builtin;
+
+    switch ( prop->format )
+    {
+    case BDF_ATOM:
+      if ( value == 0 )
+        len = 1;
+      else
+        len = ft_strlen( value ) + 1;
+
+      if ( len > 1 )
+      {
+        if ( FT_NEW_ARRAY( fp->value.atom, len ) )
+          goto Exit;
+        FT_MEM_COPY( fp->value.atom, value, len );
+      }
+      else
+        fp->value.atom = 0;
+      break;
+
+    case BDF_INTEGER:
+      fp->value.int32 = _bdf_atol( value, 0, 10 );
+      break;
+
+    case BDF_CARDINAL:
+      fp->value.card32 = _bdf_atoul( value, 0, 10 );
+      break;
+    }
+
+    /* If the property happens to be a comment, then it doesn't need */
+    /* to be added to the internal hash table.                       */
+    if ( ft_memcmp( name, "COMMENT", 7 ) != 0 ) {
+      /* Add the property to the font property table. */
+      error = hash_insert( fp->name,
+                           (void *)font->props_used,
+                           (hashtable *)font->internal,
+                           memory );
+      if ( error )
+        goto Exit;
+    }
+
+    font->props_used++;
+
+    /* Some special cases need to be handled here.  The DEFAULT_CHAR       */
+    /* property needs to be located if it exists in the property list, the */
+    /* FONT_ASCENT and FONT_DESCENT need to be assigned if they are        */
+    /* present, and the SPACING property should override the default       */
+    /* spacing.                                                            */
+    if ( ft_memcmp( name, "DEFAULT_CHAR", 12 ) == 0 )
+      font->default_char = fp->value.int32;
+    else if ( ft_memcmp( name, "FONT_ASCENT", 11 ) == 0 )
+      font->font_ascent = fp->value.int32;
+    else if ( ft_memcmp( name, "FONT_DESCENT", 12 ) == 0 )
+      font->font_descent = fp->value.int32;
+    else if ( ft_memcmp( name, "SPACING", 7 ) == 0 )
+    {
+      if ( fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P' )
+        font->spacing = BDF_PROPORTIONAL;
+      else if ( fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M' )
+        font->spacing = BDF_MONOWIDTH;
+      else if ( fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C' )
+        font->spacing = BDF_CHARCELL;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  static const unsigned char nibble_mask[8] =
+  {
+    0xFF, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE
+  };
+
+
+  /* Actually parse the glyph info and bitmaps. */
+  static FT_Error
+  _bdf_parse_glyphs( char*          line,
+                     unsigned long  linelen,
+                     unsigned long  lineno,
+                     void*          call_data,
+                     void*          client_data )
+  {
+    int                c, mask_index;
+    char*              s;
+    unsigned char*     bp;
+    unsigned long      i, slen, nibbles;
+
+    _bdf_parse_t*      p;
+    bdf_glyph_t*       glyph;
+    bdf_font_t*        font;
+
+    FT_Memory          memory;
+    FT_Error           error = BDF_Err_Ok;
+
+    FT_UNUSED( call_data );
+    FT_UNUSED( lineno );        /* only used in debug mode */
+
+
+    p = (_bdf_parse_t *)client_data;
+
+    font   = p->font;
+    memory = font->memory;
+
+    /* Check for a comment. */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
+      linelen -= 7;
+
+      s = line + 7;
+      if ( *s != 0 )
+      {
+        s++;
+        linelen--;
+      }
+      error = _bdf_add_comment( p->font, s, linelen );
+      goto Exit;
+    }
+
+    /* The very first thing expected is the number of glyphs. */
+    if ( !( p->flags & _BDF_GLYPHS ) )
+    {
+      if ( ft_memcmp( line, "CHARS", 5 ) != 0 )
+      {
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "CHARS" ));
+        error = BDF_Err_Missing_Chars_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->cnt = font->glyphs_size = _bdf_atoul( p->list.field[1], 0, 10 );
+
+      /* Make sure the number of glyphs is non-zero. */
+      if ( p->cnt == 0 )
+        font->glyphs_size = 64;
+
+      if ( FT_NEW_ARRAY( font->glyphs, font->glyphs_size ) )
+        goto Exit;
+
+      p->flags |= _BDF_GLYPHS;
+
+      goto Exit;
+    }
+
+    /* Check for the ENDFONT field. */
+    if ( ft_memcmp( line, "ENDFONT", 7 ) == 0 )
+    {
+      /* Sort the glyphs by encoding. */
+      ft_qsort( (char *)font->glyphs,
+                font->glyphs_used,
+                sizeof ( bdf_glyph_t ),
+                by_encoding );
+
+      p->flags &= ~_BDF_START;
+
+      goto Exit;
+    }
+
+    /* Check for the ENDCHAR field. */
+    if ( ft_memcmp( line, "ENDCHAR", 7 ) == 0 )
+    {
+      p->glyph_enc = 0;
+      p->flags    &= ~_BDF_GLYPH_BITS;
+
+      goto Exit;
+    }
+
+    /* Check to see whether a glyph is being scanned but should be */
+    /* ignored because it is an unencoded glyph.                   */
+    if ( ( p->flags & _BDF_GLYPH )     &&
+         p->glyph_enc            == -1 &&
+         p->opts->keep_unencoded == 0  )
+      goto Exit;
+
+    /* Check for the STARTCHAR field. */
+    if ( ft_memcmp( line, "STARTCHAR", 9 ) == 0 )
+    {
+      /* Set the character name in the parse info first until the */
+      /* encoding can be checked for an unencoded character.      */
+      FT_FREE( p->glyph_name );
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list,memory );
+      if ( error )
+        goto Exit;
+      _bdf_shift( 1, &p->list );
+
+      s = _bdf_join( ' ', &slen, &p->list );
+
+      if ( FT_NEW_ARRAY( p->glyph_name, slen + 1 ) )
+        goto Exit;
+      FT_MEM_COPY( p->glyph_name, s, slen + 1 );
+
+      p->flags |= _BDF_GLYPH;
+
+      goto Exit;
+    }
+
+    /* Check for the ENCODING field. */
+    if ( ft_memcmp( line, "ENCODING", 8 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_GLYPH ) )
+      {
+        /* Missing STARTCHAR field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "STARTCHAR" ));
+        error = BDF_Err_Missing_Startchar_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->glyph_enc = _bdf_atol( p->list.field[1], 0, 10 );
+
+      /* Check to see whether this encoding has already been encountered. */
+      /* If it has then change it to unencoded so it gets added if        */
+      /* indicated.                                                       */
+      if ( p->glyph_enc >= 0 )
+      {
+        if ( _bdf_glyph_modified( p->have, p->glyph_enc ) )
+        {
+          /* Emit a message saying a glyph has been moved to the */
+          /* unencoded area.                                     */
+          FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG12,
+                      p->glyph_enc, p->glyph_name ));
+          p->glyph_enc = -1;
+          font->modified = 1;
+        }
+        else
+          _bdf_set_glyph_modified( p->have, p->glyph_enc );
+      }
+
+      if ( p->glyph_enc >= 0 )
+      {
+        /* Make sure there are enough glyphs allocated in case the */
+        /* number of characters happen to be wrong.                */
+        if ( font->glyphs_used == font->glyphs_size )
+        {
+          if ( FT_RENEW_ARRAY( font->glyphs,
+                               font->glyphs_size,
+                               font->glyphs_size + 64 ) )
+            goto Exit;
+          FT_MEM_ZERO( font->glyphs + font->glyphs_size,
+                       sizeof ( bdf_glyph_t ) * 64 ); /* FZ inutile */
+          font->glyphs_size += 64;
+        }
+
+        glyph           = font->glyphs + font->glyphs_used++;
+        glyph->name     = p->glyph_name;
+        glyph->encoding = p->glyph_enc;
+
+        /* Reset the initial glyph info. */
+        p->glyph_name = 0;
+      }
+      else
+      {
+        /* Unencoded glyph.  Check to see whether it should */
+        /* be added or not.                                 */
+        if ( p->opts->keep_unencoded != 0 )
+        {
+          /* Allocate the next unencoded glyph. */
+          if ( font->unencoded_used == font->unencoded_size )
+          {
+            if ( font->unencoded_size == 0 )
+            {
+              if ( FT_NEW_ARRAY( font->unencoded, 4 ) )
+                goto Exit;
+            }
+            else
+            {
+              if ( FT_RENEW_ARRAY( font->unencoded ,
+                                   font->unencoded_size,
+                                   font->unencoded_size + 4 ) )
+                goto Exit;
+            }
+            font->unencoded_size += 4;
+          }
+
+          glyph           = font->unencoded + font->unencoded_used;
+          glyph->name     = p->glyph_name;
+          glyph->encoding = font->unencoded_used++;
+        }
+        else
+          /* Free up the glyph name if the unencoded shouldn't be */
+          /* kept.                                                */
+          FT_FREE( p->glyph_name );
+
+        p->glyph_name = 0;
+      }
+
+      /* Clear the flags that might be added when width and height are */
+      /* checked for consistency.                                      */
+      p->flags &= ~( _BDF_GLYPH_WIDTH_CHECK | _BDF_GLYPH_HEIGHT_CHECK );
+
+      p->flags |= _BDF_ENCODING;
+
+      goto Exit;
+    }
+
+    /* Point at the glyph being constructed. */
+    if ( p->glyph_enc == -1 )
+      glyph = font->unencoded + ( font->unencoded_used - 1 );
+    else
+      glyph = font->glyphs + ( font->glyphs_used - 1 );
+
+    /* Check to see whether a bitmap is being constructed. */
+    if ( p->flags & _BDF_BITMAP )
+    {
+      /* If there are more rows than are specified in the glyph metrics, */
+      /* ignore the remaining lines.                                     */
+      if ( p->row >= (unsigned long)glyph->bbx.height )
+      {
+        if ( !( p->flags & _BDF_GLYPH_HEIGHT_CHECK ) )
+        {
+          FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG13, glyph->encoding ));
+          p->flags |= _BDF_GLYPH_HEIGHT_CHECK;
+          font->modified = 1;
+        }
+
+        goto Exit;
+      }
+
+      /* Only collect the number of nibbles indicated by the glyph     */
+      /* metrics.  If there are more columns, they are simply ignored. */
+      nibbles = glyph->bpr << 1;
+      bp      = glyph->bitmap + p->row * glyph->bpr;
+
+      for ( i = 0, *bp = 0; i < nibbles; i++ )
+      {
+        c = line[i];
+        *bp = (FT_Byte)( ( *bp << 4 ) + a2i[c] );
+        if ( i + 1 < nibbles && ( i & 1 ) )
+          *++bp = 0;
+      }
+
+      /* Remove possible garbage at the right. */
+      mask_index = ( glyph->bbx.width * p->font->bpp ) & 7;
+      *bp &= nibble_mask[mask_index];
+
+      /* If any line has extra columns, indicate they have been removed. */
+      if ( ( line[nibbles] == '0' || a2i[(int)line[nibbles]] != 0 ) &&
+           !( p->flags & _BDF_GLYPH_WIDTH_CHECK )                   )
+      {
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG14, glyph->encoding ));
+        p->flags       |= _BDF_GLYPH_WIDTH_CHECK;
+        font->modified  = 1;
+      }
+
+      p->row++;
+      goto Exit;
+    }
+
+    /* Expect the SWIDTH (scalable width) field next. */
+    if ( ft_memcmp( line, "SWIDTH", 6 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_ENCODING ) )
+      {
+        /* Missing ENCODING field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "ENCODING" ));
+        error = BDF_Err_Missing_Encoding_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      glyph->swidth = (unsigned short)_bdf_atoul( p->list.field[1], 0, 10 );
+      p->flags |= _BDF_SWIDTH;
+
+      goto Exit;
+    }
+
+    /* Expect the DWIDTH (scalable width) field next. */
+    if ( ft_memcmp( line, "DWIDTH", 6 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list,memory );
+      if ( error )
+        goto Exit;
+      glyph->dwidth = (unsigned short)_bdf_atoul( p->list.field[1], 0, 10 );
+
+      if ( !( p->flags & _BDF_SWIDTH ) )
+      {
+        /* Missing SWIDTH field.  Emit an auto correction message and set */
+        /* the scalable width from the device width.                      */
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG9, lineno ));
+
+        glyph->swidth = (unsigned short)FT_MulDiv(
+                          glyph->dwidth, 72000L,
+                          (FT_Long)( font->point_size *
+                                     font->resolution_x ) );
+      }
+
+      p->flags |= _BDF_DWIDTH;
+      goto Exit;
+    }
+
+    /* Expect the BBX field next. */
+    if ( ft_memcmp( line, "BBX", 3 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+
+      glyph->bbx.width    = _bdf_atos( p->list.field[1], 0, 10 );
+      glyph->bbx.height   = _bdf_atos( p->list.field[2], 0, 10 );
+      glyph->bbx.x_offset = _bdf_atos( p->list.field[3], 0, 10 );
+      glyph->bbx.y_offset = _bdf_atos( p->list.field[4], 0, 10 );
+
+      /* Generate the ascent and descent of the character. */
+      glyph->bbx.ascent  = (short)( glyph->bbx.height + glyph->bbx.y_offset );
+      glyph->bbx.descent = (short)( -glyph->bbx.y_offset );
+
+      /* Determine the overall font bounding box as the characters are */
+      /* loaded so corrections can be done later if indicated.         */
+      p->maxas    = (short)FT_MAX( glyph->bbx.ascent, p->maxas );
+      p->maxds    = (short)FT_MAX( glyph->bbx.descent, p->maxds );
+
+      p->rbearing = (short)( glyph->bbx.width + glyph->bbx.x_offset );
+
+      p->maxrb    = (short)FT_MAX( p->rbearing, p->maxrb );
+      p->minlb    = (short)FT_MIN( glyph->bbx.x_offset, p->minlb );
+      p->maxlb    = (short)FT_MAX( glyph->bbx.x_offset, p->maxlb );
+
+      if ( !( p->flags & _BDF_DWIDTH ) )
+      {
+        /* Missing DWIDTH field.  Emit an auto correction message and set */
+        /* the device width to the glyph width.                           */
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG10, lineno ));
+        glyph->dwidth = glyph->bbx.width;
+      }
+
+      /* If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH */
+      /* value if necessary.                                            */
+      if ( p->opts->correct_metrics != 0 )
+      {
+        /* Determine the point size of the glyph. */
+        unsigned short  sw = (unsigned short)FT_MulDiv(
+                               glyph->dwidth, 72000L,
+                               (FT_Long)( font->point_size *
+                                          font->resolution_x ) );
+
+
+        if ( sw != glyph->swidth )
+        {
+          glyph->swidth = sw;
+
+          if ( p->glyph_enc == -1 )
+            _bdf_set_glyph_modified( font->umod,
+                                     font->unencoded_used - 1 );
+          else
+            _bdf_set_glyph_modified( font->nmod, glyph->encoding );
+
+          p->flags       |= _BDF_SWIDTH_ADJ;
+          font->modified  = 1;
+        }
+      }
+
+      p->flags |= _BDF_BBX;
+      goto Exit;
+    }
+
+    /* And finally, gather up the bitmap. */
+    if ( ft_memcmp( line, "BITMAP", 6 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_BBX ) )
+      {
+        /* Missing BBX field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "BBX" ));
+        error = BDF_Err_Missing_Bbx_Field;
+        goto Exit;
+      }
+
+      /* Allocate enough space for the bitmap. */
+      glyph->bpr   = ( glyph->bbx.width * p->font->bpp + 7 ) >> 3;
+      glyph->bytes = (unsigned short)( glyph->bpr * glyph->bbx.height );
+
+      if ( FT_NEW_ARRAY( glyph->bitmap, glyph->bytes ) )
+        goto Exit;
+
+      p->row    = 0;
+      p->flags |= _BDF_BITMAP;
+
+      goto Exit;
+    }
+
+    error = BDF_Err_Invalid_File_Format;
+
+  Exit:
+    return error;
+  }
+
+
+  /* Load the font properties. */
+  static FT_Error
+  _bdf_parse_properties( char*          line,
+                         unsigned long  linelen,
+                         unsigned long  lineno,
+                         void*          call_data,
+                         void*          client_data )
+  {
+    unsigned long      vlen;
+    _bdf_line_func_t*  next;
+    _bdf_parse_t*      p;
+    char*              name;
+    char*              value;
+    char               nbuf[128];
+    FT_Memory          memory;
+    FT_Error           error = BDF_Err_Ok;
+
+    FT_UNUSED( lineno );
+
+
+    next = (_bdf_line_func_t *)call_data;
+    p    = (_bdf_parse_t *)    client_data;
+
+    memory = p->font->memory;
+
+    /* Check for the end of the properties. */
+    if ( ft_memcmp( line, "ENDPROPERTIES", 13 ) == 0 )
+    {
+      /* If the FONT_ASCENT or FONT_DESCENT properties have not been      */
+      /* encountered yet, then make sure they are added as properties and */
+      /* make sure they are set from the font bounding box info.          */
+      /*                                                                  */
+      /* This is *always* done regardless of the options, because X11     */
+      /* requires these two fields to compile fonts.                      */
+      if ( bdf_get_font_property( p->font, "FONT_ASCENT" ) == 0 )
+      {
+        p->font->font_ascent = p->font->bbx.ascent;
+        ft_sprintf( nbuf, "%hd", p->font->bbx.ascent );
+        error = _bdf_add_property( p->font, (char *)"FONT_ASCENT", nbuf );
+        if ( error )
+          goto Exit;
+
+        FT_TRACE2(( "_bdf_parse_properties: " ACMSG1, p->font->bbx.ascent ));
+        p->font->modified = 1;
+      }
+
+      if ( bdf_get_font_property( p->font, "FONT_DESCENT" ) == 0 )
+      {
+        p->font->font_descent = p->font->bbx.descent;
+        ft_sprintf( nbuf, "%hd", p->font->bbx.descent );
+        error = _bdf_add_property( p->font, (char *)"FONT_DESCENT", nbuf );
+        if ( error )
+          goto Exit;
+
+        FT_TRACE2(( "_bdf_parse_properties: " ACMSG2, p->font->bbx.descent ));
+        p->font->modified = 1;
+      }
+
+      p->flags &= ~_BDF_PROPS;
+      *next     = _bdf_parse_glyphs;
+
+      goto Exit;
+    }
+
+    /* Ignore the _XFREE86_GLYPH_RANGES properties. */
+    if ( ft_memcmp( line, "_XFREE86_GLYPH_RANGES", 21 ) == 0 )
+      goto Exit;
+
+    /* Handle COMMENT fields and properties in a special way to preserve */
+    /* the spacing.                                                      */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
+      name = value = line;
+      value += 7;
+      if ( *value )
+        *value++ = 0;
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+    else if ( _bdf_is_atom( line, linelen, &name, &value, p->font ) )
+    {
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+    else
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      name = p->list.field[0];
+
+      _bdf_shift( 1, &p->list );
+      value = _bdf_join( ' ', &vlen, &p->list );
+
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* Load the font header. */
+  static FT_Error
+  _bdf_parse_start( char*          line,
+                    unsigned long  linelen,
+                    unsigned long  lineno,
+                    void*          call_data,
+                    void*          client_data )
+  {
+    unsigned long      slen;
+    _bdf_line_func_t*  next;
+    _bdf_parse_t*      p;
+    bdf_font_t*        font;
+    char               *s;
+
+    FT_Memory          memory = NULL;
+    FT_Error           error  = BDF_Err_Ok;
+
+    FT_UNUSED( lineno );            /* only used in debug mode */
+
+
+    next = (_bdf_line_func_t *)call_data;
+    p    = (_bdf_parse_t *)    client_data;
+
+    if ( p->font )
+      memory = p->font->memory;
+
+    /* Check for a comment.  This is done to handle those fonts that have */
+    /* comments before the STARTFONT line for some reason.                */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
+      if ( p->opts->keep_comments != 0 && p->font != 0 )
+      {
+        linelen -= 7;
+
+        s = line + 7;
+        if ( *s != 0 )
+        {
+          s++;
+          linelen--;
+        }
+
+        error = _bdf_add_comment( p->font, s, linelen );
+        if ( error )
+          goto Exit;
+        /* here font is not defined! */
+      }
+
+      goto Exit;
+    }
+
+    if ( !( p->flags & _BDF_START ) )
+    {
+      memory = p->memory;
+
+      if ( ft_memcmp( line, "STARTFONT", 9 ) != 0 )
+      {
+        /* No STARTFONT field is a good indication of a problem. */
+        error = BDF_Err_Missing_Startfont_Field;
+        goto Exit;
+      }
+
+      p->flags = _BDF_START;
+      font = p->font = 0;
+
+      if ( FT_NEW( font ) )
+        goto Exit;
+      p->font = font;
+
+      font->memory = p->memory;
+      p->memory    = 0;
+
+      { /* setup */
+        unsigned long    i;
+        bdf_property_t*  prop;
+
+
+        error = hash_init( &(font->proptbl), memory );
+        if ( error )
+          goto Exit;
+        for ( i = 0, prop = (bdf_property_t*)_bdf_properties;
+              i < _num_bdf_properties; i++, prop++ )
+        {
+          error = hash_insert( prop->name, (void *)i,
+                               &(font->proptbl), memory );
+          if ( error )
+            goto Exit;
+        }
+      }
+
+      if ( FT_ALLOC( p->font->internal, sizeof ( hashtable ) ) )
+        goto Exit;
+      error = hash_init( (hashtable *)p->font->internal,memory );
+      if ( error )
+        goto Exit;
+      p->font->spacing      = p->opts->font_spacing;
+      p->font->default_char = -1;
+
+      goto Exit;
+    }
+
+    /* Check for the start of the properties. */
+    if ( ft_memcmp( line, "STARTPROPERTIES", 15 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->cnt = p->font->props_size = _bdf_atoul( p->list.field[1], 0, 10 );
+
+      if ( FT_NEW_ARRAY( p->font->props, p->cnt ) )
+        goto Exit;
+
+      p->flags |= _BDF_PROPS;
+      *next     = _bdf_parse_properties;
+
+      goto Exit;
+    }
+
+    /* Check for the FONTBOUNDINGBOX field. */
+    if ( ft_memcmp( line, "FONTBOUNDINGBOX", 15 ) == 0 )
+    {
+      if ( !(p->flags & _BDF_SIZE ) )
+      {
+        /* Missing the SIZE field. */
+        FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "SIZE" ));
+        error = BDF_Err_Missing_Size_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list , memory );
+      if ( error )
+        goto Exit;
+
+      p->font->bbx.width  = _bdf_atos( p->list.field[1], 0, 10 );
+      p->font->bbx.height = _bdf_atos( p->list.field[2], 0, 10 );
+
+      p->font->bbx.x_offset = _bdf_atos( p->list.field[3], 0, 10 );
+      p->font->bbx.y_offset = _bdf_atos( p->list.field[4], 0, 10 );
+
+      p->font->bbx.ascent  = (short)( p->font->bbx.height +
+                                      p->font->bbx.y_offset );
+
+      p->font->bbx.descent = (short)( -p->font->bbx.y_offset );
+
+      p->flags |= _BDF_FONT_BBX;
+
+      goto Exit;
+    }
+
+    /* The next thing to check for is the FONT field. */
+    if ( ft_memcmp( line, "FONT", 4 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list , memory );
+      if ( error )
+        goto Exit;
+      _bdf_shift( 1, &p->list );
+
+      s = _bdf_join( ' ', &slen, &p->list );
+      if ( FT_NEW_ARRAY( p->font->name, slen + 1 ) )
+        goto Exit;
+      FT_MEM_COPY( p->font->name, s, slen + 1 );
+
+      /* If the font name is an XLFD name, set the spacing to the one in  */
+      /* the font name.  If there is no spacing fall back on the default. */
+      error = _bdf_set_default_spacing( p->font, p->opts );
+      if ( error )
+        goto Exit;
+
+      p->flags |= _BDF_FONT_NAME;
+
+      goto Exit;
+    }
+
+    /* Check for the SIZE field. */
+    if ( ft_memcmp( line, "SIZE", 4 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_FONT_NAME ) )
+      {
+        /* Missing the FONT field. */
+        FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "FONT" ));
+        error = BDF_Err_Missing_Font_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+
+      p->font->point_size   = _bdf_atoul( p->list.field[1], 0, 10 );
+      p->font->resolution_x = _bdf_atoul( p->list.field[2], 0, 10 );
+      p->font->resolution_y = _bdf_atoul( p->list.field[3], 0, 10 );
+
+      /* Check for the bits per pixel field. */
+      if ( p->list.used == 5 )
+      {
+        unsigned short bitcount, i, shift;
+
+
+        p->font->bpp = (unsigned short)_bdf_atos( p->list.field[4], 0, 10 );
+
+        /* Only values 1, 2, 4, 8 are allowed. */
+        shift = p->font->bpp;
+        bitcount = 0;
+        for ( i = 0; shift > 0; i++ )
+        {
+          if ( shift & 1 )
+            bitcount = i;
+          shift >>= 1;
+        }
+
+        shift = (short)( ( bitcount > 3 ) ? 8 : ( 1 << bitcount ) );
+
+        if ( p->font->bpp > shift || p->font->bpp != shift )
+        {
+          /* select next higher value */
+          p->font->bpp = (unsigned short)( shift << 1 );
+          FT_TRACE2(( "_bdf_parse_start: " ACMSG11, p->font->bpp ));
+        }
+      }
+      else
+        p->font->bpp = 1;
+
+      p->flags |= _BDF_SIZE;
+
+      goto Exit;
+    }
+
+    error = BDF_Err_Invalid_File_Format;
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* API.                                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  bdf_load_font( FT_Stream       stream,
+                 FT_Memory       extmemory,
+                 bdf_options_t*  opts,
+                 bdf_font_t*    *font )
+  {
+    unsigned long  lineno;
+    _bdf_parse_t   *p;
+
+    FT_Memory      memory = extmemory;
+    FT_Error       error  = BDF_Err_Ok;
+
+
+    if ( FT_ALLOC( p, sizeof ( _bdf_parse_t ) ) )
+      goto Exit;
+
+    memory    = NULL;
+    p->opts   = (bdf_options_t*)( ( opts != 0 ) ? opts : &_bdf_opts );
+    p->minlb  = 32767;
+    p->memory = extmemory;  /* only during font creation */
+
+    error = _bdf_readstream( stream, _bdf_parse_start,
+                             (void *)p, &lineno );
+    if ( error )
+      goto Exit;
+
+    if ( p->font != 0 )
+    {
+      /* If the font is not proportional, set the font's monowidth */
+      /* field to the width of the font bounding box.              */
+      memory = p->font->memory;
+
+      if ( p->font->spacing != BDF_PROPORTIONAL )
+        p->font->monowidth = p->font->bbx.width;
+
+      /* If the number of glyphs loaded is not that of the original count, */
+      /* indicate the difference.                                          */
+      if ( p->cnt != p->font->glyphs_used + p->font->unencoded_used )
+      {
+        FT_TRACE2(( "bdf_load_font: " ACMSG15, p->cnt,
+                    p->font->glyphs_used + p->font->unencoded_used ));
+        p->font->modified = 1;
+      }
+
+      /* Once the font has been loaded, adjust the overall font metrics if */
+      /* necessary.                                                        */
+      if ( p->opts->correct_metrics != 0 &&
+           ( p->font->glyphs_used > 0 || p->font->unencoded_used > 0 ) )
+      {
+        if ( p->maxrb - p->minlb != p->font->bbx.width )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG3,
+                      p->font->bbx.width, p->maxrb - p->minlb ));
+          p->font->bbx.width = (unsigned short)( p->maxrb - p->minlb );
+          p->font->modified  = 1;
+        }
+
+        if ( p->font->bbx.x_offset != p->minlb )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG4,
+                      p->font->bbx.x_offset, p->minlb ));
+          p->font->bbx.x_offset = p->minlb;
+          p->font->modified     = 1;
+        }
+
+        if ( p->font->bbx.ascent != p->maxas )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG5,
+                      p->font->bbx.ascent, p->maxas ));
+          p->font->bbx.ascent = p->maxas;
+          p->font->modified   = 1;
+        }
+
+        if ( p->font->bbx.descent != p->maxds )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG6,
+                      p->font->bbx.descent, p->maxds ));
+          p->font->bbx.descent  = p->maxds;
+          p->font->bbx.y_offset = (short)( -p->maxds );
+          p->font->modified     = 1;
+        }
+
+        if ( p->maxas + p->maxds != p->font->bbx.height )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG7,
+                      p->font->bbx.height, p->maxas + p->maxds ));
+          p->font->bbx.height = (unsigned short)( p->maxas + p->maxds );
+        }
+
+        if ( p->flags & _BDF_SWIDTH_ADJ )
+          FT_TRACE2(( "bdf_load_font: " ACMSG8 ));
+      }
+    }
+
+    if ( p->flags & _BDF_START )
+    {
+      {
+        /* The ENDFONT field was never reached or did not exist. */
+        if ( !( p->flags & _BDF_GLYPHS ) )
+          /* Error happened while parsing header. */
+          FT_ERROR(( "bdf_load_font: " ERRMSG2, lineno ));
+        else
+          /* Error happened when parsing glyphs. */
+          FT_ERROR(( "bdf_load_font: " ERRMSG3, lineno ));
+      }
+    }
+
+    /* Free up the list used during the parsing. */
+    if ( memory != NULL )
+      FT_FREE( p->list.field );
+
+    if ( p->font != 0 )
+    {
+      /* Make sure the comments are NULL terminated if they exist. */
+      memory = p->font->memory;
+
+      if ( p->font->comments_len > 0 ) {
+        if ( FT_RENEW_ARRAY( p->font->comments,
+                             p->font->comments_len,
+                             p->font->comments_len + 1 ) )
+          goto Exit;
+
+        p->font->comments[p->font->comments_len] = 0;
+      }
+    }
+    else if ( error == BDF_Err_Ok )
+      error = BDF_Err_Invalid_File_Format;
+
+    *font = p->font;
+
+  Exit:
+    if ( p )
+    {
+      memory = extmemory;
+      FT_FREE( p );
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  bdf_free_font( bdf_font_t*  font )
+  {
+    bdf_property_t*  prop;
+    unsigned long    i;
+    bdf_glyph_t*     glyphs;
+    FT_Memory        memory;
+
+
+    if ( font == 0 )
+      return;
+
+    memory = font->memory;
+
+    FT_FREE( font->name );
+
+    /* Free up the internal hash table of property names. */
+    if ( font->internal )
+    {
+      hash_free( (hashtable *)font->internal, memory );
+      FT_FREE( font->internal );
+    }
+
+    /* Free up the comment info. */
+    FT_FREE( font->comments );
+
+    /* Free up the properties. */
+    for ( i = 0; i < font->props_size; i++ )
+    {
+      if ( font->props[i].format == BDF_ATOM )
+        FT_FREE( font->props[i].value.atom );
+    }
+
+    FT_FREE( font->props );
+
+    /* Free up the character info. */
+    for ( i = 0, glyphs = font->glyphs;
+          i < font->glyphs_used; i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    for ( i = 0, glyphs = font->unencoded; i < font->unencoded_used;
+          i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    FT_FREE( font->glyphs );
+    FT_FREE( font->unencoded );
+
+    /* Free up the overflow storage if it was used. */
+    for ( i = 0, glyphs = font->overflow.glyphs;
+          i < font->overflow.glyphs_used; i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    FT_FREE( font->overflow.glyphs );
+
+    /* bdf_cleanup */
+    hash_free( &(font->proptbl), memory );
+
+    /* Free up the user defined properties. */
+    for (prop = font->user_props, i = 0;
+         i < font->nuser_props; i++, prop++ )
+    {
+      FT_FREE( prop->name );
+      if ( prop->format == BDF_ATOM )
+        FT_FREE( prop->value.atom );
+    }
+
+    FT_FREE( font->user_props );
+
+    /* FREE( font ); */ /* XXX Fixme */
+  }
+
+
+  FT_LOCAL_DEF( bdf_property_t * )
+  bdf_get_font_property( bdf_font_t*  font,
+                         const char*  name )
+  {
+    hashnode  hn;
+
+
+    if ( font == 0 || font->props_size == 0 || name == 0 || *name == 0 )
+      return 0;
+
+    hn = hash_lookup( name, (hashtable *)font->internal );
+
+    return hn ? ( font->props + (unsigned long)hn->data ) : 0;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/bdf/descrip.mms b/nx-X11/extras/freetype2/src/bdf/descrip.mms
new file mode 100644
index 000000000..4c32dc449
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 BDF driver compilation rules for VMS
+#
+
+
+# Copyright 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.bdf])
+
+OBJS=bdf.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/bdf/module.mk b/nx-X11/extras/freetype2/src/bdf/module.mk
new file mode 100644
index 000000000..24115e75d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/module.mk
@@ -0,0 +1,31 @@
+#
+# FreeType 2 BDF module definition
+#
+
+# Copyright 2001, 2002 by
+# Francesco Zappa Nardelli
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+make_module_list: add_bdf_driver
+
+add_bdf_driver:
+	$(OPEN_DRIVER)bdf_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)bdf    $(ECHO_DRIVER_DESC)bdf bitmap fonts$(ECHO_DRIVER_DONE)
+
diff --git a/nx-X11/extras/freetype2/src/bdf/rules.mk b/nx-X11/extras/freetype2/src/bdf/rules.mk
new file mode 100644
index 000000000..25d98e55b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/bdf/rules.mk
@@ -0,0 +1,80 @@
+#
+# FreeType 2 bdf driver configuration rules
+#
+
+
+# Copyright (C) 2001, 2002, 2003 by
+# Francesco Zappa Nardelli
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+
+
+# bdf driver directory
+#
+BDF_DIR  := $(SRC_DIR)/bdf
+
+
+BDF_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(BDF_DIR))
+
+
+# bdf driver sources (i.e., C files)
+#
+BDF_DRV_SRC := $(BDF_DIR)/bdflib.c \
+               $(BDF_DIR)/bdfdrivr.c
+
+
+# bdf driver headers
+#
+BDF_DRV_H := $(BDF_DIR)/bdf.h \
+             $(BDF_DIR)/bdfdrivr.h
+
+# bdf driver object(s)
+#
+#   BDF_DRV_OBJ_M is used during `multi' builds
+#   BDF_DRV_OBJ_S is used during `single' builds
+#
+BDF_DRV_OBJ_M := $(BDF_DRV_SRC:$(BDF_DIR)/%.c=$(OBJ_DIR)/%.$O)
+BDF_DRV_OBJ_S := $(OBJ_DIR)/bdf.$O
+
+# bdf driver source file for single build
+#
+BDF_DRV_SRC_S := $(BDF_DIR)/bdf.c
+
+
+# bdf driver - single object
+#
+$(BDF_DRV_OBJ_S): $(BDF_DRV_SRC_S) $(BDF_DRV_SRC) $(FREETYPE_H) $(BDF_DRV_H)
+	$(BDF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(BDF_DRV_SRC_S))
+
+
+# bdf driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(BDF_DIR)/%.c $(FREETYPE_H) $(BDF_DRV_H)
+	$(BDF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(BDF_DRV_OBJ_S)
+DRV_OBJS_M += $(BDF_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cache/Jamfile b/nx-X11/extras/freetype2/src/cache/Jamfile
new file mode 100644
index 000000000..b269c9557
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/Jamfile
@@ -0,0 +1,35 @@
+# FreeType 2 src/cache Jamfile (c) 2001, 2003, 2004 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) cache ;
+
+# The file <freetype/ftcache.h> contains some macro definitions that are
+# later used in #include statements related to the cache sub-system.  It
+# needs to be parsed through a HDRMACRO rule for macro definitions.
+#
+HDRMACRO  [ FT2_SubDir  include ftcache.h ] ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = ftcmru
+               ftcmanag
+               ftccache
+               ftcglyph
+               ftcsbits
+               ftcimage
+               ftcbasic
+               ftccmap
+               ;
+  }
+  else
+  {
+    _sources = ftcache ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/cache Jamfile
diff --git a/nx-X11/extras/freetype2/src/cache/descrip.mms b/nx-X11/extras/freetype2/src/cache/descrip.mms
new file mode 100644
index 000000000..4d967dc18
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/descrip.mms
@@ -0,0 +1,25 @@
+#
+# FreeType 2 Cache compilation rules for VMS
+#
+
+
+# Copyright 2001, 2002, 2003, 2004 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.cache])
+
+OBJS=ftcache.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+ftcache.obj : ftcache.c
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cache/ftcache.c b/nx-X11/extras/freetype2/src/cache/ftcache.c
new file mode 100644
index 000000000..d41e91e5e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftcache.c
@@ -0,0 +1,31 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcache.c                                                              */
+/*                                                                         */
+/*    The FreeType Caching sub-system (body only).                         */
+/*                                                                         */
+/*  Copyright 2000-2001, 2003 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 "ftcmru.c"
+#include "ftcmanag.c"
+#include "ftccache.c"
+#include "ftccmap.c"
+#include "ftcglyph.c"
+#include "ftcimage.c"
+#include "ftcsbits.c"
+#include "ftcbasic.c"
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftcbasic.c b/nx-X11/extras/freetype2/src/cache/ftcbasic.c
new file mode 100644
index 000000000..9a91f357b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftcbasic.c
@@ -0,0 +1,445 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcbasic.c                                                             */
+/*                                                                         */
+/*    The FreeType basic cache interface (body).                           */
+/*                                                                         */
+/*  Copyright 2003, 2004 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_CACHE_H
+#include FT_CACHE_INTERNAL_GLYPH_H
+#include FT_CACHE_INTERNAL_IMAGE_H
+#include FT_CACHE_INTERNAL_SBITS_H
+#include FT_INTERNAL_MEMORY_H
+
+#include "ftccback.h"
+#include "ftcerror.h"
+
+
+  /*
+   *  Basic Families
+   *
+   */
+  typedef struct  FTC_BasicAttrRec_
+  {
+    FTC_ScalerRec  scaler;
+    FT_UInt        load_flags;
+
+  } FTC_BasicAttrRec, *FTC_BasicAttrs;
+
+#define FTC_BASIC_ATTR_COMPARE( a, b )                           \
+          ( FTC_SCALER_COMPARE( &(a)->scaler, &(b)->scaler ) &&  \
+            (a)->load_flags == (b)->load_flags               )
+
+#define FTC_BASIC_ATTR_HASH( a )                                   \
+          ( FTC_SCALER_HASH( &(a)->scaler ) + 31*(a)->load_flags )
+
+
+  typedef struct  FTC_BasicQueryRec_
+  {
+    FTC_GQueryRec     gquery;
+    FTC_BasicAttrRec  attrs;
+
+  } FTC_BasicQueryRec, *FTC_BasicQuery;
+
+
+  typedef struct  FTC_BasicFamilyRec_
+  {
+    FTC_FamilyRec     family;
+    FTC_BasicAttrRec  attrs;
+
+  } FTC_BasicFamilyRec, *FTC_BasicFamily;
+
+
+  FT_CALLBACK_DEF( FT_Bool )
+  ftc_basic_family_compare( FTC_MruNode  ftcfamily,
+                            FT_Pointer   ftcquery )
+  {
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
+
+
+    return FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ftc_basic_family_init( FTC_MruNode  ftcfamily,
+                         FT_Pointer   ftcquery,
+                         FT_Pointer   ftccache )
+  {
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
+    FTC_Cache        cache  = (FTC_Cache)ftccache;
+
+
+    FTC_Family_Init( FTC_FAMILY( family ), cache );
+    family->attrs = query->attrs;
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  ftc_basic_family_get_count( FTC_Family   ftcfamily,
+                              FTC_Manager  manager )
+  {
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FT_Error         error;
+    FT_Face          face;
+    FT_UInt          result = 0;
+
+
+    error = FTC_Manager_LookupFace( manager, family->attrs.scaler.face_id,
+                                    &face );
+    if ( !error )
+      result = face->num_glyphs;
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ftc_basic_family_load_bitmap( FTC_Family   ftcfamily,
+                                FT_UInt      gindex,
+                                FTC_Manager  manager,
+                                FT_Face     *aface )
+  {
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FT_Error         error;
+    FT_Size          size;
+
+
+    error = FTC_Manager_LookupSize( manager, &family->attrs.scaler, &size );
+    if ( !error )
+    {
+      FT_Face  face = size->face;
+
+
+      error = FT_Load_Glyph( face, gindex,
+                             family->attrs.load_flags | FT_LOAD_RENDER );
+      if ( !error )
+        *aface = face;
+    }
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ftc_basic_family_load_glyph( FTC_Family  ftcfamily,
+                               FT_UInt     gindex,
+                               FTC_Cache   cache,
+                               FT_Glyph   *aglyph )
+  {
+    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
+    FT_Error         error;
+    FTC_Scaler       scaler = &family->attrs.scaler;
+    FT_Face          face;
+    FT_Size          size;
+
+
+    /* we will now load the glyph image */
+    error = FTC_Manager_LookupSize( cache->manager,
+                                    scaler,
+                                    &size );
+    if ( !error )
+    {
+      face = size->face;
+
+      error = FT_Load_Glyph( face, gindex, family->attrs.load_flags );
+      if ( !error )
+      {
+        if ( face->glyph->format == FT_GLYPH_FORMAT_BITMAP  ||
+             face->glyph->format == FT_GLYPH_FORMAT_OUTLINE )
+        {
+          /* ok, copy it */
+          FT_Glyph  glyph;
+
+
+          error = FT_Get_Glyph( face->glyph, &glyph );
+          if ( !error )
+          {
+            *aglyph = glyph;
+            goto Exit;
+          }
+        }
+        else
+          error = FTC_Err_Invalid_Argument;
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Bool )
+  ftc_basic_gnode_compare_faceid( FTC_Node    ftcgnode,
+                                  FT_Pointer  ftcface_id,
+                                  FTC_Cache   cache )
+  {
+    FTC_GNode        gnode   = (FTC_GNode)ftcgnode;
+    FTC_FaceID       face_id = (FTC_FaceID)ftcface_id;
+    FTC_BasicFamily  family  = (FTC_BasicFamily)gnode->family;
+    FT_Bool          result;
+
+
+    result = FT_BOOL( family->attrs.scaler.face_id == face_id );
+    if ( result )
+    {
+      /* we must call this function to avoid this node from appearing
+       * in later lookups with the same face_id!
+       */
+      FTC_GNode_UnselectFamily( gnode, cache );
+    }
+    return result;
+  }
+
+
+ /*
+  *
+  * basic image cache
+  *
+  */
+
+  FT_CALLBACK_TABLE_DEF
+  const FTC_IFamilyClassRec  ftc_basic_image_family_class =
+  {
+    {
+      sizeof ( FTC_BasicFamilyRec ),
+      ftc_basic_family_compare,
+      ftc_basic_family_init,
+      0,                        /* FTC_MruNode_ResetFunc */
+      0                         /* FTC_MruNode_DoneFunc  */
+    },
+    ftc_basic_family_load_glyph
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FTC_GCacheClassRec  ftc_basic_image_cache_class =
+  {
+    {
+      ftc_inode_new,
+      ftc_inode_weight,
+      ftc_gnode_compare,
+      ftc_basic_gnode_compare_faceid,
+      ftc_inode_free,
+
+      sizeof ( FTC_GCacheRec ),
+      ftc_gcache_init,
+      ftc_gcache_done
+    },
+    (FTC_MruListClass)&ftc_basic_image_family_class
+  };
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_ImageCache_New( FTC_Manager      manager,
+                      FTC_ImageCache  *acache )
+  {
+    return FTC_GCache_New( manager, &ftc_basic_image_cache_class,
+                           (FTC_GCache*)acache );
+  }
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_ImageCache_Lookup( FTC_ImageCache  cache,
+                         FTC_ImageType   type,
+                         FT_UInt         gindex,
+                         FT_Glyph       *aglyph,
+                         FTC_Node       *anode )
+  {
+    FTC_BasicQueryRec  query;
+    FTC_INode          node;
+    FT_Error           error;
+    FT_UInt32          hash;
+
+
+    /* some argument checks are delayed to FTC_Cache_Lookup */
+    if ( !aglyph )
+    {
+      error = FTC_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    *aglyph = NULL;
+    if ( anode )
+      *anode  = NULL;
+
+    query.attrs.scaler.face_id = type->face_id;
+    query.attrs.scaler.width   = type->width;
+    query.attrs.scaler.height  = type->height;
+    query.attrs.scaler.pixel   = 1;
+    query.attrs.load_flags     = type->flags;
+
+    query.attrs.scaler.x_res   = 0;  /* make compilers happy */
+    query.attrs.scaler.y_res   = 0;
+
+    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
+
+#if 1  /* inlining is about 50% faster! */
+    FTC_GCACHE_LOOKUP_CMP( cache,
+                           ftc_basic_family_compare,
+                           FTC_GNode_Compare,
+                           hash, gindex,
+                           &query,
+                           node,
+                           error );
+#else
+    error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
+                               hash, gindex,
+                               FTC_GQUERY( &query ),
+                               (FTC_Node*) &node );
+#endif
+    if ( !error )
+    {
+      *aglyph = FTC_INODE( node )->glyph;
+
+      if ( anode )
+      {
+        *anode = FTC_NODE( node );
+        FTC_NODE( node )->ref_count++;
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+ /*
+  *
+  * basic small bitmap cache
+  *
+  */
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FTC_SFamilyClassRec  ftc_basic_sbit_family_class =
+  {
+    {
+      sizeof( FTC_BasicFamilyRec ),
+      ftc_basic_family_compare,
+      ftc_basic_family_init,
+      0,                            /* FTC_MruNode_ResetFunc */
+      0                             /* FTC_MruNode_DoneFunc  */
+    },
+    ftc_basic_family_get_count,
+    ftc_basic_family_load_bitmap
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FTC_GCacheClassRec  ftc_basic_sbit_cache_class =
+  {
+    {
+      ftc_snode_new,
+      ftc_snode_weight,
+      ftc_snode_compare,
+      ftc_basic_gnode_compare_faceid,
+      ftc_snode_free,
+
+      sizeof ( FTC_GCacheRec ),
+      ftc_gcache_init,
+      ftc_gcache_done
+    },
+    (FTC_MruListClass)&ftc_basic_sbit_family_class
+  };
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_SBitCache_New( FTC_Manager     manager,
+                     FTC_SBitCache  *acache )
+  {
+    return FTC_GCache_New( manager, &ftc_basic_sbit_cache_class,
+                           (FTC_GCache*)acache );
+  }
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_SBitCache_Lookup( FTC_SBitCache  cache,
+                        FTC_ImageType  type,
+                        FT_UInt        gindex,
+                        FTC_SBit      *ansbit,
+                        FTC_Node      *anode )
+  {
+    FT_Error           error;
+    FTC_BasicQueryRec  query;
+    FTC_SNode          node;
+    FT_UInt32          hash;
+
+
+    if ( anode )
+      *anode = NULL;
+
+    /* other argument checks delayed to FTC_Cache_Lookup */
+    if ( !ansbit )
+      return FTC_Err_Invalid_Argument;
+
+    *ansbit = NULL;
+
+    query.attrs.scaler.face_id = type->face_id;
+    query.attrs.scaler.width   = type->width;
+    query.attrs.scaler.height  = type->height;
+    query.attrs.scaler.pixel   = 1;
+    query.attrs.load_flags     = type->flags;
+
+    query.attrs.scaler.x_res   = 0;  /* make compilers happy */
+    query.attrs.scaler.y_res   = 0;
+
+    /* beware, the hash must be the same for all glyph ranges! */
+    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
+           gindex / FTC_SBIT_ITEMS_PER_NODE;
+
+#if 1  /* inlining is about 50% faster! */
+    FTC_GCACHE_LOOKUP_CMP( cache,
+                           ftc_basic_family_compare,
+                           FTC_SNode_Compare,
+                           hash, gindex,
+                           &query,
+                           node,
+                           error );
+#else
+    error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
+                               hash,
+                               gindex,
+                               FTC_GQUERY( &query ),
+                               (FTC_Node*)&node );
+#endif
+    if ( error )
+      goto Exit;
+
+    *ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex );
+
+    if ( anode )
+    {
+      *anode = FTC_NODE( node );
+      FTC_NODE( node )->ref_count++;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftccache.c b/nx-X11/extras/freetype2/src/cache/ftccache.c
new file mode 100644
index 000000000..3a8a40c00
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftccache.c
@@ -0,0 +1,604 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftccache.c                                                             */
+/*                                                                         */
+/*    The FreeType internal cache interface (body).                        */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 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_CACHE_INTERNAL_MANAGER_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+
+#include "ftccback.h"
+#include "ftcerror.h"
+
+
+#define FTC_HASH_MAX_LOAD  2
+#define FTC_HASH_MIN_LOAD  1
+#define FTC_HASH_SUB_LOAD  ( FTC_HASH_MAX_LOAD - FTC_HASH_MIN_LOAD )
+
+/* this one _must_ be a power of 2! */
+#define FTC_HASH_INITIAL_SIZE  8
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                   CACHE NODE DEFINITIONS                      *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* add a new node to the head of the manager's circular MRU list */
+  static void
+  ftc_node_mru_link( FTC_Node     node,
+                     FTC_Manager  manager )
+  {
+    FTC_MruNode_Prepend( (FTC_MruNode*)&manager->nodes_list,
+                         (FTC_MruNode)node );
+    manager->num_nodes++;
+  }
+
+
+  /* remove a node from the manager's MRU list */
+  static void
+  ftc_node_mru_unlink( FTC_Node     node,
+                       FTC_Manager  manager )
+  {
+    FTC_MruNode_Remove( (FTC_MruNode*)&manager->nodes_list,
+                        (FTC_MruNode)node );
+    manager->num_nodes--;
+  }
+
+
+  /* move a node to the head of the manager's MRU list */
+  static void
+  ftc_node_mru_up( FTC_Node     node,
+                   FTC_Manager  manager )
+  {
+    FTC_MruNode_Up( (FTC_MruNode*)&manager->nodes_list,
+                    (FTC_MruNode)node );
+  }
+
+
+  /* Note that this function cannot fail.  If we cannot re-size the
+   * buckets array appropriately, we simply degrade the hash table's
+   * performance!
+   */
+  static void
+  ftc_cache_resize( FTC_Cache  cache )
+  {
+    for (;;)
+    {
+      FTC_Node  node, *pnode;
+      FT_UInt   p      = cache->p;
+      FT_UInt   mask   = cache->mask;
+      FT_UInt   count  = mask + p + 1;    /* number of buckets */
+
+
+      /* do we need to shrink the buckets array? */
+      if ( cache->slack < 0 )
+      {
+        FTC_Node  new_list = NULL;
+
+
+        /* try to expand the buckets array _before_ splitting
+         * the bucket lists
+         */
+        if ( p >= mask )
+        {
+          FT_Memory  memory = cache->memory;
+
+
+          /* if we can't expand the array, leave immediately */
+          if ( FT_MEM_RENEW_ARRAY( cache->buckets, (mask+1)*2, (mask+1)*4 ) )
+            break;
+        }
+
+        /* split a single bucket */
+        pnode = cache->buckets + p;
+
+        for (;;)
+        {
+          node = *pnode;
+          if ( node == NULL )
+            break;
+
+          if ( node->hash & ( mask + 1 ) )
+          {
+            *pnode     = node->link;
+            node->link = new_list;
+            new_list   = node;
+          }
+          else
+            pnode = &node->link;
+        }
+
+        cache->buckets[p + mask + 1] = new_list;
+
+        cache->slack += FTC_HASH_MAX_LOAD;
+
+        if ( p >= mask )
+        {
+          cache->mask = 2 * mask + 1;
+          cache->p    = 0;
+        }
+        else
+          cache->p = p + 1;
+      }
+
+      /* do we need to expand the buckets array? */
+      else if ( cache->slack > (FT_Long)count * FTC_HASH_SUB_LOAD )
+      {
+        FT_UInt    old_index = p + mask;
+        FTC_Node*  pold;
+
+
+        if ( old_index + 1 <= FTC_HASH_INITIAL_SIZE )
+          break;
+
+        if ( p == 0 )
+        {
+          FT_Memory  memory = cache->memory;
+
+
+          /* if we can't shrink the array, leave immediately */
+          if ( FT_MEM_RENEW_ARRAY( cache->buckets,
+                                   ( mask + 1 ) * 2, mask + 1 ) )
+            break;
+
+          cache->mask >>= 1;
+          p             = cache->mask;
+        }
+        else
+          p--;
+
+        pnode = cache->buckets + p;
+        while ( *pnode )
+          pnode = &(*pnode)->link;
+
+        pold   = cache->buckets + old_index;
+        *pnode = *pold;
+        *pold  = NULL;
+
+        cache->slack -= FTC_HASH_MAX_LOAD;
+        cache->p      = p;
+      }
+      else /* the hash table is balanced */
+        break;
+    }
+  }
+
+
+  /* remove a node from its cache's hash table */
+  static void
+  ftc_node_hash_unlink( FTC_Node   node0,
+                        FTC_Cache  cache )
+  {
+    FTC_Node  *pnode;
+    FT_UInt    idx;
+
+
+    idx = (FT_UInt)( node0->hash & cache->mask );
+    if ( idx < cache->p )
+      idx = (FT_UInt)( node0->hash & ( 2 * cache->mask + 1 ) );
+
+    pnode = cache->buckets + idx;
+
+    for (;;)
+    {
+      FTC_Node  node = *pnode;
+
+
+      if ( node == NULL )
+      {
+        FT_ERROR(( "ftc_node_hash_unlink: unknown node!\n" ));
+        return;
+      }
+
+      if ( node == node0 )
+        break;
+
+      pnode = &(*pnode)->link;
+    }
+
+    *pnode      = node0->link;
+    node0->link = NULL;
+
+    cache->slack++;
+    ftc_cache_resize( cache );
+  }
+
+
+  /* add a node to the `top' of its cache's hash table */
+  static void
+  ftc_node_hash_link( FTC_Node   node,
+                      FTC_Cache  cache )
+  {
+    FTC_Node  *pnode;
+    FT_UInt    idx;
+
+
+    idx = (FT_UInt)( node->hash & cache->mask );
+    if ( idx < cache->p )
+      idx = (FT_UInt)( node->hash & (2 * cache->mask + 1 ) );
+
+    pnode = cache->buckets + idx;
+
+    node->link = *pnode;
+    *pnode     = node;
+
+    cache->slack--;
+    ftc_cache_resize( cache );
+  }
+
+
+  /* remove a node from the cache manager */
+  FT_EXPORT_DEF( void )
+  ftc_node_destroy( FTC_Node     node,
+                    FTC_Manager  manager )
+  {
+    FTC_Cache  cache;
+
+
+#ifdef FT_DEBUG_ERROR
+    /* find node's cache */
+    if ( node->cache_index >= manager->num_caches )
+    {
+      FT_ERROR(( "ftc_node_destroy: invalid node handle\n" ));
+      return;
+    }
+#endif
+
+    cache = manager->caches[node->cache_index];
+
+#ifdef FT_DEBUG_ERROR
+    if ( cache == NULL )
+    {
+      FT_ERROR(( "ftc_node_destroy: invalid node handle\n" ));
+      return;
+    }
+#endif
+
+    manager->cur_weight -= cache->clazz.node_weight( node, cache );
+
+    /* remove node from mru list */
+    ftc_node_mru_unlink( node, manager );
+
+    /* remove node from cache's hash table */
+    ftc_node_hash_unlink( node, cache );
+
+    /* now finalize it */
+    cache->clazz.node_free( node, cache );
+
+#if 0
+    /* check, just in case of general corruption :-) */
+    if ( manager->num_nodes == 0 )
+      FT_ERROR(( "ftc_node_destroy: invalid cache node count! = %d\n",
+                  manager->num_nodes ));
+#endif
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    ABSTRACT CACHE CLASS                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_Cache_Init( FTC_Cache  cache )
+  {
+    return ftc_cache_init( cache );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  ftc_cache_init( FTC_Cache  cache )
+  {
+    FT_Memory  memory = cache->memory;
+
+
+    cache->p     = 0;
+    cache->mask  = FTC_HASH_INITIAL_SIZE - 1;
+    cache->slack = FTC_HASH_INITIAL_SIZE * FTC_HASH_MAX_LOAD;
+
+    return ( FT_MEM_NEW_ARRAY( cache->buckets, FTC_HASH_INITIAL_SIZE * 2 ) );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_Cache_Clear( FTC_Cache  cache )
+  {
+    if ( cache )
+    {
+      FTC_Manager  manager = cache->manager;
+      FT_UFast     i;
+      FT_UInt      count;
+
+
+      count = cache->p + cache->mask + 1;
+
+      for ( i = 0; i < count; i++ )
+      {
+        FTC_Node  *pnode = cache->buckets + i, next, node = *pnode;
+
+
+        while ( node )
+        {
+          next        = node->link;
+          node->link  = NULL;
+
+          /* remove node from mru list */
+          ftc_node_mru_unlink( node, manager );
+
+          /* now finalize it */
+          manager->cur_weight -= cache->clazz.node_weight( node, cache );
+
+          cache->clazz.node_free( node, cache );
+          node = next;
+        }
+        cache->buckets[i] = NULL;
+      }
+      ftc_cache_resize( cache );
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ftc_cache_done( FTC_Cache  cache )
+  {
+    if ( cache->memory )
+    {
+      FT_Memory  memory = cache->memory;
+
+
+      FTC_Cache_Clear( cache );
+
+      FT_FREE( cache->buckets );
+      cache->mask  = 0;
+      cache->p     = 0;
+      cache->slack = 0;
+
+      cache->memory = NULL;
+    }
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_Cache_Done( FTC_Cache  cache )
+  {
+    ftc_cache_done( cache );
+  }
+
+
+  static void
+  ftc_cache_add( FTC_Cache  cache,
+                 FT_UInt32  hash,
+                 FTC_Node   node )
+  {
+    node->hash = hash;
+    node->cache_index = (FT_UInt16) cache->index;
+    node->ref_count   = 0;
+
+    ftc_node_hash_link( node, cache );
+    ftc_node_mru_link( node, cache->manager );
+
+    {
+      FTC_Manager  manager = cache->manager;
+
+
+      manager->cur_weight += cache->clazz.node_weight( node, cache );
+
+      if ( manager->cur_weight >= manager->max_weight )
+      {
+        node->ref_count++;
+        FTC_Manager_Compress( manager );
+        node->ref_count--;
+      }
+    }
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_Cache_NewNode( FTC_Cache   cache,
+                     FT_UInt32   hash,
+                     FT_Pointer  query,
+                     FTC_Node   *anode )
+  {
+    FT_Error  error;
+    FTC_Node  node;
+
+    /*
+     *  Try to allocate a new cache node.  Note that in case of
+     *  out-of-memory error (OOM), we'll flush the cache a bit,
+     *  then try again.
+     *
+     *  On each try, the `tries' variable gives the number
+     *  of old nodes we want to flush from the manager's global list
+     *  before the next allocation attempt.  It barely doubles on
+     *  each iteration.
+     *
+     */
+    error = cache->clazz.node_new( &node, query, cache );
+    if ( error )
+      goto FlushCache;
+
+  AddNode:
+    /* don't assume that the cache has the same number of buckets, since
+     * our allocation request might have triggered global cache flushing
+     */
+    ftc_cache_add( cache, hash, node );
+
+  Exit:
+    *anode = node;
+    return error;
+
+  FlushCache:
+    node = NULL;
+    if ( error != FT_Err_Out_Of_Memory )
+      goto Exit;
+
+    {
+      FTC_Manager  manager = cache->manager;
+      FT_UInt      count, tries = 1;
+
+
+      for (;;)
+      {
+        error = cache->clazz.node_new( &node, query, cache );
+        if ( !error )
+          break;
+
+        node = NULL;
+        if ( error != FT_Err_Out_Of_Memory )
+          goto Exit;
+
+        count = FTC_Manager_FlushN( manager, tries );
+        if ( count == 0 )
+          goto Exit;
+
+        if ( count == tries )
+        {
+          count = tries * 2;
+          if ( count < tries || count > manager->num_nodes )
+            count = manager->num_nodes;
+        }
+        tries = count;
+      }
+    }
+    goto AddNode;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_Cache_Lookup( FTC_Cache   cache,
+                    FT_UInt32   hash,
+                    FT_Pointer  query,
+                    FTC_Node   *anode )
+  {
+    FT_UFast   idx;
+    FTC_Node*  bucket;
+    FTC_Node*  pnode;
+    FTC_Node   node;
+    FT_Error   error = 0;
+
+    FTC_Node_CompareFunc  compare = cache->clazz.node_compare;
+
+
+    if ( cache == NULL || anode == NULL )
+      return FT_Err_Invalid_Argument;
+
+    idx = hash & cache->mask;
+    if ( idx < cache->p )
+      idx = hash & ( cache->mask * 2 + 1 );
+
+    bucket = cache->buckets + idx;
+    pnode  = bucket;
+    for (;;)
+    {
+      node = *pnode;
+      if ( node == NULL )
+        goto NewNode;
+
+      if ( node->hash == hash && compare( node, query, cache ) )
+        break;
+
+      pnode = &node->link;
+    }
+
+    if ( node != *bucket )
+    {
+      *pnode     = node->link;
+      node->link = *bucket;
+      *bucket    = node;
+    }
+
+    /* move to head of MRU list */
+    {
+      FTC_Manager  manager = cache->manager;
+
+
+      if ( node != manager->nodes_list )
+        ftc_node_mru_up( node, manager );
+    }
+    *anode = node;
+    return error;
+
+  NewNode:
+    return FTC_Cache_NewNode( cache, hash, query, anode );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_Cache_RemoveFaceID( FTC_Cache   cache,
+                          FTC_FaceID  face_id )
+  {
+    FT_UFast     i, count;
+    FTC_Manager  manager = cache->manager;
+    FTC_Node     frees   = NULL;
+
+
+    count = cache->p + cache->mask;
+    for ( i = 0; i < count; i++ )
+    {
+      FTC_Node*  bucket = cache->buckets + i;
+      FTC_Node*  pnode  = bucket;
+
+
+      for ( ;; )
+      {
+        FTC_Node  node = *pnode;
+
+
+        if ( node == NULL )
+          break;
+
+        if ( cache->clazz.node_remove_faceid( node, face_id, cache ) )
+        {
+          *pnode     = node->link;
+          node->link = frees;
+          frees      = node;
+        }
+        else
+          pnode = &node->link;
+      }
+    }
+
+    /* remove all nodes in the free list */
+    while ( frees )
+    {
+      FTC_Node  node;
+
+
+      node  = frees;
+      frees = node->link;
+
+      manager->cur_weight -= cache->clazz.node_weight( node, cache );
+      ftc_node_mru_unlink( node, manager );
+
+      cache->clazz.node_free( node, cache );
+
+      cache->slack++;
+    }
+
+    ftc_cache_resize( cache );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftccback.h b/nx-X11/extras/freetype2/src/cache/ftccback.h
new file mode 100644
index 000000000..6b47e095e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftccback.h
@@ -0,0 +1,85 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftccback.h                                                             */
+/*                                                                         */
+/*    Callback functions of the caching sub-system (specification only).   */
+/*                                                                         */
+/*  Copyright 2004 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 __FTCCBACK_H__
+#define __FTCCBACK_H__
+
+#include <ft2build.h>
+#include FT_CACHE_H
+#include FT_CACHE_INTERNAL_MRU_H
+#include FT_CACHE_INTERNAL_IMAGE_H
+#include FT_CACHE_INTERNAL_MANAGER_H
+#include FT_CACHE_INTERNAL_GLYPH_H
+#include FT_CACHE_INTERNAL_SBITS_H
+
+
+  FT_LOCAL( void )
+  ftc_inode_free( FTC_Node   inode,
+                  FTC_Cache  cache );
+
+  FT_LOCAL( FT_Error )
+  ftc_inode_new( FTC_Node   *pinode,
+                 FT_Pointer  gquery,
+                 FTC_Cache   cache );
+
+  FT_LOCAL( FT_ULong )
+  ftc_inode_weight( FTC_Node   inode,
+                    FTC_Cache  cache );
+
+
+  FT_LOCAL( void )
+  ftc_snode_free( FTC_Node   snode,
+                  FTC_Cache  cache );
+
+  FT_LOCAL( FT_Error )
+  ftc_snode_new( FTC_Node   *psnode,
+                 FT_Pointer  gquery,
+                 FTC_Cache   cache );
+
+  FT_LOCAL( FT_ULong )
+  ftc_snode_weight( FTC_Node   snode,
+                    FTC_Cache  cache );
+
+  FT_LOCAL( FT_Bool )
+  ftc_snode_compare( FTC_Node    snode,
+                     FT_Pointer  gquery,
+                     FTC_Cache   cache );
+
+
+  FT_LOCAL( FT_Bool )
+  ftc_gnode_compare( FTC_Node    gnode,
+                     FT_Pointer  gquery,
+                     FTC_Cache   cache );
+
+
+  FT_LOCAL( FT_Error )
+  ftc_gcache_init( FTC_Cache  cache );
+
+  FT_LOCAL( void )
+  ftc_gcache_done( FTC_Cache  cache );
+
+
+  FT_LOCAL( FT_Error )
+  ftc_cache_init( FTC_Cache  cache );
+
+  FT_LOCAL( void )
+  ftc_cache_done( FTC_Cache  cache );
+
+
+#endif /* __FTCCBACK_H__ */
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftccmap.c b/nx-X11/extras/freetype2/src/cache/ftccmap.c
new file mode 100644
index 000000000..b2812c951
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftccmap.c
@@ -0,0 +1,303 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftccmap.c                                                              */
+/*                                                                         */
+/*    FreeType CharMap cache (body)                                        */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 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_CACHE_H
+#include FT_CACHE_INTERNAL_MANAGER_H
+#include FT_INTERNAL_MEMORY_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_TRUETYPE_IDS_H
+
+#include "ftccback.h"
+#include "ftcerror.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_cache
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Each FTC_CMapNode contains a simple array to map a range of character */
+  /* codes to equivalent glyph indices.                                    */
+  /*                                                                       */
+  /* For now, the implementation is very basic: Each node maps a range of  */
+  /* 128 consecutive character codes to their corresponding glyph indices. */
+  /*                                                                       */
+  /* We could do more complex things, but I don't think it is really very  */
+  /* useful.                                                               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* number of glyph indices / character code per node */
+#define FTC_CMAP_INDICES_MAX  128
+
+  /* compute a query/node hash */
+#define FTC_CMAP_HASH( faceid, index, charcode )           \
+          ( FTC_FACE_ID_HASH( faceid ) + 211 * ( index ) + \
+            ( (char_code) / FTC_CMAP_INDICES_MAX )       )
+
+  /* the charmap query */
+  typedef struct  FTC_CMapQueryRec_
+  {
+    FTC_FaceID  face_id;
+    FT_UInt     cmap_index;
+    FT_UInt32   char_code;
+
+  } FTC_CMapQueryRec, *FTC_CMapQuery;
+
+#define FTC_CMAP_QUERY( x )  ((FTC_CMapQuery)(x))
+#define FTC_CMAP_QUERY_HASH( x )                                         \
+          FTC_CMAP_HASH( (x)->face_id, (x)->cmap_index, (x)->char_code )
+
+  /* the cmap cache node */
+  typedef struct  FTC_CMapNodeRec_
+  {
+    FTC_NodeRec  node;
+    FTC_FaceID   face_id;
+    FT_UInt      cmap_index;
+    FT_UInt32    first;                         /* first character in node */
+    FT_UInt16    indices[FTC_CMAP_INDICES_MAX]; /* array of glyph indices  */
+
+  } FTC_CMapNodeRec, *FTC_CMapNode;
+
+#define FTC_CMAP_NODE( x ) ( (FTC_CMapNode)( x ) )
+#define FTC_CMAP_NODE_HASH( x )                                      \
+          FTC_CMAP_HASH( (x)->face_id, (x)->cmap_index, (x)->first )
+
+  /* if (indices[n] == FTC_CMAP_UNKNOWN), we assume that the corresponding */
+  /* glyph indices haven't been queried through FT_Get_Glyph_Index() yet   */
+#define FTC_CMAP_UNKNOWN  ( (FT_UInt16)-1 )
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        CHARMAP NODES                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* no need for specific finalizer; we use `ftc_node_done' directly */
+
+  FT_CALLBACK_DEF( void )
+  ftc_cmap_node_free( FTC_Node   ftcnode,
+                      FTC_Cache  cache )
+  {
+    FTC_CMapNode  node   = (FTC_CMapNode)ftcnode;
+    FT_Memory     memory = cache->memory;
+
+
+    FT_FREE( node );
+  }
+
+
+  /* initialize a new cmap node */
+  FT_CALLBACK_DEF( FT_Error )
+  ftc_cmap_node_new( FTC_Node   *ftcanode,
+                     FT_Pointer  ftcquery,
+                     FTC_Cache   cache )
+  {
+    FTC_CMapNode  *anode  = (FTC_CMapNode*)ftcanode;
+    FTC_CMapQuery  query  = (FTC_CMapQuery)ftcquery;
+    FT_Error       error;
+    FT_Memory      memory = cache->memory;
+    FTC_CMapNode   node;
+    FT_UInt        nn;
+
+
+    if ( !FT_NEW( node ) )
+    {
+      node->face_id    = query->face_id;
+      node->cmap_index = query->cmap_index;
+      node->first      = (query->char_code / FTC_CMAP_INDICES_MAX) *
+                         FTC_CMAP_INDICES_MAX;
+
+      for ( nn = 0; nn < FTC_CMAP_INDICES_MAX; nn++ )
+        node->indices[nn] = FTC_CMAP_UNKNOWN;
+    }
+
+    *anode = node;
+    return error;
+  }
+
+
+  /* compute the weight of a given cmap node */
+  FT_CALLBACK_DEF( FT_ULong )
+  ftc_cmap_node_weight( FTC_Node   cnode,
+                        FTC_Cache  cache )
+  {
+    FT_UNUSED( cnode );
+    FT_UNUSED( cache );
+
+    return sizeof ( *cnode );
+  }
+
+
+  /* compare a cmap node to a given query */
+  FT_CALLBACK_DEF( FT_Bool )
+  ftc_cmap_node_compare( FTC_Node    ftcnode,
+                         FT_Pointer  ftcquery,
+                         FTC_Cache   cache )
+  {
+    FTC_CMapNode   node  = (FTC_CMapNode)ftcnode;
+    FTC_CMapQuery  query = (FTC_CMapQuery)ftcquery;
+    FT_UNUSED( cache );
+
+
+    if ( node->face_id    == query->face_id    &&
+         node->cmap_index == query->cmap_index )
+    {
+      FT_UInt32  offset = (FT_UInt32)( query->char_code - node->first );
+
+
+      return FT_BOOL( offset < FTC_CMAP_INDICES_MAX );
+    }
+
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Bool )
+  ftc_cmap_node_remove_faceid( FTC_Node    ftcnode,
+                               FT_Pointer  ftcface_id,
+                               FTC_Cache   cache )
+  {
+    FTC_CMapNode  node    = (FTC_CMapNode)ftcnode;
+    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
+    FT_UNUSED( cache );
+
+    return FT_BOOL( node->face_id == face_id );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    GLYPH IMAGE CACHE                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FTC_CacheClassRec  ftc_cmap_cache_class =
+  {
+    ftc_cmap_node_new,
+    ftc_cmap_node_weight,
+    ftc_cmap_node_compare,
+    ftc_cmap_node_remove_faceid,
+    ftc_cmap_node_free,
+
+    sizeof ( FTC_CacheRec ),
+    ftc_cache_init,
+    ftc_cache_done,
+  };
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_CMapCache_New( FTC_Manager     manager,
+                     FTC_CMapCache  *acache )
+  {
+    return FTC_Manager_RegisterCache( manager,
+                                      &ftc_cmap_cache_class,
+                                      FTC_CACHE_P( acache ) );
+  }
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_UInt )
+  FTC_CMapCache_Lookup( FTC_CMapCache  cmap_cache,
+                        FTC_FaceID     face_id,
+                        FT_Int         cmap_index,
+                        FT_UInt32      char_code )
+  {
+    FTC_Cache         cache = FTC_CACHE( cmap_cache );
+    FTC_CMapQueryRec  query;
+    FTC_CMapNode      node;
+    FT_Error          error;
+    FT_UInt           gindex = 0;
+    FT_UInt32         hash;
+
+
+    if ( !cache )
+    {
+      FT_ERROR(( "FTC_CMapCache_Lookup: bad arguments, returning 0!\n" ));
+      return 0;
+    }
+
+    query.face_id    = face_id;
+    query.cmap_index = (FT_UInt)cmap_index;
+    query.char_code  = char_code;
+
+    hash = FTC_CMAP_HASH( face_id, cmap_index, char_code );
+
+#if 1
+    FTC_CACHE_LOOKUP_CMP( cache, ftc_cmap_node_compare, hash, &query,
+                          node, error );
+#else
+    error = FTC_Cache_Lookup( cache, hash, &query, (FTC_Node*) &node );
+#endif
+    if ( error )
+      goto Exit;
+
+    FT_ASSERT( (FT_UInt)( char_code - node->first ) < FTC_CMAP_INDICES_MAX );
+
+    gindex = node->indices[char_code - node->first];
+    if ( gindex == FTC_CMAP_UNKNOWN )
+    {
+      FT_Face  face;
+
+
+      gindex = 0;
+
+      error = FTC_Manager_LookupFace( cache->manager, node->face_id, &face );
+      if ( error )
+        goto Exit;
+
+      if ( (FT_UInt)cmap_index < (FT_UInt)face->num_charmaps )
+      {
+        FT_CharMap  old, cmap  = NULL;
+
+
+        old  = face->charmap;
+        cmap = face->charmaps[cmap_index];
+
+        if ( old != cmap )
+          FT_Set_Charmap( face, cmap );
+
+        gindex = FT_Get_Char_Index( face, char_code );
+
+        if ( old != cmap )
+          FT_Set_Charmap( face, old );
+      }
+
+      node->indices[char_code - node->first] = gindex;
+    }
+
+  Exit:
+    return gindex;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftcerror.h b/nx-X11/extras/freetype2/src/cache/ftcerror.h
new file mode 100644
index 000000000..5998d42da
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftcerror.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcerror.h                                                             */
+/*                                                                         */
+/*    Caching sub-system error codes (specification only).                 */
+/*                                                                         */
+/*  Copyright 2001 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 caching sub-system error enumeration  */
+  /* constants.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __FTCERROR_H__
+#define __FTCERROR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  FTC_Err_
+#define FT_ERR_BASE    FT_Mod_Err_Cache
+
+#include FT_ERRORS_H
+
+#endif /* __FTCERROR_H__ */
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftcglyph.c b/nx-X11/extras/freetype2/src/cache/ftcglyph.c
new file mode 100644
index 000000000..1f3158e79
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftcglyph.c
@@ -0,0 +1,189 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcglyph.c                                                             */
+/*                                                                         */
+/*    FreeType Glyph Image (FT_Glyph) cache (body).                        */
+/*                                                                         */
+/*  Copyright 2000-2001, 2003, 2004 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_CACHE_H
+#include FT_CACHE_INTERNAL_GLYPH_H
+#include FT_ERRORS_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+
+#include "ftccback.h"
+#include "ftcerror.h"
+
+
+  /* create a new chunk node, setting its cache index and ref count */
+  FT_EXPORT_DEF( void )
+  FTC_GNode_Init( FTC_GNode   gnode,
+                  FT_UInt     gindex,
+                  FTC_Family  family )
+  {
+    gnode->family = family;
+    gnode->gindex = gindex;
+    family->num_nodes++;
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_GNode_UnselectFamily( FTC_GNode  gnode,
+                            FTC_Cache  cache )
+  {
+    FTC_Family  family = gnode->family;
+
+
+    gnode->family = NULL;
+    if ( family && --family->num_nodes <= 0 )
+      FTC_MruList_Remove( &FTC_GCACHE( cache )->families,
+                          (FTC_MruNode)family );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_GNode_Done( FTC_GNode  gnode,
+                  FTC_Cache  cache )
+  {
+    /* finalize the node */
+    gnode->gindex = 0;
+
+    FTC_GNode_UnselectFamily( gnode, cache );
+  }
+
+
+  FT_LOCAL_DEF( FT_Bool )
+  ftc_gnode_compare( FTC_Node    ftcgnode,
+                     FT_Pointer  ftcgquery,
+                     FTC_Cache   cache )
+  {
+    FTC_GNode   gnode  = (FTC_GNode)ftcgnode;
+    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
+    FT_UNUSED( cache );
+
+
+    return FT_BOOL(  gnode->family == gquery->family &&
+                     gnode->gindex == gquery->gindex );
+  }
+
+
+  FT_EXPORT_DEF( FT_Bool )
+  FTC_GNode_Compare( FTC_GNode   gnode,
+                     FTC_GQuery  gquery )
+  {
+    return ftc_gnode_compare( FTC_NODE( gnode ), gquery, NULL );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      CHUNK SETS                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_EXPORT_DEF( void )
+  FTC_Family_Init( FTC_Family  family,
+                   FTC_Cache   cache )
+  {
+    FTC_GCacheClass  clazz = FTC_CACHE__GCACHE_CLASS( cache );
+
+
+    family->clazz     = clazz->family_class;
+    family->num_nodes = 0;
+    family->cache     = cache;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  ftc_gcache_init( FTC_Cache  ftccache )
+  {
+    FTC_GCache  cache = (FTC_GCache)ftccache;
+    FT_Error    error;
+
+
+    error = FTC_Cache_Init( FTC_CACHE( cache ) );
+    if ( !error )
+    {
+      FTC_GCacheClass   clazz = (FTC_GCacheClass)FTC_CACHE( cache )->org_class;
+
+      FTC_MruList_Init( &cache->families,
+                        clazz->family_class,
+                        0,  /* no maximum here! */
+                        cache,
+                        FTC_CACHE( cache )->memory );
+    }
+
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_GCache_Init( FTC_GCache  cache )
+  {
+    return ftc_gcache_init( FTC_CACHE( cache ) );
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ftc_gcache_done( FTC_Cache  ftccache )
+  {
+    FTC_GCache  cache = (FTC_GCache)ftccache;
+
+
+    FTC_Cache_Done( (FTC_Cache)cache );
+    FTC_MruList_Done( &cache->families );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_GCache_Done( FTC_GCache  cache )
+  {
+    ftc_gcache_done( FTC_CACHE( cache ) );
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_GCache_New( FTC_Manager       manager,
+                  FTC_GCacheClass   clazz,
+                  FTC_GCache       *acache )
+  {
+    return FTC_Manager_RegisterCache( manager, (FTC_CacheClass)clazz,
+                                      (FTC_Cache*)acache );
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_GCache_Lookup( FTC_GCache   cache,
+                     FT_UInt32    hash,
+                     FT_UInt      gindex,
+                     FTC_GQuery   query,
+                     FTC_Node    *anode )
+  {
+    FT_Error  error;
+
+
+    query->gindex = gindex;
+
+    FTC_MRULIST_LOOKUP( &cache->families, query, query->family, error );
+    if ( !error )
+      error = FTC_Cache_Lookup( FTC_CACHE( cache ), hash, query, anode );
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftcimage.c b/nx-X11/extras/freetype2/src/cache/ftcimage.c
new file mode 100644
index 000000000..508ed6c15
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftcimage.c
@@ -0,0 +1,154 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcimage.c                                                             */
+/*                                                                         */
+/*    FreeType Image cache (body).                                         */
+/*                                                                         */
+/*  Copyright 2000-2001, 2003, 2004 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_CACHE_H
+#include FT_CACHE_INTERNAL_IMAGE_H
+#include FT_INTERNAL_MEMORY_H
+
+#include "ftccback.h"
+#include "ftcerror.h"
+
+
+  /* finalize a given glyph image node */
+  FT_LOCAL_DEF( void )
+  ftc_inode_free( FTC_Node   ftcinode,
+                  FTC_Cache  cache )
+  {
+    FTC_INode  inode = (FTC_INode)ftcinode;
+    FT_Memory  memory = cache->memory;
+
+
+    if ( inode->glyph )
+    {
+      FT_Done_Glyph( inode->glyph );
+      inode->glyph = NULL;
+    }
+
+    FTC_GNode_Done( FTC_GNODE( inode ), cache );
+    FT_FREE( inode );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_INode_Free( FTC_INode  inode,
+                  FTC_Cache  cache )
+  {
+    ftc_inode_free( FTC_NODE( inode ), cache );
+  }
+
+
+  /* initialize a new glyph image node */
+  FT_EXPORT_DEF( FT_Error )
+  FTC_INode_New( FTC_INode   *pinode,
+                 FTC_GQuery   gquery,
+                 FTC_Cache    cache )
+  {
+    FT_Memory  memory = cache->memory;
+    FT_Error   error;
+    FTC_INode  inode;
+
+
+    if ( !FT_NEW( inode ) )
+    {
+      FTC_GNode         gnode  = FTC_GNODE( inode );
+      FTC_Family        family = gquery->family;
+      FT_UInt           gindex = gquery->gindex;
+      FTC_IFamilyClass  clazz  = FTC_CACHE__IFAMILY_CLASS( cache );
+
+
+      /* initialize its inner fields */
+      FTC_GNode_Init( gnode, gindex, family );
+
+      /* we will now load the glyph image */
+      error = clazz->family_load_glyph( family, gindex, cache,
+                                        &inode->glyph );
+    }
+
+    *pinode = inode;
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  ftc_inode_new( FTC_Node   *ftcpinode,
+                 FT_Pointer  ftcgquery,
+                 FTC_Cache   cache )
+  {
+    FTC_INode  *pinode = (FTC_INode*)ftcpinode;
+    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
+
+
+    return FTC_INode_New( pinode, gquery, cache );
+  }
+
+
+  FT_LOCAL_DEF( FT_ULong )
+  ftc_inode_weight( FTC_Node   ftcinode,
+                    FTC_Cache  ftccache )
+  {
+    FTC_INode  inode = (FTC_INode)ftcinode;
+    FT_ULong   size  = 0;
+    FT_Glyph   glyph = inode->glyph;
+
+    FT_UNUSED( ftccache );
+
+
+    switch ( glyph->format )
+    {
+    case FT_GLYPH_FORMAT_BITMAP:
+      {
+        FT_BitmapGlyph  bitg;
+
+
+        bitg = (FT_BitmapGlyph)glyph;
+        size = bitg->bitmap.rows * labs( bitg->bitmap.pitch ) +
+               sizeof ( *bitg );
+      }
+      break;
+
+    case FT_GLYPH_FORMAT_OUTLINE:
+      {
+        FT_OutlineGlyph  outg;
+
+
+        outg = (FT_OutlineGlyph)glyph;
+        size = outg->outline.n_points *
+                 ( sizeof ( FT_Vector ) + sizeof ( FT_Byte ) ) +
+               outg->outline.n_contours * sizeof ( FT_Short ) +
+               sizeof ( *outg );
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    size += sizeof ( *inode );
+    return size;
+  }
+
+
+  FT_EXPORT_DEF( FT_ULong )
+  FTC_INode_Weight( FTC_INode  inode )
+  {
+    return ftc_inode_weight( FTC_NODE( inode ), NULL );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftcmanag.c b/nx-X11/extras/freetype2/src/cache/ftcmanag.c
new file mode 100644
index 000000000..97d324c61
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftcmanag.c
@@ -0,0 +1,680 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcmanag.c                                                             */
+/*                                                                         */
+/*    FreeType Cache Manager (body).                                       */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 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_CACHE_H
+#include FT_CACHE_INTERNAL_MANAGER_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_SIZES_H
+
+#include "ftcerror.h"
+
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_cache
+
+#define FTC_LRU_GET_MANAGER( lru )  ( (FTC_Manager)(lru)->user_data )
+
+
+  static FT_Error
+  ftc_scaler_lookup_size( FTC_Manager  manager,
+                          FTC_Scaler   scaler,
+                          FT_Size     *asize )
+  {
+    FT_Face   face;
+    FT_Size   size = NULL;
+    FT_Error  error;
+
+
+    error = FTC_Manager_LookupFace( manager, scaler->face_id, &face );
+    if ( error )
+      goto Exit;
+
+    error = FT_New_Size( face, &size );
+    if ( error )
+      goto Exit;
+
+    FT_Activate_Size( size );
+
+    if ( scaler->pixel )
+      error = FT_Set_Pixel_Sizes( face, scaler->width, scaler->height );
+    else
+      error = FT_Set_Char_Size( face, scaler->width, scaler->height,
+                                scaler->x_res, scaler->y_res );
+    if ( error )
+    {
+      FT_Done_Size( size );
+      size = NULL;
+    }
+
+  Exit:
+    *asize = size;
+    return error;
+  }
+
+
+  typedef struct  FTC_SizeNodeRec_
+  {
+    FTC_MruNodeRec  node;
+    FT_Size         size;
+    FTC_ScalerRec   scaler;
+
+  } FTC_SizeNodeRec, *FTC_SizeNode;
+
+
+  FT_CALLBACK_DEF( void )
+  ftc_size_node_done( FTC_MruNode  ftcnode,
+                      FT_Pointer   data )
+  {
+    FTC_SizeNode  node = (FTC_SizeNode)ftcnode;
+    FT_Size       size = node->size;
+    FT_UNUSED( data );
+
+
+    if ( size )
+      FT_Done_Size( size );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Bool )
+  ftc_size_node_compare( FTC_MruNode  ftcnode,
+                         FT_Pointer   ftcscaler )
+  {
+    FTC_SizeNode  node    = (FTC_SizeNode)ftcnode;
+    FTC_Scaler    scaler  = (FTC_Scaler)ftcscaler;
+    FTC_Scaler    scaler0 = &node->scaler;
+
+
+    if ( FTC_SCALER_COMPARE( scaler0, scaler ) )
+    {
+      FT_Activate_Size( node->size );
+      return 1;
+    }
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ftc_size_node_init( FTC_MruNode  ftcnode,
+                      FT_Pointer   ftcscaler,
+                      FT_Pointer   ftcmanager )
+  {
+    FTC_SizeNode  node    = (FTC_SizeNode)ftcnode;
+    FTC_Scaler    scaler  = (FTC_Scaler)ftcscaler;
+    FTC_Manager   manager = (FTC_Manager)ftcmanager;
+
+
+    node->scaler = scaler[0];
+
+    return ftc_scaler_lookup_size( manager, scaler, &node->size );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ftc_size_node_reset( FTC_MruNode  ftcnode,
+                       FT_Pointer   ftcscaler,
+                       FT_Pointer   ftcmanager )
+  {
+    FTC_SizeNode  node    = (FTC_SizeNode)ftcnode;
+    FTC_Scaler    scaler  = (FTC_Scaler)ftcscaler;
+    FTC_Manager   manager = (FTC_Manager)ftcmanager;
+
+
+    FT_Done_Size( node->size );
+
+    node->scaler = scaler[0];
+
+    return ftc_scaler_lookup_size( manager, scaler, &node->size );
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FTC_MruListClassRec  ftc_size_list_class =
+  {
+    sizeof ( FTC_SizeNodeRec ),
+    ftc_size_node_compare,
+    ftc_size_node_init,
+    ftc_size_node_reset,
+    ftc_size_node_done
+  };
+
+
+  /* helper function used by ftc_face_node_done */
+  static FT_Bool
+  ftc_size_node_compare_faceid( FTC_MruNode  ftcnode,
+                                FT_Pointer   ftcface_id )
+  {
+    FTC_SizeNode  node    = (FTC_SizeNode)ftcnode;
+    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
+
+
+    return node->scaler.face_id == face_id;
+  }
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_Manager_LookupSize( FTC_Manager  manager,
+                          FTC_Scaler   scaler,
+                          FT_Size     *asize )
+  {
+    FT_Error      error;
+    FTC_SizeNode  node;
+
+
+    if ( asize == NULL )
+      return FTC_Err_Bad_Argument;
+
+    *asize = NULL;
+
+    if ( !manager )
+      return FTC_Err_Invalid_Cache_Handle;
+
+#ifdef FTC_INLINE
+
+    FTC_MRULIST_LOOKUP_CMP( &manager->sizes, scaler, ftc_size_node_compare,
+                            node, error );
+
+#else
+    error = FTC_MruList_Lookup( &manager->sizes, scaler, (FTC_MruNode*)&node );
+#endif
+
+    if ( !error )
+      *asize = node->size;
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    FACE MRU IMPLEMENTATION                    *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct  FTC_FaceNodeRec_
+  {
+    FTC_MruNodeRec  node;
+    FTC_FaceID      face_id;
+    FT_Face         face;
+
+  } FTC_FaceNodeRec, *FTC_FaceNode;
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  ftc_face_node_init( FTC_MruNode  ftcnode,
+                      FT_Pointer   ftcface_id,
+                      FT_Pointer   ftcmanager )
+  {
+    FTC_FaceNode  node    = (FTC_FaceNode)ftcnode;
+    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
+    FTC_Manager   manager = (FTC_Manager)ftcmanager;
+    FT_Error      error;
+
+
+    node->face_id = face_id;
+
+    error = manager->request_face( face_id,
+                                   manager->library,
+                                   manager->request_data,
+                                   &node->face );
+    if ( !error )
+    {
+      /* destroy initial size object; it will be re-created later */
+      if ( node->face->size )
+        FT_Done_Size( node->face->size );
+    }
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  ftc_face_node_done( FTC_MruNode  ftcnode,
+                      FT_Pointer   ftcmanager )
+  {
+    FTC_FaceNode  node    = (FTC_FaceNode)ftcnode;
+    FTC_Manager   manager = (FTC_Manager)ftcmanager;
+
+
+    /* we must begin by removing all scalers for the target face */
+    /* from the manager's list                                   */
+    FTC_MruList_RemoveSelection( &manager->sizes,
+                                 ftc_size_node_compare_faceid,
+                                 node->face_id );
+
+    /* all right, we can discard the face now */
+    FT_Done_Face( node->face );
+    node->face    = NULL;
+    node->face_id = NULL;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Bool )
+  ftc_face_node_compare( FTC_MruNode  ftcnode,
+                         FT_Pointer   ftcface_id )
+  {
+    FTC_FaceNode  node    = (FTC_FaceNode)ftcnode;
+    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
+
+
+    return FT_BOOL( node->face_id == face_id );
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FTC_MruListClassRec  ftc_face_list_class =
+  {
+    sizeof ( FTC_FaceNodeRec),
+
+    ftc_face_node_compare,
+    ftc_face_node_init,
+    0,                          /* FTC_MruNode_ResetFunc */
+    ftc_face_node_done
+  };
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_Manager_LookupFace( FTC_Manager  manager,
+                          FTC_FaceID   face_id,
+                          FT_Face     *aface )
+  {
+    FT_Error      error;
+    FTC_FaceNode  node;
+
+
+    if ( aface == NULL )
+      return FTC_Err_Bad_Argument;
+
+    *aface = NULL;
+
+    if ( !manager )
+      return FTC_Err_Invalid_Cache_Handle;
+
+    /* we break encapsulation for the sake of speed */
+#ifdef FTC_INLINE
+
+    FTC_MRULIST_LOOKUP_CMP( &manager->faces, face_id, ftc_face_node_compare,
+                            node, error );
+
+#else
+    error = FTC_MruList_Lookup( &manager->faces, face_id, (FTC_MruNode*)&node );
+#endif
+
+    if ( !error )
+      *aface = node->face;
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    CACHE MANAGER ROUTINES                     *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_Manager_New( FT_Library          library,
+                   FT_UInt             max_faces,
+                   FT_UInt             max_sizes,
+                   FT_ULong            max_bytes,
+                   FTC_Face_Requester  requester,
+                   FT_Pointer          req_data,
+                   FTC_Manager        *amanager )
+  {
+    FT_Error     error;
+    FT_Memory    memory;
+    FTC_Manager  manager = 0;
+
+
+    if ( !library )
+      return FTC_Err_Invalid_Library_Handle;
+
+    memory = library->memory;
+
+    if ( FT_NEW( manager ) )
+      goto Exit;
+
+    if ( max_faces == 0 )
+      max_faces = FTC_MAX_FACES_DEFAULT;
+
+    if ( max_sizes == 0 )
+      max_sizes = FTC_MAX_SIZES_DEFAULT;
+
+    if ( max_bytes == 0 )
+      max_bytes = FTC_MAX_BYTES_DEFAULT;
+
+    manager->library      = library;
+    manager->memory       = memory;
+    manager->max_weight   = max_bytes;
+
+    manager->request_face = requester;
+    manager->request_data = req_data;
+
+    FTC_MruList_Init( &manager->faces,
+                      &ftc_face_list_class,
+                      max_faces,
+                      manager,
+                      memory );
+
+    FTC_MruList_Init( &manager->sizes,
+                      &ftc_size_list_class,
+                      max_sizes,
+                      manager,
+                      memory );
+
+    *amanager = manager;
+
+  Exit:
+    return error;
+  }
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( void )
+  FTC_Manager_Done( FTC_Manager  manager )
+  {
+    FT_Memory  memory;
+    FT_UInt    idx;
+
+
+    if ( !manager || !manager->library )
+      return;
+
+    memory = manager->memory;
+
+    /* now discard all caches */
+    for (idx = manager->num_caches; idx-- > 0; )
+    {
+      FTC_Cache  cache = manager->caches[idx];
+
+
+      if ( cache )
+      {
+        cache->clazz.cache_done( cache );
+        FT_FREE( cache );
+        manager->caches[idx] = NULL;
+      }
+    }
+    manager->num_caches = 0;
+
+    /* discard faces and sizes */
+    FTC_MruList_Done( &manager->sizes );
+    FTC_MruList_Done( &manager->faces );
+
+    manager->library = NULL;
+    manager->memory  = NULL;
+
+    FT_FREE( manager );
+  }
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( void )
+  FTC_Manager_Reset( FTC_Manager  manager )
+  {
+    if ( manager )
+    {
+      FTC_MruList_Reset( &manager->sizes );
+      FTC_MruList_Reset( &manager->faces );
+    }
+    /* XXX: FIXME: flush the caches? */
+  }
+
+
+#ifdef FT_DEBUG_ERROR
+
+  FT_EXPORT_DEF( void )
+  FTC_Manager_Check( FTC_Manager  manager )
+  {
+    FTC_Node  node, first;
+
+
+    first = manager->nodes_list;
+
+    /* check node weights */
+    if ( first )
+    {
+      FT_ULong  weight = 0;
+
+
+      node = first;
+
+      do
+      {
+        FTC_Cache  cache = manager->caches[node->cache_index];
+
+
+        if ( (FT_UInt)node->cache_index >= manager->num_caches )
+          FT_ERROR(( "FTC_Manager_Check: invalid node (cache index = %ld\n",
+                     node->cache_index ));
+        else
+          weight += cache->clazz.node_weight( node, cache );
+
+        node = FTC_NODE__NEXT( node );
+
+      } while ( node != first );
+
+      if ( weight != manager->cur_weight )
+        FT_ERROR(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n",
+                   manager->cur_weight, weight ));
+    }
+
+    /* check circular list */
+    if ( first )
+    {
+      FT_UFast  count = 0;
+
+
+      node = first;
+      do
+      {
+        count++;
+        node = FTC_NODE__NEXT( node );
+
+      } while ( node != first );
+
+      if ( count != manager->num_nodes )
+        FT_ERROR((
+          "FTC_Manager_Check: invalid cache node count %d instead of %d\n",
+          manager->num_nodes, count ));
+    }
+  }
+
+#endif /* FT_DEBUG_ERROR */
+
+
+  /* `Compress' the manager's data, i.e., get rid of old cache nodes */
+  /* that are not referenced anymore in order to limit the total     */
+  /* memory used by the cache.                                       */
+
+  /* documentation is in ftcmanag.h */
+
+  FT_EXPORT_DEF( void )
+  FTC_Manager_Compress( FTC_Manager  manager )
+  {
+    FTC_Node   node, first;
+
+
+    if ( !manager )
+      return;
+
+    first = manager->nodes_list;
+
+#ifdef FT_DEBUG_ERROR
+    FTC_Manager_Check( manager );
+
+    FT_ERROR(( "compressing, weight = %ld, max = %ld, nodes = %d\n",
+               manager->cur_weight, manager->max_weight,
+               manager->num_nodes ));
+#endif
+
+    if ( manager->cur_weight < manager->max_weight || first == NULL )
+      return;
+
+    /* go to last node -- it's a circular list */
+    node = FTC_NODE__PREV( first );
+    do
+    {
+      FTC_Node  prev;
+
+
+      prev = ( node == first ) ? NULL : FTC_NODE__PREV( node );
+
+      if ( node->ref_count <= 0 )
+        ftc_node_destroy( node, manager );
+
+      node = prev;
+
+    } while ( node && manager->cur_weight > manager->max_weight );
+  }
+
+
+  /* documentation is in ftcmanag.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_Manager_RegisterCache( FTC_Manager      manager,
+                             FTC_CacheClass   clazz,
+                             FTC_Cache       *acache )
+  {
+    FT_Error   error = FTC_Err_Invalid_Argument;
+    FTC_Cache  cache = NULL;
+
+
+    if ( manager && clazz && acache )
+    {
+      FT_Memory  memory = manager->memory;
+
+
+      if ( manager->num_caches >= FTC_MAX_CACHES )
+      {
+        error = FTC_Err_Too_Many_Caches;
+        FT_ERROR(( "%s: too many registered caches\n",
+                   "FTC_Manager_Register_Cache" ));
+        goto Exit;
+      }
+
+      if ( !FT_ALLOC( cache, clazz->cache_size ) )
+      {
+        cache->manager   = manager;
+        cache->memory    = memory;
+        cache->clazz     = clazz[0];
+        cache->org_class = clazz;
+
+        /* THIS IS VERY IMPORTANT!  IT WILL WRETCH THE MANAGER */
+        /* IF IT IS NOT SET CORRECTLY                          */
+        cache->index = manager->num_caches;
+
+        error = clazz->cache_init( cache );
+        if ( error )
+        {
+          clazz->cache_done( cache );
+          FT_FREE( cache );
+          goto Exit;
+        }
+
+        manager->caches[manager->num_caches++] = cache;
+      }
+    }
+
+  Exit:
+    *acache = cache;
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_UInt )
+  FTC_Manager_FlushN( FTC_Manager  manager,
+                      FT_UInt      count )
+  {
+    FTC_Node  first = manager->nodes_list;
+    FTC_Node  node;
+    FT_UInt   result;
+
+
+    /* try to remove `count' nodes from the list */
+    if ( first == NULL )  /* empty list! */
+      return 0;
+
+    /* go to last node - it's a circular list */
+    node = FTC_NODE__PREV(first);
+    for ( result = 0; result < count; )
+    {
+      FTC_Node  prev = FTC_NODE__PREV( node );
+
+
+      /* don't touch locked nodes */
+      if ( node->ref_count <= 0 )
+      {
+        ftc_node_destroy( node, manager );
+        result++;
+      }
+
+      if ( prev == manager->nodes_list )
+        break;
+
+      node = prev;
+    }
+    return  result;
+  }
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( void )
+  FTC_Manager_RemoveFaceID( FTC_Manager  manager,
+                            FTC_FaceID   face_id )
+  {
+    FT_UInt  nn;
+
+    /* this will remove all FTC_SizeNode that correspond to
+     * the face_id as well
+     */
+    FTC_MruList_RemoveSelection( &manager->faces, NULL, face_id );
+
+    for ( nn = 0; nn < manager->num_caches; nn++ )
+      FTC_Cache_RemoveFaceID( manager->caches[nn], face_id );
+  }
+
+
+  /* documentation is in ftcache.h */
+
+  FT_EXPORT_DEF( void )
+  FTC_Node_Unref( FTC_Node     node,
+                  FTC_Manager  manager )
+  {
+    if ( node && (FT_UInt)node->cache_index < manager->num_caches )
+      node->ref_count--;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftcmru.c b/nx-X11/extras/freetype2/src/cache/ftcmru.c
new file mode 100644
index 000000000..d4f733a11
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftcmru.c
@@ -0,0 +1,355 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcmru.c                                                               */
+/*                                                                         */
+/*    FreeType MRU support (body).                                         */
+/*                                                                         */
+/*  Copyright 2003, 2004 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_CACHE_H
+#include FT_CACHE_INTERNAL_MRU_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+
+#include "ftcerror.h"
+
+
+  FT_EXPORT_DEF( void )
+  FTC_MruNode_Prepend( FTC_MruNode  *plist,
+                       FTC_MruNode   node )
+  {
+    FTC_MruNode  first = *plist;
+
+
+    if ( first )
+    {
+      FTC_MruNode  last = first->prev;
+
+
+#ifdef FT_DEBUG_ERROR
+      {
+        FTC_MruNode  cnode = first;
+
+
+        do
+        {
+          if ( cnode == node )
+          {
+            fprintf( stderr, "FTC_MruNode_Prepend: invalid action!\n" );
+            exit( 2 );
+          }
+          cnode = cnode->next;
+
+        } while ( cnode != first );
+      }
+#endif
+
+      first->prev = node;
+      last->next  = node;
+      node->next  = first;
+      node->prev  = last;
+    }
+    else
+    {
+      node->next = node;
+      node->prev = node;
+    }
+    *plist = node;
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_MruNode_Up( FTC_MruNode  *plist,
+                  FTC_MruNode   node )
+  {
+    FTC_MruNode  first = *plist;
+
+
+    FT_ASSERT( first != NULL );
+
+    if ( first != node )
+    {
+      FTC_MruNode  prev, next, last;
+
+
+#ifdef FT_DEBUG_ERROR
+      {
+        FTC_MruNode  cnode = first;
+        do
+        {
+          if ( cnode == node )
+            goto Ok;
+          cnode = cnode->next;
+
+        } while ( cnode != first );
+
+        fprintf( stderr, "FTC_MruNode_Up: invalid action!\n" );
+        exit( 2 );
+      Ok:
+      }
+#endif
+      prev = node->prev;
+      next = node->next;
+
+      prev->next = next;
+      next->prev = prev;
+
+      last = first->prev;
+
+      last->next  = node;
+      first->prev = node;
+
+      node->next = first;
+      node->prev = last;
+
+      *plist = node;
+    }
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_MruNode_Remove( FTC_MruNode  *plist,
+                      FTC_MruNode   node )
+  {
+    FTC_MruNode  first = *plist;
+    FTC_MruNode  prev, next;
+
+
+    FT_ASSERT( first != NULL );
+
+#ifdef FT_DEBUG_ERROR
+      {
+        FTC_MruNode  cnode = first;
+
+
+        do
+        {
+          if ( cnode == node )
+            goto Ok;
+          cnode = cnode->next;
+
+        } while ( cnode != first );
+
+        fprintf( stderr, "FTC_MruNode_Remove: invalid action!\n" );
+        exit( 2 );
+      Ok:
+      }
+#endif
+
+    prev = node->prev;
+    next = node->next;
+
+    prev->next = next;
+    next->prev = prev;
+
+    if ( node == next )
+    {
+      FT_ASSERT( first == node );
+      FT_ASSERT( prev  == node );
+
+      *plist = NULL;
+    }
+    else if ( node == first )
+        *plist = next;
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_MruList_Init( FTC_MruList       list,
+                    FTC_MruListClass  clazz,
+                    FT_UInt           max_nodes,
+                    FT_Pointer        data,
+                    FT_Memory         memory )
+  {
+    list->num_nodes = 0;
+    list->max_nodes = max_nodes;
+    list->nodes     = NULL;
+    list->clazz     = *clazz;
+    list->data      = data;
+    list->memory    = memory;
+  }
+
+
+  FT_EXPORT( void )
+  FTC_MruList_Reset( FTC_MruList  list )
+  {
+    while ( list->nodes )
+      FTC_MruList_Remove( list, list->nodes );
+
+    FT_ASSERT( list->num_nodes == 0 );
+  }
+
+
+  FT_EXPORT( void )
+  FTC_MruList_Done( FTC_MruList  list )
+  {
+    FTC_MruList_Reset( list );
+  }
+
+
+  FT_EXPORT_DEF( FTC_MruNode )
+  FTC_MruList_Find( FTC_MruList  list,
+                    FT_Pointer   key )
+  {
+    FTC_MruNode_CompareFunc  compare = list->clazz.node_compare;
+    FTC_MruNode              first, node;
+
+
+    first = list->nodes;
+    node  = NULL;
+
+    if ( first )
+    {
+      node = first;
+      do
+      {
+        if ( compare( node, key ) )
+        {
+          if ( node != first )
+            FTC_MruNode_Up( &list->nodes, node );
+
+          return node;
+        }
+
+        node = node->next;
+
+      } while ( node != first);
+    }
+
+    return NULL;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_MruList_New( FTC_MruList   list,
+                   FT_Pointer    key,
+                   FTC_MruNode  *anode )
+  {
+    FT_Error     error;
+    FTC_MruNode  node;
+    FT_Memory    memory = list->memory;
+
+
+    if ( list->num_nodes >= list->max_nodes && list->max_nodes > 0 )
+    {
+      node = list->nodes->prev;
+
+      FT_ASSERT( node );
+
+      if ( list->clazz.node_reset )
+      {
+        FTC_MruNode_Up( &list->nodes, node );
+
+        error = list->clazz.node_reset( node, key, list->data );
+        if ( !error )
+          goto Exit;
+      }
+
+      FTC_MruNode_Remove( &list->nodes, node );
+      list->num_nodes--;
+
+      if ( list->clazz.node_done )
+        list->clazz.node_done( node, list->data );
+    }
+    else if ( FT_ALLOC( node, list->clazz.node_size ) )
+        goto Exit;
+
+    error = list->clazz.node_init( node, key, list->data );
+    if ( error )
+      goto Fail;
+
+      FTC_MruNode_Prepend( &list->nodes, node );
+      list->num_nodes++;
+
+  Exit:
+    *anode = node;
+    return error;
+
+  Fail:
+    if ( list->clazz.node_done )
+      list->clazz.node_done( node, list->data );
+
+    FT_FREE( node );
+    goto Exit;
+  }
+
+
+  FT_EXPORT( FT_Error )
+  FTC_MruList_Lookup( FTC_MruList   list,
+                      FT_Pointer    key,
+                      FTC_MruNode  *anode )
+  {
+    FTC_MruNode  node;
+
+
+    node = FTC_MruList_Find( list, key );
+    if ( node == NULL )
+      return FTC_MruList_New( list, key, anode );
+
+    *anode = node;
+    return 0;
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_MruList_Remove( FTC_MruList  list,
+                      FTC_MruNode  node )
+  {
+    FTC_MruNode_Remove( &list->nodes, node );
+    list->num_nodes--;
+
+    {
+      FT_Memory  memory = list->memory;
+
+
+      if ( list->clazz.node_done )
+       list->clazz.node_done( node, list->data );
+
+      FT_FREE( node );
+    }
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_MruList_RemoveSelection( FTC_MruList              list,
+                               FTC_MruNode_CompareFunc  selection,
+                               FT_Pointer               key )
+  {
+    FTC_MruNode  first, node, next;
+
+
+    first = list->nodes;
+    while ( first && ( selection == NULL || selection( first, key ) ) )
+    {
+      FTC_MruList_Remove( list, first );
+      first = list->nodes;
+    }
+
+    if ( first )
+    {
+      node = first->next;
+      while ( node != first )
+      {
+        next = node->next;
+
+        if ( selection( node, key ) )
+          FTC_MruList_Remove( list, node );
+
+        node = next;
+      }
+    }
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/ftcsbits.c b/nx-X11/extras/freetype2/src/cache/ftcsbits.c
new file mode 100644
index 000000000..2f8c5f8c6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/ftcsbits.c
@@ -0,0 +1,344 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcsbits.c                                                             */
+/*                                                                         */
+/*    FreeType sbits manager (body).                                       */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 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_CACHE_H
+#include FT_CACHE_INTERNAL_SBITS_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_ERRORS_H
+
+#include "ftccback.h"
+#include "ftcerror.h"
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                     SBIT CACHE NODES                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  static FT_Error
+  ftc_sbit_copy_bitmap( FTC_SBit    sbit,
+                        FT_Bitmap*  bitmap,
+                        FT_Memory   memory )
+  {
+    FT_Error  error;
+    FT_Int    pitch = bitmap->pitch;
+    FT_ULong  size;
+
+
+    if ( pitch < 0 )
+      pitch = -pitch;
+
+    size = (FT_ULong)( pitch * bitmap->rows );
+
+    if ( !FT_ALLOC( sbit->buffer, size ) )
+      FT_MEM_COPY( sbit->buffer, bitmap->buffer, size );
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ftc_snode_free( FTC_Node   ftcsnode,
+                  FTC_Cache  cache )
+  {
+    FTC_SNode  snode  = (FTC_SNode)ftcsnode;
+    FTC_SBit   sbit   = snode->sbits;
+    FT_UInt    count  = snode->count;
+    FT_Memory  memory = cache->memory;
+
+
+    for ( ; count > 0; sbit++, count-- )
+      FT_FREE( sbit->buffer );
+
+    FTC_GNode_Done( FTC_GNODE( snode ), cache );
+
+    FT_FREE( snode );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FTC_SNode_Free( FTC_SNode  snode,
+                  FTC_Cache  cache )
+  {
+    ftc_snode_free( FTC_NODE( snode ), cache );
+  }
+
+
+  static FT_Error
+  ftc_snode_load( FTC_SNode    snode,
+                  FTC_Manager  manager,
+                  FT_UInt      gindex,
+                  FT_ULong    *asize )
+  {
+    FT_Error          error;
+    FTC_GNode         gnode  = FTC_GNODE( snode );
+    FTC_Family        family = gnode->family;
+    FT_Memory         memory = manager->memory;
+    FT_Face           face;
+    FTC_SBit          sbit;
+    FTC_SFamilyClass  clazz;
+
+
+    if ( (FT_UInt)(gindex - gnode->gindex) >= snode->count )
+    {
+      FT_ERROR(( "ftc_snode_load: invalid glyph index" ));
+      return FTC_Err_Invalid_Argument;
+    }
+
+    sbit  = snode->sbits + ( gindex - gnode->gindex );
+    clazz = (FTC_SFamilyClass)family->clazz;
+
+    sbit->buffer = 0;
+
+    error = clazz->family_load_glyph( family, gindex, manager, &face );
+    if ( error )
+      goto BadGlyph;
+
+    {
+      FT_Int        temp;
+      FT_GlyphSlot  slot   = face->glyph;
+      FT_Bitmap*    bitmap = &slot->bitmap;
+      FT_Int        xadvance, yadvance;
+
+
+      if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
+      {
+        FT_ERROR(( "%s: glyph loaded didn't return a bitmap!\n",
+                   "ftc_snode_load" ));
+        goto BadGlyph;
+      }
+
+      /* Check that our values fit into 8-bit containers!       */
+      /* If this is not the case, our bitmap is too large       */
+      /* and we will leave it as `missing' with sbit.buffer = 0 */
+
+#define CHECK_CHAR( d )  ( temp = (FT_Char)d, temp == d )
+#define CHECK_BYTE( d )  ( temp = (FT_Byte)d, temp == d )
+
+      /* horizontal advance in pixels */
+      xadvance = ( slot->metrics.horiAdvance + 32 ) >> 6;
+      yadvance = ( slot->metrics.vertAdvance + 32 ) >> 6;
+
+      if ( !CHECK_BYTE( bitmap->rows  )     ||
+           !CHECK_BYTE( bitmap->width )     ||
+           !CHECK_CHAR( bitmap->pitch )     ||
+           !CHECK_CHAR( slot->bitmap_left ) ||
+           !CHECK_CHAR( slot->bitmap_top  ) ||
+           !CHECK_CHAR( xadvance )          ||
+           !CHECK_CHAR( yadvance )          )
+        goto BadGlyph;
+
+      sbit->width     = (FT_Byte)bitmap->width;
+      sbit->height    = (FT_Byte)bitmap->rows;
+      sbit->pitch     = (FT_Char)bitmap->pitch;
+      sbit->left      = (FT_Char)slot->bitmap_left;
+      sbit->top       = (FT_Char)slot->bitmap_top;
+      sbit->xadvance  = (FT_Char)xadvance;
+      sbit->yadvance  = (FT_Char)yadvance;
+      sbit->format    = (FT_Byte)bitmap->pixel_mode;
+      sbit->max_grays = (FT_Byte)(bitmap->num_grays - 1);
+
+      /* copy the bitmap into a new buffer -- ignore error */
+      error = ftc_sbit_copy_bitmap( sbit, bitmap, memory );
+
+      /* now, compute size */
+      if ( asize )
+        *asize = FT_ABS( sbit->pitch ) * sbit->height;
+
+    } /* glyph loading successful */
+
+    /* ignore the errors that might have occurred --   */
+    /* we mark unloaded glyphs with `sbit.buffer == 0' */
+    /* and `width == 255', `height == 0'               */
+    /*                                                 */
+    if ( error && error != FTC_Err_Out_Of_Memory )
+    {
+    BadGlyph:
+      sbit->width  = 255;
+      sbit->height = 0;
+      sbit->buffer = NULL;
+      error        = 0;
+      if ( asize )
+        *asize = 0;
+    }
+
+    return error;
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FTC_SNode_New( FTC_SNode  *psnode,
+                 FTC_GQuery  gquery,
+                 FTC_Cache   cache )
+  {
+    FT_Memory   memory = cache->memory;
+    FT_Error    error;
+    FTC_SNode   snode  = NULL;
+    FT_UInt     gindex = gquery->gindex;
+    FTC_Family  family = gquery->family;
+
+    FTC_SFamilyClass  clazz = FTC_CACHE__SFAMILY_CLASS( cache );
+    FT_UInt           total;
+
+
+    total = clazz->family_get_count( family, cache->manager );
+    if ( total == 0 || gindex >= total )
+    {
+      error = FT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    if ( !FT_NEW( snode ) )
+    {
+      FT_UInt  count, start;
+
+
+      start = gindex - ( gindex % FTC_SBIT_ITEMS_PER_NODE );
+      count = total - start;
+      if ( count > FTC_SBIT_ITEMS_PER_NODE )
+        count = FTC_SBIT_ITEMS_PER_NODE;
+
+      FTC_GNode_Init( FTC_GNODE( snode ), start, family );
+
+      snode->count = count;
+
+      error = ftc_snode_load( snode,
+                              cache->manager,
+                              gindex,
+                              NULL );
+      if ( error )
+      {
+        FTC_SNode_Free( snode, cache );
+        snode = NULL;
+      }
+    }
+
+  Exit:
+    *psnode = snode;
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  ftc_snode_new( FTC_Node   *ftcpsnode,
+                 FT_Pointer  ftcgquery,
+                 FTC_Cache   cache )
+  {
+    FTC_SNode  *psnode = (FTC_SNode*)ftcpsnode;
+    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
+
+
+    return FTC_SNode_New( psnode, gquery, cache );
+  }
+
+
+  FT_LOCAL_DEF( FT_ULong )
+  ftc_snode_weight( FTC_Node   ftcsnode,
+                    FTC_Cache  cache )
+  {
+    FTC_SNode  snode = (FTC_SNode)ftcsnode;
+    FT_UInt    count = snode->count;
+    FTC_SBit   sbit  = snode->sbits;
+    FT_Int     pitch;
+    FT_ULong   size;
+
+    FT_UNUSED( cache );
+
+
+    FT_ASSERT( snode->count <= FTC_SBIT_ITEMS_PER_NODE );
+
+    /* the node itself */
+    size = sizeof ( *snode );
+
+    for ( ; count > 0; count--, sbit++ )
+    {
+      if ( sbit->buffer )
+      {
+        pitch = sbit->pitch;
+        if ( pitch < 0 )
+          pitch = -pitch;
+
+        /* add the size of a given glyph image */
+        size += pitch * sbit->height;
+      }
+    }
+
+    return size;
+  }
+
+
+  FT_EXPORT_DEF( FT_ULong )
+  FTC_SNode_Weight( FTC_SNode  snode )
+  {
+    return ftc_snode_weight( FTC_NODE( snode ), NULL );
+  }
+
+
+  FT_LOCAL_DEF( FT_Bool )
+  ftc_snode_compare( FTC_Node    ftcsnode,
+                     FT_Pointer  ftcgquery,
+                     FTC_Cache   cache )
+  {
+    FTC_SNode   snode  = (FTC_SNode)ftcsnode;
+    FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;
+    FTC_GNode   gnode  = FTC_GNODE( snode );
+    FT_UInt     gindex = gquery->gindex;
+    FT_Bool     result;
+
+
+    result = FT_BOOL( gnode->family == gquery->family                    &&
+                      (FT_UInt)( gindex - gnode->gindex ) < snode->count );
+    if ( result )
+    {
+      /* check if we need to load the glyph bitmap now */
+      FTC_SBit  sbit = snode->sbits + ( gindex - gnode->gindex );
+
+
+      if ( sbit->buffer == NULL && sbit->width != 255 )
+      {
+        FT_ULong  size;
+
+
+        if ( !ftc_snode_load( snode, cache->manager,
+                              gindex, &size ) )
+        {
+          cache->manager->cur_weight += size;
+        }
+      }
+    }
+
+    return result;
+  }
+
+
+  FT_EXPORT_DEF( FT_Bool )
+  FTC_SNode_Compare( FTC_SNode   snode,
+                     FTC_GQuery  gquery,
+                     FTC_Cache   cache )
+  {
+    return ftc_snode_compare( FTC_NODE( snode ), gquery, cache );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cache/rules.mk b/nx-X11/extras/freetype2/src/cache/rules.mk
new file mode 100644
index 000000000..381104ad6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cache/rules.mk
@@ -0,0 +1,80 @@
+#
+# FreeType 2 Cache configuration rules
+#
+
+
+# Copyright 2000, 2001, 2003, 2004 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.
+
+
+# Cache driver directory
+#
+CACHE_DIR   := $(SRC_DIR)/cache
+CACHE_H_DIR := $(PUBLIC_DIR)/cache
+
+# compilation flags for the driver
+#
+CACHE_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(CACHE_DIR))
+
+
+# Cache driver sources (i.e., C files)
+#
+CACHE_DRV_SRC := $(CACHE_DIR)/ftcmru.c   \
+                 $(CACHE_DIR)/ftcmanag.c \
+                 $(CACHE_DIR)/ftcbasic.c \
+                 $(CACHE_DIR)/ftccache.c \
+                 $(CACHE_DIR)/ftcglyph.c \
+                 $(CACHE_DIR)/ftcsbits.c \
+                 $(CACHE_DIR)/ftcimage.c \
+                 $(CACHE_DIR)/ftccmap.c
+
+# Cache driver headers
+#
+CACHE_DRV_H := $(CACHE_H_DIR)/ftcmru.h   \
+               $(CACHE_H_DIR)/ftcmanag.h \
+               $(CACHE_H_DIR)/ftcglyph.h \
+               $(CACHE_H_DIR)/ftcimage.h \
+               $(CACHE_H_DIR)/ftccmap.h  \
+               $(CACHE_DIR)/ftcerror.h   \
+               $(CACHE_DIR)/ftccback.h
+
+
+# Cache driver object(s)
+#
+#   CACHE_DRV_OBJ_M is used during `multi' builds.
+#   CACHE_DRV_OBJ_S is used during `single' builds.
+#
+CACHE_DRV_OBJ_M := $(CACHE_DRV_SRC:$(CACHE_DIR)/%.c=$(OBJ_DIR)/%.$O)
+CACHE_DRV_OBJ_S := $(OBJ_DIR)/ftcache.$O
+
+# Cache driver source file for single build
+#
+CACHE_DRV_SRC_S := $(CACHE_DIR)/ftcache.c
+
+
+# Cache driver - single object
+#
+$(CACHE_DRV_OBJ_S): $(CACHE_DRV_SRC_S) $(CACHE_DRV_SRC) \
+                   $(FREETYPE_H) $(CACHE_DRV_H)
+	$(CACHE_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(CACHE_DRV_SRC_S))
+
+
+# Cache driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(CACHE_DIR)/%.c $(FREETYPE_H) $(CACHE_DRV_H)
+	$(CACHE_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(CACHE_DRV_OBJ_S)
+DRV_OBJS_M += $(CACHE_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cff/Jamfile b/nx-X11/extras/freetype2/src/cff/Jamfile
new file mode 100644
index 000000000..dcf24c818
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/cff Jamfile (c) 2001, 2002 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) cff ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = cffdrivr cffgload cffload cffobjs cffparse cffcmap ;
+  }
+  else
+  {
+    _sources = cff ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/cff Jamfile
diff --git a/nx-X11/extras/freetype2/src/cff/cff.c b/nx-X11/extras/freetype2/src/cff/cff.c
new file mode 100644
index 000000000..e6d8954c9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cff.c
@@ -0,0 +1,29 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cff.c                                                                  */
+/*                                                                         */
+/*    FreeType OpenType driver component (body only).                      */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 "cffdrivr.c"
+#include "cffparse.c"
+#include "cffload.c"
+#include "cffobjs.c"
+#include "cffgload.c"
+#include "cffcmap.c"
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffcmap.c b/nx-X11/extras/freetype2/src/cff/cffcmap.c
new file mode 100644
index 000000000..82e04d236
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffcmap.c
@@ -0,0 +1,326 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffcmap.c                                                              */
+/*                                                                         */
+/*    CFF character mapping table (cmap) support (body).                   */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 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 "cffcmap.h"
+#include "cffload.h"
+
+#include "cfferrs.h"
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****           CFF STANDARD (AND EXPERT) ENCODING CMAPS            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_CALLBACK_DEF( FT_Error )
+  cff_cmap_encoding_init( CFF_CMapStd  cmap )
+  {
+    TT_Face       face     = (TT_Face)FT_CMAP_FACE( cmap );
+    CFF_Font      cff      = (CFF_Font)face->extra.data;
+    CFF_Encoding  encoding = &cff->encoding;
+
+
+    cmap->gids  = encoding->codes;
+
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  cff_cmap_encoding_done( CFF_CMapStd  cmap )
+  {
+    cmap->gids  = NULL;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  cff_cmap_encoding_char_index( CFF_CMapStd  cmap,
+                                FT_UInt32    char_code )
+  {
+    FT_UInt  result = 0;
+
+
+    if ( char_code < 256 )
+      result = cmap->gids[char_code];
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  cff_cmap_encoding_char_next( CFF_CMapStd   cmap,
+                               FT_UInt32    *pchar_code )
+  {
+    FT_UInt    result    = 0;
+    FT_UInt32  char_code = *pchar_code;
+
+
+    *pchar_code = 0;
+
+    if ( char_code < 255 )
+    {
+      FT_UInt  code = (FT_UInt)(char_code + 1);
+
+
+      for (;;)
+      {
+        if ( code >= 256 )
+          break;
+
+        result = cmap->gids[code];
+        if ( result != 0 )
+        {
+          *pchar_code = code;
+          break;
+        }
+
+        code++;
+      }
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  cff_cmap_encoding_class_rec =
+  {
+    sizeof ( CFF_CMapStdRec ),
+
+    (FT_CMap_InitFunc)     cff_cmap_encoding_init,
+    (FT_CMap_DoneFunc)     cff_cmap_encoding_done,
+    (FT_CMap_CharIndexFunc)cff_cmap_encoding_char_index,
+    (FT_CMap_CharNextFunc) cff_cmap_encoding_char_next
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****              CFF SYNTHETIC UNICODE ENCODING CMAP              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_CALLBACK_DEF( FT_Int )
+  cff_cmap_uni_pair_compare( const void*  pair1,
+                             const void*  pair2 )
+  {
+    FT_UInt32  u1 = ((CFF_CMapUniPair)pair1)->unicode;
+    FT_UInt32  u2 = ((CFF_CMapUniPair)pair2)->unicode;
+
+
+    if ( u1 < u2 )
+      return -1;
+
+    if ( u1 > u2 )
+      return +1;
+
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  cff_cmap_unicode_init( CFF_CMapUnicode  cmap )
+  {
+    FT_Error            error;
+    FT_UInt             count;
+    TT_Face             face    = (TT_Face)FT_CMAP_FACE( cmap );
+    FT_Memory           memory  = FT_FACE_MEMORY( face );
+    CFF_Font            cff     = (CFF_Font)face->extra.data;
+    CFF_Charset         charset = &cff->charset;
+    FT_Service_PsCMaps  psnames = (FT_Service_PsCMaps)cff->psnames;
+
+
+    cmap->num_pairs = 0;
+    cmap->pairs     = NULL;
+
+    count = cff->num_glyphs;
+
+    if ( !FT_NEW_ARRAY( cmap->pairs, count ) )
+    {
+      FT_UInt          n, new_count;
+      CFF_CMapUniPair  pair;
+      FT_UInt32        uni_code;
+
+
+      pair = cmap->pairs;
+      for ( n = 0; n < count; n++ )
+      {
+        FT_UInt      sid = charset->sids[n];
+        const char*  gname;
+
+
+        gname = cff_index_get_sid_string( &cff->string_index, sid, psnames );
+
+        /* build unsorted pair table by matching glyph names */
+        if ( gname )
+        {
+          uni_code = psnames->unicode_value( gname );
+
+          if ( uni_code != 0 )
+          {
+            pair->unicode = uni_code;
+            pair->gindex  = n;
+            pair++;
+          }
+
+          FT_FREE( gname );
+        }
+      }
+
+      new_count = (FT_UInt)( pair - cmap->pairs );
+      if ( new_count == 0 )
+      {
+        /* there are no unicode characters in here! */
+        FT_FREE( cmap->pairs );
+        error = CFF_Err_Invalid_Argument;
+      }
+      else
+      {
+        /* re-allocate if the new array is much smaller than the original */
+        /* one                                                            */
+        if ( new_count != count && new_count < count / 2 )
+        {
+          (void)FT_RENEW_ARRAY( cmap->pairs, count, new_count );
+          error = CFF_Err_Ok;
+        }
+
+        /* sort the pairs table to allow efficient binary searches */
+        ft_qsort( cmap->pairs,
+                  new_count,
+                  sizeof ( CFF_CMapUniPairRec ),
+                  cff_cmap_uni_pair_compare );
+
+        cmap->num_pairs = new_count;
+      }
+    }
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  cff_cmap_unicode_done( CFF_CMapUnicode  cmap )
+  {
+    FT_Face    face   = FT_CMAP_FACE( cmap );
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+
+    FT_FREE( cmap->pairs );
+    cmap->num_pairs = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  cff_cmap_unicode_char_index( CFF_CMapUnicode  cmap,
+                               FT_UInt32        char_code )
+  {
+    FT_UInt          min = 0;
+    FT_UInt          max = cmap->num_pairs;
+    FT_UInt          mid;
+    CFF_CMapUniPair  pair;
+
+
+    while ( min < max )
+    {
+      mid  = min + ( max - min ) / 2;
+      pair = cmap->pairs + mid;
+
+      if ( pair->unicode == char_code )
+        return pair->gindex;
+
+      if ( pair->unicode < char_code )
+        min = mid + 1;
+      else
+        max = mid;
+    }
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  cff_cmap_unicode_char_next( CFF_CMapUnicode  cmap,
+                              FT_UInt32       *pchar_code )
+  {
+    FT_UInt    result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+  Restart:
+    {
+      FT_UInt          min = 0;
+      FT_UInt          max = cmap->num_pairs;
+      FT_UInt          mid;
+      CFF_CMapUniPair  pair;
+
+
+      while ( min < max )
+      {
+        mid  = min + ( ( max - min ) >> 1 );
+        pair = cmap->pairs + mid;
+
+        if ( pair->unicode == char_code )
+        {
+          result = pair->gindex;
+          if ( result != 0 )
+            goto Exit;
+
+          char_code++;
+          goto Restart;
+        }
+
+        if ( pair->unicode < char_code )
+          min = mid+1;
+        else
+          max = mid;
+      }
+
+      /* we didn't find it, but we have a pair just above it */
+      char_code = 0;
+
+      if ( min < cmap->num_pairs )
+      {
+        pair   = cmap->pairs + min;
+        result = pair->gindex;
+        if ( result != 0 )
+          char_code = pair->unicode;
+      }
+    }
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  cff_cmap_unicode_class_rec =
+  {
+    sizeof ( CFF_CMapUnicodeRec ),
+
+    (FT_CMap_InitFunc)     cff_cmap_unicode_init,
+    (FT_CMap_DoneFunc)     cff_cmap_unicode_done,
+    (FT_CMap_CharIndexFunc)cff_cmap_unicode_char_index,
+    (FT_CMap_CharNextFunc) cff_cmap_unicode_char_next
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffcmap.h b/nx-X11/extras/freetype2/src/cff/cffcmap.h
new file mode 100644
index 000000000..ceb32cd3c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffcmap.h
@@ -0,0 +1,87 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffcmap.h                                                              */
+/*                                                                         */
+/*    CFF character mapping table (cmap) support (specification).          */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 __CFFCMAP_H__
+#define __CFFCMAP_H__
+
+#include "cffobjs.h"
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****          TYPE1 STANDARD (AND EXPERT) ENCODING CMAPS           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* standard (and expert) encoding cmaps */
+  typedef struct CFF_CMapStdRec_*  CFF_CMapStd;
+
+  typedef struct  CFF_CMapStdRec_
+  {
+    FT_CMapRec  cmap;
+    FT_UShort*  gids;   /* up to 256 elements */
+    
+  } CFF_CMapStdRec;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  cff_cmap_encoding_class_rec;
+
+  
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****               CFF SYNTHETIC UNICODE ENCODING CMAP             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* unicode (synthetic) cmaps */
+  typedef struct CFF_CMapUnicodeRec_*  CFF_CMapUnicode;
+
+  typedef struct  CFF_CMapUniPairRec_
+  {
+    FT_UInt32  unicode;
+    FT_UInt    gindex;
+  
+  } CFF_CMapUniPairRec, *CFF_CMapUniPair;
+
+
+  typedef struct  CFF_CMapUnicodeRec_
+  {
+    FT_CMapRec       cmap;
+    FT_UInt          num_pairs;
+    CFF_CMapUniPair  pairs;
+
+  } CFF_CMapUnicodeRec;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  cff_cmap_unicode_class_rec;
+
+
+FT_END_HEADER
+
+#endif /* __CFFCMAP_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffdrivr.c b/nx-X11/extras/freetype2/src/cff/cffdrivr.c
new file mode 100644
index 000000000..e1f274e84
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffdrivr.c
@@ -0,0 +1,480 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffdrivr.c                                                             */
+/*                                                                         */
+/*    OpenType font driver implementation (body).                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_SFNT_H
+#include FT_TRUETYPE_IDS_H
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+#include FT_SERVICE_POSTSCRIPT_INFO_H
+#include FT_SERVICE_TT_CMAP_H
+
+#include "cffdrivr.h"
+#include "cffgload.h"
+#include "cffload.h"
+#include "cffcmap.h"
+
+#include "cfferrs.h"
+
+#include FT_SERVICE_XFREE86_NAME_H
+#include FT_SERVICE_GLYPH_DICT_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_cffdriver
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                          F A C E S                              ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#undef  PAIR_TAG
+#define PAIR_TAG( left, right )  ( ( (FT_ULong)left << 16 ) | \
+                                     (FT_ULong)right        )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Kerning                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to return the kerning vector between two      */
+  /*    glyphs of the same face.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to the source face object.                 */
+  /*                                                                       */
+  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
+  /*                                                                       */
+  /*    right_glyph :: The index of the right glyph in the kern pair.      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    kerning     :: The kerning vector.  This is in font units for      */
+  /*                   scalable formats, and in pixels for fixed-sizes     */
+  /*                   formats.                                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
+  /*    supported by this function.  Other layouts, or more sophisticated  */
+  /*    kernings, are out of scope of this method (the basic driver        */
+  /*    interface is meant to be simple).                                  */
+  /*                                                                       */
+  /*    They can be implemented by format-specific interfaces.             */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_Error )
+  Get_Kerning( FT_Face     ttface,          /* TT_Face */
+               FT_UInt     left_glyph,
+               FT_UInt     right_glyph,
+               FT_Vector*  kerning )
+  {
+    TT_Face        face = (TT_Face)ttface;
+    TT_Kern0_Pair  pair;
+
+
+    if ( !face )
+      return CFF_Err_Invalid_Face_Handle;
+
+    kerning->x = 0;
+    kerning->y = 0;
+
+    if ( face->kern_pairs )
+    {
+      /* there are some kerning pairs in this font file! */
+      FT_ULong  search_tag = PAIR_TAG( left_glyph, right_glyph );
+      FT_Long   left, right;
+
+
+      left  = 0;
+      right = face->num_kern_pairs - 1;
+
+      while ( left <= right )
+      {
+        FT_Long   middle = left + ( ( right - left ) >> 1 );
+        FT_ULong  cur_pair;
+
+
+        pair     = face->kern_pairs + middle;
+        cur_pair = PAIR_TAG( pair->left, pair->right );
+
+        if ( cur_pair == search_tag )
+          goto Found;
+
+        if ( cur_pair < search_tag )
+          left = middle + 1;
+        else
+          right = middle - 1;
+      }
+    }
+
+  Exit:
+    return CFF_Err_Ok;
+
+  Found:
+    kerning->x = pair->value;
+    goto Exit;
+  }
+
+
+#undef PAIR_TAG
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Load_Glyph                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to load a glyph within a given glyph slot.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    slot        :: A handle to the target slot object where the glyph  */
+  /*                   will be loaded.                                     */
+  /*                                                                       */
+  /*    size        :: A handle to the source face size at which the glyph */
+  /*                   must be scaled, loaded, etc.                        */
+  /*                                                                       */
+  /*    glyph_index :: The index of the glyph in the font file.            */
+  /*                                                                       */
+  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
+  /*                   FT_LOAD_??? constants can be used to control the    */
+  /*                   glyph loading process (e.g., whether the outline    */
+  /*                   should be scaled, whether to load bitmaps or not,   */
+  /*                   whether to hint the outline, etc).                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_Error )
+  Load_Glyph( FT_GlyphSlot  cffslot,        /* CFF_GlyphSlot */
+              FT_Size       cffsize,        /* CFF_Size      */
+              FT_UInt       glyph_index,
+              FT_Int32      load_flags )
+  {
+    FT_Error  error;
+    CFF_GlyphSlot  slot = (CFF_GlyphSlot)cffslot;
+    CFF_Size       size = (CFF_Size)cffsize;
+
+
+    if ( !slot )
+      return CFF_Err_Invalid_Slot_Handle;
+
+    /* check whether we want a scaled outline or bitmap */
+    if ( !size )
+      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
+
+    if ( load_flags & FT_LOAD_NO_SCALE )
+      size = NULL;
+
+    /* reset the size object if necessary */
+    if ( size )
+    {
+      /* these two objects must have the same parent */
+      if ( cffsize->face != cffslot->face )
+        return CFF_Err_Invalid_Face_Handle;
+    }
+
+    /* now load the glyph outline if necessary */
+    error = cff_slot_load( slot, size, glyph_index, load_flags );
+
+    /* force drop-out mode to 2 - irrelevant now */
+    /* slot->outline.dropout_mode = 2; */
+
+    return error;
+  }
+
+
+ /*
+  *  GLYPH DICT SERVICE
+  *
+  */
+
+  static FT_Error
+  cff_get_glyph_name( CFF_Face    face,
+                      FT_UInt     glyph_index,
+                      FT_Pointer  buffer,
+                      FT_UInt     buffer_max )
+  {
+    CFF_Font            font   = (CFF_Font)face->extra.data;
+    FT_Memory           memory = FT_FACE_MEMORY( face );
+    FT_String*          gname;
+    FT_UShort           sid;
+    FT_Service_PsCMaps  psnames;
+    FT_Error            error;
+
+
+    FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
+    if ( !psnames )
+    {
+      FT_ERROR(( "cff_get_glyph_name:" ));
+      FT_ERROR(( " cannot get glyph name from CFF & CEF fonts\n" ));
+      FT_ERROR(( "                   " ));
+      FT_ERROR(( " without the `PSNames' module\n" ));
+      error = CFF_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* first, locate the sid in the charset table */
+    sid = font->charset.sids[glyph_index];
+
+    /* now, lookup the name itself */
+    gname = cff_index_get_sid_string( &font->string_index, sid, psnames );
+
+    if ( gname && buffer_max > 0 )
+    {
+      FT_UInt  len = (FT_UInt)ft_strlen( gname );
+
+
+      if ( len >= buffer_max )
+        len = buffer_max - 1;
+
+      FT_MEM_COPY( buffer, gname, len );
+      ((FT_Byte*)buffer)[len] = 0;
+    }
+
+    FT_FREE( gname );
+    error = CFF_Err_Ok;
+
+    Exit:
+      return error;
+  }
+
+
+  static FT_UInt
+  cff_get_name_index( CFF_Face    face,
+                      FT_String*  glyph_name )
+  {
+    CFF_Font            cff;
+    CFF_Charset         charset;
+    FT_Service_PsCMaps  psnames;
+    FT_Memory           memory = FT_FACE_MEMORY( face );
+    FT_String*          name;
+    FT_UShort           sid;
+    FT_UInt             i;
+    FT_Int              result;
+
+
+    cff     = (CFF_FontRec *)face->extra.data;
+    charset = &cff->charset;
+
+    FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
+    if ( !psnames )
+      return 0;
+
+    for ( i = 0; i < cff->num_glyphs; i++ )
+    {
+      sid = charset->sids[i];
+
+      if ( sid > 390 )
+        name = cff_index_get_name( &cff->string_index, sid - 391 );
+      else
+        name = (FT_String *)psnames->adobe_std_strings( sid );
+
+      result = ft_strcmp( glyph_name, name );
+
+      if ( sid > 390 )
+        FT_FREE( name );
+
+      if ( !result )
+        return i;
+    }
+
+    return 0;
+  }
+
+
+  static const FT_Service_GlyphDictRec  cff_service_glyph_dict =
+  {
+    (FT_GlyphDict_GetNameFunc)  cff_get_glyph_name,
+    (FT_GlyphDict_NameIndexFunc)cff_get_name_index,
+  };
+
+
+ /*
+  *  POSTSCRIPT INFO SERVICE
+  *
+  */
+
+  static FT_Int
+  cff_ps_has_glyph_names( FT_Face  face )
+  {
+    return ( face->face_flags & FT_FACE_FLAG_GLYPH_NAMES ) > 0;
+  }
+
+
+  static const FT_Service_PsInfoRec  cff_service_ps_info =
+  {
+    (PS_GetFontInfoFunc)  NULL,         /* unsupported with CFF fonts */
+    (PS_HasGlyphNamesFunc)cff_ps_has_glyph_names
+  };
+
+
+  /*
+   * TT CMAP INFO
+   *
+   * If the charmap is a synthetic Unicode encoding cmap or 
+   * a Type 1 standard (or expert) encoding cmap, hide TT CMAP INFO 
+   * service defined in SFNT module.
+   *
+   * Otherwise call the service function in the sfnt module.
+   *
+   */
+  static FT_Error
+  cff_get_cmap_info( FT_CharMap    charmap,
+                     TT_CMapInfo  *cmap_info )
+  {
+    FT_CMap   cmap  = FT_CMAP( charmap );
+    FT_Error  error = CFF_Err_Ok;
+
+
+    cmap_info->language = 0;
+
+    if ( cmap->clazz != &cff_cmap_encoding_class_rec && 
+         cmap->clazz != &cff_cmap_unicode_class_rec  )
+    {
+      FT_Face             face    = FT_CMAP_FACE( cmap );
+      FT_Library          library = FT_FACE_LIBRARY( face );
+      FT_Module           sfnt    = FT_Get_Module( library, "sfnt" );
+      FT_Service_TTCMaps  service =
+        (FT_Service_TTCMaps)ft_module_get_service( sfnt,
+                                                   FT_SERVICE_ID_TT_CMAP );
+
+
+      if ( service && service->get_cmap_info )
+        error = service->get_cmap_info( charmap, cmap_info );
+    }
+
+    return error;
+  }
+
+
+  static const FT_Service_TTCMapsRec  cff_service_get_cmap_info =
+  {
+    (TT_CMap_Info_GetFunc)cff_get_cmap_info
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                D R I V E R  I N T E R F A C E                   ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static const FT_ServiceDescRec  cff_services[] =
+  {
+    { FT_SERVICE_ID_XF86_NAME,       FT_XF86_FORMAT_CFF },
+    { FT_SERVICE_ID_POSTSCRIPT_INFO, &cff_service_ps_info },
+#ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
+    { FT_SERVICE_ID_GLYPH_DICT,      &cff_service_glyph_dict },
+#endif
+    { FT_SERVICE_ID_TT_CMAP,         &cff_service_get_cmap_info },
+    { NULL, NULL }
+  };
+
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  cff_get_interface( FT_Module    driver,       /* CFF_Driver */
+                     const char*  module_interface )
+  {
+    FT_Module            sfnt;
+    FT_Module_Interface  result;
+
+
+    result = ft_service_list_lookup( cff_services, module_interface );
+    if ( result != NULL )
+      return  result;
+
+    /* we pass our request to the `sfnt' module */
+    sfnt = FT_Get_Module( driver->library, "sfnt" );
+
+    return sfnt ? sfnt->clazz->get_interface( sfnt, module_interface ) : 0;
+  }
+
+
+  /* The FT_DriverInterface structure is defined in ftdriver.h. */
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  cff_driver_class =
+  {
+    /* begin with the FT_Module_Class fields */
+    {
+      FT_MODULE_FONT_DRIVER       |
+      FT_MODULE_DRIVER_SCALABLE   |
+      FT_MODULE_DRIVER_HAS_HINTER,
+
+      sizeof( CFF_DriverRec ),
+      "cff",
+      0x10000L,
+      0x20000L,
+
+      0,   /* module-specific interface */
+
+      cff_driver_init,
+      cff_driver_done,
+      cff_get_interface,
+    },
+
+    /* now the specific driver fields */
+    sizeof( TT_FaceRec ),
+    sizeof( CFF_SizeRec ),
+    sizeof( CFF_GlyphSlotRec ),
+
+    cff_face_init,
+    cff_face_done,
+    cff_size_init,
+    cff_size_done,
+    cff_slot_init,
+    cff_slot_done,
+
+    cff_point_size_reset,
+    cff_size_reset,
+
+    Load_Glyph,
+
+    Get_Kerning,
+    0,                      /* FT_Face_AttachFunc      */
+    0                       /* FT_Face_GetAdvancesFunc */
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffdrivr.h b/nx-X11/extras/freetype2/src/cff/cffdrivr.h
new file mode 100644
index 000000000..553848c0a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffdrivr.h
@@ -0,0 +1,39 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffdrivr.h                                                             */
+/*                                                                         */
+/*    High-level OpenType driver interface (specification).                */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __CFFDRIVER_H__
+#define __CFFDRIVER_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_CALLBACK_TABLE
+  const FT_Driver_ClassRec  cff_driver_class;
+
+
+FT_END_HEADER
+
+#endif /* __CFFDRIVER_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cfferrs.h b/nx-X11/extras/freetype2/src/cff/cfferrs.h
new file mode 100644
index 000000000..1b2a5c95c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cfferrs.h
@@ -0,0 +1,41 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cfferrs.h                                                              */
+/*                                                                         */
+/*    CFF error codes (specification only).                                */
+/*                                                                         */
+/*  Copyright 2001 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 CFF error enumeration constants.      */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __CFFERRS_H__
+#define __CFFERRS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  CFF_Err_
+#define FT_ERR_BASE    FT_Mod_Err_CFF
+
+
+#include FT_ERRORS_H
+
+#endif /* __CFFERRS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffgload.c b/nx-X11/extras/freetype2/src/cff/cffgload.c
new file mode 100644
index 000000000..934dcb07d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffgload.c
@@ -0,0 +1,2594 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffgload.c                                                             */
+/*                                                                         */
+/*    OpenType Glyph Loader (body).                                        */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_CALC_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_SFNT_H
+#include FT_OUTLINE_H
+#include FT_TRUETYPE_TAGS_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+#include "cffobjs.h"
+#include "cffload.h"
+#include "cffgload.h"
+
+#include "cfferrs.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_cffgload
+
+
+  typedef enum  CFF_Operator_
+  {
+    cff_op_unknown = 0,
+
+    cff_op_rmoveto,
+    cff_op_hmoveto,
+    cff_op_vmoveto,
+
+    cff_op_rlineto,
+    cff_op_hlineto,
+    cff_op_vlineto,
+
+    cff_op_rrcurveto,
+    cff_op_hhcurveto,
+    cff_op_hvcurveto,
+    cff_op_rcurveline,
+    cff_op_rlinecurve,
+    cff_op_vhcurveto,
+    cff_op_vvcurveto,
+
+    cff_op_flex,
+    cff_op_hflex,
+    cff_op_hflex1,
+    cff_op_flex1,
+
+    cff_op_endchar,
+
+    cff_op_hstem,
+    cff_op_vstem,
+    cff_op_hstemhm,
+    cff_op_vstemhm,
+
+    cff_op_hintmask,
+    cff_op_cntrmask,
+    cff_op_dotsection,  /* deprecated, acts as no-op */
+
+    cff_op_abs,
+    cff_op_add,
+    cff_op_sub,
+    cff_op_div,
+    cff_op_neg,
+    cff_op_random,
+    cff_op_mul,
+    cff_op_sqrt,
+
+    cff_op_blend,
+
+    cff_op_drop,
+    cff_op_exch,
+    cff_op_index,
+    cff_op_roll,
+    cff_op_dup,
+
+    cff_op_put,
+    cff_op_get,
+    cff_op_store,
+    cff_op_load,
+
+    cff_op_and,
+    cff_op_or,
+    cff_op_not,
+    cff_op_eq,
+    cff_op_ifelse,
+
+    cff_op_callsubr,
+    cff_op_callgsubr,
+    cff_op_return,
+
+    /* do not remove */
+    cff_op_max
+
+  } CFF_Operator;
+
+
+#define CFF_COUNT_CHECK_WIDTH  0x80
+#define CFF_COUNT_EXACT        0x40
+#define CFF_COUNT_CLEAR_STACK  0x20
+
+
+  static const FT_Byte  cff_argument_counts[] =
+  {
+    0,  /* unknown */
+
+    2 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT, /* rmoveto */
+    1 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT,
+    1 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT,
+
+    0 | CFF_COUNT_CLEAR_STACK, /* rlineto */
+    0 | CFF_COUNT_CLEAR_STACK,
+    0 | CFF_COUNT_CLEAR_STACK,
+
+    0 | CFF_COUNT_CLEAR_STACK, /* rrcurveto */
+    0 | CFF_COUNT_CLEAR_STACK,
+    0 | CFF_COUNT_CLEAR_STACK,
+    0 | CFF_COUNT_CLEAR_STACK,
+    0 | CFF_COUNT_CLEAR_STACK,
+    0 | CFF_COUNT_CLEAR_STACK,
+    0 | CFF_COUNT_CLEAR_STACK,
+
+    13, /* flex */
+    7,
+    9,
+    11,
+
+    0 | CFF_COUNT_CHECK_WIDTH, /* endchar */
+
+    2 | CFF_COUNT_CHECK_WIDTH, /* hstem */
+    2 | CFF_COUNT_CHECK_WIDTH,
+    2 | CFF_COUNT_CHECK_WIDTH,
+    2 | CFF_COUNT_CHECK_WIDTH,
+
+    0 | CFF_COUNT_CHECK_WIDTH, /* hintmask */
+    0 | CFF_COUNT_CHECK_WIDTH, /* cntrmask */
+    0, /* dotsection */
+
+    1, /* abs */
+    2,
+    2,
+    2,
+    1,
+    0,
+    2,
+    1,
+
+    1, /* blend */
+
+    1, /* drop */
+    2,
+    1,
+    2,
+    1,
+
+    2, /* put */
+    1,
+    4,
+    3,
+
+    2, /* and */
+    2,
+    1,
+    2,
+    4,
+
+    1, /* callsubr */
+    1,
+    0
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /**********                                                      *********/
+  /**********                                                      *********/
+  /**********             GENERIC CHARSTRING PARSING               *********/
+  /**********                                                      *********/
+  /**********                                                      *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cff_builder_init                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given glyph builder.                                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    builder :: A pointer to the glyph builder to initialize.           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: The current face object.                                */
+  /*                                                                       */
+  /*    size    :: The current size object.                                */
+  /*                                                                       */
+  /*    glyph   :: The current glyph object.                               */
+  /*                                                                       */
+  static void
+  cff_builder_init( CFF_Builder*   builder,
+                    TT_Face        face,
+                    CFF_Size       size,
+                    CFF_GlyphSlot  glyph,
+                    FT_Bool        hinting )
+  {
+    builder->path_begun  = 0;
+    builder->load_points = 1;
+
+    builder->face   = face;
+    builder->glyph  = glyph;
+    builder->memory = face->root.memory;
+
+    if ( glyph )
+    {
+      FT_GlyphLoader  loader = glyph->root.internal->loader;
+
+
+      builder->loader  = loader;
+      builder->base    = &loader->base.outline;
+      builder->current = &loader->current.outline;
+      FT_GlyphLoader_Rewind( loader );
+
+      builder->hints_globals = 0;
+      builder->hints_funcs   = 0;
+
+      if ( hinting && size )
+      {
+        builder->hints_globals = size->root.internal;
+        builder->hints_funcs   = glyph->root.internal->glyph_hints;
+      }
+    }
+
+    if ( size )
+    {
+      builder->scale_x = size->root.metrics.x_scale;
+      builder->scale_y = size->root.metrics.y_scale;
+    }
+
+    builder->pos_x = 0;
+    builder->pos_y = 0;
+
+    builder->left_bearing.x = 0;
+    builder->left_bearing.y = 0;
+    builder->advance.x      = 0;
+    builder->advance.y      = 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cff_builder_done                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes a given glyph builder.  Its contents can still be used   */
+  /*    after the call, but the function saves important information       */
+  /*    within the corresponding glyph slot.                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    builder :: A pointer to the glyph builder to finalize.             */
+  /*                                                                       */
+  static void
+  cff_builder_done( CFF_Builder*  builder )
+  {
+    CFF_GlyphSlot  glyph = builder->glyph;
+
+
+    if ( glyph )
+      glyph->root.outline = *builder->base;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cff_compute_bias                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the bias value in dependence of the number of glyph       */
+  /*    subroutines.                                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_subrs :: The number of glyph subroutines.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The bias value.                                                    */
+  static FT_Int
+  cff_compute_bias( FT_UInt  num_subrs )
+  {
+    FT_Int  result;
+
+
+    if ( num_subrs < 1240 )
+      result = 107;
+    else if ( num_subrs < 33900U )
+      result = 1131;
+    else
+      result = 32768U;
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cff_decoder_init                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given glyph decoder.                                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    decoder :: A pointer to the glyph builder to initialize.           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: The current face object.                                */
+  /*                                                                       */
+  /*    size    :: The current size object.                                */
+  /*                                                                       */
+  /*    slot    :: The current glyph object.                               */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  cff_decoder_init( CFF_Decoder*    decoder,
+                    TT_Face         face,
+                    CFF_Size        size,
+                    CFF_GlyphSlot   slot,
+                    FT_Bool         hinting,
+                    FT_Render_Mode  hint_mode )
+  {
+    CFF_Font  cff = (CFF_Font)face->extra.data;
+
+
+    /* clear everything */
+    FT_MEM_ZERO( decoder, sizeof ( *decoder ) );
+
+    /* initialize builder */
+    cff_builder_init( &decoder->builder, face, size, slot, hinting );
+
+    /* initialize Type2 decoder */
+    decoder->num_globals  = cff->num_global_subrs;
+    decoder->globals      = cff->global_subrs;
+    decoder->globals_bias = cff_compute_bias( decoder->num_globals );
+
+    decoder->hint_mode    = hint_mode;
+  }
+
+
+  /* this function is used to select the locals subrs array */
+  FT_LOCAL_DEF( void )
+  cff_decoder_prepare( CFF_Decoder*  decoder,
+                       FT_UInt       glyph_index )
+  {
+    CFF_Font     cff = (CFF_Font)decoder->builder.face->extra.data;
+    CFF_SubFont  sub = &cff->top_font;
+
+
+    /* manage CID fonts */
+    if ( cff->num_subfonts >= 1 )
+    {
+      FT_Byte  fd_index = cff_fd_select_get( &cff->fd_select, glyph_index );
+
+
+      sub = cff->subfonts[fd_index];
+    }
+
+    decoder->num_locals    = sub->num_local_subrs;
+    decoder->locals        = sub->local_subrs;
+    decoder->locals_bias   = cff_compute_bias( decoder->num_locals );
+
+    decoder->glyph_width   = sub->private_dict.default_width;
+    decoder->nominal_width = sub->private_dict.nominal_width;
+  }
+
+
+  /* check that there is enough space for `count' more points */
+  static FT_Error
+  check_points( CFF_Builder*  builder,
+                FT_Int        count )
+  {
+    return FT_GlyphLoader_CheckPoints( builder->loader, count, 0 );
+  }
+
+
+  /* add a new point, do not check space */
+  static void
+  cff_builder_add_point( CFF_Builder*  builder,
+                         FT_Pos        x,
+                         FT_Pos        y,
+                         FT_Byte       flag )
+  {
+    FT_Outline*  outline = builder->current;
+
+
+    if ( builder->load_points )
+    {
+      FT_Vector*  point   = outline->points + outline->n_points;
+      FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points;
+
+
+      point->x = x >> 16;
+      point->y = y >> 16;
+      *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
+
+      builder->last = *point;
+    }
+
+    outline->n_points++;
+  }
+
+
+  /* check space for a new on-curve point, then add it */
+  static FT_Error
+  cff_builder_add_point1( CFF_Builder*  builder,
+                          FT_Pos        x,
+                          FT_Pos        y )
+  {
+    FT_Error  error;
+
+
+    error = check_points( builder, 1 );
+    if ( !error )
+      cff_builder_add_point( builder, x, y, 1 );
+
+    return error;
+  }
+
+
+  /* check space for a new contour, then add it */
+  static FT_Error
+  cff_builder_add_contour( CFF_Builder*  builder )
+  {
+    FT_Outline*  outline = builder->current;
+    FT_Error     error;
+
+
+    if ( !builder->load_points )
+    {
+      outline->n_contours++;
+      return CFF_Err_Ok;
+    }
+
+    error = FT_GlyphLoader_CheckPoints( builder->loader, 0, 1 );
+    if ( !error )
+    {
+      if ( outline->n_contours > 0 )
+        outline->contours[outline->n_contours - 1] =
+          (short)( outline->n_points - 1 );
+
+      outline->n_contours++;
+    }
+
+    return error;
+  }
+
+
+  /* if a path was begun, add its first on-curve point */
+  static FT_Error
+  cff_builder_start_point( CFF_Builder*  builder,
+                           FT_Pos        x,
+                           FT_Pos        y )
+  {
+    FT_Error  error = CFF_Err_Ok;
+
+
+    /* test whether we are building a new contour */
+    if ( !builder->path_begun )
+    {
+      builder->path_begun = 1;
+      error = cff_builder_add_contour( builder );
+      if ( !error )
+        error = cff_builder_add_point1( builder, x, y );
+    }
+
+    return error;
+  }
+
+
+  /* close the current contour */
+  static void
+  cff_builder_close_contour( CFF_Builder*  builder )
+  {
+    FT_Outline*  outline = builder->current;
+
+
+    /* XXXX: We must not include the last point in the path if it */
+    /*       is located on the first point.                       */
+    if ( outline->n_points > 1 )
+    {
+      FT_Int      first   = 0;
+      FT_Vector*  p1      = outline->points + first;
+      FT_Vector*  p2      = outline->points + outline->n_points - 1;
+      FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points - 1;
+
+
+      if ( outline->n_contours > 1 )
+      {
+        first = outline->contours[outline->n_contours - 2] + 1;
+        p1    = outline->points + first;
+      }
+
+      /* `delete' last point only if it coincides with the first    */
+      /* point and if it is not a control point (which can happen). */
+      if ( p1->x == p2->x && p1->y == p2->y )
+        if ( *control == FT_CURVE_TAG_ON )
+          outline->n_points--;
+    }
+
+    if ( outline->n_contours > 0 )
+      outline->contours[outline->n_contours - 1] =
+        (short)( outline->n_points - 1 );
+  }
+
+
+  static FT_Int
+  cff_lookup_glyph_by_stdcharcode( CFF_Font  cff,
+                                   FT_Int    charcode )
+  {
+    FT_UInt    n;
+    FT_UShort  glyph_sid;
+
+
+    /* CID-keyed fonts don't have glyph names */
+    if ( !cff->charset.sids )
+      return -1;
+
+    /* check range of standard char code */
+    if ( charcode < 0 || charcode > 255 )
+      return -1;
+
+    /* Get code to SID mapping from `cff_standard_encoding'. */
+    glyph_sid = cff_get_standard_encoding( (FT_UInt)charcode );
+
+    for ( n = 0; n < cff->num_glyphs; n++ )
+    {
+      if ( cff->charset.sids[n] == glyph_sid )
+        return n;
+    }
+
+    return -1;
+  }
+
+
+  static FT_Error
+  cff_get_glyph_data( TT_Face    face,
+                      FT_UInt    glyph_index,
+                      FT_Byte**  pointer,
+                      FT_ULong*  length )
+  {
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    /* For incremental fonts get the character data using the */
+    /* callback function.                                     */
+    if ( face->root.internal->incremental_interface )
+    {
+      FT_Data   data;
+      FT_Error  error =
+                  face->root.internal->incremental_interface->funcs->get_glyph_data(
+                    face->root.internal->incremental_interface->object,
+                    glyph_index, &data );
+
+
+      *pointer = (FT_Byte*)data.pointer;
+      *length = data.length;
+
+      return error;
+    }
+    else
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+    {
+      CFF_Font  cff  = (CFF_Font)(face->extra.data);
+
+
+      return cff_index_access_element( &cff->charstrings_index, glyph_index,
+                                       pointer, length );
+    }
+  }
+
+
+  static void
+  cff_free_glyph_data( TT_Face    face,
+                       FT_Byte**  pointer,
+                       FT_ULong   length )
+  {
+#ifndef FT_CONFIG_OPTION_INCREMENTAL
+    FT_UNUSED( length );
+#endif
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    /* For incremental fonts get the character data using the */
+    /* callback function.                                     */
+    if ( face->root.internal->incremental_interface )
+    {
+      FT_Data data;
+
+
+      data.pointer = *pointer;
+      data.length  = length;
+
+      face->root.internal->incremental_interface->funcs->free_glyph_data(
+        face->root.internal->incremental_interface->object,&data );
+    }
+    else
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+    {
+      CFF_Font  cff = (CFF_Font)(face->extra.data);
+
+
+      cff_index_forget_element( &cff->charstrings_index, pointer );
+    }
+  }
+
+
+  static FT_Error
+  cff_operator_seac( CFF_Decoder*  decoder,
+                     FT_Pos        adx,
+                     FT_Pos        ady,
+                     FT_Int        bchar,
+                     FT_Int        achar )
+  {
+    FT_Error      error;
+    CFF_Builder*  builder = &decoder->builder;
+    FT_Int        bchar_index, achar_index;
+    TT_Face       face = decoder->builder.face;
+    FT_Vector     left_bearing, advance;
+    FT_Byte*      charstring;
+    FT_ULong      charstring_len;
+
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    /* Incremental fonts don't necessarily have valid charsets.        */
+    /* They use the character code, not the glyph index, in this case. */
+    if ( face->root.internal->incremental_interface )
+    {
+      bchar_index = bchar;
+      achar_index = achar;
+    }
+    else
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+    {
+      CFF_Font cff = (CFF_Font)(face->extra.data);
+
+
+      bchar_index = cff_lookup_glyph_by_stdcharcode( cff, bchar );
+      achar_index = cff_lookup_glyph_by_stdcharcode( cff, achar );
+    }
+
+    if ( bchar_index < 0 || achar_index < 0 )
+    {
+      FT_ERROR(( "cff_operator_seac:" ));
+      FT_ERROR(( " invalid seac character code arguments\n" ));
+      return CFF_Err_Syntax_Error;
+    }
+
+    /* If we are trying to load a composite glyph, do not load the */
+    /* accent character and return the array of subglyphs.         */
+    if ( builder->no_recurse )
+    {
+      FT_GlyphSlot    glyph  = (FT_GlyphSlot)builder->glyph;
+      FT_GlyphLoader  loader = glyph->internal->loader;
+      FT_SubGlyph     subg;
+
+
+      /* reallocate subglyph array if necessary */
+      error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 );
+      if ( error )
+        goto Exit;
+
+      subg = loader->current.subglyphs;
+
+      /* subglyph 0 = base character */
+      subg->index = bchar_index;
+      subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
+                    FT_SUBGLYPH_FLAG_USE_MY_METRICS;
+      subg->arg1  = 0;
+      subg->arg2  = 0;
+      subg++;
+
+      /* subglyph 1 = accent character */
+      subg->index = achar_index;
+      subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
+      subg->arg1  = (FT_Int)( adx >> 16 );
+      subg->arg2  = (FT_Int)( ady >> 16 );
+
+      /* set up remaining glyph fields */
+      glyph->num_subglyphs = 2;
+      glyph->subglyphs     = loader->base.subglyphs;
+      glyph->format        = FT_GLYPH_FORMAT_COMPOSITE;
+
+      loader->current.num_subglyphs = 2;
+    }
+
+    FT_GlyphLoader_Prepare( builder->loader );
+
+    /* First load `bchar' in builder */
+    error = cff_get_glyph_data( face, bchar_index,
+                                &charstring, &charstring_len );
+    if ( !error )
+    {
+      error = cff_decoder_parse_charstrings( decoder, charstring,
+                                             charstring_len );
+
+      if ( error )
+        goto Exit;
+
+      cff_free_glyph_data( face, &charstring, charstring_len );
+    }
+
+    /* Save the left bearing and width of the base character */
+    /* as they will be erased by the next load.              */
+
+    left_bearing = builder->left_bearing;
+    advance      = builder->advance;
+
+    builder->left_bearing.x = 0;
+    builder->left_bearing.y = 0;
+
+    builder->pos_x = adx;
+    builder->pos_y = ady;
+
+    /* Now load `achar' on top of the base outline. */
+    error = cff_get_glyph_data( face, achar_index,
+                                &charstring, &charstring_len );
+    if ( !error )
+    {
+      error = cff_decoder_parse_charstrings( decoder, charstring,
+                                             charstring_len );
+
+      if ( error )
+        goto Exit;
+
+      cff_free_glyph_data( face, &charstring, charstring_len );
+    }
+
+    /* Restore the left side bearing and advance width */
+    /* of the base character.                          */
+    builder->left_bearing = left_bearing;
+    builder->advance      = advance;
+
+    builder->pos_x = 0;
+    builder->pos_y = 0;
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cff_decoder_parse_charstrings                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Parses a given Type 2 charstrings program.                         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    decoder         :: The current Type 1 decoder.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charstring_base :: The base of the charstring stream.              */
+  /*                                                                       */
+  /*    charstring_len  :: The length in bytes of the charstring stream.   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  cff_decoder_parse_charstrings( CFF_Decoder*  decoder,
+                                 FT_Byte*      charstring_base,
+                                 FT_ULong      charstring_len )
+  {
+    FT_Error           error;
+    CFF_Decoder_Zone*  zone;
+    FT_Byte*           ip;
+    FT_Byte*           limit;
+    CFF_Builder*       builder = &decoder->builder;
+    FT_Pos             x, y;
+    FT_Fixed           seed;
+    FT_Fixed*          stack;
+
+    T2_Hints_Funcs     hinter;
+
+
+    /* set default width */
+    decoder->num_hints  = 0;
+    decoder->read_width = 1;
+
+    /* compute random seed from stack address of parameter */
+    seed = (FT_Fixed)(char*)&seed           ^
+           (FT_Fixed)(char*)&decoder        ^
+           (FT_Fixed)(char*)&charstring_base;
+    seed = ( seed ^ ( seed >> 10 ) ^ ( seed >> 20 ) ) & 0xFFFFL;
+    if ( seed == 0 )
+      seed = 0x7384;
+
+    /* initialize the decoder */
+    decoder->top  = decoder->stack;
+    decoder->zone = decoder->zones;
+    zone          = decoder->zones;
+    stack         = decoder->top;
+
+    hinter = (T2_Hints_Funcs)builder->hints_funcs;
+
+    builder->path_begun = 0;
+
+    zone->base           = charstring_base;
+    limit = zone->limit  = charstring_base + charstring_len;
+    ip    = zone->cursor = zone->base;
+
+    error = CFF_Err_Ok;
+
+    x = builder->pos_x;
+    y = builder->pos_y;
+
+    /* begin hints recording session, if any */
+    if ( hinter )
+      hinter->open( hinter->hints );
+
+    /* now execute loop */
+    while ( ip < limit )
+    {
+      CFF_Operator  op;
+      FT_Byte       v;
+
+
+      /********************************************************************/
+      /*                                                                  */
+      /* Decode operator or operand                                       */
+      /*                                                                  */
+      v = *ip++;
+      if ( v >= 32 || v == 28 )
+      {
+        FT_Int    shift = 16;
+        FT_Int32  val;
+
+
+        /* this is an operand, push it on the stack */
+        if ( v == 28 )
+        {
+          if ( ip + 1 >= limit )
+            goto Syntax_Error;
+          val = (FT_Short)( ( (FT_Short)ip[0] << 8 ) | ip[1] );
+          ip += 2;
+        }
+        else if ( v < 247 )
+          val = (FT_Long)v - 139;
+        else if ( v < 251 )
+        {
+          if ( ip >= limit )
+            goto Syntax_Error;
+          val = ( (FT_Long)v - 247 ) * 256 + *ip++ + 108;
+        }
+        else if ( v < 255 )
+        {
+          if ( ip >= limit )
+            goto Syntax_Error;
+          val = -( (FT_Long)v - 251 ) * 256 - *ip++ - 108;
+        }
+        else
+        {
+          if ( ip + 3 >= limit )
+            goto Syntax_Error;
+          val = ( (FT_Int32)ip[0] << 24 ) |
+                ( (FT_Int32)ip[1] << 16 ) |
+                ( (FT_Int32)ip[2] <<  8 ) |
+                            ip[3];
+          ip    += 4;
+          shift  = 0;
+        }
+        if ( decoder->top - stack >= CFF_MAX_OPERANDS )
+          goto Stack_Overflow;
+
+        val           <<= shift;
+        *decoder->top++ = val;
+
+#ifdef FT_DEBUG_LEVEL_TRACE
+        if ( !( val & 0xFFFFL ) )
+          FT_TRACE4(( " %ld", (FT_Int32)( val >> 16 ) ));
+        else
+          FT_TRACE4(( " %.2f", val / 65536.0 ));
+#endif
+
+      }
+      else
+      {
+        FT_Fixed*  args     = decoder->top;
+        FT_Int     num_args = (FT_Int)( args - decoder->stack );
+        FT_Int     req_args;
+
+
+        /* find operator */
+        op = cff_op_unknown;
+
+        switch ( v )
+        {
+        case 1:
+          op = cff_op_hstem;
+          break;
+        case 3:
+          op = cff_op_vstem;
+          break;
+        case 4:
+          op = cff_op_vmoveto;
+          break;
+        case 5:
+          op = cff_op_rlineto;
+          break;
+        case 6:
+          op = cff_op_hlineto;
+          break;
+        case 7:
+          op = cff_op_vlineto;
+          break;
+        case 8:
+          op = cff_op_rrcurveto;
+          break;
+        case 10:
+          op = cff_op_callsubr;
+          break;
+        case 11:
+          op = cff_op_return;
+          break;
+        case 12:
+          {
+            if ( ip >= limit )
+              goto Syntax_Error;
+            v = *ip++;
+
+            switch ( v )
+            {
+            case 0:
+              op = cff_op_dotsection;
+              break;
+            case 3:
+              op = cff_op_and;
+              break;
+            case 4:
+              op = cff_op_or;
+              break;
+            case 5:
+              op = cff_op_not;
+              break;
+            case 8:
+              op = cff_op_store;
+              break;
+            case 9:
+              op = cff_op_abs;
+              break;
+            case 10:
+              op = cff_op_add;
+              break;
+            case 11:
+              op = cff_op_sub;
+              break;
+            case 12:
+              op = cff_op_div;
+              break;
+            case 13:
+              op = cff_op_load;
+              break;
+            case 14:
+              op = cff_op_neg;
+              break;
+            case 15:
+              op = cff_op_eq;
+              break;
+            case 18:
+              op = cff_op_drop;
+              break;
+            case 20:
+              op = cff_op_put;
+              break;
+            case 21:
+              op = cff_op_get;
+              break;
+            case 22:
+              op = cff_op_ifelse;
+              break;
+            case 23:
+              op = cff_op_random;
+              break;
+            case 24:
+              op = cff_op_mul;
+              break;
+            case 26:
+              op = cff_op_sqrt;
+              break;
+            case 27:
+              op = cff_op_dup;
+              break;
+            case 28:
+              op = cff_op_exch;
+              break;
+            case 29:
+              op = cff_op_index;
+              break;
+            case 30:
+              op = cff_op_roll;
+              break;
+            case 34:
+              op = cff_op_hflex;
+              break;
+            case 35:
+              op = cff_op_flex;
+              break;
+            case 36:
+              op = cff_op_hflex1;
+              break;
+            case 37:
+              op = cff_op_flex1;
+              break;
+            default:
+              /* decrement ip for syntax error message */
+              ip--;
+            }
+          }
+          break;
+        case 14:
+          op = cff_op_endchar;
+          break;
+        case 16:
+          op = cff_op_blend;
+          break;
+        case 18:
+          op = cff_op_hstemhm;
+          break;
+        case 19:
+          op = cff_op_hintmask;
+          break;
+        case 20:
+          op = cff_op_cntrmask;
+          break;
+        case 21:
+          op = cff_op_rmoveto;
+          break;
+        case 22:
+          op = cff_op_hmoveto;
+          break;
+        case 23:
+          op = cff_op_vstemhm;
+          break;
+        case 24:
+          op = cff_op_rcurveline;
+          break;
+        case 25:
+          op = cff_op_rlinecurve;
+          break;
+        case 26:
+          op = cff_op_vvcurveto;
+          break;
+        case 27:
+          op = cff_op_hhcurveto;
+          break;
+        case 29:
+          op = cff_op_callgsubr;
+          break;
+        case 30:
+          op = cff_op_vhcurveto;
+          break;
+        case 31:
+          op = cff_op_hvcurveto;
+          break;
+        default:
+          ;
+        }
+        if ( op == cff_op_unknown )
+          goto Syntax_Error;
+
+        /* check arguments */
+        req_args = cff_argument_counts[op];
+        if ( req_args & CFF_COUNT_CHECK_WIDTH )
+        {
+          args = stack;
+
+          if ( num_args > 0 && decoder->read_width )
+          {
+            /* If `nominal_width' is non-zero, the number is really a      */
+            /* difference against `nominal_width'.  Else, the number here  */
+            /* is truly a width, not a difference against `nominal_width'. */
+            /* If the font does not set `nominal_width', then              */
+            /* `nominal_width' defaults to zero, and so we can set         */
+            /* `glyph_width' to `nominal_width' plus number on the stack   */
+            /* -- for either case.                                         */
+
+            FT_Int  set_width_ok;
+
+
+            switch ( op )
+            {
+            case cff_op_hmoveto:
+            case cff_op_vmoveto:
+              set_width_ok = num_args & 2;
+              break;
+
+            case cff_op_hstem:
+            case cff_op_vstem:
+            case cff_op_hstemhm:
+            case cff_op_vstemhm:
+            case cff_op_rmoveto:
+            case cff_op_hintmask:
+            case cff_op_cntrmask:
+              set_width_ok = num_args & 1;
+              break;
+
+            case cff_op_endchar:
+              /* If there is a width specified for endchar, we either have */
+              /* 1 argument or 5 arguments.  We like to argue.             */
+              set_width_ok = ( ( num_args == 5 ) || ( num_args == 1 ) );
+              break;
+
+            default:
+              set_width_ok = 0;
+              break;
+            }
+
+            if ( set_width_ok )
+            {
+              decoder->glyph_width = decoder->nominal_width +
+                                       ( stack[0] >> 16 );
+
+              /* Consumed an argument. */
+              num_args--;
+              args++;
+            }
+          }
+
+          decoder->read_width = 0;
+          req_args            = 0;
+        }
+
+        req_args &= 15;
+        if ( num_args < req_args )
+          goto Stack_Underflow;
+        args     -= req_args;
+        num_args -= req_args;
+
+        switch ( op )
+        {
+        case cff_op_hstem:
+        case cff_op_vstem:
+        case cff_op_hstemhm:
+        case cff_op_vstemhm:
+          /* the number of arguments is always even here */
+          FT_TRACE4(( op == cff_op_hstem   ? " hstem"   :
+                    ( op == cff_op_vstem   ? " vstem"   :
+                    ( op == cff_op_hstemhm ? " hstemhm" : " vstemhm" ) ) ));
+
+          if ( hinter )
+            hinter->stems( hinter->hints,
+                           ( op == cff_op_hstem || op == cff_op_hstemhm ),
+                           num_args / 2,
+                           args );
+
+          decoder->num_hints += num_args / 2;
+          args = stack;
+          break;
+
+        case cff_op_hintmask:
+        case cff_op_cntrmask:
+          FT_TRACE4(( op == cff_op_hintmask ? " hintmask" : " cntrmask" ));
+
+          /* implement vstem when needed --                        */
+          /* the specification doesn't say it, but this also works */
+          /* with the 'cntrmask' operator                          */
+          /*                                                       */
+          if ( num_args > 0 )
+          {
+            if ( hinter )
+              hinter->stems( hinter->hints,
+                             0,
+                             num_args / 2,
+                             args );
+
+            decoder->num_hints += num_args / 2;
+          }
+
+          if ( hinter )
+          {
+            if ( op == cff_op_hintmask )
+              hinter->hintmask( hinter->hints,
+                                builder->current->n_points,
+                                decoder->num_hints,
+                                ip );
+            else
+              hinter->counter( hinter->hints,
+                               decoder->num_hints,
+                               ip );
+          }
+
+#ifdef FT_DEBUG_LEVEL_TRACE
+          {
+            FT_UInt maskbyte;
+
+
+            FT_TRACE4(( " " ));
+
+            for ( maskbyte = 0;
+                  maskbyte < (FT_UInt)(( decoder->num_hints + 7 ) >> 3);
+                  maskbyte++, ip++ )
+              FT_TRACE4(( "0x%02X", *ip ));
+          }
+#else
+          ip += ( decoder->num_hints + 7 ) >> 3;
+#endif
+          if ( ip >= limit )
+            goto Syntax_Error;
+          args = stack;
+          break;
+
+        case cff_op_rmoveto:
+          FT_TRACE4(( " rmoveto" ));
+
+          cff_builder_close_contour( builder );
+          builder->path_begun = 0;
+          x   += args[0];
+          y   += args[1];
+          args = stack;
+          break;
+
+        case cff_op_vmoveto:
+          FT_TRACE4(( " vmoveto" ));
+
+          cff_builder_close_contour( builder );
+          builder->path_begun = 0;
+          y   += args[0];
+          args = stack;
+          break;
+
+        case cff_op_hmoveto:
+          FT_TRACE4(( " hmoveto" ));
+
+          cff_builder_close_contour( builder );
+          builder->path_begun = 0;
+          x   += args[0];
+          args = stack;
+          break;
+
+        case cff_op_rlineto:
+          FT_TRACE4(( " rlineto" ));
+
+          if ( cff_builder_start_point ( builder, x, y ) ||
+               check_points( builder, num_args / 2 )     )
+            goto Fail;
+
+          if ( num_args < 2 || num_args & 1 )
+            goto Stack_Underflow;
+
+          args = stack;
+          while ( args < decoder->top )
+          {
+            x += args[0];
+            y += args[1];
+            cff_builder_add_point( builder, x, y, 1 );
+            args += 2;
+          }
+          args = stack;
+          break;
+
+        case cff_op_hlineto:
+        case cff_op_vlineto:
+          {
+            FT_Int  phase = ( op == cff_op_hlineto );
+
+
+            FT_TRACE4(( op == cff_op_hlineto ? " hlineto"
+                                             : " vlineto" ));
+
+            if ( cff_builder_start_point ( builder, x, y ) ||
+                 check_points( builder, num_args )         )
+              goto Fail;
+
+            args = stack;
+            while (args < decoder->top )
+            {
+              if ( phase )
+                x += args[0];
+              else
+                y += args[0];
+
+              if ( cff_builder_add_point1( builder, x, y ) )
+                goto Fail;
+
+              args++;
+              phase ^= 1;
+            }
+            args = stack;
+          }
+          break;
+
+        case cff_op_rrcurveto:
+          FT_TRACE4(( " rrcurveto" ));
+
+          /* check number of arguments; must be a multiple of 6 */
+          if ( num_args % 6 != 0 )
+            goto Stack_Underflow;
+
+          if ( cff_builder_start_point ( builder, x, y ) ||
+               check_points( builder, num_args / 2 )     )
+            goto Fail;
+
+          args = stack;
+          while ( args < decoder->top )
+          {
+            x += args[0];
+            y += args[1];
+            cff_builder_add_point( builder, x, y, 0 );
+            x += args[2];
+            y += args[3];
+            cff_builder_add_point( builder, x, y, 0 );
+            x += args[4];
+            y += args[5];
+            cff_builder_add_point( builder, x, y, 1 );
+            args += 6;
+          }
+          args = stack;
+          break;
+
+        case cff_op_vvcurveto:
+          FT_TRACE4(( " vvcurveto" ));
+
+          if ( cff_builder_start_point( builder, x, y ) )
+            goto Fail;
+
+          args = stack;
+          if ( num_args & 1 )
+          {
+            x += args[0];
+            args++;
+            num_args--;
+          }
+
+          if ( num_args % 4 != 0 )
+            goto Stack_Underflow;
+
+          if ( check_points( builder, 3 * ( num_args / 4 ) ) )
+            goto Fail;
+
+          while ( args < decoder->top )
+          {
+            y += args[0];
+            cff_builder_add_point( builder, x, y, 0 );
+            x += args[1];
+            y += args[2];
+            cff_builder_add_point( builder, x, y, 0 );
+            y += args[3];
+            cff_builder_add_point( builder, x, y, 1 );
+            args += 4;
+          }
+          args = stack;
+          break;
+
+        case cff_op_hhcurveto:
+          FT_TRACE4(( " hhcurveto" ));
+
+          if ( cff_builder_start_point( builder, x, y ) )
+            goto Fail;
+
+          args = stack;
+          if ( num_args & 1 )
+          {
+            y += args[0];
+            args++;
+            num_args--;
+          }
+
+          if ( num_args % 4 != 0 )
+            goto Stack_Underflow;
+
+          if ( check_points( builder, 3 * ( num_args / 4 ) ) )
+            goto Fail;
+
+          while ( args < decoder->top )
+          {
+            x += args[0];
+            cff_builder_add_point( builder, x, y, 0 );
+            x += args[1];
+            y += args[2];
+            cff_builder_add_point( builder, x, y, 0 );
+            x += args[3];
+            cff_builder_add_point( builder, x, y, 1 );
+            args += 4;
+          }
+          args = stack;
+          break;
+
+        case cff_op_vhcurveto:
+        case cff_op_hvcurveto:
+          {
+            FT_Int  phase;
+
+
+            FT_TRACE4(( op == cff_op_vhcurveto ? " vhcurveto"
+                                               : " hvcurveto" ));
+
+            if ( cff_builder_start_point( builder, x, y ) )
+              goto Fail;
+
+            args = stack;
+            if (num_args < 4 || ( num_args % 4 ) > 1 )
+              goto Stack_Underflow;
+
+            if ( check_points( builder, ( num_args / 4 ) * 3 ) )
+              goto Stack_Underflow;
+
+            phase = ( op == cff_op_hvcurveto );
+
+            while ( num_args >= 4 )
+            {
+              num_args -= 4;
+              if ( phase )
+              {
+                x += args[0];
+                cff_builder_add_point( builder, x, y, 0 );
+                x += args[1];
+                y += args[2];
+                cff_builder_add_point( builder, x, y, 0 );
+                y += args[3];
+                if ( num_args == 1 )
+                  x += args[4];
+                cff_builder_add_point( builder, x, y, 1 );
+              }
+              else
+              {
+                y += args[0];
+                cff_builder_add_point( builder, x, y, 0 );
+                x += args[1];
+                y += args[2];
+                cff_builder_add_point( builder, x, y, 0 );
+                x += args[3];
+                if ( num_args == 1 )
+                  y += args[4];
+                cff_builder_add_point( builder, x, y, 1 );
+              }
+              args  += 4;
+              phase ^= 1;
+            }
+            args = stack;
+          }
+          break;
+
+        case cff_op_rlinecurve:
+          {
+            FT_Int  num_lines = ( num_args - 6 ) / 2;
+
+
+            FT_TRACE4(( " rlinecurve" ));
+
+            if ( num_args < 8 || ( num_args - 6 ) & 1 )
+              goto Stack_Underflow;
+
+            if ( cff_builder_start_point( builder, x, y ) ||
+                 check_points( builder, num_lines + 3 )   )
+              goto Fail;
+
+            args = stack;
+
+            /* first, add the line segments */
+            while ( num_lines > 0 )
+            {
+              x += args[0];
+              y += args[1];
+              cff_builder_add_point( builder, x, y, 1 );
+              args += 2;
+              num_lines--;
+            }
+
+            /* then the curve */
+            x += args[0];
+            y += args[1];
+            cff_builder_add_point( builder, x, y, 0 );
+            x += args[2];
+            y += args[3];
+            cff_builder_add_point( builder, x, y, 0 );
+            x += args[4];
+            y += args[5];
+            cff_builder_add_point( builder, x, y, 1 );
+            args = stack;
+          }
+          break;
+
+        case cff_op_rcurveline:
+          {
+            FT_Int  num_curves = ( num_args - 2 ) / 6;
+
+
+            FT_TRACE4(( " rcurveline" ));
+
+            if ( num_args < 8 || ( num_args - 2 ) % 6 )
+              goto Stack_Underflow;
+
+            if ( cff_builder_start_point ( builder, x, y ) ||
+                 check_points( builder, num_curves*3 + 2 ) )
+              goto Fail;
+
+            args = stack;
+
+            /* first, add the curves */
+            while ( num_curves > 0 )
+            {
+              x += args[0];
+              y += args[1];
+              cff_builder_add_point( builder, x, y, 0 );
+              x += args[2];
+              y += args[3];
+              cff_builder_add_point( builder, x, y, 0 );
+              x += args[4];
+              y += args[5];
+              cff_builder_add_point( builder, x, y, 1 );
+              args += 6;
+              num_curves--;
+            }
+
+            /* then the final line */
+            x += args[0];
+            y += args[1];
+            cff_builder_add_point( builder, x, y, 1 );
+            args = stack;
+          }
+          break;
+
+        case cff_op_hflex1:
+          {
+            FT_Pos start_y;
+
+
+            FT_TRACE4(( " hflex1" ));
+
+            args = stack;
+
+            /* adding five more points; 4 control points, 1 on-curve point */
+            /* make sure we have enough space for the start point if it    */
+            /* needs to be added                                           */
+            if ( cff_builder_start_point( builder, x, y ) ||
+                 check_points( builder, 6 )               )
+              goto Fail;
+
+            /* Record the starting point's y postion for later use */
+            start_y = y;
+
+            /* first control point */
+            x += args[0];
+            y += args[1];
+            cff_builder_add_point( builder, x, y, 0 );
+
+            /* second control point */
+            x += args[2];
+            y += args[3];
+            cff_builder_add_point( builder, x, y, 0 );
+
+            /* join point; on curve, with y-value the same as the last */
+            /* control point's y-value                                 */
+            x += args[4];
+            cff_builder_add_point( builder, x, y, 1 );
+
+            /* third control point, with y-value the same as the join */
+            /* point's y-value                                        */
+            x += args[5];
+            cff_builder_add_point( builder, x, y, 0 );
+
+            /* fourth control point */
+            x += args[6];
+            y += args[7];
+            cff_builder_add_point( builder, x, y, 0 );
+
+            /* ending point, with y-value the same as the start   */
+            x += args[8];
+            y  = start_y;
+            cff_builder_add_point( builder, x, y, 1 );
+
+            args = stack;
+            break;
+          }
+
+        case cff_op_hflex:
+          {
+            FT_Pos start_y;
+
+
+            FT_TRACE4(( " hflex" ));
+
+            args = stack;
+
+            /* adding six more points; 4 control points, 2 on-curve points */
+            if ( cff_builder_start_point( builder, x, y ) ||
+                 check_points( builder, 6 )               )
+              goto Fail;
+
+            /* record the starting point's y-position for later use */
+            start_y = y;
+
+            /* first control point */
+            x += args[0];
+            cff_builder_add_point( builder, x, y, 0 );
+
+            /* second control point */
+            x += args[1];
+            y += args[2];
+            cff_builder_add_point( builder, x, y, 0 );
+
+            /* join point; on curve, with y-value the same as the last */
+            /* control point's y-value                                 */
+            x += args[3];
+            cff_builder_add_point( builder, x, y, 1 );
+
+            /* third control point, with y-value the same as the join */
+            /* point's y-value                                        */
+            x += args[4];
+            cff_builder_add_point( builder, x, y, 0 );
+
+            /* fourth control point */
+            x += args[5];
+            y  = start_y;
+            cff_builder_add_point( builder, x, y, 0 );
+
+            /* ending point, with y-value the same as the start point's */
+            /* y-value -- we don't add this point, though               */
+            x += args[6];
+            cff_builder_add_point( builder, x, y, 1 );
+
+            args = stack;
+            break;
+          }
+
+        case cff_op_flex1:
+          {
+            FT_Pos    start_x, start_y; /* record start x, y values for */
+                                        /* alter use                                */
+            FT_Fixed  dx = 0, dy = 0;   /* used in horizontal/vertical  */
+                                        /* algorithm below              */
+            FT_Int    horizontal, count;
+
+
+            FT_TRACE4(( " flex1" ));
+
+            /* adding six more points; 4 control points, 2 on-curve points */
+            if ( cff_builder_start_point( builder, x, y ) ||
+                 check_points( builder, 6 )               )
+              goto Fail;
+
+            /* record the starting point's x, y postion for later use */
+            start_x = x;
+            start_y = y;
+
+            /* XXX: figure out whether this is supposed to be a horizontal */
+            /*      or vertical flex; the Type 2 specification is vague... */
+
+            args = stack;
+
+            /* grab up to the last argument */
+            for ( count = 5; count > 0; count-- )
+            {
+              dx += args[0];
+              dy += args[1];
+              args += 2;
+            }
+
+            /* rewind */
+            args = stack;
+
+            if ( dx < 0 ) dx = -dx;
+            if ( dy < 0 ) dy = -dy;
+
+            /* strange test, but here it is... */
+            horizontal = ( dx > dy );
+
+            for ( count = 5; count > 0; count-- )
+            {
+              x += args[0];
+              y += args[1];
+              cff_builder_add_point( builder, x, y, (FT_Bool)( count == 3 ) );
+              args += 2;
+            }
+
+            /* is last operand an x- or y-delta? */
+            if ( horizontal )
+            {
+              x += args[0];
+              y  = start_y;
+            }
+            else
+            {
+              x  = start_x;
+              y += args[0];
+            }
+
+            cff_builder_add_point( builder, x, y, 1 );
+
+            args = stack;
+            break;
+           }
+
+        case cff_op_flex:
+          {
+            FT_UInt  count;
+
+
+            FT_TRACE4(( " flex" ));
+
+            if ( cff_builder_start_point( builder, x, y ) ||
+                 check_points( builder, 6 )               )
+              goto Fail;
+
+            args = stack;
+            for ( count = 6; count > 0; count-- )
+            {
+              x += args[0];
+              y += args[1];
+              cff_builder_add_point( builder, x, y,
+                                     (FT_Bool)( count == 4 || count == 1 ) );
+              args += 2;
+            }
+
+            args = stack;
+          }
+          break;
+
+        case cff_op_endchar:
+          FT_TRACE4(( " endchar" ));
+
+          /* We are going to emulate the seac operator. */
+          if ( num_args == 4 )
+          {
+            /* Save glyph width so that the subglyphs don't overwrite it. */
+            FT_Pos  glyph_width = decoder->glyph_width;
+
+
+            error = cff_operator_seac( decoder,
+                                       args[0],
+                                       args[1],
+                                       (FT_Int)( args[2] >> 16 ),
+                                       (FT_Int)( args[3] >> 16 ) );
+            args += 4;
+
+            decoder->glyph_width = glyph_width;
+          }
+          else
+          {
+            if ( !error )
+              error = CFF_Err_Ok;
+
+            cff_builder_close_contour( builder );
+
+            /* close hints recording session */
+            if ( hinter )
+            {
+              if (hinter->close( hinter->hints, builder->current->n_points ) )
+                goto Syntax_Error;
+
+              /* apply hints to the loaded glyph outline now */
+              hinter->apply( hinter->hints,
+                             builder->current,
+                             (PSH_Globals)builder->hints_globals,
+                             decoder->hint_mode );
+            }
+
+            /* add current outline to the glyph slot */
+            FT_GlyphLoader_Add( builder->loader );
+          }
+
+          /* return now! */
+          FT_TRACE4(( "\n\n" ));
+          return error;
+
+        case cff_op_abs:
+          FT_TRACE4(( " abs" ));
+
+          if ( args[0] < 0 )
+            args[0] = -args[0];
+          args++;
+          break;
+
+        case cff_op_add:
+          FT_TRACE4(( " add" ));
+
+          args[0] += args[1];
+          args++;
+          break;
+
+        case cff_op_sub:
+          FT_TRACE4(( " sub" ));
+
+          args[0] -= args[1];
+          args++;
+          break;
+
+        case cff_op_div:
+          FT_TRACE4(( " div" ));
+
+          args[0] = FT_DivFix( args[0], args[1] );
+          args++;
+          break;
+
+        case cff_op_neg:
+          FT_TRACE4(( " neg" ));
+
+          args[0] = -args[0];
+          args++;
+          break;
+
+        case cff_op_random:
+          {
+            FT_Fixed  Rand;
+
+
+            FT_TRACE4(( " rand" ));
+
+            Rand = seed;
+            if ( Rand >= 0x8000L )
+              Rand++;
+
+            args[0] = Rand;
+            seed    = FT_MulFix( seed, 0x10000L - seed );
+            if ( seed == 0 )
+              seed += 0x2873;
+            args++;
+          }
+          break;
+
+        case cff_op_mul:
+          FT_TRACE4(( " mul" ));
+
+          args[0] = FT_MulFix( args[0], args[1] );
+          args++;
+          break;
+
+        case cff_op_sqrt:
+          FT_TRACE4(( " sqrt" ));
+
+          if ( args[0] > 0 )
+          {
+            FT_Int    count = 9;
+            FT_Fixed  root  = args[0];
+            FT_Fixed  new_root;
+
+
+            for (;;)
+            {
+              new_root = ( root + FT_DivFix( args[0], root ) + 1 ) >> 1;
+              if ( new_root == root || count <= 0 )
+                break;
+              root = new_root;
+            }
+            args[0] = new_root;
+          }
+          else
+            args[0] = 0;
+          args++;
+          break;
+
+        case cff_op_drop:
+          /* nothing */
+          FT_TRACE4(( " drop" ));
+
+          break;
+
+        case cff_op_exch:
+          {
+            FT_Fixed  tmp;
+
+
+            FT_TRACE4(( " exch" ));
+
+            tmp     = args[0];
+            args[0] = args[1];
+            args[1] = tmp;
+            args   += 2;
+          }
+          break;
+
+        case cff_op_index:
+          {
+            FT_Int  idx = (FT_Int)( args[0] >> 16 );
+
+
+            FT_TRACE4(( " index" ));
+
+            if ( idx < 0 )
+              idx = 0;
+            else if ( idx > num_args - 2 )
+              idx = num_args - 2;
+            args[0] = args[-( idx + 1 )];
+            args++;
+          }
+          break;
+
+        case cff_op_roll:
+          {
+            FT_Int  count = (FT_Int)( args[0] >> 16 );
+            FT_Int  idx   = (FT_Int)( args[1] >> 16 );
+
+
+            FT_TRACE4(( " roll" ));
+
+            if ( count <= 0 )
+              count = 1;
+
+            args -= count;
+            if ( args < stack )
+              goto Stack_Underflow;
+
+            if ( idx >= 0 )
+            {
+              while ( idx > 0 )
+              {
+                FT_Fixed  tmp = args[count - 1];
+                FT_Int    i;
+
+
+                for ( i = count - 2; i >= 0; i-- )
+                  args[i + 1] = args[i];
+                args[0] = tmp;
+                idx--;
+              }
+            }
+            else
+            {
+              while ( idx < 0 )
+              {
+                FT_Fixed  tmp = args[0];
+                FT_Int    i;
+
+
+                for ( i = 0; i < count - 1; i++ )
+                  args[i] = args[i + 1];
+                args[count - 1] = tmp;
+                idx++;
+              }
+            }
+            args += count;
+          }
+          break;
+
+        case cff_op_dup:
+          FT_TRACE4(( " dup" ));
+
+          args[1] = args[0];
+          args++;
+          break;
+
+        case cff_op_put:
+          {
+            FT_Fixed  val = args[0];
+            FT_Int    idx = (FT_Int)( args[1] >> 16 );
+
+
+            FT_TRACE4(( " put" ));
+
+            if ( idx >= 0 && idx < decoder->len_buildchar )
+              decoder->buildchar[idx] = val;
+          }
+          break;
+
+        case cff_op_get:
+          {
+            FT_Int    idx = (FT_Int)( args[0] >> 16 );
+            FT_Fixed  val = 0;
+
+
+            FT_TRACE4(( " get" ));
+
+            if ( idx >= 0 && idx < decoder->len_buildchar )
+              val = decoder->buildchar[idx];
+
+            args[0] = val;
+            args++;
+          }
+          break;
+
+        case cff_op_store:
+          FT_TRACE4(( " store "));
+
+          goto Unimplemented;
+
+        case cff_op_load:
+          FT_TRACE4(( " load" ));
+
+          goto Unimplemented;
+
+        case cff_op_dotsection:
+          /* this operator is deprecated and ignored by the parser */
+          FT_TRACE4(( " dotsection" ));
+          break;
+
+        case cff_op_and:
+          {
+            FT_Fixed  cond = args[0] && args[1];
+
+
+            FT_TRACE4(( " and" ));
+
+            args[0] = cond ? 0x10000L : 0;
+            args++;
+          }
+          break;
+
+        case cff_op_or:
+          {
+            FT_Fixed  cond = args[0] || args[1];
+
+
+            FT_TRACE4(( " or" ));
+
+            args[0] = cond ? 0x10000L : 0;
+            args++;
+          }
+          break;
+
+        case cff_op_eq:
+          {
+            FT_Fixed  cond = !args[0];
+
+
+            FT_TRACE4(( " eq" ));
+
+            args[0] = cond ? 0x10000L : 0;
+            args++;
+          }
+          break;
+
+        case cff_op_ifelse:
+          {
+            FT_Fixed  cond = (args[2] <= args[3]);
+
+
+            FT_TRACE4(( " ifelse" ));
+
+            if ( !cond )
+              args[0] = args[1];
+            args++;
+          }
+          break;
+
+        case cff_op_callsubr:
+          {
+            FT_UInt  idx = (FT_UInt)( ( args[0] >> 16 ) +
+                                      decoder->locals_bias );
+
+
+            FT_TRACE4(( " callsubr(%d)", idx ));
+
+            if ( idx >= decoder->num_locals )
+            {
+              FT_ERROR(( "cff_decoder_parse_charstrings:" ));
+              FT_ERROR(( "  invalid local subr index\n" ));
+              goto Syntax_Error;
+            }
+
+            if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
+            {
+              FT_ERROR(( "cff_decoder_parse_charstrings:"
+                         " too many nested subrs\n" ));
+              goto Syntax_Error;
+            }
+
+            zone->cursor = ip;  /* save current instruction pointer */
+
+            zone++;
+            zone->base   = decoder->locals[idx];
+            zone->limit  = decoder->locals[idx + 1];
+            zone->cursor = zone->base;
+
+            if ( !zone->base )
+            {
+              FT_ERROR(( "cff_decoder_parse_charstrings:"
+                         " invoking empty subrs!\n" ));
+              goto Syntax_Error;
+            }
+
+            decoder->zone = zone;
+            ip            = zone->base;
+            limit         = zone->limit;
+          }
+          break;
+
+        case cff_op_callgsubr:
+          {
+            FT_UInt  idx = (FT_UInt)( ( args[0] >> 16 ) +
+                                      decoder->globals_bias );
+
+
+            FT_TRACE4(( " callgsubr(%d)", idx ));
+
+            if ( idx >= decoder->num_globals )
+            {
+              FT_ERROR(( "cff_decoder_parse_charstrings:" ));
+              FT_ERROR(( " invalid global subr index\n" ));
+              goto Syntax_Error;
+            }
+
+            if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
+            {
+              FT_ERROR(( "cff_decoder_parse_charstrings:"
+                         " too many nested subrs\n" ));
+              goto Syntax_Error;
+            }
+
+            zone->cursor = ip;  /* save current instruction pointer */
+
+            zone++;
+            zone->base   = decoder->globals[idx];
+            zone->limit  = decoder->globals[idx + 1];
+            zone->cursor = zone->base;
+
+            if ( !zone->base )
+            {
+              FT_ERROR(( "cff_decoder_parse_charstrings:"
+                         " invoking empty subrs!\n" ));
+              goto Syntax_Error;
+            }
+
+            decoder->zone = zone;
+            ip            = zone->base;
+            limit         = zone->limit;
+          }
+          break;
+
+        case cff_op_return:
+          FT_TRACE4(( " return" ));
+
+          if ( decoder->zone <= decoder->zones )
+          {
+            FT_ERROR(( "cff_decoder_parse_charstrings:"
+                       " unexpected return\n" ));
+            goto Syntax_Error;
+          }
+
+          decoder->zone--;
+          zone  = decoder->zone;
+          ip    = zone->cursor;
+          limit = zone->limit;
+          break;
+
+        default:
+        Unimplemented:
+          FT_ERROR(( "Unimplemented opcode: %d", ip[-1] ));
+
+          if ( ip[-1] == 12 )
+            FT_ERROR(( " %d", ip[0] ));
+          FT_ERROR(( "\n" ));
+
+          return CFF_Err_Unimplemented_Feature;
+        }
+
+      decoder->top = args;
+
+      } /* general operator processing */
+
+    } /* while ip < limit */
+
+    FT_TRACE4(( "..end..\n\n" ));
+
+  Fail:
+    return error;
+
+  Syntax_Error:
+    FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error!" ));
+    return CFF_Err_Invalid_File_Format;
+
+  Stack_Underflow:
+    FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow!" ));
+    return CFF_Err_Too_Few_Arguments;
+
+  Stack_Overflow:
+    FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow!" ));
+    return CFF_Err_Stack_Overflow;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /**********                                                      *********/
+  /**********                                                      *********/
+  /**********            COMPUTE THE MAXIMUM ADVANCE WIDTH         *********/
+  /**********                                                      *********/
+  /**********    The following code is in charge of computing      *********/
+  /**********    the maximum advance width of the font.  It        *********/
+  /**********    quickly processes each glyph charstring to        *********/
+  /**********    extract the value from either a `sbw' or `seac'   *********/
+  /**********    operator.                                         *********/
+  /**********                                                      *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#if 0 /* unused until we support pure CFF fonts */
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_compute_max_advance( TT_Face  face,
+                           FT_Int*  max_advance )
+  {
+    FT_Error     error = CFF_Err_Ok;
+    CFF_Decoder  decoder;
+    FT_Int       glyph_index;
+    CFF_Font     cff = (CFF_Font)face->other;
+
+
+    *max_advance = 0;
+
+    /* Initialize load decoder */
+    cff_decoder_init( &decoder, face, 0, 0, 0, 0 );
+
+    decoder.builder.metrics_only = 1;
+    decoder.builder.load_points  = 0;
+
+    /* For each glyph, parse the glyph charstring and extract */
+    /* the advance width.                                     */
+    for ( glyph_index = 0; glyph_index < face->root.num_glyphs;
+          glyph_index++ )
+    {
+      FT_Byte*  charstring;
+      FT_ULong  charstring_len;
+
+
+      /* now get load the unscaled outline */
+      error = cff_get_glyph_data( face, glyph_index,
+                                  &charstring, &charstring_len );
+      if ( !error )
+      {
+        cff_decoder_prepare( &decoder, glyph_index );
+        error = cff_decoder_parse_charstrings( &decoder,
+                                               charstring, charstring_len );
+
+        cff_free_glyph_data( face, &charstring, &charstring_len );
+      }
+
+      /* ignore the error if one has occurred -- skip to next glyph */
+      error = CFF_Err_Ok;
+    }
+
+    *max_advance = decoder.builder.advance.x;
+
+    return CFF_Err_Ok;
+  }
+
+
+#endif /* 0 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /**********                                                      *********/
+  /**********                                                      *********/
+  /**********               UNHINTED GLYPH LOADER                  *********/
+  /**********                                                      *********/
+  /**********    The following code is in charge of loading a      *********/
+  /**********    single outline.  It completely ignores hinting    *********/
+  /**********    and is used when FT_LOAD_NO_HINTING is set.       *********/
+  /**********                                                      *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_slot_load( CFF_GlyphSlot  glyph,
+                 CFF_Size       size,
+                 FT_Int         glyph_index,
+                 FT_Int32       load_flags )
+  {
+    FT_Error      error;
+    CFF_Decoder   decoder;
+    TT_Face       face     = (TT_Face)glyph->root.face;
+    FT_Bool       hinting;
+    CFF_Font      cff      = (CFF_Font)face->extra.data;
+
+    FT_Matrix     font_matrix;
+    FT_Vector     font_offset;
+
+
+    if ( load_flags & FT_LOAD_NO_RECURSE )
+      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
+
+    glyph->x_scale = 0x10000L;
+    glyph->y_scale = 0x10000L;
+    if ( size )
+    {
+      glyph->x_scale = size->root.metrics.x_scale;
+      glyph->y_scale = size->root.metrics.y_scale;
+    }
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    /* try to load embedded bitmap if any              */
+    /*                                                 */
+    /* XXX: The convention should be emphasized in     */
+    /*      the documents because it can be confusing. */
+    if ( size )
+    {
+      CFF_Face      cff_face = (CFF_Face)size->root.face;
+      SFNT_Service  sfnt     = (SFNT_Service)cff_face->sfnt;
+      FT_Stream     stream   = cff_face->root.stream;
+
+
+      if ( size->strike_index != 0xFFFFU           &&
+           sfnt->load_sbits                        &&
+           ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
+      {
+        TT_SBit_MetricsRec  metrics;
+
+
+        error = sfnt->load_sbit_image( face,
+                                       (FT_ULong)size->strike_index,
+                                       (FT_UInt)glyph_index,
+                                       (FT_Int)load_flags,
+                                       stream,
+                                       &glyph->root.bitmap,
+                                       &metrics );
+
+        if ( !error )
+        {
+          glyph->root.outline.n_points   = 0;
+          glyph->root.outline.n_contours = 0;
+
+          glyph->root.metrics.width  = (FT_Pos)metrics.width  << 6;
+          glyph->root.metrics.height = (FT_Pos)metrics.height << 6;
+
+          glyph->root.metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6;
+          glyph->root.metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6;
+          glyph->root.metrics.horiAdvance  = (FT_Pos)metrics.horiAdvance  << 6;
+
+          glyph->root.metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6;
+          glyph->root.metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6;
+          glyph->root.metrics.vertAdvance  = (FT_Pos)metrics.vertAdvance  << 6;
+
+          glyph->root.format = FT_GLYPH_FORMAT_BITMAP;
+
+          if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
+          {
+            glyph->root.bitmap_left = metrics.vertBearingX;
+            glyph->root.bitmap_top  = metrics.vertBearingY;
+          }
+          else
+          {
+            glyph->root.bitmap_left = metrics.horiBearingX;
+            glyph->root.bitmap_top  = metrics.horiBearingY;
+          }
+          return error;
+        }
+      }
+    }
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+    /* return immediately if we only want the embedded bitmaps */
+    if ( load_flags & FT_LOAD_SBITS_ONLY )
+      return CFF_Err_Invalid_Argument;
+
+    glyph->root.outline.n_points   = 0;
+    glyph->root.outline.n_contours = 0;
+
+    hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE   ) == 0 &&
+                       ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
+
+    glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;  /* by default */
+
+    {
+      FT_Byte*  charstring;
+      FT_ULong  charstring_len;
+
+
+      /* in a CID-keyed font, consider `glyph_index' as a CID and map */
+      /* it immediately to the real glyph_index -- if it isn't a      */
+      /* subsetted font, glyph_indices and CIDs are identical, though */
+      if ( cff->top_font.font_dict.cid_registry != 0xFFFFU &&
+           cff->charset.cids )
+        glyph_index = cff->charset.cids[glyph_index];
+
+      cff_decoder_init( &decoder, face, size, glyph, hinting,
+                        FT_LOAD_TARGET_MODE( load_flags ) );
+
+      decoder.builder.no_recurse =
+        (FT_Bool)( ( load_flags & FT_LOAD_NO_RECURSE ) != 0 );
+
+      /* now load the unscaled outline */
+      error = cff_get_glyph_data( face, glyph_index,
+                                  &charstring, &charstring_len );
+      if ( !error )
+      {
+        cff_decoder_prepare( &decoder, glyph_index );
+        error = cff_decoder_parse_charstrings( &decoder,
+                                               charstring, charstring_len );
+
+        cff_free_glyph_data( face, &charstring, charstring_len );
+
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+        /* Control data and length may not be available for incremental   */
+        /* fonts.                                                         */
+        if ( face->root.internal->incremental_interface )
+        {
+          glyph->root.control_data = 0;
+          glyph->root.control_len = 0;
+        }
+        else
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+        /* We set control_data and control_len if charstrings is loaded.  */
+        /* See how charstring loads at cff_index_access_element() in      */
+        /* cffload.c.                                                     */
+        {
+          CFF_IndexRec csindex = cff->charstrings_index;
+
+
+          glyph->root.control_data =
+            csindex.bytes + csindex.offsets[glyph_index] - 1;
+          glyph->root.control_len =
+            charstring_len;
+        }
+      }
+
+      /* save new glyph tables */
+      cff_builder_done( &decoder.builder );
+    }
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    /* Incremental fonts can optionally override the metrics. */
+    if ( !error                                                              &&
+         face->root.internal->incremental_interface                          &&
+         face->root.internal->incremental_interface->funcs->get_glyph_metrics )
+    {
+      FT_Incremental_MetricsRec  metrics;
+
+
+      metrics.bearing_x = decoder.builder.left_bearing.x;
+      metrics.bearing_y = decoder.builder.left_bearing.y;
+      metrics.advance   = decoder.builder.advance.x;
+      error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
+                face->root.internal->incremental_interface->object,
+                glyph_index, FALSE, &metrics );
+      decoder.builder.left_bearing.x = metrics.bearing_x;
+      decoder.builder.left_bearing.y = metrics.bearing_y;
+      decoder.builder.advance.x      = metrics.advance;
+      decoder.builder.advance.y      = 0;
+    }
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+    font_matrix = cff->top_font.font_dict.font_matrix;
+    font_offset = cff->top_font.font_dict.font_offset;
+
+    /* Now, set the metrics -- this is rather simple, as   */
+    /* the left side bearing is the xMin, and the top side */
+    /* bearing the yMax.                                   */
+    if ( !error )
+    {
+      /* For composite glyphs, return only left side bearing and */
+      /* advance width.                                          */
+      if ( load_flags & FT_LOAD_NO_RECURSE )
+      {
+        FT_Slot_Internal  internal = glyph->root.internal;
+
+
+        glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
+        glyph->root.metrics.horiAdvance  = decoder.glyph_width;
+        internal->glyph_matrix           = font_matrix;
+        internal->glyph_delta            = font_offset;
+        internal->glyph_transformed      = 1;
+      }
+      else
+      {
+        FT_BBox            cbox;
+        FT_Glyph_Metrics*  metrics = &glyph->root.metrics;
+        FT_Vector          advance;
+
+
+        /* copy the _unscaled_ advance width */
+        metrics->horiAdvance                    = decoder.glyph_width;
+        glyph->root.linearHoriAdvance           = decoder.glyph_width;
+        glyph->root.internal->glyph_transformed = 0;
+
+        /* make up vertical metrics */
+        metrics->vertBearingX = 0;
+        metrics->vertBearingY = 0;
+        metrics->vertAdvance  = 0;
+
+        glyph->root.linearVertAdvance = 0;
+
+        glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;
+
+        glyph->root.outline.flags = 0;
+        if ( size && size->root.metrics.y_ppem < 24 )
+          glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;
+
+        glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;
+
+        /* apply the font matrix */
+        FT_Outline_Transform( &glyph->root.outline, &font_matrix );
+
+        FT_Outline_Translate( &glyph->root.outline,
+                              font_offset.x,
+                              font_offset.y );
+
+        advance.x = metrics->horiAdvance;
+        advance.y = 0;
+        FT_Vector_Transform( &advance, &font_matrix );
+        metrics->horiAdvance = advance.x + font_offset.x;
+        advance.x = 0;
+        advance.y = metrics->vertAdvance;
+        FT_Vector_Transform( &advance, &font_matrix );
+        metrics->vertAdvance = advance.y + font_offset.y;
+
+        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )
+        {
+          /* scale the outline and the metrics */
+          FT_Int       n;
+          FT_Outline*  cur     = &glyph->root.outline;
+          FT_Vector*   vec     = cur->points;
+          FT_Fixed     x_scale = glyph->x_scale;
+          FT_Fixed     y_scale = glyph->y_scale;
+
+
+          /* First of all, scale the points */
+          if ( !hinting )
+            for ( n = cur->n_points; n > 0; n--, vec++ )
+            {
+              vec->x = FT_MulFix( vec->x, x_scale );
+              vec->y = FT_MulFix( vec->y, y_scale );
+            }
+
+          FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
+
+          /* Then scale the metrics */
+          metrics->horiAdvance  = FT_MulFix( metrics->horiAdvance,  x_scale );
+          metrics->vertAdvance  = FT_MulFix( metrics->vertAdvance,  y_scale );
+
+          metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );
+          metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );
+
+          if ( hinting )
+          {
+            metrics->horiAdvance  = FT_PIX_ROUND( metrics->horiAdvance );
+            metrics->vertAdvance  = FT_PIX_ROUND( metrics->vertAdvance );
+
+            metrics->vertBearingX = FT_PIX_ROUND( metrics->vertBearingX );
+            metrics->vertBearingY = FT_PIX_ROUND( metrics->vertBearingY );
+          }
+        }
+
+        /* compute the other metrics */
+        FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
+
+        /* grid fit the bounding box if necessary */
+        if ( hinting )
+        {
+          cbox.xMin &= -64;
+          cbox.yMin &= -64;
+          cbox.xMax  = ( cbox.xMax + 63 ) & -64;
+          cbox.yMax  = ( cbox.yMax + 63 ) & -64;
+        }
+
+        metrics->width  = cbox.xMax - cbox.xMin;
+        metrics->height = cbox.yMax - cbox.yMin;
+
+        metrics->horiBearingX = cbox.xMin;
+        metrics->horiBearingY = cbox.yMax;
+      }
+    }
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffgload.h b/nx-X11/extras/freetype2/src/cff/cffgload.h
new file mode 100644
index 000000000..89ae049b5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffgload.h
@@ -0,0 +1,208 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffgload.h                                                             */
+/*                                                                         */
+/*    OpenType Glyph Loader (specification).                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 __CFFGLOAD_H__
+#define __CFFGLOAD_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include "cffobjs.h"
+
+
+FT_BEGIN_HEADER
+
+
+#define CFF_MAX_OPERANDS     48
+#define CFF_MAX_SUBRS_CALLS  32
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Structure>                                                           */
+  /*    CFF_Builder                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*     A structure used during glyph loading to store its outline.       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    memory        :: The current memory object.                        */
+  /*                                                                       */
+  /*    face          :: The current face object.                          */
+  /*                                                                       */
+  /*    glyph         :: The current glyph slot.                           */
+  /*                                                                       */
+  /*    loader        :: The current glyph loader.                         */
+  /*                                                                       */
+  /*    base          :: The base glyph outline.                           */
+  /*                                                                       */
+  /*    current       :: The current glyph outline.                        */
+  /*                                                                       */
+  /*    last          :: The last point position.                          */
+  /*                                                                       */
+  /*    scale_x       :: The horizontal scale (FUnits to sub-pixels).      */
+  /*                                                                       */
+  /*    scale_y       :: The vertical scale (FUnits to sub-pixels).        */
+  /*                                                                       */
+  /*    pos_x         :: The horizontal translation (if composite glyph).  */
+  /*                                                                       */
+  /*    pos_y         :: The vertical translation (if composite glyph).    */
+  /*                                                                       */
+  /*    left_bearing  :: The left side bearing point.                      */
+  /*                                                                       */
+  /*    advance       :: The horizontal advance vector.                    */
+  /*                                                                       */
+  /*    bbox          :: Unused.                                           */
+  /*                                                                       */
+  /*    path_begun    :: A flag which indicates that a new path has begun. */
+  /*                                                                       */
+  /*    load_points   :: If this flag is not set, no points are loaded.    */
+  /*                                                                       */
+  /*    no_recurse    :: Set but not used.                                 */
+  /*                                                                       */
+  /*    metrics_only  :: A boolean indicating that we only want to compute */
+  /*                     the metrics of a given glyph, not load all of its */
+  /*                     points.                                           */
+  /*                                                                       */
+  /*    hints_funcs   :: Auxiliary pointer for hinting.                    */
+  /*                                                                       */
+  /*    hints_globals :: Auxiliary pointer for hinting.                    */
+  /*                                                                       */
+  typedef struct  CFF_Builder_
+  {
+    FT_Memory       memory;
+    TT_Face         face;
+    CFF_GlyphSlot   glyph;
+    FT_GlyphLoader  loader;
+    FT_Outline*     base;
+    FT_Outline*     current;
+
+    FT_Vector       last;
+
+    FT_Fixed        scale_x;
+    FT_Fixed        scale_y;
+
+    FT_Pos          pos_x;
+    FT_Pos          pos_y;
+
+    FT_Vector       left_bearing;
+    FT_Vector       advance;
+
+    FT_BBox         bbox;          /* bounding box */
+    FT_Bool         path_begun;
+    FT_Bool         load_points;
+    FT_Bool         no_recurse;
+
+    FT_Bool         metrics_only;
+
+    void*           hints_funcs;    /* hinter-specific */
+    void*           hints_globals;  /* hinter-specific */
+
+  } CFF_Builder;
+
+
+  /* execution context charstring zone */
+
+  typedef struct  CFF_Decoder_Zone_
+  {
+    FT_Byte*  base;
+    FT_Byte*  limit;
+    FT_Byte*  cursor;
+
+  } CFF_Decoder_Zone;
+
+
+  typedef struct  CFF_Decoder_
+  {
+    CFF_Builder        builder;
+    CFF_Font           cff;
+
+    FT_Fixed           stack[CFF_MAX_OPERANDS + 1];
+    FT_Fixed*          top;
+
+    CFF_Decoder_Zone   zones[CFF_MAX_SUBRS_CALLS + 1];
+    CFF_Decoder_Zone*  zone;
+
+    FT_Int             flex_state;
+    FT_Int             num_flex_vectors;
+    FT_Vector          flex_vectors[7];
+
+    FT_Pos             glyph_width;
+    FT_Pos             nominal_width;
+
+    FT_Bool            read_width;
+    FT_Int             num_hints;
+    FT_Fixed*          buildchar;
+    FT_Int             len_buildchar;
+
+    FT_UInt            num_locals;
+    FT_UInt            num_globals;
+
+    FT_Int             locals_bias;
+    FT_Int             globals_bias;
+
+    FT_Byte**          locals;
+    FT_Byte**          globals;
+
+    FT_Byte**          glyph_names;   /* for pure CFF fonts only  */
+    FT_UInt            num_glyphs;    /* number of glyphs in font */
+
+    FT_Render_Mode     hint_mode;
+
+  } CFF_Decoder;
+
+
+  FT_LOCAL( void )
+  cff_decoder_init( CFF_Decoder*    decoder,
+                    TT_Face         face,
+                    CFF_Size        size,
+                    CFF_GlyphSlot   slot,
+                    FT_Bool         hinting,
+                    FT_Render_Mode  hint_mode );
+
+  FT_LOCAL( void )
+  cff_decoder_prepare( CFF_Decoder*  decoder,
+                       FT_UInt       glyph_index );
+
+#if 0  /* unused until we support pure CFF fonts */
+
+  /* Compute the maximum advance width of a font through quick parsing */
+  FT_LOCAL( FT_Error )
+  cff_compute_max_advance( TT_Face  face,
+                           FT_Int*  max_advance );
+
+#endif /* 0 */
+
+  FT_LOCAL( FT_Error )
+  cff_decoder_parse_charstrings( CFF_Decoder*  decoder,
+                                 FT_Byte*      charstring_base,
+                                 FT_ULong      charstring_len );
+
+  FT_LOCAL( FT_Error )
+  cff_slot_load( CFF_GlyphSlot  glyph,
+                 CFF_Size       size,
+                 FT_Int         glyph_index,
+                 FT_Int32       load_flags );
+
+
+FT_END_HEADER
+
+#endif /* __CFFGLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffload.c b/nx-X11/extras/freetype2/src/cff/cffload.c
new file mode 100644
index 000000000..350e01f3f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffload.c
@@ -0,0 +1,2313 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffload.c                                                              */
+/*                                                                         */
+/*    OpenType and CFF data/program tables loader (body).                  */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+#include FT_TRUETYPE_TAGS_H
+
+#include "cffload.h"
+#include "cffparse.h"
+
+#include "cfferrs.h"
+
+
+#if 1
+  static const FT_UShort  cff_isoadobe_charset[229] =
+  {
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    76,
+    77,
+    78,
+    79,
+    80,
+    81,
+    82,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    91,
+    92,
+    93,
+    94,
+    95,
+    96,
+    97,
+    98,
+    99,
+    100,
+    101,
+    102,
+    103,
+    104,
+    105,
+    106,
+    107,
+    108,
+    109,
+    110,
+    111,
+    112,
+    113,
+    114,
+    115,
+    116,
+    117,
+    118,
+    119,
+    120,
+    121,
+    122,
+    123,
+    124,
+    125,
+    126,
+    127,
+    128,
+    129,
+    130,
+    131,
+    132,
+    133,
+    134,
+    135,
+    136,
+    137,
+    138,
+    139,
+    140,
+    141,
+    142,
+    143,
+    144,
+    145,
+    146,
+    147,
+    148,
+    149,
+    150,
+    151,
+    152,
+    153,
+    154,
+    155,
+    156,
+    157,
+    158,
+    159,
+    160,
+    161,
+    162,
+    163,
+    164,
+    165,
+    166,
+    167,
+    168,
+    169,
+    170,
+    171,
+    172,
+    173,
+    174,
+    175,
+    176,
+    177,
+    178,
+    179,
+    180,
+    181,
+    182,
+    183,
+    184,
+    185,
+    186,
+    187,
+    188,
+    189,
+    190,
+    191,
+    192,
+    193,
+    194,
+    195,
+    196,
+    197,
+    198,
+    199,
+    200,
+    201,
+    202,
+    203,
+    204,
+    205,
+    206,
+    207,
+    208,
+    209,
+    210,
+    211,
+    212,
+    213,
+    214,
+    215,
+    216,
+    217,
+    218,
+    219,
+    220,
+    221,
+    222,
+    223,
+    224,
+    225,
+    226,
+    227,
+    228
+  };
+
+  static const FT_UShort  cff_expert_charset[166] =
+  {
+    0,
+    1,
+    229,
+    230,
+    231,
+    232,
+    233,
+    234,
+    235,
+    236,
+    237,
+    238,
+    13,
+    14,
+    15,
+    99,
+    239,
+    240,
+    241,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    27,
+    28,
+    249,
+    250,
+    251,
+    252,
+    253,
+    254,
+    255,
+    256,
+    257,
+    258,
+    259,
+    260,
+    261,
+    262,
+    263,
+    264,
+    265,
+    266,
+    109,
+    110,
+    267,
+    268,
+    269,
+    270,
+    271,
+    272,
+    273,
+    274,
+    275,
+    276,
+    277,
+    278,
+    279,
+    280,
+    281,
+    282,
+    283,
+    284,
+    285,
+    286,
+    287,
+    288,
+    289,
+    290,
+    291,
+    292,
+    293,
+    294,
+    295,
+    296,
+    297,
+    298,
+    299,
+    300,
+    301,
+    302,
+    303,
+    304,
+    305,
+    306,
+    307,
+    308,
+    309,
+    310,
+    311,
+    312,
+    313,
+    314,
+    315,
+    316,
+    317,
+    318,
+    158,
+    155,
+    163,
+    319,
+    320,
+    321,
+    322,
+    323,
+    324,
+    325,
+    326,
+    150,
+    164,
+    169,
+    327,
+    328,
+    329,
+    330,
+    331,
+    332,
+    333,
+    334,
+    335,
+    336,
+    337,
+    338,
+    339,
+    340,
+    341,
+    342,
+    343,
+    344,
+    345,
+    346,
+    347,
+    348,
+    349,
+    350,
+    351,
+    352,
+    353,
+    354,
+    355,
+    356,
+    357,
+    358,
+    359,
+    360,
+    361,
+    362,
+    363,
+    364,
+    365,
+    366,
+    367,
+    368,
+    369,
+    370,
+    371,
+    372,
+    373,
+    374,
+    375,
+    376,
+    377,
+    378
+  };
+
+  static const FT_UShort  cff_expertsubset_charset[87] =
+  {
+    0,
+    1,
+    231,
+    232,
+    235,
+    236,
+    237,
+    238,
+    13,
+    14,
+    15,
+    99,
+    239,
+    240,
+    241,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    27,
+    28,
+    249,
+    250,
+    251,
+    253,
+    254,
+    255,
+    256,
+    257,
+    258,
+    259,
+    260,
+    261,
+    262,
+    263,
+    264,
+    265,
+    266,
+    109,
+    110,
+    267,
+    268,
+    269,
+    270,
+    272,
+    300,
+    301,
+    302,
+    305,
+    314,
+    315,
+    158,
+    155,
+    163,
+    320,
+    321,
+    322,
+    323,
+    324,
+    325,
+    326,
+    150,
+    164,
+    169,
+    327,
+    328,
+    329,
+    330,
+    331,
+    332,
+    333,
+    334,
+    335,
+    336,
+    337,
+    338,
+    339,
+    340,
+    341,
+    342,
+    343,
+    344,
+    345,
+    346
+  };
+
+  static const FT_UShort  cff_standard_encoding[256] =
+  {
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    76,
+    77,
+    78,
+    79,
+    80,
+    81,
+    82,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    91,
+    92,
+    93,
+    94,
+    95,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    96,
+    97,
+    98,
+    99,
+    100,
+    101,
+    102,
+    103,
+    104,
+    105,
+    106,
+    107,
+    108,
+    109,
+    110,
+    0,
+    111,
+    112,
+    113,
+    114,
+    0,
+    115,
+    116,
+    117,
+    118,
+    119,
+    120,
+    121,
+    122,
+    0,
+    123,
+    0,
+    124,
+    125,
+    126,
+    127,
+    128,
+    129,
+    130,
+    131,
+    0,
+    132,
+    133,
+    0,
+    134,
+    135,
+    136,
+    137,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    138,
+    0,
+    139,
+    0,
+    0,
+    0,
+    0,
+    140,
+    141,
+    142,
+    143,
+    0,
+    0,
+    0,
+    0,
+    0,
+    144,
+    0,
+    0,
+    0,
+    145,
+    0,
+    0,
+    146,
+    147,
+    148,
+    149,
+    0,
+    0,
+    0,
+    0
+  };
+
+  static const FT_UShort  cff_expert_encoding[256] =
+  {
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    229,
+    230,
+    0,
+    231,
+    232,
+    233,
+    234,
+    235,
+    236,
+    237,
+    238,
+    13,
+    14,
+    15,
+    99,
+    239,
+    240,
+    241,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    27,
+    28,
+    249,
+    250,
+    251,
+    252,
+    0,
+    253,
+    254,
+    255,
+    256,
+    257,
+    0,
+    0,
+    0,
+    258,
+    0,
+    0,
+    259,
+    260,
+    261,
+    262,
+    0,
+    0,
+    263,
+    264,
+    265,
+    0,
+    266,
+    109,
+    110,
+    267,
+    268,
+    269,
+    0,
+    270,
+    271,
+    272,
+    273,
+    274,
+    275,
+    276,
+    277,
+    278,
+    279,
+    280,
+    281,
+    282,
+    283,
+    284,
+    285,
+    286,
+    287,
+    288,
+    289,
+    290,
+    291,
+    292,
+    293,
+    294,
+    295,
+    296,
+    297,
+    298,
+    299,
+    300,
+    301,
+    302,
+    303,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    304,
+    305,
+    306,
+    0,
+    0,
+    307,
+    308,
+    309,
+    310,
+    311,
+    0,
+    312,
+    0,
+    0,
+    312,
+    0,
+    0,
+    314,
+    315,
+    0,
+    0,
+    316,
+    317,
+    318,
+    0,
+    0,
+    0,
+    158,
+    155,
+    163,
+    319,
+    320,
+    321,
+    322,
+    323,
+    324,
+    325,
+    0,
+    0,
+    326,
+    150,
+    164,
+    169,
+    327,
+    328,
+    329,
+    330,
+    331,
+    332,
+    333,
+    334,
+    335,
+    336,
+    337,
+    338,
+    339,
+    340,
+    341,
+    342,
+    343,
+    344,
+    345,
+    346,
+    347,
+    348,
+    349,
+    350,
+    351,
+    352,
+    353,
+    354,
+    355,
+    356,
+    357,
+    358,
+    359,
+    360,
+    361,
+    362,
+    363,
+    364,
+    365,
+    366,
+    367,
+    368,
+    369,
+    370,
+    371,
+    372,
+    373,
+    374,
+    375,
+    376,
+    377,
+    378
+  };
+#endif
+
+
+  FT_LOCAL_DEF( FT_UShort )
+  cff_get_standard_encoding( FT_UInt  charcode )
+  {
+    return  (FT_UShort)(charcode < 256 ? cff_standard_encoding[charcode] : 0);
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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_cffload
+
+
+  /* read a CFF offset from memory */
+  static FT_ULong
+  cff_get_offset( FT_Byte*  p,
+                  FT_Byte   off_size )
+  {
+    FT_ULong  result;
+
+
+    for ( result = 0; off_size > 0; off_size-- )
+    {
+      result <<= 8;
+      result  |= *p++;
+    }
+
+    return result;
+  }
+
+
+  static FT_Error
+  cff_new_index( CFF_Index  idx,
+                 FT_Stream  stream,
+                 FT_Bool    load )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+    FT_UShort  count;
+
+
+    FT_MEM_ZERO( idx, sizeof ( *idx ) );
+
+    idx->stream = stream;
+    if ( !FT_READ_USHORT( count ) &&
+         count > 0                )
+    {
+      FT_Byte*   p;
+      FT_Byte    offsize;
+      FT_ULong   data_size;
+      FT_ULong*  poff;
+
+
+      /* there is at least one element; read the offset size,           */
+      /* then access the offset table to compute the index's total size */
+      if ( FT_READ_BYTE( offsize ) )
+        goto Exit;
+
+      idx->stream   = stream;
+      idx->count    = count;
+      idx->off_size = offsize;
+      data_size     = (FT_ULong)( count + 1 ) * offsize;
+
+      if ( FT_NEW_ARRAY( idx->offsets, count + 1 ) ||
+           FT_FRAME_ENTER( data_size )             )
+        goto Exit;
+
+      poff = idx->offsets;
+      p    = (FT_Byte*)stream->cursor;
+
+      for ( ; (FT_Short)count >= 0; count-- )
+      {
+        poff[0] = cff_get_offset( p, offsize );
+        poff++;
+        p += offsize;
+      }
+
+      FT_FRAME_EXIT();
+
+      idx->data_offset = FT_STREAM_POS();
+      data_size        = poff[-1] - 1;
+
+      if ( load )
+      {
+        /* load the data */
+        if ( FT_FRAME_EXTRACT( data_size, idx->bytes ) )
+          goto Exit;
+      }
+      else
+      {
+        /* skip the data */
+        if ( FT_STREAM_SKIP( data_size ) )
+          goto Exit;
+      }
+    }
+
+  Exit:
+    if ( error )
+      FT_FREE( idx->offsets );
+
+    return error;
+  }
+
+
+  static void
+  cff_done_index( CFF_Index  idx )
+  {
+    if ( idx->stream )
+    {
+      FT_Stream  stream = idx->stream;
+      FT_Memory  memory = stream->memory;
+
+
+      if ( idx->bytes )
+        FT_FRAME_RELEASE( idx->bytes );
+
+      FT_FREE( idx->offsets );
+      FT_MEM_ZERO( idx, sizeof ( *idx ) );
+    }
+  }
+
+
+  /* allocate a table containing pointers to an index's elements */
+  static FT_Error
+  cff_index_get_pointers( CFF_Index   idx,
+                          FT_Byte***  table )
+  {
+    FT_Error   error  = CFF_Err_Ok;
+    FT_Memory  memory = idx->stream->memory;
+    FT_ULong   n, offset, old_offset;
+    FT_Byte**  t;
+
+
+    *table = 0;
+
+    if ( idx->count > 0 && !FT_NEW_ARRAY( t, idx->count + 1 ) )
+    {
+      old_offset = 1;
+      for ( n = 0; n <= idx->count; n++ )
+      {
+        offset = idx->offsets[n];
+        if ( !offset )
+          offset = old_offset;
+
+        t[n] = idx->bytes + offset - 1;
+
+        old_offset = offset;
+      }
+      *table = t;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_index_access_element( CFF_Index  idx,
+                            FT_UInt    element,
+                            FT_Byte**  pbytes,
+                            FT_ULong*  pbyte_len )
+  {
+    FT_Error  error = CFF_Err_Ok;
+
+
+    if ( idx && idx->count > element )
+    {
+      /* compute start and end offsets */
+      FT_ULong  off1, off2 = 0;
+
+
+      off1 = idx->offsets[element];
+      if ( off1 )
+      {
+        do
+        {
+          element++;
+          off2 = idx->offsets[element];
+
+        } while ( off2 == 0 && element < idx->count );
+
+        if ( !off2 )
+          off1 = 0;
+      }
+
+      /* access element */
+      if ( off1 )
+      {
+        *pbyte_len = off2 - off1;
+
+        if ( idx->bytes )
+        {
+          /* this index was completely loaded in memory, that's easy */
+          *pbytes = idx->bytes + off1 - 1;
+        }
+        else
+        {
+          /* this index is still on disk/file, access it through a frame */
+          FT_Stream  stream = idx->stream;
+
+
+          if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) ||
+               FT_FRAME_EXTRACT( off2 - off1, *pbytes )      )
+            goto Exit;
+        }
+      }
+      else
+      {
+        /* empty index element */
+        *pbytes    = 0;
+        *pbyte_len = 0;
+      }
+    }
+    else
+      error = CFF_Err_Invalid_Argument;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  cff_index_forget_element( CFF_Index  idx,
+                            FT_Byte**  pbytes )
+  {
+    if ( idx->bytes == 0 )
+    {
+      FT_Stream  stream = idx->stream;
+
+
+      FT_FRAME_RELEASE( *pbytes );
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_String* )
+  cff_index_get_name( CFF_Index  idx,
+                      FT_UInt    element )
+  {
+    FT_Memory   memory = idx->stream->memory;
+    FT_Byte*    bytes;
+    FT_ULong    byte_len;
+    FT_Error    error;
+    FT_String*  name = 0;
+
+
+    error = cff_index_access_element( idx, element, &bytes, &byte_len );
+    if ( error )
+      goto Exit;
+
+    if ( !FT_ALLOC( name, byte_len + 1 ) )
+    {
+      FT_MEM_COPY( name, bytes, byte_len );
+      name[byte_len] = 0;
+    }
+    cff_index_forget_element( idx, &bytes );
+
+  Exit:
+    return name;
+  }
+
+
+  FT_LOCAL_DEF( FT_String* )
+  cff_index_get_sid_string( CFF_Index           idx,
+                            FT_UInt             sid,
+                            FT_Service_PsCMaps  psnames )
+  {
+    /* value 0xFFFFU indicates a missing dictionary entry */
+    if ( sid == 0xFFFFU )
+      return 0;
+
+    /* if it is not a standard string, return it */
+    if ( sid > 390 )
+      return cff_index_get_name( idx, sid - 391 );
+
+    /* CID-keyed CFF fonts don't have glyph names */
+    if ( !psnames )
+      return 0;
+
+    /* that's a standard string, fetch a copy from the PSName module */
+    {
+      FT_String*   name       = 0;
+      const char*  adobe_name = psnames->adobe_std_strings( sid );
+      FT_UInt      len;
+
+
+      if ( adobe_name )
+      {
+        FT_Memory  memory = idx->stream->memory;
+        FT_Error   error;
+
+
+        len = (FT_UInt)ft_strlen( adobe_name );
+        if ( !FT_ALLOC( name, len + 1 ) )
+        {
+          FT_MEM_COPY( name, adobe_name, len );
+          name[len] = 0;
+        }
+
+        FT_UNUSED( error );
+      }
+
+      return name;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***   FD Select table support                                         ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  static void
+  CFF_Done_FD_Select( CFF_FDSelect  fdselect,
+                      FT_Stream     stream )
+  {
+    if ( fdselect->data )
+      FT_FRAME_RELEASE( fdselect->data );
+
+    fdselect->data_size   = 0;
+    fdselect->format      = 0;
+    fdselect->range_count = 0;
+  }
+
+
+  static FT_Error
+  CFF_Load_FD_Select( CFF_FDSelect  fdselect,
+                      FT_UInt       num_glyphs,
+                      FT_Stream     stream,
+                      FT_ULong      offset )
+  {
+    FT_Error  error;
+    FT_Byte   format;
+    FT_UInt   num_ranges;
+
+
+    /* read format */
+    if ( FT_STREAM_SEEK( offset ) || FT_READ_BYTE( format ) )
+      goto Exit;
+
+    fdselect->format      = format;
+    fdselect->cache_count = 0;   /* clear cache */
+
+    switch ( format )
+    {
+    case 0:     /* format 0, that's simple */
+      fdselect->data_size = num_glyphs;
+      goto Load_Data;
+
+    case 3:     /* format 3, a tad more complex */
+      if ( FT_READ_USHORT( num_ranges ) )
+        goto Exit;
+
+      fdselect->data_size = num_ranges * 3 + 2;
+
+    Load_Data:
+      if ( FT_FRAME_EXTRACT( fdselect->data_size, fdselect->data ) )
+        goto Exit;
+      break;
+
+    default:    /* hmm... that's wrong */
+      error = CFF_Err_Invalid_File_Format;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Byte )
+  cff_fd_select_get( CFF_FDSelect  fdselect,
+                     FT_UInt       glyph_index )
+  {
+    FT_Byte  fd = 0;
+
+
+    switch ( fdselect->format )
+    {
+    case 0:
+      fd = fdselect->data[glyph_index];
+      break;
+
+    case 3:
+      /* first, compare to cache */
+      if ( (FT_UInt)( glyph_index - fdselect->cache_first ) <
+                        fdselect->cache_count )
+      {
+        fd = fdselect->cache_fd;
+        break;
+      }
+
+      /* then, lookup the ranges array */
+      {
+        FT_Byte*  p       = fdselect->data;
+        FT_Byte*  p_limit = p + fdselect->data_size;
+        FT_Byte   fd2;
+        FT_UInt   first, limit;
+
+
+        first = FT_NEXT_USHORT( p );
+        do
+        {
+          if ( glyph_index < first )
+            break;
+
+          fd2   = *p++;
+          limit = FT_NEXT_USHORT( p );
+
+          if ( glyph_index < limit )
+          {
+            fd = fd2;
+
+            /* update cache */
+            fdselect->cache_first = first;
+            fdselect->cache_count = limit-first;
+            fdselect->cache_fd    = fd2;
+            break;
+          }
+          first = limit;
+
+        } while ( p < p_limit );
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    return fd;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***   CFF font support                                                ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  cff_charset_done( CFF_Charset  charset,
+                    FT_Stream    stream )
+  {
+    FT_Memory  memory = stream->memory;
+
+
+    FT_FREE( charset->sids );
+    FT_FREE( charset->cids );
+    charset->format = 0;
+    charset->offset = 0;
+  }
+
+
+  static FT_Error
+  cff_charset_load( CFF_Charset  charset,
+                    FT_UInt      num_glyphs,
+                    FT_Stream    stream,
+                    FT_ULong     base_offset,
+                    FT_ULong     offset,
+                    FT_Bool      invert )
+  {
+    FT_Memory  memory = stream->memory;
+    FT_Error   error  = CFF_Err_Ok;
+    FT_UShort  glyph_sid;
+
+
+    /* If the the offset is greater than 2, we have to parse the */
+    /* charset table.                                            */
+    if ( offset > 2 )
+    {
+      FT_UInt  j;
+
+
+      charset->offset = base_offset + offset;
+
+      /* Get the format of the table. */
+      if ( FT_STREAM_SEEK( charset->offset ) ||
+           FT_READ_BYTE( charset->format )   )
+        goto Exit;
+
+      /* Allocate memory for sids. */
+      if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
+        goto Exit;
+
+      /* assign the .notdef glyph */
+      charset->sids[0] = 0;
+
+      switch ( charset->format )
+      {
+      case 0:
+        if ( num_glyphs > 0 )
+        {
+          if ( FT_FRAME_ENTER( ( num_glyphs - 1 ) * 2 ) )
+            goto Exit;
+
+          for ( j = 1; j < num_glyphs; j++ )
+            charset->sids[j] = FT_GET_USHORT();
+
+          FT_FRAME_EXIT();
+        }
+        break;
+
+      case 1:
+      case 2:
+        {
+          FT_UInt  nleft;
+          FT_UInt  i;
+
+
+          j = 1;
+
+          while ( j < num_glyphs )
+          {
+            /* Read the first glyph sid of the range. */
+            if ( FT_READ_USHORT( glyph_sid ) )
+              goto Exit;
+
+            /* Read the number of glyphs in the range.  */
+            if ( charset->format == 2 )
+            {
+              if ( FT_READ_USHORT( nleft ) )
+                goto Exit;
+            }
+            else
+            {
+              if ( FT_READ_BYTE( nleft ) )
+                goto Exit;
+            }
+
+            /* Fill in the range of sids -- `nleft + 1' glyphs. */
+            for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
+              charset->sids[j] = glyph_sid;
+          }
+        }
+        break;
+
+      default:
+        FT_ERROR(( "cff_charset_load: invalid table format!\n" ));
+        error = CFF_Err_Invalid_File_Format;
+        goto Exit;
+      }
+    }
+    else
+    {
+      /* Parse default tables corresponding to offset == 0, 1, or 2.  */
+      /* CFF specification intimates the following:                   */
+      /*                                                              */
+      /* In order to use a predefined charset, the following must be  */
+      /* true: The charset constructed for the glyphs in the font's   */
+      /* charstrings dictionary must match the predefined charset in  */
+      /* the first num_glyphs.                                        */
+
+      charset->offset = offset;  /* record charset type */
+
+      switch ( (FT_UInt)offset )
+      {
+      case 0:
+        if ( num_glyphs > 229 )
+        {
+          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
+                     "predefined charset (Adobe ISO-Latin)!\n" ));
+          error = CFF_Err_Invalid_File_Format;
+          goto Exit;
+        }
+
+        /* Allocate memory for sids. */
+        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
+          goto Exit;
+
+        /* Copy the predefined charset into the allocated memory. */
+        FT_ARRAY_COPY( charset->sids, cff_isoadobe_charset, num_glyphs );
+
+        break;
+
+      case 1:
+        if ( num_glyphs > 166 )
+        {
+          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
+                     "predefined charset (Adobe Expert)!\n" ));
+          error = CFF_Err_Invalid_File_Format;
+          goto Exit;
+        }
+
+        /* Allocate memory for sids. */
+        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
+          goto Exit;
+
+        /* Copy the predefined charset into the allocated memory.     */
+        FT_ARRAY_COPY( charset->sids, cff_expert_charset, num_glyphs );
+
+        break;
+
+      case 2:
+        if ( num_glyphs > 87 )
+        {
+          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
+                     "predefined charset (Adobe Expert Subset)!\n" ));
+          error = CFF_Err_Invalid_File_Format;
+          goto Exit;
+        }
+
+        /* Allocate memory for sids. */
+        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
+          goto Exit;
+
+        /* Copy the predefined charset into the allocated memory.     */
+        FT_ARRAY_COPY( charset->sids, cff_expertsubset_charset, num_glyphs );
+
+        break;
+
+      default:
+        error = CFF_Err_Invalid_File_Format;
+        goto Exit;
+      }
+    }
+
+    /* we have to invert the `sids' array for subsetted CID-keyed fonts */
+    if ( invert )
+    {
+      FT_UInt    i;
+      FT_UShort  max_cid = 0;
+
+
+      for ( i = 0; i < num_glyphs; i++ )
+        if ( charset->sids[i] > max_cid )
+          max_cid = charset->sids[i];
+      max_cid++;
+
+      if ( FT_NEW_ARRAY( charset->cids, max_cid ) )
+        goto Exit;
+      FT_MEM_ZERO( charset->cids, sizeof ( FT_UShort ) * max_cid );
+
+      for ( i = 0; i < num_glyphs; i++ )
+        charset->cids[charset->sids[i]] = i;
+    }
+
+  Exit:
+    /* Clean up if there was an error. */
+    if ( error )
+    {
+      FT_FREE( charset->sids );
+      FT_FREE( charset->cids );
+      charset->format = 0;
+      charset->offset = 0;
+      charset->sids   = 0;
+    }
+
+    return error;
+  }
+
+
+  static void
+  cff_encoding_done( CFF_Encoding  encoding )
+  {
+    encoding->format = 0;
+    encoding->offset = 0;
+    encoding->count  = 0;
+  }
+
+
+  static FT_Error
+  cff_encoding_load( CFF_Encoding  encoding,
+                     CFF_Charset   charset,
+                     FT_UInt       num_glyphs,
+                     FT_Stream     stream,
+                     FT_ULong      base_offset,
+                     FT_ULong      offset )
+  {
+    FT_Error   error = CFF_Err_Ok;
+    FT_UInt    count;
+    FT_UInt    j;
+    FT_UShort  glyph_sid;
+    FT_UInt    glyph_code;
+
+
+    /* Check for charset->sids.  If we do not have this, we fail. */
+    if ( !charset->sids )
+    {
+      error = CFF_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    /* Zero out the code to gid/sid mappings. */
+    for ( j = 0; j < 256; j++ )
+    {
+      encoding->sids [j] = 0;
+      encoding->codes[j] = 0;
+    }
+
+    /* Note: The encoding table in a CFF font is indexed by glyph index;  */
+    /* the first encoded glyph index is 1.  Hence, we read the character  */
+    /* code (`glyph_code') at index j and make the assignment:            */
+    /*                                                                    */
+    /*    encoding->codes[glyph_code] = j + 1                             */
+    /*                                                                    */
+    /* We also make the assignment:                                       */
+    /*                                                                    */
+    /*    encoding->sids[glyph_code] = charset->sids[j + 1]               */
+    /*                                                                    */
+    /* This gives us both a code to GID and a code to SID mapping.        */
+
+    if ( offset > 1 )
+    {
+      encoding->offset = base_offset + offset;
+
+      /* we need to parse the table to determine its size */
+      if ( FT_STREAM_SEEK( encoding->offset ) ||
+           FT_READ_BYTE( encoding->format )   ||
+           FT_READ_BYTE( count )              )
+        goto Exit;
+
+      switch ( encoding->format & 0x7F )
+      {
+      case 0:
+        {
+          FT_Byte*  p;
+
+
+          /* By convention, GID 0 is always ".notdef" and is never */
+          /* coded in the font.  Hence, the number of codes found  */
+          /* in the table is `count+1'.                            */
+          /*                                                       */
+          encoding->count = count + 1;
+
+          if ( FT_FRAME_ENTER( count ) )
+            goto Exit;
+
+          p = (FT_Byte*)stream->cursor;
+
+          for ( j = 1; j <= count; j++ )
+          {
+            glyph_code = *p++;
+
+            /* Make sure j is not too big. */
+            if ( j < num_glyphs )
+            {
+              /* Assign code to GID mapping. */
+              encoding->codes[glyph_code] = (FT_UShort)j;
+
+              /* Assign code to SID mapping. */
+              encoding->sids[glyph_code] = charset->sids[j];
+            }
+          }
+
+          FT_FRAME_EXIT();
+        }
+        break;
+
+      case 1:
+        {
+          FT_UInt  nleft;
+          FT_UInt  i = 1;
+          FT_UInt  k;
+
+
+          encoding->count = 0;
+
+          /* Parse the Format1 ranges. */
+          for ( j = 0;  j < count; j++, i += nleft )
+          {
+            /* Read the first glyph code of the range. */
+            if ( FT_READ_BYTE( glyph_code ) )
+              goto Exit;
+
+            /* Read the number of codes in the range. */
+            if ( FT_READ_BYTE( nleft ) )
+              goto Exit;
+
+            /* Increment nleft, so we read `nleft + 1' codes/sids. */
+            nleft++;
+
+            /* compute max number of character codes */
+            if ( (FT_UInt)nleft > encoding->count )
+              encoding->count = nleft;
+
+            /* Fill in the range of codes/sids. */
+            for ( k = i; k < nleft + i; k++, glyph_code++ )
+            {
+              /* Make sure k is not too big. */
+              if ( k < num_glyphs && glyph_code < 256 )
+              {
+                /* Assign code to GID mapping. */
+                encoding->codes[glyph_code] = (FT_UShort)k;
+
+                /* Assign code to SID mapping. */
+                encoding->sids[glyph_code] = charset->sids[k];
+              }
+            }
+          }
+
+          /* simple check; one never knows what can be found in a font */
+          if ( encoding->count > 256 )
+            encoding->count = 256;
+        }
+        break;
+
+      default:
+        FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
+        error = CFF_Err_Invalid_File_Format;
+        goto Exit;
+      }
+
+      /* Parse supplemental encodings, if any. */
+      if ( encoding->format & 0x80 )
+      {
+        FT_UInt  gindex;
+
+
+        /* count supplements */
+        if ( FT_READ_BYTE( count ) )
+          goto Exit;
+
+        for ( j = 0; j < count; j++ )
+        {
+          /* Read supplemental glyph code. */
+          if ( FT_READ_BYTE( glyph_code ) )
+            goto Exit;
+
+          /* Read the SID associated with this glyph code. */
+          if ( FT_READ_USHORT( glyph_sid ) )
+            goto Exit;
+
+          /* Assign code to SID mapping. */
+          encoding->sids[glyph_code] = glyph_sid;
+
+          /* First, look up GID which has been assigned to */
+          /* SID glyph_sid.                                */
+          for ( gindex = 0; gindex < num_glyphs; gindex++ )
+          {
+            if ( charset->sids[gindex] == glyph_sid )
+            {
+              encoding->codes[glyph_code] = (FT_UShort)gindex;
+              break;
+            }
+          }
+        }
+      }
+    }
+    else
+    {
+      FT_UInt i;
+
+
+      /* We take into account the fact a CFF font can use a predefined */
+      /* encoding without containing all of the glyphs encoded by this */
+      /* encoding (see the note at the end of section 12 in the CFF    */
+      /* specification).                                               */
+
+      switch ( (FT_UInt)offset )
+      {
+      case 0:
+        /* First, copy the code to SID mapping. */
+        FT_ARRAY_COPY( encoding->sids, cff_standard_encoding, 256 );
+        goto Populate;
+
+      case 1:
+        /* First, copy the code to SID mapping. */
+        FT_ARRAY_COPY( encoding->sids, cff_expert_encoding, 256 );
+
+      Populate:
+        /* Construct code to GID mapping from code to SID mapping */
+        /* and charset.                                           */
+
+        encoding->count = 0;
+
+        for ( j = 0; j < 256; j++ )
+        {
+          /* If j is encoded, find the GID for it. */
+          if ( encoding->sids[j] )
+          {
+            for ( i = 1; i < num_glyphs; i++ )
+              /* We matched, so break. */
+              if ( charset->sids[i] == encoding->sids[j] )
+                break;
+
+            /* i will be equal to num_glyphs if we exited the above */
+            /* loop without a match.  In this case, we also have to */
+            /* fix the code to SID mapping.                         */
+            if ( i == num_glyphs )
+            {
+              encoding->codes[j] = 0;
+              encoding->sids [j] = 0;
+            }
+            else
+            {
+              encoding->codes[j] = (FT_UShort)i;
+
+              /* update encoding count */
+              if ( encoding->count < j + 1 )
+                encoding->count = j + 1;
+            }
+          }
+        }
+        break;
+
+      default:
+        FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
+        error = CFF_Err_Invalid_File_Format;
+        goto Exit;
+      }
+    }
+
+  Exit:
+
+    /* Clean up if there was an error. */
+    return error;
+  }
+
+
+  static FT_Error
+  cff_subfont_load( CFF_SubFont  font,
+                    CFF_Index    idx,
+                    FT_UInt      font_index,
+                    FT_Stream    stream,
+                    FT_ULong     base_offset )
+  {
+    FT_Error         error;
+    CFF_ParserRec    parser;
+    FT_Byte*         dict = NULL;
+    FT_ULong         dict_len;
+    CFF_FontRecDict  top  = &font->font_dict;
+    CFF_Private      priv = &font->private_dict;
+
+
+    cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict );
+
+    /* set defaults */
+    FT_MEM_ZERO( top, sizeof ( *top ) );
+
+    top->underline_position  = -100L << 16;
+    top->underline_thickness = 50L << 16;
+    top->charstring_type     = 2;
+    top->font_matrix.xx      = 0x10000L;
+    top->font_matrix.yy      = 0x10000L;
+    top->cid_count           = 8720;
+
+    /* we use the implementation specific SID value 0xFFFF to indicate */
+    /* missing entries                                                 */
+    top->version             = 0xFFFFU;
+    top->notice              = 0xFFFFU;
+    top->copyright           = 0xFFFFU;
+    top->full_name           = 0xFFFFU;
+    top->family_name         = 0xFFFFU;
+    top->weight              = 0xFFFFU;
+    top->embedded_postscript = 0xFFFFU;
+
+    top->cid_registry        = 0xFFFFU;
+    top->cid_ordering        = 0xFFFFU;
+    top->cid_font_name       = 0xFFFFU;
+
+    error = cff_index_access_element( idx, font_index, &dict, &dict_len ) ||
+            cff_parser_run( &parser, dict, dict + dict_len );
+
+    cff_index_forget_element( idx, &dict );
+
+    if ( error )
+      goto Exit;
+
+    /* if it is a CID font, we stop there */
+    if ( top->cid_registry != 0xFFFFU )
+      goto Exit;
+
+    /* parse the private dictionary, if any */
+    if ( top->private_offset && top->private_size )
+    {
+      /* set defaults */
+      FT_MEM_ZERO( priv, sizeof ( *priv ) );
+
+      priv->blue_shift       = 7;
+      priv->blue_fuzz        = 1;
+      priv->lenIV            = -1;
+      priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
+      priv->blue_scale       = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
+
+      cff_parser_init( &parser, CFF_CODE_PRIVATE, priv );
+
+      if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) ||
+           FT_FRAME_ENTER( font->font_dict.private_size )                 )
+        goto Exit;
+
+      error = cff_parser_run( &parser,
+                              (FT_Byte*)stream->cursor,
+                              (FT_Byte*)stream->limit );
+      FT_FRAME_EXIT();
+      if ( error )
+        goto Exit;
+    }
+
+    /* read the local subrs, if any */
+    if ( priv->local_subrs_offset )
+    {
+      if ( FT_STREAM_SEEK( base_offset + top->private_offset +
+                           priv->local_subrs_offset ) )
+        goto Exit;
+
+      error = cff_new_index( &font->local_subrs_index, stream, 1 );
+      if ( error )
+        goto Exit;
+
+      font->num_local_subrs = font->local_subrs_index.count;
+      error = cff_index_get_pointers( &font->local_subrs_index,
+                                      &font->local_subrs );
+      if ( error )
+        goto Exit;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  cff_subfont_done( FT_Memory    memory,
+                    CFF_SubFont  subfont )
+  {
+    if ( subfont )
+    {
+      cff_done_index( &subfont->local_subrs_index );
+      FT_FREE( subfont->local_subrs );
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_font_load( FT_Stream  stream,
+                 FT_Int     face_index,
+                 CFF_Font   font )
+  {
+    static const FT_Frame_Field  cff_header_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  CFF_FontRec
+
+      FT_FRAME_START( 4 ),
+        FT_FRAME_BYTE( version_major ),
+        FT_FRAME_BYTE( version_minor ),
+        FT_FRAME_BYTE( header_size ),
+        FT_FRAME_BYTE( absolute_offsize ),
+      FT_FRAME_END
+    };
+
+    FT_Error         error;
+    FT_Memory        memory = stream->memory;
+    FT_ULong         base_offset;
+    CFF_FontRecDict  dict;
+
+    FT_ZERO( font );
+
+    font->stream = stream;
+    font->memory = memory;
+    dict         = &font->top_font.font_dict;
+    base_offset  = FT_STREAM_POS();
+
+    /* read CFF font header */
+    if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )
+      goto Exit;
+
+    /* check format */
+    if ( font->version_major   != 1 ||
+         font->header_size      < 4 ||
+         font->absolute_offsize > 4 )
+    {
+      FT_TRACE2(( "[not a CFF font header!]\n" ));
+      error = CFF_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* skip the rest of the header */
+    if ( FT_STREAM_SKIP( font->header_size - 4 ) )
+      goto Exit;
+
+    /* read the name, top dict, string and global subrs index */
+    if ( FT_SET_ERROR( cff_new_index( &font->name_index,         stream, 0 )) ||
+         FT_SET_ERROR( cff_new_index( &font->font_dict_index,    stream, 0 )) ||
+         FT_SET_ERROR( cff_new_index( &font->string_index,       stream, 0 )) ||
+         FT_SET_ERROR( cff_new_index( &font->global_subrs_index, stream, 1 )) )
+      goto Exit;
+
+    /* well, we don't really forget the `disabled' fonts... */
+    font->num_faces = font->name_index.count;
+    if ( face_index >= (FT_Int)font->num_faces )
+    {
+      FT_ERROR(( "cff_font_load: incorrect face index = %d\n",
+                 face_index ));
+      error = CFF_Err_Invalid_Argument;
+    }
+
+    /* in case of a font format check, simply exit now */
+    if ( face_index < 0 )
+      goto Exit;
+
+    /* now, parse the top-level font dictionary */
+    error = cff_subfont_load( &font->top_font,
+                              &font->font_dict_index,
+                              face_index,
+                              stream,
+                              base_offset );
+    if ( error )
+      goto Exit;
+
+    if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )
+      goto Exit;
+
+    error = cff_new_index( &font->charstrings_index, stream, 0 );
+    if ( error )
+      goto Exit;
+
+    /* now, check for a CID font */
+    if ( dict->cid_registry != 0xFFFFU )
+    {
+      CFF_IndexRec  fd_index;
+      CFF_SubFont   sub;
+      FT_UInt       idx;
+
+
+      /* this is a CID-keyed font, we must now allocate a table of */
+      /* sub-fonts, then load each of them separately              */
+      if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) )
+        goto Exit;
+
+      error = cff_new_index( &fd_index, stream, 0 );
+      if ( error )
+        goto Exit;
+
+      if ( fd_index.count > CFF_MAX_CID_FONTS )
+      {
+        FT_ERROR(( "cff_font_load: FD array too large in CID font\n" ));
+        goto Fail_CID;
+      }
+
+      /* allocate & read each font dict independently */
+      font->num_subfonts = fd_index.count;
+      if ( FT_NEW_ARRAY( sub, fd_index.count ) )
+        goto Fail_CID;
+
+      /* setup pointer table */
+      for ( idx = 0; idx < fd_index.count; idx++ )
+        font->subfonts[idx] = sub + idx;
+
+      /* now load each sub font independently */
+      for ( idx = 0; idx < fd_index.count; idx++ )
+      {
+        sub = font->subfonts[idx];
+        error = cff_subfont_load( sub, &fd_index, idx,
+                                  stream, base_offset );
+        if ( error )
+          goto Fail_CID;
+      }
+
+      /* now load the FD Select array */
+      error = CFF_Load_FD_Select( &font->fd_select,
+                                  font->charstrings_index.count,
+                                  stream,
+                                  base_offset + dict->cid_fd_select_offset );
+
+    Fail_CID:
+      cff_done_index( &fd_index );
+
+      if ( error )
+        goto Exit;
+    }
+    else
+      font->num_subfonts = 0;
+
+    /* read the charstrings index now */
+    if ( dict->charstrings_offset == 0 )
+    {
+      FT_ERROR(( "cff_font_load: no charstrings offset!\n" ));
+      error = CFF_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* explicit the global subrs */
+    font->num_global_subrs = font->global_subrs_index.count;
+    font->num_glyphs       = font->charstrings_index.count;
+
+    error = cff_index_get_pointers( &font->global_subrs_index,
+                                    &font->global_subrs ) ;
+
+    if ( error )
+      goto Exit;
+
+    /* read the Charset and Encoding tables if available */
+    if ( font->num_glyphs > 0 )
+    {
+      FT_Bool  invert;
+
+
+      invert = dict->cid_registry != 0xFFFFU &&
+               font->charstrings_index.count != dict->cid_count;
+      error = cff_charset_load( &font->charset, font->num_glyphs, stream,
+                                base_offset, dict->charset_offset, invert );
+      if ( error )
+        goto Exit;
+
+      /* CID-keyed CFFs don't have an encoding */
+      if ( dict->cid_registry == 0xFFFFU )
+      {
+        error = cff_encoding_load( &font->encoding,
+                                   &font->charset,
+                                   font->num_glyphs,
+                                   stream,
+                                   base_offset,
+                                   dict->encoding_offset );
+        if ( error )
+          goto Exit;
+      }
+      else
+        /* CID-keyed fonts only need CIDs */
+        FT_FREE( font->charset.sids );
+    }
+
+    /* get the font name (/CIDFontName for CID-keyed fonts, */
+    /* /FontName otherwise)                                 */
+    font->font_name = cff_index_get_name( &font->name_index, face_index );
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  cff_font_done( CFF_Font  font )
+  {
+    FT_Memory  memory = font->memory;
+    FT_UInt    idx;
+
+
+    cff_done_index( &font->global_subrs_index );
+    cff_done_index( &font->string_index );
+    cff_done_index( &font->font_dict_index );
+    cff_done_index( &font->name_index );
+    cff_done_index( &font->charstrings_index );
+
+    /* release font dictionaries, but only if working with */
+    /* a CID keyed CFF font                                */
+    if ( font->num_subfonts > 0 )
+    {
+      for ( idx = 0; idx < font->num_subfonts; idx++ )
+        cff_subfont_done( memory, font->subfonts[idx] );
+
+      FT_FREE( font->subfonts );
+    }
+
+    cff_encoding_done( &font->encoding );
+    cff_charset_done( &font->charset, font->stream );
+
+    cff_subfont_done( memory, &font->top_font );
+
+    CFF_Done_FD_Select( &font->fd_select, font->stream );
+
+    FT_FREE( font->global_subrs );
+    FT_FREE( font->font_name );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffload.h b/nx-X11/extras/freetype2/src/cff/cffload.h
new file mode 100644
index 000000000..ccf8ada1c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffload.h
@@ -0,0 +1,74 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffload.h                                                              */
+/*                                                                         */
+/*    OpenType & CFF data/program tables loader (specification).           */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 __CFFLOAD_H__
+#define __CFFLOAD_H__
+
+
+#include <ft2build.h>
+#include "cfftypes.h"
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+
+
+FT_BEGIN_HEADER
+
+  FT_LOCAL( FT_UShort )
+  cff_get_standard_encoding( FT_UInt  charcode );
+
+
+  FT_LOCAL( FT_String* )
+  cff_index_get_name( CFF_Index  idx,
+                      FT_UInt    element );
+
+  FT_LOCAL( FT_String* )
+  cff_index_get_sid_string( CFF_Index          idx,
+                            FT_UInt            sid,
+                            FT_Service_PsCMaps psnames );
+
+
+  FT_LOCAL( FT_Error )
+  cff_index_access_element( CFF_Index  idx,
+                            FT_UInt    element,
+                            FT_Byte**  pbytes,
+                            FT_ULong*  pbyte_len );
+
+  FT_LOCAL( void )
+  cff_index_forget_element( CFF_Index  idx,
+                            FT_Byte**  pbytes );
+
+
+  FT_LOCAL( FT_Error )
+  cff_font_load( FT_Stream  stream,
+                 FT_Int     face_index,
+                 CFF_Font   font );
+
+  FT_LOCAL( void )
+  cff_font_done( CFF_Font  font );
+
+
+  FT_LOCAL( FT_Byte )
+  cff_fd_select_get( CFF_FDSelect  fdselect,
+                     FT_UInt       glyph_index );
+
+
+FT_END_HEADER
+
+#endif /* __CFFLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffobjs.c b/nx-X11/extras/freetype2/src/cff/cffobjs.c
new file mode 100644
index 000000000..ec4d1e4f5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffobjs.c
@@ -0,0 +1,775 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffobjs.c                                                              */
+/*                                                                         */
+/*    OpenType objects manager (body).                                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_CALC_H
+#include FT_INTERNAL_STREAM_H
+#include FT_ERRORS_H
+#include FT_TRUETYPE_IDS_H
+#include FT_TRUETYPE_TAGS_H
+#include FT_INTERNAL_SFNT_H
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+#include "cffobjs.h"
+#include "cffload.h"
+#include "cffcmap.h"
+#include "cfferrs.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_cffobjs
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                            SIZE FUNCTIONS                             */
+  /*                                                                       */
+  /*  Note that we store the global hints in the size's `internal' root    */
+  /*  field.                                                               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+  static FT_Error
+  sbit_size_reset( CFF_Size  size )
+  {
+    CFF_Face          face;
+    FT_Error          error = CFF_Err_Ok;
+
+    FT_ULong          strike_index;
+    FT_Size_Metrics*  metrics;
+    FT_Size_Metrics*  sbit_metrics;
+    SFNT_Service      sfnt;
+
+
+    metrics = &size->root.metrics;
+
+    face = (CFF_Face)size->root.face;
+    sfnt = (SFNT_Service)face->sfnt;
+
+    sbit_metrics = &size->strike_metrics;
+
+    error = sfnt->set_sbit_strike( face,
+                                   metrics->x_ppem, metrics->y_ppem,
+                                   &strike_index );
+
+    if ( !error )
+    {
+      TT_SBit_Strike  strike = face->sbit_strikes + strike_index;
+
+
+      sbit_metrics->x_ppem = metrics->x_ppem;
+      sbit_metrics->y_ppem = metrics->y_ppem;
+
+      sbit_metrics->ascender  = strike->hori.ascender << 6;
+      sbit_metrics->descender = strike->hori.descender << 6;
+
+      /* XXX: Is this correct? */
+      sbit_metrics->height = sbit_metrics->ascender -
+                             sbit_metrics->descender;
+
+      /* XXX: Is this correct? */
+      sbit_metrics->max_advance = ( strike->hori.min_origin_SB  +
+                                    strike->hori.max_width      +
+                                    strike->hori.min_advance_SB ) << 6;
+
+      size->strike_index = (FT_UInt)strike_index;
+    }
+    else
+    {
+      size->strike_index = 0xFFFFU;
+
+      sbit_metrics->x_ppem      = 0;
+      sbit_metrics->y_ppem      = 0;
+      sbit_metrics->ascender    = 0;
+      sbit_metrics->descender   = 0;
+      sbit_metrics->height      = 0;
+      sbit_metrics->max_advance = 0;
+    }
+
+    return error;
+  }
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+
+  static PSH_Globals_Funcs
+  cff_size_get_globals_funcs( CFF_Size  size )
+  {
+    CFF_Face          face     = (CFF_Face)size->root.face;
+    CFF_Font          font     = (CFF_FontRec *)face->extra.data;
+    PSHinter_Service  pshinter = (PSHinter_Service)font->pshinter;
+    FT_Module         module;
+
+
+    module = FT_Get_Module( size->root.face->driver->root.library,
+                            "pshinter" );
+    return ( module && pshinter && pshinter->get_globals_funcs )
+           ? pshinter->get_globals_funcs( module )
+           : 0;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  cff_size_done( FT_Size  cffsize )        /* CFF_Size */
+  {
+    CFF_Size  size = (CFF_Size)cffsize;
+
+
+    if ( cffsize->internal )
+    {
+      PSH_Globals_Funcs  funcs;
+
+
+      funcs = cff_size_get_globals_funcs( size );
+      if ( funcs )
+        funcs->destroy( (PSH_Globals)cffsize->internal );
+
+      cffsize->internal = 0;
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_size_init( FT_Size  cffsize )         /* CFF_Size */
+  {
+    CFF_Size           size  = (CFF_Size)cffsize;
+    FT_Error           error = CFF_Err_Ok;
+    PSH_Globals_Funcs  funcs = cff_size_get_globals_funcs( size );
+
+
+    if ( funcs )
+    {
+      PSH_Globals    globals;
+      CFF_Face       face    = (CFF_Face)cffsize->face;
+      CFF_Font       font    = (CFF_FontRec *)face->extra.data;
+      CFF_SubFont    subfont = &font->top_font;
+
+      CFF_Private    cpriv   = &subfont->private_dict;
+      PS_PrivateRec  priv;
+
+
+      /* IMPORTANT: The CFF and Type1 private dictionaries have    */
+      /*            slightly different structures; we need to      */
+      /*            synthetize a type1 dictionary on the fly here. */
+
+      {
+        FT_UInt  n, count;
+
+
+        FT_MEM_ZERO( &priv, sizeof ( priv ) );
+
+        count = priv.num_blue_values = cpriv->num_blue_values;
+        for ( n = 0; n < count; n++ )
+          priv.blue_values[n] = (FT_Short)cpriv->blue_values[n];
+
+        count = priv.num_other_blues = cpriv->num_other_blues;
+        for ( n = 0; n < count; n++ )
+          priv.other_blues[n] = (FT_Short)cpriv->other_blues[n];
+
+        count = priv.num_family_blues = cpriv->num_family_blues;
+        for ( n = 0; n < count; n++ )
+          priv.family_blues[n] = (FT_Short)cpriv->family_blues[n];
+
+        count = priv.num_family_other_blues = cpriv->num_family_other_blues;
+        for ( n = 0; n < count; n++ )
+          priv.family_other_blues[n] = (FT_Short)cpriv->family_other_blues[n];
+
+        priv.blue_scale = cpriv->blue_scale;
+        priv.blue_shift = (FT_Int)cpriv->blue_shift;
+        priv.blue_fuzz  = (FT_Int)cpriv->blue_fuzz;
+
+        priv.standard_width[0]  = (FT_UShort)cpriv->standard_width;
+        priv.standard_height[0] = (FT_UShort)cpriv->standard_height;
+
+        count = priv.num_snap_widths = cpriv->num_snap_widths;
+        for ( n = 0; n < count; n++ )
+          priv.snap_widths[n] = (FT_Short)cpriv->snap_widths[n];
+
+        count = priv.num_snap_heights = cpriv->num_snap_heights;
+        for ( n = 0; n < count; n++ )
+          priv.snap_heights[n] = (FT_Short)cpriv->snap_heights[n];
+
+        priv.force_bold     = cpriv->force_bold;
+        priv.language_group = cpriv->language_group;
+        priv.lenIV          = cpriv->lenIV;
+      }
+
+      error = funcs->create( cffsize->face->memory, &priv, &globals );
+      if ( !error )
+        cffsize->internal = (FT_Size_Internal)(void*)globals;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_size_reset( FT_Size  cffsize,         /* CFF_Size */
+                  FT_UInt  char_width,
+                  FT_UInt  char_height )
+  {
+    CFF_Size           size  = (CFF_Size)cffsize;
+    PSH_Globals_Funcs  funcs = cff_size_get_globals_funcs( size );
+    FT_Error           error = CFF_Err_Ok;
+    FT_Face            face  = cffsize->face;
+
+    FT_UNUSED( char_width );
+    FT_UNUSED( char_height );
+
+
+    if ( funcs )
+      error = funcs->set_scale( (PSH_Globals)cffsize->internal,
+                                 cffsize->metrics.x_scale,
+                                 cffsize->metrics.y_scale,
+                                 0, 0 );
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    if ( face->face_flags & FT_FACE_FLAG_FIXED_SIZES )
+    {
+      error = sbit_size_reset( size );
+
+      if ( !error && !( face->face_flags & FT_FACE_FLAG_SCALABLE ) )
+        cffsize->metrics = size->strike_metrics;
+    }
+
+#endif
+
+    if ( face->face_flags & FT_FACE_FLAG_SCALABLE )
+      return CFF_Err_Ok;
+    else
+      return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_point_size_reset( FT_Size     cffsize,
+                        FT_F26Dot6  char_width,
+                        FT_F26Dot6  char_height,
+                        FT_UInt     horz_resolution,
+                        FT_UInt     vert_resolution )
+  {
+    FT_UNUSED( char_width );
+    FT_UNUSED( char_height );
+    FT_UNUSED( horz_resolution );
+    FT_UNUSED( vert_resolution );
+
+    return cff_size_reset( cffsize, 0, 0 );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                            SLOT  FUNCTIONS                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( void )
+  cff_slot_done( FT_GlyphSlot  slot )
+  {
+    slot->internal->glyph_hints = 0;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_slot_init( FT_GlyphSlot  slot )
+  {
+    CFF_Face          face     = (CFF_Face)slot->face;
+    CFF_Font          font     = (CFF_FontRec *)face->extra.data;
+    PSHinter_Service  pshinter = (PSHinter_Service)font->pshinter;
+
+
+    if ( pshinter )
+    {
+      FT_Module  module;
+
+
+      module = FT_Get_Module( slot->face->driver->root.library,
+                              "pshinter" );
+      if ( module )
+      {
+        T2_Hints_Funcs  funcs;
+
+
+        funcs = pshinter->get_t2_funcs( module );
+        slot->internal->glyph_hints = (void*)funcs;
+      }
+    }
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                           FACE  FUNCTIONS                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+  static FT_String*
+  cff_strcpy( FT_Memory         memory,
+              const FT_String*  source )
+  {
+    FT_Error    error;
+    FT_String*  result = 0;
+    FT_Int      len = (FT_Int)ft_strlen( source );
+
+
+    if ( !FT_ALLOC( result, len + 1 ) )
+    {
+      FT_MEM_COPY( result, source, len );
+      result[len] = 0;
+    }
+
+    FT_UNUSED( error );
+
+    return result;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_face_init( FT_Stream      stream,
+                 FT_Face        cffface,        /* CFF_Face */
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    CFF_Face            face = (CFF_Face)cffface;
+    FT_Error            error;
+    SFNT_Service        sfnt;
+    FT_Service_PsCMaps  psnames;
+    PSHinter_Service    pshinter;
+    FT_Bool             pure_cff    = 1;
+    FT_Bool             sfnt_format = 0;
+
+#if 0
+    FT_FACE_FIND_GLOBAL_SERVICE( face, sfnt,     SFNT );
+    FT_FACE_FIND_GLOBAL_SERVICE( face, psnames,  POSTSCRIPT_NAMES );
+    FT_FACE_FIND_GLOBAL_SERVICE( face, pshinter, POSTSCRIPT_HINTER );
+
+    if ( !sfnt )
+      goto Bad_Format;
+#else
+    sfnt = (SFNT_Service)FT_Get_Module_Interface(
+             cffface->driver->root.library, "sfnt" );
+    if ( !sfnt )
+      goto Bad_Format;
+
+    FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
+
+    pshinter = (PSHinter_Service)FT_Get_Module_Interface(
+                 cffface->driver->root.library, "pshinter" );
+#endif
+
+    /* create input stream from resource */
+    if ( FT_STREAM_SEEK( 0 ) )
+      goto Exit;
+
+    /* check whether we have a valid OpenType file */
+    error = sfnt->init_face( stream, face, face_index, num_params, params );
+    if ( !error )
+    {
+      if ( face->format_tag != 0x4F54544FL )  /* `OTTO'; OpenType/CFF font */
+      {
+        FT_TRACE2(( "[not a valid OpenType/CFF font]\n" ));
+        goto Bad_Format;
+      }
+
+      /* if we are performing a simple font format check, exit immediately */
+      if ( face_index < 0 )
+        return CFF_Err_Ok;
+
+      sfnt_format = 1;
+
+      /* now, the font can be either an OpenType/CFF font, or an SVG CEF */
+      /* font; in the latter case it doesn't have a `head' table         */
+      error = face->goto_table( face, TTAG_head, stream, 0 );
+      if ( !error )
+      {
+        pure_cff = 0;
+
+        /* load font directory */
+        error = sfnt->load_face( stream, face,
+                                 face_index, num_params, params );
+        if ( error )
+          goto Exit;
+      }
+      else
+      {
+        /* load the `cmap' table explicitly */
+        error = sfnt->load_charmaps( face, stream );
+        if ( error )
+          goto Exit;
+
+        /* XXX: we don't load the GPOS table, as OpenType Layout     */
+        /* support will be added later to a layout library on top of */
+        /* FreeType 2                                                */
+      }
+
+      /* now load the CFF part of the file */
+      error = face->goto_table( face, TTAG_CFF, stream, 0 );
+      if ( error )
+        goto Exit;
+    }
+    else
+    {
+      /* rewind to start of file; we are going to load a pure-CFF font */
+      if ( FT_STREAM_SEEK( 0 ) )
+        goto Exit;
+      error = CFF_Err_Ok;
+    }
+
+    /* now load and parse the CFF table in the file */
+    {
+      CFF_Font         cff;
+      CFF_FontRecDict  dict;
+      FT_Memory        memory = cffface->memory;
+      FT_Int32         flags;
+
+
+      if ( FT_NEW( cff ) )
+        goto Exit;
+
+      face->extra.data = cff;
+      error = cff_font_load( stream, face_index, cff );
+      if ( error )
+        goto Exit;
+
+      cff->pshinter = pshinter;
+      cff->psnames  = (void*)psnames;
+
+      /* Complement the root flags with some interesting information. */
+      /* Note that this is only necessary for pure CFF and CEF fonts. */
+
+      cffface->num_glyphs = cff->num_glyphs;
+
+      dict = &cff->top_font.font_dict;
+
+      /* we need the `PSNames' module for CFF and CEF formats */
+      /* which aren't CID-keyed                               */
+      if ( dict->cid_registry == 0xFFFFU && !psnames )
+      {
+        FT_ERROR(( "cff_face_init:" ));
+        FT_ERROR(( " cannot open CFF & CEF fonts\n" ));
+        FT_ERROR(( "              " ));
+        FT_ERROR(( " without the `PSNames' module\n" ));
+        goto Bad_Format;
+      }
+
+      if ( pure_cff )
+      {
+        char*  style_name = NULL;
+
+
+        /* Set up num_faces. */
+        cffface->num_faces = cff->num_faces;
+
+        /* compute number of glyphs */
+        if ( dict->cid_registry != 0xFFFFU )
+          cffface->num_glyphs = dict->cid_count;
+        else
+          cffface->num_glyphs = cff->charstrings_index.count;
+
+        /* set global bbox, as well as EM size */
+        cffface->bbox.xMin =   dict->font_bbox.xMin             >> 16;
+        cffface->bbox.yMin =   dict->font_bbox.yMin             >> 16;
+        cffface->bbox.xMax = ( dict->font_bbox.xMax + 0xFFFFU ) >> 16;
+        cffface->bbox.yMax = ( dict->font_bbox.yMax + 0xFFFFU ) >> 16;
+
+        cffface->ascender  = (FT_Short)( cffface->bbox.yMax );
+        cffface->descender = (FT_Short)( cffface->bbox.yMin );
+        cffface->height    = (FT_Short)(
+          ( ( cffface->ascender - cffface->descender ) * 12 ) / 10 );
+
+        if ( dict->units_per_em )
+          cffface->units_per_EM = dict->units_per_em;
+        else
+          cffface->units_per_EM = 1000;
+
+        cffface->underline_position  =
+          (FT_Short)( dict->underline_position >> 16 );
+        cffface->underline_thickness =
+          (FT_Short)( dict->underline_thickness >> 16 );
+
+        /* retrieve font family & style name */
+        cffface->family_name = cff_index_get_name( &cff->name_index,
+                                                   face_index );
+
+        if ( cffface->family_name )
+        {
+          char*  full   = cff_index_get_sid_string( &cff->string_index,
+                                                    dict->full_name,
+                                                    psnames );
+          char*  fullp  = full;
+          char*  family = cffface->family_name;
+
+          /* We try to extract the style name from the full name.   */
+          /* We need to ignore spaces and dashes during the search. */
+          if ( full )
+          {
+            while ( *fullp )
+            {
+              /* skip common characters at the start of both strings */
+              if ( *fullp == *family )
+              {
+                family++;
+                fullp++;
+                continue;
+              }
+
+              /* ignore spaces and dashes in full name during comparison */
+              if ( *fullp == ' ' || *fullp == '-' )
+              {
+                fullp++;
+                continue;
+              }
+
+              /* ignore spaces and dashes in family name during comparison */
+              if ( *family == ' ' || *family == '-' )
+              {
+                family++;
+                continue;
+              }
+
+              if ( !*family && *fullp )
+              {
+                /* Rhe full name begins with the same characters as the  */
+                /* family name, with spaces and dashes removed.  In this */
+                /* case, the remaining string in `fullp' will be used as */
+                /* the style name.                                       */
+                style_name = cff_strcpy( memory, fullp );
+              }
+              break;
+            }
+            FT_FREE( full );
+          }
+        }
+        else
+        {
+          char  *cid_font_name =
+                   cff_index_get_sid_string( &cff->string_index,
+                                             dict->cid_font_name,
+                                             psnames );
+
+
+          /* do we have a `/FontName' for a CID-keyed font? */
+          if ( cid_font_name )
+            cffface->family_name = cid_font_name;
+        }
+
+        if ( style_name )
+          cffface->style_name = style_name;
+        else
+          /* assume "Regular" style if we don't know better */
+          cffface->style_name = cff_strcpy( memory, (char *)"Regular" );
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Compute face flags.                                             */
+        /*                                                                 */
+        flags = FT_FACE_FLAG_SCALABLE  |    /* scalable outlines */
+                FT_FACE_FLAG_HORIZONTAL;    /* horizontal data   */
+
+        if ( sfnt_format )
+          flags |= FT_FACE_FLAG_SFNT;
+
+        /* fixed width font? */
+        if ( dict->is_fixed_pitch )
+          flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+  /* XXX: WE DO NOT SUPPORT KERNING METRICS IN THE GPOS TABLE FOR NOW */
+#if 0
+        /* kerning available? */
+        if ( face->kern_pairs )
+          flags |= FT_FACE_FLAG_KERNING;
+#endif
+
+        cffface->face_flags = flags;
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Compute style flags.                                            */
+        /*                                                                 */
+        flags = 0;
+
+        if ( dict->italic_angle )
+          flags |= FT_STYLE_FLAG_ITALIC;
+
+        {
+          char  *weight = cff_index_get_sid_string( &cff->string_index,
+                                                    dict->weight,
+                                                    psnames );
+
+
+          if ( weight )
+            if ( !ft_strcmp( weight, "Bold"  ) ||
+                 !ft_strcmp( weight, "Black" ) )
+              flags |= FT_STYLE_FLAG_BOLD;
+          FT_FREE( weight );
+        }
+
+        cffface->style_flags = flags;
+      }
+
+#ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
+      /* CID-keyed CFF fonts don't have glyph names -- the SFNT loader */
+      /* has unset this flag because of the 3.0 `post' table           */
+      if ( dict->cid_registry == 0xFFFFU )
+        cffface->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;
+#endif
+
+      /*******************************************************************/
+      /*                                                                 */
+      /* Compute char maps.                                              */
+      /*                                                                 */
+
+      /* Try to synthetize a Unicode charmap if there is none available */
+      /* already.  If an OpenType font contains a Unicode "cmap", we    */
+      /* will use it, whatever be in the CFF part of the file.          */
+      {
+        FT_CharMapRec  cmaprec;
+        FT_CharMap     cmap;
+        FT_UInt        nn;
+        CFF_Encoding   encoding = &cff->encoding;
+
+
+        for ( nn = 0; nn < (FT_UInt)cffface->num_charmaps; nn++ )
+        {
+          cmap = cffface->charmaps[nn];
+
+          /* Windows Unicode (3,1)? */
+          if ( cmap->platform_id == 3 && cmap->encoding_id == 1 )
+            goto Skip_Unicode;
+
+          /* Deprecated Unicode platform id? */
+          if ( cmap->platform_id == 0 )
+            goto Skip_Unicode; /* Standard Unicode (deprecated) */
+        }
+
+        /* since CID-keyed fonts don't contain glyph names, we can't */
+        /* construct a cmap                                          */
+        if ( pure_cff && cff->top_font.font_dict.cid_registry != 0xFFFFU )
+          goto Exit;
+
+        /* we didn't find a Unicode charmap -- synthetize one */
+        cmaprec.face        = cffface;
+        cmaprec.platform_id = 3;
+        cmaprec.encoding_id = 1;
+        cmaprec.encoding    = FT_ENCODING_UNICODE;
+
+        nn = (FT_UInt)cffface->num_charmaps;
+
+        FT_CMap_New( &cff_cmap_unicode_class_rec, NULL, &cmaprec, NULL );
+
+        /* if no Unicode charmap was previously selected, select this one */
+        if ( cffface->charmap == NULL && nn != (FT_UInt)cffface->num_charmaps )
+          cffface->charmap = cffface->charmaps[nn];
+
+      Skip_Unicode:
+        if ( encoding->count > 0 )
+        {
+          FT_CMap_Class  clazz;
+
+
+          cmaprec.face        = cffface;
+          cmaprec.platform_id = 7;  /* Adobe platform id */
+
+          if ( encoding->offset == 0 )
+          {
+            cmaprec.encoding_id = TT_ADOBE_ID_STANDARD;
+            cmaprec.encoding    = FT_ENCODING_ADOBE_STANDARD;
+            clazz               = &cff_cmap_encoding_class_rec;
+          }
+          else if ( encoding->offset == 1 )
+          {
+            cmaprec.encoding_id = TT_ADOBE_ID_EXPERT;
+            cmaprec.encoding    = FT_ENCODING_ADOBE_EXPERT;
+            clazz               = &cff_cmap_encoding_class_rec;
+          }
+          else
+          {
+            cmaprec.encoding_id = TT_ADOBE_ID_CUSTOM;
+            cmaprec.encoding    = FT_ENCODING_ADOBE_CUSTOM;
+            clazz               = &cff_cmap_encoding_class_rec;
+          }
+
+          FT_CMap_New( clazz, NULL, &cmaprec, NULL );
+        }
+      }
+    }
+
+  Exit:
+    return error;
+
+  Bad_Format:
+    error = CFF_Err_Unknown_File_Format;
+    goto Exit;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  cff_face_done( FT_Face  cffface )         /* CFF_Face */
+  {
+    CFF_Face      face   = (CFF_Face)cffface;
+    FT_Memory     memory = cffface->memory;
+    SFNT_Service  sfnt   = (SFNT_Service)face->sfnt;
+
+
+    if ( sfnt )
+      sfnt->done_face( face );
+
+    {
+      CFF_Font  cff = (CFF_Font)face->extra.data;
+
+
+      if ( cff )
+      {
+        cff_font_done( cff );
+        FT_FREE( face->extra.data );
+      }
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_driver_init( FT_Module  module )
+  {
+    FT_UNUSED( module );
+
+    return CFF_Err_Ok;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  cff_driver_done( FT_Module  module )
+  {
+    FT_UNUSED( module );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffobjs.h b/nx-X11/extras/freetype2/src/cff/cffobjs.h
new file mode 100644
index 000000000..338ec748b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffobjs.h
@@ -0,0 +1,171 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffobjs.h                                                              */
+/*                                                                         */
+/*    OpenType objects manager (specification).                            */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 __CFFOBJS_H__
+#define __CFFOBJS_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include "cfftypes.h"
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    CFF_Driver                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an OpenType driver object.                             */
+  /*                                                                       */
+  typedef struct CFF_DriverRec_*  CFF_Driver;
+
+  typedef TT_Face  CFF_Face;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    CFF_Size                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an OpenType size object.                               */
+  /*                                                                       */
+  typedef struct  CFF_SizeRec_
+  {
+    FT_SizeRec       root;
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    FT_UInt          strike_index;    /* 0xFFFF to indicate invalid */
+    FT_Size_Metrics  strike_metrics;  /* current strike's metrics   */
+
+#endif
+
+  } CFF_SizeRec, *CFF_Size;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    CFF_GlyphSlot                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an OpenType glyph slot object.                         */
+  /*                                                                       */
+  typedef struct  CFF_GlyphSlotRec_
+  {
+    FT_GlyphSlotRec  root;
+
+    FT_Bool          hint;
+    FT_Bool          scaled;
+
+    FT_Fixed         x_scale;
+    FT_Fixed         y_scale;
+
+  } CFF_GlyphSlotRec, *CFF_GlyphSlot;
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Subglyph transformation record.                                       */
+  /*                                                                       */
+  typedef struct  CFF_Transform_
+  {
+    FT_Fixed    xx, xy;     /* transformation matrix coefficients */
+    FT_Fixed    yx, yy;
+    FT_F26Dot6  ox, oy;     /* offsets        */
+
+  } CFF_Transform;
+
+
+  /***********************************************************************/
+  /*                                                                     */
+  /* TrueType driver class.                                              */
+  /*                                                                     */
+  typedef struct  CFF_DriverRec_
+  {
+    FT_DriverRec  root;
+    void*         extension_component;
+
+  } CFF_DriverRec;
+
+
+  FT_LOCAL( FT_Error )
+  cff_size_init( FT_Size  size );           /* CFF_Size */
+
+  FT_LOCAL( void )
+  cff_size_done( FT_Size  size );           /* CFF_Size */
+
+  FT_LOCAL( FT_Error )
+  cff_size_reset( FT_Size  size,            /* CFF_Size */
+                  FT_UInt  char_width,
+                  FT_UInt  char_height );
+
+  FT_LOCAL( FT_Error )
+  cff_point_size_reset( FT_Size     cffsize,
+                        FT_F26Dot6  char_width,
+                        FT_F26Dot6  char_height,
+                        FT_UInt     horz_resolution,
+                        FT_UInt     vert_resolution );
+
+  FT_LOCAL( void )
+  cff_slot_done( FT_GlyphSlot  slot );
+
+  FT_LOCAL( FT_Error )
+  cff_slot_init( FT_GlyphSlot  slot );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Face functions                                                        */
+  /*                                                                       */
+  FT_LOCAL( FT_Error )
+  cff_face_init( FT_Stream      stream,
+                 FT_Face        face,           /* CFF_Face */
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params );
+
+  FT_LOCAL( void )
+  cff_face_done( FT_Face  face );               /* CFF_Face */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Driver functions                                                      */
+  /*                                                                       */
+  FT_LOCAL( FT_Error )
+  cff_driver_init( FT_Module  module );
+
+  FT_LOCAL( void )
+  cff_driver_done( FT_Module  module );
+
+
+FT_END_HEADER
+
+#endif /* __CFFOBJS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffparse.c b/nx-X11/extras/freetype2/src/cff/cffparse.c
new file mode 100644
index 000000000..8f1a98c55
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffparse.c
@@ -0,0 +1,688 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffparse.c                                                             */
+/*                                                                         */
+/*    CFF token stream parser (body)                                       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 "cffparse.h"
+#include FT_INTERNAL_STREAM_H
+
+#include "cfferrs.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_cffparse
+
+
+  enum
+  {
+    cff_kind_none = 0,
+    cff_kind_num,
+    cff_kind_fixed,
+    cff_kind_fixed_thousand,
+    cff_kind_string,
+    cff_kind_bool,
+    cff_kind_delta,
+    cff_kind_callback,
+
+    cff_kind_max  /* do not remove */
+  };
+
+
+  /* now generate handlers for the most simple fields */
+  typedef FT_Error  (*CFF_Field_Reader)( CFF_Parser  parser );
+
+  typedef struct  CFF_Field_Handler_
+  {
+    int               kind;
+    int               code;
+    FT_UInt           offset;
+    FT_Byte           size;
+    CFF_Field_Reader  reader;
+    FT_UInt           array_max;
+    FT_UInt           count_offset;
+
+  } CFF_Field_Handler;
+
+
+  FT_LOCAL_DEF( void )
+  cff_parser_init( CFF_Parser  parser,
+                   FT_UInt     code,
+                   void*       object )
+  {
+    FT_MEM_ZERO( parser, sizeof ( *parser ) );
+
+    parser->top         = parser->stack;
+    parser->object_code = code;
+    parser->object      = object;
+  }
+
+
+  /* read an integer */
+  static FT_Long
+  cff_parse_integer( FT_Byte*  start,
+                     FT_Byte*  limit )
+  {
+    FT_Byte*  p   = start;
+    FT_Int    v   = *p++;
+    FT_Long   val = 0;
+
+
+    if ( v == 28 )
+    {
+      if ( p + 2 > limit )
+        goto Bad;
+
+      val = (FT_Short)( ( (FT_Int)p[0] << 8 ) | p[1] );
+      p  += 2;
+    }
+    else if ( v == 29 )
+    {
+      if ( p + 4 > limit )
+        goto Bad;
+
+      val = ( (FT_Long)p[0] << 24 ) |
+            ( (FT_Long)p[1] << 16 ) |
+            ( (FT_Long)p[2] <<  8 ) |
+                       p[3];
+      p += 4;
+    }
+    else if ( v < 247 )
+    {
+      val = v - 139;
+    }
+    else if ( v < 251 )
+    {
+      if ( p + 1 > limit )
+        goto Bad;
+
+      val = ( v - 247 ) * 256 + p[0] + 108;
+      p++;
+    }
+    else
+    {
+      if ( p + 1 > limit )
+        goto Bad;
+
+      val = -( v - 251 ) * 256 - p[0] - 108;
+      p++;
+    }
+
+  Exit:
+    return val;
+
+  Bad:
+    val = 0;
+    goto Exit;
+  }
+
+
+  /* read a real */
+  static FT_Fixed
+  cff_parse_real( FT_Byte*  start,
+                  FT_Byte*  limit,
+                  FT_Int    power_ten )
+  {
+    FT_Byte*  p    = start;
+    FT_Long   num, divider, result, exp;
+    FT_Int    sign = 0, exp_sign = 0;
+    FT_UInt   nib;
+    FT_UInt   phase;
+
+
+    result  = 0;
+    num     = 0;
+    divider = 1;
+
+    /* first of all, read the integer part */
+    phase = 4;
+
+    for (;;)
+    {
+      /* If we entered this iteration with phase == 4, we need to */
+      /* read a new byte.  This also skips past the intial 0x1E.  */
+      if ( phase )
+      {
+        p++;
+
+        /* Make sure we don't read past the end. */
+        if ( p >= limit )
+          goto Bad;
+      }
+
+      /* Get the nibble. */
+      nib   = ( p[0] >> phase ) & 0xF;
+      phase = 4 - phase;
+
+      if ( nib == 0xE )
+        sign = 1;
+      else if ( nib > 9 )
+        break;
+      else
+        result = result * 10 + nib;
+    }
+
+    /* read decimal part, if any */
+    if ( nib == 0xa )
+      for (;;)
+      {
+        /* If we entered this iteration with phase == 4, we need */
+        /* to read a new byte.                                   */
+        if ( phase )
+        {
+          p++;
+
+          /* Make sure we don't read past the end. */
+          if ( p >= limit )
+            goto Bad;
+        }
+
+        /* Get the nibble. */
+        nib   = ( p[0] >> phase ) & 0xF;
+        phase = 4 - phase;
+        if ( nib >= 10 )
+          break;
+
+        if ( divider < 10000000L )
+        {
+          num      = num * 10 + nib;
+          divider *= 10;
+        }
+      }
+
+    /* read exponent, if any */
+    if ( nib == 12 )
+    {
+      exp_sign = 1;
+      nib      = 11;
+    }
+
+    if ( nib == 11 )
+    {
+      exp = 0;
+
+      for (;;)
+      {
+        /* If we entered this iteration with phase == 4, we need */
+        /* to read a new byte.                                   */
+        if ( phase )
+        {
+          p++;
+
+          /* Make sure we don't read past the end. */
+          if ( p >= limit )
+            goto Bad;
+        }
+
+        /* Get the nibble. */
+        nib   = ( p[0] >> phase ) & 0xF;
+        phase = 4 - phase;
+        if ( nib >= 10 )
+          break;
+
+        exp = exp * 10 + nib;
+      }
+
+      if ( exp_sign )
+        exp = -exp;
+
+      power_ten += (FT_Int)exp;
+    }
+
+    /* raise to power of ten if needed */
+    while ( power_ten > 0 )
+    {
+      result = result * 10;
+      num    = num * 10;
+
+      power_ten--;
+    }
+
+    while ( power_ten < 0 )
+    {
+      result  = result / 10;
+      divider = divider * 10;
+
+      power_ten++;
+    }
+
+    /* Move the integer part into the high 16 bits. */
+    result <<= 16;
+
+    /* Place the decimal part into the low 16 bits. */
+    if ( num )
+      result |= FT_DivFix( num, divider );
+
+    if ( sign )
+      result = -result;
+
+  Exit:
+    return result;
+
+  Bad:
+    result = 0;
+    goto Exit;
+  }
+
+
+  /* read a number, either integer or real */
+  static FT_Long
+  cff_parse_num( FT_Byte**  d )
+  {
+    return ( **d == 30 ? ( cff_parse_real   ( d[0], d[1], 0 ) >> 16 )
+                       :   cff_parse_integer( d[0], d[1] ) );
+  }
+
+
+  /* read a floating point number, either integer or real */
+  static FT_Fixed
+  cff_parse_fixed( FT_Byte**  d )
+  {
+    return ( **d == 30 ? cff_parse_real   ( d[0], d[1], 0 )
+                       : cff_parse_integer( d[0], d[1] ) << 16 );
+  }
+
+  /* read a floating point number, either integer or real, */
+  /* but return 1000 times the number read in.             */
+  static FT_Fixed
+  cff_parse_fixed_thousand( FT_Byte**  d )
+  {
+    return **d ==
+      30 ? cff_parse_real     ( d[0], d[1], 3 )
+         : (FT_Fixed)FT_MulFix( cff_parse_integer( d[0], d[1] ) << 16, 1000 );
+  }
+
+  static FT_Error
+  cff_parse_font_matrix( CFF_Parser  parser )
+  {
+    CFF_FontRecDict  dict   = (CFF_FontRecDict)parser->object;
+    FT_Matrix*       matrix = &dict->font_matrix;
+    FT_Vector*       offset = &dict->font_offset;
+    FT_UShort*       upm    = &dict->units_per_em;
+    FT_Byte**        data   = parser->stack;
+    FT_Error         error;
+    FT_Fixed         temp;
+
+
+    error = CFF_Err_Stack_Underflow;
+
+    if ( parser->top >= parser->stack + 6 )
+    {
+      matrix->xx = cff_parse_fixed_thousand( data++ );
+      matrix->yx = cff_parse_fixed_thousand( data++ );
+      matrix->xy = cff_parse_fixed_thousand( data++ );
+      matrix->yy = cff_parse_fixed_thousand( data++ );
+      offset->x  = cff_parse_fixed_thousand( data++ );
+      offset->y  = cff_parse_fixed_thousand( data   );
+
+      temp = FT_ABS( matrix->yy );
+
+      *upm = (FT_UShort)FT_DivFix( 0x10000L, FT_DivFix( temp, 1000 ) );
+
+      if ( temp != 0x10000L )
+      {
+        matrix->xx = FT_DivFix( matrix->xx, temp );
+        matrix->yx = FT_DivFix( matrix->yx, temp );
+        matrix->xy = FT_DivFix( matrix->xy, temp );
+        matrix->yy = FT_DivFix( matrix->yy, temp );
+        offset->x  = FT_DivFix( offset->x,  temp );
+        offset->y  = FT_DivFix( offset->y,  temp );
+      }
+
+      /* note that the offsets must be expressed in integer font units */
+      offset->x >>= 16;
+      offset->y >>= 16;
+
+      error = CFF_Err_Ok;
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  cff_parse_font_bbox( CFF_Parser  parser )
+  {
+    CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
+    FT_BBox*         bbox = &dict->font_bbox;
+    FT_Byte**        data = parser->stack;
+    FT_Error         error;
+
+
+    error = CFF_Err_Stack_Underflow;
+
+    if ( parser->top >= parser->stack + 4 )
+    {
+      bbox->xMin = FT_RoundFix( cff_parse_fixed( data++ ) );
+      bbox->yMin = FT_RoundFix( cff_parse_fixed( data++ ) );
+      bbox->xMax = FT_RoundFix( cff_parse_fixed( data++ ) );
+      bbox->yMax = FT_RoundFix( cff_parse_fixed( data   ) );
+      error = CFF_Err_Ok;
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  cff_parse_private_dict( CFF_Parser  parser )
+  {
+    CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
+    FT_Byte**        data = parser->stack;
+    FT_Error         error;
+
+
+    error = CFF_Err_Stack_Underflow;
+
+    if ( parser->top >= parser->stack + 2 )
+    {
+      dict->private_size   = cff_parse_num( data++ );
+      dict->private_offset = cff_parse_num( data   );
+      error = CFF_Err_Ok;
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  cff_parse_cid_ros( CFF_Parser  parser )
+  {
+    CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
+    FT_Byte**        data = parser->stack;
+    FT_Error         error;
+
+
+    error = CFF_Err_Stack_Underflow;
+
+    if ( parser->top >= parser->stack + 3 )
+    {
+      dict->cid_registry   = (FT_UInt)cff_parse_num ( data++ );
+      dict->cid_ordering   = (FT_UInt)cff_parse_num ( data++ );
+      dict->cid_supplement = (FT_ULong)cff_parse_num( data );
+      error = CFF_Err_Ok;
+    }
+
+    return error;
+  }
+
+
+#define CFF_FIELD_NUM( code, name ) \
+          CFF_FIELD( code, name, cff_kind_num )
+#define CFF_FIELD_FIXED( code, name ) \
+          CFF_FIELD( code, name, cff_kind_fixed )
+#define CFF_FIELD_FIXED_1000( code, name ) \
+          CFF_FIELD( code, name, cff_kind_fixed_thousand )
+#define CFF_FIELD_STRING( code, name ) \
+          CFF_FIELD( code, name, cff_kind_string )
+#define CFF_FIELD_BOOL( code, name ) \
+          CFF_FIELD( code, name, cff_kind_bool )
+#define CFF_FIELD_DELTA( code, name, max ) \
+          CFF_FIELD( code, name, cff_kind_delta )
+
+#define CFF_FIELD_CALLBACK( code, name ) \
+          {                              \
+            cff_kind_callback,           \
+            code | CFFCODE,              \
+            0, 0,                        \
+            cff_parse_ ## name,          \
+            0, 0                         \
+          },
+
+#undef  CFF_FIELD
+#define CFF_FIELD( code, name, kind ) \
+          {                          \
+            kind,                    \
+            code | CFFCODE,          \
+            FT_FIELD_OFFSET( name ), \
+            FT_FIELD_SIZE( name ),   \
+            0, 0, 0                  \
+          },
+
+#undef  CFF_FIELD_DELTA
+#define CFF_FIELD_DELTA( code, name, max ) \
+        {                                  \
+          cff_kind_delta,                  \
+          code | CFFCODE,                  \
+          FT_FIELD_OFFSET( name ),         \
+          FT_FIELD_SIZE_DELTA( name ),     \
+          0,                               \
+          max,                             \
+          FT_FIELD_OFFSET( num_ ## name )  \
+        },
+
+#define CFFCODE_TOPDICT  0x1000
+#define CFFCODE_PRIVATE  0x2000
+
+  static const CFF_Field_Handler  cff_field_handlers[] =
+  {
+
+#include "cfftoken.h"
+
+    { 0, 0, 0, 0, 0, 0, 0 }
+  };
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cff_parser_run( CFF_Parser  parser,
+                  FT_Byte*    start,
+                  FT_Byte*    limit )
+  {
+    FT_Byte*  p     = start;
+    FT_Error  error = CFF_Err_Ok;
+
+
+    parser->top    = parser->stack;
+    parser->start  = start;
+    parser->limit  = limit;
+    parser->cursor = start;
+
+    while ( p < limit )
+    {
+      FT_UInt  v = *p;
+
+
+      if ( v >= 27 && v != 31 )
+      {
+        /* it's a number; we will push its position on the stack */
+        if ( parser->top - parser->stack >= CFF_MAX_STACK_DEPTH )
+          goto Stack_Overflow;
+
+        *parser->top ++ = p;
+
+        /* now, skip it */
+        if ( v == 30 )
+        {
+          /* skip real number */
+          p++;
+          for (;;)
+          {
+            if ( p >= limit )
+              goto Syntax_Error;
+            v = p[0] >> 4;
+            if ( v == 15 )
+              break;
+            v = p[0] & 0xF;
+            if ( v == 15 )
+              break;
+            p++;
+          }
+        }
+        else if ( v == 28 )
+          p += 2;
+        else if ( v == 29 )
+          p += 4;
+        else if ( v > 246 )
+          p += 1;
+      }
+      else
+      {
+        /* This is not a number, hence it's an operator.  Compute its code */
+        /* and look for it in our current list.                            */
+
+        FT_UInt                   code;
+        FT_UInt                   num_args = (FT_UInt)
+                                             ( parser->top - parser->stack );
+        const CFF_Field_Handler*  field;
+
+
+        *parser->top = p;
+        code = v;
+        if ( v == 12 )
+        {
+          /* two byte operator */
+          p++;
+          if ( p >= limit )
+            goto Syntax_Error;
+
+          code = 0x100 | p[0];
+        }
+        code = code | parser->object_code;
+
+        for ( field = cff_field_handlers; field->kind; field++ )
+        {
+          if ( field->code == (FT_Int)code )
+          {
+            /* we found our field's handler; read it */
+            FT_Long   val;
+            FT_Byte*  q = (FT_Byte*)parser->object + field->offset;
+
+
+            /* check that we have enough arguments -- except for */
+            /* delta encoded arrays, which can be empty          */
+            if ( field->kind != cff_kind_delta && num_args < 1 )
+              goto Stack_Underflow;
+
+            switch ( field->kind )
+            {
+            case cff_kind_bool:
+            case cff_kind_string:
+            case cff_kind_num:
+              val = cff_parse_num( parser->stack );
+              goto Store_Number;
+
+            case cff_kind_fixed:
+              val = cff_parse_fixed( parser->stack );
+              goto Store_Number;
+
+            case cff_kind_fixed_thousand:
+              val = cff_parse_fixed_thousand( parser->stack );
+
+            Store_Number:
+              switch ( field->size )
+              {
+              case (8 / FT_CHAR_BIT):
+                *(FT_Byte*)q = (FT_Byte)val;
+                break;
+
+              case (16 / FT_CHAR_BIT):
+                *(FT_Short*)q = (FT_Short)val;
+                break;
+
+              case (32 / FT_CHAR_BIT):
+                *(FT_Int32*)q = (FT_Int)val;
+                break;
+
+              default:  /* for 64-bit systems */
+                *(FT_Long*)q = val;
+              }
+              break;
+
+            case cff_kind_delta:
+              {
+                FT_Byte*   qcount = (FT_Byte*)parser->object +
+                                      field->count_offset;
+
+                FT_Byte**  data = parser->stack;
+
+
+                if ( num_args > field->array_max )
+                  num_args = field->array_max;
+
+                /* store count */
+                *qcount = (FT_Byte)num_args;
+
+                val = 0;
+                while ( num_args > 0 )
+                {
+                  val += cff_parse_num( data++ );
+                  switch ( field->size )
+                  {
+                  case (8 / FT_CHAR_BIT):
+                    *(FT_Byte*)q = (FT_Byte)val;
+                    break;
+
+                  case (16 / FT_CHAR_BIT):
+                    *(FT_Short*)q = (FT_Short)val;
+                    break;
+
+                  case (32 / FT_CHAR_BIT):
+                    *(FT_Int32*)q = (FT_Int)val;
+                    break;
+
+                  default:  /* for 64-bit systems */
+                    *(FT_Long*)q = val;
+                  }
+
+                  q += field->size;
+                  num_args--;
+                }
+              }
+              break;
+
+            default:  /* callback */
+              error = field->reader( parser );
+              if ( error )
+                goto Exit;
+            }
+            goto Found;
+          }
+        }
+
+        /* this is an unknown operator, or it is unsupported; */
+        /* we will ignore it for now.                         */
+
+      Found:
+        /* clear stack */
+        parser->top = parser->stack;
+      }
+      p++;
+    }
+
+  Exit:
+    return error;
+
+  Stack_Overflow:
+    error = CFF_Err_Invalid_Argument;
+    goto Exit;
+
+  Stack_Underflow:
+    error = CFF_Err_Invalid_Argument;
+    goto Exit;
+
+  Syntax_Error:
+    error = CFF_Err_Invalid_Argument;
+    goto Exit;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cffparse.h b/nx-X11/extras/freetype2/src/cff/cffparse.h
new file mode 100644
index 000000000..8f3fa5885
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cffparse.h
@@ -0,0 +1,69 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cffparse.h                                                             */
+/*                                                                         */
+/*    CFF token stream parser (specification)                              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 __CFF_PARSE_H__
+#define __CFF_PARSE_H__
+
+
+#include <ft2build.h>
+#include "cfftypes.h"
+#include FT_INTERNAL_OBJECTS_H
+
+
+FT_BEGIN_HEADER
+
+
+#define CFF_MAX_STACK_DEPTH  96
+
+#define CFF_CODE_TOPDICT  0x1000
+#define CFF_CODE_PRIVATE  0x2000
+
+
+  typedef struct  CFF_ParserRec_
+  {
+    FT_Byte*   start;
+    FT_Byte*   limit;
+    FT_Byte*   cursor;
+
+    FT_Byte*   stack[CFF_MAX_STACK_DEPTH + 1];
+    FT_Byte**  top;
+
+    FT_UInt    object_code;
+    void*      object;
+
+  } CFF_ParserRec, *CFF_Parser;
+
+
+  FT_LOCAL( void )
+  cff_parser_init( CFF_Parser  parser,
+                   FT_UInt     code,
+                   void*       object );
+
+  FT_LOCAL( FT_Error )
+  cff_parser_run( CFF_Parser  parser,
+                  FT_Byte*    start,
+                  FT_Byte*    limit );
+
+
+FT_END_HEADER
+
+
+#endif /* __CFF_PARSE_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cfftoken.h b/nx-X11/extras/freetype2/src/cff/cfftoken.h
new file mode 100644
index 000000000..659d1576a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cfftoken.h
@@ -0,0 +1,97 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cfftoken.h                                                             */
+/*                                                                         */
+/*    CFF token definitions (specification only).                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  CFF_FontRecDictRec
+
+#undef  CFFCODE
+#define CFFCODE       CFFCODE_TOPDICT
+
+  CFF_FIELD_STRING  ( 0,     version )
+  CFF_FIELD_STRING  ( 1,     notice )
+  CFF_FIELD_STRING  ( 0x100, copyright )
+  CFF_FIELD_STRING  ( 2,     full_name )
+  CFF_FIELD_STRING  ( 3,     family_name )
+  CFF_FIELD_STRING  ( 4,     weight )
+  CFF_FIELD_BOOL    ( 0x101, is_fixed_pitch )
+  CFF_FIELD_FIXED   ( 0x102, italic_angle )
+  CFF_FIELD_FIXED   ( 0x103, underline_position )
+  CFF_FIELD_FIXED   ( 0x104, underline_thickness )
+  CFF_FIELD_NUM     ( 0x105, paint_type )
+  CFF_FIELD_NUM     ( 0x106, charstring_type )
+  CFF_FIELD_CALLBACK( 0x107, font_matrix )
+  CFF_FIELD_NUM     ( 13,    unique_id )
+  CFF_FIELD_CALLBACK( 5,     font_bbox )
+  CFF_FIELD_NUM     ( 0x108, stroke_width )
+  CFF_FIELD_NUM     ( 15,    charset_offset )
+  CFF_FIELD_NUM     ( 16,    encoding_offset )
+  CFF_FIELD_NUM     ( 17,    charstrings_offset )
+  CFF_FIELD_CALLBACK( 18,    private_dict )
+  CFF_FIELD_NUM     ( 0x114, synthetic_base )
+  CFF_FIELD_STRING  ( 0x115, embedded_postscript )
+
+#if 0
+  CFF_FIELD_STRING  ( 0x116, base_font_name )
+  CFF_FIELD_DELTA   ( 0x117, base_font_blend, 16 )
+  CFF_FIELD_CALLBACK( 0x118, multiple_master )
+  CFF_FIELD_CALLBACK( 0x119, blend_axit_types )
+#endif
+
+  CFF_FIELD_CALLBACK( 0x11E, cid_ros )
+  CFF_FIELD_NUM     ( 0x11F, cid_font_version )
+  CFF_FIELD_NUM     ( 0x120, cid_font_revision )
+  CFF_FIELD_NUM     ( 0x121, cid_font_type )
+  CFF_FIELD_NUM     ( 0x122, cid_count )
+  CFF_FIELD_NUM     ( 0x123, cid_uid_base )
+  CFF_FIELD_NUM     ( 0x124, cid_fd_array_offset )
+  CFF_FIELD_NUM     ( 0x125, cid_fd_select_offset )
+  CFF_FIELD_STRING  ( 0x126, cid_font_name )
+
+#if 0
+  CFF_FIELD_NUM     ( 0x127, chameleon )
+#endif
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  CFF_PrivateRec
+#undef  CFFCODE
+#define CFFCODE       CFFCODE_PRIVATE
+
+  CFF_FIELD_DELTA     ( 6,     blue_values, 14 )
+  CFF_FIELD_DELTA     ( 7,     other_blues, 10 )
+  CFF_FIELD_DELTA     ( 8,     family_blues, 14 )
+  CFF_FIELD_DELTA     ( 9,     family_other_blues, 10 )
+  CFF_FIELD_FIXED_1000( 0x109, blue_scale )
+  CFF_FIELD_NUM       ( 0x10A, blue_shift )
+  CFF_FIELD_NUM       ( 0x10B, blue_fuzz )
+  CFF_FIELD_NUM       ( 10,    standard_width )
+  CFF_FIELD_NUM       ( 11,    standard_height )
+  CFF_FIELD_DELTA     ( 0x10C, snap_widths, 13 )
+  CFF_FIELD_DELTA     ( 0x10D, snap_heights, 13 )
+  CFF_FIELD_BOOL      ( 0x10E, force_bold )
+  CFF_FIELD_FIXED     ( 0x10F, force_bold_threshold )
+  CFF_FIELD_NUM       ( 0x110, lenIV )
+  CFF_FIELD_NUM       ( 0x111, language_group )
+  CFF_FIELD_FIXED     ( 0x112, expansion_factor )
+  CFF_FIELD_NUM       ( 0x113, initial_random_seed )
+  CFF_FIELD_NUM       ( 19,    local_subrs_offset )
+  CFF_FIELD_NUM       ( 20,    default_width )
+  CFF_FIELD_NUM       ( 21,    nominal_width )
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/cfftypes.h b/nx-X11/extras/freetype2/src/cff/cfftypes.h
new file mode 100644
index 000000000..9ddc663de
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/cfftypes.h
@@ -0,0 +1,255 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cfftypes.h                                                             */
+/*                                                                         */
+/*    Basic OpenType/CFF type definitions and interface (specification     */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 __CFFTYPES_H__
+#define __CFFTYPES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CFF_IndexRec                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a CFF Index table.                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    stream      :: The source input stream.                            */
+  /*                                                                       */
+  /*    count       :: The number of elements in the index.                */
+  /*                                                                       */
+  /*    off_size    :: The size in bytes of object offsets in index.       */
+  /*                                                                       */
+  /*    data_offset :: The position of first data byte in the index's      */
+  /*                   bytes.                                              */
+  /*                                                                       */
+  /*    offsets     :: A table of element offsets in the index.            */
+  /*                                                                       */
+  /*    bytes       :: If the index is loaded in memory, its bytes.        */
+  /*                                                                       */
+  typedef struct  CFF_IndexRec_
+  {
+    FT_Stream  stream;
+    FT_UInt    count;
+    FT_Byte    off_size;
+    FT_ULong   data_offset;
+
+    FT_ULong*  offsets;
+    FT_Byte*   bytes;
+
+  } CFF_IndexRec, *CFF_Index;
+
+
+  typedef struct  CFF_EncodingRec_
+  {
+    FT_UInt     format;
+    FT_ULong    offset;
+
+    FT_UInt     count;
+    FT_UShort   sids [256];  /* avoid dynamic allocations */
+    FT_UShort   codes[256];
+
+  } CFF_EncodingRec, *CFF_Encoding;
+
+
+  typedef struct  CFF_CharsetRec_
+  {
+
+    FT_UInt     format;
+    FT_ULong    offset;
+
+    FT_UShort*  sids;
+    FT_UShort*  cids;       /* the inverse mapping of `sids'; only needed */
+                            /* for CID-keyed fonts                        */
+  } CFF_CharsetRec, *CFF_Charset;
+
+
+  typedef struct  CFF_FontRecDictRec_
+  {
+    FT_UInt    version;
+    FT_UInt    notice;
+    FT_UInt    copyright;
+    FT_UInt    full_name;
+    FT_UInt    family_name;
+    FT_UInt    weight;
+    FT_Bool    is_fixed_pitch;
+    FT_Fixed   italic_angle;
+    FT_Fixed   underline_position;
+    FT_Fixed   underline_thickness;
+    FT_Int     paint_type;
+    FT_Int     charstring_type;
+    FT_Matrix  font_matrix;
+    FT_UShort  units_per_em;
+    FT_Vector  font_offset;
+    FT_ULong   unique_id;
+    FT_BBox    font_bbox;
+    FT_Pos     stroke_width;
+    FT_ULong   charset_offset;
+    FT_ULong   encoding_offset;
+    FT_ULong   charstrings_offset;
+    FT_ULong   private_offset;
+    FT_ULong   private_size;
+    FT_Long    synthetic_base;
+    FT_UInt    embedded_postscript;
+
+    /* these should only be used for the top-level font dictionary */
+    FT_UInt    cid_registry;
+    FT_UInt    cid_ordering;
+    FT_ULong   cid_supplement;
+
+    FT_Long    cid_font_version;
+    FT_Long    cid_font_revision;
+    FT_Long    cid_font_type;
+    FT_ULong   cid_count;
+    FT_ULong   cid_uid_base;
+    FT_ULong   cid_fd_array_offset;
+    FT_ULong   cid_fd_select_offset;
+    FT_UInt    cid_font_name;
+
+  } CFF_FontRecDictRec, *CFF_FontRecDict;
+
+
+  typedef struct  CFF_PrivateRec_
+  {
+    FT_Byte   num_blue_values;
+    FT_Byte   num_other_blues;
+    FT_Byte   num_family_blues;
+    FT_Byte   num_family_other_blues;
+
+    FT_Pos    blue_values[14];
+    FT_Pos    other_blues[10];
+    FT_Pos    family_blues[14];
+    FT_Pos    family_other_blues[10];
+
+    FT_Fixed  blue_scale;
+    FT_Pos    blue_shift;
+    FT_Pos    blue_fuzz;
+    FT_Pos    standard_width;
+    FT_Pos    standard_height;
+
+    FT_Byte   num_snap_widths;
+    FT_Byte   num_snap_heights;
+    FT_Pos    snap_widths[13];
+    FT_Pos    snap_heights[13];
+    FT_Bool   force_bold;
+    FT_Fixed  force_bold_threshold;
+    FT_Int    lenIV;
+    FT_Int    language_group;
+    FT_Fixed  expansion_factor;
+    FT_Long   initial_random_seed;
+    FT_ULong  local_subrs_offset;
+    FT_Pos    default_width;
+    FT_Pos    nominal_width;
+
+  } CFF_PrivateRec, *CFF_Private;
+
+
+  typedef struct  CFF_FDSelectRec_
+  {
+    FT_Byte   format;
+    FT_UInt   range_count;
+
+    /* that's the table, taken from the file `as is' */
+    FT_Byte*  data;
+    FT_UInt   data_size;
+
+    /* small cache for format 3 only */
+    FT_UInt   cache_first;
+    FT_UInt   cache_count;
+    FT_Byte   cache_fd;
+
+  } CFF_FDSelectRec, *CFF_FDSelect;
+
+
+  /* A SubFont packs a font dict and a private dict together.  They are */
+  /* needed to support CID-keyed CFF fonts.                             */
+  typedef struct  CFF_SubFontRec_
+  {
+    CFF_FontRecDictRec  font_dict;
+    CFF_PrivateRec      private_dict;
+
+    CFF_IndexRec        local_subrs_index;
+    FT_UInt             num_local_subrs;
+    FT_Byte**           local_subrs;
+
+  } CFF_SubFontRec, *CFF_SubFont;
+
+
+  /* maximum number of sub-fonts in a CID-keyed file */
+#define CFF_MAX_CID_FONTS  32
+
+
+  typedef struct  CFF_FontRec_
+  {
+    FT_Stream        stream;
+    FT_Memory        memory;
+    FT_UInt          num_faces;
+    FT_UInt          num_glyphs;
+
+    FT_Byte          version_major;
+    FT_Byte          version_minor;
+    FT_Byte          header_size;
+    FT_Byte          absolute_offsize;
+
+
+    CFF_IndexRec     name_index;
+    CFF_IndexRec     top_dict_index;
+    CFF_IndexRec     string_index;
+    CFF_IndexRec     global_subrs_index;
+
+    CFF_EncodingRec  encoding;
+    CFF_CharsetRec   charset;
+
+    CFF_IndexRec     charstrings_index;
+    CFF_IndexRec     font_dict_index;
+    CFF_IndexRec     private_index;
+    CFF_IndexRec     local_subrs_index;
+
+    FT_String*       font_name;
+    FT_UInt          num_global_subrs;
+    FT_Byte**        global_subrs;
+
+    CFF_SubFontRec   top_font;
+    FT_UInt          num_subfonts;
+    CFF_SubFont      subfonts[CFF_MAX_CID_FONTS];
+
+    CFF_FDSelectRec  fd_select;
+
+    /* interface to PostScript hinter */
+    void*            pshinter;
+
+    /* interface to Postscript Names service */
+    void*            psnames;
+
+  } CFF_FontRec, *CFF_Font;
+
+
+FT_END_HEADER
+
+#endif /* __CFFTYPES_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cff/descrip.mms b/nx-X11/extras/freetype2/src/cff/descrip.mms
new file mode 100644
index 000000000..2401f2ee2
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 OpenType/CFF driver compilation rules for VMS
+#
+
+
+# Copyright 2001, 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.cff])
+
+OBJS=cff.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cff/module.mk b/nx-X11/extras/freetype2/src/cff/module.mk
new file mode 100644
index 000000000..68789c98a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 CFF module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_cff_driver
+
+add_cff_driver:
+	$(OPEN_DRIVER)cff_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)cff       $(ECHO_DRIVER_DESC)OpenType fonts with extension *.otf$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cff/rules.mk b/nx-X11/extras/freetype2/src/cff/rules.mk
new file mode 100644
index 000000000..4100c8068
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cff/rules.mk
@@ -0,0 +1,72 @@
+#
+# FreeType 2 OpenType/CFF driver configuration rules
+#
+
+
+# Copyright 1996-2000, 2001, 2003 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.
+
+
+# OpenType driver directory
+#
+CFF_DIR := $(SRC_DIR)/cff
+
+
+CFF_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(CFF_DIR))
+
+
+# CFF driver sources (i.e., C files)
+#
+CFF_DRV_SRC := $(CFF_DIR)/cffobjs.c  \
+               $(CFF_DIR)/cffload.c  \
+               $(CFF_DIR)/cffgload.c \
+               $(CFF_DIR)/cffparse.c \
+               $(CFF_DIR)/cffcmap.c  \
+               $(CFF_DIR)/cffdrivr.c
+
+# CFF driver headers
+#
+CFF_DRV_H := $(CFF_DRV_SRC:%.c=%.h) \
+             $(CFF_DIR)/cfftoken.h  \
+             $(CFF_DIR)/cfftypes.h  \
+             $(CFF_DIR)/cfferrs.h
+
+
+# CFF driver object(s)
+#
+#   CFF_DRV_OBJ_M is used during `multi' builds
+#   CFF_DRV_OBJ_S is used during `single' builds
+#
+CFF_DRV_OBJ_M := $(CFF_DRV_SRC:$(CFF_DIR)/%.c=$(OBJ_DIR)/%.$O)
+CFF_DRV_OBJ_S := $(OBJ_DIR)/cff.$O
+
+# CFF driver source file for single build
+#
+CFF_DRV_SRC_S := $(CFF_DIR)/cff.c
+
+
+# CFF driver - single object
+#
+$(CFF_DRV_OBJ_S): $(CFF_DRV_SRC_S) $(CFF_DRV_SRC) $(FREETYPE_H) $(CFF_DRV_H)
+	$(CFF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(CFF_DRV_SRC_S))
+
+
+# CFF driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(CFF_DIR)/%.c $(FREETYPE_H) $(CFF_DRV_H)
+	$(CFF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(CFF_DRV_OBJ_S)
+DRV_OBJS_M += $(CFF_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cid/Jamfile b/nx-X11/extras/freetype2/src/cid/Jamfile
new file mode 100644
index 000000000..a505e3ca4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/cid Jamfile (c) 2001 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) cid ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = cidobjs cidload cidgload cidriver cidparse ;
+  }
+  else
+  {
+    _sources = type1cid ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/cid Jamfile
diff --git a/nx-X11/extras/freetype2/src/cid/ciderrs.h b/nx-X11/extras/freetype2/src/cid/ciderrs.h
new file mode 100644
index 000000000..01813e189
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/ciderrs.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ciderrs.h                                                              */
+/*                                                                         */
+/*    CID error codes (specification only).                                */
+/*                                                                         */
+/*  Copyright 2001 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 CID error enumeration constants.      */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __CIDERRS_H__
+#define __CIDERRS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  CID_Err_
+#define FT_ERR_BASE    FT_Mod_Err_CID
+
+#include FT_ERRORS_H
+
+#endif /* __CIDERRS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidgload.c b/nx-X11/extras/freetype2/src/cid/cidgload.c
new file mode 100644
index 000000000..cbd0865d3
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidgload.c
@@ -0,0 +1,449 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidgload.c                                                             */
+/*                                                                         */
+/*    CID-keyed Type1 Glyph Loader (body).                                 */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 "cidload.h"
+#include "cidgload.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_OUTLINE_H
+
+#include "ciderrs.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_cidgload
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  cid_load_glyph( T1_Decoder  decoder,
+                  FT_UInt     glyph_index )
+  {
+    CID_Face       face = (CID_Face)decoder->builder.face;
+    CID_FaceInfo   cid  = &face->cid;
+    FT_Byte*       p;
+    FT_UInt        fd_select;
+    FT_Stream      stream = face->cid_stream;
+    FT_Error       error  = 0;
+    FT_Byte*       charstring = 0;
+    FT_Memory      memory = face->root.memory;
+    FT_ULong       glyph_length = 0;
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
+
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    /* For incremental fonts get the character data using */
+    /* the callback function.                             */
+    if ( face->root.internal->incremental_interface )
+    {
+      FT_Data  glyph_data;
+
+
+      error = face->root.internal->incremental_interface->funcs->get_glyph_data(
+                face->root.internal->incremental_interface->object,
+                glyph_index,
+                &glyph_data );
+      if ( error )
+        goto Exit;
+
+      p         = (FT_Byte*)glyph_data.pointer;
+      fd_select = (FT_UInt)cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
+
+      if ( glyph_data.length != 0 )
+      {
+        glyph_length = glyph_data.length - cid->fd_bytes;
+        FT_ALLOC( charstring, glyph_length );
+        if ( !error )
+          ft_memcpy( charstring, glyph_data.pointer + cid->fd_bytes,
+                     glyph_length );
+      }
+
+      face->root.internal->incremental_interface->funcs->free_glyph_data(
+                face->root.internal->incremental_interface->object,
+                &glyph_data );
+
+      if ( error )
+        goto Exit;
+    }
+
+    else
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+    /* For ordinary fonts read the CID font dictionary index */
+    /* and charstring offset from the CIDMap.                */
+    {
+      FT_UInt   entry_len = cid->fd_bytes + cid->gd_bytes;
+      FT_ULong  off1;
+
+
+      if ( FT_STREAM_SEEK( cid->data_offset + cid->cidmap_offset +
+                           glyph_index * entry_len )               ||
+           FT_FRAME_ENTER( 2 * entry_len )                         )
+        goto Exit;
+
+      p            = (FT_Byte*)stream->cursor;
+      fd_select    = (FT_UInt) cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
+      off1         = (FT_ULong)cid_get_offset( &p, (FT_Byte)cid->gd_bytes );
+      p           += cid->fd_bytes;
+      glyph_length = cid_get_offset( &p, (FT_Byte)cid->gd_bytes ) - off1;
+      FT_FRAME_EXIT();
+
+      if ( glyph_length == 0 )
+        goto Exit;
+      if ( FT_ALLOC( charstring, glyph_length ) )
+        goto Exit;
+      if ( FT_STREAM_READ_AT( cid->data_offset + off1,
+                              charstring, glyph_length ) )
+        goto Exit;
+    }
+
+    /* Now set up the subrs array and parse the charstrings. */
+    {
+      CID_FaceDict  dict;
+      CID_Subrs     cid_subrs = face->subrs + fd_select;
+      FT_Int        cs_offset;
+
+
+      /* Set up subrs */
+      decoder->num_subrs = cid_subrs->num_subrs;
+      decoder->subrs     = cid_subrs->code;
+      decoder->subrs_len = 0;
+
+      /* Set up font matrix */
+      dict                 = cid->font_dicts + fd_select;
+
+      decoder->font_matrix = dict->font_matrix;
+      decoder->font_offset = dict->font_offset;
+      decoder->lenIV       = dict->private_dict.lenIV;
+
+      /* Decode the charstring. */
+
+      /* Adjustment for seed bytes. */
+      cs_offset = ( decoder->lenIV >= 0 ? decoder->lenIV : 0 );
+
+      /* Decrypt only if lenIV >= 0. */
+      if ( decoder->lenIV >= 0 )
+        psaux->t1_decrypt( charstring, glyph_length, 4330 );
+
+      error = decoder->funcs.parse_charstrings(
+                decoder, charstring + cs_offset,
+                (FT_Int)glyph_length - cs_offset  );
+    }
+
+    FT_FREE( charstring );
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    /* Incremental fonts can optionally override the metrics. */
+    if ( !error                                                              &&
+         face->root.internal->incremental_interface                          &&
+         face->root.internal->incremental_interface->funcs->get_glyph_metrics )
+    {
+      FT_Incremental_MetricsRec  metrics;
+
+
+      metrics.bearing_x = decoder->builder.left_bearing.x;
+      metrics.bearing_y = decoder->builder.left_bearing.y;
+      metrics.advance   = decoder->builder.advance.x;
+      error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
+                face->root.internal->incremental_interface->object,
+                glyph_index, FALSE, &metrics );
+      decoder->builder.left_bearing.x = metrics.bearing_x;
+      decoder->builder.left_bearing.y = metrics.bearing_y;
+      decoder->builder.advance.x      = metrics.advance;
+      decoder->builder.advance.y      = 0;
+    }
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+  Exit:
+    return error;
+  }
+
+
+#if 0
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /**********                                                      *********/
+  /**********                                                      *********/
+  /**********            COMPUTE THE MAXIMUM ADVANCE WIDTH         *********/
+  /**********                                                      *********/
+  /**********    The following code is in charge of computing      *********/
+  /**********    the maximum advance width of the font.  It        *********/
+  /**********    quickly processes each glyph charstring to        *********/
+  /**********    extract the value from either a `sbw' or `seac'   *********/
+  /**********    operator.                                         *********/
+  /**********                                                      *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_face_compute_max_advance( CID_Face  face,
+                                FT_Int*   max_advance )
+  {
+    FT_Error       error;
+    T1_DecoderRec  decoder;
+    FT_Int         glyph_index;
+
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
+
+
+    *max_advance = 0;
+
+    /* Initialize load decoder */
+    error = psaux->t1_decoder_funcs->init( &decoder,
+                                           (FT_Face)face,
+                                           0, /* size       */
+                                           0, /* glyph slot */
+                                           0, /* glyph names! XXX */
+                                           0, /* blend == 0 */
+                                           0, /* hinting == 0 */
+                                           cid_load_glyph );
+    if ( error )
+      return error;
+
+    decoder.builder.metrics_only = 1;
+    decoder.builder.load_points  = 0;
+
+    /* for each glyph, parse the glyph charstring and extract */
+    /* the advance width                                      */
+    for ( glyph_index = 0; glyph_index < face->root.num_glyphs;
+          glyph_index++ )
+    {
+      /* now get load the unscaled outline */
+      error = cid_load_glyph( &decoder, glyph_index );
+      /* ignore the error if one occurred - skip to next glyph */
+    }
+
+    *max_advance = decoder.builder.advance.x;
+
+    return CID_Err_Ok;
+  }
+
+
+#endif /* 0 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /**********                                                      *********/
+  /**********                                                      *********/
+  /**********               UNHINTED GLYPH LOADER                  *********/
+  /**********                                                      *********/
+  /**********    The following code is in charge of loading a      *********/
+  /**********    single outline.  It completely ignores hinting    *********/
+  /**********    and is used when FT_LOAD_NO_HINTING is set.       *********/
+  /**********                                                      *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_slot_load_glyph( FT_GlyphSlot  cidglyph,      /* CID_GlyphSlot */
+                       FT_Size       cidsize,       /* CID_Size      */
+                       FT_UInt       glyph_index,
+                       FT_Int32      load_flags )
+  {
+    CID_GlyphSlot  glyph = (CID_GlyphSlot)cidglyph;
+    CID_Size       size  = (CID_Size)cidsize;
+    FT_Error       error;
+    T1_DecoderRec  decoder;
+    CID_Face       face = (CID_Face)cidglyph->face;
+    FT_Bool        hinting;
+
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
+    FT_Matrix      font_matrix;
+    FT_Vector      font_offset;
+
+
+    if ( load_flags & FT_LOAD_NO_RECURSE )
+      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
+
+    glyph->x_scale = cidsize->metrics.x_scale;
+    glyph->y_scale = cidsize->metrics.y_scale;
+
+    cidglyph->outline.n_points   = 0;
+    cidglyph->outline.n_contours = 0;
+
+    hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE   ) == 0 &&
+                       ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
+
+    cidglyph->format = FT_GLYPH_FORMAT_OUTLINE;
+
+    {
+      error = psaux->t1_decoder_funcs->init( &decoder,
+                                             cidglyph->face,
+                                             cidsize,
+                                             cidglyph,
+                                             0, /* glyph names -- XXX */
+                                             0, /* blend == 0 */
+                                             hinting,
+                                             FT_LOAD_TARGET_MODE( load_flags ),
+                                             cid_load_glyph );
+
+      /* set up the decoder */
+      decoder.builder.no_recurse = FT_BOOL(
+        ( ( load_flags & FT_LOAD_NO_RECURSE ) != 0 ) );
+
+      error = cid_load_glyph( &decoder, glyph_index );
+
+      font_matrix = decoder.font_matrix;
+      font_offset = decoder.font_offset;
+
+      /* save new glyph tables */
+      psaux->t1_decoder_funcs->done( &decoder );
+    }
+
+    /* now, set the metrics -- this is rather simple, as   */
+    /* the left side bearing is the xMin, and the top side */
+    /* bearing the yMax                                    */
+    if ( !error )
+    {
+      cidglyph->outline.flags &= FT_OUTLINE_OWNER;
+      cidglyph->outline.flags |= FT_OUTLINE_REVERSE_FILL;
+
+      /* for composite glyphs, return only left side bearing and */
+      /* advance width                                           */
+      if ( load_flags & FT_LOAD_NO_RECURSE )
+      {
+        FT_Slot_Internal  internal = cidglyph->internal;
+
+
+        cidglyph->metrics.horiBearingX = decoder.builder.left_bearing.x;
+        cidglyph->metrics.horiAdvance  = decoder.builder.advance.x;
+
+        internal->glyph_matrix         = font_matrix;
+        internal->glyph_delta          = font_offset;
+        internal->glyph_transformed    = 1;
+      }
+      else
+      {
+        FT_BBox            cbox;
+        FT_Glyph_Metrics*  metrics = &cidglyph->metrics;
+        FT_Vector          advance;
+
+
+        /* copy the _unscaled_ advance width */
+        metrics->horiAdvance                  = decoder.builder.advance.x;
+        cidglyph->linearHoriAdvance           = decoder.builder.advance.x;
+        cidglyph->internal->glyph_transformed = 0;
+
+        /* make up vertical metrics */
+        metrics->vertBearingX = 0;
+        metrics->vertBearingY = 0;
+        metrics->vertAdvance  = 0;
+
+        cidglyph->linearVertAdvance = 0;
+        cidglyph->format            = FT_GLYPH_FORMAT_OUTLINE;
+
+        if ( size && cidsize->metrics.y_ppem < 24 )
+          cidglyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;
+
+        /* apply the font matrix */
+        FT_Outline_Transform( &cidglyph->outline, &font_matrix );
+
+        FT_Outline_Translate( &cidglyph->outline,
+                              font_offset.x,
+                              font_offset.y );
+
+        advance.x = metrics->horiAdvance;
+        advance.y = 0;
+        FT_Vector_Transform( &advance, &font_matrix );
+        metrics->horiAdvance = advance.x + font_offset.x;
+        advance.x = 0;
+        advance.y = metrics->vertAdvance;
+        FT_Vector_Transform( &advance, &font_matrix );
+        metrics->vertAdvance = advance.y + font_offset.y;
+
+        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )
+        {
+          /* scale the outline and the metrics */
+          FT_Int       n;
+          FT_Outline*  cur = decoder.builder.base;
+          FT_Vector*   vec = cur->points;
+          FT_Fixed     x_scale = glyph->x_scale;
+          FT_Fixed     y_scale = glyph->y_scale;
+
+
+          /* First of all, scale the points */
+          if ( !hinting )
+            for ( n = cur->n_points; n > 0; n--, vec++ )
+            {
+              vec->x = FT_MulFix( vec->x, x_scale );
+              vec->y = FT_MulFix( vec->y, y_scale );
+            }
+
+          FT_Outline_Get_CBox( &cidglyph->outline, &cbox );
+
+          /* Then scale the metrics */
+          metrics->horiAdvance  = FT_MulFix( metrics->horiAdvance,  x_scale );
+          metrics->vertAdvance  = FT_MulFix( metrics->vertAdvance,  y_scale );
+
+          metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );
+          metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );
+
+          if ( hinting )
+          {
+            metrics->horiAdvance = FT_PIX_ROUND( metrics->horiAdvance );
+            metrics->vertAdvance = FT_PIX_ROUND( metrics->vertAdvance );
+
+            metrics->vertBearingX = FT_PIX_ROUND( metrics->vertBearingX );
+            metrics->vertBearingY = FT_PIX_ROUND( metrics->vertBearingY );
+          }
+        }
+
+        /* compute the other metrics */
+        FT_Outline_Get_CBox( &cidglyph->outline, &cbox );
+
+        /* grid fit the bounding box if necessary */
+        if ( hinting )
+        {
+          cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
+          cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
+          cbox.xMax = FT_PIX_CEIL( cbox.xMax );
+          cbox.yMax = FT_PIX_CEIL( cbox.yMax );
+        }
+
+        metrics->width  = cbox.xMax - cbox.xMin;
+        metrics->height = cbox.yMax - cbox.yMin;
+
+        metrics->horiBearingX = cbox.xMin;
+        metrics->horiBearingY = cbox.yMax;
+      }
+    }
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidgload.h b/nx-X11/extras/freetype2/src/cid/cidgload.h
new file mode 100644
index 000000000..a0a91bfea
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidgload.h
@@ -0,0 +1,51 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidgload.h                                                             */
+/*                                                                         */
+/*    OpenType Glyph Loader (specification).                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2004 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 __CIDGLOAD_H__
+#define __CIDGLOAD_H__
+
+
+#include <ft2build.h>
+#include "cidobjs.h"
+
+
+FT_BEGIN_HEADER
+
+
+#if 0
+
+  /* Compute the maximum advance width of a font through quick parsing */
+  FT_LOCAL( FT_Error )
+  cid_face_compute_max_advance( CID_Face  face,
+                                FT_Int*   max_advance );
+
+#endif /* 0 */
+
+  FT_LOCAL( FT_Error )
+  cid_slot_load_glyph( FT_GlyphSlot  glyph,         /* CID_Glyph_Slot */
+                       FT_Size       size,          /* CID_Size       */
+                       FT_UInt       glyph_index,
+                       FT_Int32      load_flags );
+
+
+FT_END_HEADER
+
+#endif /* __CIDGLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidload.c b/nx-X11/extras/freetype2/src/cid/cidload.c
new file mode 100644
index 000000000..ad29dd52d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidload.c
@@ -0,0 +1,644 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidload.c                                                              */
+/*                                                                         */
+/*    CID-keyed Type1 font loader (body).                                  */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_CONFIG_CONFIG_H
+#include FT_MULTIPLE_MASTERS_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+
+#include "cidload.h"
+
+#include "ciderrs.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_cidload
+
+
+  /* read a single offset */
+  FT_LOCAL_DEF( FT_Long )
+  cid_get_offset( FT_Byte*  *start,
+                  FT_Byte    offsize )
+  {
+    FT_Long   result;
+    FT_Byte*  p = *start;
+
+
+    for ( result = 0; offsize > 0; offsize-- )
+    {
+      result <<= 8;
+      result  |= *p++;
+    }
+
+    *start = p;
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    TYPE 1 SYMBOL PARSING                      *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  static FT_Error
+  cid_load_keyword( CID_Face        face,
+                    CID_Loader*     loader,
+                    const T1_Field  keyword )
+  {
+    FT_Error      error;
+    CID_Parser*   parser = &loader->parser;
+    FT_Byte*      object;
+    void*         dummy_object;
+    CID_FaceInfo  cid = &face->cid;
+
+
+    /* if the keyword has a dedicated callback, call it */
+    if ( keyword->type == T1_FIELD_TYPE_CALLBACK )
+    {
+      keyword->reader( (FT_Face)face, parser );
+      error = parser->root.error;
+      goto Exit;
+    }
+
+    /* we must now compute the address of our target object */
+    switch ( keyword->location )
+    {
+    case T1_FIELD_LOCATION_CID_INFO:
+      object = (FT_Byte*)cid;
+      break;
+
+    case T1_FIELD_LOCATION_FONT_INFO:
+      object = (FT_Byte*)&cid->font_info;
+      break;
+
+    case T1_FIELD_LOCATION_BBOX:
+      object = (FT_Byte*)&cid->font_bbox;
+      break;
+
+    default:
+      {
+        CID_FaceDict  dict;
+
+
+        if ( parser->num_dict < 0 )
+        {
+          FT_ERROR(( "cid_load_keyword: invalid use of `%s'!\n",
+                     keyword->ident ));
+          error = CID_Err_Syntax_Error;
+          goto Exit;
+        }
+
+        dict = cid->font_dicts + parser->num_dict;
+        switch ( keyword->location )
+        {
+        case T1_FIELD_LOCATION_PRIVATE:
+          object = (FT_Byte*)&dict->private_dict;
+          break;
+
+        default:
+          object = (FT_Byte*)dict;
+        }
+      }
+    }
+
+    dummy_object = object;
+
+    /* now, load the keyword data in the object's field(s) */
+    if ( keyword->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
+         keyword->type == T1_FIELD_TYPE_FIXED_ARRAY   )
+      error = cid_parser_load_field_table( &loader->parser, keyword,
+                                           &dummy_object );
+    else
+      error = cid_parser_load_field( &loader->parser,
+                                     keyword, &dummy_object );
+  Exit:
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  parse_font_matrix( CID_Face     face,
+                     CID_Parser*  parser )
+  {
+    FT_Matrix*    matrix;
+    FT_Vector*    offset;
+    CID_FaceDict  dict;
+    FT_Face       root = (FT_Face)&face->root;
+    FT_Fixed      temp[6];
+    FT_Fixed      temp_scale;
+
+
+    if ( parser->num_dict >= 0 )
+    {
+      dict   = face->cid.font_dicts + parser->num_dict;
+      matrix = &dict->font_matrix;
+      offset = &dict->font_offset;
+
+      (void)cid_parser_to_fixed_array( parser, 6, temp, 3 );
+
+      temp_scale = FT_ABS( temp[3] );
+
+      /* Set units per EM based on FontMatrix values.  We set the value to */
+      /* `1000/temp_scale', because temp_scale was already multiplied by   */
+      /* 1000 (in `t1_tofixed', from psobjs.c).                            */
+      root->units_per_EM = (FT_UShort)( FT_DivFix( 0x10000L,
+                                        FT_DivFix( temp_scale, 1000 ) ) );
+
+      /* we need to scale the values by 1.0/temp[3] */
+      if ( temp_scale != 0x10000L )
+      {
+        temp[0] = FT_DivFix( temp[0], temp_scale );
+        temp[1] = FT_DivFix( temp[1], temp_scale );
+        temp[2] = FT_DivFix( temp[2], temp_scale );
+        temp[4] = FT_DivFix( temp[4], temp_scale );
+        temp[5] = FT_DivFix( temp[5], temp_scale );
+        temp[3] = 0x10000L;
+      }
+
+      matrix->xx = temp[0];
+      matrix->yx = temp[1];
+      matrix->xy = temp[2];
+      matrix->yy = temp[3];
+
+      /* note that the font offsets are expressed in integer font units */
+      offset->x  = temp[4] >> 16;
+      offset->y  = temp[5] >> 16;
+    }
+
+    return CID_Err_Ok;      /* this is a callback function; */
+                            /* we must return an error code */
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  parse_fd_array( CID_Face     face,
+                  CID_Parser*  parser )
+  {
+    CID_FaceInfo  cid    = &face->cid;
+    FT_Memory     memory = face->root.memory;
+    FT_Error      error  = CID_Err_Ok;
+    FT_Long       num_dicts;
+
+
+    num_dicts = cid_parser_to_int( parser );
+
+    if ( !cid->font_dicts )
+    {
+      FT_Int  n;
+
+
+      if ( FT_NEW_ARRAY( cid->font_dicts, num_dicts ) )
+        goto Exit;
+
+      cid->num_dicts = (FT_UInt)num_dicts;
+
+      /* don't forget to set a few defaults */
+      for ( n = 0; n < cid->num_dicts; n++ )
+      {
+        CID_FaceDict  dict = cid->font_dicts + n;
+
+
+        /* default value for lenIV */
+        dict->private_dict.lenIV = 4;
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  static
+  const T1_FieldRec  cid_field_records[] =
+  {
+
+#include "cidtoken.h"
+
+    T1_FIELD_CALLBACK( "FDArray",    parse_fd_array )
+    T1_FIELD_CALLBACK( "FontMatrix", parse_font_matrix )
+
+    { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0 }
+  };
+
+
+  static FT_Error
+  cid_parse_dict( CID_Face     face,
+                  CID_Loader*  loader,
+                  FT_Byte*     base,
+                  FT_Long      size )
+  {
+    CID_Parser*  parser = &loader->parser;
+
+
+    parser->root.cursor = base;
+    parser->root.limit  = base + size;
+    parser->root.error  = CID_Err_Ok;
+
+    {
+      FT_Byte*  cur   = base;
+      FT_Byte*  limit = cur + size;
+
+
+      for (;;)
+      {
+        FT_Byte*  newlimit;
+
+
+        parser->root.cursor = cur;
+        cid_parser_skip_spaces( parser );
+
+        if ( parser->root.cursor >= limit )
+          newlimit = limit - 1 - 17;
+        else
+          newlimit = parser->root.cursor - 17;
+
+        /* look for `%ADOBeginFontDict' */
+        for ( ; cur < newlimit; cur++ )
+        {
+          if ( *cur == '%'                                            &&
+               ft_strncmp( (char*)cur, "%ADOBeginFontDict", 17 ) == 0 )
+          {
+            /* if /FDArray was found, then cid->num_dicts is > 0, and */
+            /* we can start increasing parser->num_dict               */
+            if ( face->cid.num_dicts > 0 )
+              parser->num_dict++;
+          }
+        }
+
+        cur = parser->root.cursor;
+        /* no error can occur in cid_parser_skip_spaces */
+        if ( cur >= limit )
+          break;
+
+        cid_parser_skip_PS_token( parser );
+        if ( parser->root.cursor >= limit || parser->root.error )
+          break;
+
+        /* look for immediates */
+        if ( *cur == '/' && cur + 2 < limit )
+        {
+          FT_PtrDist  len;
+
+
+          cur++;
+          len = parser->root.cursor - cur;
+
+          if ( len > 0 && len < 22 )
+          {
+            /* now compare the immediate name to the keyword table */
+            T1_Field  keyword = (T1_Field)cid_field_records;
+
+
+            for (;;)
+            {
+              FT_Byte*  name;
+
+
+              name = (FT_Byte*)keyword->ident;
+              if ( !name )
+                break;
+
+              if ( cur[0] == name[0]                     &&
+                   len == ft_strlen( (const char*)name ) )
+              {
+                FT_PtrDist  n;
+
+
+                for ( n = 1; n < len; n++ )
+                  if ( cur[n] != name[n] )
+                    break;
+
+                if ( n >= len )
+                {
+                  /* we found it - run the parsing callback */
+                  parser->root.error = cid_load_keyword( face,
+                                                         loader,
+                                                         keyword );
+                  if ( parser->root.error )
+                    return parser->root.error;
+                  break;
+                }
+              }
+              keyword++;
+            }
+          }
+        }
+
+        cur = parser->root.cursor;
+      }
+    }
+    return parser->root.error;
+  }
+
+
+  /* read the subrmap and the subrs of each font dict */
+  static FT_Error
+  cid_read_subrs( CID_Face  face )
+  {
+    CID_FaceInfo   cid    = &face->cid;
+    FT_Memory      memory = face->root.memory;
+    FT_Stream      stream = face->cid_stream;
+    FT_Error       error;
+    FT_Int         n;
+    CID_Subrs      subr;
+    FT_UInt        max_offsets = 0;
+    FT_ULong*      offsets = 0;
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
+
+
+    if ( FT_NEW_ARRAY( face->subrs, cid->num_dicts ) )
+      goto Exit;
+
+    subr = face->subrs;
+    for ( n = 0; n < cid->num_dicts; n++, subr++ )
+    {
+      CID_FaceDict  dict  = cid->font_dicts + n;
+      FT_Int        lenIV = dict->private_dict.lenIV;
+      FT_UInt       count, num_subrs = dict->num_subrs;
+      FT_ULong      data_len;
+      FT_Byte*      p;
+
+
+      /* reallocate offsets array if needed */
+      if ( num_subrs + 1 > max_offsets )
+      {
+        FT_UInt  new_max = FT_PAD_CEIL( num_subrs + 1, 4 );
+
+
+        if ( FT_RENEW_ARRAY( offsets, max_offsets, new_max ) )
+          goto Fail;
+
+        max_offsets = new_max;
+      }
+
+      /* read the subrmap's offsets */
+      if ( FT_STREAM_SEEK( cid->data_offset + dict->subrmap_offset ) ||
+           FT_FRAME_ENTER( ( num_subrs + 1 ) * dict->sd_bytes )      )
+        goto Fail;
+
+      p = (FT_Byte*)stream->cursor;
+      for ( count = 0; count <= num_subrs; count++ )
+        offsets[count] = cid_get_offset( &p, (FT_Byte)dict->sd_bytes );
+
+      FT_FRAME_EXIT();
+
+      /* now, compute the size of subrs charstrings, */
+      /* allocate, and read them                     */
+      data_len = offsets[num_subrs] - offsets[0];
+
+      if ( FT_NEW_ARRAY( subr->code, num_subrs + 1 ) ||
+               FT_ALLOC( subr->code[0], data_len )   )
+        goto Fail;
+
+      if ( FT_STREAM_SEEK( cid->data_offset + offsets[0] ) ||
+           FT_STREAM_READ( subr->code[0], data_len )  )
+        goto Fail;
+
+      /* set up pointers */
+      for ( count = 1; count <= num_subrs; count++ )
+      {
+        FT_ULong  len;
+
+
+        len               = offsets[count] - offsets[count - 1];
+        subr->code[count] = subr->code[count - 1] + len;
+      }
+
+      /* decrypt subroutines, but only if lenIV >= 0 */
+      if ( lenIV >= 0 )
+      {
+        for ( count = 0; count < num_subrs; count++ )
+        {
+          FT_ULong  len;
+
+
+          len = offsets[count + 1] - offsets[count];
+          psaux->t1_decrypt( subr->code[count], len, 4330 );
+        }
+      }
+
+      subr->num_subrs = num_subrs;
+    }
+
+  Exit:
+    FT_FREE( offsets );
+    return error;
+
+  Fail:
+    if ( face->subrs )
+    {
+      for ( n = 0; n < cid->num_dicts; n++ )
+      {
+        if ( face->subrs[n].code )
+          FT_FREE( face->subrs[n].code[0] );
+
+        FT_FREE( face->subrs[n].code );
+      }
+      FT_FREE( face->subrs );
+    }
+    goto Exit;
+  }
+
+
+  static void
+  t1_init_loader( CID_Loader*  loader,
+                  CID_Face     face )
+  {
+    FT_UNUSED( face );
+
+    FT_MEM_ZERO( loader, sizeof ( *loader ) );
+  }
+
+
+  static void
+  t1_done_loader( CID_Loader*  loader )
+  {
+    CID_Parser*  parser = &loader->parser;
+
+
+    /* finalize parser */
+    cid_parser_done( parser );
+  }
+
+
+  static FT_Error
+  cid_hex_to_binary( FT_Byte*  data,
+                     FT_Long   data_len,
+                     FT_ULong  offset,
+                     CID_Face  face )
+  {
+    FT_Stream  stream = face->root.stream;
+    FT_Error   error;
+
+    FT_Byte    buffer[256];
+    FT_Byte   *p, *plimit;
+    FT_Byte   *d, *dlimit;
+    FT_Byte    val;
+
+    FT_Bool    upper_nibble, done;
+
+
+    if ( FT_STREAM_SEEK( offset ) )
+      goto Exit;
+
+    d      = data;
+    dlimit = d + data_len;
+    p      = buffer;
+    plimit = p;
+
+    upper_nibble = 1;
+    done         = 0;
+
+    while ( d < dlimit )
+    {
+      if ( p >= plimit )
+      {
+        FT_ULong  oldpos = FT_STREAM_POS();
+        FT_ULong  size   = stream->size - oldpos;
+
+
+        if ( size == 0 )
+        {
+          error = CID_Err_Syntax_Error;
+          goto Exit;
+        }
+
+        if ( FT_STREAM_READ( buffer, 256 > size ? size : 256 ) )
+          goto Exit;
+        p      = buffer;
+        plimit = p + FT_STREAM_POS() - oldpos;
+      }
+
+      if ( ft_isdigit( *p ) )
+        val = *p - '0';
+      else if ( *p >= 'a' && *p <= 'f' )
+        val = *p - 'a';
+      else if ( *p >= 'A' && *p <= 'F' )
+        val = *p - 'A' + 10;
+      else if ( *p == ' '  ||
+                *p == '\t' ||
+                *p == '\r' ||
+                *p == '\n' ||
+                *p == '\f' ||
+                *p == '\0' )
+      {
+        p++;
+        continue;
+      }
+      else if ( *p == '>' )
+      {
+        val  = 0;
+        done = 1;
+      }
+      else
+      {
+        error = CID_Err_Syntax_Error;
+        goto Exit;
+      }
+
+      if ( upper_nibble )
+        *d = val << 4;
+      else
+      {
+        *d += val;
+        d++;
+      }
+
+      upper_nibble = 1 - upper_nibble;
+
+      if ( done )
+        break;
+
+      p++;
+    }
+
+    error = CID_Err_Ok;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_face_open( CID_Face  face,
+                 FT_Int    face_index )
+  {
+    CID_Loader   loader;
+    CID_Parser*  parser;
+    FT_Memory    memory = face->root.memory;
+    FT_Error     error;
+
+
+    t1_init_loader( &loader, face );
+
+    parser = &loader.parser;
+    error = cid_parser_new( parser, face->root.stream, face->root.memory,
+                            (PSAux_Service)face->psaux );
+    if ( error )
+      goto Exit;
+
+    error = cid_parse_dict( face, &loader,
+                            parser->postscript,
+                            parser->postscript_len );
+    if ( error )
+      goto Exit;
+
+    if ( face_index < 0 )
+      goto Exit;
+
+    if ( FT_NEW( face->cid_stream ) )
+      goto Exit;
+
+    if ( parser->binary_length )
+    {
+      /* we must convert the data section from hexadecimal to binary */
+      if ( FT_ALLOC( face->binary_data, parser->binary_length )         ||
+           cid_hex_to_binary( face->binary_data, parser->binary_length,
+                              parser->data_offset, face )               )
+        goto Exit;
+
+      FT_Stream_OpenMemory( face->cid_stream,
+                            face->binary_data, parser->binary_length );
+      face->cid.data_offset = 0;
+    }
+    else
+    {
+      *face->cid_stream     = *face->root.stream;
+      face->cid.data_offset = loader.parser.data_offset;
+    }
+
+    error = cid_read_subrs( face );
+
+  Exit:
+    t1_done_loader( &loader );
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidload.h b/nx-X11/extras/freetype2/src/cid/cidload.h
new file mode 100644
index 000000000..8c172ffee
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidload.h
@@ -0,0 +1,53 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidload.h                                                              */
+/*                                                                         */
+/*    CID-keyed Type1 font loader (specification).                         */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 __CIDLOAD_H__
+#define __CIDLOAD_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_STREAM_H
+#include "cidparse.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  CID_Loader_
+  {
+    CID_Parser  parser;          /* parser used to read the stream */
+    FT_Int      num_chars;       /* number of characters in encoding */
+
+  } CID_Loader;
+
+
+  FT_LOCAL( FT_Long )
+  cid_get_offset( FT_Byte**  start,
+                  FT_Byte    offsize );
+
+  FT_LOCAL( FT_Error )
+  cid_face_open( CID_Face  face,
+                 FT_Int    face_index );
+
+
+FT_END_HEADER
+
+#endif /* __CIDLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidobjs.c b/nx-X11/extras/freetype2/src/cid/cidobjs.c
new file mode 100644
index 000000000..691ec1749
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidobjs.c
@@ -0,0 +1,501 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidobjs.c                                                              */
+/*                                                                         */
+/*    CID objects manager (body).                                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 "cidgload.h"
+#include "cidload.h"
+
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+#include "ciderrs.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_cidobjs
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                            SLOT  FUNCTIONS                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( void )
+  cid_slot_done( FT_GlyphSlot  slot )
+  {
+    slot->internal->glyph_hints = 0;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_slot_init( FT_GlyphSlot  slot )
+  {
+    CID_Face          face;
+    PSHinter_Service  pshinter;
+
+
+    face     = (CID_Face)slot->face;
+    pshinter = (PSHinter_Service)face->pshinter;
+
+    if ( pshinter )
+    {
+      FT_Module  module;
+
+
+      module = FT_Get_Module( slot->face->driver->root.library,
+                              "pshinter" );
+      if ( module )
+      {
+        T1_Hints_Funcs  funcs;
+
+
+        funcs = pshinter->get_t1_funcs( module );
+        slot->internal->glyph_hints = (void*)funcs;
+      }
+    }
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                           SIZE  FUNCTIONS                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static PSH_Globals_Funcs
+  cid_size_get_globals_funcs( CID_Size  size )
+  {
+    CID_Face          face     = (CID_Face)size->root.face;
+    PSHinter_Service  pshinter = (PSHinter_Service)face->pshinter;
+    FT_Module         module;
+
+
+    module = FT_Get_Module( size->root.face->driver->root.library,
+                            "pshinter" );
+    return ( module && pshinter && pshinter->get_globals_funcs )
+           ? pshinter->get_globals_funcs( module )
+           : 0;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  cid_size_done( FT_Size  cidsize )         /* CID_Size */
+  {
+    CID_Size  size = (CID_Size)cidsize;
+
+
+    if ( cidsize->internal )
+    {
+      PSH_Globals_Funcs  funcs;
+
+
+      funcs = cid_size_get_globals_funcs( size );
+      if ( funcs )
+        funcs->destroy( (PSH_Globals)cidsize->internal );
+
+      cidsize->internal = 0;
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_size_init( FT_Size  cidsize )     /* CID_Size */
+  {
+    CID_Size           size  = (CID_Size)cidsize;
+    FT_Error           error = 0;
+    PSH_Globals_Funcs  funcs = cid_size_get_globals_funcs( size );
+
+
+    if ( funcs )
+    {
+      PSH_Globals   globals;
+      CID_Face      face = (CID_Face)cidsize->face;
+      CID_FaceDict  dict = face->cid.font_dicts + face->root.face_index;
+      PS_Private    priv = &dict->private_dict;
+
+
+      error = funcs->create( cidsize->face->memory, priv, &globals );
+      if ( !error )
+        cidsize->internal = (FT_Size_Internal)(void*)globals;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_size_reset( FT_Size  cidsize,             /* CID_Size */
+                  FT_UInt  char_width,
+                  FT_UInt  char_height )
+  {
+    CID_Size           size  = (CID_Size)cidsize;
+    PSH_Globals_Funcs  funcs = cid_size_get_globals_funcs( size );
+    FT_Error           error = 0;
+
+    FT_UNUSED( char_width );
+    FT_UNUSED( char_height );
+
+
+    if ( funcs )
+      error = funcs->set_scale( (PSH_Globals)cidsize->internal,
+                                 cidsize->metrics.x_scale,
+                                 cidsize->metrics.y_scale,
+                                 0, 0 );
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_point_size_reset( FT_Size     size,
+                        FT_F26Dot6  char_width,
+                        FT_F26Dot6  char_height,
+                        FT_UInt     horz_resolution,
+                        FT_UInt     vert_resolution )
+  {
+    FT_UNUSED( char_width );
+    FT_UNUSED( char_height );
+    FT_UNUSED( horz_resolution );
+    FT_UNUSED( vert_resolution );
+
+    return cid_size_reset( size, 0, 0 );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                           FACE  FUNCTIONS                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cid_face_done                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes a given face object.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A pointer to the face object to destroy.                   */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  cid_face_done( FT_Face  cidface )         /* CID_Face */
+  {
+    CID_Face   face = (CID_Face)cidface;
+    FT_Memory  memory;
+
+
+    if ( face )
+    {
+      CID_FaceInfo  cid  = &face->cid;
+      PS_FontInfo   info = &cid->font_info;
+
+
+      memory = cidface->memory;
+
+      /* release subrs */
+      if ( face->subrs )
+      {
+        FT_Int  n;
+
+
+        for ( n = 0; n < cid->num_dicts; n++ )
+        {
+          CID_Subrs  subr = face->subrs + n;
+
+
+          if ( subr->code )
+          {
+            FT_FREE( subr->code[0] );
+            FT_FREE( subr->code );
+          }
+        }
+
+        FT_FREE( face->subrs );
+      }
+
+      /* release FontInfo strings */
+      FT_FREE( info->version );
+      FT_FREE( info->notice );
+      FT_FREE( info->full_name );
+      FT_FREE( info->family_name );
+      FT_FREE( info->weight );
+
+      /* release font dictionaries */
+      FT_FREE( cid->font_dicts );
+      cid->num_dicts = 0;
+
+      /* release other strings */
+      FT_FREE( cid->cid_font_name );
+      FT_FREE( cid->registry );
+      FT_FREE( cid->ordering );
+
+      cidface->family_name = 0;
+      cidface->style_name  = 0;
+
+      FT_FREE( face->binary_data );
+      FT_FREE( face->cid_stream );
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cid_face_init                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given CID face object.                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream     :: The source font stream.                              */
+  /*                                                                       */
+  /*    face_index :: The index of the font face in the resource.          */
+  /*                                                                       */
+  /*    num_params :: Number of additional generic parameters.  Ignored.   */
+  /*                                                                       */
+  /*    params     :: Additional generic parameters.  Ignored.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: The newly built face object.                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  cid_face_init( FT_Stream      stream,
+                 FT_Face        cidface,        /* CID_Face */
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    CID_Face            face = (CID_Face)cidface;
+    FT_Error            error;
+    FT_Service_PsCMaps  psnames;
+    PSAux_Service       psaux;
+    PSHinter_Service    pshinter;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( stream );
+
+
+    cidface->num_faces = 1;
+
+    FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
+
+    psaux = (PSAux_Service)face->psaux;
+    if ( !psaux )
+    {
+      psaux = (PSAux_Service)FT_Get_Module_Interface(
+                FT_FACE_LIBRARY( face ), "psaux" );
+
+      face->psaux = psaux;
+    }
+
+    pshinter = (PSHinter_Service)face->pshinter;
+    if ( !pshinter )
+    {
+      pshinter = (PSHinter_Service)FT_Get_Module_Interface(
+                   FT_FACE_LIBRARY( face ), "pshinter" );
+
+      face->pshinter = pshinter;
+    }
+
+    /* open the tokenizer; this will also check the font format */
+    if ( FT_STREAM_SEEK( 0 ) )
+      goto Exit;
+
+    error = cid_face_open( face, face_index );
+    if ( error )
+      goto Exit;
+
+    /* if we just wanted to check the format, leave successfully now */
+    if ( face_index < 0 )
+      goto Exit;
+
+    /* check the face index */
+    if ( face_index != 0 )
+    {
+      FT_ERROR(( "cid_face_init: invalid face index\n" ));
+      error = CID_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* now load the font program into the face object */
+
+    /* initialize the face object fields */
+
+    /* set up root face fields */
+    {
+      CID_FaceInfo  cid  = &face->cid;
+      PS_FontInfo   info = &cid->font_info;
+
+
+      cidface->num_glyphs   = cid->cid_count;
+      cidface->num_charmaps = 0;
+
+      cidface->face_index = face_index;
+      cidface->face_flags = FT_FACE_FLAG_SCALABLE;
+
+      cidface->face_flags |= FT_FACE_FLAG_HORIZONTAL;
+
+      if ( info->is_fixed_pitch )
+        cidface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      /* XXX: TODO: add kerning with .afm support */
+
+      /* get style name -- be careful, some broken fonts only */
+      /* have a /FontName dictionary entry!                   */
+      cidface->family_name = info->family_name;
+      /* assume "Regular" style if we don't know better */
+      cidface->style_name = (char *)"Regular";
+      if ( cidface->family_name )
+      {
+        char*  full   = info->full_name;
+        char*  family = cidface->family_name;
+
+
+        if ( full )
+        {
+          while ( *full )
+          {
+            if ( *full == *family )
+            {
+              family++;
+              full++;
+            }
+            else
+            {
+              if ( *full == ' ' || *full == '-' )
+                full++;
+              else if ( *family == ' ' || *family == '-' )
+                family++;
+              else
+              {
+                if ( !*family )
+                  cidface->style_name = full;
+                break;
+              }
+            }
+          }
+        }
+      }
+      else
+      {
+        /* do we have a `/FontName'? */
+        if ( cid->cid_font_name )
+          cidface->family_name = cid->cid_font_name;
+      }
+
+      /* compute style flags */
+      cidface->style_flags = 0;
+      if ( info->italic_angle )
+        cidface->style_flags |= FT_STYLE_FLAG_ITALIC;
+      if ( info->weight )
+      {
+        if ( !ft_strcmp( info->weight, "Bold"  ) ||
+             !ft_strcmp( info->weight, "Black" ) )
+          cidface->style_flags |= FT_STYLE_FLAG_BOLD;
+      }
+
+      /* no embedded bitmap support */
+      cidface->num_fixed_sizes = 0;
+      cidface->available_sizes = 0;
+
+      cidface->bbox.xMin =   cid->font_bbox.xMin             >> 16;
+      cidface->bbox.yMin =   cid->font_bbox.yMin             >> 16;
+      cidface->bbox.xMax = ( cid->font_bbox.xMax + 0xFFFFU ) >> 16;
+      cidface->bbox.yMax = ( cid->font_bbox.yMax + 0xFFFFU ) >> 16;
+
+      if ( !cidface->units_per_EM )
+        cidface->units_per_EM = 1000;
+
+      cidface->ascender  = (FT_Short)( cidface->bbox.yMax );
+      cidface->descender = (FT_Short)( cidface->bbox.yMin );
+      cidface->height    = (FT_Short)(
+        ( ( cidface->ascender - cidface->descender ) * 12 ) / 10 );
+
+      cidface->underline_position  = (FT_Short)info->underline_position;
+      cidface->underline_thickness = (FT_Short)info->underline_thickness;
+
+      cidface->internal->max_points   = 0;
+      cidface->internal->max_contours = 0;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cid_driver_init                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given CID driver object.                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    driver :: A handle to the target driver object.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  cid_driver_init( FT_Module  driver )
+  {
+    FT_UNUSED( driver );
+
+    return CID_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    cid_driver_done                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes a given CID driver.                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    driver :: A handle to the target CID driver.                       */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  cid_driver_done( FT_Module  driver )
+  {
+    FT_UNUSED( driver );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidobjs.h b/nx-X11/extras/freetype2/src/cid/cidobjs.h
new file mode 100644
index 000000000..9d230baf8
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidobjs.h
@@ -0,0 +1,163 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidobjs.h                                                              */
+/*                                                                         */
+/*    CID objects manager (specification).                                 */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2004 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 __CIDOBJS_H__
+#define __CIDOBJS_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_CONFIG_CONFIG_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* The following structures must be defined by the hinter */
+  typedef struct CID_Size_Hints_   CID_Size_Hints;
+  typedef struct CID_Glyph_Hints_  CID_Glyph_Hints;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    CID_Driver                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a Type 1 driver object.                                */
+  /*                                                                       */
+  typedef struct CID_DriverRec_*  CID_Driver;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    CID_Size                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a Type 1 size object.                                  */
+  /*                                                                       */
+  typedef struct CID_SizeRec_*  CID_Size;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    CID_GlyphSlot                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a Type 1 glyph slot object.                            */
+  /*                                                                       */
+  typedef struct CID_GlyphSlotRec_*  CID_GlyphSlot;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    CID_CharMap                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a Type 1 character mapping object.                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The Type 1 format doesn't use a charmap but an encoding table.     */
+  /*    The driver is responsible for making up charmap objects            */
+  /*    corresponding to these tables.                                     */
+  /*                                                                       */
+  typedef struct CID_CharMapRec_*  CID_CharMap;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* HERE BEGINS THE TYPE 1 SPECIFIC STUFF                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  typedef struct  CID_SizeRec_
+  {
+    FT_SizeRec  root;
+    FT_Bool     valid;
+
+  } CID_SizeRec;
+
+
+  typedef struct  CID_GlyphSlotRec_
+  {
+    FT_GlyphSlotRec  root;
+
+    FT_Bool          hint;
+    FT_Bool          scaled;
+
+    FT_Fixed         x_scale;
+    FT_Fixed         y_scale;
+
+  } CID_GlyphSlotRec;
+
+
+  FT_LOCAL( void )
+  cid_slot_done( FT_GlyphSlot  slot );
+
+  FT_LOCAL( FT_Error )
+  cid_slot_init( FT_GlyphSlot  slot );
+
+
+  FT_LOCAL( void )
+  cid_size_done( FT_Size  size );       /* CID_Size */
+
+  FT_LOCAL( FT_Error )
+  cid_size_init( FT_Size  size );       /* CID_Size */
+
+  FT_LOCAL( FT_Error )
+  cid_size_reset( FT_Size  size,        /* CID_Size */
+                  FT_UInt  char_width,
+                  FT_UInt  char_height );
+
+  FT_LOCAL( FT_Error )
+  cid_point_size_reset( FT_Size     size,
+                        FT_F26Dot6  char_width,
+                        FT_F26Dot6  char_height,
+                        FT_UInt     horz_resolution,
+                        FT_UInt     vert_resolution );
+
+
+  FT_LOCAL( FT_Error )
+  cid_face_init( FT_Stream      stream,
+                 FT_Face        face,           /* CID_Face */
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params );
+
+  FT_LOCAL( void )
+  cid_face_done( FT_Face  face );               /* CID_Face */
+
+
+  FT_LOCAL( FT_Error )
+  cid_driver_init( FT_Module  driver );
+
+  FT_LOCAL( void )
+  cid_driver_done( FT_Module  driver );
+
+
+FT_END_HEADER
+
+#endif /* __CIDOBJS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidparse.c b/nx-X11/extras/freetype2/src/cid/cidparse.c
new file mode 100644
index 000000000..3f18749f6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidparse.c
@@ -0,0 +1,198 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidparse.c                                                             */
+/*                                                                         */
+/*    CID-keyed Type1 parser (body).                                       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_CALC_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+
+#include "cidparse.h"
+
+#include "ciderrs.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_cidparse
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    INPUT STREAM PARSER                        *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  cid_parser_new( CID_Parser*    parser,
+                  FT_Stream      stream,
+                  FT_Memory      memory,
+                  PSAux_Service  psaux )
+  {
+    FT_Error  error;
+    FT_ULong  base_offset, offset, ps_len;
+    FT_Byte   buffer[256 + 10];
+    FT_Int    buff_len;
+    FT_Byte   *cur, *limit;
+    FT_Byte   *arg1, *arg2;
+
+
+    FT_MEM_ZERO( parser, sizeof ( *parser ) );
+    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );
+
+    parser->stream = stream;
+
+    base_offset = FT_STREAM_POS();
+
+    /* first of all, check the font format in the header */
+    if ( FT_FRAME_ENTER( 31 ) )
+      goto Exit;
+
+    if ( ft_strncmp( (char *)stream->cursor,
+                     "%!PS-Adobe-3.0 Resource-CIDFont", 31 ) )
+    {
+      FT_TRACE2(( "[not a valid CID-keyed font]\n" ));
+      error = CID_Err_Unknown_File_Format;
+    }
+
+    FT_FRAME_EXIT();
+    if ( error )
+      goto Exit;
+
+  Again:
+    /* now, read the rest of the file until we find a `StartData' */
+    buff_len = 256;
+    for (;;)
+    {
+      FT_Byte*  p;
+      FT_ULong  top_position;
+
+
+      /* fill input buffer */
+      limit     = buffer + 256;
+      buff_len -= 256;
+      if ( buff_len > 0 )
+        FT_MEM_MOVE( buffer, limit, buff_len );
+
+      p = buffer + buff_len;
+
+      if ( FT_STREAM_READ( p, 256 + 10 - buff_len ) )
+        goto Exit;
+
+      top_position = FT_STREAM_POS() - buff_len;
+      buff_len     = 256 + 10;
+
+      /* look for `StartData' */
+      for ( p = buffer; p < limit; p++ )
+      {
+        if ( p[0] == 'S' && ft_strncmp( (char*)p, "StartData", 9 ) == 0 )
+        {
+          /* save offset of binary data after `StartData' */
+          offset = (FT_ULong)( top_position - ( limit - p ) + 10 );
+          goto Found;
+        }
+      }
+    }
+
+  Found:
+    /* we have found the start of the binary data.  We will now     */
+    /* rewind and extract the frame corresponding to the PostScript */
+    /* section                                                      */
+
+    ps_len = offset - base_offset;
+    if ( FT_STREAM_SEEK( base_offset )                  ||
+         FT_FRAME_EXTRACT( ps_len, parser->postscript ) )
+      goto Exit;
+
+    parser->data_offset    = offset;
+    parser->postscript_len = ps_len;
+    parser->root.base      = parser->postscript;
+    parser->root.cursor    = parser->postscript;
+    parser->root.limit     = parser->root.cursor + ps_len;
+    parser->num_dict       = -1;
+
+    /* Finally, we check whether `StartData' was real -- it could be  */
+    /* in a comment or string.  We also get its arguments to find out */
+    /* whether the data is represented in binary or hex format.       */
+
+    arg1 = parser->root.cursor;
+    cid_parser_skip_PS_token( parser );
+    cid_parser_skip_spaces  ( parser );
+    arg2 = parser->root.cursor;
+    cid_parser_skip_PS_token( parser );
+    cid_parser_skip_spaces  ( parser );
+
+    limit = parser->root.limit;
+    cur   = parser->root.cursor;
+
+    while ( cur < limit )
+    {
+      if ( *cur == 'S' && ft_strncmp( (char*)cur, "StartData", 9 ) == 0 )
+      {
+        if ( ft_strncmp( (char*)arg1, "(Hex)", 5 ) == 0 )
+          parser->binary_length = ft_atol( (const char *)arg2 );
+
+        limit = parser->root.limit;
+        cur   = parser->root.cursor;
+        goto Exit;
+      }
+
+      cid_parser_skip_PS_token( parser );
+      cid_parser_skip_spaces  ( parser );
+      arg1 = arg2;
+      arg2 = cur;
+      cur  = parser->root.cursor;
+    }
+
+    /* we haven't found the correct `StartData'; go back and continue */
+    /* searching                                                      */
+    FT_FRAME_RELEASE( parser->postscript );
+    if ( !FT_STREAM_SEEK( offset ) )
+      goto Again;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  cid_parser_done( CID_Parser*  parser )
+  {
+    /* always free the private dictionary */
+    if ( parser->postscript )
+    {
+      FT_Stream  stream = parser->stream;
+
+
+      FT_FRAME_RELEASE( parser->postscript );
+    }
+    parser->root.funcs.done( &parser->root );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidparse.h b/nx-X11/extras/freetype2/src/cid/cidparse.h
new file mode 100644
index 000000000..ca37deab9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidparse.h
@@ -0,0 +1,123 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidparse.h                                                             */
+/*                                                                         */
+/*    CID-keyed Type1 parser (specification).                              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 __CIDPARSE_H__
+#define __CIDPARSE_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_Parser                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A CID_Parser is an object used to parse a Type 1 fonts very        */
+  /*    quickly.                                                           */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root           :: The root PS_ParserRec fields.                    */
+  /*                                                                       */
+  /*    stream         :: The current input stream.                        */
+  /*                                                                       */
+  /*    postscript     :: A pointer to the data to be parsed.              */
+  /*                                                                       */
+  /*    postscript_len :: The length of the data to be parsed.             */
+  /*                                                                       */
+  /*    data_offset    :: The start position of the binary data (i.e., the */
+  /*                      end of the data to be parsed.                    */
+  /*                                                                       */
+  /*    binary_length  :: The length of the data after the `StartData'     */
+  /*                      command if the data format is hexadecimal.       */
+  /*                                                                       */
+  /*    cid            :: A structure which holds the information about    */
+  /*                      the current font.                                */
+  /*                                                                       */
+  /*    num_dict       :: The number of font dictionaries.                 */
+  /*                                                                       */
+  typedef struct  CID_Parser_
+  {
+    PS_ParserRec  root;
+    FT_Stream     stream;
+
+    FT_Byte*      postscript;
+    FT_Long       postscript_len;
+
+    FT_ULong      data_offset;
+
+    FT_Long       binary_length;
+
+    CID_FaceInfo  cid;
+    FT_Int        num_dict;
+
+  } CID_Parser;
+
+
+  FT_LOCAL( FT_Error )
+  cid_parser_new( CID_Parser*    parser,
+                  FT_Stream      stream,
+                  FT_Memory      memory,
+                  PSAux_Service  psaux );
+
+  FT_LOCAL( void )
+  cid_parser_done( CID_Parser*  parser );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                            PARSING ROUTINES                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+#define cid_parser_skip_spaces( p ) \
+          (p)->root.funcs.skip_spaces( &(p)->root )
+#define cid_parser_skip_PS_token( p ) \
+          (p)->root.funcs.skip_PS_token( &(p)->root )
+
+#define cid_parser_to_int( p )        (p)->root.funcs.to_int( &(p)->root )
+#define cid_parser_to_fixed( p, t )   (p)->root.funcs.to_fixed( &(p)->root, t )
+
+#define cid_parser_to_coord_array( p, m, c )                          \
+          (p)->root.funcs.to_coord_array( &(p)->root, m, c )
+#define cid_parser_to_fixed_array( p, m, f, t )                          \
+          (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
+#define cid_parser_to_token( p, t )                         \
+          (p)->root.funcs.to_token( &(p)->root, t )
+#define cid_parser_to_token_array( p, t, m, c )                          \
+          (p)->root.funcs.to_token_array( &(p)->root, t, m, c )
+
+#define cid_parser_load_field( p, f, o )                              \
+          (p)->root.funcs.load_field( &(p)->root, f, o, 0, 0 )
+#define cid_parser_load_field_table( p, f, o )                              \
+          (p)->root.funcs.load_field_table( &(p)->root, f, o, 0, 0 )
+
+
+FT_END_HEADER
+
+#endif /* __CIDPARSE_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidriver.c b/nx-X11/extras/freetype2/src/cid/cidriver.c
new file mode 100644
index 000000000..7d885a818
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidriver.c
@@ -0,0 +1,157 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidriver.c                                                             */
+/*                                                                         */
+/*    CID driver interface (body).                                         */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 "cidriver.h"
+#include "cidgload.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+
+#include "ciderrs.h"
+
+#include FT_SERVICE_POSTSCRIPT_NAME_H
+#include FT_SERVICE_XFREE86_NAME_H
+#include FT_SERVICE_POSTSCRIPT_INFO_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_ciddriver
+
+
+ /*
+  *  POSTSCRIPT NAME SERVICE
+  *
+  */
+
+  static const char*
+  cid_get_postscript_name( CID_Face  face )
+  {
+    const char*  result = face->cid.cid_font_name;
+
+
+    if ( result && result[0] == '/' )
+      result++;
+
+    return result;
+  }
+
+
+  static const FT_Service_PsFontNameRec  cid_service_ps_name =
+  {
+    (FT_PsName_GetFunc) cid_get_postscript_name
+  };
+
+
+ /*
+  *  POSTSCRIPT INFO SERVICE
+  *
+  */
+
+  static FT_Error
+  cid_ps_get_font_info( FT_Face          face,
+                        PS_FontInfoRec*  afont_info )
+  {
+    *afont_info = ((CID_Face)face)->cid.font_info;
+    return 0;
+  }
+
+
+  static const FT_Service_PsInfoRec  cid_service_ps_info =
+  {
+    (PS_GetFontInfoFunc)  cid_ps_get_font_info,
+    (PS_HasGlyphNamesFunc)NULL          /* unsupported with CID fonts */
+  };
+
+
+ /*
+  *  SERVICE LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  cid_services[] =
+  {
+    { FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &cid_service_ps_name },
+    { FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_CID },
+    { FT_SERVICE_ID_POSTSCRIPT_INFO,      &cid_service_ps_info },
+    { NULL, NULL }
+  };
+
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  cid_get_interface( FT_Module    module,
+                     const char*  cid_interface )
+  {
+    FT_UNUSED( module );
+
+    return ft_service_list_lookup( cid_services, cid_interface );
+  }
+
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  t1cid_driver_class =
+  {
+    /* first of all, the FT_Module_Class fields */
+    {
+      FT_MODULE_FONT_DRIVER       |
+      FT_MODULE_DRIVER_SCALABLE   |
+      FT_MODULE_DRIVER_HAS_HINTER,
+
+      sizeof( FT_DriverRec ),
+      "t1cid",   /* module name           */
+      0x10000L,  /* version 1.0 of driver */
+      0x20000L,  /* requires FreeType 2.0 */
+
+      0,
+
+      cid_driver_init,
+      cid_driver_done,
+      cid_get_interface
+    },
+
+    /* then the other font drivers fields */
+    sizeof( CID_FaceRec ),
+    sizeof( CID_SizeRec ),
+    sizeof( CID_GlyphSlotRec ),
+
+    cid_face_init,
+    cid_face_done,
+
+    cid_size_init,
+    cid_size_done,
+    cid_slot_init,
+    cid_slot_done,
+
+    cid_point_size_reset,
+    cid_size_reset,
+
+    cid_slot_load_glyph,
+
+    0,                      /* FT_Face_GetKerningFunc  */
+    0,                      /* FT_Face_AttachFunc      */
+
+    0                       /* FT_Face_GetAdvancesFunc */
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidriver.h b/nx-X11/extras/freetype2/src/cid/cidriver.h
new file mode 100644
index 000000000..d5a80f6f9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidriver.h
@@ -0,0 +1,39 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidriver.h                                                             */
+/*                                                                         */
+/*    High-level CID driver interface (specification).                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __CIDRIVER_H__
+#define __CIDRIVER_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_CALLBACK_TABLE
+  const FT_Driver_ClassRec  t1cid_driver_class;
+
+
+FT_END_HEADER
+
+#endif /* __CIDRIVER_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/cidtoken.h b/nx-X11/extras/freetype2/src/cid/cidtoken.h
new file mode 100644
index 000000000..2070aa91b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/cidtoken.h
@@ -0,0 +1,103 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cidtoken.h                                                             */
+/*                                                                         */
+/*    CID token definitions (specification only).                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  CID_FaceInfoRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_CID_INFO
+
+  T1_FIELD_KEY   ( "CIDFontName", cid_font_name )
+  T1_FIELD_NUM   ( "CIDFontVersion", cid_version )
+  T1_FIELD_NUM   ( "CIDFontType", cid_font_type )
+  T1_FIELD_STRING( "Registry", registry )
+  T1_FIELD_STRING( "Ordering", ordering )
+  T1_FIELD_NUM   ( "Supplement", supplement )
+  T1_FIELD_NUM   ( "UIDBase", uid_base )
+  T1_FIELD_NUM   ( "CIDMapOffset", cidmap_offset )
+  T1_FIELD_NUM   ( "FDBytes", fd_bytes )
+  T1_FIELD_NUM   ( "GDBytes", gd_bytes )
+  T1_FIELD_NUM   ( "CIDCount", cid_count )
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PS_FontInfoRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_FONT_INFO
+
+  T1_FIELD_STRING( "version", version )
+  T1_FIELD_STRING( "Notice", notice )
+  T1_FIELD_STRING( "FullName", full_name )
+  T1_FIELD_STRING( "FamilyName", family_name )
+  T1_FIELD_STRING( "Weight", weight )
+  T1_FIELD_NUM   ( "ItalicAngle", italic_angle )
+  T1_FIELD_BOOL  ( "isFixedPitch", is_fixed_pitch )
+  T1_FIELD_NUM   ( "UnderlinePosition", underline_position )
+  T1_FIELD_NUM   ( "UnderlineThickness", underline_thickness )
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  CID_FaceDictRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_FONT_DICT
+
+  T1_FIELD_NUM  ( "PaintType", paint_type )
+  T1_FIELD_NUM  ( "FontType", font_type )
+  T1_FIELD_NUM  ( "SubrMapOffset", subrmap_offset )
+  T1_FIELD_NUM  ( "SDBytes", sd_bytes )
+  T1_FIELD_NUM  ( "SubrCount", num_subrs )
+  T1_FIELD_NUM  ( "lenBuildCharArray", len_buildchar )
+  T1_FIELD_FIXED( "ForceBoldThreshold", forcebold_threshold )
+  T1_FIELD_FIXED( "ExpansionFactor", expansion_factor )
+  T1_FIELD_FIXED( "StrokeWidth", stroke_width )
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PS_PrivateRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_PRIVATE
+
+  T1_FIELD_NUM       ( "UniqueID", unique_id )
+  T1_FIELD_NUM       ( "lenIV", lenIV )
+  T1_FIELD_NUM       ( "LanguageGroup", language_group )
+  T1_FIELD_NUM       ( "password", password )
+
+  T1_FIELD_FIXED_1000( "BlueScale", blue_scale )
+  T1_FIELD_NUM       ( "BlueShift", blue_shift )
+  T1_FIELD_NUM       ( "BlueFuzz",  blue_fuzz )
+
+  T1_FIELD_NUM_TABLE ( "BlueValues", blue_values, 14 )
+  T1_FIELD_NUM_TABLE ( "OtherBlues", other_blues, 10 )
+  T1_FIELD_NUM_TABLE ( "FamilyBlues", family_blues, 14 )
+  T1_FIELD_NUM_TABLE ( "FamilyOtherBlues", family_other_blues, 10 )
+
+  T1_FIELD_NUM_TABLE2( "StdHW", standard_width,  1 )
+  T1_FIELD_NUM_TABLE2( "StdVW", standard_height, 1 )
+  T1_FIELD_NUM_TABLE2( "MinFeature", min_feature, 2 )
+
+  T1_FIELD_NUM_TABLE ( "StemSnapH", snap_widths, 12 )
+  T1_FIELD_NUM_TABLE ( "StemSnapV", snap_heights, 12 )
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  FT_BBox
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_BBOX
+
+  T1_FIELD_BBOX( "FontBBox", xMin )
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/cid/descrip.mms b/nx-X11/extras/freetype2/src/cid/descrip.mms
new file mode 100644
index 000000000..592fd587a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 CID driver compilation rules for VMS
+#
+
+
+# Copyright 2001 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.cid])
+
+OBJS=type1cid.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cid/module.mk b/nx-X11/extras/freetype2/src/cid/module.mk
new file mode 100644
index 000000000..f59d8a951
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/module.mk
@@ -0,0 +1,21 @@
+#
+# FreeType 2 CID module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_type1cid_driver
+
+add_type1cid_driver:
+	$(OPEN_DRIVER)t1cid_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)cid       $(ECHO_DRIVER_DESC)Postscript CID-keyed fonts, no known extension$(ECHO_DRIVER_DONE)
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cid/rules.mk b/nx-X11/extras/freetype2/src/cid/rules.mk
new file mode 100644
index 000000000..f36274461
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/rules.mk
@@ -0,0 +1,70 @@
+#
+# FreeType 2 CID driver configuration rules
+#
+
+
+# Copyright 1996-2000, 2001, 2003 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.
+
+
+# CID driver directory
+#
+CID_DIR := $(SRC_DIR)/cid
+
+
+CID_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(CID_DIR))
+
+
+# CID driver sources (i.e., C files)
+#
+CID_DRV_SRC := $(CID_DIR)/cidparse.c \
+               $(CID_DIR)/cidload.c  \
+               $(CID_DIR)/cidriver.c \
+               $(CID_DIR)/cidgload.c \
+               $(CID_DIR)/cidobjs.c
+
+# CID driver headers
+#
+CID_DRV_H := $(CID_DRV_SRC:%.c=%.h) \
+             $(CID_DIR)/cidtoken.h  \
+             $(CID_DIR)/ciderrs.h
+
+
+# CID driver object(s)
+#
+#   CID_DRV_OBJ_M is used during `multi' builds
+#   CID_DRV_OBJ_S is used during `single' builds
+#
+CID_DRV_OBJ_M := $(CID_DRV_SRC:$(CID_DIR)/%.c=$(OBJ_DIR)/%.$O)
+CID_DRV_OBJ_S := $(OBJ_DIR)/type1cid.$O
+
+# CID driver source file for single build
+#
+CID_DRV_SRC_S := $(CID_DIR)/type1cid.c
+
+
+# CID driver - single object
+#
+$(CID_DRV_OBJ_S): $(CID_DRV_SRC_S) $(CID_DRV_SRC) $(FREETYPE_H) $(CID_DRV_H)
+	$(CID_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(CID_DRV_SRC_S))
+
+
+# CID driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(CID_DIR)/%.c $(FREETYPE_H) $(CID_DRV_H)
+	$(CID_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(CID_DRV_OBJ_S)
+DRV_OBJS_M += $(CID_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/cid/type1cid.c b/nx-X11/extras/freetype2/src/cid/type1cid.c
new file mode 100644
index 000000000..0b866e97c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/cid/type1cid.c
@@ -0,0 +1,29 @@
+/***************************************************************************/
+/*                                                                         */
+/*  type1cid.c                                                             */
+/*                                                                         */
+/*    FreeType OpenType driver component (body only).                      */
+/*                                                                         */
+/*  Copyright 1996-2001 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 "cidparse.c"
+#include "cidload.c"
+#include "cidobjs.c"
+#include "cidriver.c"
+#include "cidgload.c"
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/gzip/Jamfile b/nx-X11/extras/freetype2/src/gzip/Jamfile
new file mode 100644
index 000000000..e461cf174
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/Jamfile
@@ -0,0 +1,8 @@
+# FreeType 2 src/gzip Jamfile (c) 2001 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) gzip ;
+
+Library  $(FT2_LIB) : ftgzip.c ;
+
+# end of src/pcf Jamfile
diff --git a/nx-X11/extras/freetype2/src/gzip/adler32.c b/nx-X11/extras/freetype2/src/gzip/adler32.c
new file mode 100644
index 000000000..11a25bee6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/adler32.c
@@ -0,0 +1,48 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id: adler32.c,v 1.1.1.3 2004/03/14 08:28:54 eich Exp $ */
+
+#include "zlib.h"
+
+#define BASE 65521L /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {s1 += buf[i]; s2 += s1;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* ========================================================================= */
+ZEXPORT(uLong) adler32( /* adler, buf, len) */
+    uLong adler,
+    const Bytef *buf,
+    uInt len )
+{
+    unsigned long s1 = adler & 0xffff;
+    unsigned long s2 = (adler >> 16) & 0xffff;
+    int k;
+
+    if (buf == Z_NULL) return 1L;
+
+    while (len > 0) {
+        k = len < NMAX ? len : NMAX;
+        len -= k;
+        while (k >= 16) {
+            DO16(buf);
+	    buf += 16;
+            k -= 16;
+        }
+        if (k != 0) do {
+            s1 += *buf++;
+	    s2 += s1;
+        } while (--k);
+        s1 %= BASE;
+        s2 %= BASE;
+    }
+    return (s2 << 16) | s1;
+}
diff --git a/nx-X11/extras/freetype2/src/gzip/descrip.mms b/nx-X11/extras/freetype2/src/gzip/descrip.mms
new file mode 100644
index 000000000..68d7a870d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 GZip support compilation rules for VMS
+#
+
+
+# Copyright 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.gzip])
+
+OBJS=ftgzip.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/gzip/ftgzip.c b/nx-X11/extras/freetype2/src/gzip/ftgzip.c
new file mode 100644
index 000000000..a78c19524
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/ftgzip.c
@@ -0,0 +1,605 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgzip.c                                                               */
+/*                                                                         */
+/*    FreeType support for .gz compressed files.                           */
+/*                                                                         */
+/*  This optional component relies on zlib.  It should mainly be used to   */
+/*  parse compressed PCF fonts, as found with many X11 server              */
+/*  distributions.                                                         */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 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_MEMORY_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_DEBUG_H
+#include <string.h>
+
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  Gzip_Err_
+#define FT_ERR_BASE    FT_Mod_Err_Gzip
+
+#include FT_ERRORS_H
+
+
+#ifdef FT_CONFIG_OPTION_USE_ZLIB
+
+#ifdef FT_CONFIG_OPTION_SYSTEM_ZLIB
+
+#include <zlib.h>
+
+#else /* !FT_CONFIG_OPTION_SYSTEM_ZLIB */
+
+ /* In this case, we include our own modified sources of the ZLib    */
+ /* within the "ftgzip" component.  The modifications were necessary */
+ /* to #include all files without conflicts, as well as preventing   */
+ /* the definition of "extern" functions that may cause linking      */
+ /* conflicts when a program is linked with both FreeType and the    */
+ /* original ZLib.                                                   */
+
+#define NO_DUMMY_DECL
+#define MY_ZCALLOC
+
+#include "zlib.h"
+
+#undef  SLOW
+#define SLOW  1  /* we can't use asm-optimized sources here! */
+
+  /* Urgh.  `inflate_mask' must not be declared twice -- C++ doesn't like
+     this.  We temporarily disable it and load all necessary header files. */
+#define NO_INFLATE_MASK
+#include "zutil.h"
+#include "inftrees.h"
+#include "infblock.h"
+#include "infcodes.h"
+#include "infutil.h"
+#undef  NO_INFLATE_MASK
+
+  /* infutil.c must be included before infcodes.c */
+#include "zutil.c"
+#include "inftrees.c"
+#include "infutil.c"
+#include "infcodes.c"
+#include "infblock.c"
+#include "inflate.c"
+#include "adler32.c"
+
+#endif /* !FT_CONFIG_OPTION_SYSTEM_ZLIB */
+
+
+/***************************************************************************/
+/***************************************************************************/
+/*****                                                                 *****/
+/*****            Z L I B   M E M O R Y   M A N A G E M E N T          *****/
+/*****                                                                 *****/
+/***************************************************************************/
+/***************************************************************************/
+
+  /* it is better to use FreeType memory routines instead of raw
+     'malloc/free' */
+
+  static voidpf
+  ft_gzip_alloc( FT_Memory  memory,
+                 uInt       items,
+                 uInt       size )
+  {
+    FT_ULong    sz = (FT_ULong)size * items;
+    FT_Pointer  p;
+
+
+    FT_MEM_ALLOC( p, sz );
+
+    return (voidpf) p;
+  }
+
+
+  static void
+  ft_gzip_free( FT_Memory  memory,
+                voidpf     address )
+  {
+    FT_MEM_FREE( address );
+  }
+
+
+#ifndef FT_CONFIG_OPTION_SYSTEM_ZLIB
+
+  local voidpf
+  zcalloc ( voidpf    opaque,
+            unsigned  items,
+            unsigned  size )
+  {
+    return ft_gzip_alloc( (FT_Memory)opaque, items, size );
+  }
+
+  local void
+  zcfree( voidpf  opaque,
+          voidpf  ptr )
+  {
+    ft_gzip_free( (FT_Memory)opaque, ptr );
+  }
+
+#endif /* !SYSTEM_ZLIB */
+
+
+/***************************************************************************/
+/***************************************************************************/
+/*****                                                                 *****/
+/*****               Z L I B   F I L E   D E S C R I P T O R           *****/
+/*****                                                                 *****/
+/***************************************************************************/
+/***************************************************************************/
+
+#define FT_GZIP_BUFFER_SIZE  4096
+
+  typedef struct  FT_GZipFileRec_
+  {
+    FT_Stream  source;         /* parent/source stream        */
+    FT_Stream  stream;         /* embedding stream            */
+    FT_Memory  memory;         /* memory allocator            */
+    z_stream   zstream;        /* zlib input stream           */
+
+    FT_ULong   start;          /* starting position, after .gz header */
+    FT_Byte    input[FT_GZIP_BUFFER_SIZE];   /* input read buffer  */
+
+    FT_Byte    buffer[FT_GZIP_BUFFER_SIZE];  /* output buffer      */
+    FT_ULong   pos;                          /* position in output */
+    FT_Byte*   cursor;
+    FT_Byte*   limit;
+
+  } FT_GZipFileRec, *FT_GZipFile;
+
+
+  /* gzip flag byte */
+#define FT_GZIP_ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
+#define FT_GZIP_HEAD_CRC     0x02 /* bit 1 set: header CRC present */
+#define FT_GZIP_EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
+#define FT_GZIP_ORIG_NAME    0x08 /* bit 3 set: original file name present */
+#define FT_GZIP_COMMENT      0x10 /* bit 4 set: file comment present */
+#define FT_GZIP_RESERVED     0xE0 /* bits 5..7: reserved */
+
+
+  /* check and skip .gz header - we don't support `transparent' compression */
+  static FT_Error
+  ft_gzip_check_header( FT_Stream  stream )
+  {
+    FT_Error  error;
+    FT_Byte   head[4];
+
+
+    if ( FT_STREAM_SEEK( 0 )       ||
+         FT_STREAM_READ( head, 4 ) )
+      goto Exit;
+
+    /* head[0] && head[1] are the magic numbers;    */
+    /* head[2] is the method, and head[3] the flags */
+    if ( head[0] != 0x1f              ||
+         head[1] != 0x8b              ||
+         head[2] != Z_DEFLATED        ||
+        (head[3] & FT_GZIP_RESERVED)  )
+    {
+      error = Gzip_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    /* skip time, xflags and os code */
+    (void)FT_STREAM_SKIP( 6 );
+
+    /* skip the extra field */
+    if ( head[3] & FT_GZIP_EXTRA_FIELD )
+    {
+      FT_UInt  len;
+
+
+      if ( FT_READ_USHORT_LE( len ) ||
+           FT_STREAM_SKIP( len )    )
+        goto Exit;
+    }
+
+    /* skip original file name */
+    if ( head[3] & FT_GZIP_ORIG_NAME )
+      for (;;)
+      {
+        FT_UInt  c;
+
+
+        if ( FT_READ_BYTE( c ) )
+          goto Exit;
+
+        if ( c == 0 )
+          break;
+      }
+
+    /* skip .gz comment */
+    if ( head[3] & FT_GZIP_COMMENT )
+      for (;;)
+      {
+        FT_UInt  c;
+
+
+        if ( FT_READ_BYTE( c ) )
+          goto Exit;
+
+        if ( c == 0 )
+          break;
+      }
+
+    /* skip CRC */
+    if ( head[3] & FT_GZIP_HEAD_CRC )
+      if ( FT_STREAM_SKIP( 2 ) )
+        goto Exit;
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  ft_gzip_file_init( FT_GZipFile  zip,
+                     FT_Stream    stream,
+                     FT_Stream    source )
+  {
+    z_stream*  zstream = &zip->zstream;
+    FT_Error   error   = Gzip_Err_Ok;
+
+
+    zip->stream = stream;
+    zip->source = source;
+    zip->memory = stream->memory;
+
+    zip->limit  = zip->buffer + FT_GZIP_BUFFER_SIZE;
+    zip->cursor = zip->limit;
+    zip->pos    = 0;
+
+    /* check and skip .gz header */
+    {
+      stream = source;
+
+      error = ft_gzip_check_header( stream );
+      if ( error )
+        goto Exit;
+
+      zip->start = FT_STREAM_POS();
+    }
+
+    /* initialize zlib -- there is no zlib header in the compressed stream */
+    zstream->zalloc = (alloc_func)ft_gzip_alloc;
+    zstream->zfree  = (free_func) ft_gzip_free;
+    zstream->opaque = stream->memory;
+
+    zstream->avail_in = 0;
+    zstream->next_in  = zip->buffer;
+
+    if ( inflateInit2( zstream, -MAX_WBITS ) != Z_OK ||
+         zstream->next_in == NULL                     )
+      error = Gzip_Err_Invalid_File_Format;
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  ft_gzip_file_done( FT_GZipFile  zip )
+  {
+    z_stream*  zstream = &zip->zstream;
+
+
+    inflateEnd( zstream );
+
+    /* clear the rest */
+    zstream->zalloc    = NULL;
+    zstream->zfree     = NULL;
+    zstream->opaque    = NULL;
+    zstream->next_in   = NULL;
+    zstream->next_out  = NULL;
+    zstream->avail_in  = 0;
+    zstream->avail_out = 0;
+
+    zip->memory = NULL;
+    zip->source = NULL;
+    zip->stream = NULL;
+  }
+
+
+  static FT_Error
+  ft_gzip_file_reset( FT_GZipFile  zip )
+  {
+    FT_Stream  stream = zip->source;
+    FT_Error   error;
+
+
+    if ( !FT_STREAM_SEEK( zip->start ) )
+    {
+      z_stream*  zstream = &zip->zstream;
+
+
+      inflateReset( zstream );
+
+      zstream->avail_in  = 0;
+      zstream->next_in   = zip->input;
+      zstream->avail_out = 0;
+      zstream->next_out  = zip->buffer;
+
+      zip->limit  = zip->buffer + FT_GZIP_BUFFER_SIZE;
+      zip->cursor = zip->limit;
+      zip->pos    = 0;
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  ft_gzip_file_fill_input( FT_GZipFile  zip )
+  {
+    z_stream*  zstream = &zip->zstream;
+    FT_Stream  stream  = zip->source;
+    FT_ULong   size;
+
+
+    if ( stream->read )
+    {
+      size = stream->read( stream, stream->pos, zip->input,
+                           FT_GZIP_BUFFER_SIZE );
+      if ( size == 0 )
+        return Gzip_Err_Invalid_Stream_Operation;
+    }
+    else
+    {
+      size = stream->size - stream->pos;
+      if ( size > FT_GZIP_BUFFER_SIZE )
+        size = FT_GZIP_BUFFER_SIZE;
+
+      if ( size == 0 )
+        return Gzip_Err_Invalid_Stream_Operation;
+
+      FT_MEM_COPY( zip->input, stream->base + stream->pos, size );
+    }
+    stream->pos += size;
+
+    zstream->next_in  = zip->input;
+    zstream->avail_in = size;
+
+    return Gzip_Err_Ok;
+  }
+
+
+  static FT_Error
+  ft_gzip_file_fill_output( FT_GZipFile  zip )
+  {
+    z_stream*  zstream = &zip->zstream;
+    FT_Error   error   = 0;
+
+
+    zip->cursor        = zip->buffer;
+    zstream->next_out  = zip->cursor;
+    zstream->avail_out = FT_GZIP_BUFFER_SIZE;
+
+    while ( zstream->avail_out > 0 )
+    {
+      int  err;
+
+
+      if ( zstream->avail_in == 0 )
+      {
+        error = ft_gzip_file_fill_input( zip );
+        if ( error )
+          break;
+      }
+
+      err = inflate( zstream, Z_NO_FLUSH );
+
+      if ( err == Z_STREAM_END )
+      {
+        zip->limit = zstream->next_out;
+        if ( zip->limit == zip->cursor )
+          error = Gzip_Err_Invalid_Stream_Operation;
+        break;
+      }
+      else if ( err != Z_OK )
+      {
+        error = Gzip_Err_Invalid_Stream_Operation;
+        break;
+      }
+    }
+
+    return error;
+  }
+
+
+  /* fill output buffer; `count' must be <= FT_GZIP_BUFFER_SIZE */
+  static FT_Error
+  ft_gzip_file_skip_output( FT_GZipFile  zip,
+                            FT_ULong     count )
+  {
+    FT_Error  error = Gzip_Err_Ok;
+    FT_ULong  delta;
+
+
+    for (;;)
+    {
+      delta = (FT_ULong)( zip->limit - zip->cursor );
+      if ( delta >= count )
+        delta = count;
+
+      zip->cursor += delta;
+      zip->pos    += delta;
+
+      count -= delta;
+      if ( count == 0 )
+        break;
+
+      error = ft_gzip_file_fill_output( zip );
+      if ( error )
+        break;
+    }
+
+    return error;
+  }
+
+
+  static FT_ULong
+  ft_gzip_file_io( FT_GZipFile  zip,
+                   FT_ULong     pos,
+                   FT_Byte*     buffer,
+                   FT_ULong     count )
+  {
+    FT_ULong  result = 0;
+    FT_Error  error;
+
+
+    /* Reset inflate stream if we're seeking backwards.        */
+    /* Yes, that is not too efficient, but it saves memory :-) */
+    if ( pos < zip->pos )
+    {
+      error = ft_gzip_file_reset( zip );
+      if ( error )
+        goto Exit;
+    }
+
+    /* skip unwanted bytes */
+    if ( pos > zip->pos )
+    {
+      error = ft_gzip_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) );
+      if ( error )
+        goto Exit;
+    }
+
+    if ( count == 0 )
+      goto Exit;
+
+    /* now read the data */
+    for (;;)
+    {
+      FT_ULong  delta;
+
+
+      delta = (FT_ULong)( zip->limit - zip->cursor );
+      if ( delta >= count )
+        delta = count;
+
+      FT_MEM_COPY( buffer, zip->cursor, delta );
+      buffer      += delta;
+      result      += delta;
+      zip->cursor += delta;
+      zip->pos    += delta;
+
+      count -= delta;
+      if ( count == 0 )
+        break;
+
+      error = ft_gzip_file_fill_output( zip );
+      if ( error )
+        break;
+    }
+
+  Exit:
+    return result;
+  }
+
+
+/***************************************************************************/
+/***************************************************************************/
+/*****                                                                 *****/
+/*****               G Z   E M B E D D I N G   S T R E A M             *****/
+/*****                                                                 *****/
+/***************************************************************************/
+/***************************************************************************/
+
+  static void
+  ft_gzip_stream_close( FT_Stream  stream )
+  {
+    FT_GZipFile  zip    = (FT_GZipFile)stream->descriptor.pointer;
+    FT_Memory    memory = stream->memory;
+
+
+    if ( zip )
+    {
+      /* finalize gzip file descriptor */
+      ft_gzip_file_done( zip );
+
+      FT_FREE( zip );
+
+      stream->descriptor.pointer = NULL;
+    }
+  }
+
+
+  static FT_ULong
+  ft_gzip_stream_io( FT_Stream  stream,
+                     FT_ULong   pos,
+                     FT_Byte*   buffer,
+                     FT_ULong   count )
+  {
+    FT_GZipFile  zip = (FT_GZipFile)stream->descriptor.pointer;
+
+
+    return ft_gzip_file_io( zip, pos, buffer, count );
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stream_OpenGzip( FT_Stream  stream,
+                      FT_Stream  source )
+  {
+    FT_Error     error;
+    FT_Memory    memory = source->memory;
+    FT_GZipFile  zip;
+
+
+    FT_ZERO( stream );
+    stream->memory = memory;
+
+    if ( !FT_QNEW( zip ) )
+    {
+      error = ft_gzip_file_init( zip, stream, source );
+      if ( error )
+      {
+        FT_FREE( zip );
+        goto Exit;
+      }
+
+      stream->descriptor.pointer = zip;
+    }
+
+    stream->size  = 0x7FFFFFFFL;  /* don't know the real size! */
+    stream->pos   = 0;
+    stream->base  = 0;
+    stream->read  = ft_gzip_stream_io;
+    stream->close = ft_gzip_stream_close;
+
+  Exit:
+    return error;
+  }
+
+#else  /* !FT_CONFIG_OPTION_USE_ZLIB */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stream_OpenGzip( FT_Stream  stream,
+                      FT_Stream  source )
+  {
+    FT_UNUSED( stream );
+    FT_UNUSED( source );
+
+    return Gzip_Err_Unimplemented_Feature;
+  }
+
+#endif /* !FT_CONFIG_OPTION_USE_ZLIB */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/gzip/infblock.c b/nx-X11/extras/freetype2/src/gzip/infblock.c
new file mode 100644
index 000000000..d6e2dc297
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/infblock.c
@@ -0,0 +1,387 @@
+/* infblock.c -- interpret and process block types to last block
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+#include "inftrees.h"
+#include "infcodes.h"
+#include "infutil.h"
+
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+/* Table for deflate from PKZIP's appnote.txt. */
+local const uInt border[] = { /* Order of the bit length code lengths */
+        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+/*
+   Notes beyond the 1.93a appnote.txt:
+
+   1. Distance pointers never point before the beginning of the output
+      stream.
+   2. Distance pointers can point back across blocks, up to 32k away.
+   3. There is an implied maximum of 7 bits for the bit length table and
+      15 bits for the actual data.
+   4. If only one code exists, then it is encoded using one bit.  (Zero
+      would be more efficient, but perhaps a little confusing.)  If two
+      codes exist, they are coded using one bit each (0 and 1).
+   5. There is no way of sending zero distance codes--a dummy must be
+      sent if there are none.  (History: a pre 2.0 version of PKZIP would
+      store blocks with no distance codes, but this was discovered to be
+      too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
+      zero distance codes, which is sent as one code of zero bits in
+      length.
+   6. There are up to 286 literal/length codes.  Code 256 represents the
+      end-of-block.  Note however that the static length tree defines
+      288 codes just to fill out the Huffman codes.  Codes 286 and 287
+      cannot be used though, since there is no length base or extra bits
+      defined for them.  Similarily, there are up to 30 distance codes.
+      However, static trees define 32 codes (all 5 bits) to fill out the
+      Huffman codes, but the last two had better not show up in the data.
+   7. Unzip can check dynamic Huffman blocks for complete code sets.
+      The exception is that a single code would not be complete (see #4).
+   8. The five bits following the block type is really the number of
+      literal codes sent minus 257.
+   9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
+      (1+6+6).  Therefore, to output three times the length, you output
+      three codes (1+1+1), whereas to output four times the same length,
+      you only need two codes (1+3).  Hmm.
+  10. In the tree reconstruction algorithm, Code = Code + Increment
+      only if BitLength(i) is not zero.  (Pretty obvious.)
+  11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
+  12. Note: length code 284 can represent 227-258, but length code 285
+      really is 258.  The last length deserves its own, short code
+      since it gets used a lot in very redundant files.  The length
+      258 is special since 258 - 3 (the min match length) is 255.
+  13. The literal/length and distance code bit lengths are read as a
+      single stream of lengths.  It is possible (and advantageous) for
+      a repeat code (16, 17, or 18) to go across the boundary between
+      the two sets of lengths.
+ */
+
+
+local void inflate_blocks_reset( /* s, z, c) */
+inflate_blocks_statef *s,
+z_streamp z,
+uLongf *c )
+{
+  if (c != Z_NULL)
+    *c = s->check;
+  if (s->mode == BTREE || s->mode == DTREE)
+    ZFREE(z, s->sub.trees.blens);
+  if (s->mode == CODES)
+    inflate_codes_free(s->sub.decode.codes, z);
+  s->mode = TYPE;
+  s->bitk = 0;
+  s->bitb = 0;
+  s->read = s->write = s->window;
+  if (s->checkfn != Z_NULL)
+    z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0);
+  Tracev((stderr, "inflate:   blocks reset\n"));
+}
+
+
+local inflate_blocks_statef *inflate_blocks_new( /* z, c, w) */
+z_streamp z,
+check_func c,
+uInt w )
+{
+  inflate_blocks_statef *s;
+
+  if ((s = (inflate_blocks_statef *)ZALLOC
+       (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
+    return s;
+  if ((s->hufts =
+       (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL)
+  {
+    ZFREE(z, s);
+    return Z_NULL;
+  }
+  if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
+  {
+    ZFREE(z, s->hufts);
+    ZFREE(z, s);
+    return Z_NULL;
+  }
+  s->end = s->window + w;
+  s->checkfn = c;
+  s->mode = TYPE;
+  Tracev((stderr, "inflate:   blocks allocated\n"));
+  inflate_blocks_reset(s, z, Z_NULL);
+  return s;
+}
+
+
+local int inflate_blocks( /* s, z, r) */
+inflate_blocks_statef *s,
+z_streamp z,
+int r )
+{
+  uInt t;               /* temporary storage */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Bytef *p;             /* input data pointer */
+  uInt n;               /* bytes available there */
+  Bytef *q;             /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+
+  /* copy input/output information to locals (UPDATE macro restores) */
+  LOAD
+
+  /* process input based on current state */
+  while (1) switch (s->mode)
+  {
+    case TYPE:
+      NEEDBITS(3)
+      t = (uInt)b & 7;
+      s->last = t & 1;
+      switch (t >> 1)
+      {
+        case 0:                         /* stored */
+          Tracev((stderr, "inflate:     stored block%s\n",
+                 s->last ? " (last)" : ""));
+          DUMPBITS(3)
+          t = k & 7;                    /* go to byte boundary */
+          DUMPBITS(t)
+          s->mode = LENS;               /* get length of stored block */
+          break;
+        case 1:                         /* fixed */
+          Tracev((stderr, "inflate:     fixed codes block%s\n",
+                 s->last ? " (last)" : ""));
+          {
+            uInt bl, bd;
+            inflate_huft *tl, *td;
+
+            inflate_trees_fixed(&bl, &bd, (const inflate_huft**)&tl,
+                                          (const inflate_huft**)&td, z);
+            s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
+            if (s->sub.decode.codes == Z_NULL)
+            {
+              r = Z_MEM_ERROR;
+              LEAVE
+            }
+          }
+          DUMPBITS(3)
+          s->mode = CODES;
+          break;
+        case 2:                         /* dynamic */
+          Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                 s->last ? " (last)" : ""));
+          DUMPBITS(3)
+          s->mode = TABLE;
+          break;
+        case 3:                         /* illegal */
+          DUMPBITS(3)
+          s->mode = BAD;
+          z->msg = (char*)"invalid block type";
+          r = Z_DATA_ERROR;
+          LEAVE
+      }
+      break;
+    case LENS:
+      NEEDBITS(32)
+      if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
+      {
+        s->mode = BAD;
+        z->msg = (char*)"invalid stored block lengths";
+        r = Z_DATA_ERROR;
+        LEAVE
+      }
+      s->sub.left = (uInt)b & 0xffff;
+      b = k = 0;                      /* dump bits */
+      Tracev((stderr, "inflate:       stored length %u\n", s->sub.left));
+      s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
+      break;
+    case STORED:
+      if (n == 0)
+        LEAVE
+      NEEDOUT
+      t = s->sub.left;
+      if (t > n) t = n;
+      if (t > m) t = m;
+      zmemcpy(q, p, t);
+      p += t;  n -= t;
+      q += t;  m -= t;
+      if ((s->sub.left -= t) != 0)
+        break;
+      Tracev((stderr, "inflate:       stored end, %lu total out\n",
+              z->total_out + (q >= s->read ? q - s->read :
+              (s->end - s->read) + (q - s->window))));
+      s->mode = s->last ? DRY : TYPE;
+      break;
+    case TABLE:
+      NEEDBITS(14)
+      s->sub.trees.table = t = (uInt)b & 0x3fff;
+#ifndef PKZIP_BUG_WORKAROUND
+      if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
+      {
+        s->mode = BAD;
+        z->msg = (char*)"too many length or distance symbols";
+        r = Z_DATA_ERROR;
+        LEAVE
+      }
+#endif
+      t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
+      if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
+      {
+        r = Z_MEM_ERROR;
+        LEAVE
+      }
+      DUMPBITS(14)
+      s->sub.trees.index = 0;
+      Tracev((stderr, "inflate:       table sizes ok\n"));
+      s->mode = BTREE;
+    case BTREE:
+      while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
+      {
+        NEEDBITS(3)
+        s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
+        DUMPBITS(3)
+      }
+      while (s->sub.trees.index < 19)
+        s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
+      s->sub.trees.bb = 7;
+      t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
+                             &s->sub.trees.tb, s->hufts, z);
+      if (t != Z_OK)
+      {
+        r = t;
+        if (r == Z_DATA_ERROR)
+        {
+          ZFREE(z, s->sub.trees.blens);
+          s->mode = BAD;
+        }
+        LEAVE
+      }
+      s->sub.trees.index = 0;
+      Tracev((stderr, "inflate:       bits tree ok\n"));
+      s->mode = DTREE;
+    case DTREE:
+      while (t = s->sub.trees.table,
+             s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
+      {
+        inflate_huft *h;
+        uInt i, j, c;
+
+        t = s->sub.trees.bb;
+        NEEDBITS(t)
+        h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
+        t = h->bits;
+        c = h->base;
+        if (c < 16)
+        {
+          DUMPBITS(t)
+          s->sub.trees.blens[s->sub.trees.index++] = c;
+        }
+        else /* c == 16..18 */
+        {
+          i = c == 18 ? 7 : c - 14;
+          j = c == 18 ? 11 : 3;
+          NEEDBITS(t + i)
+          DUMPBITS(t)
+          j += (uInt)b & inflate_mask[i];
+          DUMPBITS(i)
+          i = s->sub.trees.index;
+          t = s->sub.trees.table;
+          if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
+              (c == 16 && i < 1))
+          {
+            ZFREE(z, s->sub.trees.blens);
+            s->mode = BAD;
+            z->msg = (char*)"invalid bit length repeat";
+            r = Z_DATA_ERROR;
+            LEAVE
+          }
+          c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
+          do {
+            s->sub.trees.blens[i++] = c;
+          } while (--j);
+          s->sub.trees.index = i;
+        }
+      }
+      s->sub.trees.tb = Z_NULL;
+      {
+        uInt bl, bd;
+        inflate_huft *tl, *td;
+        inflate_codes_statef *c;
+
+        bl = 9;         /* must be <= 9 for lookahead assumptions */
+        bd = 6;         /* must be <= 9 for lookahead assumptions */
+        t = s->sub.trees.table;
+        t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
+                                  s->sub.trees.blens, &bl, &bd, &tl, &td,
+                                  s->hufts, z);
+        if (t != Z_OK)
+        {
+          if (t == (uInt)Z_DATA_ERROR)
+          {
+            ZFREE(z, s->sub.trees.blens);
+            s->mode = BAD;
+          }
+          r = t;
+          LEAVE
+        }
+        Tracev((stderr, "inflate:       trees ok\n"));
+        if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
+        {
+          r = Z_MEM_ERROR;
+          LEAVE
+        }
+        s->sub.decode.codes = c;
+      }
+      ZFREE(z, s->sub.trees.blens);
+      s->mode = CODES;
+    case CODES:
+      UPDATE
+      if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
+        return inflate_flush(s, z, r);
+      r = Z_OK;
+      inflate_codes_free(s->sub.decode.codes, z);
+      LOAD
+      Tracev((stderr, "inflate:       codes end, %lu total out\n",
+              z->total_out + (q >= s->read ? q - s->read :
+              (s->end - s->read) + (q - s->window))));
+      if (!s->last)
+      {
+        s->mode = TYPE;
+        break;
+      }
+      s->mode = DRY;
+    case DRY:
+      FLUSH
+      if (s->read != s->write)
+        LEAVE
+      s->mode = DONE;
+    case DONE:
+      r = Z_STREAM_END;
+      LEAVE
+    case BAD:
+      r = Z_DATA_ERROR;
+      LEAVE
+    default:
+      r = Z_STREAM_ERROR;
+      LEAVE
+  }
+#ifdef NEED_DUMMY_RETURN
+  return 0;
+#endif
+}
+
+
+local int inflate_blocks_free( /* s, z) */
+inflate_blocks_statef *s,
+z_streamp z )
+{
+  inflate_blocks_reset(s, z, Z_NULL);
+  ZFREE(z, s->window);
+  ZFREE(z, s->hufts);
+  ZFREE(z, s);
+  Tracev((stderr, "inflate:   blocks freed\n"));
+  return Z_OK;
+}
+
+
diff --git a/nx-X11/extras/freetype2/src/gzip/infblock.h b/nx-X11/extras/freetype2/src/gzip/infblock.h
new file mode 100644
index 000000000..c2535a1e4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/infblock.h
@@ -0,0 +1,36 @@
+/* infblock.h -- header to use infblock.c
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+#ifndef _INFBLOCK_H
+#define _INFBLOCK_H
+
+struct inflate_blocks_state;
+typedef struct inflate_blocks_state FAR inflate_blocks_statef;
+
+local  inflate_blocks_statef * inflate_blocks_new OF((
+    z_streamp z,
+    check_func c,               /* check function */
+    uInt w));                   /* window size */
+
+local  int inflate_blocks OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));                      /* initial return code */
+
+local  void inflate_blocks_reset OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    uLongf *));                  /* check value on output */
+
+local  int inflate_blocks_free OF((
+    inflate_blocks_statef *,
+    z_streamp));
+
+#endif /* _INFBLOCK_H */
diff --git a/nx-X11/extras/freetype2/src/gzip/infcodes.c b/nx-X11/extras/freetype2/src/gzip/infcodes.c
new file mode 100644
index 000000000..f7bfd58c4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/infcodes.c
@@ -0,0 +1,250 @@
+/* infcodes.c -- process literals and length/distance pairs
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "infblock.h"
+#include "infcodes.h"
+#include "infutil.h"
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+typedef enum {        /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
+      START,    /* x: set up for LEN */
+      LEN,      /* i: get length/literal/eob next */
+      LENEXT,   /* i: getting length extra (have base) */
+      DIST,     /* i: get distance next */
+      DISTEXT,  /* i: getting distance extra */
+      COPY,     /* o: copying bytes in window, waiting for space */
+      LIT,      /* o: got literal, waiting for output space */
+      WASH,     /* o: got eob, possibly still output waiting */
+      END,      /* x: got eob and all data flushed */
+      BADCODE}  /* x: got error */
+inflate_codes_mode;
+
+/* inflate codes private state */
+struct inflate_codes_state {
+
+  /* mode */
+  inflate_codes_mode mode;      /* current inflate_codes mode */
+
+  /* mode dependent information */
+  uInt len;
+  union {
+    struct {
+      inflate_huft *tree;       /* pointer into tree */
+      uInt need;                /* bits needed */
+    } code;             /* if LEN or DIST, where in tree */
+    uInt lit;           /* if LIT, literal */
+    struct {
+      uInt get;                 /* bits to get for extra */
+      uInt dist;                /* distance back to copy from */
+    } copy;             /* if EXT or COPY, where and how much */
+  } sub;                /* submode */
+
+  /* mode independent information */
+  Byte lbits;           /* ltree bits decoded per branch */
+  Byte dbits;           /* dtree bits decoder per branch */
+  inflate_huft *ltree;          /* literal/length/eob tree */
+  inflate_huft *dtree;          /* distance tree */
+
+};
+
+
+local inflate_codes_statef *inflate_codes_new( /* bl, bd, tl, td, z) */
+uInt bl, uInt bd,
+inflate_huft *tl,
+inflate_huft *td, /* need separate declaration for Borland C++ */
+z_streamp z )
+{
+  inflate_codes_statef *c;
+
+  if ((c = (inflate_codes_statef *)
+       ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL)
+  {
+    c->mode = START;
+    c->lbits = (Byte)bl;
+    c->dbits = (Byte)bd;
+    c->ltree = tl;
+    c->dtree = td;
+    Tracev((stderr, "inflate:       codes new\n"));
+  }
+  return c;
+}
+
+
+local int inflate_codes( /* s, z, r) */
+inflate_blocks_statef *s,
+z_streamp z,
+int r )
+{
+  uInt j;               /* temporary storage */
+  inflate_huft *t;      /* temporary pointer */
+  uInt e;               /* extra bits or operation */
+  uLong b;              /* bit buffer */
+  uInt k;               /* bits in bit buffer */
+  Bytef *p;             /* input data pointer */
+  uInt n;               /* bytes available there */
+  Bytef *q;             /* output window write pointer */
+  uInt m;               /* bytes to end of window or read pointer */
+  Bytef *f;             /* pointer to copy strings from */
+  inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */
+
+  /* copy input/output information to locals (UPDATE macro restores) */
+  LOAD
+
+  /* process input and output based on current state */
+  while (1) switch (c->mode)
+  {             /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
+    case START:         /* x: set up for LEN */
+#ifndef SLOW
+      if (m >= 258 && n >= 10)
+      {
+        UPDATE
+        r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
+        LOAD
+        if (r != Z_OK)
+        {
+          c->mode = r == Z_STREAM_END ? WASH : BADCODE;
+          break;
+        }
+      }
+#endif /* !SLOW */
+      c->sub.code.need = c->lbits;
+      c->sub.code.tree = c->ltree;
+      c->mode = LEN;
+    case LEN:           /* i: get length/literal/eob next */
+      j = c->sub.code.need;
+      NEEDBITS(j)
+      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
+      DUMPBITS(t->bits)
+      e = (uInt)(t->exop);
+      if (e == 0)               /* literal */
+      {
+        c->sub.lit = t->base;
+        Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
+                 "inflate:         literal '%c'\n" :
+                 "inflate:         literal 0x%02x\n", t->base));
+        c->mode = LIT;
+        break;
+      }
+      if (e & 16)               /* length */
+      {
+        c->sub.copy.get = e & 15;
+        c->len = t->base;
+        c->mode = LENEXT;
+        break;
+      }
+      if ((e & 64) == 0)        /* next table */
+      {
+        c->sub.code.need = e;
+        c->sub.code.tree = t + t->base;
+        break;
+      }
+      if (e & 32)               /* end of block */
+      {
+        Tracevv((stderr, "inflate:         end of block\n"));
+        c->mode = WASH;
+        break;
+      }
+      c->mode = BADCODE;        /* invalid code */
+      z->msg = (char*)"invalid literal/length code";
+      r = Z_DATA_ERROR;
+      LEAVE
+    case LENEXT:        /* i: getting length extra (have base) */
+      j = c->sub.copy.get;
+      NEEDBITS(j)
+      c->len += (uInt)b & inflate_mask[j];
+      DUMPBITS(j)
+      c->sub.code.need = c->dbits;
+      c->sub.code.tree = c->dtree;
+      Tracevv((stderr, "inflate:         length %u\n", c->len));
+      c->mode = DIST;
+    case DIST:          /* i: get distance next */
+      j = c->sub.code.need;
+      NEEDBITS(j)
+      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
+      DUMPBITS(t->bits)
+      e = (uInt)(t->exop);
+      if (e & 16)               /* distance */
+      {
+        c->sub.copy.get = e & 15;
+        c->sub.copy.dist = t->base;
+        c->mode = DISTEXT;
+        break;
+      }
+      if ((e & 64) == 0)        /* next table */
+      {
+        c->sub.code.need = e;
+        c->sub.code.tree = t + t->base;
+        break;
+      }
+      c->mode = BADCODE;        /* invalid code */
+      z->msg = (char*)"invalid distance code";
+      r = Z_DATA_ERROR;
+      LEAVE
+    case DISTEXT:       /* i: getting distance extra */
+      j = c->sub.copy.get;
+      NEEDBITS(j)
+      c->sub.copy.dist += (uInt)b & inflate_mask[j];
+      DUMPBITS(j)
+      Tracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist));
+      c->mode = COPY;
+    case COPY:          /* o: copying bytes in window, waiting for space */
+      f = q - c->sub.copy.dist;
+      while (f < s->window)             /* modulo window size-"while" instead */
+        f += s->end - s->window;        /* of "if" handles invalid distances */
+      while (c->len)
+      {
+        NEEDOUT
+        OUTBYTE(*f++)
+        if (f == s->end)
+          f = s->window;
+        c->len--;
+      }
+      c->mode = START;
+      break;
+    case LIT:           /* o: got literal, waiting for output space */
+      NEEDOUT
+      OUTBYTE(c->sub.lit)
+      c->mode = START;
+      break;
+    case WASH:          /* o: got eob, possibly more output */
+      if (k > 7)        /* return unused byte, if any */
+      {
+        Assert(k < 16, "inflate_codes grabbed too many bytes")
+        k -= 8;
+        n++;
+        p--;            /* can always return one */
+      }
+      FLUSH
+      if (s->read != s->write)
+        LEAVE
+      c->mode = END;
+    case END:
+      r = Z_STREAM_END;
+      LEAVE
+    case BADCODE:       /* x: got error */
+      r = Z_DATA_ERROR;
+      LEAVE
+    default:
+      r = Z_STREAM_ERROR;
+      LEAVE
+  }
+#ifdef NEED_DUMMY_RETURN
+  return Z_STREAM_ERROR;  /* Some dumb compilers complain without this */
+#endif
+}
+
+
+local void inflate_codes_free( /* c, z) */
+inflate_codes_statef *c,
+z_streamp z )
+{
+  ZFREE(z, c);
+  Tracev((stderr, "inflate:       codes free\n"));
+}
diff --git a/nx-X11/extras/freetype2/src/gzip/infcodes.h b/nx-X11/extras/freetype2/src/gzip/infcodes.h
new file mode 100644
index 000000000..154d7f896
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/infcodes.h
@@ -0,0 +1,31 @@
+/* infcodes.h -- header to use infcodes.c
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+#ifndef _INFCODES_H
+#define _INFCODES_H
+
+struct inflate_codes_state;
+typedef struct inflate_codes_state FAR inflate_codes_statef;
+
+local inflate_codes_statef *inflate_codes_new OF((
+    uInt, uInt,
+    inflate_huft *, inflate_huft *,
+    z_streamp ));
+
+local int inflate_codes OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));
+
+local void inflate_codes_free OF((
+    inflate_codes_statef *,
+    z_streamp ));
+
+#endif /* _INFCODES_H */
diff --git a/nx-X11/extras/freetype2/src/gzip/inffixed.h b/nx-X11/extras/freetype2/src/gzip/inffixed.h
new file mode 100644
index 000000000..4d4760ea0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/inffixed.h
@@ -0,0 +1,151 @@
+/* inffixed.h -- table for decoding fixed codes
+ * Generated automatically by the maketree.c program
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+local const uInt fixed_bl = 9;
+local const uInt fixed_bd = 5;
+local const inflate_huft fixed_tl[] = {
+    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
+    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192},
+    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160},
+    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224},
+    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144},
+    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208},
+    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176},
+    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240},
+    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
+    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200},
+    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168},
+    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232},
+    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152},
+    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216},
+    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184},
+    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248},
+    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
+    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196},
+    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164},
+    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228},
+    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148},
+    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212},
+    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180},
+    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244},
+    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204},
+    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172},
+    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236},
+    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156},
+    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220},
+    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188},
+    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252},
+    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
+    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194},
+    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162},
+    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226},
+    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146},
+    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210},
+    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178},
+    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242},
+    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
+    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202},
+    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170},
+    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234},
+    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154},
+    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218},
+    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186},
+    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250},
+    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
+    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198},
+    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166},
+    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230},
+    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150},
+    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214},
+    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182},
+    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246},
+    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206},
+    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174},
+    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238},
+    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158},
+    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222},
+    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190},
+    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254},
+    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},
+    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193},
+    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161},
+    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225},
+    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145},
+    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209},
+    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177},
+    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241},
+    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},
+    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201},
+    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169},
+    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233},
+    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153},
+    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217},
+    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185},
+    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249},
+    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},
+    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197},
+    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165},
+    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229},
+    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149},
+    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213},
+    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181},
+    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245},
+    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205},
+    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173},
+    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237},
+    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157},
+    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221},
+    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189},
+    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253},
+    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},
+    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195},
+    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163},
+    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227},
+    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147},
+    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211},
+    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179},
+    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243},
+    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},
+    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203},
+    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171},
+    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235},
+    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155},
+    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219},
+    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187},
+    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251},
+    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},
+    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199},
+    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167},
+    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231},
+    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151},
+    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215},
+    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183},
+    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247},
+    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},
+    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207},
+    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175},
+    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239},
+    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159},
+    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223},
+    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191},
+    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255}
+  };
+local const inflate_huft fixed_td[] = {
+    {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097},
+    {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385},
+    {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193},
+    {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577},
+    {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145},
+    {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577},
+    {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289},
+    {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577}
+  };
diff --git a/nx-X11/extras/freetype2/src/gzip/inflate.c b/nx-X11/extras/freetype2/src/gzip/inflate.c
new file mode 100644
index 000000000..8877fa3eb
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/inflate.c
@@ -0,0 +1,273 @@
+/* inflate.c -- zlib interface to inflate modules
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+
+#define  DONE  INFLATE_DONE
+#define  BAD   INFLATE_BAD
+
+typedef enum {
+      METHOD,   /* waiting for method byte */
+      FLAG,     /* waiting for flag byte */
+      DICT4,    /* four dictionary check bytes to go */
+      DICT3,    /* three dictionary check bytes to go */
+      DICT2,    /* two dictionary check bytes to go */
+      DICT1,    /* one dictionary check byte to go */
+      DICT0,    /* waiting for inflateSetDictionary */
+      BLOCKS,   /* decompressing blocks */
+      CHECK4,   /* four check bytes to go */
+      CHECK3,   /* three check bytes to go */
+      CHECK2,   /* two check bytes to go */
+      CHECK1,   /* one check byte to go */
+      DONE,     /* finished check, done */
+      BAD}      /* got an error--stay here */
+inflate_mode;
+
+/* inflate private state */
+struct internal_state {
+
+  /* mode */
+  inflate_mode  mode;   /* current inflate mode */
+
+  /* mode dependent information */
+  union {
+    uInt method;        /* if FLAGS, method byte */
+    struct {
+      uLong was;                /* computed check value */
+      uLong need;               /* stream check value */
+    } check;            /* if CHECK, check values to compare */
+    uInt marker;        /* if BAD, inflateSync's marker bytes count */
+  } sub;        /* submode */
+
+  /* mode independent information */
+  int  nowrap;          /* flag for no wrapper */
+  uInt wbits;           /* log2(window size)  (8..15, defaults to 15) */
+  inflate_blocks_statef
+    *blocks;            /* current inflate_blocks state */
+
+};
+
+
+ZEXPORT(int) inflateReset( /* z) */
+z_streamp z )
+{
+  if (z == Z_NULL || z->state == Z_NULL)
+    return Z_STREAM_ERROR;
+  z->total_in = z->total_out = 0;
+  z->msg = Z_NULL;
+  z->state->mode = z->state->nowrap ? BLOCKS : METHOD;
+  inflate_blocks_reset(z->state->blocks, z, Z_NULL);
+  Tracev((stderr, "inflate: reset\n"));
+  return Z_OK;
+}
+
+
+ZEXPORT(int) inflateEnd( /* z) */
+z_streamp z )
+{
+  if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
+    return Z_STREAM_ERROR;
+  if (z->state->blocks != Z_NULL)
+    inflate_blocks_free(z->state->blocks, z);
+  ZFREE(z, z->state);
+  z->state = Z_NULL;
+  Tracev((stderr, "inflate: end\n"));
+  return Z_OK;
+}
+
+
+ZEXPORT(int) inflateInit2_( /* z, w, version, stream_size) */
+z_streamp z,
+int w,
+const char *version,
+int stream_size )
+{
+  if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+      stream_size != sizeof(z_stream))
+      return Z_VERSION_ERROR;
+
+  /* initialize state */
+  if (z == Z_NULL)
+    return Z_STREAM_ERROR;
+  z->msg = Z_NULL;
+  if (z->zalloc == Z_NULL)
+  {
+    z->zalloc = zcalloc;
+    z->opaque = (voidpf)0;
+  }
+  if (z->zfree == Z_NULL) z->zfree = zcfree;
+  if ((z->state = (struct internal_state FAR *)
+       ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)
+    return Z_MEM_ERROR;
+  z->state->blocks = Z_NULL;
+
+  /* handle undocumented nowrap option (no zlib header or check) */
+  z->state->nowrap = 0;
+  if (w < 0)
+  {
+    w = - w;
+    z->state->nowrap = 1;
+  }
+
+  /* set window size */
+  if (w < 8 || w > 15)
+  {
+    inflateEnd(z);
+    return Z_STREAM_ERROR;
+  }
+  z->state->wbits = (uInt)w;
+
+  /* create inflate_blocks state */
+  if ((z->state->blocks =
+      inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w))
+      == Z_NULL)
+  {
+    inflateEnd(z);
+    return Z_MEM_ERROR;
+  }
+  Tracev((stderr, "inflate: allocated\n"));
+
+  /* reset state */
+  inflateReset(z);
+  return Z_OK;
+}
+
+
+
+#undef  NEEDBYTE
+#define NEEDBYTE {if(z->avail_in==0)return r;r=f;}
+
+#undef  NEXTBYTE
+#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)
+
+
+ZEXPORT(int) inflate( /* z, f) */
+z_streamp z,
+int f )
+{
+  int r;
+  uInt b;
+
+  if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL)
+    return Z_STREAM_ERROR;
+  f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
+  r = Z_BUF_ERROR;
+  while (1) switch (z->state->mode)
+  {
+    case METHOD:
+      NEEDBYTE
+      if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"unknown compression method";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"invalid window size";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      z->state->mode = FLAG;
+    case FLAG:
+      NEEDBYTE
+      b = NEXTBYTE;
+      if (((z->state->sub.method << 8) + b) % 31)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"incorrect header check";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      Tracev((stderr, "inflate: zlib header ok\n"));
+      if (!(b & PRESET_DICT))
+      {
+        z->state->mode = BLOCKS;
+        break;
+      }
+      z->state->mode = DICT4;
+    case DICT4:
+      NEEDBYTE
+      z->state->sub.check.need = (uLong)NEXTBYTE << 24;
+      z->state->mode = DICT3;
+    case DICT3:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 16;
+      z->state->mode = DICT2;
+    case DICT2:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 8;
+      z->state->mode = DICT1;
+    case DICT1:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE;
+      z->adler = z->state->sub.check.need;
+      z->state->mode = DICT0;
+      return Z_NEED_DICT;
+    case DICT0:
+      z->state->mode = BAD;
+      z->msg = (char*)"need dictionary";
+      z->state->sub.marker = 0;       /* can try inflateSync */
+      return Z_STREAM_ERROR;
+    case BLOCKS:
+      r = inflate_blocks(z->state->blocks, z, r);
+      if (r == Z_DATA_ERROR)
+      {
+        z->state->mode = BAD;
+        z->state->sub.marker = 0;       /* can try inflateSync */
+        break;
+      }
+      if (r == Z_OK)
+        r = f;
+      if (r != Z_STREAM_END)
+        return r;
+      r = f;
+      inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
+      if (z->state->nowrap)
+      {
+        z->state->mode = DONE;
+        break;
+      }
+      z->state->mode = CHECK4;
+    case CHECK4:
+      NEEDBYTE
+      z->state->sub.check.need = (uLong)NEXTBYTE << 24;
+      z->state->mode = CHECK3;
+    case CHECK3:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 16;
+      z->state->mode = CHECK2;
+    case CHECK2:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE << 8;
+      z->state->mode = CHECK1;
+    case CHECK1:
+      NEEDBYTE
+      z->state->sub.check.need += (uLong)NEXTBYTE;
+
+      if (z->state->sub.check.was != z->state->sub.check.need)
+      {
+        z->state->mode = BAD;
+        z->msg = (char*)"incorrect data check";
+        z->state->sub.marker = 5;       /* can't try inflateSync */
+        break;
+      }
+      Tracev((stderr, "inflate: zlib check ok\n"));
+      z->state->mode = DONE;
+    case DONE:
+      return Z_STREAM_END;
+    case BAD:
+      return Z_DATA_ERROR;
+    default:
+      return Z_STREAM_ERROR;
+  }
+#ifdef NEED_DUMMY_RETURN
+  return Z_STREAM_ERROR;  /* Some dumb compilers complain without this */
+#endif
+}
+
diff --git a/nx-X11/extras/freetype2/src/gzip/inftrees.c b/nx-X11/extras/freetype2/src/gzip/inftrees.c
new file mode 100644
index 000000000..9002bf5b8
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/inftrees.c
@@ -0,0 +1,462 @@
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#if !defined(BUILDFIXED) && !defined(STDC)
+#  define BUILDFIXED   /* non ANSI compilers may not accept inffixed.h */
+#endif
+
+
+#if 0
+local const char inflate_copyright[] =
+   " inflate 1.1.4 Copyright 1995-2002 Mark Adler ";
+#endif
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/* simplify the use of the inflate_huft type with some defines */
+#define exop word.what.Exop
+#define bits word.what.Bits
+
+
+local int huft_build OF((
+    uIntf *,            /* code lengths in bits */
+    uInt,               /* number of codes */
+    uInt,               /* number of "simple" codes */
+    const uIntf *,      /* list of base values for non-simple codes */
+    const uIntf *,      /* list of extra bits for non-simple codes */
+    inflate_huft * FAR*,/* result: starting table */
+    uIntf *,            /* maximum lookup bits (returns actual) */
+    inflate_huft *,     /* space for trees */
+    uInt *,             /* hufts used in space */
+    uIntf * ));         /* space for values */
+
+/* Tables for deflate from PKZIP's appnote.txt. */
+local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+        /* see note #13 above about 258 */
+local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
+        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */
+local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577};
+local const uInt cpdext[30] = { /* Extra bits for distance codes */
+        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
+        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
+        12, 12, 13, 13};
+
+/*
+   Huffman code decoding is performed using a multi-level table lookup.
+   The fastest way to decode is to simply build a lookup table whose
+   size is determined by the longest code.  However, the time it takes
+   to build this table can also be a factor if the data being decoded
+   is not very long.  The most common codes are necessarily the
+   shortest codes, so those codes dominate the decoding time, and hence
+   the speed.  The idea is you can have a shorter table that decodes the
+   shorter, more probable codes, and then point to subsidiary tables for
+   the longer codes.  The time it costs to decode the longer codes is
+   then traded against the time it takes to make longer tables.
+
+   This results of this trade are in the variables lbits and dbits
+   below.  lbits is the number of bits the first level table for literal/
+   length codes can decode in one step, and dbits is the same thing for
+   the distance codes.  Subsequent tables are also less than or equal to
+   those sizes.  These values may be adjusted either when all of the
+   codes are shorter than that, in which case the longest code length in
+   bits is used, or when the shortest code is *longer* than the requested
+   table size, in which case the length of the shortest code in bits is
+   used.
+
+   There are two different values for the two tables, since they code a
+   different number of possibilities each.  The literal/length table
+   codes 286 possible values, or in a flat code, a little over eight
+   bits.  The distance table codes 30 possible values, or a little less
+   than five bits, flat.  The optimum values for speed end up being
+   about one bit more than those, so lbits is 8+1 and dbits is 5+1.
+   The optimum values may differ though from machine to machine, and
+   possibly even between compilers.  Your mileage may vary.
+ */
+
+
+/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
+#define BMAX 15         /* maximum bit length of any code */
+
+local int huft_build( /* b, n, s, d, e, t, m, hp, hn, v) */
+uIntf *b,               /* code lengths in bits (all assumed <= BMAX) */
+uInt n,                 /* number of codes (assumed <= 288) */
+uInt s,                 /* number of simple-valued codes (0..s-1) */
+const uIntf *d,         /* list of base values for non-simple codes */
+const uIntf *e,         /* list of extra bits for non-simple codes */
+inflate_huft * FAR *t,  /* result: starting table */
+uIntf *m,               /* maximum lookup bits, returns actual */
+inflate_huft *hp,       /* space for trees */
+uInt *hn,               /* hufts used in space */
+uIntf *v                /* working area: values in order of bit length */
+/* Given a list of code lengths and a maximum table size, make a set of
+   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+   if the given code set is incomplete (the tables are still built in this
+   case), or Z_DATA_ERROR if the input is invalid. */
+)
+{
+
+  uInt a;                       /* counter for codes of length k */
+  uInt c[BMAX+1];               /* bit length count table */
+  uInt f;                       /* i repeats in table every f entries */
+  int g;                        /* maximum code length */
+  int h;                        /* table level */
+  register uInt i;              /* counter, current code */
+  register uInt j;              /* counter */
+  register int k;               /* number of bits in current code */
+  int l;                        /* bits per table (returned in m) */
+  uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */
+  register uIntf *p;            /* pointer into c[], b[], or v[] */
+  inflate_huft *q;              /* points to current table */
+  struct inflate_huft_s r;      /* table entry for structure assignment */
+  inflate_huft *u[BMAX];        /* table stack */
+  register int w;               /* bits before this table == (l * h) */
+  uInt x[BMAX+1];               /* bit offsets, then code stack */
+  uIntf *xp;                    /* pointer into x */
+  int y;                        /* number of dummy codes added */
+  uInt z;                       /* number of entries in current table */
+
+
+  /* Generate counts for each bit length */
+  p = c;
+#define C0 *p++ = 0;
+#define C2 C0 C0 C0 C0
+#define C4 C2 C2 C2 C2
+  C4                            /* clear c[]--assume BMAX+1 is 16 */
+  p = b;  i = n;
+  do {
+    c[*p++]++;                  /* assume all entries <= BMAX */
+  } while (--i);
+  if (c[0] == n)                /* null input--all zero length codes */
+  {
+    *t = (inflate_huft *)Z_NULL;
+    *m = 0;
+    return Z_OK;
+  }
+
+
+  /* Find minimum and maximum length, bound *m by those */
+  l = *m;
+  for (j = 1; j <= BMAX; j++)
+    if (c[j])
+      break;
+  k = j;                        /* minimum code length */
+  if ((uInt)l < j)
+    l = j;
+  for (i = BMAX; i; i--)
+    if (c[i])
+      break;
+  g = i;                        /* maximum code length */
+  if ((uInt)l > i)
+    l = i;
+  *m = l;
+
+
+  /* Adjust last length count to fill out codes, if needed */
+  for (y = 1 << j; j < i; j++, y <<= 1)
+    if ((y -= c[j]) < 0)
+      return Z_DATA_ERROR;
+  if ((y -= c[i]) < 0)
+    return Z_DATA_ERROR;
+  c[i] += y;
+
+
+  /* Generate starting offsets into the value table for each length */
+  x[1] = j = 0;
+  p = c + 1;  xp = x + 2;
+  while (--i) {                 /* note that i == g from above */
+    *xp++ = (j += *p++);
+  }
+
+
+  /* Make a table of values in order of bit lengths */
+  p = b;  i = 0;
+  do {
+    if ((j = *p++) != 0)
+      v[x[j]++] = i;
+  } while (++i < n);
+  n = x[g];                     /* set n to length of v */
+
+
+  /* Generate the Huffman codes and for each, make the table entries */
+  x[0] = i = 0;                 /* first Huffman code is zero */
+  p = v;                        /* grab values in bit order */
+  h = -1;                       /* no tables yet--level -1 */
+  w = -l;                       /* bits decoded == (l * h) */
+  u[0] = (inflate_huft *)Z_NULL;        /* just to keep compilers happy */
+  q = (inflate_huft *)Z_NULL;   /* ditto */
+  z = 0;                        /* ditto */
+
+  /* go through the bit lengths (k already is bits in shortest code) */
+  for (; k <= g; k++)
+  {
+    a = c[k];
+    while (a--)
+    {
+      /* here i is the Huffman code of length k bits for value *p */
+      /* make tables up to required level */
+      while (k > w + l)
+      {
+        h++;
+        w += l;                 /* previous table always l bits */
+
+        /* compute minimum size table less than or equal to l bits */
+        z = g - w;
+        z = z > (uInt)l ? (uInt)l : z;        /* table size upper limit */
+        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */
+        {                       /* too few codes for k-w bit table */
+          f -= a + 1;           /* deduct codes from patterns left */
+          xp = c + k;
+          if (j < z)
+            while (++j < z)     /* try smaller tables up to z bits */
+            {
+              if ((f <<= 1) <= *++xp)
+                break;          /* enough codes to use up j bits */
+              f -= *xp;         /* else deduct codes from patterns */
+            }
+        }
+        z = 1 << j;             /* table entries for j-bit table */
+
+        /* allocate new table */
+        if (*hn + z > MANY)     /* (note: doesn't matter for fixed) */
+          return Z_DATA_ERROR;  /* overflow of MANY */
+        u[h] = q = hp + *hn;
+        *hn += z;
+
+        /* connect to last table, if there is one */
+        if (h)
+        {
+          x[h] = i;             /* save pattern for backing up */
+          r.bits = (Byte)l;     /* bits to dump before this table */
+          r.exop = (Byte)j;     /* bits in this table */
+          j = i >> (w - l);
+          r.base = (uInt)(q - u[h-1] - j);   /* offset to this table */
+          u[h-1][j] = r;        /* connect to last table */
+        }
+        else
+          *t = q;               /* first table is returned result */
+      }
+
+      /* set up table entry in r */
+      r.bits = (Byte)(k - w);
+      if (p >= v + n)
+        r.exop = 128 + 64;      /* out of values--invalid code */
+      else if (*p < s)
+      {
+        r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     /* 256 is end-of-block */
+        r.base = *p++;          /* simple code is just the value */
+      }
+      else
+      {
+        r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */
+        r.base = d[*p++ - s];
+      }
+
+      /* fill code-like entries with r */
+      f = 1 << (k - w);
+      for (j = i >> w; j < z; j += f)
+        q[j] = r;
+
+      /* backwards increment the k-bit code i */
+      for (j = 1 << (k - 1); i & j; j >>= 1)
+        i ^= j;
+      i ^= j;
+
+      /* backup over finished tables */
+      mask = (1 << w) - 1;      /* needed on HP, cc -O bug */
+      while ((i & mask) != x[h])
+      {
+        h--;                    /* don't need to update q */
+        w -= l;
+        mask = (1 << w) - 1;
+      }
+    }
+  }
+
+
+  /* Return Z_BUF_ERROR if we were given an incomplete table */
+  return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
+}
+
+
+local int inflate_trees_bits( /* c, bb, tb, hp, z) */
+uIntf *c,               /* 19 code lengths */
+uIntf *bb,              /* bits tree desired/actual depth */
+inflate_huft * FAR *tb, /* bits tree result */
+inflate_huft *hp,       /* space for trees */
+z_streamp z             /* for messages */
+)
+{
+  int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,
+                 tb, bb, hp, &hn, v);
+  if (r == Z_DATA_ERROR)
+    z->msg = (char*)"oversubscribed dynamic bit lengths tree";
+  else if (r == Z_BUF_ERROR || *bb == 0)
+  {
+    z->msg = (char*)"incomplete dynamic bit lengths tree";
+    r = Z_DATA_ERROR;
+  }
+  ZFREE(z, v);
+  return r;
+}
+
+
+local int inflate_trees_dynamic( /* nl, nd, c, bl, bd, tl, td, hp, z) */
+uInt nl,                /* number of literal/length codes */
+uInt nd,                /* number of distance codes */
+uIntf *c,               /* that many (total) code lengths */
+uIntf *bl,              /* literal desired/actual bit depth */
+uIntf *bd,              /* distance desired/actual bit depth */
+inflate_huft * FAR *tl, /* literal/length tree result */
+inflate_huft * FAR *td, /* distance tree result */
+inflate_huft *hp,       /* space for trees */
+z_streamp z             /* for messages */
+)
+{
+  int r;
+  uInt hn = 0;          /* hufts used in space */
+  uIntf *v;             /* work area for huft_build */
+
+  /* allocate work area */
+  if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    return Z_MEM_ERROR;
+
+  /* build literal/length tree */
+  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
+  if (r != Z_OK || *bl == 0)
+  {
+    if (r == Z_DATA_ERROR)
+      z->msg = (char*)"oversubscribed literal/length tree";
+    else if (r != Z_MEM_ERROR)
+    {
+      z->msg = (char*)"incomplete literal/length tree";
+      r = Z_DATA_ERROR;
+    }
+    ZFREE(z, v);
+    return r;
+  }
+
+  /* build distance tree */
+  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
+  if (r != Z_OK || (*bd == 0 && nl > 257))
+  {
+    if (r == Z_DATA_ERROR)
+      z->msg = (char*)"oversubscribed distance tree";
+    else if (r == Z_BUF_ERROR) {
+#ifdef PKZIP_BUG_WORKAROUND
+      r = Z_OK;
+    }
+#else
+      z->msg = (char*)"incomplete distance tree";
+      r = Z_DATA_ERROR;
+    }
+    else if (r != Z_MEM_ERROR)
+    {
+      z->msg = (char*)"empty distance tree with lengths";
+      r = Z_DATA_ERROR;
+    }
+    ZFREE(z, v);
+    return r;
+#endif
+  }
+
+  /* done */
+  ZFREE(z, v);
+  return Z_OK;
+}
+
+
+/* build fixed tables only once--keep them here */
+#ifdef BUILDFIXED
+local int fixed_built = 0;
+#define FIXEDH 544      /* number of hufts used by fixed tables */
+local inflate_huft fixed_mem[FIXEDH];
+local uInt fixed_bl;
+local uInt fixed_bd;
+local inflate_huft *fixed_tl;
+local inflate_huft *fixed_td;
+#else
+#include "inffixed.h"
+#endif
+
+
+local int inflate_trees_fixed( /* bl, bd, tl, td, z) */
+uIntf *bl,                      /* literal desired/actual bit depth */
+uIntf *bd,                      /* distance desired/actual bit depth */
+const inflate_huft * FAR *tl,   /* literal/length tree result */
+const inflate_huft * FAR *td,   /* distance tree result */
+z_streamp z                     /* for memory allocation */
+)
+{
+#ifdef BUILDFIXED
+  /* build fixed tables if not already */
+  if (!fixed_built)
+  {
+    int k;              /* temporary variable */
+    uInt f = 0;         /* number of hufts used in fixed_mem */
+    uIntf *c;           /* length list for huft_build */
+    uIntf *v;           /* work area for huft_build */
+
+    /* allocate memory */
+    if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+      return Z_MEM_ERROR;
+    if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
+    {
+      ZFREE(z, c);
+      return Z_MEM_ERROR;
+    }
+
+    /* literal table */
+    for (k = 0; k < 144; k++)
+      c[k] = 8;
+    for (; k < 256; k++)
+      c[k] = 9;
+    for (; k < 280; k++)
+      c[k] = 7;
+    for (; k < 288; k++)
+      c[k] = 8;
+    fixed_bl = 9;
+    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,
+               fixed_mem, &f, v);
+
+    /* distance table */
+    for (k = 0; k < 30; k++)
+      c[k] = 5;
+    fixed_bd = 5;
+    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,
+               fixed_mem, &f, v);
+
+    /* done */
+    ZFREE(z, v);
+    ZFREE(z, c);
+    fixed_built = 1;
+  }
+#else
+  FT_UNUSED(z);
+#endif
+  *bl = fixed_bl;
+  *bd = fixed_bd;
+  *tl = fixed_tl;
+  *td = fixed_td;
+  return Z_OK;
+}
diff --git a/nx-X11/extras/freetype2/src/gzip/inftrees.h b/nx-X11/extras/freetype2/src/gzip/inftrees.h
new file mode 100644
index 000000000..07bf2aa0b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/inftrees.h
@@ -0,0 +1,63 @@
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Huffman code lookup table entry--this entry is four bytes for machines
+   that have 16-bit pointers (e.g. PC's in the small or medium model). */
+
+#ifndef _INFTREES_H
+#define _INFTREES_H
+
+typedef struct inflate_huft_s FAR inflate_huft;
+
+struct inflate_huft_s {
+  union {
+    struct {
+      Byte Exop;        /* number of extra bits or operation */
+      Byte Bits;        /* number of bits in this code or subcode */
+    } what;
+    uInt pad;           /* pad structure to a power of 2 (4 bytes for */
+  } word;               /*  16-bit, 8 bytes for 32-bit int's) */
+  uInt base;            /* literal, length base, distance base,
+                           or table offset */
+};
+
+/* Maximum size of dynamic tree.  The maximum found in a long but non-
+   exhaustive search was 1004 huft structures (850 for length/literals
+   and 154 for distances, the latter actually the result of an
+   exhaustive search).  The actual maximum is not known, but the
+   value below is more than safe. */
+#define MANY 1440
+
+local  int inflate_trees_bits OF((
+    uIntf *,                    /* 19 code lengths */
+    uIntf *,                    /* bits tree desired/actual depth */
+    inflate_huft * FAR *,       /* bits tree result */
+    inflate_huft *,             /* space for trees */
+    z_streamp));                /* for messages */
+
+local  int inflate_trees_dynamic OF((
+    uInt,                       /* number of literal/length codes */
+    uInt,                       /* number of distance codes */
+    uIntf *,                    /* that many (total) code lengths */
+    uIntf *,                    /* literal desired/actual bit depth */
+    uIntf *,                    /* distance desired/actual bit depth */
+    inflate_huft * FAR *,       /* literal/length tree result */
+    inflate_huft * FAR *,       /* distance tree result */
+    inflate_huft *,             /* space for trees */
+    z_streamp));                /* for messages */
+
+local  int inflate_trees_fixed OF((
+    uIntf *,                    /* literal desired/actual bit depth */
+    uIntf *,                    /* distance desired/actual bit depth */
+    const inflate_huft * FAR *, /* literal/length tree result */
+    const inflate_huft * FAR *, /* distance tree result */
+    z_streamp));                /* for memory allocation */
+
+#endif /* _INFTREES_H */
diff --git a/nx-X11/extras/freetype2/src/gzip/infutil.c b/nx-X11/extras/freetype2/src/gzip/infutil.c
new file mode 100644
index 000000000..6087b4064
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/infutil.c
@@ -0,0 +1,86 @@
+/* inflate_util.c -- data and routines common to blocks and codes
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "infblock.h"
+#include "inftrees.h"
+#include "infcodes.h"
+#include "infutil.h"
+
+
+/* And'ing with mask[n] masks the lower n bits */
+local const uInt inflate_mask[17] = {
+    0x0000,
+    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
+    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
+};
+
+
+/* copy as much as possible from the sliding window to the output area */
+local int inflate_flush( /* s, z, r) */
+inflate_blocks_statef *s,
+z_streamp z,
+int r )
+{
+  uInt n;
+  Bytef *p;
+  Bytef *q;
+
+  /* local copies of source and destination pointers */
+  p = z->next_out;
+  q = s->read;
+
+  /* compute number of bytes to copy as far as end of window */
+  n = (uInt)((q <= s->write ? s->write : s->end) - q);
+  if (n > z->avail_out) n = z->avail_out;
+  if (n && r == Z_BUF_ERROR) r = Z_OK;
+
+  /* update counters */
+  z->avail_out -= n;
+  z->total_out += n;
+
+  /* update check information */
+  if (s->checkfn != Z_NULL)
+    z->adler = s->check = (*s->checkfn)(s->check, q, n);
+
+  /* copy as far as end of window */
+  zmemcpy(p, q, n);
+  p += n;
+  q += n;
+
+  /* see if more to copy at beginning of window */
+  if (q == s->end)
+  {
+    /* wrap pointers */
+    q = s->window;
+    if (s->write == s->end)
+      s->write = s->window;
+
+    /* compute bytes to copy */
+    n = (uInt)(s->write - q);
+    if (n > z->avail_out) n = z->avail_out;
+    if (n && r == Z_BUF_ERROR) r = Z_OK;
+
+    /* update counters */
+    z->avail_out -= n;
+    z->total_out += n;
+
+    /* update check information */
+    if (s->checkfn != Z_NULL)
+      z->adler = s->check = (*s->checkfn)(s->check, q, n);
+
+    /* copy */
+    zmemcpy(p, q, n);
+    p += n;
+    q += n;
+  }
+
+  /* update pointers */
+  z->next_out = p;
+  s->read = q;
+
+  /* done */
+  return r;
+}
diff --git a/nx-X11/extras/freetype2/src/gzip/infutil.h b/nx-X11/extras/freetype2/src/gzip/infutil.h
new file mode 100644
index 000000000..7174b6dd0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/infutil.h
@@ -0,0 +1,98 @@
+/* infutil.h -- types and macros common to blocks and codes
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+#ifndef _INFUTIL_H
+#define _INFUTIL_H
+
+typedef enum {
+      TYPE,     /* get type bits (3, including end bit) */
+      LENS,     /* get lengths for stored */
+      STORED,   /* processing stored block */
+      TABLE,    /* get table lengths */
+      BTREE,    /* get bit lengths tree for a dynamic block */
+      DTREE,    /* get length, distance trees for a dynamic block */
+      CODES,    /* processing fixed or dynamic block */
+      DRY,      /* output remaining window bytes */
+      DONE,     /* finished last block, done */
+      BAD}      /* got a data error--stuck here */
+inflate_block_mode;
+
+/* inflate blocks semi-private state */
+struct inflate_blocks_state {
+
+  /* mode */
+  inflate_block_mode  mode;     /* current inflate_block mode */
+
+  /* mode dependent information */
+  union {
+    uInt left;          /* if STORED, bytes left to copy */
+    struct {
+      uInt table;               /* table lengths (14 bits) */
+      uInt index;               /* index into blens (or border) */
+      uIntf *blens;             /* bit lengths of codes */
+      uInt bb;                  /* bit length tree depth */
+      inflate_huft *tb;         /* bit length decoding tree */
+    } trees;            /* if DTREE, decoding info for trees */
+    struct {
+      inflate_codes_statef
+         *codes;
+    } decode;           /* if CODES, current state */
+  } sub;                /* submode */
+  uInt last;            /* true if this block is the last block */
+
+  /* mode independent information */
+  uInt bitk;            /* bits in bit buffer */
+  uLong bitb;           /* bit buffer */
+  inflate_huft *hufts;  /* single malloc for tree space */
+  Bytef *window;        /* sliding window */
+  Bytef *end;           /* one byte after sliding window */
+  Bytef *read;          /* window read pointer */
+  Bytef *write;         /* window write pointer */
+  check_func checkfn;   /* check function */
+  uLong check;          /* check on output */
+
+};
+
+
+/* defines for inflate input/output */
+/*   update pointers and return */
+#define UPDBITS {s->bitb=b;s->bitk=k;}
+#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;}
+#define UPDOUT {s->write=q;}
+#define UPDATE {UPDBITS UPDIN UPDOUT}
+#define LEAVE {UPDATE return inflate_flush(s,z,r);}
+/*   get bytes and bits */
+#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}
+#define NEEDBYTE {if(n)r=Z_OK;else LEAVE}
+#define NEXTBYTE (n--,*p++)
+#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}
+#define DUMPBITS(j) {b>>=(j);k-=(j);}
+/*   output bytes */
+#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q)
+#define LOADOUT {q=s->write;m=(uInt)WAVAIL;}
+#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}
+#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
+#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;}
+#define OUTBYTE(a) {*q++=(Byte)(a);m--;}
+/*   load local pointers */
+#define LOAD {LOADIN LOADOUT}
+
+/* masks for lower bits (size given to avoid silly warnings with Visual C++) */
+#ifndef NO_INFLATE_MASK
+local uInt inflate_mask[17];
+#endif
+
+/* copy as much as possible from the sliding window to the output area */
+local int inflate_flush OF((
+    inflate_blocks_statef *,
+    z_streamp ,
+    int));
+
+#endif
diff --git a/nx-X11/extras/freetype2/src/gzip/rules.mk b/nx-X11/extras/freetype2/src/gzip/rules.mk
new file mode 100644
index 000000000..d2a43a6a8
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/rules.mk
@@ -0,0 +1,75 @@
+#
+# FreeType 2 GZip support configuration rules
+#
+
+
+# Copyright 2002, 2003 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.
+
+
+# gzip driver directory
+#
+GZIP_DIR := $(SRC_DIR)/gzip
+
+
+# compilation flags for the driver
+#
+ifeq ($(SYSTEM_ZLIB),)
+  GZIP_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(GZIP_DIR))
+else
+  GZIP_COMPILE := $(FT_COMPILE)
+endif
+
+
+# gzip support sources (i.e., C files)
+#
+GZIP_DRV_SRC := $(GZIP_DIR)/ftgzip.c
+
+# gzip support headers
+#
+GZIP_DRV_H :=
+
+
+# gzip driver object(s)
+#
+#   GZIP_DRV_OBJ_M is used during `multi' builds
+#   GZIP_DRV_OBJ_S is used during `single' builds
+#
+ifeq ($(SYSTEM_ZLIB),)
+  GZIP_DRV_OBJ_M := $(GZIP_DRV_SRC:$(GZIP_DIR)/%.c=$(OBJ_DIR)/%.$O)
+else
+  GZIP_DRV_OBJ_M := $(OBJ_DIR)/ftgzip.$O
+endif
+GZIP_DRV_OBJ_S := $(OBJ_DIR)/ftgzip.$O
+
+# gzip support source file for single build
+#
+GZIP_DRV_SRC_S := $(GZIP_DIR)/ftgzip.c
+
+
+# gzip support - single object
+#
+$(GZIP_DRV_OBJ_S): $(GZIP_DRV_SRC_S) $(GZIP_DRV_SRC) $(FREETYPE_H) \
+                   $(GZIP_DRV_H)
+	$(GZIP_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(GZIP_DRV_SRC_S))
+
+
+# gzip support - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(GZIP_DIR)/%.c $(FREETYPE_H) $(GZIP_DRV_H)
+	$(GZIP_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(GZIP_DRV_OBJ_S)
+DRV_OBJS_M += $(GZIP_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/gzip/zconf.h b/nx-X11/extras/freetype2/src/gzip/zconf.h
new file mode 100644
index 000000000..271d3386a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/zconf.h
@@ -0,0 +1,278 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id: zconf.h,v 1.1.1.3 2004/03/14 08:28:54 eich Exp $ */
+
+#ifndef _ZCONF_H
+#define _ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+#  define deflateInit_	z_deflateInit_
+#  define deflate	z_deflate
+#  define deflateEnd	z_deflateEnd
+#  define inflateInit_ 	z_inflateInit_
+#  define inflate	z_inflate
+#  define inflateEnd	z_inflateEnd
+#  define deflateInit2_	z_deflateInit2_
+#  define deflateSetDictionary z_deflateSetDictionary
+#  define deflateCopy	z_deflateCopy
+#  define deflateReset	z_deflateReset
+#  define deflateParams	z_deflateParams
+#  define inflateInit2_	z_inflateInit2_
+#  define inflateSetDictionary z_inflateSetDictionary
+#  define inflateSync	z_inflateSync
+#  define inflateSyncPoint z_inflateSyncPoint
+#  define inflateReset	z_inflateReset
+#  define compress	z_compress
+#  define compress2	z_compress2
+#  define uncompress	z_uncompress
+#  define adler32	z_adler32
+#  define crc32		z_crc32
+#  define get_crc_table z_get_crc_table
+
+#  define Byte		z_Byte
+#  define uInt		z_uInt
+#  define uLong		z_uLong
+#  define Bytef	        z_Bytef
+#  define charf		z_charf
+#  define intf		z_intf
+#  define uIntf		z_uIntf
+#  define uLongf	z_uLongf
+#  define voidpf	z_voidpf
+#  define voidp		z_voidp
+#endif
+
+#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
+#  define WIN32
+#endif
+#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
+#  ifndef __32BIT__
+#    define __32BIT__
+#  endif
+#endif
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#if defined(MSDOS) && !defined(__32BIT__)
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32))  && !defined(STDC)
+#  define STDC
+#endif
+#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__)
+#  ifndef STDC
+#    define STDC
+#  endif
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Old Borland C and LCC incorrectly complains about missing returns: */
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
+#  define NEED_DUMMY_RETURN
+#endif
+
+#if defined(__LCC__)
+#  define  NEED_DUMMY_RETURN
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
+   /* MSC small or medium model */
+#  define SMALL_MEDIUM
+#  ifdef _MSC_VER
+#    define FAR _far
+#  else
+#    define FAR far
+#  endif
+#endif
+#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
+#  ifndef __32BIT__
+#    define SMALL_MEDIUM
+#    define FAR _far
+#  endif
+#endif
+
+/* Compile with -DZLIB_DLL for Windows DLL support */
+#if defined(ZLIB_DLL)
+#  if defined(_WINDOWS) || defined(WINDOWS)
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+#    define ZEXPORT(x)  x WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA(x)  x WINAPIV
+#    else
+#      define ZEXPORTVA(x)  x FAR _cdecl _export
+#    endif
+#  endif
+#  if defined (__BORLANDC__)
+#    if (__BORLANDC__ >= 0x0500) && defined (WIN32)
+#      include <windows.h>
+#      define ZEXPORT(x) x __declspec(dllexport) WINAPI
+#      define ZEXPORTRVA(x)  x __declspec(dllexport) WINAPIV
+#    else
+#      if defined (_Windows) && defined (__DLL__)
+#        define ZEXPORT(x) x _export
+#        define ZEXPORTVA(x) x _export
+#      endif
+#    endif
+#  endif
+#endif
+
+
+#ifndef ZEXPORT
+#  define ZEXPORT(x)   static x
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA(x)   static x
+#endif
+#ifndef ZEXTERN
+#  define ZEXTERN(x) static x
+#endif
+#ifndef ZEXTERNDEF
+#  define ZEXTERNDEF(x)  static x
+#endif
+
+#ifndef FAR
+#   define FAR
+#endif
+
+#if !defined(MACOS) && !defined(TARGET_OS_MAC)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void FAR *voidpf;
+   typedef void     *voidp;
+#else
+   typedef Byte FAR *voidpf;
+   typedef Byte     *voidp;
+#endif
+
+#ifdef HAVE_UNISTD_H
+#  include <sys/types.h> /* for off_t */
+#  include <unistd.h>    /* for SEEK_* and off_t */
+#  define z_off_t  off_t
+#endif
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+#  define  z_off_t long
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#   pragma map(deflateInit_,"DEIN")
+#   pragma map(deflateInit2_,"DEIN2")
+#   pragma map(deflateEnd,"DEEND")
+#   pragma map(inflateInit_,"ININ")
+#   pragma map(inflateInit2_,"ININ2")
+#   pragma map(inflateEnd,"INEND")
+#   pragma map(inflateSync,"INSY")
+#   pragma map(inflateSetDictionary,"INSEDI")
+#   pragma map(inflate_blocks,"INBL")
+#   pragma map(inflate_blocks_new,"INBLNE")
+#   pragma map(inflate_blocks_free,"INBLFR")
+#   pragma map(inflate_blocks_reset,"INBLRE")
+#   pragma map(inflate_codes_free,"INCOFR")
+#   pragma map(inflate_codes,"INCO")
+#   pragma map(inflate_fast,"INFA")
+#   pragma map(inflate_flush,"INFLU")
+#   pragma map(inflate_mask,"INMA")
+#   pragma map(inflate_set_dictionary,"INSEDI2")
+#   pragma map(inflate_copyright,"INCOPY")
+#   pragma map(inflate_trees_bits,"INTRBI")
+#   pragma map(inflate_trees_dynamic,"INTRDY")
+#   pragma map(inflate_trees_fixed,"INTRFI")
+#   pragma map(inflate_trees_free,"INTRFR")
+#endif
+
+#endif /* _ZCONF_H */
diff --git a/nx-X11/extras/freetype2/src/gzip/zlib.h b/nx-X11/extras/freetype2/src/gzip/zlib.h
new file mode 100644
index 000000000..50d0d3f14
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/zlib.h
@@ -0,0 +1,830 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.1.4, March 11th, 2002
+
+  Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef _ZLIB_H
+#define _ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.1.4"
+
+/*
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: ascii or binary */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+/* Allowed flush values; see deflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_ASCII    1
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+
+                        /* basic functions */
+
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+   This check is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN(int)  deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression. The fields
+   zalloc, zfree and opaque must be initialized before by the caller.
+   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+   use default allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at
+   all (the input data is simply copied a block at a time).
+   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+   compression (currently equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).
+   msg is set to null if there is no error message.  deflateInit does not
+   perform any compression: this will be done by deflate().
+*/
+
+
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may introduce some
+  output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows. deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly. This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).
+    Some output may be provided even if flush is not set.
+
+  Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating avail_in or avail_out accordingly; avail_out
+  should never be zero before the call. The application can consume the
+  compressed output when it wants, for example when the output buffer is full
+  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+  and with zero avail_out, it must be called again after making room in the
+  output buffer because there might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far. (In particular
+  avail_in is zero after the call if enough output space has been provided
+  before the call.)  Flushing may degrade compression for some compression
+  algorithms and so it should be used only when necessary.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+  the compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there
+  was enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error. After
+  deflate has returned Z_STREAM_END, the only possible operations on the
+  stream are deflateReset or deflateEnd.
+
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step. In this case, avail_out must be at least
+  0.1% larger than avail_in plus 12 bytes.  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update data_type if it can make a good guess about
+  the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
+  binary. This field is only for information purposes and does not affect
+  the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).
+*/
+
+
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded). In the error case,
+   msg may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN(int)  inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression. The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+   value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller.  msg is set to null if there is no error
+   message. inflateInit does not perform any decompression apart from reading
+   the zlib header if present: this will be done by inflate().  (So next_in and
+   avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN(int) inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full. It may some
+  introduce some output latency (reading input without producing any output)
+  except when forced to flush.
+
+  The detailed semantics are as follows. inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there
+    is no more input data or no more space in the output buffer (see below
+    about the flush parameter).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+  must be called again after making room in the output buffer because there
+  might be more output pending.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
+  output as possible to the output buffer. The flushing behavior of inflate is
+  not specified for values of the flush parameter other than Z_SYNC_FLUSH
+  and Z_FINISH, but the current implementation actually flushes as much output
+  as possible anyway.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster routine
+  may be used for the single inflate() call.
+
+     If a preset dictionary is needed at this point (see inflateSetDictionary
+  below), inflate sets strm-adler to the adler32 checksum of the
+  dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise
+  it sets strm->adler to the adler32 checksum of all output produced
+  so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
+  an error code as described below. At the end of the stream, inflate()
+  checks that its computed adler32 checksum is equal to that saved by the
+  compressor and returns Z_STREAM_END only if the checksum is correct.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect
+  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
+  (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
+  enough memory, Z_BUF_ERROR if no progress is possible or if there was not
+  enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
+  case, the application may then call inflateSync to look for a good
+  compression block.
+*/
+
+
+ZEXTERN(int)  inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN(int)  deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options. The
+   fields next_in, zalloc, zfree and opaque must be initialized before by
+   the caller.
+
+     The method parameter is the compression method. It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library. Larger values of this parameter result in better
+   compression at the expense of memory usage. The default value is 15 if
+   deflateInit is used instead.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state. memLevel=1 uses minimum memory but
+   is slow and reduces compression ratio; memLevel=9 uses maximum memory
+   for optimal speed. The default value is 8. See zconf.h for total memory
+   usage as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm. Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match).  Filtered data consists mostly of small values with a
+   somewhat random distribution. In this case, the compression algorithm is
+   tuned to compress them better. The effect of Z_FILTERED is to force more
+   Huffman coding and less string matching; it is somewhat intermediate
+   between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
+   the compression ratio but not the correctness of the compressed output even
+   if it is not set appropriately.
+
+      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+   method). msg is set to null if there is no error message.  deflateInit2 does
+   not perform any compression: this will be done by deflate().
+*/
+
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output. This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any
+   call of deflate. The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary. Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size in
+   deflate or deflate2. Thus the strings most likely to be useful should be
+   put at the end of the dictionary, not at the front.
+
+     Upon return of this function, strm->adler is set to the Adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor. (The Adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.)
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort). deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter. The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and
+   can consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being NULL). msg is left unchanged in both source and
+   destination.
+*/
+
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.
+   The stream will keep the same compression level and any other attributes
+   that may have been set by deflateInit2.
+
+      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different
+   strategy. If the compression level is changed, the input available so far
+   is compressed with the old level (and may be flushed); the new level will
+   take effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to
+   be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+   if strm->avail_out was zero.
+*/
+
+/*
+ZEXTERN(int)  inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter. The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library. The default value is 15 if inflateInit is used
+   instead. If a compressed stream with a larger window size is given as
+   input, inflate() will return with the error code Z_DATA_ERROR instead of
+   trying to allocate a larger window.
+
+      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
+   memLevel). msg is set to null if there is no error message.  inflateInit2
+   does not perform any decompression apart from reading the zlib header if
+   present: this will be done by inflate(). (So next_in and avail_in may be
+   modified, but next_out and avail_out are unchanged.)
+*/
+
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence. This function must be called immediately after a call of inflate
+   if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the Adler32 value returned by this call of
+   inflate. The compressor and decompressor must use exactly the same
+   dictionary (see deflateSetDictionary).
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (such as NULL dictionary) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler32 value). inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+/*
+    Skips invalid compressed data until a full flush point (see above the
+  description of deflate with Z_FULL_FLUSH) can be found, or until all
+  available input is skipped. No output is provided.
+
+    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+ZEXTERN(int)  inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the
+   basic stream-oriented functions. To simplify the interface, some
+   default options are assumed (compression level and memory usage,
+   standard memory allocation functions). The source code of these
+   utility functions can easily be modified if you need special options.
+*/
+
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be at least 0.1% larger than
+   sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
+   compressed buffer.
+     This function can be used to compress a whole file at once if the
+   input file is mmap'ed.
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+/*
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer. Upon entry, destLen is the total
+   size of the destination buffer, which must be large enough to hold the
+   entire uncompressed data. (The size of the uncompressed data must have
+   been saved previously by the compressor and transmitted to the decompressor
+   by some mechanism outside the scope of this compression library.)
+   Upon exit, destLen is the actual size of the compressed buffer.
+     This function can be used to decompress a whole file at once if the
+   input file is mmap'ed.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted.
+*/
+
+
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h". (See the description
+   of deflateInit2 for more information about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+/*
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the
+   compression library.
+*/
+
+ZEXTERN(uLong)  adler32 OF((uLong adler, const Bytef *buf, uInt len));
+
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+/*
+     Update a running crc with the bytes buf[0..len-1] and return the updated
+   crc. If buf is NULL, this function returns the required initial value
+   for the crc. Pre- and post-conditioning (one's complement) is performed
+   within this function so it shouldn't be done by the application.
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN(int)  inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ZLIB_H */
diff --git a/nx-X11/extras/freetype2/src/gzip/zutil.c b/nx-X11/extras/freetype2/src/gzip/zutil.c
new file mode 100644
index 000000000..7df679c1a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/zutil.c
@@ -0,0 +1,181 @@
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id: zutil.c,v 1.1.1.3 2004/03/14 08:28:54 eich Exp $ */
+
+#include "zutil.h"
+
+#ifndef STDC
+extern void exit OF((int));
+#endif
+
+
+#ifndef HAVE_MEMCPY
+
+void zmemcpy(dest, source, len)
+    Bytef* dest;
+    const Bytef* source;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = *source++; /* ??? to be unrolled */
+    } while (--len != 0);
+}
+
+int zmemcmp(s1, s2, len)
+    const Bytef* s1;
+    const Bytef* s2;
+    uInt  len;
+{
+    uInt j;
+
+    for (j = 0; j < len; j++) {
+        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+    }
+    return 0;
+}
+
+void zmemzero(dest, len)
+    Bytef* dest;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = 0;  /* ??? to be unrolled */
+    } while (--len != 0);
+}
+#endif
+
+#ifdef __TURBOC__
+#if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
+/* Small and medium model in Turbo C are for now limited to near allocation
+ * with reduced MAX_WBITS and MAX_MEM_LEVEL
+ */
+#  define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+    voidpf org_ptr;
+    voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    voidpf buf = opaque; /* just to make some compilers happy */
+    ulg bsize = (ulg)items*size;
+
+    /* If we allocate less than 65520 bytes, we assume that farmalloc
+     * will return a usable pointer which doesn't have to be normalized.
+     */
+    if (bsize < 65520L) {
+        buf = farmalloc(bsize);
+        if (*(ush*)&buf != 0) return buf;
+    } else {
+        buf = farmalloc(bsize + 16L);
+    }
+    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+    table[next_ptr].org_ptr = buf;
+
+    /* Normalize the pointer to seg:0 */
+    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+    *(ush*)&buf = 0;
+    table[next_ptr++].new_ptr = buf;
+    return buf;
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    int n;
+    if (*(ush*)&ptr != 0) { /* object < 64K */
+        farfree(ptr);
+        return;
+    }
+    /* Find the original pointer */
+    for (n = 0; n < next_ptr; n++) {
+        if (ptr != table[n].new_ptr) continue;
+
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
+    }
+    ptr = opaque; /* just to make some compilers happy */
+    Assert(0, "zcfree: ptr not found");
+}
+#endif
+#endif /* __TURBOC__ */
+
+
+#if defined(M_I86) && !defined(__32BIT__)
+/* Microsoft C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+#  define _halloc  halloc
+#  define _hfree   hfree
+#endif
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    return _halloc((long)items, size);
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    _hfree(ptr);
+}
+
+#endif /* MSC */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp  calloc OF((uInt items, uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+
+voidpf zcalloc (opaque, items, size)
+    voidpf opaque;
+    unsigned items;
+    unsigned size;
+{
+    if (opaque) items += size - size; /* make compiler happy */
+    return (voidpf)calloc(items, size);
+}
+
+void  zcfree (opaque, ptr)
+    voidpf opaque;
+    voidpf ptr;
+{
+    free(ptr);
+    if (opaque) return; /* make compiler happy */
+}
+
+#endif /* MY_ZCALLOC */
diff --git a/nx-X11/extras/freetype2/src/gzip/zutil.h b/nx-X11/extras/freetype2/src/gzip/zutil.h
new file mode 100644
index 000000000..247ec8525
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/gzip/zutil.h
@@ -0,0 +1,216 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2002 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id: zutil.h,v 1.3 2004/04/28 10:39:05 gisburn Exp $ */
+
+#ifndef _Z_UTIL_H
+#define _Z_UTIL_H
+
+#include "zlib.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = (char*)ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#ifdef MSDOS
+#  define OS_CODE  0x00
+#  if defined(__TURBOC__) || defined(__BORLANDC__)
+#    if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+       /* Allow compilation with ANSI keywords only enabled */
+       void _Cdecl farfree( void *block );
+       void *_Cdecl farmalloc( unsigned long nbytes );
+#    else
+#     include <alloc.h>
+#    endif
+#  else /* MSC or DJGPP */
+#    include <malloc.h>
+#  endif
+#endif
+
+#ifdef OS2
+#  define OS_CODE  0x06
+#endif
+
+#ifdef WIN32 /* Window 95 & Windows NT */
+#  define OS_CODE  0x0b
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  0x02
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  0x01
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  0x05
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  0x07
+#  if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#    include <unix.h> /* for fdopen */
+#  else
+#    ifndef fdopen
+#      define fdopen(fd,mode) NULL /* No fdopen() */
+#    endif
+#  endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+#  define OS_CODE  0x0F
+#endif
+
+#ifdef TOPS20
+#  define OS_CODE  0x0a
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600))
+#  define fdopen(fd,type)  _fdopen(fd,type)
+#endif
+
+
+        /* Common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03  /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#ifdef HAVE_STRERROR
+   extern char *strerror OF((int));
+#  define zstrerror(errnum) strerror(errnum)
+#else
+#  define zstrerror(errnum) ""
+#endif
+
+#if defined(pyr)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy ft_memcpy
+#    define zmemcmp ft_memcmp
+#    define zmemzero(dest, len) ft_memset(dest, 0, len)
+#  endif
+#else
+   extern void zmemcpy  OF((Bytef* dest, const Bytef* source, uInt len));
+   extern int  zmemcmp  OF((const Bytef* s1, const Bytef* s2, uInt len));
+   extern void zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+#  include <stdio.h>
+   extern int z_verbose;
+   extern void z_error    OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+
+typedef uLong (*check_func) OF((uLong check, const Bytef *buf,
+				       uInt len));
+local voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
+local void   zcfree  OF((voidpf opaque, voidpf ptr));
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+#endif /* _Z_UTIL_H */
diff --git a/nx-X11/extras/freetype2/src/lzw/Jamfile b/nx-X11/extras/freetype2/src/lzw/Jamfile
new file mode 100644
index 000000000..995cbb98c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/lzw/Jamfile
@@ -0,0 +1,9 @@
+# FreeType 2 src/lzw Jamfile (C) 2004 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) lzw ;
+
+Library  $(FT2_LIB) : ftlzw.c ;
+
+# end of src/lzw Jamfile
+
diff --git a/nx-X11/extras/freetype2/src/lzw/ftlzw.c b/nx-X11/extras/freetype2/src/lzw/ftlzw.c
new file mode 100644
index 000000000..a0e4cc576
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/lzw/ftlzw.c
@@ -0,0 +1,463 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftlzw.c                                                                */
+/*                                                                         */
+/*    FreeType support for .Z compressed files.                            */
+/*                                                                         */
+/*  This optional component relies on NetBSD's zopen().  It should mainly  */
+/*  be used to parse compressed PCF fonts, as found with many X11 server   */
+/*  distributions.                                                         */
+/*                                                                         */
+/*  Copyright 2004 by                                                      */
+/*  Albert Chin-A-Young.                                                   */
+/*                                                                         */
+/*  Based on code in src/gzip/ftgzip.c, Copyright 2004 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_MEMORY_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_DEBUG_H
+#include <string.h>
+#include <stdio.h>
+
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  LZW_Err_
+#define FT_ERR_BASE    FT_Mod_Err_LZW
+
+#include FT_ERRORS_H
+
+
+#ifdef FT_CONFIG_OPTION_USE_LZW
+
+#include "zopen.h"
+
+
+/***************************************************************************/
+/***************************************************************************/
+/*****                                                                 *****/
+/*****                  M E M O R Y   M A N A G E M E N T              *****/
+/*****                                                                 *****/
+/***************************************************************************/
+/***************************************************************************/
+
+/***************************************************************************/
+/***************************************************************************/
+/*****                                                                 *****/
+/*****                   F I L E   D E S C R I P T O R                 *****/
+/*****                                                                 *****/
+/***************************************************************************/
+/***************************************************************************/
+
+#define  FT_LZW_BUFFER_SIZE  4096
+
+  typedef struct FT_LZWFileRec_
+  {
+    FT_Stream   source;         /* parent/source stream        */
+    FT_Stream   stream;         /* embedding stream            */
+    FT_Memory   memory;         /* memory allocator            */
+    s_zstate_t  zstream;        /* lzw input stream            */
+
+    FT_ULong    start;          /* starting position, after .Z header */
+    FT_Byte     input[FT_LZW_BUFFER_SIZE];  /* input buffer */
+
+    FT_Byte     buffer[FT_LZW_BUFFER_SIZE]; /* output buffer */
+    FT_ULong    pos;            /* position in output          */
+    FT_Byte*    cursor;
+    FT_Byte*    limit;
+
+  } FT_LZWFileRec, *FT_LZWFile;
+
+
+  /* check and skip .Z header */
+  static FT_Error
+  ft_lzw_check_header( FT_Stream  stream )
+  {
+    FT_Error  error;
+    FT_Byte   head[2];
+
+
+    if ( FT_STREAM_SEEK( 0 )       ||
+         FT_STREAM_READ( head, 2 ) )
+      goto Exit;
+
+    /* head[0] && head[1] are the magic numbers     */
+    if ( head[0] != 0x1f ||
+         head[1] != 0x9d )
+      error = LZW_Err_Invalid_File_Format;
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  ft_lzw_file_init( FT_LZWFile  zip,
+                    FT_Stream   stream,
+                    FT_Stream   source )
+  {
+    s_zstate_t*  zstream = &zip->zstream;
+    FT_Error     error   = LZW_Err_Ok;
+
+
+    zip->stream = stream;
+    zip->source = source;
+    zip->memory = stream->memory;
+
+    zip->limit  = zip->buffer + FT_LZW_BUFFER_SIZE;
+    zip->cursor = zip->limit;
+    zip->pos    = 0;
+
+    /* check and skip .Z header */
+    {
+      stream = source;
+
+      error = ft_lzw_check_header( source );
+      if ( error )
+        goto Exit;
+
+      zip->start = FT_STREAM_POS();
+    }
+
+    /* initialize internal lzw variable */
+    zinit( zstream );
+
+    zstream->avail_in    = 0;
+    zstream->next_in     = zip->buffer;
+    zstream->zs_in_count = source->size - 2;
+
+    if ( zstream->next_in == NULL )
+      error = LZW_Err_Invalid_File_Format;
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  ft_lzw_file_done( FT_LZWFile  zip )
+  {
+    s_zstate_t*  zstream = &zip->zstream;
+
+
+    /* clear the rest */
+    zstream->next_in   = NULL;
+    zstream->next_out  = NULL;
+    zstream->avail_in  = 0;
+    zstream->avail_out = 0;
+    zstream->total_in  = 0;
+    zstream->total_out = 0;
+
+    zip->memory = NULL;
+    zip->source = NULL;
+    zip->stream = NULL;
+  }
+
+
+  static FT_Error
+  ft_lzw_file_reset( FT_LZWFile  zip )
+  {
+    FT_Stream  stream = zip->source;
+    FT_Error   error;
+
+
+    if ( !FT_STREAM_SEEK( zip->start ) )
+    {
+      s_zstate_t*  zstream = &zip->zstream;
+
+
+      zinit( zstream );
+
+      zstream->avail_in    = 0;
+      zstream->next_in     = zip->input;
+      zstream->total_in    = 0;
+      zstream->avail_out   = 0;
+      zstream->next_out    = zip->buffer;
+      zstream->total_out   = 0;
+      zstream->zs_in_count = zip->source->size - 2;
+
+      zip->limit  = zip->buffer + FT_LZW_BUFFER_SIZE;
+      zip->cursor = zip->limit;
+      zip->pos    = 0;
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  ft_lzw_file_fill_input( FT_LZWFile  zip )
+  {
+    s_zstate_t*  zstream = &zip->zstream;
+    FT_Stream    stream  = zip->source;
+    FT_ULong     size;
+
+
+    if ( stream->read )
+    {
+      size = stream->read( stream, stream->pos, zip->input,
+                           FT_LZW_BUFFER_SIZE );
+      if ( size == 0 )
+        return LZW_Err_Invalid_Stream_Operation;
+    }
+    else
+    {
+      size = stream->size - stream->pos;
+      if ( size > FT_LZW_BUFFER_SIZE )
+        size = FT_LZW_BUFFER_SIZE;
+
+      if ( size == 0 )
+        return LZW_Err_Invalid_Stream_Operation;
+
+      FT_MEM_COPY( zip->input, stream->base + stream->pos, size );
+    }
+    stream->pos += size;
+
+    zstream->next_in  = zip->input;
+    zstream->avail_in = size;
+
+    return LZW_Err_Ok;
+  }
+
+
+
+  static FT_Error
+  ft_lzw_file_fill_output( FT_LZWFile  zip )
+  {
+    s_zstate_t*  zstream = &zip->zstream;
+    FT_Error     error   = 0;
+
+
+    zip->cursor        = zip->buffer;
+    zstream->next_out  = zip->cursor;
+    zstream->avail_out = FT_LZW_BUFFER_SIZE;
+
+    while ( zstream->avail_out > 0 )
+    {
+      int  num_read = 0;
+
+
+      if ( zstream->avail_in == 0 )
+      {
+        error = ft_lzw_file_fill_input( zip );
+        if ( error )
+          break;
+      }
+
+      num_read = zread( zstream );
+
+      if ( num_read == -1 && zstream->zs_in_count == 0 )
+      {
+        zip->limit = zstream->next_out;
+        if ( zip->limit == zip->cursor )
+          error = LZW_Err_Invalid_Stream_Operation;
+        break;
+      }
+      else if ( num_read == -1 )
+        break;
+      else
+        zstream->avail_out -= num_read;
+    }
+
+    return error;
+  }
+
+
+  /* fill output buffer; `count' must be <= FT_LZW_BUFFER_SIZE */
+  static FT_Error
+  ft_lzw_file_skip_output( FT_LZWFile  zip,
+                           FT_ULong    count )
+  {
+    FT_Error  error = LZW_Err_Ok;
+    FT_ULong  delta;
+
+
+    for (;;)
+    {
+      delta = (FT_ULong)( zip->limit - zip->cursor );
+      if ( delta >= count )
+        delta = count;
+
+      zip->cursor += delta;
+      zip->pos    += delta;
+
+      count -= delta;
+      if ( count == 0 )
+        break;
+
+      error = ft_lzw_file_fill_output( zip );
+      if ( error )
+        break;
+    }
+
+    return error;
+  }
+
+
+  static FT_ULong
+  ft_lzw_file_io( FT_LZWFile  zip,
+                  FT_ULong    pos,
+                  FT_Byte*    buffer,
+                  FT_ULong    count )
+  {
+    FT_ULong  result = 0;
+    FT_Error  error;
+
+
+    /* Teset inflate stream if we're seeking backwards.        */
+    /* Yes, that is not too efficient, but it saves memory :-) */
+    if ( pos < zip->pos )
+    {
+      error = ft_lzw_file_reset( zip );
+      if ( error )
+        goto Exit;
+    }
+
+    /* skip unwanted bytes */
+    if ( pos > zip->pos )
+    {
+      error = ft_lzw_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) );
+      if ( error )
+        goto Exit;
+    }
+
+    if ( count == 0 )
+      goto Exit;
+
+    /* now read the data */
+    for (;;)
+    {
+      FT_ULong  delta;
+
+
+      delta = (FT_ULong)( zip->limit - zip->cursor );
+      if ( delta >= count )
+        delta = count;
+
+      FT_MEM_COPY( buffer, zip->cursor, delta );
+      buffer      += delta;
+      result      += delta;
+      zip->cursor += delta;
+      zip->pos    += delta;
+
+      count -= delta;
+      if ( count == 0 )
+        break;
+
+      error = ft_lzw_file_fill_output( zip );
+      if ( error )
+        break;
+    }
+
+  Exit:
+    return result;
+  }
+
+
+/***************************************************************************/
+/***************************************************************************/
+/*****                                                                 *****/
+/*****            L Z W   E M B E D D I N G   S T R E A M              *****/
+/*****                                                                 *****/
+/***************************************************************************/
+/***************************************************************************/
+
+  static void
+  ft_lzw_stream_close( FT_Stream  stream )
+  {
+    FT_LZWFile  zip    = (FT_LZWFile)stream->descriptor.pointer;
+    FT_Memory   memory = stream->memory;
+
+
+    if ( zip )
+    {
+      /* finalize lzw file descriptor */
+      ft_lzw_file_done( zip );
+
+      FT_FREE( zip );
+
+      stream->descriptor.pointer = NULL;
+    }
+  }
+
+
+  static FT_ULong
+  ft_lzw_stream_io( FT_Stream  stream,
+                    FT_ULong   pos,
+                    FT_Byte*   buffer,
+                    FT_ULong   count )
+  {
+    FT_LZWFile  zip = (FT_LZWFile)stream->descriptor.pointer;
+
+
+    return ft_lzw_file_io( zip, pos, buffer, count );
+  }
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stream_OpenLZW( FT_Stream  stream,
+                     FT_Stream  source )
+  {
+    FT_Error    error;
+    FT_Memory   memory = source->memory;
+    FT_LZWFile  zip;
+
+
+    FT_ZERO( stream );
+    stream->memory = memory;
+
+    if ( !FT_NEW( zip ) )
+    {
+      error = ft_lzw_file_init( zip, stream, source );
+      if ( error )
+      {
+        FT_FREE( zip );
+        goto Exit;
+      }
+
+      stream->descriptor.pointer = zip;
+    }
+
+    stream->size  = 0x7FFFFFFFL;  /* don't know the real size! */
+    stream->pos   = 0;
+    stream->base  = 0;
+    stream->read  = ft_lzw_stream_io;
+    stream->close = ft_lzw_stream_close;
+
+  Exit:
+    return error;
+  }
+
+#include "zopen.c"
+
+
+#else  /* !FT_CONFIG_OPTION_USE_LZW */
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Stream_OpenLZW( FT_Stream  stream,
+                     FT_Stream  source )
+  {
+    FT_UNUSED( stream );
+    FT_UNUSED( source );
+
+    return LZW_Err_Unimplemented_Feature;
+  }
+
+
+#endif /* !FT_CONFIG_OPTION_USE_LZW */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/lzw/rules.mk b/nx-X11/extras/freetype2/src/lzw/rules.mk
new file mode 100644
index 000000000..73ce71804
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/lzw/rules.mk
@@ -0,0 +1,70 @@
+#
+# FreeType 2 LZW support configuration rules
+#
+
+
+# Copyright 2004 by
+# Albert Chin-A-Young.
+#
+# Based on src/lzw/rules.mk, Copyright 2002 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.
+
+
+# LZW driver directory
+#
+LZW_DIR := $(SRC_DIR)/lzw
+
+
+# compilation flags for the driver
+#
+LZW_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(LZW_DIR))
+
+
+# LZW support sources (i.e., C files)
+#
+LZW_DRV_SRC := $(LZW_DIR)/ftlzw.c \
+               $(LZW_DIR)/zopen.c
+
+# LZW support headers
+#
+LZW_DRV_H := $(LZW_DIR)/zopen.h
+
+
+# LZW driver object(s)
+#
+#   LZW_DRV_OBJ_M is used during `multi' builds
+#   LZW_DRV_OBJ_S is used during `single' builds
+#
+LZW_DRV_OBJ_M := $(OBJ_DIR)/ftlzw.$O
+LZW_DRV_OBJ_S := $(OBJ_DIR)/ftlzw.$O
+
+# LZW support source file for single build
+#
+LZW_DRV_SRC_S := $(LZW_DIR)/ftlzw.c
+
+
+# LZW support - single object
+#
+$(LZW_DRV_OBJ_S): $(LZW_DRV_SRC_S) $(LZW_DRV_SRC) $(FREETYPE_H) $(LZW_DRV_H)
+	$(LZW_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(LZW_DRV_SRC_S))
+
+
+# LZW support - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(LZW_DIR)/%.c $(FREETYPE_H) $(LZW_DRV_H)
+	$(LZW_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(LZW_DRV_OBJ_S)
+DRV_OBJS_M += $(LZW_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/lzw/zopen.c b/nx-X11/extras/freetype2/src/lzw/zopen.c
new file mode 100644
index 000000000..2b438c25b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/lzw/zopen.c
@@ -0,0 +1,400 @@
+/*	$NetBSD: zopen.c,v 1.8 2003/08/07 11:13:29 agc Exp $	*/
+
+/*-
+ * Copyright (c) 1985, 1986, 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Diomidis Spinellis and James A. Woods, derived from original
+ * work by Spencer Thomas and Joseph Orost.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*-
+ *
+ * Copyright (c) 2004
+ *	Albert Chin-A-Young.
+ *
+ * Modified to work with FreeType's PCF driver.
+ *
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)zopen.c	8.1 (Berkeley) 6/27/93";
+#else
+static char rcsid[] = "$NetBSD: zopen.c,v 1.8 2003/08/07 11:13:29 agc Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+/*-
+ * fcompress.c - File compression ala IEEE Computer, June 1984.
+ *
+ * Compress authors:
+ *		Spencer W. Thomas	(decvax!utah-cs!thomas)
+ *		Jim McKie		(decvax!mcvax!jim)
+ *		Steve Davies		(decvax!vax135!petsd!peora!srd)
+ *		Ken Turkowski		(decvax!decwrl!turtlevax!ken)
+ *		James A. Woods		(decvax!ihnp4!ames!jaw)
+ *		Joe Orost		(decvax!vax135!petsd!joe)
+ *
+ * Cleaned up and converted to library returning I/O streams by
+ * Diomidis Spinellis <dds@doc.ic.ac.uk>.
+ */
+
+#include <ctype.h>
+#if 0
+#include <signal.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+#if 0
+#include <unistd.h>
+#endif
+
+#if 0
+static char_type magic_header[] =
+	{ 0x1f, 0x9d };		/* 1F 9D */
+#endif
+
+#define	BIT_MASK	0x1f		/* Defines for third byte of header. */
+#define	BLOCK_MASK	0x80
+
+/*
+ * Masks 0x40 and 0x20 are free.  I think 0x20 should mean that there is
+ * a fourth header byte (for expansion).
+ */
+#define	INIT_BITS 9			/* Initial number of bits/code. */
+
+#define	MAXCODE(n_bits)	((1 << (n_bits)) - 1)
+
+/* Definitions to retain old variable names */
+#define	fp		zs->zs_fp
+#define	state		zs->zs_state
+#define	n_bits		zs->zs_n_bits
+#define	maxbits		zs->zs_maxbits
+#define	maxcode		zs->zs_maxcode
+#define	maxmaxcode	zs->zs_maxmaxcode
+#define	htab		zs->zs_htab
+#define	codetab		zs->zs_codetab
+#define	hsize		zs->zs_hsize
+#define	free_ent	zs->zs_free_ent
+#define	block_compress	zs->zs_block_compress
+#define	clear_flg	zs->zs_clear_flg
+#define	offset		zs->zs_offset
+#define	in_count	zs->zs_in_count
+#define	buf_len		zs->zs_buf_len
+#define	buf		zs->zs_buf
+#define	stackp		zs->u.r.zs_stackp
+#define	finchar		zs->u.r.zs_finchar
+#define	code		zs->u.r.zs_code
+#define	oldcode		zs->u.r.zs_oldcode
+#define	incode		zs->u.r.zs_incode
+#define	roffset		zs->u.r.zs_roffset
+#define	size		zs->u.r.zs_size
+#define	gbuf		zs->u.r.zs_gbuf
+
+/*
+ * To save much memory, we overlay the table used by compress() with those
+ * used by decompress().  The tab_prefix table is the same size and type as
+ * the codetab.  The tab_suffix table needs 2**BITS characters.  We get this
+ * from the beginning of htab.  The output stack uses the rest of htab, and
+ * contains characters.  There is plenty of room for any possible stack
+ * (stack used to be 8000 characters).
+ */
+
+#define	htabof(i)	htab[i]
+#define	codetabof(i)	codetab[i]
+
+#define	tab_prefixof(i)	codetabof(i)
+#define	tab_suffixof(i)	((char_type *)(htab))[i]
+#define	de_stack	((char_type *)&tab_suffixof(1 << BITS))
+
+#define	CHECK_GAP 10000		/* Ratio check interval. */
+
+/*
+ * the next two codes should not be changed lightly, as they must not
+ * lie within the contiguous general code space.
+ */
+#define	FIRST	257		/* First free entry. */
+#define	CLEAR	256		/* Table clear output code. */
+
+/*-
+ * Algorithm from "A Technique for High Performance Data Compression",
+ * Terry A. Welch, IEEE Computer Vol 17, No 6 (June 1984), pp 8-19.
+ *
+ * Algorithm:
+ * 	Modified Lempel-Ziv method (LZW).  Basically finds common
+ * substrings and replaces them with a variable size code.  This is
+ * deterministic, and can be done on the fly.  Thus, the decompression
+ * procedure needs no input table, but tracks the way the table was built.
+ */
+
+#if 0
+static int
+zclose(s_zstate_t *zs)
+{
+	free(zs);
+	return (0);
+}
+#endif
+
+/*-
+ * Output the given code.
+ * Inputs:
+ * 	code:	A n_bits-bit integer.  If == -1, then EOF.  This assumes
+ *		that n_bits =< (long)wordsize - 1.
+ * Outputs:
+ * 	Outputs code to the file.
+ * Assumptions:
+ *	Chars are 8 bits long.
+ * Algorithm:
+ * 	Maintain a BITS character long buffer (so that 8 codes will
+ * fit in it exactly).  Use the VAX insv instruction to insert each
+ * code in turn.  When the buffer fills up empty it and start over.
+ */
+
+static const char_type rmask[9] =
+	{0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
+
+/*
+ * Decompress read.  This routine adapts to the codes in the file building
+ * the "string" table on-the-fly; requiring no table to be stored in the
+ * compressed file.  The tables used herein are shared with those of the
+ * compress() routine.  See the definitions above.
+ */
+static int
+zread(s_zstate_t *zs)
+{
+	unsigned int count;
+
+	if (in_count == 0)
+		return -1;
+	if (zs->avail_out == 0)
+		return 0;
+
+	count = zs->avail_out;
+	switch (state) {
+	case S_START:
+		state = S_MIDDLE;
+		break;
+	case S_MIDDLE:
+		goto middle;
+	case S_EOF:
+		goto eof;
+	}
+
+	maxbits = *(zs->next_in);	/* Set -b from file. */
+	zs->avail_in--;
+	zs->next_in++;
+	zs->total_in++;
+	in_count--;
+	block_compress = maxbits & BLOCK_MASK;
+	maxbits &= BIT_MASK;
+	maxmaxcode = 1L << maxbits;
+	if (maxbits > BITS) {
+		return -1;
+	}
+	/* As above, initialize the first 256 entries in the table. */
+	maxcode = MAXCODE(n_bits = INIT_BITS);
+	for (code = 255; code >= 0; code--) {
+		tab_prefixof(code) = 0;
+		tab_suffixof(code) = (char_type) code;
+	}
+	free_ent = block_compress ? FIRST : 256;
+
+	finchar = oldcode = getcode(zs);
+	if (oldcode == -1)		/* EOF already? */
+		return 0;		/* Get out of here */
+
+	/* First code must be 8 bits = char. */
+	*(zs->next_out)++ = (unsigned char)finchar;
+	zs->total_out++;
+	count--;
+	stackp = de_stack;
+
+	while ((code = getcode(zs)) > -1) {
+		if ((code == CLEAR) && block_compress) {
+			for (code = 255; code >= 0; code--)
+				tab_prefixof(code) = 0;
+			clear_flg = 1;
+			free_ent = FIRST - 1;
+			if ((code = getcode(zs)) == -1)
+				/* O, untimely death! */
+				break;
+		}
+		incode = code;
+
+		/* Special case for KwKwK string. */
+		if (code >= free_ent) {
+			*stackp++ = finchar;
+			code = oldcode;
+		}
+
+		/* Generate output characters in reverse order. */
+		while (code >= 256) {
+			*stackp++ = tab_suffixof(code);
+			code = tab_prefixof(code);
+		}
+		*stackp++ = finchar = tab_suffixof(code);
+
+		/* And put them out in forward order.  */
+middle:
+		if (stackp == de_stack)
+			continue;
+
+		do {
+			if (count-- == 0) {
+				return zs->avail_out;
+			}
+			*(zs->next_out)++ = *--stackp;
+			zs->total_out++;
+		} while (stackp > de_stack);
+
+		/* Generate the new entry. */
+		if ((code = free_ent) < maxmaxcode) {
+			tab_prefixof(code) = (unsigned short) oldcode;
+			tab_suffixof(code) = finchar;
+			free_ent = code + 1;
+		}
+
+		/* Remember previous code. */
+		oldcode = incode;
+	}
+	/* state = S_EOF; */
+eof:	return (zs->avail_out - count);
+}
+
+/*-
+ * Read one code from the standard input.  If EOF, return -1.
+ * Inputs:
+ * 	stdin
+ * Outputs:
+ * 	code or -1 is returned.
+ */
+static code_int
+getcode(s_zstate_t *zs)
+{
+	code_int gcode;
+	int r_off, bits;
+	char_type *bp;
+
+	bp = gbuf;
+	if (clear_flg > 0 || roffset >= size || free_ent > maxcode) {
+		/*
+		 * If the next entry will be too big for the current gcode
+		 * size, then we must increase the size.  This implies reading
+		 * a new buffer full, too.
+		 */
+		if (free_ent > maxcode) {
+			n_bits++;
+			if (n_bits == maxbits)	/* Won't get any bigger now. */
+				maxcode = maxmaxcode;
+			else
+				maxcode = MAXCODE(n_bits);
+		}
+		if (clear_flg > 0) {
+			maxcode = MAXCODE(n_bits = INIT_BITS);
+			clear_flg = 0;
+		}
+		if ( zs->avail_in < (unsigned int)n_bits && in_count > (long)n_bits ) {
+			memcpy (buf, zs->next_in, zs->avail_in);
+			buf_len = zs->avail_in;
+			zs->avail_in = 0;
+			return -1;
+		}
+		if (buf_len) {
+			memcpy (gbuf, buf, buf_len);
+			memcpy (gbuf + buf_len, zs->next_in,
+				n_bits - buf_len);
+			zs->next_in += n_bits - buf_len;
+			zs->avail_in -= n_bits - buf_len;
+			buf_len = 0;
+			zs->total_in += n_bits;
+			size = n_bits;
+			in_count -= n_bits;
+		} else {
+			if (in_count > n_bits) {
+				memcpy (gbuf, zs->next_in, n_bits);
+				zs->next_in += n_bits;
+				zs->avail_in -= n_bits;
+				zs->total_in += n_bits;
+				size = n_bits;
+				in_count -= n_bits;
+			} else {
+				memcpy (gbuf, zs->next_in, in_count);
+				zs->next_in += in_count;
+				zs->avail_in -= in_count;
+				zs->total_in += in_count;
+				size = in_count;
+				in_count = 0;
+			}
+		}
+		roffset = 0;
+		/* Round size down to integral number of codes. */
+		size = (size << 3) - (n_bits - 1);
+	}
+	r_off = roffset;
+	bits = n_bits;
+
+	/* Get to the first byte. */
+	bp += (r_off >> 3);
+	r_off &= 7;
+
+	/* Get first part (low order bits). */
+	gcode = (*bp++ >> r_off);
+	bits -= (8 - r_off);
+	r_off = 8 - r_off;	/* Now, roffset into gcode word. */
+
+	/* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
+	if (bits >= 8) {
+		gcode |= *bp++ << r_off;
+		r_off += 8;
+		bits -= 8;
+	}
+
+	/* High order bits. */
+	gcode |= (*bp & rmask[bits]) << r_off;
+	roffset += n_bits;
+
+	return (gcode);
+}
+
+static void
+zinit(s_zstate_t *zs)
+{
+	memset(zs, 0, sizeof (s_zstate_t));
+
+	maxbits = BITS;			/* User settable max # bits/code. */
+	maxmaxcode = 1 << maxbits;	/* Should NEVER generate this code. */
+	hsize = HSIZE;			/* For dynamic table sizing. */
+	free_ent = 0;			/* First unused entry. */
+	block_compress = BLOCK_MASK;
+	clear_flg = 0;
+	state = S_START;
+	roffset = 0;
+	size = 0;
+}
diff --git a/nx-X11/extras/freetype2/src/lzw/zopen.h b/nx-X11/extras/freetype2/src/lzw/zopen.h
new file mode 100644
index 000000000..483b47e5c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/lzw/zopen.h
@@ -0,0 +1,114 @@
+/*	$NetBSD: zopen.c,v 1.8 2003/08/07 11:13:29 agc Exp $	*/
+
+/*-
+ * Copyright (c) 1985, 1986, 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Diomidis Spinellis and James A. Woods, derived from original
+ * work by Spencer Thomas and Joseph Orost.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*-
+ *
+ * Copyright (c) 2004
+ *	Albert Chin-A-Young.
+ *
+ * Modified to work with FreeType's PCF driver.
+ *
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)zopen.c	8.1 (Berkeley) 6/27/93";
+#else
+static char rcsid[] = "$NetBSD: zopen.c,v 1.8 2003/08/07 11:13:29 agc Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+
+#define	BITS		16		/* Default bits. */
+#define	HSIZE		69001		/* 95% occupancy */
+
+/* A code_int must be able to hold 2**BITS values of type int, and also -1. */
+typedef long code_int;
+typedef long count_int;
+
+typedef unsigned char char_type;
+
+typedef enum {
+	S_START, S_MIDDLE, S_EOF
+} zs_enum;
+
+typedef struct {
+	unsigned char *next_in;
+	unsigned int avail_in;
+	unsigned long total_in;
+
+	unsigned char *next_out;
+	unsigned int avail_out;
+	unsigned long total_out;
+
+	zs_enum zs_state;		/* State of computation */
+	int zs_n_bits;			/* Number of bits/code. */
+	int zs_maxbits;			/* User settable max # bits/code. */
+	code_int zs_maxcode;		/* Maximum code, given n_bits. */
+	code_int zs_maxmaxcode;		/* Should NEVER generate this code. */
+	count_int zs_htab [HSIZE];
+	unsigned short zs_codetab [HSIZE];
+	code_int zs_hsize;		/* For dynamic table sizing. */
+	code_int zs_free_ent;		/* First unused entry. */
+	/*
+	 * Block compression parameters -- after all codes are used up,
+	 * and compression rate changes, start over.
+	 */
+	int zs_block_compress;
+	int zs_clear_flg;
+	int zs_offset;
+	long zs_in_count;		/* Remaining uncompressed bytes. */
+	char_type zs_buf_len;
+	char_type zs_buf[BITS];		/* Temporary buffer if we need
+					   to read more to accumulate
+					   n_bits. */
+	union {
+		struct {
+			char_type *zs_stackp;
+			int zs_finchar;
+			code_int zs_code, zs_oldcode, zs_incode;
+			int zs_roffset, zs_size;
+			char_type zs_gbuf[BITS];
+		} r;			/* Read parameters */
+	} u;
+} s_zstate_t;
+
+static code_int getcode(s_zstate_t *);
+#if 0
+static int      zclose(s_zstate_t *);
+#endif
+static void     zinit(s_zstate_t *);
+static int      zread(s_zstate_t *);
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlayout.h b/nx-X11/extras/freetype2/src/otlayout/otlayout.h
new file mode 100644
index 000000000..2cd67f568
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlayout.h
@@ -0,0 +1,205 @@
+#ifndef __OT_LAYOUT_H__
+#define __OT_LAYOUT_H__
+
+
+#include "otlconf.h"
+
+OTL_BEGIN_HEADER
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       BASE DATA TYPES                        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  typedef unsigned char     OTL_Byte;
+  typedef const OTL_Byte*   OTL_Bytes;
+
+  typedef int               OTL_Error;
+
+  typedef void*             OTL_Pointer;
+
+  typedef int               OTL_Int;
+  typedef unsigned int      OTL_UInt;
+
+  typedef long              OTL_Long;
+  typedef unsigned long     OTL_ULong;
+
+  typedef short             OTL_Int16;
+  typedef unsigned short    OTL_UInt16;
+
+
+#if OTL_SIZEOF_INT == 4
+
+  typedef int               OTL_Int32;
+  typedef unsigned int      OTL_UInt32;
+
+#elif OTL_SIZEOF_LONG == 4
+
+  typedef long              OTL_Int32;
+  typedef unsigned long     OTL_UInt32;
+
+#else
+#  error "no 32-bits type found"
+#endif
+
+  typedef OTL_UInt32        OTL_Tag;
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       ERROR CODES                            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  typedef enum
+  {
+    OTL_Err_Ok = 0,
+    OTL_Err_InvalidArgument,
+    OTL_Err_InvalidFormat,
+    OTL_Err_InvalidOffset,
+
+    OTL_Err_Max
+
+  } OTL_Error;
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                     MEMORY MANAGEMENT                        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  typedef OTL_Pointer  (*OTL_AllocFunc)( OTL_ULong    size,
+                                         OTL_Pointer  data );
+
+  typedef OTL_Pointer  (*OTL_ReallocFunc)( OTL_Pointer   block,
+                                           OTL_ULong     size,
+                                           OTL_Pointer   data );
+
+  typedef void         (*OTL_FreeFunc)( OTL_Pointer  block,
+                                        OTL_Pointer  data );
+
+  typedef struct OTL_MemoryRec_
+  {
+    OTL_Pointer      mem_data;
+    OTL_AllocFunc    mem_alloc;
+    OTL_ReallocFunc  mem_realloc;
+    OTL_FreeFunc     mem_free;
+
+  } OTL_MemoryRec, *OTL_Memory;
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                        ENUMERATIONS                          *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+/* re-define OTL_MAKE_TAG to something different if you're not */
+/* using an ASCII-based character set (Vaxes anyone ?)         */
+#ifndef  OTL_MAKE_TAG
+#define  OTL_MAKE_TAG(c1,c2,c3,c4)         \
+           ( ( (OTL_UInt32)(c1) << 24 ) |  \
+               (OTL_UInt32)(c2) << 16 ) |  \
+               (OTL_UInt32)(c3) <<  8 ) |  \
+               (OTL_UInt32)(c4)         )
+#endif
+
+  typedef enum OTL_ScriptTag_
+  {
+    OTL_SCRIPT_NONE = 0,
+
+#define OTL_SCRIPT_TAG(c1,c2,c3,c4,s,n)  OTL_SCRIPT_TAG_ ## n = OTL_MAKE_TAG(c1,c2,c3,c4),
+#include "otltags.h"
+
+    OTL_SCRIPT_MAX
+
+  } OTL_ScriptTag;
+
+
+  typedef enum OTL_LangTag_
+  {
+    OTL_LANG_DEFAULT = 0,
+
+#define OTL_LANG_TAG(c1,c2,c3,c4,s,n)  OTL_LANG_TAG_ ## n = OTL_MAKE_TAG(c1,c2,c3,c4),
+#include "otltags.h"
+
+    OTL_LANG_MAX
+
+  } OTL_LangTag;
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       MEMORY READS                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#define  OTL_PEEK_USHORT(p)  ( ((OTL_UInt)((p)[0]) << 8) |  \
+                               ((OTL_UInt)((p)[1])     ) )
+
+#define  OTL_PEEK_ULONG(p)   ( ((OTL_UInt32)((p)[0]) << 24) |  \
+                               ((OTL_UInt32)((p)[1]) << 16) |  \
+                               ((OTL_UInt32)((p)[2]) <<  8) |  \
+                               ((OTL_UInt32)((p)[3])      ) )
+
+#define  OTL_PEEK_SHORT(p)     ((OTL_Int16)OTL_PEEK_USHORT(p))
+
+#define  OTL_PEEK_LONG(p)      ((OTL_Int32)OTL_PEEK_ULONG(p))
+
+#define  OTL_NEXT_USHORT(p)  ( (p) += 2, OTL_PEEK_USHORT((p)-2) )
+#define  OTL_NEXT_ULONG(p)   ( (p) += 4, OTL_PEEK_ULONG((p)-4) )
+
+#define  OTL_NEXT_SHORT(p)   ((OTL_Int16)OTL_NEXT_USHORT(p))
+#define  OTL_NEXT_LONG(p)    ((OTL_Int32)OTL_NEXT_ULONG(p))
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                        VALIDATION                            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  typedef struct OTL_ValidatorRec_*  OTL_Validator;
+
+  typedef struct OTL_ValidatorRec_
+  {
+    OTL_Bytes    limit;
+    OTL_Bytes    base;
+    OTL_Error    error;
+    OTL_jmp_buf  jump_buffer;
+
+  } OTL_ValidatorRec;
+
+  typedef void  (*OTL_ValidateFunc)( OTL_Bytes  table,
+                                     OTL_Valid  valid );
+
+  OTL_API( void )
+  otl_validator_error( OTL_Validator  validator,
+                       OTL_Error      error );
+
+#define  OTL_INVALID(e)  otl_validator_error( valid, e )
+
+#define  OTL_INVALID_TOO_SHORT  OTL_INVALID( OTL_Err_InvalidOffset )
+#define  OTL_INVALID_DATA       OTL_INVALID( OTL_Err_InvalidFormat )
+
+#define  OTL_CHECK(_count)   OTL_BEGIN_STMNT                       \
+                               if ( p + (_count) > valid->limit )  \
+                                 OTL_INVALID_TOO_SHORT;            \
+                             OTL_END_STMNT
+
+ /* */
+
+OTL_END_HEADER
+
+#endif /* __OPENTYPE_LAYOUT_H__ */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlbase.c b/nx-X11/extras/freetype2/src/otlayout/otlbase.c
new file mode 100644
index 000000000..614e13c1a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlbase.c
@@ -0,0 +1,181 @@
+#include "otlbase.h"
+#include "otlcommn.h"
+
+  static void
+  otl_base_coord_validate( OTL_Bytes      table,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 4 );
+
+    format = OTL_NEXT_USHORT( p );
+    p += 2;
+
+    switch ( format )
+    {
+      case 1:
+        break;
+
+      case 2:
+        OTL_CHECK( 4 );
+        break;
+
+      case 3:
+        OTL_CHECK( 2 );
+        otl_device_table_validate( table + OTL_PEEK_USHORT( p ) );
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static void
+  otl_base_tag_list_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK(2);
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count*4 );
+  }
+
+
+
+  static void
+  otl_base_values_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 4 );
+
+    p    += 2;  /* skip default index */
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+
+    for ( ; count > 0; count-- )
+      otl_base_coord_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_base_minmax_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   min_coord, max_coord, count;
+
+    OTL_CHECK(6);
+    min_coord = OTL_NEXT_USHORT( p );
+    max_coord = OTL_NEXT_USHORT( p );
+    count     = OTL_NEXT_USHORT( p );
+
+    if ( min_coord )
+      otl_base_coord_validate( table + min_coord, valid );
+
+    if ( max_coord )
+      otl_base_coord_validate( table + max_coord, valid );
+
+    OTL_CHECK( count*8 );
+    for ( ; count > 0; count-- )
+    {
+      p += 4;  /* ignore tag */
+      min_coord = OTL_NEXT_USHORT( p );
+      max_coord = OTL_NEXT_USHORT( p );
+
+      if ( min_coord )
+        otl_base_coord_validate( table + min_coord, valid );
+
+      if ( max_coord )
+        otl_base_coord_validate( table + max_coord, valid );
+    }
+  }
+
+
+  static void
+  otl_base_script_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   values, default_minmax;
+
+    OTL_CHECK(6);
+
+    values         = OTL_NEXT_USHORT( p );
+    default_minmax = OTL_NEXT_USHORT( p );
+    count          = OTL_NEXT_USHORT( p );
+
+    if ( values )
+      otl_base_values_validate( table + values, valid );
+
+    if ( default_minmax )
+      otl_base_minmax_validate( table + default_minmax, valid );
+
+    OTL_CHECK( count*6 );
+    for ( ; count > 0; count-- )
+    {
+      p += 4;  /* ignore tag */
+      otl_base_minmax_validate( table + OTL_NEXT_USHORT( p ), valid );
+    }
+  }
+
+
+  static void
+  otl_base_script_list_validate( OTL_Bytes      table,
+                                 OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK(2);
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK(count*6);
+
+    for ( ; count > 0; count-- )
+    {
+      p += 4;  /* ignore script tag */
+      otl_base_script_validate( table + OTL_NEXT_USHORT( p ) );
+    }
+  }
+
+  static void
+  otl_axis_table_validate( OTL_Bytes      table,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   tags;
+
+    OTL_CHECK(4);
+
+    tags = OTL_NEXT_USHORT( p );
+    if ( tags )
+      otl_base_tag_list_validate   ( table + tags );
+
+    otl_base_script_list_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_base_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes p = table;
+
+    OTL_CHECK(6);
+
+    if ( OTL_NEXT_ULONG( p ) != 0x10000UL )
+      OTL_INVALID_DATA;
+
+    otl_axis_table_validate( table + OTL_NEXT_USHORT( p ) );
+    otl_axis_table_validate( table + OTL_NEXT_USHORT( p ) );
+  }
\ No newline at end of file
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlbase.h b/nx-X11/extras/freetype2/src/otlayout/otlbase.h
new file mode 100644
index 000000000..563d3002d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlbase.h
@@ -0,0 +1,14 @@
+#ifndef __OTL_BASE_H__
+#define __OTL_BASE_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_LOCAL( void )
+  otl_base_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_BASE_H__ */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlcommn.c b/nx-X11/extras/freetype2/src/otlayout/otlcommn.c
new file mode 100644
index 000000000..742ff5b36
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlcommn.c
@@ -0,0 +1,940 @@
+/***************************************************************************/
+/*                                                                         */
+/*  otlcommn.c                                                             */
+/*                                                                         */
+/*    OpenType layout support, common tables (body).                       */
+/*                                                                         */
+/*  Copyright 2002 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 "otlayout.h"
+
+
+ /*************************************************************************/
+ /*************************************************************************/
+ /*****                                                               *****/
+ /*****                       COVERAGE TABLE                          *****/
+ /*****                                                               *****/
+ /*************************************************************************/
+ /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_coverage_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_Bytes  p;
+    OTL_UInt   format;
+
+
+    if ( table + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+    case 1:
+      {
+        OTL_UInt  count = OTL_NEXT_USHORT( p );
+
+
+        if ( p + count * 2 >= valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        /* XXX: check glyph indices */
+      }
+      break;
+
+    case 2:
+      {
+        OTL_UInt  n, num_ranges = OTL_NEXT_USHORT( p );
+        OTL_UInt  start, end, start_cover, total = 0, last = 0;
+
+
+        if ( p + num_ranges * 6 >= valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        for ( n = 0; n < num_ranges; n++ )
+        {
+          start       = OTL_NEXT_USHORT( p );
+          end         = OTL_NEXT_USHORT( p );
+          start_cover = OTL_NEXT_USHORT( p );
+
+          if ( start > end || start_cover != total )
+            OTL_INVALID_DATA;
+
+          if ( n > 0 && start <= last )
+            OTL_INVALID_DATA;
+
+          total += end - start + 1;
+          last   = end;
+        }
+      }
+      break;
+
+    default:
+      OTL_INVALID_FORMAT;
+    }
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_coverage_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p      = table;
+    OTL_UInt   format = OTL_NEXT_USHORT( p );
+    OTL_UInt   count  = OTL_NEXT_USHORT( p );
+    OTL_UInt   result = 0;
+
+
+    switch ( format )
+    {
+    case 1:
+      return count;
+
+    case 2:
+      {
+        OTL_UInt  start, end;
+
+
+        for ( ; count > 0; count-- )
+        {
+          start = OTL_NEXT_USHORT( p );
+          end   = OTL_NEXT_USHORT( p );
+          p    += 2;                    /* skip start_index */
+
+          result += end - start + 1;
+        }
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    return result;
+  }
+
+
+  OTL_LOCALDEF( OTL_Int )
+  otl_coverage_get_index( OTL_Bytes  table,
+                          OTL_UInt   glyph_index )
+  {
+    OTL_Bytes  p      = table;
+    OTL_UInt   format = OTL_NEXT_USHORT( p );
+    OTL_UInt   count  = OTL_NEXT_USHORT( p );
+
+
+    switch ( format )
+    {
+    case 1:
+      {
+        OTL_UInt  min = 0, max = count, mid, gindex;
+
+
+        table += 4;
+        while ( min < max )
+        {
+          mid    = ( min + max ) >> 1;
+          p      = table + 2 * mid;
+          gindex = OTL_PEEK_USHORT( p );
+
+          if ( glyph_index == gindex )
+            return (OTL_Int)mid;
+
+          if ( glyph_index < gindex )
+            max = mid;
+          else
+            min = mid + 1;
+        }
+      }
+      break;
+
+    case 2:
+      {
+        OTL_UInt  min = 0, max = count, mid;
+        OTL_UInt  start, end, delta, start_cover;
+
+
+        table += 4;
+        while ( min < max )
+        {
+          mid    = ( min + max ) >> 1;
+          p      = table + 6 * mid;
+          start  = OTL_NEXT_USHORT( p );
+          end    = OTL_NEXT_USHORT( p );
+
+          if ( glyph_index < start )
+            max = mid;
+          else if ( glyph_index > end )
+            min = mid + 1;
+          else
+            return (OTL_Int)( glyph_index + OTL_NEXT_USHORT( p ) - start );
+        }
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    return -1;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  CLASS DEFINITION TABLE                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_class_definition_validate( OTL_Bytes      table,
+                                 OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+    case 1:
+      {
+        OTL_UInt  count, start = OTL_NEXT_USHORT( p );
+
+
+        if ( p + 2 > valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        count = OTL_NEXT_USHORT( p );
+
+        if ( p + count * 2 > valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        /* XXX: check glyph indices */
+      }
+      break;
+
+    case 2:
+      {
+        OTL_UInt  n, num_ranges = OTL_NEXT_USHORT( p );
+        OTL_UInt  start, end, value, last = 0;
+
+
+        if ( p + num_ranges * 6 > valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        for ( n = 0; n < num_ranges; n++ )
+        {
+          start = OTL_NEXT_USHORT( p );
+          end   = OTL_NEXT_USHORT( p );
+          value = OTL_NEXT_USHORT( p );  /* ignored */
+
+          if ( start > end || ( n > 0 && start <= last ) )
+            OTL_INVALID_DATA;
+
+          last = end;
+        }
+      }
+      break;
+
+    default:
+      OTL_INVALID_FORMAT;
+    }
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_class_definition_get_value( OTL_Bytes  table,
+                                  OTL_UInt   glyph_index )
+  {
+    OTL_Bytes  p      = table;
+    OTL_UInt   format = OTL_NEXT_USHORT( p );
+
+
+    switch ( format )
+    {
+    case 1:
+      {
+        OTL_UInt  start = OTL_NEXT_USHORT( p );
+        OTL_UInt  count = OTL_NEXT_USHORT( p );
+        OTL_UInt  idx   = (OTL_UInt)( glyph_index - start );
+
+
+        if ( idx < count )
+        {
+          p += 2 * idx;
+          return OTL_PEEK_USHORT( p );
+        }
+      }
+      break;
+
+    case 2:
+      {
+        OTL_UInt  count = OTL_NEXT_USHORT( p );
+        OTL_UInt  min = 0, max = count, mid, gindex;
+
+
+        table += 4;
+        while ( min < max )
+        {
+          mid   = ( min + max ) >> 1;
+          p     = table + 6 * mid;
+          start = OTL_NEXT_USHORT( p );
+          end   = OTL_NEXT_USHORT( p );
+
+          if ( glyph_index < start )
+            max = mid;
+          else if ( glyph_index > end )
+            min = mid + 1;
+          else
+            return OTL_PEEK_USHORT( p );
+        }
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      DEVICE TABLE                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_device_table_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   start, end, count, format, count;
+
+
+    if ( p + 8 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    start  = OTL_NEXT_USHORT( p );
+    end    = OTL_NEXT_USHORT( p );
+    format = OTL_NEXT_USHORT( p );
+
+    if ( format < 1 || format > 3 || end < start )
+      OTL_INVALID_DATA;
+
+    count = (OTL_UInt)( end - start + 1 );
+
+    if ( p + ( ( 1 << format ) * count ) / 8 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_device_table_get_start( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_device_table_get_end( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 2;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_Int )
+  otl_device_table_get_delta( OTL_Bytes  table,
+                              OTL_UInt   size )
+  {
+    OTL_Bytes  p = table;
+    OTL_Int    result = 0;
+    OTL_UInt   start, end, format, idx, value;
+
+
+    start  = OTL_NEXT_USHORT( p );
+    end    = OTL_NEXT_USHORT( p );
+    format = OTL_NEXT_USHORT( p );
+
+    if ( size >= start && size <= end )
+    {
+      /* we could do that with clever bit operations, but a switch is */
+      /* much simpler to understand and maintain                      */
+      /*                                                              */
+      switch ( format )
+      {
+      case 1:
+        idx    = (OTL_UInt)( ( size - start ) * 2 );
+        p     += idx / 16;
+        value  = OTL_PEEK_USHORT( p );
+        shift  = idx & 15;
+        result = (OTL_Short)( value << shift ) >> ( 14 - shift );
+
+        break;
+
+      case 2:
+        idx    = (OTL_UInt)( ( size - start ) * 4 );
+        p     += idx / 16;
+        value  = OTL_PEEK_USHORT( p );
+        shift  = idx & 15;
+        result = (OTL_Short)( value << shift ) >> ( 12 - shift );
+
+        break;
+
+      case 3:
+        idx    = (OTL_UInt)( ( size - start ) * 8 );
+        p     += idx / 16;
+        value  = OTL_PEEK_USHORT( p );
+        shift  = idx & 15;
+        result = (OTL_Short)( value << shift ) >> ( 8 - shift );
+
+        break;
+
+      default:
+        ;
+      }
+    }
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      LOOKUP LISTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_lookup_validate( OTL_Bytes      table,
+                       OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   num_tables;
+
+
+    if ( table + 6 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    p += 4;
+    num_tables = OTL_NEXT_USHORT( p );
+
+    if ( p + num_tables * 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; num_tables > 0; num_tables-- )
+    {
+      offset = OTL_NEXT_USHORT( p );
+
+      if ( table + offset >= valid->limit )
+        OTL_INVALID_OFFSET;
+    }
+
+    /* XXX: check sub-tables? */
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lookup_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 4;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_get_table( OTL_Bytes  table,
+                        OTL_UInt   idx )
+  {
+    OTL_Bytes  p, result = NULL;
+    OTL_UInt   count;
+
+
+    p     = table + 4;
+    count = OTL_NEXT_USHORT( p );
+    if ( idx < count )
+    {
+      p     += idx * 2;
+      result = table + OTL_PEEK_USHORT( p );
+    }
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      LOOKUP LISTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_lookup_list_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table, q;
+    OTL_UInt   num_lookups, offset;
+
+
+    if ( p + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    num_lookups = OTL_NEXT_USHORT( p );
+
+    if ( p + num_lookups * 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; num_lookups > 0; num_lookups-- )
+    {
+      offset = OTL_NEXT_USHORT( p );
+
+      otl_lookup_validate( table + offset, valid );
+    }
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lookup_list_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_list_get_lookup( OTL_Bytes  table,
+                              OTL_UInt   idx )
+  {
+    OTL_Bytes  p, result = 0;
+    OTL_UInt   count;
+
+
+    p     = table;
+    count = OTL_NEXT_USHORT( p );
+    if ( idx < count )
+    {
+      p     += idx * 2;
+      result = table + OTL_PEEK_USHORT( p );
+    }
+
+    return result;
+  }
+
+
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_list_get_table( OTL_Bytes  table,
+                             OTL_UInt   lookup_index,
+                             OTL_UInt   table_index )
+  {
+    OTL_Bytes  result = NULL;
+
+
+    result = otl_lookup_list_get_lookup( table, lookup_index );
+    if ( result )
+      result = otl_lookup_get_table( result, table_index );
+
+    return result;
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_lookup_list_foreach( OTL_Bytes        table,
+                           OTL_ForeachFunc  func,
+                           OTL_Pointer      func_data )
+  {
+    OTL_Bytes  p     = table;
+    OTL_UInt   count = OTL_NEXT_USHORT( p );
+
+
+    for ( ; count > 0; count-- )
+      func( table + OTL_NEXT_USHORT( p ), func_data );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        FEATURES                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_feature_validate( OTL_Bytes      table,
+                        OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   feat_params, num_lookups;
+
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    feat_params = OTL_NEXT_USHORT( p );  /* ignored */
+    num_lookups = OTL_NEXT_USHORT( p );
+
+    if ( p + num_lookups * 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    /* XXX: check lookup indices */
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 4;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_get_lookups( OTL_Bytes  table,
+                           OTL_UInt   start,
+                           OTL_UInt   count,
+                           OTL_UInt  *lookups )
+  {
+    OTL_Bytes  p;
+    OTL_UInt   num_features, result = 0;
+
+
+    p            = table + 4;
+    num_features = OTL_NEXT_USHORT( p );
+
+    p += start * 2;
+
+    for ( ; count > 0 && start < num_features; count--, start++ )
+    {
+      lookups[0] = OTL_NEXT_USHORT(p);
+      lookups++;
+      result++;
+    }
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        FEATURE LIST                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_feature_list_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   num_features, offset;
+
+
+    if ( table + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    num_features = OTL_NEXT_USHORT( p );
+
+    if ( p + num_features * 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; num_features > 0; num_features-- )
+    {
+      p     += 4;                       /* skip tag */
+      offset = OTL_NEXT_USHORT( p );
+
+      otl_feature_table_validate( table + offset, valid );
+    }
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_list_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_feature_list_get_feature( OTL_Bytes  table,
+                                OTL_UInt   idx )
+  {
+    OTL_Bytes  p, result = NULL;
+    OTL_UInt   count;
+
+
+    p     = table;
+    count = OTL_NEXT_USHORT( p );
+
+    if ( idx < count )
+    {
+      p     += idx * 2;
+      result = table + OTL_PEEK_USHORT( p );
+    }
+
+    return result;
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_feature_list_foreach( OTL_Bytes        table,
+                            OTL_ForeachFunc  func,
+                            OTL_Pointer      func_data )
+  {
+    OTL_Bytes  p;
+    OTL_UInt   count;
+
+
+    p = table;
+    count = OTL_NEXT_USHORT( p );
+
+    for ( ; count > 0; count-- )
+      func( table + OTL_NEXT_USHORT( p ), func_data );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       LANGUAGE SYSTEM                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  OTL_LOCALDEF( void )
+  otl_lang_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   lookup_order;
+    OTL_UInt   req_feature;
+    OTL_UInt   num_features;
+
+
+    if ( table + 6 >= valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    lookup_order = OTL_NEXT_USHORT( p );
+    req_feature  = OTL_NEXT_USHORT( p );
+    num_features = OTL_NEXT_USHORT( p );
+
+    /* XXX: check req_feature if not 0xFFFFU */
+
+    if ( p + 2 * num_features >= valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    /* XXX: check features indices! */
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lang_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 4;
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lang_get_req_feature( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 2;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lang_get_features( OTL_Bytes  table,
+                         OTL_UInt   start,
+                         OTL_UInt   count,
+                         OTL_UInt  *features )
+  {
+    OTL_Bytes  p            = table + 4;
+    OTL_UInt   num_features = OTL_NEXT_USHORT( p );
+    OTL_UInt   result       = 0;
+
+
+    p += start * 2;
+
+    for ( ; count > 0 && start < num_features; start++, count-- )
+    {
+      features[0] = OTL_NEXT_USHORT( p );
+      features++;
+      result++;
+    }
+
+    return result;
+  }
+
+
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           SCRIPTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  OTL_LOCALDEF( void )
+  otl_script_validate( OTL_Bytes      table,
+                       OTL_Validator  valid )
+  {
+    OTL_UInt   default_lang;
+    OTL_Bytes  p = table;
+
+
+    if ( table + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    default_lang = OTL_NEXT_USHORT( p );
+    num_langs    = OTL_NEXT_USHORT( p );
+
+    if ( default_lang != 0 )
+    {
+      if ( table + default_lang >= valid->limit )
+        OTL_INVALID_OFFSET;
+    }
+
+    if ( p + num_langs * 6 >= valid->limit )
+      OTL_INVALID_OFFSET;
+
+    for ( ; num_langs > 0; num_langs-- )
+    {
+      OTL_UInt  offset;
+
+
+      p     += 4;  /* skip tag */
+      offset = OTL_NEXT_USHORT( p );
+
+      otl_lang_validate( table + offset, valid );
+    }
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_script_list_validate( OTL_Bytes      list,
+                            OTL_Validator  valid )
+  {
+    OTL_UInt   num_scripts;
+    OTL_Bytes  p = list;
+
+
+    if ( list + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    num_scripts = OTL_NEXT_USHORT( p );
+
+    if ( p + num_scripts * 6 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; num_scripts > 0; num_scripts-- )
+    {
+      OTL_UInt  offset;
+
+
+      p     += 4;                       /* skip tag */
+      offset = OTL_NEXT_USHORT( p );
+
+      otl_script_table_validate( list + offset, valid );
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                         LOOKUP LISTS                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  otl_lookup_table_validate( OTL_Bytes          table,
+                             OTL_UInt           type_count,
+                             OTL_ValidateFunc*  type_funcs,
+                             OTL_Validator      valid )
+  {
+    OTL_Bytes         p = table;
+    OTL_UInt          lookup_type, lookup_flag, count;
+    OTL_ValidateFunc  validate;
+
+    OTL_CHECK( 6 );
+    lookup_type = OTL_NEXT_USHORT( p );
+    lookup_flag = OTL_NEXT_USHORT( p );
+    count       = OTL_NEXT_USHORT( p );
+
+    if ( lookup_type == 0 || lookup_type >= type_count )
+      OTL_INVALID_DATA;
+
+    validate = type_funcs[ lookup_type - 1 ];
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_lookup_list_validate( OTL_Bytes          table,
+                            OTL_UInt           type_count,
+                            OTL_ValidateFunc*  type_funcs,
+                            OTL_Validator      valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_lookup_table_validate( table + OTL_NEXT_USHORT( p ),
+                                 type_count, type_funcs, valid );
+  }
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlcommn.h b/nx-X11/extras/freetype2/src/otlayout/otlcommn.h
new file mode 100644
index 000000000..25914fb9f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlcommn.h
@@ -0,0 +1,277 @@
+/***************************************************************************/
+/*                                                                         */
+/*  otlcommn.h                                                             */
+/*                                                                         */
+/*    OpenType layout support, common tables (specification).              */
+/*                                                                         */
+/*  Copyright 2002 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 __OTLCOMMN_H__
+#define __OTLCOMMN_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       COVERAGE TABLE                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate coverage table */
+  OTL_LOCALDEF( void )
+  otl_coverage_validate( OTL_Bytes      base,
+                         OTL_Validator  valid );
+
+  /* return number of covered glyphs */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_coverage_get_count( OTL_Bytes  base );
+
+  /* Return the coverage index corresponding to a glyph glyph index. */
+  /* Return -1 if the glyph isn't covered.                           */
+  OTL_LOCALDEF( OTL_Int )
+  otl_coverage_get_index( OTL_Bytes  base,
+                          OTL_UInt   glyph_index );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  CLASS DEFINITION TABLE                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate class definition table */
+  OTL_LOCALDEF( void )
+  otl_class_definition_validate( OTL_Bytes      table,
+                                 OTL_Validator  valid );
+
+  /* return class value for a given glyph index */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_class_definition_get_value( OTL_Bytes  table,
+                                  OTL_UInt   glyph_index );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      DEVICE TABLE                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate a device table */
+  OTL_LOCALDEF( void )
+  otl_device_table_validate( OTL_Bytes      table,
+                             OTL_Validator  valid );
+
+  /* return a device table's first size */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_device_table_get_start( OTL_Bytes  table );
+
+  /* return a device table's last size */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_device_table_get_end( OTL_Bytes  table );
+
+  /* return pixel adjustment for a given size */
+  OTL_LOCALDEF( OTL_Int )
+  otl_device_table_get_delta( OTL_Bytes  table,
+                              OTL_UInt   size );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           LOOKUPS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate lookup table */
+  OTL_LOCALDEF( void )
+  otl_lookup_validate( OTL_Bytes      table,
+                       OTL_Validator  valid );
+
+  /* return number of sub-tables in a lookup */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lookup_get_count( OTL_Bytes  table );
+
+
+  /* return lookup sub-table */
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_get_table( OTL_Bytes  table,
+                        OTL_UInt   idx );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      LOOKUP LISTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate lookup list */
+  OTL_LOCALDEF( void )
+  otl_lookup_list_validate( OTL_Bytes      table,
+                            OTL_Validator  valid );
+
+  /* return number of lookups in list */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lookup_list_get_count( OTL_Bytes  table );
+
+  /* return a given lookup from a list */
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_list_get_lookup( OTL_Bytes  table,
+                              OTL_UInt   idx );
+
+  /* return lookup sub-table from a list */
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_list_get_table( OTL_Bytes  table,
+                             OTL_UInt   lookup_index,
+                             OTL_UInt   table_index );
+
+  /* iterate over lookup list */
+  OTL_LOCALDEF( void )
+  otl_lookup_list_foreach( OTL_Bytes        table,
+                           OTL_ForeachFunc  func,
+                           OTL_Pointer      func_data );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        FEATURES                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate feature table */
+  OTL_LOCALDEF( void )
+  otl_feature_validate( OTL_Bytes      table,
+                        OTL_Validator  valid );
+
+  /* return feature's lookup count */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_get_count( OTL_Bytes  table );
+
+  /* get several lookups indices from a feature. returns the number of */
+  /* lookups grabbed                                                   */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_get_lookups( OTL_Bytes  table,
+                           OTL_UInt   start,
+                           OTL_UInt   count,
+                           OTL_UInt  *lookups );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        FEATURE LIST                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate a feature list */
+  OTL_LOCALDEF( void )
+  otl_feature_list_validate( OTL_Bytes      table,
+                             OTL_Validator  valid );
+
+  /* return number of features in list */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_list_get_count( OTL_Bytes  table );
+
+
+  /* return a given feature from a list */
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_feature_list_get_feature( OTL_Bytes  table,
+                                OTL_UInt   idx );
+
+  /* iterate over all features in a list */
+  OTL_LOCALDEF( void )
+  otl_feature_list_foreach( OTL_Bytes        table,
+                            OTL_ForeachFunc  func,
+                            OTL_Pointer      func_data );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       LANGUAGE SYSTEM                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCAL( void )
+  otl_lang_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+
+  OTL_LOCAL( OTL_UInt )
+  otl_lang_get_req_feature( OTL_Bytes  table );
+
+
+  OTL_LOCAL( OTL_UInt )
+  otl_lang_get_count( OTL_Bytes  table );
+
+
+  OTL_LOCAL( OTL_UInt )
+  otl_lang_get_features( OTL_Bytes  table,
+                         OTL_UInt   start,
+                         OTL_UInt   count,
+                         OTL_UInt  *features );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           SCRIPTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCAL( void )
+  otl_script_list_validate( OTL_Bytes          list,
+                            OTL_Validator      valid );
+
+  OTL_LOCAL( OTL_Bytes )
+  otl_script_list_get_script( OTL_Bytes  table );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                         LOOKUP LISTS                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCAL( void )
+  otl_lookup_list_validate( OTL_Bytes          list,
+                            OTL_UInt           type_count,
+                            OTL_ValidateFunc*  type_funcs,
+                            OTL_Validator      valid );
+
+ /* */
+
+OTL_END_HEADER
+
+#endif /* __OTLCOMMN_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlconf.h b/nx-X11/extras/freetype2/src/otlayout/otlconf.h
new file mode 100644
index 000000000..3ef17a079
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlconf.h
@@ -0,0 +1,78 @@
+#ifndef __OT_LAYOUT_CONFIG_H__
+#define __OT_LAYOUT_CONFIG_H__
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                    CONFIGURATION MACROS                      *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#ifdef __cplusplus
+#  define OTL_BEGIN_HEADER  extern "C" {
+#else
+#  define OTL_BEGIN_HEADER  /* nothing */
+#endif
+
+#ifdef __cplusplus
+#  define OTL_END_HEADER   }
+#else
+#  define OTL_END_HEADER   /* nothing */
+#endif
+
+#ifndef OTL_API
+#  ifdef __cplusplus
+#    define  OTL_API( x )   extern "C"
+#  else
+#    define  OTL_API( x )   extern x
+#  endif
+#endif
+
+#ifndef OTL_APIDEF
+#  define  OTL_APIDEF( x )  x
+#endif
+
+#ifndef OTL_LOCAL
+#  define OTL_LOCAL( x )   extern x
+#endif
+
+#ifndef OTL_LOCALDEF
+#  define OTL_LOCALDEF( x )  x
+#endif
+
+#define  OTL_BEGIN_STMNT  do {
+#define  OTL_END_STMNT    } while (0)
+#define  OTL_DUMMY_STMNT  OTL_BEGIN_STMNT OTL_END_STMNT
+
+#define  OTL_UNUSED( x )       (x)=(x)
+#define  OTL_UNUSED_CONST(x)   (void)(x)
+
+
+#include <limits.h>
+#if UINT_MAX == 0xFFFFU
+#  define OTL_SIZEOF_INT  2
+#elif UINT_MAX == 0xFFFFFFFFU
+#  define OTL_SIZEOF_INT  4
+#elif UINT_MAX > 0xFFFFFFFFU && UINT_MAX == 0xFFFFFFFFFFFFFFFFU
+#  define OTL_SIZEOF_INT  8
+#else
+#  error  "unsupported number of bytes in 'int' type!"
+#endif
+
+#if ULONG_MAX == 0xFFFFFFFFU
+#  define  OTL_SIZEOF_LONG  4
+#elif ULONG_MAX > 0xFFFFFFFFU && ULONG_MAX == 0xFFFFFFFFFFFFFFFFU
+#  define  OTL_SIZEOF_LONG  8
+#else
+#  error  "unsupported number of bytes in 'long' type!"
+#endif
+
+#include <setjmp.h>
+#define  OTL_jmp_buf   jmp_buf
+#define  otl_setjmp    setjmp
+#define  otl_longjmp   longjmp
+
+/* */
+
+#endif /* __OT_LAYOUT_CONFIG_H__ */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlgdef.c b/nx-X11/extras/freetype2/src/otlayout/otlgdef.c
new file mode 100644
index 000000000..ff1c2a1e8
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlgdef.c
@@ -0,0 +1,175 @@
+#include "otlgdef.h"
+#include "otlcommn.h"
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                      ATTACHMENTS LIST                        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_attach_point_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    if ( p + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    count = OTL_NEXT_USHORT( p );
+    if ( table + count*2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+  }
+
+
+  static void
+  otl_attach_list_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_Bytes  coverage;
+    OTL_UInt   count;
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    coverage = table + OTL_NEXT_USHORT( p );
+    count    = OTL_NEXT_USHORT( p );
+
+    otl_coverage_validate( coverage, valid );
+    if ( count != otl_coverage_get_count( coverage ) )
+      OTL_INVALID_DATA;
+
+    if ( p + count*2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; count > 0; count-- )
+      otl_attach_point_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                      LIGATURE CARETS                         *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_caret_value_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+      case 2:
+        break;
+
+      case 3:
+        {
+          OTL_Bytes  device;
+
+          p += 2;
+          if ( p + 2 > valid->limit )
+            OTL_INVALID_TOO_SHORT;
+
+          otl_device_table_validate( table + OTL_PEEK_USHORT( p ) );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static void
+  otl_ligature_glyph_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    if ( p + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    count = OTL_NEXT_USHORT( p );
+
+    if ( p + count*2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; count > 0; count-- )
+      otl_caret_value_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+  static void
+  otl_ligature_caret_list_validate( OTL_Bytes      table,
+                                    OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_Bytes  coverage;
+    OTL_UInt   count;
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    coverage = table + OTL_NEXT_USHORT( p );
+    count    = OTL_NEXT_USHORT( p );
+
+    otl_coverage_validate( coverage, valid );
+    if ( count != otl_coverage_get_count( coverage ) )
+      OTL_INVALID_DATA;
+
+    if ( p + count*2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; count > 0; count-- )
+      otl_ligature_glyph_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                         GDEF TABLE                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  OTL_APIDEF( void )
+  otl_gdef_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+
+    if ( p + 12 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    /* check format */
+    if ( OTL_NEXT_ULONG( p ) != 0x00010000UL )
+      OTL_INVALID_FORMAT;
+
+    /* validate class definition table */
+    otl_class_definition_validate( table + OTL_NEXT_USHORT( p ) );
+
+    /* validate attachment point list */
+    otl_attach_list_validate( table + OTL_NEXT_USHORT( p ) );
+
+    /* validate ligature caret list */
+    otl_ligature_caret_list_validate( table + OTL_NEXT_USHORT( p ) );
+
+    /* validate mark attach class */
+    otl_class_definition_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlgdef.h b/nx-X11/extras/freetype2/src/otlayout/otlgdef.h
new file mode 100644
index 000000000..5046cc436
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlgdef.h
@@ -0,0 +1,14 @@
+#ifndef __OTL_GDEF_H__
+#define __OTL_GDEF_H__
+
+#include "otltable.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_API( void )
+  otl_gdef_validate( OTL_Bytes  table,
+                     OTL_Valid  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_GDEF_H__ */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlgpos.c b/nx-X11/extras/freetype2/src/otlayout/otlgpos.c
new file mode 100644
index 000000000..01942d7f0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlgpos.c
@@ -0,0 +1,980 @@
+#include "otlgpos.h"
+#include "otlcommn.h"
+
+ /* forward declaration */
+  static OTL_ValidateFunc  otl_gpos_validate_funcs[];
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                         VALUE RECORDS                        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static OTL_UInt
+  otl_value_length( OTL_UInt  format )
+  {
+    FT_UInt  count;
+
+    count = (( format & 0xAA ) >> 1) + ( format & 0x55 );
+    count = (( count  & 0xCC ) >> 2) + ( count  & 0x33 );
+    count = (( count  & 0xF0 ) >> 4) + ( count  & 0x0F );
+
+    return count;
+  }
+
+
+  static void
+  otl_value_validate( OTL_Bytes      table,
+                      OTL_Bytes      pos_table,
+                      OTL_UInt       format,
+                      OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, device;
+
+    if ( format >= 0x100U )
+      OTL_INVALID_DATA;
+
+    for ( count = 4; count > 0; count-- )
+    {
+      if ( format & 1 )
+      {
+        OTL_CHECK( 2 );
+        p += 2;
+      }
+
+      format >>= 1;
+    }
+
+    for ( count = 4; count > 0; count-- )
+    {
+      if ( format & 1 )
+      {
+        OTL_CHECK( 2 );
+        device = OTL_NEXT_USHORT( p );
+        if ( device )
+          otl_device_table_validate( pos_table + device, valid );
+      }
+      format >>= 1;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                          ANCHORS                             *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_anchor_validate( OTL_Bytes      table,
+                       OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 6 );
+    format = OTL_NEXT_USHORT( p );
+    p += 4;
+
+    switch ( format )
+    {
+      case 1:
+        break;
+
+      case 2:
+        OTL_CHECK( 2 );  /* anchor point */
+        break;
+
+      case 3:
+        {
+          OTL_UInt  x_device, y_device;
+
+          OTL_CHECK( 4 );
+          x_device = OTL_NEXT_USHORT( p );
+          y_device = OTL_NEXT_USHORT( p );
+
+          if ( x_device )
+            otl_device_table_validate( table + x_device, valid );
+
+          if ( y_device )
+            otl_device_table_validate( table + y_device, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                           MARK ARRAY                         *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_mark_array_validate( OTL_Bytes      table,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count * 4 );
+    for ( ; count > 0; count-- )
+    {
+      p += 2;  /* ignore class index */
+      otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 1                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gpos_lookup1_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          FT_UInt  coverage, value_format;
+
+          OTL_CHECK( 4 );
+          coverage     = OTL_NEXT_USHORT( p );
+          value_format = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+          otl_value_validate( p, table, value_format, valid );
+        }
+        break;
+
+      case 2:
+        {
+          FT_UInt  coverage, value_format, count, len;
+
+          OTL_CHECK( 6 );
+          coverage     = OTL_NEXT_USHORT( p );
+          value_format = OTL_NEXT_USHORT( p );
+          count        = OTL_NEXT_USHORT( p );
+          len          = otl_value_length( value_format );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count * len );
+          for ( ; count > 0; count-- )
+          {
+            otl_value_validate( p, table, value_format, valid );
+            p += len;
+          }
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 2                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static otl_gpos_pairset_validate( OTL_Bytes      table,
+                                    OTL_Bytes      pos_table,
+                                    OTL_UInt       format1,
+                                    OTL_UInt       format2,
+                                    OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   len1, len2, count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+    len1  = otl_value_length( format1 );
+    len2  = otl_value_length( format2 );
+
+    OTL_CHECK( count * (len1+len2+2) );
+    for ( ; count > 0; count-- )
+    {
+      p += 2;  /* ignore glyph id */
+      otl_value_validate( p, pos_table, format1, valid );
+      p += len1;
+
+      otl_value_validate( p, pos_table, format2, valid );
+      p += len2;
+    }
+  }
+
+  static void
+  otl_gpos_lookup2_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, value1, value2, count;
+
+          OTL_CHECK( 8 );
+          coverage = OTL_NEXT_USHORT( p );
+          value1   = OTL_NEXT_USHORT( p );
+          value2   = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+          {
+            otl_gpos_pairset_validate( table + OTL_NEXT_USHORT( p ),
+                                       table, value1, value2, valid );
+          }
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, value1, value2, class1, class2, count1, count2;
+          OTL_UInt  len1, len2;
+
+          OTL_CHECK( 14 );
+          coverage = OTL_NEXT_USHORT( p );
+          value1   = OTL_NEXT_USHORT( p );
+          value2   = OTL_NEXT_USHORT( p );
+          class1   = OTL_NEXT_USHORT( p );
+          class2   = OTL_NEXT_USHORT( p );
+          count1   = OTL_NEXT_USHORT( p );
+          count2   = OTL_NEXT_USHORT( p );
+
+          len1 = otl_value_length( value1 );
+          len2 = otl_value_length( value2 );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count1*count2*(len1+len2) );
+          for ( ; count1 > 0; count1-- )
+          {
+            for ( ; count2 > 0; count2-- )
+            {
+              otl_value_validate( p, table, value1, valid );
+              p += len1;
+
+              otl_value_validate( p, table, value2, valid );
+              p += len2;
+            }
+          }
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 3                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gpos_lookup3_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count, anchor1, anchor2;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count*4 );
+          for ( ; count > 0; count-- )
+          {
+            anchor1 = OTL_NEXT_USHORT( p );
+            anchor2 = OTL_NEXT_USHORT( p );
+
+            if ( anchor1 )
+              otl_anchor_validate( table + anchor1, valid );
+
+            if ( anchor2 )
+              otl_anchor_validate( table + anchor2, valid );
+          }
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 4                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_base_array_validate( OTL_Bytes      table,
+                           OTL_UInt       class_count,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, count2;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*class_count*2 );
+    for ( ; count > 0; count-- )
+      for ( count2 = class_count; count2 > 0; count2-- )
+        otl_anchor_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+  static void
+  otl_gpos_lookup4_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  mark_coverage, base_coverage, class_count;
+          OTL_UInt  mark_array, base_array;
+
+          OTL_CHECK( 10 );
+          mark_coverage = OTL_NEXT_USHORT( p );
+          base_coverage = OTL_NEXT_USHORT( p );
+          class_count   = OTL_NEXT_USHORT( p );
+          mark_array    = OTL_NEXT_USHORT( p );
+          base_array    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + mark_coverage, valid );
+          otl_coverage_validate( table + base_coverage, valid );
+
+          otl_mark_array_validate( table + mark_array, valid );
+          otl_base_array_validate( table, class_count, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 5                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_liga_attach_validate( OTL_Bytes      table,
+                            OTL_UInt       class_count,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, count2;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*class_count*2 );
+    for ( ; count > 0; count-- )
+      for ( count2 = class_count; class_count > 0; class_count-- )
+        otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_liga_array_validate( OTL_Bytes      table,
+                           OTL_UInt       class_count,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, count2;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_liga_attach_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gpos_lookup5_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  mark_coverage, lig_coverage, class_count;
+          OTL_UInt  mar_array, lig_array;
+
+          OTL_CHECK( 10 );
+          mark_coverage = OTL_NEXT_USHORT( p );
+          liga_coverage = OTL_NEXT_USHORT( p );
+          class_count   = OTL_NEXT_USHORT( p );
+          mark_array    = OTL_NEXT_USHORT( p );
+          liga_array    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + mark_coverage, valid );
+          otl_coverage_validate( table + liga_coverage, valid );
+
+          otl_mark_array_validate( table + mark_array, valid );
+          otl_liga_array_validate( table + liga_array, class_count, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 6                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  static void
+  otl_mark2_array_validate( OTL_Bytes      table,
+                            OTL_UInt       class_count,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, count2;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*class_count*2 );
+    for ( ; count > 0; count-- )
+      for ( count2 = class_count; class_count > 0; class_count-- )
+        otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gpos_lookup6_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage1, coverage2, class_count, array1, array2;
+
+          OTL_CHECK( 10 );
+          coverage1   = OTL_NEXT_USHORT( p );
+          coverage2   = OTL_NEXT_USHORT( p );
+          class_count = OTL_NEXT_USHORT( p );
+          array1      = OTL_NEXT_USHORT( p );
+          array2      = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage1, valid );
+          otl_coverage_validate( table + coverage2, valid );
+
+          otl_mark_array_validate( table + array1, valid );
+          otl_mark2_array_validate( table + array2, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 7                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_pos_rule_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   glyph_count, pos_count;
+
+    OTL_CHECK( 4 );
+    glyph_count = OTL_NEXT_USHORT( p );
+    pos_count   = OTL_NEXT_USHORT( p );
+
+    if ( glyph_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( (glyph_count-1)*2 + pos_count*4 );
+
+    /* XXX: check glyph indices and pos lookups */
+  }
+
+
+  static void
+  otl_pos_rule_set_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_pos_rule_validate( table + OTL_NEXT_USHORT(p), valid );
+  }
+
+
+
+  static void
+  otl_pos_class_rule_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   glyph_count, pos_count;
+
+    OTL_CHECK( 4 );
+    glyph_count = OTL_NEXT_USHORT( p );
+    pos_count   = OTL_NEXT_USHORT( p );
+
+    if ( glyph_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( (glyph_count-1)*2 + pos_count*4 );
+
+    /* XXX: check glyph indices and pos lookups */
+  }
+
+
+  static void
+  otl_pos_class_set_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_pos_rule_validate( table + OTL_NEXT_USHORT(p), valid );
+  }
+
+
+  static void
+  otl_gpos_lookup7_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+            otl_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, class_def, count;
+
+          OTL_CHECK( 6 );
+          coverage  = OTL_NEXT_USHORT( p );
+          class_def = OTL_NEXT_USHORT( p );
+          count     = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate        ( table + coverage, valid );
+          otl_class_definition_validate( table + class_def, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+            otl_
+        }
+        break;
+
+      case 3:
+        {
+          OTL_UInt  glyph_count, pos_count;
+
+          OTL_CHECK( 4 );
+          glyph_count = OTL_NEXT_USHORT( p );
+          pos_count   = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( glyph_count*2 + pos_count*4 );
+          for ( ; glyph_count > 0; glyph_count )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          /* XXX: check pos lookups */
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 8                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_chain_pos_rule_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   back_count, input_count, ahead_count, pos_count;
+
+    OTL_CHECK( 2 );
+    back_count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( back_count*2 + 2 );
+    p += back_count*2;
+
+    input_count = OTL_NEXT_USHORT( p );
+    if ( input_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( input_count*2 );
+    p += (input_count-1)*2;
+
+    ahead_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( ahead_count*2 + 2 );
+    p += ahead_count*2;
+
+    pos_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( pos_count*4 );
+  }
+
+
+  static void
+  otl_chain_pos_rule_set_validate( OTL_Bytes      table,
+                                   OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_chain_pos_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+
+  static void
+  otl_chain_pos_class_rule_validate( OTL_Bytes      table,
+                                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   back_count, input_count, ahead_count, pos_count;
+
+    OTL_CHECK( 2 );
+    back_count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( back_count*2 + 2 );
+    p += back_count*2;
+
+    input_count = OTL_NEXT_USHORT( p );
+    if ( input_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( input_count*2 );
+    p += (input_count-1)*2;
+
+    ahead_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( ahead_count*2 + 2 );
+    p += ahead_count*2;
+
+    pos_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( pos_count*4 );
+  }
+
+
+  static void
+  otl_chain_pos_class_set_validate( OTL_Bytes      table,
+                                   OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_chain_pos_class_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gpos_lookup8_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+            otl_chain_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ),
+                                             valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, back_class, input_class, ahead_class, count;
+
+          OTL_CHECK( 10 );
+          coverage    = OTL_NEXT_USHORT( p );
+          back_class  = OTL_NEXT_USHORT( p );
+          input_class = OTL_NEXT_USHORT( p );
+          ahead_class = OTL_NEXT_USHORT( p );
+          count       = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          otl_class_definition_validate( table + back_class,  valid );
+          otl_class_definition_validate( table + input_class, valid );
+          otl_class_definition_validate( table + ahead_class, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+            otl_chain_pos_class_set_validate( table + OTL_NEXT_USHORT( p ),
+                                              valid );
+        }
+        break;
+
+      case 3:
+        {
+          OTL_UInt  back_count, input_count, ahead_count, pos_count, count;
+
+          OTL_CHECK( 2 );
+          back_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*back_count+2 );
+          for ( count = back_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          input_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*input_count+2 );
+          for ( count = input_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          ahead_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*ahead_count+2 );
+          for ( count = ahead_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          pos_count = OTL_NEXT_USHORT( p );
+          OTL_CHECK( pos_count*4 );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 9                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gpos_lookup9_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt          lookup_type, lookup_offset;
+          OTL_ValidateFunc  validate;
+
+          OTL_CHECK( 6 );
+          lookup_type   = OTL_NEXT_USHORT( p );
+          lookup_offset = OTL_NEXT_ULONG( p );
+
+          if ( lookup_type == 0 || lookup_type >= 9 )
+            OTL_INVALID_DATA;
+
+          validate = otl_gpos_validate_funcs[ lookup_type-1 ];
+          validate( table + lookup_offset, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+  static OTL_ValidateFunc  otl_gpos_validate_funcs[ 9 ] =
+  {
+    otl_gpos_lookup1_validate,
+    otl_gpos_lookup2_validate,
+    otl_gpos_lookup3_validate,
+    otl_gpos_lookup4_validate,
+    otl_gpos_lookup5_validate,
+    otl_gpos_lookup6_validate,
+    otl_gpos_lookup7_validate,
+    otl_gpos_lookup8_validate,
+    otl_gpos_lookup9_validate,
+  };
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                         GPOS TABLE                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  OTL_LOCALDEF( void )
+  otl_gpos_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   scripts, features, lookups;
+
+    OTL_CHECK( 10 );
+
+    if ( OTL_NEXT_USHORT( p ) != 0x10000UL )
+      OTL_INVALID_DATA;
+
+    scripts  = OTL_NEXT_USHORT( p );
+    features = OTL_NEXT_USHORT( p );
+    lookups  = OTL_NEXT_USHORT( p );
+
+    otl_script_list_validate ( table + scripts, valid );
+    otl_feature_list_validate( table + features, valid );
+
+    otl_lookup_list_validate( table + lookups, 9, otl_gpos_validate_funcs,
+                              valid );
+  }
+  
\ No newline at end of file
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlgpos.h b/nx-X11/extras/freetype2/src/otlayout/otlgpos.h
new file mode 100644
index 000000000..1d10cab49
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlgpos.h
@@ -0,0 +1,14 @@
+#ifndef __OTL_GPOS_H__
+#define __OTL_GPOS_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_LOCAL( void )
+  otl_gpos_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_GPOS_H__ */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlgsub.c b/nx-X11/extras/freetype2/src/otlayout/otlgsub.c
new file mode 100644
index 000000000..13a8eae98
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlgsub.c
@@ -0,0 +1,867 @@
+#include "otlgsub.h"
+#include "otlcommn.h"
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 1                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+ /*
+  *  1: Single Substitution - Table format(s)
+  *
+  *  This table is used to substiture individual glyph indices
+  *  with another one. There are only two sub-formats:
+  *
+  *   Name         Offset    Size       Description
+  *   ------------------------------------------
+  *   format       0         2          sub-table format (1)
+  *   offset       2         2          offset to coverage table
+  *   delta        4         2          16-bit delta to apply on all
+  *                                     covered glyph indices
+  *
+  *   Name         Offset    Size       Description
+  *   ------------------------------------------
+  *   format       0         2          sub-table format (2)
+  *   offset       2         2          offset to coverage table
+  *   count        4         2          coverage table count
+  *   substs[]     6         2*count    substituted glyph indices,
+  *
+  */
+
+  static void
+  otl_gsub_lookup1_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+
+          /* NB: we don't check that there are at most 'count'   */
+          /*     elements in the coverage table. This is delayed */
+          /*     to the lookup function...                       */
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static OTL_Bool
+  otl_gsub_lookup1_apply( OTL_Bytes   table,
+                          OTL_Parser  parser )
+  {
+    OTL_Bytes  p = table;
+    OTL_Bytes  coverage;
+    OTL_UInt   format, gindex, property;
+    OTL_Int    index;
+    OTL_Bool   subst = 0;
+
+    if ( parser->context_len != 0xFFFFU && parser->context_len < 1 )
+      goto Exit;
+
+    gindex = otl_parser_get_gindex( parser );
+
+    if ( !otl_parser_check_property( parser, gindex, &property ) )
+      goto Exit;
+
+    format   = OTL_NEXT_USHORT(p);
+    coverage = table + OTL_NEXT_USHORT(p);
+    index    = otl_coverage_lookup( coverage, gindex );
+
+    if ( index >= 0 )
+    {
+      switch ( format )
+      {
+        case 1:
+          {
+            OTL_Int  delta = OTL_NEXT_SHORT(p);
+
+            gindex = ( gindex + delta ) & 0xFFFFU;
+            otl_parser_replace_1( parser, gindex );
+            subst = 1;
+          }
+          break;
+
+        case 2:
+          {
+            OTL_UInt  count = OTL_NEXT_USHORT(p);
+
+            if ( (OTL_UInt) index < count )
+            {
+              p += index*2;
+              otl_parser_replace_1( parser, OTL_PEEK_USHORT(p) );
+              subst = 1;
+            }
+          }
+          break;
+
+        default:
+          ;
+      }
+    }
+  Exit:
+    return subst;
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 2                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+ /*
+  *  2: Multiple Substitution - Table format(s)
+  *
+  *  Replaces a single glyph with one or more glyphs.
+  *
+  *   Name         Offset    Size       Description
+  *   -----------------------------------------------------------
+  *   format       0         2          sub-table format (1)
+  *   offset       2         2          offset to coverage table
+  *   count        4         2          coverage table count
+  *   sequencess[] 6         2*count    offsets to sequence items
+  *
+  *   each sequence item has the following format:
+  *
+  *   Name         Offset    Size       Description
+  *   -----------------------------------------------------------
+  *   count        0         2          number of replacement glyphs
+  *   gindices[]   2         2*count    string of glyph indices
+  */
+
+  static void
+  otl_seq_validate( OTL_Bytes      table,
+                    OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    /* XXX: according to the spec, 'count' should be > 0     */
+    /*      we can deal with these cases pretty well however */
+
+    OTL_CHECK( 2*count );
+    /* check glyph indices */
+  }
+
+
+  static void
+  otl_gsub_lookup2_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, seq_count;
+
+          OTL_CHECK( 4 );
+          coverage  = OTL_NEXT_USHORT( p );
+          seq_count = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( seq_count*2 );
+          for ( ; seq_count > 0; seq_count-- )
+            otl_seq_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static OTL_Bool
+  otl_gsub_lookup2_apply( OTL_Bytes    table,
+                          OTL_Parser   parser )
+  {
+    OTL_Bytes  p = table;
+    OTL_Bytes  coverage, sequence;
+    OTL_UInt   format, gindex, index, property;
+    OTL_Int    index;
+    OTL_Bool   subst = 0;
+
+    if ( context_len != 0xFFFFU && context_len < 1 )
+      goto Exit;
+
+    gindex = otl_parser_get_gindex( parser );
+
+    if ( !otl_parser_check_property( parser, gindex, &property ) )
+      goto Exit;
+
+    p        += 2;  /* skip format */
+    coverage  = table + OTL_NEXT_USHORT(p);
+    seq_count = OTL_NEXT_USHORT(p);
+    index     = otl_coverage_lookup( coverage, gindex );
+
+    if ( (OTL_UInt) index >= seq_count )
+      goto Exit;
+
+    p       += index*2;
+    sequence = table + OTL_PEEK_USHORT(p);
+    p        = sequence;
+    count    = OTL_NEXT_USHORT(p);
+
+    otl_parser_replace_n( parser, count, p );
+    subst = 1;
+
+   Exit:
+    return subst;
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 3                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+ /*
+  *  3: Alternate Substitution - Table format(s)
+  *
+  *  Replaces a single glyph by another one taken liberally
+  *  in a list of alternatives
+  *
+  *   Name         Offset    Size       Description
+  *   -----------------------------------------------------------
+  *   format       0         2          sub-table format (1)
+  *   offset       2         2          offset to coverage table
+  *   count        4         2          coverage table count
+  *   alternates[] 6         2*count    offsets to alternate items
+  *
+  *   each alternate item has the following format:
+  *
+  *   Name         Offset    Size       Description
+  *   -----------------------------------------------------------
+  *   count        0         2          number of replacement glyphs
+  *   gindices[]   2         2*count    string of glyph indices, each one
+  *                                     is a valid alternative
+  */
+
+  static void
+  otl_alternate_set_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    /* XXX: check glyph indices */
+  }
+
+
+  static void
+  otl_gsub_lookup3_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_alternate_set_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static OTL_Bool
+  otl_gsub_lookup3_apply( OTL_Bytes    table,
+                          OTL_Parser   parser )
+  {
+    OTL_Bytes  p = table;
+    OTL_Bytes  coverage, alternates;
+    OTL_UInt   format, gindex, index, property;
+    OTL_Int    index;
+    OTL_Bool   subst = 0;
+
+    OTL_GSUB_Alternate  alternate = parser->alternate;
+
+    if ( context_len != 0xFFFFU && context_len < 1 )
+      goto Exit;
+
+    if ( alternate == NULL )
+      goto Exit;
+
+    gindex = otl_parser_get_gindex( parser );
+
+    if ( !otl_parser_check_property( parser, gindex, &property ) )
+      goto Exit;
+
+    p        += 2;  /* skip format */
+    coverage  = table + OTL_NEXT_USHORT(p);
+    seq_count = OTL_NEXT_USHORT(p);
+    index     = otl_coverage_lookup( coverage, gindex );
+
+    if ( (OTL_UInt) index >= seq_count )
+      goto Exit;
+
+    p         += index*2;
+    alternates = table + OTL_PEEK_USHORT(p);
+    p          = alternates;
+    count      = OTL_NEXT_USHORT(p);
+
+    gindex = alternate->handler_func(
+                 gindex, count, p, alternate->handler_data );
+
+    otl_parser_replace_1( parser, gindex );
+    subst = 1;
+
+   Exit:
+    return subst;
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 4                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_ligature_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_UInt  glyph_id, count;
+
+    OTL_CHECK( 4 );
+    glyph_id = OTL_NEXT_USHORT( p );
+    count    = OTL_NEXT_USHORT( p );
+
+    if ( count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( 2*(count-1) );
+    /* XXX: check glyph indices */
+  }
+
+
+  static void
+  otl_ligature_set_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_ligature_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gsub_lookup4_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_ligature_set_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 5                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  static void
+  otl_sub_rule_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   glyph_count, subst_count;
+
+    OTL_CHECK( 4 );
+    glyph_count = OTL_NEXT_USHORT( p );
+    subst_count = OTL_NEXT_USHORT( p );
+
+    if ( glyph_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( (glyph_count-1)*2 + substcount*4 );
+
+    /* XXX: check glyph indices and subst lookups */
+  }
+
+
+  static void
+  otl_sub_rule_set_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_sub_class_rule_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_UInt  glyph_count, subst_count;
+
+    OTL_CHECK( 4 );
+    glyph_count = OTL_NEXT_USHORT( p );
+    subst_count = OTL_NEXT_USHORT( p );
+
+    if ( glyph_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( (glyph_count-1)*2 + substcount*4 );
+
+    /* XXX: check glyph indices and subst lookups */
+  }
+
+
+  static void
+  otl_sub_class_rule_set_validate( OTL_Bytes      table,
+                                   OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_sub_class_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gsub_lookup5_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_sub_rule_set_validate( table + coverage, valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, class_def, count;
+
+          OTL_CHECK( 6 );
+          coverage  = OTL_NEXT_USHORT( p );
+          class_def = OTL_NEXT_USHORT( p );
+          count     = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate        ( table + coverage, valid );
+          otl_class_definition_validate( table + class_def, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_sub_class_rule_set_validate( table + coveragen valid );
+        }
+        break;
+
+      case 3:
+        {
+          OTL_UInt  glyph_count, subst_count, count;
+
+          OTL_CHECK( 4 );
+          glyph_count = OTL_NEXT_USHORT( p );
+          subst_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*glyph_count + 4*subst_count );
+          for ( count = glyph_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 6                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  static void
+  otl_chain_sub_rule_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   back_count, input_count, ahead_count, subst_count, count;
+
+    OTL_CHECK( 2 );
+    back_count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*back_count+2 );
+    p += 2*back_count;
+
+    input_count = OTL_NEXT_USHORT( p );
+    if ( input_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( 2*input_count );
+    p += 2*(input_count-1);
+
+    ahead_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( 2*ahead_count + 2 );
+    p += 2*ahead_count;
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( 4*count );
+
+    /* XXX: check glyph indices and subst lookups */
+  }
+
+
+  static void
+  otl_chain_sub_rule_set_validate( OTL_Bytes      table,
+                                   OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_chain_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_chain_sub_class_rule_validate( OTL_Bytes      table,
+                                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   back_count, input_count, ahead_count, subst_count, count;
+
+    OTL_CHECK( 2 );
+    back_count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*back_count+2 );
+    p += 2*back_count;
+
+    input_count = OTL_NEXT_USHORT( p );
+    if ( input_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( 2*input_count );
+    p += 2*(input_count-1);
+
+    ahead_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( 2*ahead_count + 2 );
+    p += 2*ahead_count;
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( 4*count );
+
+    /* XXX: check class indices and subst lookups */
+  }
+
+
+
+  static void
+  otl_chain_sub_class_set_validate( OTL_Bytes      table,
+                                    OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_chain_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gsub_lookup6_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_chain_sub_rule_set_validate( table + coverage, valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, back_class, input_class, ahead_class, count;
+
+          OTL_CHECK( 10 );
+          coverage    = OTL_NEXT_USHORT( p );
+          back_class  = OTL_NEXT_USHORT( p );
+          input_class = OTL_NEXT_USHORT( p );
+          ahead_class = OTL_NEXT_USHORT( p );
+          count       = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          otl_class_definition_validate( table + back_class,  valid );
+          otl_class_definition_validate( table + input_class, valid );
+          otl_class_definition_validate( table + ahead_class, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_chain_sub_class_set( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      case 3:
+        {
+          OTL_UInt  back_count, input_count, ahead_count, subst_count, count;
+
+          OTL_CHECK( 2 );
+          back_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*back_count+2 );
+          for ( count = back_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          input_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*input_count+2 );
+          for ( count = input_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          ahead_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*ahead_count+2 );
+          for ( count = ahead_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          subst_count = OTL_NEXT_USHORT( p );
+          OTL_CHECK( subst_count*4 );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 6                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gsub_lookup7_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt          lookup_type, lookup_offset;
+          OTL_ValidateFunc  validate;
+
+          OTL_CHECK( 6 );
+          lookup_type   = OTL_NEXT_USHORT( p );
+          lookup_offset = OTL_NEXT_ULONG( p );
+
+          if ( lookup_type == 0 || lookup_type >= 7 )
+            OTL_INVALID_DATA;
+
+          validate = otl_gsub_validate_funcs[ lookup_type-1 ];
+          validate( table + lookup_offset, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static const OTL_ValidateFunc  otl_gsub_validate_funcs[ 7 ] =
+  {
+    otl_gsub_lookup1_validate,
+    otl_gsub_lookup2_validate,
+    otl_gsub_lookup3_validate,
+    otl_gsub_lookup4_validate,
+    otl_gsub_lookup5_validate,
+    otl_gsub_lookup6_validate
+  };
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                         GSUB TABLE                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  OTL_LOCALDEF( void )
+  otl_gsub_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   scripts, features, lookups;
+
+    OTL_CHECK( 10 );
+
+    if ( OTL_NEXT_USHORT( p ) != 0x10000UL )
+      OTL_INVALID_DATA;
+
+    scripts  = OTL_NEXT_USHORT( p );
+    features = OTL_NEXT_USHORT( p );
+    lookups  = OTL_NEXT_USHORT( p );
+
+    otl_script_list_validate ( table + scripts, valid );
+    otl_feature_list_validate( table + features, valid );
+
+    otl_lookup_list_validate( table + lookups, 7, otl_gsub_validate_funcs,
+                              valid );
+  }
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlgsub.h b/nx-X11/extras/freetype2/src/otlayout/otlgsub.h
new file mode 100644
index 000000000..db5edecf1
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlgsub.h
@@ -0,0 +1,26 @@
+#ifndef __OTL_GSUB_H__
+#define __OTL_GSUB_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  typedef OTL_UInt  (*OTL_GSUB_AlternateFunc)( OTL_UInt     gindex,
+                                               OTL_UInt     count,
+                                               OTL_Bytes    alternates,
+                                               OTL_Pointer  data );
+
+  typedef struct OTL_GSUB_AlternateRec_
+  {
+    OTL_GSUB_AlternateFunc  handler_func;
+    OTL_Pointer             handler_data;
+
+  } OTL_GSUB_AlternateRec, *OTL_GSUB_Alternate;
+
+  OTL_LOCAL( void )
+  otl_gsub_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_GSUB_H__ */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otljstf.c b/nx-X11/extras/freetype2/src/otlayout/otljstf.c
new file mode 100644
index 000000000..b0fa9f406
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otljstf.c
@@ -0,0 +1,189 @@
+#include "otljstf.h"
+#include "otlcommn.h"
+#include "otlgpos.h"
+
+  static void
+  otl_jstf_extender_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+  }
+
+
+  static void
+  otl_jstf_gsub_mods_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count*2 );
+
+    /* XXX: check GSUB lookup indices */
+  }
+
+
+  static void
+  otl_jstf_gpos_mods_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count*2 );
+
+    /* XXX: check GPOS lookup indices */
+  }
+
+
+  static void
+  otl_jstf_max_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_gpos_subtable_check( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_jstf_priority_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   offset;
+
+    OTL_CHECK( 20 );
+
+    /* shrinkage GSUB enable/disable */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gsub_mods_validate( table + val, valid );
+
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gsub_mods_validate( table + val, valid );
+
+    /* shrinkage GPOS enable/disable */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gpos_mods_validate( table + val, valid );
+
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gpos_mods_validate( table + val, valid );
+
+    /* shrinkage JSTF max */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_max_validate( table + val, valid );
+
+    /* extension GSUB enable/disable */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gsub_mods_validate( table + val, valid );
+
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gsub_mods_validate( table + val, valid );
+
+    /* extension GPOS enable/disable */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gpos_mods_validate( table + val, valid );
+
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gpos_mods_validate( table + val, valid );
+
+    /* extension JSTF max */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_max_validate( table + val, valid );
+  }
+
+  static void
+  otl_jstf_lang_validate( OTL_Bytes      table,
+                          OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_jstf_priority_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_jstf_script_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, extender, default_lang;
+
+    OTL_CHECK( 6 );
+    extender     = OTL_NEXT_USHORT( p );
+    default_lang = OTL_NEXT_USHORT( p );
+    count        = OTL_NEXT_USHORT( p );
+
+    if ( extender )
+      otl_jstf_extender_validate( table + extender, valid );
+
+    if ( default_lang )
+      otl_jstf_lang_validate( table + default_lang, valid );
+
+    OTL_CHECK( 6*count );
+
+    for ( ; count > 0; count-- )
+    {
+      p += 4;  /* ignore tag */
+      otl_jstf_lang_validate( table + OTL_NEXT_USHORT( p ), valid );
+    }
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_jstf_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 4 );
+
+    if ( OTL_NEXT_ULONG( p ) != 0x10000UL )
+      OTL_INVALID_DATA;
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count*6 );
+
+    for ( ; count > 0; count++ )
+    {
+      p += 4;  /* ignore tag */
+      otl_jstf_script_validate( table + OTL_NEXT_USHORT( p ), valid );
+    }
+  }
+  
\ No newline at end of file
diff --git a/nx-X11/extras/freetype2/src/otlayout/otljstf.h b/nx-X11/extras/freetype2/src/otlayout/otljstf.h
new file mode 100644
index 000000000..c8a98a64a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otljstf.h
@@ -0,0 +1,14 @@
+#ifndef __OTL_JSTF_H__
+#define __OTL_JSTF_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_LOCAL( void )
+  otl_jstf_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_JSTF_H__ */
\ No newline at end of file
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlparse.c b/nx-X11/extras/freetype2/src/otlayout/otlparse.c
new file mode 100644
index 000000000..705c0c60f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlparse.c
@@ -0,0 +1,142 @@
+#include "otlparse.h"
+#include "otlutils.h"
+
+  static void
+  otl_string_ensure( OTL_String  string,
+                     OTL_UInt    count,
+                     OTL_Parser  parser )
+  {
+    count += string->length;
+
+    if ( count > string->capacity )
+    {
+      OTL_UInt    old_count = string->capacity;
+      OTL_UInt    new_count = old_count;
+      OTL_Memory  memory    = parser->memory;
+
+      while ( new_count < count )
+        new_count += (new_count >> 1) + 16;
+
+      if ( OTL_MEM_RENEW_ARRAY( string->glyphs, old_count, new_count ) )
+        otl_parser_error( parser, OTL_Parse_Err_Memory );
+
+      string->capacity = new_count;
+    }
+  }
+
+#define  OTL_STRING_ENSURE(str,count,parser)                   \
+           OTL_BEGIN_STMNT                                     \
+             if ( (str)->length + (count) > (str)>capacity )   \
+               otl_string_ensure( str, count, parser );        \
+           OTL_END_STMNT
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_parser_get_gindex( OTL_Parser  parser )
+  {
+    OTL_String  in = parser->str_in;
+
+    if ( in->cursor >= in->num_glyphs )
+      otl_parser_error( parser, OTL_Err_Parser_Internal );
+
+    return in->str[ in->cursor ].gindex;
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_parser_error( OTL_Parser      parser,
+                    OTL_ParseError  error; )
+  {
+    parser->error = error;
+    otl_longjmp( parser->jump_buffer, 1 );
+  }
+
+#define  OTL_PARSER_UNCOVERED(x)  otl_parser_error( x, OTL_Parse_Err_UncoveredGlyph );
+
+  OTL_LOCAL( void )
+  otl_parser_check_property( OTL_Parser  parser,
+                             OTL_UInt    gindex,
+                             OTL_UInt    flags,
+                             OTL_UInt   *aproperty );
+
+  OTL_LOCALDEF( void )
+  otl_parser_replace_1( OTL_Parser  parser,
+                        OTL_UInt    gindex )
+  {
+    OTL_String       in  = parser->str_in;
+    OTL_String       out = parser->str_out;
+    OTL_StringGlyph  glyph, in_glyph;
+
+    /* sanity check */
+    if ( in == NULL               ||
+         out == NULL              ||
+         in->length == 0          ||
+         in->cursor >= in->length )
+    {
+      /* report as internal error, since these should */
+      /* never happen !!                              */
+      otl_parser_error( parser, OTL_Err_Parse_Internal );
+    }
+
+    OTL_STRING_ENSURE( out, 1, parser );
+    glyph    = out->glyphs + out->length;
+    in_glyph = in->glyphs  + in->cursor;
+
+    glyph->gindex        = gindex;
+    glyph->property      = in_glyph->property;
+    glyph->lig_component = in_glyph->lig_component;
+    glyph->lig_id        = in_glyph->lig_id;
+
+    out->length += 1;
+    out->cursor  = out->length;
+    in->cursor  += 1;
+  }
+
+  OTL_LOCALDEF( void )
+  otl_parser_replace_n( OTL_Parser  parser,
+                        OTL_UInt    count,
+                        OTL_Bytes   indices )
+  {
+    OTL_UInt         lig_component, lig_id, property;
+    OTL_String       in  = parser->str_in;
+    OTL_String       out = parser->str_out;
+    OTL_StringGlyph  glyph, in_glyph;
+    OTL_Bytes        p = indices;
+
+    /* sanity check */
+    if ( in == NULL               ||
+         out == NULL              ||
+         in->length == 0          ||
+         in->cursor >= in->length )
+    {
+      /* report as internal error, since these should */
+      /* never happen !!                              */
+      otl_parser_error( parser, OTL_Err_Parse_Internal );
+    }
+
+    OTL_STRING_ENSURE( out, count, parser );
+    glyph    = out->glyphs + out->length;
+    in_glyph = in->glyphs  + in->cursor;
+
+    glyph->gindex = gindex;
+
+    lig_component = in_glyph->lig_component;
+    lig_id        = in_glyph->lid_id;
+    property      = in_glyph->property;
+
+    for ( ; count > 0; count-- )
+    {
+      glyph->gindex        = OTL_NEXT_USHORT(p);
+      glyph->property      = property;
+      glyph->lig_component = lig_component;
+      glyph->lig_id        = lig_id;
+
+      out->length ++;
+    }
+
+    out->cursor  = out->length;
+    in->cursor  += 1;
+  }
+
+
+
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlparse.h b/nx-X11/extras/freetype2/src/otlayout/otlparse.h
new file mode 100644
index 000000000..92f34bfdc
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlparse.h
@@ -0,0 +1,99 @@
+#ifndef __OTL_PARSER_H__
+#define __OTL_PARSER_H__
+
+#include "otlayout.h"
+#include "otlgdef.h"
+#include "otlgsub.h"
+#include "otlgpos.h"
+
+OTL_BEGIN_HEADER
+
+  typedef struct OTL_ParserRec_*   OTL_Parser;
+
+  typedef struct OTL_StringRec_*   OTL_String;
+
+  typedef struct OTL_StringGlyphRec_
+  {
+    OTL_UInt  gindex;
+    OTL_UInt  properties;
+    OTL_UInt  lig_component;
+    OTL_UInt  lig_id;
+
+  } OTL_StringGlyphRec, *OTL_StringGlyph;
+
+  typedef struct OTL_StringRec_
+  {
+    OTL_StringGlyph  glyphs;
+    OTL_UInt         cursor;
+    OTL_UInt         length;
+    OTL_UInt         capacity;
+
+  } OTL_StringRec;
+
+  typedef struct OTL_ParserRec_
+  {
+    OTL_Bytes      tab_gdef;
+    OTL_Bytes      tab_gsub;
+    OTL_Bytes      tab_gpos;
+    OTL_Bytes      tab_base;
+    OTL_Bytes      tab_jstf;
+
+    OTL_Alternate  alternate;  /* external alternate handler */
+
+    OTL_UInt       context_len;
+    OTL_UInt       markup_flags;
+
+    OTL_jmp_buf    jump_buffer;
+    OTL_Memory     memory;
+    OTL_Error      error;
+
+    OTL_StringRec  strings[2];
+    OTL_String     str_in;
+    OTL_String     str_out;
+
+  } OTL_ParserRec;
+
+  typedef enum
+  {
+    OTL_Err_Parser_Ok = 0,
+    OTL_Err_Parser_InvalidData,
+    OTL_Err_Parser_UncoveredGlyph
+
+  } OTL_ParseError;
+
+  OTL_LOCAL( OTL_UInt )
+  otl_parser_get_gindex( OTL_Parser  parser );
+
+
+  OTL_LOCAL( void )
+  otl_parser_error( OTL_Parser  parser, OTL_ParserError  error );
+
+#define  OTL_PARSER_UNCOVERED(x)  \
+           otl_parser_error( x, OTL_Err_Parser_UncoveredGlyph )
+
+  OTL_LOCAL( void )
+  otl_parser_check_property( OTL_Parser  parser,
+                             OTL_UInt    gindex,
+                             OTL_UInt    flags,
+                             OTL_UInt   *aproperty );
+
+ /* copy current input glyph to output */
+  OTL_LOCAL( void )
+  otl_parser_copy_1( OTL_Parser  parser );
+
+ /* copy current input glyph to output, replacing its index */
+  OTL_LOCAL( void )
+  otl_parser_replace_1( OTL_Parser  parser,
+                        OTL_UInt    gindex );
+
+ /* copy current input glyph to output, replacing it by several indices */
+ /* read directly from the table                                        */
+  OTL_LOCAL( void )
+  otl_parser_replace_n( OTL_Parser  parser,
+                        OTL_UInt    count,
+                        OTL_Bytes   indices );
+
+OTL_END_HEADER
+
+#endif /* __OTL_PARSER_H__ */
+
diff --git a/nx-X11/extras/freetype2/src/otlayout/otltable.h b/nx-X11/extras/freetype2/src/otlayout/otltable.h
new file mode 100644
index 000000000..af7bd78a5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otltable.h
@@ -0,0 +1,60 @@
+#ifndef __OTL_TABLE_H__
+#define __OTL_TABLE_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  typedef struct OTL_TableRec_*    OTL_Table;
+
+  typedef enum
+  {
+    OTL_TABLE_TYPE_GDEF = 1,
+    OTL_TABLE_TYPE_GSUB,
+    OTL_TABLE_TYPE_GPOS,
+    OTL_TABLE_TYPE_BASE,
+    OTL_TABLE_TYPE_JSTF
+
+  } OTL_TableType;
+
+
+ /* this may become a private structure later */
+  typedef struct OTL_TableRec_
+  {
+    OTL_TableType  type;
+    OTL_Bytes      base;
+    OTL_Bytes      limit;
+
+    OTL_Tag        script_tag;
+    OTL_Tag        lang_tag;
+
+    OTL_UInt       lookup_count;
+    OTL_Byte*      lookup_flags;
+
+    OTL_UInt       feature_count;
+    OTL_Tag        feature_tags;
+    OTL_Byte*      feature_flags;
+
+  } OTL_TableRec;
+
+
+  OTL_API( OTL_Error )
+  otl_table_validate( OTL_Bytes      table,
+                      OTL_Size       size,
+                      OTL_TableType  type,
+                      OTL_Size      *abyte_size );
+
+  OTL_API( void )
+  otl_table_init( OTL_Table      table,
+                  OTL_TableType  type,
+                  OTL_Bytes      base,
+                  OTL_Size       size );
+
+  OTL_API( void )
+  otl_table_set_script( OTL_Table      table,
+                        OTL_ScriptTag  script,
+                        OTL_LangTag    language );
+
+OTL_END_HEADER
+
+#endif /* __OTL_TABLE_H__ */
diff --git a/nx-X11/extras/freetype2/src/otlayout/otltags.h b/nx-X11/extras/freetype2/src/otlayout/otltags.h
new file mode 100644
index 000000000..d954b5851
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otltags.h
@@ -0,0 +1,88 @@
+/* this file may be included several times by other parts of */
+/* the OpenType Layout library.. don't add #ifdef .. #endif  */
+/* delimiters to it...                                       */
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       SCRIPT TAGS                            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#ifndef OTL_SCRIPT_TAG
+#define OTL_SCRIPT_TAG(c1,c2,c3,c4,s,n)  /* void */
+#endif
+
+OTL_SCRIPT_TAG( 'a','r','a','b', "Arabic", ARABIC )
+OTL_SCRIPT_TAG( 'a','r','m','n', "Armenian", ARMENIAN )
+OTL_SCRIPT_TAG( 'b','e','n','g', "Bengali", BENGALI )
+OTL_SCRIPT_TAG( 'b','o','p','o', "Bopomofo", BOPOMOFO )
+OTL_SCRIPT_TAG( 'b','r','a','i', "Braille", BRAILLE )
+OTL_SCRIPT_TAG( 'b','y','z','m', "Byzantine Music", BYZANTINE_MUSIC )
+OTL_SCRIPT_TAG( 'c','a','n','s', "Canadian Syllabic", CANADIAN )
+OTL_SCRIPT_TAG( 'c','h','e','r', "Cherokee", CHEROKEE )
+OTL_SCRIPT_TAG( 'h','a','n','i', "CJK Ideographic", CJK )
+OTL_SCRIPT_TAG( 'c','y','r','l', "Cyrillic", CYRILLIC )
+OTL_SCRIPT_TAG( 'd','f','l','t', "Default", DEFAULT )
+OTL_SCRIPT_TAG( 'd','e','v','a', "Devanagari", DEVANAGARI )
+OTL_SCRIPT_TAG( 'e','t','h','i', "Ethiopic", ETHIOPIC )
+OTL_SCRIPT_TAG( 'g','e','o','r', "Georgian", GEORGIAN )
+OTL_SCRIPT_TAG( 'g','r','e','k', "Greek", GREEK )
+OTL_SCRIPT_TAG( 'g','u','j','r', "Gujarati", GUJARATI )
+OTL_SCRIPT_TAG( 'g','u','r','u', "Gurmukhi", GURMUKHI )
+OTL_SCRIPT_TAG( 'j','a','m','o', "Hangul Jamo", JAMO )
+OTL_SCRIPT_TAG( 'h','a','n','g', "Hangul", HANGUL )
+OTL_SCRIPT_TAG( 'h','e','b','r', "Hebrew", HEBREW )
+OTL_SCRIPT_TAG( 'h','i','r','a', "Hiragana", HIRAGANA ) /* not in TAGS.txt */
+OTL_SCRIPT_TAG( 'k','n','d','a', "Kannada", KANNADA )
+OTL_SCRIPT_TAG( 'k','a','n','a', "Katakana", KATAKANA ) /* in TAGS.txt, means Hiragana _and_ Katakana */
+OTL_SCRIPT_TAG( 'k','h','m','r', "Khmer", KHMER )
+OTL_SCRIPT_TAG( 'l','a','o',' ', "Lao", LAO )
+OTL_SCRIPT_TAG( 'l','a','t','n', "Latin", LATIN )
+OTL_SCRIPT_TAG( 'm','l','y','m', "Malayalam", MALAYALAM )
+OTL_SCRIPT_TAG( 'm','o','n','g', "Mongolian", MONGOLIAN )
+OTL_SCRIPT_TAG( 'm','y','m','r', "Myanmar", MYANMAR )
+OTL_SCRIPT_TAG( 'o','g','a','m', "Ogham", OGHAM )
+OTL_SCRIPT_TAG( 'o','r','y','a', "Oriya", ORIYA )
+OTL_SCRIPT_TAG( 'r','u','n','r', "Runic", RUNIC )
+OTL_SCRIPT_TAG( 's','i','n','h', "Sinhala", SINHALA )
+OTL_SCRIPT_TAG( 's','y','r','c', "Syriac", SYRIAC )
+OTL_SCRIPT_TAG( 't','a','m','l', "Tamil", TAMIL )
+OTL_SCRIPT_TAG( 't','e','l','u', "Telugu", TELUGU )
+OTL_SCRIPT_TAG( 't','h','a','a', "Thaana", THAANA )
+OTL_SCRIPT_TAG( 't','h','a','i', "Thai", THAI )
+OTL_SCRIPT_TAG( 't','i','b','t', "Tibetan", TIBETAN )
+OTL_SCRIPT_TAG( 'y','i',' ',' ', "Yi", YI )
+
+#undef OTL_SCRIPT_TAG
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       LANGUAGE TAGS                          *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#ifndef OTL_LANG_TAG
+#define OTL_LANG_TAG(c1,c2,c3,c4,s,n)  /* void */
+#endif
+
+#undef OTL_LANG_TAG
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       FEATURE TAGS                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#ifndef OTL_FEATURE_TAG
+#define OTL_FEATURE_TAG(c1,c2,c3,c4,s,n)  /* void */
+#endif
+
+#undef OTL_FEATURE_TAG
+
diff --git a/nx-X11/extras/freetype2/src/otlayout/otlutils.h b/nx-X11/extras/freetype2/src/otlayout/otlutils.h
new file mode 100644
index 000000000..de50f66f0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/otlayout/otlutils.h
@@ -0,0 +1,33 @@
+#ifndef __OTLAYOUT_UTILS_H__
+#define __OTLAYOUT_UTILS_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_LOCAL( OTL_Error )
+  otl_mem_alloc( OTL_Pointer*  pblock,
+                 OTL_ULong     size,
+                 OTL_Memory    memory );
+
+  OTL_LOCAL( void )
+  otl_mem_free( OTL_Pointer*  pblock,
+                OTL_Memory    memory );
+
+  OTL_LOCAL( OTL_Error )
+  otl_mem_realloc( OTL_Pointer  *pblock,
+                   OTL_ULong     cur_size,
+                   OTL_ULong     new_size,
+                   OTL_Memory    memory );
+
+#define  OTL_MEM_ALLOC(p,s)       otl_mem_alloc( (void**)&(p), (s), memory )
+#define  OTL_MEM_FREE(p)          otl_mem_free( (void**)&(p), memory )
+#define  OTL_MEM_REALLOC(p,c,n)   otl_mem_realloc( (void**)&(p), (c), (s), memory )
+
+#define  OTL_MEM_NEW(p)   OTL_MEM_ALLOC(p,sizeof(*(p)))
+#define  OTL_MEM_NEW_ARRAY(p,c)  OTL_MEM_ALLOC(p,(c)*sizeof(*(p)))
+#define  OTL_MEM_RENEW_ARRAY(p,c,n)  OTL_MEM_REALLOC(p,(c)*sizeof(*(p)),(n)*sizeof(*(p)))
+
+OTL_END_HEADER
+
+#endif /* __OTLAYOUT_UTILS_H__ */
diff --git a/nx-X11/extras/freetype2/src/pcf/Jamfile b/nx-X11/extras/freetype2/src/pcf/Jamfile
new file mode 100644
index 000000000..3a884f534
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/pcf Jamfile (c) 2001, 2003 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) pcf ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = pcfdrivr pcfread pcfutil ;
+  }
+  else
+  {
+    _sources = pcf ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/pcf Jamfile
diff --git a/nx-X11/extras/freetype2/src/pcf/descrip.mms b/nx-X11/extras/freetype2/src/pcf/descrip.mms
new file mode 100644
index 000000000..a3fd23180
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/descrip.mms
@@ -0,0 +1,35 @@
+#
+# FreeType 2 pcf driver compilation rules for VMS
+#
+
+
+# Copyright (C) 2001, 2002 by
+# Francesco Zappa Nardelli
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.pcf])
+
+OBJS=pcf.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/pcf/module.mk b/nx-X11/extras/freetype2/src/pcf/module.mk
new file mode 100644
index 000000000..614c31920
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/module.mk
@@ -0,0 +1,32 @@
+#
+# FreeType 2 PCF module definition
+#
+
+# Copyright 2000 by
+# Francesco Zappa Nardelli
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+make_module_list: add_pcf_driver
+
+add_pcf_driver:
+	$(OPEN_DRIVER)pcf_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)pcf       $(ECHO_DRIVER_DESC)pcf bitmap fonts$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/pcf/pcf.c b/nx-X11/extras/freetype2/src/pcf/pcf.c
new file mode 100644
index 000000000..11d5b7b2a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcf.c
@@ -0,0 +1,36 @@
+/*  pcf.c
+
+    FreeType font driver for pcf fonts
+
+  Copyright 2000-2001, 2003 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+
+
+#include <ft2build.h>
+#include "pcfutil.c"
+#include "pcfread.c"
+#include "pcfdrivr.c"
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/pcf.h b/nx-X11/extras/freetype2/src/pcf/pcf.h
new file mode 100644
index 000000000..64acefc4e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcf.h
@@ -0,0 +1,237 @@
+/*  pcf.h
+
+  FreeType font driver for pcf fonts
+
+  Copyright (C) 2000, 2001, 2002, 2003 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#ifndef __PCF_H__
+#define __PCF_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+#include FT_INTERNAL_STREAM_H
+
+
+FT_BEGIN_HEADER
+
+  typedef struct  PCF_TableRec_
+  {
+    FT_ULong  type;
+    FT_ULong  format;
+    FT_ULong  size;
+    FT_ULong  offset;
+
+  } PCF_TableRec, *PCF_Table;
+
+
+  typedef struct  PCF_TocRec_
+  {
+    FT_ULong   version;
+    FT_ULong   count;
+    PCF_Table  tables;
+
+  } PCF_TocRec, *PCF_Toc;
+
+
+  typedef struct  PCF_ParsePropertyRec_
+  {
+    FT_Long  name;
+    FT_Byte  isString;
+    FT_Long  value;
+
+  } PCF_ParsePropertyRec, *PCF_ParseProperty;
+
+
+  typedef struct  PCF_PropertyRec_
+  {
+    FT_String*  name;
+    FT_Byte     isString;
+
+    union
+    {
+      FT_String*  atom;
+      FT_Long     integer;
+      FT_ULong    cardinal;
+
+    } value;
+
+  } PCF_PropertyRec, *PCF_Property;
+
+
+  typedef struct  PCF_Compressed_MetricRec_
+  {
+    FT_Byte  leftSideBearing;
+    FT_Byte  rightSideBearing;
+    FT_Byte  characterWidth;
+    FT_Byte  ascent;
+    FT_Byte  descent;
+
+  } PCF_Compressed_MetricRec, *PCF_Compressed_Metric;
+
+
+  typedef struct  PCF_MetricRec_
+  {
+    FT_Short  leftSideBearing;
+    FT_Short  rightSideBearing;
+    FT_Short  characterWidth;
+    FT_Short  ascent;
+    FT_Short  descent;
+    FT_Short  attributes;
+    FT_ULong  bits;
+
+  } PCF_MetricRec, *PCF_Metric;
+
+
+  typedef struct  PCF_AccelRec_
+  {
+    FT_Byte        noOverlap;
+    FT_Byte        constantMetrics;
+    FT_Byte        terminalFont;
+    FT_Byte        constantWidth;
+    FT_Byte        inkInside;
+    FT_Byte        inkMetrics;
+    FT_Byte        drawDirection;
+    FT_Long        fontAscent;
+    FT_Long        fontDescent;
+    FT_Long        maxOverlap;
+    PCF_MetricRec  minbounds;
+    PCF_MetricRec  maxbounds;
+    PCF_MetricRec  ink_minbounds;
+    PCF_MetricRec  ink_maxbounds;
+
+  } PCF_AccelRec, *PCF_Accel;
+
+
+  typedef struct  PCF_EncodingRec_
+  {
+    FT_Long    enc;
+    FT_UShort  glyph;
+
+  } PCF_EncodingRec, *PCF_Encoding;
+
+
+  typedef struct  PCF_FaceRec_
+  {
+    FT_FaceRec     root;
+
+    FT_StreamRec   gzip_stream;
+    FT_Stream      gzip_source;
+
+    char*          charset_encoding;
+    char*          charset_registry;
+
+    PCF_TocRec     toc;
+    PCF_AccelRec   accel;
+
+    int            nprops;
+    PCF_Property   properties;
+
+    FT_Long        nmetrics;
+    PCF_Metric     metrics;
+    FT_Long        nencodings;
+    PCF_Encoding   encodings;
+
+    FT_Short       defaultChar;
+
+    FT_ULong       bitmapsFormat;
+
+    FT_CharMap     charmap_handle;
+    FT_CharMapRec  charmap;  /* a single charmap per face */
+
+  } PCF_FaceRec, *PCF_Face;
+
+
+  /* macros for pcf font format */
+
+#define LSBFirst  0
+#define MSBFirst  1
+
+#define PCF_FILE_VERSION        ( ( 'p' << 24 ) | \
+                                  ( 'c' << 16 ) | \
+                                  ( 'f' <<  8 ) | 1 )
+#define PCF_FORMAT_MASK         0xFFFFFF00L
+
+#define PCF_DEFAULT_FORMAT      0x00000000L
+#define PCF_INKBOUNDS           0x00000200L
+#define PCF_ACCEL_W_INKBOUNDS   0x00000100L
+#define PCF_COMPRESSED_METRICS  0x00000100L
+
+#define PCF_FORMAT_MATCH( a, b ) \
+          ( ( (a) & PCF_FORMAT_MASK ) == ( (b) & PCF_FORMAT_MASK ) )
+
+#define PCF_GLYPH_PAD_MASK  ( 3 << 0 )
+#define PCF_BYTE_MASK       ( 1 << 2 )
+#define PCF_BIT_MASK        ( 1 << 3 )
+#define PCF_SCAN_UNIT_MASK  ( 3 << 4 )
+
+#define PCF_BYTE_ORDER( f ) \
+          ( ( (f) & PCF_BYTE_MASK ) ? MSBFirst : LSBFirst )
+#define PCF_BIT_ORDER( f ) \
+          ( ( (f) & PCF_BIT_MASK ) ? MSBFirst : LSBFirst )
+#define PCF_GLYPH_PAD_INDEX( f ) \
+          ( (f) & PCF_GLYPH_PAD_MASK )
+#define PCF_GLYPH_PAD( f ) \
+          ( 1 << PCF_GLYPH_PAD_INDEX( f ) )
+#define PCF_SCAN_UNIT_INDEX( f ) \
+          ( ( (f) & PCF_SCAN_UNIT_MASK ) >> 4 )
+#define PCF_SCAN_UNIT( f ) \
+          ( 1 << PCF_SCAN_UNIT_INDEX( f ) )
+#define PCF_FORMAT_BITS( f )             \
+          ( (f) & ( PCF_GLYPH_PAD_MASK | \
+                    PCF_BYTE_MASK      | \
+                    PCF_BIT_MASK       | \
+                    PCF_SCAN_UNIT_MASK ) )
+
+#define PCF_SIZE_TO_INDEX( s )  ( (s) == 4 ? 2 : (s) == 2 ? 1 : 0 )
+#define PCF_INDEX_TO_SIZE( b )  ( 1 << b )
+
+#define PCF_FORMAT( bit, byte, glyph, scan )          \
+          ( ( PCF_SIZE_TO_INDEX( scan )      << 4 ) | \
+            ( ( (bit)  == MSBFirst ? 1 : 0 ) << 3 ) | \
+            ( ( (byte) == MSBFirst ? 1 : 0 ) << 2 ) | \
+            ( PCF_SIZE_TO_INDEX( glyph )     << 0 ) )
+
+#define PCF_PROPERTIES        ( 1 << 0 )
+#define PCF_ACCELERATORS      ( 1 << 1 )
+#define PCF_METRICS           ( 1 << 2 )
+#define PCF_BITMAPS           ( 1 << 3 )
+#define PCF_INK_METRICS       ( 1 << 4 )
+#define PCF_BDF_ENCODINGS     ( 1 << 5 )
+#define PCF_SWIDTHS           ( 1 << 6 )
+#define PCF_GLYPH_NAMES       ( 1 << 7 )
+#define PCF_BDF_ACCELERATORS  ( 1 << 8 )
+
+#define GLYPHPADOPTIONS  4 /* I'm not sure about this */
+
+  FT_LOCAL( FT_Error )
+  pcf_load_font( FT_Stream,
+                 PCF_Face );
+
+FT_END_HEADER
+
+#endif /* __PCF_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/pcfdrivr.c b/nx-X11/extras/freetype2/src/pcf/pcfdrivr.c
new file mode 100644
index 000000000..b6b04b98f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcfdrivr.c
@@ -0,0 +1,651 @@
+/*  pcfdrivr.c
+
+    FreeType font driver for pcf files
+
+    Copyright (C) 2000, 2001, 2002, 2003, 2004 by
+    Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#include <ft2build.h>
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_GZIP_H
+#include FT_LZW_H
+#include FT_ERRORS_H
+#include FT_BDF_H
+
+#include "pcf.h"
+#include "pcfdrivr.h"
+#include "pcfread.h"
+
+#include "pcferror.h"
+#include "pcfutil.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pcfread
+
+#include FT_SERVICE_BDF_H
+#include FT_SERVICE_XFREE86_NAME_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_pcfdriver
+
+
+  typedef struct  PCF_CMapRec_
+  {
+    FT_CMapRec    root;
+    FT_UInt       num_encodings;
+    PCF_Encoding  encodings;
+
+  } PCF_CMapRec, *PCF_CMap;
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  pcf_cmap_init( FT_CMap     pcfcmap,   /* PCF_CMap */
+                 FT_Pointer  init_data )
+  {
+    PCF_CMap  cmap = (PCF_CMap)pcfcmap;
+    PCF_Face  face = (PCF_Face)FT_CMAP_FACE( pcfcmap );
+
+    FT_UNUSED( init_data );
+
+
+    cmap->num_encodings = (FT_UInt)face->nencodings;
+    cmap->encodings     = face->encodings;
+
+    return PCF_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  pcf_cmap_done( FT_CMap  pcfcmap )         /* PCF_CMap */
+  {
+    PCF_CMap  cmap = (PCF_CMap)pcfcmap;
+
+
+    cmap->encodings     = NULL;
+    cmap->num_encodings = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pcf_cmap_char_index( FT_CMap    pcfcmap,  /* PCF_CMap */
+                       FT_UInt32  charcode )
+  {
+    PCF_CMap      cmap      = (PCF_CMap)pcfcmap;
+    PCF_Encoding  encodings = cmap->encodings;
+    FT_UInt       min, max, mid;
+    FT_UInt       result    = 0;
+
+
+    min = 0;
+    max = cmap->num_encodings;
+
+    while ( min < max )
+    {
+      FT_UInt32  code;
+
+
+      mid  = ( min + max ) >> 1;
+      code = encodings[mid].enc;
+
+      if ( charcode == code )
+      {
+        result = encodings[mid].glyph + 1;
+        break;
+      }
+
+      if ( charcode < code )
+        max = mid;
+      else
+        min = mid + 1;
+    }
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pcf_cmap_char_next( FT_CMap    pcfcmap,   /* PCF_CMap */
+                      FT_UInt32  *acharcode )
+  {
+    PCF_CMap      cmap      = (PCF_CMap)pcfcmap;
+    PCF_Encoding  encodings = cmap->encodings;
+    FT_UInt       min, max, mid;
+    FT_UInt32     charcode  = *acharcode + 1;
+    FT_UInt       result    = 0;
+
+
+    min = 0;
+    max = cmap->num_encodings;
+
+    while ( min < max )
+    {
+      FT_UInt32  code;
+
+
+      mid  = ( min + max ) >> 1;
+      code = encodings[mid].enc;
+
+      if ( charcode == code )
+      {
+        result = encodings[mid].glyph + 1;
+        goto Exit;
+      }
+
+      if ( charcode < code )
+        max = mid;
+      else
+        min = mid + 1;
+    }
+
+    charcode = 0;
+    if ( min < cmap->num_encodings )
+    {
+      charcode = encodings[min].enc;
+      result   = encodings[min].glyph + 1;
+    }
+
+  Exit:
+    *acharcode = charcode;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_CMap_ClassRec  pcf_cmap_class =
+  {
+    sizeof ( PCF_CMapRec ),
+    pcf_cmap_init,
+    pcf_cmap_done,
+    pcf_cmap_char_index,
+    pcf_cmap_char_next
+  };
+
+
+  FT_CALLBACK_DEF( void )
+  PCF_Face_Done( FT_Face  pcfface )         /* PCF_Face */
+  {
+    PCF_Face   face   = (PCF_Face)pcfface;
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+
+    FT_FREE( face->encodings );
+    FT_FREE( face->metrics );
+
+    /* free properties */
+    {
+      PCF_Property  prop = face->properties;
+      FT_Int        i;
+
+
+      for ( i = 0; i < face->nprops; i++ )
+      {
+        prop = &face->properties[i];
+
+        FT_FREE( prop->name );
+        if ( prop->isString )
+          FT_FREE( prop->value );
+      }
+
+      FT_FREE( face->properties );
+    }
+
+    FT_FREE( face->toc.tables );
+    FT_FREE( pcfface->family_name );
+    FT_FREE( pcfface->available_sizes );
+    FT_FREE( face->charset_encoding );
+    FT_FREE( face->charset_registry );
+
+    FT_TRACE4(( "PCF_Face_Done: done face\n" ));
+
+    /* close gzip/LZW stream if any */
+    if ( pcfface->stream == &face->gzip_stream )
+    {
+      FT_Stream_Close( &face->gzip_stream );
+      pcfface->stream = face->gzip_source;
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  PCF_Face_Init( FT_Stream      stream,
+                 FT_Face        pcfface,        /* PCF_Face */
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    PCF_Face  face  = (PCF_Face)pcfface;
+    FT_Error  error = PCF_Err_Ok;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( face_index );
+
+
+    error = pcf_load_font( stream, face );
+    if ( error )
+    {
+      FT_Error  error2;
+
+
+      /* this didn't work, try gzip support! */
+      error2 = FT_Stream_OpenGzip( &face->gzip_stream, stream );
+      if ( FT_ERROR_BASE( error2 ) == FT_Err_Unimplemented_Feature )
+        goto Fail;
+
+      error = error2;
+      if ( error )
+      {
+        FT_Error  error3;
+
+
+        /* this didn't work, try LZW support! */
+        error3 = FT_Stream_OpenLZW( &face->gzip_stream, stream );
+        if ( FT_ERROR_BASE( error3 ) == FT_Err_Unimplemented_Feature )
+          goto Fail;
+
+        error = error3;
+        if ( error )
+          goto Fail;
+
+        face->gzip_source = stream;
+        pcfface->stream   = &face->gzip_stream;
+
+        stream = pcfface->stream;
+
+        error = pcf_load_font( stream, face );
+        if ( error )
+          goto Fail;
+      }
+      else
+      {
+        face->gzip_source = stream;
+        pcfface->stream   = &face->gzip_stream;
+
+        stream = pcfface->stream;
+
+        error = pcf_load_font( stream, face );
+        if ( error )
+          goto Fail;
+      }
+    }
+
+    /* set up charmap */
+    {
+      FT_String  *charset_registry = face->charset_registry;
+      FT_String  *charset_encoding = face->charset_encoding;
+      FT_Bool     unicode_charmap  = 0;
+
+
+      if ( charset_registry && charset_encoding )
+      {
+        char*  s = charset_registry;
+
+
+        /* Uh, oh, compare first letters manually to avoid dependency
+           on locales. */
+        if ( ( s[0] == 'i' || s[0] == 'I' ) &&
+             ( s[1] == 's' || s[1] == 'S' ) &&
+             ( s[2] == 'o' || s[2] == 'O' ) )
+        {
+          s += 3;
+          if ( !ft_strcmp( s, "10646" )                      ||
+               ( !ft_strcmp( s, "8859" ) &&
+                 !ft_strcmp( face->charset_encoding, "1" ) ) )
+          unicode_charmap = 1;
+        }
+      }
+
+      {
+        FT_CharMapRec  charmap;
+
+
+        charmap.face        = FT_FACE( face );
+        charmap.encoding    = FT_ENCODING_NONE;
+        charmap.platform_id = 0;
+        charmap.encoding_id = 0;
+
+        if ( unicode_charmap )
+        {
+          charmap.encoding    = FT_ENCODING_UNICODE;
+          charmap.platform_id = 3;
+          charmap.encoding_id = 1;
+        }
+
+        error = FT_CMap_New( &pcf_cmap_class, NULL, &charmap, NULL );
+
+#if 0
+        /* Select default charmap */
+        if ( pcfface->num_charmaps )
+          pcfface->charmap = pcfface->charmaps[0];
+#endif
+      }
+    }
+
+  Exit:
+    return error;
+
+  Fail:
+    FT_TRACE2(( "[not a valid PCF file]\n" ));
+    error = PCF_Err_Unknown_File_Format;  /* error */
+    goto Exit;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  PCF_Set_Pixel_Size( FT_Size  size,
+                      FT_UInt  pixel_width,
+                      FT_UInt  pixel_height )
+  {
+    PCF_Face  face = (PCF_Face)FT_SIZE_FACE( size );
+
+    FT_UNUSED( pixel_width );
+    FT_UNUSED( pixel_height );
+
+
+    FT_TRACE4(( "rec %d - pres %d\n", size->metrics.y_ppem,
+                                      face->root.available_sizes->y_ppem >> 6 ));
+
+    if ( size->metrics.y_ppem == face->root.available_sizes->y_ppem >> 6 )
+    {
+      size->metrics.ascender    = face->accel.fontAscent << 6;
+      size->metrics.descender   = face->accel.fontDescent * (-64);
+#if 0
+      size->metrics.height      = face->accel.maxbounds.ascent << 6;
+#endif
+      size->metrics.height      = size->metrics.ascender -
+                                  size->metrics.descender;
+
+      size->metrics.max_advance = face->accel.maxbounds.characterWidth << 6;
+
+      return PCF_Err_Ok;
+    }
+    else
+    {
+      FT_TRACE4(( "size WRONG\n" ));
+      return PCF_Err_Invalid_Pixel_Size;
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  PCF_Set_Point_Size( FT_Size     size,
+                      FT_F26Dot6  char_width,
+                      FT_F26Dot6  char_height,
+                      FT_UInt     horz_resolution,
+                      FT_UInt     vert_resolution )
+  {
+    FT_UNUSED( char_width );
+    FT_UNUSED( char_height );
+    FT_UNUSED( horz_resolution );
+    FT_UNUSED( vert_resolution );
+
+    return PCF_Set_Pixel_Size( size, 0, 0 );
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  PCF_Glyph_Load( FT_GlyphSlot  slot,
+                  FT_Size       size,
+                  FT_UInt       glyph_index,
+                  FT_Int32      load_flags )
+  {
+    PCF_Face    face   = (PCF_Face)FT_SIZE_FACE( size );
+    FT_Stream   stream = face->root.stream;
+    FT_Error    error  = PCF_Err_Ok;
+    FT_Bitmap*  bitmap = &slot->bitmap;
+    PCF_Metric  metric;
+    int         bytes;
+
+    FT_UNUSED( load_flags );
+
+
+    FT_TRACE4(( "load_glyph %d ---", glyph_index ));
+
+    if ( !face )
+    {
+      error = PCF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    if ( glyph_index > 0 )
+      glyph_index--;
+
+    metric = face->metrics + glyph_index;
+
+    bitmap->rows       = metric->ascent + metric->descent;
+    bitmap->width      = metric->rightSideBearing - metric->leftSideBearing;
+    bitmap->num_grays  = 1;
+    bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
+
+    FT_TRACE6(( "BIT_ORDER %d ; BYTE_ORDER %d ; GLYPH_PAD %d\n",
+                  PCF_BIT_ORDER( face->bitmapsFormat ),
+                  PCF_BYTE_ORDER( face->bitmapsFormat ),
+                  PCF_GLYPH_PAD( face->bitmapsFormat ) ));
+
+    switch ( PCF_GLYPH_PAD( face->bitmapsFormat ) )
+    {
+    case 1:
+      bitmap->pitch = ( bitmap->width + 7 ) >> 3;
+      break;
+
+    case 2:
+      bitmap->pitch = ( ( bitmap->width + 15 ) >> 4 ) << 1;
+      break;
+
+    case 4:
+      bitmap->pitch = ( ( bitmap->width + 31 ) >> 5 ) << 2;
+      break;
+
+    case 8:
+      bitmap->pitch = ( ( bitmap->width + 63 ) >> 6 ) << 3;
+      break;
+
+    default:
+      return PCF_Err_Invalid_File_Format;
+    }
+
+    /* XXX: to do: are there cases that need repadding the bitmap? */
+    bytes = bitmap->pitch * bitmap->rows;
+
+    error = ft_glyphslot_alloc_bitmap( slot, bytes );
+    if ( error )
+      goto Exit;
+
+    if ( FT_STREAM_SEEK( metric->bits )          ||
+         FT_STREAM_READ( bitmap->buffer, bytes ) )
+      goto Exit;
+
+    if ( PCF_BIT_ORDER( face->bitmapsFormat ) != MSBFirst )
+      BitOrderInvert( bitmap->buffer, bytes );
+
+    if ( ( PCF_BYTE_ORDER( face->bitmapsFormat ) !=
+           PCF_BIT_ORDER( face->bitmapsFormat )  ) )
+    {
+      switch ( PCF_SCAN_UNIT( face->bitmapsFormat ) )
+      {
+      case 1:
+        break;
+
+      case 2:
+        TwoByteSwap( bitmap->buffer, bytes );
+        break;
+
+      case 4:
+        FourByteSwap( bitmap->buffer, bytes );
+        break;
+      }
+    }
+
+    slot->bitmap_left = metric->leftSideBearing;
+    slot->bitmap_top  = metric->ascent;
+
+    slot->metrics.horiAdvance  = metric->characterWidth << 6;
+    slot->metrics.horiBearingX = metric->leftSideBearing << 6;
+    slot->metrics.horiBearingY = metric->ascent << 6;
+    slot->metrics.width        = ( metric->rightSideBearing -
+                                   metric->leftSideBearing ) << 6;
+    slot->metrics.height       = bitmap->rows << 6;
+
+    slot->linearHoriAdvance = (FT_Fixed)bitmap->width << 16;
+    slot->format            = FT_GLYPH_FORMAT_BITMAP;
+
+    FT_TRACE4(( " --- ok\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+ /*
+  *
+  *  BDF SERVICE
+  *
+  */
+
+  static FT_Error
+  pcf_get_bdf_property( PCF_Face          face,
+                        const char*       prop_name,
+                        BDF_PropertyRec  *aproperty )
+  {
+    PCF_Property  prop;
+
+
+    prop = pcf_find_property( face, prop_name );
+    if ( prop != NULL )
+    {
+      if ( prop->isString )
+      {
+        aproperty->type   = BDF_PROPERTY_TYPE_ATOM;
+        aproperty->u.atom = prop->value.atom;
+      }
+      else
+      {
+        /* Apparently, the PCF driver loads all properties as signed integers!
+         * This really doesn't seem to be a problem, because this is
+         * sufficient for any meaningful values.
+         */
+        aproperty->type      = BDF_PROPERTY_TYPE_INTEGER;
+        aproperty->u.integer = prop->value.integer;
+      }
+      return 0;
+    }
+
+    return PCF_Err_Invalid_Argument;
+  }
+
+
+  static FT_Error
+  pcf_get_charset_id( PCF_Face      face,
+                      const char*  *acharset_encoding,
+                      const char*  *acharset_registry )
+  {
+    *acharset_encoding = face->charset_encoding;
+    *acharset_registry = face->charset_registry;
+
+    return 0;
+  }
+
+
+  static const FT_Service_BDFRec  pcf_service_bdf =
+  {
+    (FT_BDF_GetCharsetIdFunc)pcf_get_charset_id,
+    (FT_BDF_GetPropertyFunc) pcf_get_bdf_property
+  };
+
+
+ /*
+  *
+  *  SERVICE LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  pcf_services[] =
+  {
+    { FT_SERVICE_ID_BDF,       &pcf_service_bdf },
+    { FT_SERVICE_ID_XF86_NAME, FT_XF86_FORMAT_PCF },
+    { NULL, NULL }
+  };
+
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  pcf_driver_requester( FT_Module    module,
+                        const char*  name )
+  {
+    FT_UNUSED( module );
+
+    return ft_service_list_lookup( pcf_services, name );
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  pcf_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER        |
+      FT_MODULE_DRIVER_NO_OUTLINES,
+      sizeof ( FT_DriverRec ),
+
+      "pcf",
+      0x10000L,
+      0x20000L,
+
+      0,
+
+      0,
+      0,
+      pcf_driver_requester
+    },
+
+    sizeof ( PCF_FaceRec ),
+    sizeof ( FT_SizeRec ),
+    sizeof ( FT_GlyphSlotRec ),
+
+    PCF_Face_Init,
+    PCF_Face_Done,
+    0,                      /* FT_Size_InitFunc */
+    0,                      /* FT_Size_DoneFunc */
+    0,                      /* FT_Slot_InitFunc */
+    0,                      /* FT_Slot_DoneFunc */
+
+    PCF_Set_Point_Size,
+    PCF_Set_Pixel_Size,
+
+    PCF_Glyph_Load,
+
+    0,                      /* FT_Face_GetKerningFunc  */
+    0,                      /* FT_Face_AttachFunc      */
+    0                       /* FT_Face_GetAdvancesFunc */
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/pcfdrivr.h b/nx-X11/extras/freetype2/src/pcf/pcfdrivr.h
new file mode 100644
index 000000000..7ddf697e1
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcfdrivr.h
@@ -0,0 +1,44 @@
+/*  pcfdrivr.h
+
+    FreeType font driver for pcf fonts
+
+  Copyright 2000-2001, 2002 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#ifndef __PCFDRIVR_H__
+#define __PCFDRIVR_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+FT_BEGIN_HEADER
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  pcf_driver_class;
+
+FT_END_HEADER
+
+
+#endif /* __PCFDRIVR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/pcferror.h b/nx-X11/extras/freetype2/src/pcf/pcferror.h
new file mode 100644
index 000000000..d75c067aa
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcferror.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pcferror.h                                                             */
+/*                                                                         */
+/*    PCF error codes (specification only).                                */
+/*                                                                         */
+/*  Copyright 2001 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 PCF error enumeration constants.      */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __PCFERROR_H__
+#define __PCFERROR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  PCF_Err_
+#define FT_ERR_BASE    FT_Mod_Err_PCF
+
+#include FT_ERRORS_H
+
+#endif /* __PCFERROR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/pcfread.c b/nx-X11/extras/freetype2/src/pcf/pcfread.c
new file mode 100644
index 000000000..383daaa1c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcfread.c
@@ -0,0 +1,1175 @@
+/*  pcfread.c
+
+    FreeType font driver for pcf fonts
+
+  Copyright 2000, 2001, 2002, 2003, 2004 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#include <ft2build.h>
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+
+#include "pcf.h"
+#include "pcfdrivr.h"
+#include "pcfread.h"
+
+#include "pcferror.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_pcfread
+
+
+#if defined( FT_DEBUG_LEVEL_TRACE )
+  static const char* const  tableNames[] =
+  {
+    "prop", "accl", "mtrcs", "bmps", "imtrcs",
+    "enc", "swidth", "names", "accel"
+  };
+#endif
+
+
+  static
+  const FT_Frame_Field  pcf_toc_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_TocRec
+
+    FT_FRAME_START( 8 ),
+      FT_FRAME_ULONG_LE( version ),
+      FT_FRAME_ULONG_LE( count ),
+    FT_FRAME_END
+  };
+
+
+  static
+  const FT_Frame_Field  pcf_table_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_TableRec
+
+    FT_FRAME_START( 16  ),
+      FT_FRAME_ULONG_LE( type ),
+      FT_FRAME_ULONG_LE( format ),
+      FT_FRAME_ULONG_LE( size ),
+      FT_FRAME_ULONG_LE( offset ),
+    FT_FRAME_END
+  };
+
+
+  static FT_Error
+  pcf_read_TOC( FT_Stream  stream,
+                PCF_Face   face )
+  {
+    FT_Error   error;
+    PCF_Toc    toc = &face->toc;
+    PCF_Table  tables;
+
+    FT_Memory  memory = FT_FACE(face)->memory;
+    FT_UInt    n;
+
+
+    if ( FT_STREAM_SEEK ( 0 )                          ||
+         FT_STREAM_READ_FIELDS ( pcf_toc_header, toc ) )
+      return PCF_Err_Cannot_Open_Resource;
+
+    if ( toc->version != PCF_FILE_VERSION )
+      return PCF_Err_Invalid_File_Format;
+
+    if ( FT_NEW_ARRAY( face->toc.tables, toc->count ) )
+      return PCF_Err_Out_Of_Memory;
+
+    tables = face->toc.tables;
+    for ( n = 0; n < toc->count; n++ )
+    {
+      if ( FT_STREAM_READ_FIELDS( pcf_table_header, tables ) )
+        goto Exit;
+      tables++;
+    }
+
+#if defined( FT_DEBUG_LEVEL_TRACE )
+
+    {
+      FT_UInt      i, j;
+      const char*  name = "?";
+
+
+      FT_TRACE4(( "pcf_read_TOC:\n" ));
+
+      FT_TRACE4(( "  number of tables: %ld\n", face->toc.count ));
+
+      tables = face->toc.tables;
+      for ( i = 0; i < toc->count; i++ )
+      {
+        for( j = 0; j < sizeof ( tableNames ) / sizeof ( tableNames[0] ); j++ )
+          if ( tables[i].type == (FT_UInt)( 1 << j ) )
+            name = tableNames[j];
+
+        FT_TRACE4(( "  %d: type=%s, format=0x%X, "
+                    "size=%ld (0x%lX), offset=%ld (0x%lX)\n",
+                    i, name,
+                    tables[i].format,
+                    tables[i].size, tables[i].size,
+                    tables[i].offset, tables[i].offset ));
+      }
+    }
+
+#endif
+
+    return PCF_Err_Ok;
+
+  Exit:
+    FT_FREE( face->toc.tables );
+    return error;
+  }
+
+
+  static
+  const FT_Frame_Field  pcf_metric_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_MetricRec
+
+    FT_FRAME_START( 12 ),
+      FT_FRAME_SHORT_LE( leftSideBearing ),
+      FT_FRAME_SHORT_LE( rightSideBearing ),
+      FT_FRAME_SHORT_LE( characterWidth ),
+      FT_FRAME_SHORT_LE( ascent ),
+      FT_FRAME_SHORT_LE( descent ),
+      FT_FRAME_SHORT_LE( attributes ),
+    FT_FRAME_END
+  };
+
+
+  static
+  const FT_Frame_Field  pcf_metric_msb_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_MetricRec
+
+    FT_FRAME_START( 12 ),
+      FT_FRAME_SHORT( leftSideBearing ),
+      FT_FRAME_SHORT( rightSideBearing ),
+      FT_FRAME_SHORT( characterWidth ),
+      FT_FRAME_SHORT( ascent ),
+      FT_FRAME_SHORT( descent ),
+      FT_FRAME_SHORT( attributes ),
+    FT_FRAME_END
+  };
+
+
+  static
+  const FT_Frame_Field  pcf_compressed_metric_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_Compressed_MetricRec
+
+    FT_FRAME_START( 5 ),
+      FT_FRAME_BYTE( leftSideBearing ),
+      FT_FRAME_BYTE( rightSideBearing ),
+      FT_FRAME_BYTE( characterWidth ),
+      FT_FRAME_BYTE( ascent ),
+      FT_FRAME_BYTE( descent ),
+    FT_FRAME_END
+  };
+
+
+  static FT_Error
+  pcf_get_metric( FT_Stream   stream,
+                  FT_ULong    format,
+                  PCF_Metric  metric )
+  {
+    FT_Error  error = PCF_Err_Ok;
+
+
+    if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
+    {
+      const FT_Frame_Field*  fields;
+
+
+      /* parsing normal metrics */
+      fields = PCF_BYTE_ORDER( format ) == MSBFirst
+               ? pcf_metric_msb_header
+               : pcf_metric_header;
+
+      /* the following sets 'error' but doesn't return in case of failure */
+      (void)FT_STREAM_READ_FIELDS( fields, metric );
+    }
+    else
+    {
+      PCF_Compressed_MetricRec  compr;
+
+
+      /* parsing compressed metrics */
+      if ( FT_STREAM_READ_FIELDS( pcf_compressed_metric_header, &compr ) )
+        goto Exit;
+
+      metric->leftSideBearing  = (FT_Short)( compr.leftSideBearing  - 0x80 );
+      metric->rightSideBearing = (FT_Short)( compr.rightSideBearing - 0x80 );
+      metric->characterWidth   = (FT_Short)( compr.characterWidth   - 0x80 );
+      metric->ascent           = (FT_Short)( compr.ascent           - 0x80 );
+      metric->descent          = (FT_Short)( compr.descent          - 0x80 );
+      metric->attributes       = 0;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  pcf_seek_to_table_type( FT_Stream  stream,
+                          PCF_Table  tables,
+                          FT_Int     ntables,
+                          FT_ULong   type,
+                          FT_ULong  *aformat,
+                          FT_ULong  *asize )
+  {
+    FT_Error  error = PCF_Err_Invalid_File_Format;
+    FT_Int    i;
+
+
+    for ( i = 0; i < ntables; i++ )
+      if ( tables[i].type == type )
+      {
+        if ( stream->pos > tables[i].offset ) {
+          error = PCF_Err_Invalid_Stream_Skip;
+          goto Fail;
+        }
+
+        if ( FT_STREAM_SKIP( tables[i].offset - stream->pos ) ) {
+          error = PCF_Err_Invalid_Stream_Skip;
+          goto Fail;
+        }
+
+        *asize   = tables[i].size;  /* unused - to be removed */
+        *aformat = tables[i].format;
+
+        return PCF_Err_Ok;
+      }
+
+  Fail:
+    return error;
+  }
+
+
+  static FT_Bool
+  pcf_has_table_type( PCF_Table  tables,
+                      FT_Int     ntables,
+                      FT_ULong   type )
+  {
+    FT_Int  i;
+
+
+    for ( i = 0; i < ntables; i++ )
+      if ( tables[i].type == type )
+        return TRUE;
+
+    return FALSE;
+  }
+
+
+  static
+  const FT_Frame_Field  pcf_property_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_ParsePropertyRec
+
+    FT_FRAME_START( 9 ),
+      FT_FRAME_LONG_LE( name ),
+      FT_FRAME_BYTE   ( isString ),
+      FT_FRAME_LONG_LE( value ),
+    FT_FRAME_END
+  };
+
+
+  static
+  const FT_Frame_Field  pcf_property_msb_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_ParsePropertyRec
+
+    FT_FRAME_START( 9 ),
+      FT_FRAME_LONG( name ),
+      FT_FRAME_BYTE( isString ),
+      FT_FRAME_LONG( value ),
+    FT_FRAME_END
+  };
+
+
+  FT_LOCAL_DEF( PCF_Property )
+  pcf_find_property( PCF_Face          face,
+                     const FT_String*  prop )
+  {
+    PCF_Property  properties = face->properties;
+    FT_Bool       found      = 0;
+    int           i;
+
+
+    for ( i = 0 ; i < face->nprops && !found; i++ )
+    {
+      if ( !ft_strcmp( properties[i].name, prop ) )
+        found = 1;
+    }
+
+    if ( found )
+      return properties + i - 1;
+    else
+      return NULL;
+  }
+
+
+  static FT_Error
+  pcf_get_properties( FT_Stream  stream,
+                      PCF_Face   face )
+  {
+    PCF_ParseProperty  props      = 0;
+    PCF_Property       properties = 0;
+    FT_Int             nprops, i;
+    FT_ULong           format, size;
+    FT_Error           error;
+    FT_Memory          memory     = FT_FACE(face)->memory;
+    FT_ULong           string_size;
+    FT_String*         strings    = 0;
+
+
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    PCF_PROPERTIES,
+                                    &format,
+                                    &size );
+    if ( error )
+      goto Bail;
+
+    if ( FT_READ_ULONG_LE( format ) )
+      goto Bail;
+
+    FT_TRACE4(( "pcf_get_properties:\n" ));
+
+    FT_TRACE4(( "  format = %ld\n", format ));
+
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
+      goto Bail;
+
+    if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+      (void)FT_READ_ULONG( nprops );
+    else
+      (void)FT_READ_ULONG_LE( nprops );
+    if ( error )
+      goto Bail;
+
+    FT_TRACE4(( "  nprop = %d\n", nprops ));
+
+    if ( FT_NEW_ARRAY( props, nprops ) )
+      goto Bail;
+
+    for ( i = 0; i < nprops; i++ )
+    {
+      if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+      {
+        if ( FT_STREAM_READ_FIELDS( pcf_property_msb_header, props + i ) )
+          goto Bail;
+      }
+      else
+      {
+        if ( FT_STREAM_READ_FIELDS( pcf_property_header, props + i ) )
+          goto Bail;
+      }
+    }
+
+    /* pad the property array                                            */
+    /*                                                                   */
+    /* clever here - nprops is the same as the number of odd-units read, */
+    /* as only isStringProp are odd length   (Keith Packard)             */
+    /*                                                                   */
+    if ( nprops & 3 )
+    {
+      i = 4 - ( nprops & 3 );
+      FT_Stream_Skip( stream, i );
+    }
+
+    if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+      (void)FT_READ_ULONG( string_size );
+    else
+      (void)FT_READ_ULONG_LE( string_size );
+    if ( error )
+      goto Bail;
+
+    FT_TRACE4(( "  string_size = %ld\n", string_size ));
+
+    if ( FT_NEW_ARRAY( strings, string_size ) )
+      goto Bail;
+
+    error = FT_Stream_Read( stream, (FT_Byte*)strings, string_size );
+    if ( error )
+      goto Bail;
+
+    if ( FT_NEW_ARRAY( properties, nprops ) )
+      goto Bail;
+
+    for ( i = 0; i < nprops; i++ )
+    {
+      /* XXX: make atom */
+      if ( FT_NEW_ARRAY( properties[i].name,
+                         ft_strlen( strings + props[i].name ) + 1 ) )
+        goto Bail;
+      ft_strcpy( properties[i].name, strings + props[i].name );
+
+      FT_TRACE4(( "  %s:", properties[i].name ));
+
+      properties[i].isString = props[i].isString;
+
+      if ( props[i].isString )
+      {
+        if ( FT_NEW_ARRAY( properties[i].value.atom,
+                           ft_strlen( strings + props[i].value ) + 1 ) )
+          goto Bail;
+        ft_strcpy( properties[i].value.atom, strings + props[i].value );
+
+        FT_TRACE4(( " `%s'\n", properties[i].value.atom ));
+      }
+      else
+      {
+        properties[i].value.integer = props[i].value;
+
+        FT_TRACE4(( " %d\n", properties[i].value.integer ));
+      }
+    }
+
+    face->properties = properties;
+    face->nprops = nprops;
+
+    FT_FREE( props );
+    FT_FREE( strings );
+
+    return PCF_Err_Ok;
+
+  Bail:
+    FT_FREE( props );
+    FT_FREE( strings );
+
+    return error;
+  }
+
+
+  static FT_Error
+  pcf_get_metrics( FT_Stream  stream,
+                   PCF_Face   face )
+  {
+    FT_Error    error    = PCF_Err_Ok;
+    FT_Memory   memory   = FT_FACE(face)->memory;
+    FT_ULong    format   = 0;
+    FT_ULong    size     = 0;
+    PCF_Metric  metrics  = 0;
+    int         i;
+    int         nmetrics = -1;
+
+
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    PCF_METRICS,
+                                    &format,
+                                    &size );
+    if ( error )
+      return error;
+
+    error = FT_READ_ULONG_LE( format );
+
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT )     &&
+         !PCF_FORMAT_MATCH( format, PCF_COMPRESSED_METRICS ) )
+      return PCF_Err_Invalid_File_Format;
+
+    if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
+    {
+      if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+        (void)FT_READ_ULONG( nmetrics );
+      else
+        (void)FT_READ_ULONG_LE( nmetrics );
+    }
+    else
+    {
+      if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+        (void)FT_READ_USHORT( nmetrics );
+      else
+        (void)FT_READ_USHORT_LE( nmetrics );
+    }
+    if ( error || nmetrics == -1 )
+      return PCF_Err_Invalid_File_Format;
+
+    face->nmetrics = nmetrics;
+
+    if ( FT_NEW_ARRAY( face->metrics, nmetrics ) )
+      return PCF_Err_Out_Of_Memory;
+
+    FT_TRACE4(( "pcf_get_metrics:\n" ));
+
+    metrics = face->metrics;
+    for ( i = 0; i < nmetrics; i++ )
+    {
+      pcf_get_metric( stream, format, metrics + i );
+
+      metrics[i].bits = 0;
+
+      FT_TRACE4(( "  idx %d: width=%d, "
+                  "lsb=%d, rsb=%d, ascent=%d, descent=%d, swidth=%d\n",
+                  i,
+                  ( metrics + i )->characterWidth,
+                  ( metrics + i )->leftSideBearing,
+                  ( metrics + i )->rightSideBearing,
+                  ( metrics + i )->ascent,
+                  ( metrics + i )->descent,
+                  ( metrics + i )->attributes ));
+
+      if ( error )
+        break;
+    }
+
+    if ( error )
+      FT_FREE( face->metrics );
+    return error;
+  }
+
+
+  static FT_Error
+  pcf_get_bitmaps( FT_Stream  stream,
+                   PCF_Face   face )
+  {
+    FT_Error   error  = PCF_Err_Ok;
+    FT_Memory  memory = FT_FACE(face)->memory;
+    FT_Long*   offsets;
+    FT_Long    bitmapSizes[GLYPHPADOPTIONS];
+    FT_ULong   format, size;
+    int        nbitmaps, i, sizebitmaps = 0;
+    char*      bitmaps;
+
+
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    PCF_BITMAPS,
+                                    &format,
+                                    &size );
+    if ( error )
+      return error;
+
+    error = FT_Stream_EnterFrame( stream, 8 );
+    if ( error )
+      return error;
+
+    format = FT_GET_ULONG_LE();
+    if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+      nbitmaps  = FT_GET_ULONG();
+    else
+      nbitmaps  = FT_GET_ULONG_LE();
+
+    FT_Stream_ExitFrame( stream );
+
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
+      return PCF_Err_Invalid_File_Format;
+
+    if ( nbitmaps != face->nmetrics )
+      return PCF_Err_Invalid_File_Format;
+
+    if ( FT_NEW_ARRAY( offsets, nbitmaps ) )
+      return error;
+
+    FT_TRACE4(( "pcf_get_bitmaps:\n" ));
+
+    for ( i = 0; i < nbitmaps; i++ )
+    {
+      if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+        (void)FT_READ_LONG( offsets[i] );
+      else
+        (void)FT_READ_LONG_LE( offsets[i] );
+
+      FT_TRACE4(( "  bitmap %d: offset %ld (0x%lX)\n",
+                  i, offsets[i], offsets[i] ));
+    }
+    if ( error )
+      goto Bail;
+
+    for ( i = 0; i < GLYPHPADOPTIONS; i++ )
+    {
+      if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+        (void)FT_READ_LONG( bitmapSizes[i] );
+      else
+        (void)FT_READ_LONG_LE( bitmapSizes[i] );
+      if ( error )
+        goto Bail;
+
+      sizebitmaps = bitmapSizes[PCF_GLYPH_PAD_INDEX( format )];
+
+      FT_TRACE4(( "  padding %d implies a size of %ld\n", i, bitmapSizes[i] ));
+    }
+
+    FT_TRACE4(( "  %d bitmaps, padding index %ld\n",
+                nbitmaps,
+                PCF_GLYPH_PAD_INDEX( format ) ));
+    FT_TRACE4(( "  bitmap size = %d\n", sizebitmaps ));
+
+    FT_UNUSED( sizebitmaps );       /* only used for debugging */
+
+    for ( i = 0; i < nbitmaps; i++ )
+      face->metrics[i].bits = stream->pos + offsets[i];
+
+    face->bitmapsFormat = format;
+
+    FT_FREE ( offsets );
+    return error;
+
+  Bail:
+    FT_FREE ( offsets );
+    FT_FREE ( bitmaps );
+    return error;
+  }
+
+
+  static FT_Error
+  pcf_get_encodings( FT_Stream  stream,
+                     PCF_Face   face )
+  {
+    FT_Error      error  = PCF_Err_Ok;
+    FT_Memory     memory = FT_FACE(face)->memory;
+    FT_ULong      format, size;
+    int           firstCol, lastCol;
+    int           firstRow, lastRow;
+    int           nencoding, encodingOffset;
+    int           i, j;
+    PCF_Encoding  tmpEncoding, encoding = 0;
+
+
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    PCF_BDF_ENCODINGS,
+                                    &format,
+                                    &size );
+    if ( error )
+      return error;
+
+    error = FT_Stream_EnterFrame( stream, 14 );
+    if ( error )
+      return error;
+
+    format = FT_GET_ULONG_LE();
+
+    if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+    {
+      firstCol          = FT_GET_SHORT();
+      lastCol           = FT_GET_SHORT();
+      firstRow          = FT_GET_SHORT();
+      lastRow           = FT_GET_SHORT();
+      face->defaultChar = FT_GET_SHORT();
+    }
+    else
+    {
+      firstCol          = FT_GET_SHORT_LE();
+      lastCol           = FT_GET_SHORT_LE();
+      firstRow          = FT_GET_SHORT_LE();
+      lastRow           = FT_GET_SHORT_LE();
+      face->defaultChar = FT_GET_SHORT_LE();
+    }
+
+    FT_Stream_ExitFrame( stream );
+
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
+      return PCF_Err_Invalid_File_Format;
+
+    FT_TRACE4(( "pdf_get_encodings:\n" ));
+
+    FT_TRACE4(( "  firstCol %d, lastCol %d, firstRow %d, lastRow %d\n",
+                firstCol, lastCol, firstRow, lastRow ));
+
+    nencoding = ( lastCol - firstCol + 1 ) * ( lastRow - firstRow + 1 );
+
+    if ( FT_NEW_ARRAY( tmpEncoding, nencoding ) )
+      return PCF_Err_Out_Of_Memory;
+
+    error = FT_Stream_EnterFrame( stream, 2 * nencoding );
+    if ( error )
+      goto Bail;
+
+    for ( i = 0, j = 0 ; i < nencoding; i++ )
+    {
+      if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+        encodingOffset = FT_GET_SHORT();
+      else
+        encodingOffset = FT_GET_SHORT_LE();
+
+      if ( encodingOffset != -1 )
+      {
+        tmpEncoding[j].enc = ( ( ( i / ( lastCol - firstCol + 1 ) ) +
+                                 firstRow ) * 256 ) +
+                               ( ( i % ( lastCol - firstCol + 1 ) ) +
+                                 firstCol );
+
+        tmpEncoding[j].glyph = (FT_Short)encodingOffset;
+
+        FT_TRACE4(( "  code %d (0x%04X): idx %d\n",
+                    tmpEncoding[j].enc, tmpEncoding[j].enc,
+                    tmpEncoding[j].glyph ));
+
+        j++;
+      }
+    }
+    FT_Stream_ExitFrame( stream );
+
+    if ( FT_NEW_ARRAY( encoding, j ) )
+      goto Bail;
+
+    for ( i = 0; i < j; i++ )
+    {
+      encoding[i].enc   = tmpEncoding[i].enc;
+      encoding[i].glyph = tmpEncoding[i].glyph;
+    }
+
+    face->nencodings = j;
+    face->encodings  = encoding;
+    FT_FREE( tmpEncoding );
+
+    return error;
+
+  Bail:
+    FT_FREE( encoding );
+    FT_FREE( tmpEncoding );
+    return error;
+  }
+
+
+  static
+  const FT_Frame_Field  pcf_accel_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_AccelRec
+
+    FT_FRAME_START( 20 ),
+      FT_FRAME_BYTE      ( noOverlap ),
+      FT_FRAME_BYTE      ( constantMetrics ),
+      FT_FRAME_BYTE      ( terminalFont ),
+      FT_FRAME_BYTE      ( constantWidth ),
+      FT_FRAME_BYTE      ( inkInside ),
+      FT_FRAME_BYTE      ( inkMetrics ),
+      FT_FRAME_BYTE      ( drawDirection ),
+      FT_FRAME_SKIP_BYTES( 1 ),
+      FT_FRAME_LONG_LE   ( fontAscent ),
+      FT_FRAME_LONG_LE   ( fontDescent ),
+      FT_FRAME_LONG_LE   ( maxOverlap ),
+    FT_FRAME_END
+  };
+
+
+  static
+  const FT_Frame_Field  pcf_accel_msb_header[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PCF_AccelRec
+
+    FT_FRAME_START( 20 ),
+      FT_FRAME_BYTE      ( noOverlap ),
+      FT_FRAME_BYTE      ( constantMetrics ),
+      FT_FRAME_BYTE      ( terminalFont ),
+      FT_FRAME_BYTE      ( constantWidth ),
+      FT_FRAME_BYTE      ( inkInside ),
+      FT_FRAME_BYTE      ( inkMetrics ),
+      FT_FRAME_BYTE      ( drawDirection ),
+      FT_FRAME_SKIP_BYTES( 1 ),
+      FT_FRAME_LONG      ( fontAscent ),
+      FT_FRAME_LONG      ( fontDescent ),
+      FT_FRAME_LONG      ( maxOverlap ),
+    FT_FRAME_END
+  };
+
+
+  static FT_Error
+  pcf_get_accel( FT_Stream  stream,
+                 PCF_Face   face,
+                 FT_ULong   type )
+  {
+    FT_ULong   format, size;
+    FT_Error   error = PCF_Err_Ok;
+    PCF_Accel  accel = &face->accel;
+
+
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    type,
+                                    &format,
+                                    &size );
+    if ( error )
+      goto Bail;
+
+    error = FT_READ_ULONG_LE( format );
+
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT )    &&
+         !PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) )
+      goto Bail;
+
+    if ( PCF_BYTE_ORDER( format ) == MSBFirst )
+    {
+      if ( FT_STREAM_READ_FIELDS( pcf_accel_msb_header, accel ) )
+        goto Bail;
+    }
+    else
+    {
+      if ( FT_STREAM_READ_FIELDS( pcf_accel_header, accel ) )
+        goto Bail;
+    }
+
+    error = pcf_get_metric( stream,
+                            format & ( ~PCF_FORMAT_MASK ),
+                            &(accel->minbounds) );
+    if ( error )
+      goto Bail;
+
+    error = pcf_get_metric( stream,
+                            format & ( ~PCF_FORMAT_MASK ),
+                            &(accel->maxbounds) );
+    if ( error )
+      goto Bail;
+
+    if ( PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) )
+    {
+      error = pcf_get_metric( stream,
+                              format & ( ~PCF_FORMAT_MASK ),
+                              &(accel->ink_minbounds) );
+      if ( error )
+        goto Bail;
+
+      error = pcf_get_metric( stream,
+                              format & ( ~PCF_FORMAT_MASK ),
+                              &(accel->ink_maxbounds) );
+      if ( error )
+        goto Bail;
+    }
+    else
+    {
+      accel->ink_minbounds = accel->minbounds; /* I'm not sure about this */
+      accel->ink_maxbounds = accel->maxbounds;
+    }
+    return error;
+
+  Bail:
+    return error;
+  }
+
+
+  static FT_Error
+  pcf_interpret_style( PCF_Face  pcf )
+  {
+    FT_Error   error  = PCF_Err_Ok;
+    FT_Face    face   = FT_FACE( pcf );
+    FT_Memory  memory = face->memory;
+
+    PCF_Property  prop;
+
+    char  *istr = NULL, *bstr = NULL;
+    char  *sstr = NULL, *astr = NULL;
+
+    int  parts = 0, len = 0;
+
+
+    face->style_flags = 0;
+
+    prop = pcf_find_property( pcf, "SLANT" );
+    if ( prop && prop->isString                                       &&
+         ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' ||
+           *(prop->value.atom) == 'I' || *(prop->value.atom) == 'i' ) )
+    {
+      face->style_flags |= FT_STYLE_FLAG_ITALIC;
+      istr = ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' )
+               ? (char *)"Oblique"
+               : (char *)"Italic";
+      len += ft_strlen( istr );
+      parts++;
+    }
+
+    prop = pcf_find_property( pcf, "WEIGHT_NAME" );
+    if ( prop && prop->isString                                       &&
+         ( *(prop->value.atom) == 'B' || *(prop->value.atom) == 'b' ) )
+    {
+      face->style_flags |= FT_STYLE_FLAG_BOLD;
+      bstr = (char *)"Bold";
+      len += ft_strlen( bstr );
+      parts++;
+    }
+
+    prop = pcf_find_property( pcf, "SETWIDTH_NAME" );
+    if ( prop && prop->isString                                        &&
+         *(prop->value.atom)                                           &&
+         !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
+    {
+      sstr = (char *)(prop->value.atom);
+      len += ft_strlen( sstr );
+      parts++;
+    }
+
+    prop = pcf_find_property( pcf, "ADD_STYLE_NAME" );
+    if ( prop && prop->isString                                        &&
+         *(prop->value.atom)                                           &&
+         !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
+    {
+      astr = (char *)(prop->value.atom);
+      len += ft_strlen( astr );
+      parts++;
+    }
+
+    if ( !parts || !len )
+      face->style_name = (char *)"Regular";
+    else
+    {
+      char          *style, *s;
+      unsigned int  i;
+
+
+      if ( FT_ALLOC( style, len + parts ) )
+        return error;
+
+      s = style;
+
+      if ( astr )
+      {
+        ft_strcpy( s, astr );
+        for ( i = 0; i < ft_strlen( astr ); i++, s++ )
+          if ( *s == ' ' )
+            *s = '-';                     /* replace spaces with dashes */
+        *(s++) = ' ';
+      }
+      if ( bstr )
+      {
+        ft_strcpy( s, bstr );
+        s += ft_strlen( bstr );
+        *(s++) = ' ';
+      }
+      if ( istr )
+      {
+        ft_strcpy( s, istr );
+        s += ft_strlen( istr );
+        *(s++) = ' ';
+      }
+      if ( sstr )
+      {
+        ft_strcpy( s, sstr );
+        for ( i = 0; i < ft_strlen( sstr ); i++, s++ )
+          if ( *s == ' ' )
+            *s = '-';                     /* replace spaces with dashes */
+        *(s++) = ' ';
+      }
+      *(--s) = '\0';        /* overwrite last ' ', terminate the string */
+
+      face->style_name = style;                     /* allocated string */
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pcf_load_font( FT_Stream  stream,
+                 PCF_Face   face )
+  {
+    FT_Error   error  = PCF_Err_Ok;
+    FT_Memory  memory = FT_FACE(face)->memory;
+    FT_Bool    hasBDFAccelerators;
+
+
+    error = pcf_read_TOC( stream, face );
+    if ( error )
+      goto Exit;
+
+    error = pcf_get_properties( stream, face );
+    if ( error )
+      goto Exit;
+
+    /* Use the old accelerators if no BDF accelerators are in the file. */
+    hasBDFAccelerators = pcf_has_table_type( face->toc.tables,
+                                             face->toc.count,
+                                             PCF_BDF_ACCELERATORS );
+    if ( !hasBDFAccelerators )
+    {
+      error = pcf_get_accel( stream, face, PCF_ACCELERATORS );
+      if ( error )
+        goto Exit;
+    }
+
+    /* metrics */
+    error = pcf_get_metrics( stream, face );
+    if ( error )
+      goto Exit;
+
+    /* bitmaps */
+    error = pcf_get_bitmaps( stream, face );
+    if ( error )
+      goto Exit;
+
+    /* encodings */
+    error = pcf_get_encodings( stream, face );
+    if ( error )
+      goto Exit;
+
+    /* BDF style accelerators (i.e. bounds based on encoded glyphs) */
+    if ( hasBDFAccelerators )
+    {
+      error = pcf_get_accel( stream, face, PCF_BDF_ACCELERATORS );
+      if ( error )
+        goto Exit;
+    }
+
+    /* XXX: TO DO: inkmetrics and glyph_names are missing */
+
+    /* now construct the face object */
+    {
+      FT_Face       root = FT_FACE( face );
+      PCF_Property  prop;
+
+
+      root->num_faces  = 1;
+      root->face_index = 0;
+      root->face_flags = FT_FACE_FLAG_FIXED_SIZES |
+                         FT_FACE_FLAG_HORIZONTAL  |
+                         FT_FACE_FLAG_FAST_GLYPHS;
+
+      if ( face->accel.constantWidth )
+        root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      if ( ( error = pcf_interpret_style( face ) ) != 0 )
+         goto Exit;
+
+      prop = pcf_find_property( face, "FAMILY_NAME" );
+      if ( prop && prop->isString )
+      {
+        int  l = ft_strlen( prop->value.atom ) + 1;
+
+
+        if ( FT_NEW_ARRAY( root->family_name, l ) )
+          goto Exit;
+        ft_strcpy( root->family_name, prop->value.atom );
+      }
+      else
+        root->family_name = NULL;
+
+      /* Note: We shift all glyph indices by +1 since we must
+       * respect the convention that glyph 0 always corresponds
+       * to the "missing glyph".
+       *
+       * This implies bumping the number of "available" glyphs by 1.
+       */
+      root->num_glyphs = face->nmetrics + 1;
+
+      root->num_fixed_sizes = 1;
+      if ( FT_NEW_ARRAY( root->available_sizes, 1 ) )
+        goto Exit;
+
+      {
+        FT_Bitmap_Size*  bsize = root->available_sizes;
+        FT_Short         resolution_x = 0, resolution_y = 0;
+
+
+        FT_MEM_ZERO( bsize, sizeof ( FT_Bitmap_Size ) );
+
+        bsize->height = face->accel.fontAscent + face->accel.fontDescent;
+
+        prop = pcf_find_property( face, "AVERAGE_WIDTH" );
+        if ( prop )
+          bsize->width = (FT_Short)( ( prop->value.integer + 5 ) / 10 );
+        else
+          bsize->width = bsize->height * 2/3;
+
+        prop = pcf_find_property( face, "POINT_SIZE" );
+        if ( prop )
+          /* convert from 722.7 decipoints to 72 points per inch */
+          bsize->size =
+            (FT_Pos)( ( prop->value.integer * 64 * 7200 + 36135L ) / 72270L );
+
+        prop = pcf_find_property( face, "PIXEL_SIZE" );
+        if ( prop )
+          bsize->y_ppem = (FT_Short)prop->value.integer << 6;
+
+        prop = pcf_find_property( face, "RESOLUTION_X" );
+        if ( prop )
+          resolution_x = (FT_Short)prop->value.integer;
+
+        prop = pcf_find_property( face, "RESOLUTION_Y" );
+        if ( prop )
+          resolution_y = (FT_Short)prop->value.integer;
+
+        if ( bsize->y_ppem == 0 )
+        {
+          bsize->y_ppem = bsize->size;
+          if ( resolution_y )
+            bsize->y_ppem = bsize->y_ppem * resolution_y / 72;
+        }
+        if ( resolution_x && resolution_y )
+          bsize->x_ppem = bsize->y_ppem * resolution_x / resolution_y;
+        else
+          bsize->x_ppem = bsize->y_ppem;
+      }
+
+      /* set up charset */
+      {
+        PCF_Property  charset_registry = 0, charset_encoding = 0;
+
+
+        charset_registry = pcf_find_property( face, "CHARSET_REGISTRY" );
+        charset_encoding = pcf_find_property( face, "CHARSET_ENCODING" );
+
+        if ( charset_registry && charset_registry->isString &&
+             charset_encoding && charset_encoding->isString )
+        {
+          if ( FT_NEW_ARRAY( face->charset_encoding,
+                             ft_strlen( charset_encoding->value.atom ) + 1 ) )
+            goto Exit;
+
+          if ( FT_NEW_ARRAY( face->charset_registry,
+                             ft_strlen( charset_registry->value.atom ) + 1 ) )
+            goto Exit;
+
+          ft_strcpy( face->charset_registry, charset_registry->value.atom );
+          ft_strcpy( face->charset_encoding, charset_encoding->value.atom );
+        }
+      }
+    }
+
+  Exit:
+    if ( error )
+    {
+      /* this is done to respect the behaviour of the original */
+      /* PCF font driver.                                      */
+      error = PCF_Err_Invalid_File_Format;
+    }
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/pcfread.h b/nx-X11/extras/freetype2/src/pcf/pcfread.h
new file mode 100644
index 000000000..c9524f134
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcfread.h
@@ -0,0 +1,45 @@
+/*  pcfread.h
+
+    FreeType font driver for pcf fonts
+
+  Copyright 2003 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#ifndef __PCFREAD_H__
+#define __PCFREAD_H__
+
+
+#include <ft2build.h>
+
+FT_BEGIN_HEADER
+
+  FT_LOCAL( PCF_Property )
+  pcf_find_property( PCF_Face          face,
+                     const FT_String*  prop );
+
+FT_END_HEADER
+
+#endif /* __PCFREAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/pcfutil.c b/nx-X11/extras/freetype2/src/pcf/pcfutil.c
new file mode 100644
index 000000000..8fcf23df0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcfutil.c
@@ -0,0 +1,132 @@
+/*
+
+Copyright 1990, 1994, 1998  The Open Group
+
+All Rights Reserved.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/* $XFree86: xc/lib/font/util/utilbitmap.c,v 1.3 1999/08/22 08:58:58 dawes Exp $ */
+
+/*
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+/* Modified for use with FreeType */
+
+
+#include <ft2build.h>
+#include "pcfutil.h"
+
+
+  /* Utility functions for reformatting font bitmaps */
+
+  static const unsigned char  _reverse_byte[0x100] =
+  {
+    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
+  };
+
+  /*
+   *  Invert bit order within each BYTE of an array.
+   */
+
+  FT_LOCAL_DEF( void )
+  BitOrderInvert( unsigned char*  buf,
+                  int             nbytes )
+  {
+    const unsigned char*  rev = _reverse_byte;
+
+
+    for ( ; --nbytes >= 0; buf++ )
+      *buf = rev[*buf];
+  }
+
+
+  /*
+   *  Invert byte order within each 16-bits of an array.
+   */
+
+  FT_LOCAL_DEF( void )
+  TwoByteSwap( unsigned char*  buf,
+               int             nbytes )
+  {
+    unsigned char  c;
+
+
+    for ( ; nbytes > 0; nbytes -= 2, buf += 2 )
+    {
+      c      = buf[0];
+      buf[0] = buf[1];
+      buf[1] = c;
+    }
+  }
+
+  /*
+   *  Invert byte order within each 32-bits of an array.
+   */
+
+  FT_LOCAL_DEF( void )
+  FourByteSwap( unsigned char*  buf,
+                int             nbytes )
+  {
+    unsigned char  c;
+
+
+    for ( ; nbytes > 0; nbytes -= 4, buf += 4 )
+    {
+      c      = buf[0];
+      buf[0] = buf[3];
+      buf[3] = c;
+
+      c      = buf[1];
+      buf[1] = buf[2];
+      buf[2] = c;
+    }
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/pcfutil.h b/nx-X11/extras/freetype2/src/pcf/pcfutil.h
new file mode 100644
index 000000000..1557be3e8
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/pcfutil.h
@@ -0,0 +1,55 @@
+/*  pcfutil.h
+
+    FreeType font driver for pcf fonts
+
+  Copyright 2000, 2001, 2004 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#ifndef __PCFUTIL_H__
+#define __PCFUTIL_H__
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+
+
+FT_BEGIN_HEADER
+
+  FT_LOCAL( void )
+  BitOrderInvert( unsigned char*  buf,
+                  int             nbytes );
+
+  FT_LOCAL( void )
+  TwoByteSwap( unsigned char*  buf,
+               int             nbytes );
+
+  FT_LOCAL( void )
+  FourByteSwap( unsigned char*  buf,
+                int             nbytes );
+
+FT_END_HEADER
+
+#endif /* __PCFUTIL_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pcf/readme b/nx-X11/extras/freetype2/src/pcf/readme
new file mode 100644
index 000000000..75f49e142
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/readme
@@ -0,0 +1,114 @@
+                  FreeType font driver for PCF fonts
+
+                       Francesco Zappa Nardelli
+                  <francesco.zappa.nardelli@ens.fr>
+
+
+Introduction
+************
+
+PCF (Portable Compiled Format) is a binary bitmap font format, largely used
+in X world. This code implements a PCF driver for the FreeType library.
+Glyph images are loaded into memory only on demand, thus leading to a small
+memory footprint.
+
+Informations on the PCF font format can only be worked out from
+``pcfread.c'', and ``pcfwrite.c'', to be found, for instance, in the XFree86
+(www.xfree86.org) source tree (xc/lib/font/bitmap/).
+
+Many good bitmap fonts in bdf format come with XFree86: they can be
+compiled into the pcf format using the ``bdftopcf'' utility.
+
+
+Supported hardware
+******************
+
+The driver has been tested on linux/x86 and sunos5.5/sparc.  In both
+cases the compiler was gcc.  When back in Paris, I will test it also
+on linux/alpha.
+
+
+Encodings
+*********
+
+The variety of encodings that accompanies pcf fonts appears to encompass the
+small set defined in freetype.h.  On the other hand, each pcf font defines
+two properties that specify encoding and registry.
+
+I decided to make these two properties directly accessible, leaving to the
+client application the work of interpreting them.  For instance:
+
+  #include "pcftypes.h"  /* include/freetype/internal/pcftypes.h */
+
+  FT_Face     face;
+  PCF_Public_Face  pcfface;
+
+  FT_New_Face( library,..., &face );
+
+  pcfface = (PCF_Public_Face)face;
+  
+  if ((pcfface->charset_registry == "ISO10646") && 
+        (pcfface->charset_encoding) == "1")) [..]
+
+Thus the driver always export ``ft_encoding_none'' as
+face->charmap.encoding.  FT_Get_Char_Index() behavior is unmodified, that
+is, it converts the ULong value given as argument into the corresponding
+glyph number.
+
+
+Known problems
+**************
+
+- dealing explicitly with encodings breaks the uniformity of freetype2
+  api.
+
+- except for encodings properties, client applications have no
+  visibility of the PCF_Face object.  This means that applications
+  cannot directly access font tables and are obliged to trust
+  FreeType.
+
+- currently, glyph names and ink_metrics are ignored.
+
+I plan to give full visibility of the PCF_Face object in the next
+release of the driver, thus implementing also glyph names and
+ink_metrics.
+
+- height is defined as (ascent - descent).  Is this correct?
+
+- if unable to read size informations from the font, PCF_Init_Face
+  sets available_size->width and available_size->height to 12.
+
+- too many english grammar errors in the readme file :-(
+
+
+License
+*******
+
+Copyright (C) 2000 by Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Credits
+*******
+
+Keith Packard wrote the pcf driver found in XFree86.  His work is at
+the same time the specification and the sample implementation of the
+PCF format.  Undoubtedly, this driver is inspired from his work.
diff --git a/nx-X11/extras/freetype2/src/pcf/rules.mk b/nx-X11/extras/freetype2/src/pcf/rules.mk
new file mode 100644
index 000000000..1ad4ba897
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pcf/rules.mk
@@ -0,0 +1,80 @@
+#
+# FreeType 2 pcf driver configuration rules
+#
+
+
+# Copyright (C) 2000, 2001, 2003 by
+# Francesco Zappa Nardelli
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+# pcf driver directory
+#
+PCF_DIR := $(SRC_DIR)/pcf
+
+
+PCF_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(PCF_DIR))
+
+
+# pcf driver sources (i.e., C files)
+#
+PCF_DRV_SRC := $(PCF_DIR)/pcfread.c  \
+               $(PCF_DIR)/pcfdrivr.c \
+               $(PCF_DIR)/pcfutil.c
+
+# pcf driver headers
+#
+PCF_DRV_H := $(PCF_DIR)/pcf.h      \
+             $(PCF_DIR)/pcfdrivr.h \
+             $(PCF_DIR)/pcfutil.h  \
+             $(PCF_DIR)/pcferror.h
+
+# pcf driver object(s)
+#
+#   PCF_DRV_OBJ_M is used during `multi' builds
+#   PCF_DRV_OBJ_S is used during `single' builds
+#
+PCF_DRV_OBJ_M := $(PCF_DRV_SRC:$(PCF_DIR)/%.c=$(OBJ_DIR)/%.$O)
+PCF_DRV_OBJ_S := $(OBJ_DIR)/pcf.$O
+
+# pcf driver source file for single build
+#
+PCF_DRV_SRC_S := $(PCF_DIR)/pcf.c
+
+
+# pcf driver - single object
+#
+$(PCF_DRV_OBJ_S): $(PCF_DRV_SRC_S) $(PCF_DRV_SRC) $(FREETYPE_H) $(PCF_DRV_H)
+	$(PCF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(PCF_DRV_SRC_S))
+
+
+# pcf driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(PCF_DIR)/%.c $(FREETYPE_H) $(PCF_DRV_H)
+	$(PCF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(PCF_DRV_OBJ_S)
+DRV_OBJS_M += $(PCF_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/pfr/Jamfile b/nx-X11/extras/freetype2/src/pfr/Jamfile
new file mode 100644
index 000000000..4c38a2de9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/pfr Jamfile (c) 2002 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) pfr ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = pfrdrivr pfrgload pfrload pfrobjs pfrcmap pfrsbit ;
+  }
+  else
+  {
+    _sources = pfr ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/pfr Jamfile
diff --git a/nx-X11/extras/freetype2/src/pfr/descrip.mms b/nx-X11/extras/freetype2/src/pfr/descrip.mms
new file mode 100644
index 000000000..75178d0ef
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 PFR driver compilation rules for VMS
+#
+
+
+# Copyright 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.pfr])
+
+OBJS=pfr.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/pfr/module.mk b/nx-X11/extras/freetype2/src/pfr/module.mk
new file mode 100644
index 000000000..3da0d5a3c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 PFR module definition
+#
+
+
+# Copyright 2002 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.
+
+
+make_module_list: add_pfr_driver
+
+add_pfr_driver:
+	$(OPEN_DRIVER)pfr_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)pfr       $(ECHO_DRIVER_DESC)PFR/TrueDoc font files with extension *.pfr$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/pfr/pfr.c b/nx-X11/extras/freetype2/src/pfr/pfr.c
new file mode 100644
index 000000000..eb2c4edb7
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfr.c
@@ -0,0 +1,29 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfr.c                                                                  */
+/*                                                                         */
+/*    FreeType PFR driver component.                                       */
+/*                                                                         */
+/*  Copyright 2002 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 "pfrload.c"
+#include "pfrgload.c"
+#include "pfrcmap.c"
+#include "pfrobjs.c"
+#include "pfrdrivr.c"
+#include "pfrsbit.c"
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrcmap.c b/nx-X11/extras/freetype2/src/pfr/pfrcmap.c
new file mode 100644
index 000000000..de6c5a07c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrcmap.c
@@ -0,0 +1,158 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrcmap.c                                                              */
+/*                                                                         */
+/*    FreeType PFR cmap handling (body).                                   */
+/*                                                                         */
+/*  Copyright 2002 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 "pfrcmap.h" 
+#include "pfrobjs.h"
+#include FT_INTERNAL_DEBUG_H
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_cmap_init( PFR_CMap  cmap )
+  {
+    PFR_Face  face = (PFR_Face)FT_CMAP_FACE( cmap );
+
+
+    cmap->num_chars = face->phy_font.num_chars;
+    cmap->chars     = face->phy_font.chars;
+    
+    /* just for safety, check that the character entries are correctly */
+    /* sorted in increasing character code order                       */
+    {
+      FT_UInt  n;
+      
+
+      for ( n = 1; n < cmap->num_chars; n++ )
+      {
+        if ( cmap->chars[n - 1].char_code >= cmap->chars[n].char_code )
+          FT_ASSERT( 0 );
+      }
+    }
+    
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  pfr_cmap_done( PFR_CMap  cmap )
+  {
+    cmap->chars     = NULL;
+    cmap->num_chars = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pfr_cmap_char_index( PFR_CMap   cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_UInt   min = 0;
+    FT_UInt   max = cmap->num_chars;
+    FT_UInt   mid;
+    PFR_Char  gchar;
+
+
+    while ( min < max )
+    {
+      mid   = min + ( max - min ) / 2;
+      gchar = cmap->chars + mid;
+
+      if ( gchar->char_code == char_code )
+        return mid + 1;
+
+      if ( gchar->char_code < char_code )
+        min = mid + 1;
+      else
+        max = mid;
+    }
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pfr_cmap_char_next( PFR_CMap    cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_UInt    result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+  Restart:
+    {
+      FT_UInt   min = 0;
+      FT_UInt   max = cmap->num_chars;
+      FT_UInt   mid;
+      PFR_Char  gchar;
+
+
+      while ( min < max )
+      {
+        mid   = min + ( ( max - min ) >> 1 );
+        gchar = cmap->chars + mid;
+
+        if ( gchar->char_code == char_code )
+        {
+          result = mid;
+          if ( result != 0 )
+          {
+            result++;
+            goto Exit;
+          }
+
+          char_code++;
+          goto Restart;
+        }
+
+        if ( gchar->char_code < char_code )
+          min = mid+1;
+        else
+          max = mid;
+      }
+
+      /* we didn't find it, but we have a pair just above it */
+      char_code = 0;
+
+      if ( min < cmap->num_chars )
+      {
+        gchar  = cmap->chars + min;
+        result = min;
+        if ( result != 0 )
+        {
+          result++;
+          char_code = gchar->char_code;
+        }
+      }
+    }
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  pfr_cmap_class_rec =
+  {
+    sizeof ( PFR_CMapRec ),
+
+    (FT_CMap_InitFunc)     pfr_cmap_init,
+    (FT_CMap_DoneFunc)     pfr_cmap_done,
+    (FT_CMap_CharIndexFunc)pfr_cmap_char_index,
+    (FT_CMap_CharNextFunc) pfr_cmap_char_next
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrcmap.h b/nx-X11/extras/freetype2/src/pfr/pfrcmap.h
new file mode 100644
index 000000000..d77813e3c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrcmap.h
@@ -0,0 +1,46 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrcmap.h                                                              */
+/*                                                                         */
+/*    FreeType PFR cmap handling (specification).                          */
+/*                                                                         */
+/*  Copyright 2002 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 __PFRCMAP_H__
+#define __PFRCMAP_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include "pfrtypes.h"
+
+
+FT_BEGIN_HEADER
+
+  typedef struct  PFR_CMapRec_
+  {
+    FT_CMapRec  cmap;
+    FT_UInt     num_chars;
+    PFR_Char    chars;
+  
+  } PFR_CMapRec, *PFR_CMap;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec  pfr_cmap_class_rec;
+
+FT_END_HEADER
+
+
+#endif /* __PFRCMAP_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrdrivr.c b/nx-X11/extras/freetype2/src/pfr/pfrdrivr.c
new file mode 100644
index 000000000..55752a5f4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrdrivr.c
@@ -0,0 +1,203 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrdrivr.c                                                             */
+/*                                                                         */
+/*    FreeType PFR driver interface (body).                                */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 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_SERVICE_PFR_H
+#include FT_SERVICE_XFREE86_NAME_H
+#include "pfrdrivr.h"
+#include "pfrobjs.h"
+
+#include "pfrerror.h"
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_get_kerning( FT_Face     pfrface,     /* PFR_Face */
+                   FT_UInt     left,
+                   FT_UInt     right,
+                   FT_Vector  *avector )
+  {
+    PFR_Face     face = (PFR_Face)pfrface;
+    PFR_PhyFont  phys = &face->phy_font;
+
+
+    pfr_face_get_kerning( pfrface, left, right, avector );
+
+    /* convert from metrics to outline units when necessary */
+    if ( phys->outline_resolution != phys->metrics_resolution )
+    {
+      if ( avector->x != 0 )
+        avector->x = FT_MulDiv( avector->x, phys->outline_resolution,
+                                            phys->metrics_resolution );
+
+      if ( avector->y != 0 )
+        avector->y = FT_MulDiv( avector->x, phys->outline_resolution,
+                                            phys->metrics_resolution );
+    }
+
+    return PFR_Err_Ok;
+  }
+
+
+ /*
+  *  PFR METRICS SERVICE
+  *
+  */
+
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_get_advance( FT_Face   pfrface,       /* PFR_Face */
+                   FT_UInt   gindex,
+                   FT_Pos   *anadvance )
+  {
+    PFR_Face  face  = (PFR_Face)pfrface;
+    FT_Error  error = PFR_Err_Bad_Argument;
+
+
+    *anadvance = 0;
+    if ( face )
+    {
+      PFR_PhyFont  phys = &face->phy_font;
+
+
+      if ( gindex < phys->num_chars )
+      {
+        *anadvance = phys->chars[gindex].advance;
+        error = 0;
+      }
+    }
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_get_metrics( FT_Face    pfrface,      /* PFR_Face */
+                   FT_UInt   *anoutline_resolution,
+                   FT_UInt   *ametrics_resolution,
+                   FT_Fixed  *ametrics_x_scale,
+                   FT_Fixed  *ametrics_y_scale )
+  {
+    PFR_Face     face = (PFR_Face)pfrface;
+    PFR_PhyFont  phys = &face->phy_font;
+    FT_Fixed     x_scale, y_scale;
+    FT_Size      size = face->root.size;
+
+
+    if ( anoutline_resolution )
+      *anoutline_resolution = phys->outline_resolution;
+
+    if ( ametrics_resolution )
+      *ametrics_resolution = phys->metrics_resolution;
+
+    x_scale = 0x10000L;
+    y_scale = 0x10000L;
+
+    if ( size )
+    {
+      x_scale = FT_DivFix( size->metrics.x_ppem << 6,
+                           phys->metrics_resolution );
+
+      y_scale = FT_DivFix( size->metrics.y_ppem << 6,
+                           phys->metrics_resolution );
+    }
+
+    if ( ametrics_x_scale )
+      *ametrics_x_scale = x_scale;
+
+    if ( ametrics_y_scale )
+      *ametrics_y_scale = y_scale;
+
+    return PFR_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Service_PfrMetricsRec  pfr_metrics_service_rec =
+  {
+    pfr_get_metrics,
+    pfr_face_get_kerning,
+    pfr_get_advance
+  };
+
+
+ /*
+  *  SERVICE LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  pfr_services[] =
+  {
+    { FT_SERVICE_ID_PFR_METRICS, &pfr_metrics_service_rec },
+    { FT_SERVICE_ID_XF86_NAME,   FT_XF86_FORMAT_PFR },
+    { NULL, NULL }
+  };
+
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  pfr_get_service( FT_Module         module,
+                   const FT_String*  service_id )
+  {
+    FT_UNUSED( module );
+
+    return ft_service_list_lookup( pfr_services, service_id );
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  pfr_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER     |
+      FT_MODULE_DRIVER_SCALABLE,
+
+      sizeof( FT_DriverRec ),
+
+      "pfr",
+      0x10000L,
+      0x20000L,
+
+      NULL,
+
+      0,
+      0,
+      pfr_get_service
+    },
+
+    sizeof( PFR_FaceRec ),
+    sizeof( PFR_SizeRec ),
+    sizeof( PFR_SlotRec ),
+
+    pfr_face_init,
+    pfr_face_done,
+    0,                  /* FT_Size_InitFunc */
+    0,                  /* FT_Size_DoneFunc */
+    pfr_slot_init,
+    pfr_slot_done,
+
+    0,                  /* FT_Size_ResetPointsFunc */
+    0,                  /* FT_Size_ResetPixelsFunc */
+    pfr_slot_load,
+
+    pfr_get_kerning,
+    0,                  /* FT_Face_AttachFunc      */
+    0                   /* FT_Face_GetAdvancesFunc */
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrdrivr.h b/nx-X11/extras/freetype2/src/pfr/pfrdrivr.h
new file mode 100644
index 000000000..36f1205b7
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrdrivr.h
@@ -0,0 +1,39 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrdrivr.h                                                             */
+/*                                                                         */
+/*    High-level Type PFR driver interface (specification).                */
+/*                                                                         */
+/*  Copyright 2002 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 __PFRDRIVR_H__
+#define __PFRDRIVR_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  pfr_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __PFRDRIVR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrerror.h b/nx-X11/extras/freetype2/src/pfr/pfrerror.h
new file mode 100644
index 000000000..2e1c401dd
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrerror.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrerror.h                                                             */
+/*                                                                         */
+/*    PFR error codes (specification only).                                */
+/*                                                                         */
+/*  Copyright 2002 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 PFR error enumeration constants.      */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __PFRERROR_H__
+#define __PFRERROR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  PFR_Err_
+#define FT_ERR_BASE    FT_Mod_Err_PFR
+
+#include FT_ERRORS_H
+
+#endif /* __PFRERROR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrgload.c b/nx-X11/extras/freetype2/src/pfr/pfrgload.c
new file mode 100644
index 000000000..87ba6846e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrgload.c
@@ -0,0 +1,801 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrgload.c                                                             */
+/*                                                                         */
+/*    FreeType PFR glyph loader (body).                                    */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 "pfrgload.h"
+#include "pfrsbit.h"
+#include "pfrload.h"            /* for macro definitions */
+#include FT_INTERNAL_DEBUG_H
+
+#include "pfrerror.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pfr
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      PFR GLYPH BUILDER                        *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( void )
+  pfr_glyph_init( PFR_Glyph       glyph,
+                  FT_GlyphLoader  loader )
+  {
+    FT_ZERO( glyph );
+
+    glyph->loader     = loader;
+    glyph->path_begun = 0;
+
+    FT_GlyphLoader_Rewind( loader );
+  }
+
+
+  FT_LOCAL_DEF( void )
+  pfr_glyph_done( PFR_Glyph  glyph )
+  {
+    FT_Memory  memory = glyph->loader->memory;
+
+
+    FT_FREE( glyph->x_control );
+    glyph->y_control = NULL;
+
+    glyph->max_xy_control = 0;
+    glyph->num_x_control  = 0;
+    glyph->num_y_control  = 0;
+
+    FT_FREE( glyph->subs );
+
+    glyph->max_subs = 0;
+    glyph->num_subs = 0;
+
+    glyph->loader     = NULL;
+    glyph->path_begun = 0;
+  }
+
+
+  /* close current contour, if any */
+  static void
+  pfr_glyph_close_contour( PFR_Glyph  glyph )
+  {
+    FT_GlyphLoader  loader  = glyph->loader;
+    FT_Outline*     outline = &loader->current.outline;
+    FT_Int          last, first;
+
+
+    if ( !glyph->path_begun )
+      return;
+
+    /* compute first and last point indices in current glyph outline */
+    last  = outline->n_points - 1;
+    first = 0;
+    if ( outline->n_contours > 0 )
+      first = outline->contours[outline->n_contours - 1];
+
+    /* if the last point falls on the same location than the first one */
+    /* we need to delete it                                            */
+    if ( last > first )
+    {
+      FT_Vector*  p1 = outline->points + first;
+      FT_Vector*  p2 = outline->points + last;
+
+
+      if ( p1->x == p2->x && p1->y == p2->y )
+      {
+        outline->n_points--;
+        last--;
+      }
+    }
+
+    /* don't add empty contours */
+    if ( last >= first )
+      outline->contours[outline->n_contours++] = (short)last;
+
+    glyph->path_begun = 0;
+  }
+
+
+  /* reset glyph to start the loading of a new glyph */
+  static void
+  pfr_glyph_start( PFR_Glyph  glyph )
+  {
+    glyph->path_begun = 0;
+  }
+
+
+  static FT_Error
+  pfr_glyph_line_to( PFR_Glyph   glyph,
+                     FT_Vector*  to )
+  {
+    FT_GlyphLoader  loader  = glyph->loader;
+    FT_Outline*     outline = &loader->current.outline;
+    FT_Error        error;
+
+
+    /* check that we have begun a new path */
+    FT_ASSERT( glyph->path_begun != 0 );
+
+    error = FT_GlyphLoader_CheckPoints( loader, 1, 0 );
+    if ( !error )
+    {
+      FT_UInt  n = outline->n_points;
+
+
+      outline->points[n] = *to;
+      outline->tags  [n] = FT_CURVE_TAG_ON;
+
+      outline->n_points++;
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  pfr_glyph_curve_to( PFR_Glyph   glyph,
+                      FT_Vector*  control1,
+                      FT_Vector*  control2,
+                      FT_Vector*  to )
+  {
+    FT_GlyphLoader  loader  = glyph->loader;
+    FT_Outline*     outline = &loader->current.outline;
+    FT_Error        error;
+
+
+    /* check that we have begun a new path */
+    FT_ASSERT( glyph->path_begun != 0 );
+
+    error = FT_GlyphLoader_CheckPoints( loader, 3, 0 );
+    if ( !error )
+    {
+      FT_Vector*  vec = outline->points         + outline->n_points;
+      FT_Byte*    tag = (FT_Byte*)outline->tags + outline->n_points;
+
+
+      vec[0] = *control1;
+      vec[1] = *control2;
+      vec[2] = *to;
+      tag[0] = FT_CURVE_TAG_CUBIC;
+      tag[1] = FT_CURVE_TAG_CUBIC;
+      tag[2] = FT_CURVE_TAG_ON;
+
+      outline->n_points = (FT_Short)( outline->n_points + 3 );
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  pfr_glyph_move_to( PFR_Glyph   glyph,
+                     FT_Vector*  to )
+  {
+    FT_GlyphLoader  loader  = glyph->loader;
+    FT_Error        error;
+
+
+    /* close current contour if any */
+    pfr_glyph_close_contour( glyph );
+
+    /* indicate that a new contour has started */
+    glyph->path_begun = 1;
+
+    /* check that there is space for a new contour and a new point */
+    error = FT_GlyphLoader_CheckPoints( loader, 1, 1 );
+    if ( !error )
+      /* add new start point */
+      error = pfr_glyph_line_to( glyph, to );
+
+    return error;
+  }
+
+
+  static void
+  pfr_glyph_end( PFR_Glyph  glyph )
+  {
+    /* close current contour if any */
+    pfr_glyph_close_contour( glyph );
+
+    /* merge the current glyph into the stack */
+    FT_GlyphLoader_Add( glyph->loader );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      PFR GLYPH LOADER                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* load a simple glyph */
+  static FT_Error
+  pfr_glyph_load_simple( PFR_Glyph  glyph,
+                         FT_Byte*   p,
+                         FT_Byte*   limit )
+  {
+    FT_Error   error  = 0;
+    FT_Memory  memory = glyph->loader->memory;
+    FT_UInt    flags, x_count, y_count, i, count, mask;
+    FT_Int     x;
+
+
+    PFR_CHECK( 1 );
+    flags = PFR_NEXT_BYTE( p );
+
+    /* test for composite glyphs */
+    FT_ASSERT( ( flags & PFR_GLYPH_IS_COMPOUND ) == 0 );
+
+    x_count = 0;
+    y_count = 0;
+
+    if ( flags & PFR_GLYPH_1BYTE_XYCOUNT )
+    {
+      PFR_CHECK( 1 );
+      count   = PFR_NEXT_BYTE( p );
+      x_count = ( count & 15 );
+      y_count = ( count >> 4 );
+    }
+    else
+    {
+      if ( flags & PFR_GLYPH_XCOUNT )
+      {
+        PFR_CHECK( 1 );
+        x_count = PFR_NEXT_BYTE( p );
+      }
+
+      if ( flags & PFR_GLYPH_YCOUNT )
+      {
+        PFR_CHECK( 1 );
+        y_count = PFR_NEXT_BYTE( p );
+      }
+    }
+
+    count = x_count + y_count;
+
+    /* re-allocate array when necessary */
+    if ( count > glyph->max_xy_control )
+    {
+      FT_UInt  new_max = FT_PAD_CEIL( count, 8 );
+
+
+      if ( FT_RENEW_ARRAY( glyph->x_control,
+                           glyph->max_xy_control,
+                           new_max ) )
+        goto Exit;
+
+      glyph->max_xy_control = new_max;
+    }
+
+    glyph->y_control = glyph->x_control + x_count;
+
+    mask  = 0;
+    x     = 0;
+
+    for ( i = 0; i < count; i++ )
+    {
+      if ( ( i & 7 ) == 0 )
+      {
+        PFR_CHECK( 1 );
+        mask = PFR_NEXT_BYTE( p );
+      }
+
+      if ( mask & 1 )
+      {
+        PFR_CHECK( 2 );
+        x = PFR_NEXT_SHORT( p );
+      }
+      else
+      {
+        PFR_CHECK( 1 );
+        x += PFR_NEXT_BYTE( p );
+      }
+
+      glyph->x_control[i] = x;
+
+      mask >>= 1;
+    }
+
+    /* XXX: for now we ignore the secondary stroke and edge definitions */
+    /*      since we don't want to support native PFR hinting           */
+    /*                                                                  */
+    if ( flags & PFR_GLYPH_EXTRA_ITEMS )
+    {
+      error = pfr_extra_items_skip( &p, limit );
+      if ( error )
+        goto Exit;
+    }
+
+    pfr_glyph_start( glyph );
+
+    /* now load a simple glyph */
+    {
+      FT_Vector   pos[4];
+      FT_Vector*  cur;
+
+
+      pos[0].x = pos[0].y = 0;
+      pos[3]   = pos[0];
+
+      for (;;)
+      {
+        FT_Int  format, args_format = 0, args_count, n;
+
+
+        /***************************************************************/
+        /*  read instruction                                           */
+        /*                                                             */
+        PFR_CHECK( 1 );
+        format = PFR_NEXT_BYTE( p );
+
+        switch ( format >> 4 )
+        {
+        case 0:                             /* end glyph */
+          FT_TRACE6(( "- end glyph" ));
+          args_count = 0;
+          break;
+
+        case 1:                             /* general line operation */
+          FT_TRACE6(( "- general line" ));
+          goto Line1;
+
+        case 4:                             /* move to inside contour  */
+          FT_TRACE6(( "- move to inside" ));
+          goto Line1;
+
+        case 5:                             /* move to outside contour */
+          FT_TRACE6(( "- move to outside" ));
+        Line1:
+          args_format = format & 15;
+          args_count  = 1;
+          break;
+
+        case 2:                             /* horizontal line to */
+          FT_TRACE6(( "- horizontal line to cx.%d", format & 15 ));
+          pos[0].y   = pos[3].y;
+          pos[0].x   = glyph->x_control[format & 15];
+          pos[3]     = pos[0];
+          args_count = 0;
+          break;
+
+        case 3:                             /* vertical line to */
+          FT_TRACE6(( "- vertical line to cy.%d", format & 15 ));
+          pos[0].x   = pos[3].x;
+          pos[0].y   = glyph->y_control[format & 15];
+          pos[3] = pos[0];
+          args_count = 0;
+          break;
+
+        case 6:                             /* horizontal to vertical curve */
+          FT_TRACE6(( "- hv curve " ));
+          args_format  = 0xB8E;
+          args_count   = 3;
+          break;
+
+        case 7:                             /* vertical to horizontal curve */
+          FT_TRACE6(( "- vh curve" ));
+          args_format = 0xE2B;
+          args_count  = 3;
+          break;
+
+        default:                            /* general curve to */
+          FT_TRACE6(( "- general curve" ));
+          args_count  = 4;
+          args_format = format & 15;
+        }
+
+        /***********************************************************/
+        /*  now read arguments                                     */
+        /*                                                         */
+        cur = pos;
+        for ( n = 0; n < args_count; n++ )
+        {
+          FT_Int  idx, delta;
+
+
+          /* read the X argument */
+          switch ( args_format & 3 )
+          {
+          case 0:                           /* 8-bit index */
+            PFR_CHECK( 1 );
+            idx  = PFR_NEXT_BYTE( p );
+            cur->x = glyph->x_control[idx];
+            FT_TRACE7(( " cx#%d", idx ));
+            break;
+
+          case 1:                           /* 16-bit value */
+            PFR_CHECK( 2 );
+            cur->x = PFR_NEXT_SHORT( p );
+            FT_TRACE7(( " x.%d", cur->x ));
+            break;
+
+          case 2:                           /* 8-bit delta */
+            PFR_CHECK( 1 );
+            delta  = PFR_NEXT_INT8( p );
+            cur->x = pos[3].x + delta;
+            FT_TRACE7(( " dx.%d", delta ));
+            break;
+
+          default:
+            FT_TRACE7(( " |" ));
+            cur->x = pos[3].x;
+          }
+
+          /* read the Y argument */
+          switch ( ( args_format >> 2 ) & 3 )
+          {
+          case 0:                           /* 8-bit index */
+            PFR_CHECK( 1 );
+            idx  = PFR_NEXT_BYTE( p );
+            cur->y = glyph->y_control[idx];
+            FT_TRACE7(( " cy#%d", idx ));
+            break;
+
+          case 1:                           /* 16-bit absolute value */
+            PFR_CHECK( 2 );
+            cur->y = PFR_NEXT_SHORT( p );
+            FT_TRACE7(( " y.%d", cur->y ));
+            break;
+
+          case 2:                           /* 8-bit delta */
+            PFR_CHECK( 1 );
+            delta  = PFR_NEXT_INT8( p );
+            cur->y = pos[3].y + delta;
+            FT_TRACE7(( " dy.%d", delta ));
+            break;
+
+          default:
+            FT_TRACE7(( " -" ));
+            cur->y = pos[3].y;
+          }
+
+          /* read the additional format flag for the general curve */
+          if ( n == 0 && args_count == 4 )
+          {
+            PFR_CHECK( 1 );
+            args_format = PFR_NEXT_BYTE( p );
+            args_count--;
+          }
+          else
+            args_format >>= 4;
+
+          /* save the previous point */
+          pos[3] = cur[0];
+          cur++;
+        }
+
+        FT_TRACE7(( "\n" ));
+
+        /***********************************************************/
+        /*  finally, execute instruction                           */
+        /*                                                         */
+        switch ( format >> 4 )
+        {
+        case 0:                             /* end glyph => EXIT */
+          pfr_glyph_end( glyph );
+          goto Exit;
+
+        case 1:                             /* line operations */
+        case 2:
+        case 3:
+          error = pfr_glyph_line_to( glyph, pos );
+          goto Test_Error;
+
+        case 4:                             /* move to inside contour  */
+        case 5:                             /* move to outside contour */
+          error = pfr_glyph_move_to( glyph, pos );
+          goto Test_Error;
+
+        default:                            /* curve operations */
+          error = pfr_glyph_curve_to( glyph, pos, pos + 1, pos + 2 );
+
+        Test_Error:  /* test error condition */
+          if ( error )
+            goto Exit;
+        }
+      } /* for (;;) */
+    }
+
+  Exit:
+    return error;
+
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_glyph_load_simple: invalid glyph data\n" ));
+    goto Exit;
+  }
+
+
+  /* load a composite/compound glyph */
+  static FT_Error
+  pfr_glyph_load_compound( PFR_Glyph  glyph,
+                           FT_Byte*   p,
+                           FT_Byte*   limit )
+  {
+    FT_Error        error  = 0;
+    FT_GlyphLoader  loader = glyph->loader;
+    FT_Memory       memory = loader->memory;
+    PFR_SubGlyph    subglyph;
+    FT_UInt         flags, i, count, org_count;
+    FT_Int          x_pos, y_pos;
+
+
+    PFR_CHECK( 1 );
+    flags = PFR_NEXT_BYTE( p );
+
+    /* test for composite glyphs */
+    FT_ASSERT( ( flags & PFR_GLYPH_IS_COMPOUND ) != 0 );
+
+    count = flags & 0x3F;
+
+    /* ignore extra items when present */
+    /*                                 */
+    if ( flags & PFR_GLYPH_EXTRA_ITEMS )
+    {
+      error = pfr_extra_items_skip( &p, limit );
+      if (error) goto Exit;
+    }
+
+    /* we can't rely on the FT_GlyphLoader to load sub-glyphs, because   */
+    /* the PFR format is dumb, using direct file offsets to point to the */
+    /* sub-glyphs (instead of glyph indices).  Sigh.                     */
+    /*                                                                   */
+    /* For now, we load the list of sub-glyphs into a different array    */
+    /* but this will prevent us from using the auto-hinter at its best   */
+    /* quality.                                                          */
+    /*                                                                   */
+    org_count = glyph->num_subs;
+
+    if ( org_count + count > glyph->max_subs )
+    {
+      FT_UInt  new_max = ( org_count + count + 3 ) & -4;
+
+
+      if ( FT_RENEW_ARRAY( glyph->subs, glyph->max_subs, new_max ) )
+        goto Exit;
+
+      glyph->max_subs = new_max;
+    }
+
+    subglyph = glyph->subs + org_count;
+
+    for ( i = 0; i < count; i++, subglyph++ )
+    {
+      FT_UInt  format;
+
+
+      x_pos = 0;
+      y_pos = 0;
+
+      PFR_CHECK( 1 );
+      format = PFR_NEXT_BYTE( p );
+
+      /* read scale when available */
+      subglyph->x_scale = 0x10000L;
+      if ( format & PFR_SUBGLYPH_XSCALE )
+      {
+        PFR_CHECK( 2 );
+        subglyph->x_scale = PFR_NEXT_SHORT( p ) << 4;
+      }
+
+      subglyph->y_scale = 0x10000L;
+      if ( format & PFR_SUBGLYPH_YSCALE )
+      {
+        PFR_CHECK( 2 );
+        subglyph->y_scale = PFR_NEXT_SHORT( p ) << 4;
+      }
+
+      /* read offset */
+      switch ( format & 3 )
+      {
+      case 1:
+        PFR_CHECK( 2 );
+        x_pos = PFR_NEXT_SHORT( p );
+        break;
+
+      case 2:
+        PFR_CHECK( 1 );
+        x_pos += PFR_NEXT_INT8( p );
+        break;
+
+      default:
+        ;
+      }
+
+      switch ( ( format >> 2 ) & 3 )
+      {
+      case 1:
+        PFR_CHECK( 2 );
+        y_pos = PFR_NEXT_SHORT( p );
+        break;
+
+      case 2:
+        PFR_CHECK( 1 );
+        y_pos += PFR_NEXT_INT8( p );
+        break;
+
+      default:
+        ;
+      }
+
+      subglyph->x_delta = x_pos;
+      subglyph->y_delta = y_pos;
+
+      /* read glyph position and size now */
+      if ( format & PFR_SUBGLYPH_2BYTE_SIZE )
+      {
+        PFR_CHECK( 2 );
+        subglyph->gps_size = PFR_NEXT_USHORT( p );
+      }
+      else
+      {
+        PFR_CHECK( 1 );
+        subglyph->gps_size = PFR_NEXT_BYTE( p );
+      }
+
+      if ( format & PFR_SUBGLYPH_3BYTE_OFFSET )
+      {
+        PFR_CHECK( 3 );
+        subglyph->gps_offset = PFR_NEXT_LONG( p );
+      }
+      else
+      {
+        PFR_CHECK( 2 );
+        subglyph->gps_offset = PFR_NEXT_USHORT( p );
+      }
+
+      glyph->num_subs++;
+    }
+
+  Exit:
+    return error;
+
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_glyph_load_compound: invalid glyph data\n" ));
+    goto Exit;
+  }
+
+
+
+
+
+  static FT_Error
+  pfr_glyph_load_rec( PFR_Glyph  glyph,
+                      FT_Stream  stream,
+                      FT_ULong   gps_offset,
+                      FT_ULong   offset,
+                      FT_ULong   size )
+  {
+    FT_Error  error;
+    FT_Byte*  p;
+    FT_Byte*  limit;
+
+
+    if ( FT_STREAM_SEEK( gps_offset + offset ) ||
+         FT_FRAME_ENTER( size )                )
+      goto Exit;
+
+    p     = (FT_Byte*)stream->cursor;
+    limit = p + size;
+
+    if ( size > 0 && *p & PFR_GLYPH_IS_COMPOUND )
+    {
+      FT_Int          n, old_count, count;
+      FT_GlyphLoader  loader = glyph->loader;
+      FT_Outline*     base   = &loader->base.outline;
+
+
+      old_count = glyph->num_subs;
+
+      /* this is a compound glyph - load it */
+      error = pfr_glyph_load_compound( glyph, p, limit );
+
+      FT_FRAME_EXIT();
+
+      if ( error )
+        goto Exit;
+
+      count = glyph->num_subs - old_count;
+
+      /* now, load each individual glyph */
+      for ( n = 0; n < count; n++ )
+      {
+        FT_Int        i, old_points, num_points;
+        PFR_SubGlyph  subglyph;
+
+
+        subglyph   = glyph->subs + old_count + n;
+        old_points = base->n_points;
+
+        error = pfr_glyph_load_rec( glyph, stream, gps_offset,
+                                    subglyph->gps_offset,
+                                    subglyph->gps_size );
+        if ( error )
+          goto Exit;
+
+        /* note that `glyph->subs' might have been re-allocated */
+        subglyph   = glyph->subs + old_count + n;
+        num_points = base->n_points - old_points;
+
+        /* translate and eventually scale the new glyph points */
+        if ( subglyph->x_scale != 0x10000L || subglyph->y_scale != 0x10000L )
+        {
+          FT_Vector*  vec = base->points + old_points;
+
+
+          for ( i = 0; i < num_points; i++, vec++ )
+          {
+            vec->x = FT_MulFix( vec->x, subglyph->x_scale ) +
+                       subglyph->x_delta;
+            vec->y = FT_MulFix( vec->y, subglyph->y_scale ) +
+                       subglyph->y_delta;
+          }
+        }
+        else
+        {
+          FT_Vector*  vec = loader->base.outline.points + old_points;
+
+
+          for ( i = 0; i < num_points; i++, vec++ )
+          {
+            vec->x += subglyph->x_delta;
+            vec->y += subglyph->y_delta;
+          }
+        }
+
+        /* proceed to next sub-glyph */
+      }
+    }
+    else
+    {
+      /* load a simple glyph */
+      error = pfr_glyph_load_simple( glyph, p, limit );
+
+      FT_FRAME_EXIT();
+    }
+
+  Exit:
+    return error;
+  }
+
+
+
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_glyph_load( PFR_Glyph  glyph,
+                  FT_Stream  stream,
+                  FT_ULong   gps_offset,
+                  FT_ULong   offset,
+                  FT_ULong   size )
+  {
+    /* initialize glyph loader */
+    FT_GlyphLoader_Rewind( glyph->loader );
+
+    /* load the glyph, recursively when needed */
+    return pfr_glyph_load_rec( glyph, stream, gps_offset, offset, size );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrgload.h b/nx-X11/extras/freetype2/src/pfr/pfrgload.h
new file mode 100644
index 000000000..7cc7a8702
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrgload.h
@@ -0,0 +1,49 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrgload.h                                                             */
+/*                                                                         */
+/*    FreeType PFR glyph loader (specification).                           */
+/*                                                                         */
+/*  Copyright 2002 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 __PFRGLOAD_H__
+#define __PFRGLOAD_H__
+
+#include "pfrtypes.h"
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( void )
+  pfr_glyph_init( PFR_Glyph       glyph,
+                  FT_GlyphLoader  loader );
+
+  FT_LOCAL( void )
+  pfr_glyph_done( PFR_Glyph  glyph );
+
+
+  FT_LOCAL( FT_Error )
+  pfr_glyph_load( PFR_Glyph  glyph,
+                  FT_Stream  stream,
+                  FT_ULong   gps_offset,
+                  FT_ULong   offset,
+                  FT_ULong   size );
+
+
+FT_END_HEADER
+
+
+#endif /* __PFRGLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrload.c b/nx-X11/extras/freetype2/src/pfr/pfrload.c
new file mode 100644
index 000000000..19ced45d1
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrload.c
@@ -0,0 +1,1081 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrload.c                                                              */
+/*                                                                         */
+/*    FreeType PFR loader (body).                                          */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 "pfrload.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+
+#include "pfrerror.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pfr
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          EXTRA ITEMS                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_extra_items_skip( FT_Byte*  *pp,
+                        FT_Byte*   limit )
+  {
+    return pfr_extra_items_parse( pp, limit, NULL, NULL );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_extra_items_parse( FT_Byte*       *pp,
+                         FT_Byte*        limit,
+                         PFR_ExtraItem   item_list,
+                         FT_Pointer      item_data )
+  {
+    FT_Error  error = 0;
+    FT_Byte*  p     = *pp;
+    FT_UInt   num_items, item_type, item_size;
+
+
+    PFR_CHECK( 1 );
+    num_items = PFR_NEXT_BYTE( p );
+
+    for ( ; num_items > 0; num_items-- )
+    {
+      PFR_CHECK( 2 );
+      item_size = PFR_NEXT_BYTE( p );
+      item_type = PFR_NEXT_BYTE( p );
+
+      PFR_CHECK( item_size );
+
+      if ( item_list )
+      {
+        PFR_ExtraItem  extra = item_list;
+
+
+        for ( extra = item_list; extra->parser != NULL; extra++ )
+        {
+          if ( extra->type == item_type )
+          {
+            error = extra->parser( p, p + item_size, item_data );
+            if ( error ) goto Exit;
+
+            break;
+          }
+        }
+      }
+
+      p += item_size;
+    }
+
+  Exit:
+    *pp = p;
+    return error;
+
+  Too_Short:
+    FT_ERROR(( "pfr_extra_items_parse: invalid extra items table\n" ));
+    error = PFR_Err_Invalid_Table;
+    goto Exit;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          PFR HEADER                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+   static const FT_Frame_Field  pfr_header_fields[] =
+   {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PFR_HeaderRec
+
+     FT_FRAME_START( 58 ),
+       FT_FRAME_ULONG ( signature ),
+       FT_FRAME_USHORT( version ),
+       FT_FRAME_USHORT( signature2 ),
+       FT_FRAME_USHORT( header_size ),
+
+       FT_FRAME_USHORT( log_dir_size ),
+       FT_FRAME_USHORT( log_dir_offset ),
+
+       FT_FRAME_USHORT( log_font_max_size ),
+       FT_FRAME_UOFF3 ( log_font_section_size ),
+       FT_FRAME_UOFF3 ( log_font_section_offset ),
+
+       FT_FRAME_USHORT( phy_font_max_size ),
+       FT_FRAME_UOFF3 ( phy_font_section_size ),
+       FT_FRAME_UOFF3 ( phy_font_section_offset ),
+
+       FT_FRAME_USHORT( gps_max_size ),
+       FT_FRAME_UOFF3 ( gps_section_size ),
+       FT_FRAME_UOFF3 ( gps_section_offset ),
+
+       FT_FRAME_BYTE  ( max_blue_values ),
+       FT_FRAME_BYTE  ( max_x_orus ),
+       FT_FRAME_BYTE  ( max_y_orus ),
+
+       FT_FRAME_BYTE  ( phy_font_max_size_high ),
+       FT_FRAME_BYTE  ( color_flags ),
+
+       FT_FRAME_UOFF3 ( bct_max_size ),
+       FT_FRAME_UOFF3 ( bct_set_max_size ),
+       FT_FRAME_UOFF3 ( phy_bct_set_max_size ),
+
+       FT_FRAME_USHORT( num_phy_fonts ),
+       FT_FRAME_BYTE  ( max_vert_stem_snap ),
+       FT_FRAME_BYTE  ( max_horz_stem_snap ),
+       FT_FRAME_USHORT( max_chars ),
+     FT_FRAME_END
+   };
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_header_load( PFR_Header  header,
+                   FT_Stream   stream )
+  {
+    FT_Error  error;
+
+
+    /* read header directly */
+    if ( !FT_STREAM_SEEK( 0 )                                &&
+         !FT_STREAM_READ_FIELDS( pfr_header_fields, header ) )
+    {
+      /* make a few adjustments to the header */
+      header->phy_font_max_size +=
+        (FT_UInt32)header->phy_font_max_size_high << 16;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Bool )
+  pfr_header_check( PFR_Header  header )
+  {
+    FT_Bool  result = 1;
+
+
+    /* check signature and header size */
+    if ( header->signature  != 0x50465230L ||   /* "PFR0" */
+         header->version     > 4           ||
+         header->header_size < 58          ||
+         header->signature2 != 0x0d0a      )    /* CR/LF  */
+    {
+      result = 0;
+    }
+    return  result;
+  }
+
+
+  /***********************************************************************/
+  /***********************************************************************/
+  /*****                                                             *****/
+  /*****                    PFR LOGICAL FONTS                        *****/
+  /*****                                                             *****/
+  /***********************************************************************/
+  /***********************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_log_font_count( FT_Stream  stream,
+                      FT_UInt32  section_offset,
+                      FT_UInt   *acount )
+  {
+    FT_Error  error;
+    FT_UInt   count;
+    FT_UInt   result = 0;
+
+
+    if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT( count ) )
+      goto Exit;
+
+    result = count;
+
+  Exit:
+    *acount = result;
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_log_font_load( PFR_LogFont  log_font,
+                     FT_Stream    stream,
+                     FT_UInt      idx,
+                     FT_UInt32    section_offset,
+                     FT_Bool      size_increment )
+  {
+    FT_UInt    num_log_fonts;
+    FT_UInt    flags;
+    FT_UInt32  offset;
+    FT_UInt32  size;
+    FT_Error   error;
+
+
+    if ( FT_STREAM_SEEK( section_offset ) ||
+         FT_READ_USHORT( num_log_fonts )  )
+      goto Exit;
+
+    if ( idx >= num_log_fonts )
+      return PFR_Err_Invalid_Argument;
+
+    if ( FT_STREAM_SKIP( idx * 5 ) ||
+         FT_READ_USHORT( size )    ||
+         FT_READ_UOFF3 ( offset )  )
+      goto Exit;
+
+    /* save logical font size and offset */
+    log_font->size   = size;
+    log_font->offset = offset;
+
+    /* now, check the rest of the table before loading it */
+    {
+      FT_Byte*  p;
+      FT_Byte*  limit;
+      FT_UInt   local;
+
+
+      if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) )
+        goto Exit;
+
+      p     = stream->cursor;
+      limit = p + size;
+
+      PFR_CHECK(13);
+
+      log_font->matrix[0] = PFR_NEXT_LONG( p );
+      log_font->matrix[1] = PFR_NEXT_LONG( p );
+      log_font->matrix[2] = PFR_NEXT_LONG( p );
+      log_font->matrix[3] = PFR_NEXT_LONG( p );
+
+      flags = PFR_NEXT_BYTE( p );
+
+      local = 0;
+      if ( flags & PFR_LOG_STROKE )
+      {
+        local++;
+        if ( flags & PFR_LOG_2BYTE_STROKE )
+          local++;
+
+        if ( (flags & PFR_LINE_JOIN_MASK) == PFR_LINE_JOIN_MITER )
+          local += 3;
+      }
+      if ( flags & PFR_LOG_BOLD )
+      {
+        local++;
+        if ( flags & PFR_LOG_2BYTE_BOLD )
+          local++;
+      }
+
+      PFR_CHECK( local );
+
+      if ( flags & PFR_LOG_STROKE )
+      {
+        log_font->stroke_thickness = ( flags & PFR_LOG_2BYTE_STROKE )
+                                     ? PFR_NEXT_SHORT( p )
+                                     : PFR_NEXT_BYTE( p );
+
+        if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER )
+          log_font->miter_limit = PFR_NEXT_LONG( p );
+      }
+
+      if ( flags & PFR_LOG_BOLD )
+      {
+        log_font->bold_thickness = ( flags & PFR_LOG_2BYTE_BOLD )
+                                   ? PFR_NEXT_SHORT( p )
+                                   : PFR_NEXT_BYTE( p );
+      }
+
+      if ( flags & PFR_LOG_EXTRA_ITEMS )
+      {
+        error = pfr_extra_items_skip( &p, limit );
+        if (error) goto Fail;
+      }
+
+      PFR_CHECK(5);
+      log_font->phys_size   = PFR_NEXT_USHORT( p );
+      log_font->phys_offset = PFR_NEXT_ULONG( p );
+      if ( size_increment )
+      {
+        PFR_CHECK( 1 );
+        log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE( p ) << 16;
+      }
+    }
+
+  Fail:
+    FT_FRAME_EXIT();
+
+  Exit:
+    return error;
+
+  Too_Short:
+    FT_ERROR(( "pfr_log_font_load: invalid logical font table\n" ));
+    error = PFR_Err_Invalid_Table;
+    goto Fail;
+  }
+
+
+  /***********************************************************************/
+  /***********************************************************************/
+  /*****                                                             *****/
+  /*****                    PFR PHYSICAL FONTS                       *****/
+  /*****                                                             *****/
+  /***********************************************************************/
+  /***********************************************************************/
+
+
+  /* load bitmap strikes lists */
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_extra_item_load_bitmap_info( FT_Byte*     p,
+                                   FT_Byte*     limit,
+                                   PFR_PhyFont  phy_font )
+  {
+    FT_Memory   memory = phy_font->memory;
+    PFR_Strike  strike;
+    FT_UInt     flags0;
+    FT_UInt     n, count, size1;
+    FT_Error    error = 0;
+
+
+    PFR_CHECK( 5 );
+
+    p += 3;  /* skip bctSize */
+    flags0 = PFR_NEXT_BYTE( p );
+    count  = PFR_NEXT_BYTE( p );
+
+    /* re-allocate when needed */
+    if ( phy_font->num_strikes + count > phy_font->max_strikes )
+    {
+      FT_UInt  new_max = FT_PAD_CEIL( phy_font->num_strikes + count, 4 );
+
+
+      if ( FT_RENEW_ARRAY( phy_font->strikes,
+                           phy_font->num_strikes,
+                           new_max ) )
+        goto Exit;
+
+      phy_font->max_strikes = new_max;
+    }
+
+    size1 = 1 + 1 + 1 + 2 + 2 + 1;
+    if ( flags0 & PFR_STRIKE_2BYTE_XPPM )
+      size1++;
+
+    if ( flags0 & PFR_STRIKE_2BYTE_YPPM )
+      size1++;
+
+    if ( flags0 & PFR_STRIKE_3BYTE_SIZE )
+      size1++;
+
+    if ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
+      size1++;
+
+    if ( flags0 & PFR_STRIKE_2BYTE_COUNT )
+      size1++;
+
+    strike = phy_font->strikes + phy_font->num_strikes;
+
+    PFR_CHECK( count * size1 );
+
+    for ( n = 0; n < count; n++, strike++ )
+    {
+      strike->x_ppm       = ( flags0 & PFR_STRIKE_2BYTE_XPPM )
+                            ? PFR_NEXT_USHORT( p )
+                            : PFR_NEXT_BYTE( p );
+
+      strike->y_ppm       = ( flags0 & PFR_STRIKE_2BYTE_YPPM )
+                            ? PFR_NEXT_USHORT( p )
+                            : PFR_NEXT_BYTE( p );
+
+      strike->flags       = PFR_NEXT_BYTE( p );
+
+      strike->bct_size    = ( flags0 & PFR_STRIKE_3BYTE_SIZE )
+                            ? PFR_NEXT_ULONG( p )
+                            : PFR_NEXT_USHORT( p );
+
+      strike->bct_offset  = ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
+                            ? PFR_NEXT_ULONG( p )
+                            : PFR_NEXT_USHORT( p );
+
+      strike->num_bitmaps = ( flags0 & PFR_STRIKE_2BYTE_COUNT )
+                            ? PFR_NEXT_USHORT( p )
+                            : PFR_NEXT_BYTE( p );
+    }
+
+    phy_font->num_strikes += count;
+
+  Exit:
+    return error;
+
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_extra_item_load_bitmap_info: invalid bitmap info table\n" ));
+    goto Exit;
+  }
+
+
+  /* Load font ID.  This is a so-called "unique" name that is rather
+   * long and descriptive (like "Tiresias ScreenFont v7.51").
+   *
+   * Note that a PFR font's family name is contained in an *undocumented*
+   * string of the "auxiliary data" portion of a physical font record.  This
+   * may also contain the "real" style name!
+   *
+   * If no family name is present, the font ID is used instead for the
+   * family.
+   */
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_extra_item_load_font_id( FT_Byte*     p,
+                               FT_Byte*     limit,
+                               PFR_PhyFont  phy_font )
+  {
+    FT_Error    error  = 0;
+    FT_Memory   memory = phy_font->memory;
+    FT_PtrDist  len    = limit - p;
+
+
+    if ( phy_font->font_id != NULL )
+      goto Exit;
+
+    if ( FT_ALLOC( phy_font->font_id, len + 1 ) )
+      goto Exit;
+
+    /* copy font ID name, and terminate it for safety */
+    FT_MEM_COPY( phy_font->font_id, p, len );
+    phy_font->font_id[len] = 0;
+
+  Exit:
+    return error;
+  }
+
+
+  /* load stem snap tables */
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_extra_item_load_stem_snaps( FT_Byte*     p,
+                                  FT_Byte*     limit,
+                                  PFR_PhyFont  phy_font )
+  {
+    FT_UInt    count, num_vert, num_horz;
+    FT_Int*    snaps;
+    FT_Error   error  = 0;
+    FT_Memory  memory = phy_font->memory;
+
+
+    if ( phy_font->vertical.stem_snaps != NULL )
+      goto Exit;
+
+    PFR_CHECK( 1 );
+    count = PFR_NEXT_BYTE( p );
+
+    num_vert = count & 15;
+    num_horz = count >> 4;
+    count    = num_vert + num_horz;
+
+    PFR_CHECK( count * 2 );
+
+    if ( FT_NEW_ARRAY( snaps, count ) )
+      goto Exit;
+
+    phy_font->vertical.stem_snaps = snaps;
+    phy_font->horizontal.stem_snaps = snaps + num_vert;
+
+    for ( ; count > 0; count--, snaps++ )
+      *snaps = FT_NEXT_SHORT( p );
+
+  Exit:
+    return error;
+
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_exta_item_load_stem_snaps: invalid stem snaps table\n" ));
+    goto Exit;
+  }
+
+
+
+  /* load kerning pair data */
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_extra_item_load_kerning_pairs( FT_Byte*     p,
+                                     FT_Byte*     limit,
+                                     PFR_PhyFont  phy_font )
+  {
+    PFR_KernItem  item;
+    FT_Error      error  = 0;
+    FT_Memory     memory = phy_font->memory;
+
+
+    FT_TRACE2(( "pfr_extra_item_load_kerning_pairs()\n" ));
+
+    if ( FT_NEW( item ) )
+      goto Exit;
+
+    PFR_CHECK( 4 );
+
+    item->pair_count = PFR_NEXT_BYTE( p );
+    item->base_adj   = PFR_NEXT_SHORT( p );
+    item->flags      = PFR_NEXT_BYTE( p );
+    item->offset     = phy_font->offset + ( p - phy_font->cursor );
+
+#ifndef PFR_CONFIG_NO_CHECKS
+    item->pair_size = 3;
+
+    if ( item->flags & PFR_KERN_2BYTE_CHAR )
+      item->pair_size += 2;
+
+    if ( item->flags & PFR_KERN_2BYTE_ADJ )
+      item->pair_size += 1;
+
+    PFR_CHECK( item->pair_count * item->pair_size );
+#endif
+
+    /* load first and last pairs into the item to speed up */
+    /* lookup later...                                     */
+    if ( item->pair_count > 0 )
+    {
+      FT_UInt   char1, char2;
+      FT_Byte*  q;
+
+
+      if ( item->flags & PFR_KERN_2BYTE_CHAR )
+      {
+        q     = p;
+        char1 = PFR_NEXT_USHORT( q );
+        char2 = PFR_NEXT_USHORT( q );
+
+        item->pair1 = PFR_KERN_INDEX( char1, char2 );
+
+        q = p + item->pair_size * ( item->pair_count - 1 );
+        char1 = PFR_NEXT_USHORT( q );
+        char2 = PFR_NEXT_USHORT( q );
+
+        item->pair2 = PFR_KERN_INDEX( char1, char2 );
+      }
+      else
+      {
+        q     = p;
+        char1 = PFR_NEXT_BYTE( q );
+        char2 = PFR_NEXT_BYTE( q );
+
+        item->pair1 = PFR_KERN_INDEX( char1, char2 );
+
+        q = p + item->pair_size * ( item->pair_count - 1 );
+        char1 = PFR_NEXT_BYTE( q );
+        char2 = PFR_NEXT_BYTE( q );
+
+        item->pair2 = PFR_KERN_INDEX( char1, char2 );
+      }
+
+      /* add new item to the current list */
+      item->next                 = NULL;
+      *phy_font->kern_items_tail = item;
+      phy_font->kern_items_tail  = &item->next;
+      phy_font->num_kern_pairs  += item->pair_count;
+    }
+    else
+    {
+      /* empty item! */
+      FT_FREE( item );
+    }
+
+  Exit:
+    return error;
+
+  Too_Short:
+    FT_FREE( item );
+
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_extra_item_load_kerning_pairs: "
+               "invalid kerning pairs table\n" ));
+    goto Exit;
+  }
+
+
+ /*
+  *  The kerning data embedded in a PFR font are (charcode,charcode)
+  *  pairs; we need to translate them to (gindex,gindex) and sort
+  *  the resulting array.
+  */
+  static FT_UInt
+  pfr_get_gindex( PFR_Char  chars,
+                  FT_UInt   count,
+                  FT_UInt   charcode )
+  {
+    FT_UInt  min = 0;
+    FT_UInt  max = count;
+
+
+    while ( min < max )
+    {
+      FT_UInt   mid = ( min + max ) >> 1;
+      PFR_Char  c   = chars + mid;
+
+
+      if ( c->char_code == charcode )
+        return mid + 1;
+
+      if ( c->char_code < charcode )
+        min = mid + 1;
+      else
+        max = mid;
+    }
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( int )
+  pfr_compare_kern_pairs( const void*  pair1,
+                          const void*  pair2 )
+  {
+    FT_UInt32  p1 = PFR_KERN_PAIR_INDEX( (PFR_KernPair)pair1 );
+    FT_UInt32  p2 = PFR_KERN_PAIR_INDEX( (PFR_KernPair)pair2 );
+
+
+    if ( p1 < p2 )
+      return -1;
+    if ( p1 > p2 )
+      return 1;
+    return 0;
+  }
+
+
+  static FT_Error
+  pfr_sort_kerning_pairs( FT_Stream    stream,
+                          PFR_PhyFont  phy_font )
+  {
+    FT_Error      error;
+    FT_Memory     memory = stream->memory;
+    PFR_KernPair  pairs;
+    PFR_KernItem  item;
+    PFR_Char      chars     = phy_font->chars;
+    FT_UInt       num_chars = phy_font->num_chars;
+    FT_UInt       count;
+
+
+   /* create kerning pairs array
+    */
+    if ( FT_NEW_ARRAY( phy_font->kern_pairs, phy_font->num_kern_pairs ) )
+      goto Exit;
+
+   /* load all kerning items into the array,
+    * converting character codes into glyph indices
+    */
+    pairs = phy_font->kern_pairs;
+    item  = phy_font->kern_items;
+    count = 0;
+
+    for ( ; item; item = item->next )
+    {
+      FT_UInt   limit = count + item->pair_count;
+      FT_Byte*  p;
+
+
+      if ( limit > phy_font->num_kern_pairs )
+      {
+        error = PFR_Err_Invalid_Table;
+        goto Exit;
+      }
+
+      if ( FT_STREAM_SEEK( item->offset )                       ||
+           FT_FRAME_ENTER( item->pair_count * item->pair_size ) )
+        goto Exit;
+
+      p = stream->cursor;
+
+      for ( ; count < limit; count++ )
+      {
+        PFR_KernPair  pair = pairs + count;
+        FT_UInt       char1, char2;
+        FT_Int        kerning;
+
+
+        if ( item->flags & PFR_KERN_2BYTE_CHAR )
+        {
+          char1 = FT_NEXT_USHORT( p );
+          char2 = FT_NEXT_USHORT( p );
+        }
+        else
+        {
+          char1 = FT_NEXT_BYTE( p );
+          char2 = FT_NEXT_BYTE( p );
+        }
+
+        if ( item->flags & PFR_KERN_2BYTE_ADJ )
+          kerning = item->base_adj + FT_NEXT_SHORT( p );
+        else
+          kerning = item->base_adj + FT_NEXT_CHAR( p );
+
+        pair->glyph1  = pfr_get_gindex( chars, num_chars, char1 );
+        pair->glyph2  = pfr_get_gindex( chars, num_chars, char2 );
+        pair->kerning = kerning;
+      }
+
+      FT_FRAME_EXIT();
+    }
+
+   /* sort the resulting array
+    */
+    ft_qsort( pairs, count,
+              sizeof ( PFR_KernPairRec ),
+              pfr_compare_kern_pairs );
+
+  Exit:
+    if ( error )
+    {
+     /* disable kerning data in case of error
+      */
+      phy_font->num_kern_pairs = 0;
+    }
+
+    return error;
+  }
+
+
+  static const PFR_ExtraItemRec  pfr_phy_font_extra_items[] =
+  {
+    { 1, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_bitmap_info },
+    { 2, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_font_id },
+    { 3, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_stem_snaps },
+    { 4, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_kerning_pairs },
+    { 0, NULL }
+  };
+
+
+  /* Loads a name from the auxiliary data.  Since this extracts undocumented
+   * strings from the font file, we need to be careful here.
+   */
+  static FT_Error
+  pfr_aux_name_load( FT_Byte*     p,
+                     FT_UInt      len,
+                     FT_Memory    memory,
+                     FT_String*  *astring )
+  {
+    FT_Error    error = 0;
+    FT_String*  result = NULL;
+    FT_UInt     n, ok;
+
+
+    if ( len > 0 && p[len - 1] == 0 )
+      len--;
+
+    /* check that each character is ASCII for making sure not to
+       load garbage
+     */
+    ok = ( len > 0 );
+    for ( n = 0; n < len; n++ )
+      if ( p[n] < 32 || p[n] > 127 )
+      {
+        ok = 0;
+        break;
+      }
+
+    if ( ok )
+    {
+      if ( FT_ALLOC( result, len + 1 ) )
+        goto Exit;
+
+      FT_MEM_COPY( result, p, len );
+      result[len] = 0;
+    }
+  Exit:
+    *astring = result;
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  pfr_phy_font_done( PFR_PhyFont  phy_font,
+                     FT_Memory    memory )
+  {
+    FT_FREE( phy_font->font_id );
+    FT_FREE( phy_font->family_name );
+    FT_FREE( phy_font->style_name );
+
+    FT_FREE( phy_font->vertical.stem_snaps );
+    phy_font->vertical.num_stem_snaps = 0;
+
+    phy_font->horizontal.stem_snaps     = NULL;
+    phy_font->horizontal.num_stem_snaps = 0;
+
+    FT_FREE( phy_font->strikes );
+    phy_font->num_strikes = 0;
+    phy_font->max_strikes = 0;
+
+    FT_FREE( phy_font->chars );
+    phy_font->num_chars    = 0;
+    phy_font->chars_offset = 0;
+
+    FT_FREE( phy_font->blue_values );
+    phy_font->num_blue_values = 0;
+
+    FT_FREE( phy_font->kern_pairs );
+    {
+      PFR_KernItem  item, next;
+
+
+      item = phy_font->kern_items;
+      while ( item )
+      {
+        next = item->next;
+        FT_FREE( item );
+        item = next;
+      }
+      phy_font->kern_items      = NULL;
+      phy_font->kern_items_tail = NULL;
+    }
+
+    phy_font->num_kern_pairs = 0;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_phy_font_load( PFR_PhyFont  phy_font,
+                     FT_Stream    stream,
+                     FT_UInt32    offset,
+                     FT_UInt32    size )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+    FT_UInt    flags, num_aux;
+    FT_Byte*   p;
+    FT_Byte*   limit;
+
+
+    phy_font->memory = memory;
+    phy_font->offset = offset;
+
+    phy_font->kern_items      = NULL;
+    phy_font->kern_items_tail = &phy_font->kern_items;
+
+    if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) )
+      goto Exit;
+
+    phy_font->cursor = stream->cursor;
+
+    p     = stream->cursor;
+    limit = p + size;
+
+    PFR_CHECK( 15 );
+    phy_font->font_ref_number    = PFR_NEXT_USHORT( p );
+    phy_font->outline_resolution = PFR_NEXT_USHORT( p );
+    phy_font->metrics_resolution = PFR_NEXT_USHORT( p );
+    phy_font->bbox.xMin          = PFR_NEXT_SHORT( p );
+    phy_font->bbox.yMin          = PFR_NEXT_SHORT( p );
+    phy_font->bbox.xMax          = PFR_NEXT_SHORT( p );
+    phy_font->bbox.yMax          = PFR_NEXT_SHORT( p );
+    phy_font->flags      = flags = PFR_NEXT_BYTE( p );
+
+    /* get the standard advance for non-proprotional fonts */
+    if ( !(flags & PFR_PHY_PROPORTIONAL) )
+    {
+      PFR_CHECK( 2 );
+      phy_font->standard_advance = PFR_NEXT_SHORT( p );
+    }
+
+    /* load the extra items when present */
+    if ( flags & PFR_PHY_EXTRA_ITEMS )
+    {
+      error =  pfr_extra_items_parse( &p, limit,
+                                      pfr_phy_font_extra_items, phy_font );
+
+      if ( error )
+        goto Fail;
+    }
+
+    /* In certain fonts, the auxiliary bytes contain interesting  */
+    /* information. These are not in the specification but can be */
+    /* guessed by looking at the content of a few PFR0 fonts.     */
+    PFR_CHECK( 3 );
+    num_aux = PFR_NEXT_ULONG( p );
+
+    if ( num_aux > 0 )
+    {
+      FT_Byte*  q = p;
+      FT_Byte*  q2;
+
+
+      PFR_CHECK( num_aux );
+      p += num_aux;
+
+      while ( num_aux > 0 )
+      {
+        FT_UInt  length, type;
+
+
+        if ( q + 4 > p )
+          break;
+
+        length = PFR_NEXT_USHORT( q );
+        if ( length < 4 || length > num_aux )
+          break;
+
+        q2   = q + length - 2;
+        type = PFR_NEXT_USHORT( q );
+
+        switch ( type )
+        {
+        case 1:
+          /* this seems to correspond to the font's family name,
+           * padded to 16-bits with one zero when necessary
+           */
+          error = pfr_aux_name_load( q, length - 4U, memory,
+                                     &phy_font->family_name );
+          if ( error )
+            goto Exit;
+          break;
+
+        case 2:
+          if ( q + 32 > q2 )
+            break;
+
+          q += 10;
+          phy_font->ascent  = PFR_NEXT_SHORT( q );
+          phy_font->descent = PFR_NEXT_SHORT( q );
+          phy_font->leading = PFR_NEXT_SHORT( q );
+          q += 16;
+          break;
+
+        case 3:
+          /* this seems to correspond to the font's style name,
+           * padded to 16-bits with one zero when necessary
+           */
+          error = pfr_aux_name_load( q, length - 4U, memory,
+                                     &phy_font->style_name );
+          if ( error )
+            goto Exit;
+          break;
+
+        default:
+          ;
+        }
+
+        q        = q2;
+        num_aux -= length;
+      }
+    }
+
+    /* read the blue values */
+    {
+      FT_UInt  n, count;
+
+
+      PFR_CHECK( 1 );
+      phy_font->num_blue_values = count = PFR_NEXT_BYTE( p );
+
+      PFR_CHECK( count * 2 );
+
+      if ( FT_NEW_ARRAY( phy_font->blue_values, count ) )
+        goto Fail;
+
+      for ( n = 0; n < count; n++ )
+        phy_font->blue_values[n] = PFR_NEXT_SHORT( p );
+    }
+
+    PFR_CHECK( 8 );
+    phy_font->blue_fuzz  = PFR_NEXT_BYTE( p );
+    phy_font->blue_scale = PFR_NEXT_BYTE( p );
+
+    phy_font->vertical.standard   = PFR_NEXT_USHORT( p );
+    phy_font->horizontal.standard = PFR_NEXT_USHORT( p );
+
+    /* read the character descriptors */
+    {
+      FT_UInt  n, count, Size;
+
+
+      phy_font->num_chars    = count = PFR_NEXT_USHORT( p );
+      phy_font->chars_offset = offset + ( p - stream->cursor );
+
+      if ( FT_NEW_ARRAY( phy_font->chars, count ) )
+        goto Fail;
+
+      Size = 1 + 1 + 2;
+      if ( flags & PFR_PHY_2BYTE_CHARCODE )
+        Size += 1;
+
+      if ( flags & PFR_PHY_PROPORTIONAL )
+        Size += 2;
+
+      if ( flags & PFR_PHY_ASCII_CODE )
+        Size += 1;
+
+      if ( flags & PFR_PHY_2BYTE_GPS_SIZE )
+        Size += 1;
+
+      if ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
+        Size += 1;
+
+      PFR_CHECK( count * Size );
+
+      for ( n = 0; n < count; n++ )
+      {
+        PFR_Char  cur = &phy_font->chars[n];
+
+
+        cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE )
+                         ? PFR_NEXT_USHORT( p )
+                         : PFR_NEXT_BYTE( p );
+
+        cur->advance   = ( flags & PFR_PHY_PROPORTIONAL )
+                         ? PFR_NEXT_SHORT( p )
+                         : (FT_Int) phy_font->standard_advance;
+
+#if 0
+        cur->ascii     = ( flags & PFR_PHY_ASCII_CODE )
+                         ? PFR_NEXT_BYTE( p )
+                         : 0;
+#else
+        if ( flags & PFR_PHY_ASCII_CODE )
+          p += 1;
+#endif
+        cur->gps_size  = ( flags & PFR_PHY_2BYTE_GPS_SIZE )
+                         ? PFR_NEXT_USHORT( p )
+                         : PFR_NEXT_BYTE( p );
+
+        cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
+                          ? PFR_NEXT_ULONG( p )
+                          : PFR_NEXT_USHORT( p );
+      }
+    }
+
+    /* that's it! */
+
+  Fail:
+    FT_FRAME_EXIT();
+
+    /* save position of bitmap info */
+    phy_font->bct_offset = FT_STREAM_POS();
+    phy_font->cursor     = NULL;
+
+    /* now sort kerning pairs */
+    error = pfr_sort_kerning_pairs( stream, phy_font );
+
+  Exit:
+    return error;
+
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_phy_font_load: invalid physical font table\n" ));
+    goto Fail;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrload.h b/nx-X11/extras/freetype2/src/pfr/pfrload.h
new file mode 100644
index 000000000..9e54b7d3f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrload.h
@@ -0,0 +1,118 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrload.h                                                              */
+/*                                                                         */
+/*    FreeType PFR loader (specification).                                 */
+/*                                                                         */
+/*  Copyright 2002 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 __PFRLOAD_H__
+#define __PFRLOAD_H__
+
+#include "pfrobjs.h"
+#include FT_INTERNAL_STREAM_H
+
+
+FT_BEGIN_HEADER
+
+#ifdef PFR_CONFIG_NO_CHECKS
+#define PFR_CHECK( x )  do { } while ( 0 )
+#else
+#define PFR_CHECK( x )  do                       \
+                        {                        \
+                          if ( p + (x) > limit ) \
+                            goto Too_Short;      \
+                        } while ( 0 )
+#endif
+
+#define PFR_NEXT_BYTE( p )    FT_NEXT_BYTE( p )
+#define PFR_NEXT_INT8( p )    FT_NEXT_CHAR( p )
+#define PFR_NEXT_SHORT( p )   FT_NEXT_SHORT( p )
+#define PFR_NEXT_USHORT( p )  FT_NEXT_USHORT( p )
+#define PFR_NEXT_LONG( p )    FT_NEXT_OFF3( p )
+#define PFR_NEXT_ULONG( p )   FT_NEXT_UOFF3( p )
+
+
+ /* handling extra items */
+
+  typedef FT_Error
+  (*PFR_ExtraItem_ParseFunc)( FT_Byte*    p,
+                              FT_Byte*    limit,
+                              FT_Pointer  data );
+
+  typedef struct  PFR_ExtraItemRec_
+  {
+    FT_UInt                  type;
+    PFR_ExtraItem_ParseFunc  parser;
+  
+  } PFR_ExtraItemRec;
+  
+  typedef const struct PFR_ExtraItemRec_*  PFR_ExtraItem;
+ 
+
+  FT_LOCAL( FT_Error )
+  pfr_extra_items_skip( FT_Byte*  *pp,
+                        FT_Byte*  limit );
+
+  FT_LOCAL( FT_Error )
+  pfr_extra_items_parse( FT_Byte*      *pp,
+                         FT_Byte*       limit,
+                         PFR_ExtraItem  item_list,
+                         FT_Pointer     item_data );
+
+
+  /* load a PFR header */
+  FT_LOCAL( FT_Error )
+  pfr_header_load( PFR_Header  header,
+                   FT_Stream   stream );
+
+  /* check a PFR header */
+  FT_LOCAL( FT_Bool )
+  pfr_header_check( PFR_Header  header );
+
+
+  /* return number of logical fonts in this file */
+  FT_LOCAL( FT_Error )
+  pfr_log_font_count( FT_Stream   stream,
+                      FT_UInt32   log_section_offset,
+                      FT_UInt    *acount );
+
+  /* load a pfr logical font entry */
+  FT_LOCAL( FT_Error )
+  pfr_log_font_load( PFR_LogFont  log_font,
+                     FT_Stream    stream,
+                     FT_UInt      face_index,
+                     FT_UInt32    section_offset,
+                     FT_Bool      size_increment );
+
+
+  /* load a physical font entry */
+  FT_LOCAL( FT_Error )
+  pfr_phy_font_load( PFR_PhyFont  phy_font,
+                     FT_Stream    stream,
+                     FT_UInt32    offset,
+                     FT_UInt32    size );
+
+  /* finalize a physical font */
+  FT_LOCAL( void )
+  pfr_phy_font_done( PFR_PhyFont  phy_font,
+                     FT_Memory    memory );
+
+  /* */
+ 
+FT_END_HEADER
+
+#endif /* __PFRLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrobjs.c b/nx-X11/extras/freetype2/src/pfr/pfrobjs.c
new file mode 100644
index 000000000..8b318e958
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrobjs.c
@@ -0,0 +1,465 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrobjs.c                                                              */
+/*                                                                         */
+/*    FreeType PFR object methods (body).                                  */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 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 "pfrobjs.h"
+#include "pfrload.h"
+#include "pfrgload.h"
+#include "pfrcmap.h"
+#include "pfrsbit.h"
+#include FT_OUTLINE_H
+#include FT_INTERNAL_DEBUG_H
+
+#include "pfrerror.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pfr
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                     FACE OBJECT METHODS                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( void )
+  pfr_face_done( FT_Face  pfrface )     /* PFR_Face */
+  {
+    PFR_Face   face   = (PFR_Face)pfrface;
+    FT_Memory  memory = pfrface->driver->root.memory;
+
+
+    /* we don't want dangling pointers */
+    pfrface->family_name = NULL;
+    pfrface->style_name  = NULL;
+    
+    /* finalize the physical font record */
+    pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY( face ) );
+
+    /* no need to finalize the logical font or the header */
+    FT_FREE( pfrface->available_sizes );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_face_init( FT_Stream      stream,
+                 FT_Face        pfrface,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    PFR_Face  face = (PFR_Face)pfrface;
+    FT_Error  error;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+
+
+    /* load the header and check it */
+    error = pfr_header_load( &face->header, stream );
+    if ( error )
+      goto Exit;
+
+    if ( !pfr_header_check( &face->header ) )
+    {
+      FT_TRACE4(( "pfr_face_init: not a valid PFR font\n" ));
+      error = PFR_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* check face index */
+    {
+      FT_UInt  num_faces;
+
+
+      error = pfr_log_font_count( stream,
+                                  face->header.log_dir_offset,
+                                  &num_faces );
+      if ( error )
+        goto Exit;
+
+      pfrface->num_faces = num_faces;
+    }
+
+    if ( face_index < 0 )
+      goto Exit;
+
+    if ( face_index >= pfrface->num_faces )
+    {
+      FT_ERROR(( "pfr_face_init: invalid face index\n" ));
+      error = PFR_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* load the face */
+    error = pfr_log_font_load(
+               &face->log_font, stream, face_index,
+               face->header.log_dir_offset,
+               FT_BOOL( face->header.phy_font_max_size_high != 0 ) );
+    if ( error )
+      goto Exit;
+
+    /* now load the physical font descriptor */
+    error = pfr_phy_font_load( &face->phy_font, stream,
+                               face->log_font.phys_offset,
+                               face->log_font.phys_size );
+    if ( error )
+      goto Exit;
+
+    /* now, set-up all root face fields */
+    {
+      PFR_PhyFont  phy_font = &face->phy_font;
+
+
+      pfrface->face_index = face_index;
+      pfrface->num_glyphs = phy_font->num_chars;
+      pfrface->face_flags = FT_FACE_FLAG_SCALABLE;
+
+      if ( (phy_font->flags & PFR_PHY_PROPORTIONAL) == 0 )
+        pfrface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      if ( phy_font->flags & PFR_PHY_VERTICAL )
+        pfrface->face_flags |= FT_FACE_FLAG_VERTICAL;
+      else
+        pfrface->face_flags |= FT_FACE_FLAG_HORIZONTAL;
+
+      if ( phy_font->num_strikes > 0 )
+        pfrface->face_flags |= FT_FACE_FLAG_FIXED_SIZES;
+
+      if ( phy_font->num_kern_pairs > 0 )
+        pfrface->face_flags |= FT_FACE_FLAG_KERNING;
+
+      /* If no family name was found in the "undocumented" auxiliary
+       * data, use the font ID instead.  This sucks but is better than
+       * nothing.
+       */
+      pfrface->family_name = phy_font->family_name;
+      if ( pfrface->family_name == NULL )
+        pfrface->family_name = phy_font->font_id;
+
+      /* note that the style name can be NULL in certain PFR fonts,
+       * probably meaning "Regular"
+       */
+      pfrface->style_name = phy_font->style_name;
+
+      pfrface->num_fixed_sizes = 0;
+      pfrface->available_sizes = 0;
+
+      pfrface->bbox         = phy_font->bbox;
+      pfrface->units_per_EM = (FT_UShort)phy_font->outline_resolution;
+      pfrface->ascender     = (FT_Short) phy_font->bbox.yMax;
+      pfrface->descender    = (FT_Short) phy_font->bbox.yMin;
+      pfrface->height       = (FT_Short)(
+        ( ( pfrface->ascender - pfrface->descender ) * 12 ) / 10 );
+
+      if ( phy_font->num_strikes > 0 )
+      {
+        FT_UInt          n, count = phy_font->num_strikes;
+        FT_Bitmap_Size*  size;
+        PFR_Strike       strike;
+        FT_Memory        memory = pfrface->stream->memory;
+         
+         
+        if ( FT_NEW_ARRAY( pfrface->available_sizes, count ) )
+          goto Exit;
+         
+        size   = pfrface->available_sizes;
+        strike = phy_font->strikes;
+        for ( n = 0; n < count; n++, size++, strike++ )
+        {
+          size->height = (FT_UShort)strike->y_ppm;
+          size->width  = (FT_UShort)strike->x_ppm;
+        }
+        pfrface->num_fixed_sizes = count;
+      }
+
+      /* now compute maximum advance width */
+      if ( ( phy_font->flags & PFR_PHY_PROPORTIONAL ) == 0 )
+        pfrface->max_advance_width = (FT_Short)phy_font->standard_advance;
+      else
+      {
+        FT_Int    max = 0;
+        FT_UInt   count = phy_font->num_chars;
+        PFR_Char  gchar = phy_font->chars;
+
+
+        for ( ; count > 0; count--, gchar++ )
+        {
+          if ( max < gchar->advance )
+            max = gchar->advance;
+        }
+
+        pfrface->max_advance_width = (FT_Short)max;
+      }
+
+      pfrface->max_advance_height = pfrface->height;
+
+      pfrface->underline_position  = (FT_Short)( -pfrface->units_per_EM / 10 );
+      pfrface->underline_thickness = (FT_Short)(  pfrface->units_per_EM / 30 );
+
+      /* create charmap */
+      {
+        FT_CharMapRec  charmap;
+
+
+        charmap.face        = pfrface;
+        charmap.platform_id = 3;
+        charmap.encoding_id = 1;
+        charmap.encoding    = FT_ENCODING_UNICODE;
+
+        FT_CMap_New( &pfr_cmap_class_rec, NULL, &charmap, NULL );
+
+#if 0
+        /* Select default charmap */
+        if ( pfrface->num_charmaps )
+          pfrface->charmap = pfrface->charmaps[0];
+#endif
+      }
+
+      /* check whether we've loaded any kerning pairs */
+      if ( phy_font->num_kern_pairs )
+        pfrface->face_flags |= FT_FACE_FLAG_KERNING;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    SLOT OBJECT METHOD                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_slot_init( FT_GlyphSlot  pfrslot )        /* PFR_Slot */
+  {
+    PFR_Slot        slot   = (PFR_Slot)pfrslot;
+    FT_GlyphLoader  loader = pfrslot->internal->loader;
+
+
+    pfr_glyph_init( &slot->glyph, loader );
+
+    return 0;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  pfr_slot_done( FT_GlyphSlot  pfrslot )        /* PFR_Slot */
+  {
+    PFR_Slot  slot = (PFR_Slot)pfrslot;
+
+
+    pfr_glyph_done( &slot->glyph );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_slot_load( FT_GlyphSlot  pfrslot,         /* PFR_Slot */
+                 FT_Size       pfrsize,         /* PFR_Size */
+                 FT_UInt       gindex,
+                 FT_Int32      load_flags )
+  {
+    PFR_Slot     slot    = (PFR_Slot)pfrslot;
+    PFR_Size     size    = (PFR_Size)pfrsize;
+    FT_Error     error;
+    PFR_Face     face    = (PFR_Face)pfrslot->face;
+    PFR_Char     gchar;
+    FT_Outline*  outline = &pfrslot->outline;
+    FT_ULong     gps_offset;
+
+
+    if ( gindex > 0 )
+      gindex--;
+
+    /* check that the glyph index is correct */
+    FT_ASSERT( gindex < face->phy_font.num_chars );
+
+    /* try to load an embedded bitmap */
+    if ( ( load_flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP ) ) == 0 )
+    {
+      error = pfr_slot_load_bitmap( slot, size, gindex );
+      if ( error == 0 )
+        goto Exit;
+    }
+
+    if ( load_flags & FT_LOAD_SBITS_ONLY )
+    {
+      error = PFR_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    gchar               = face->phy_font.chars + gindex;
+    pfrslot->format     = FT_GLYPH_FORMAT_OUTLINE;
+    outline->n_points   = 0;
+    outline->n_contours = 0;
+    gps_offset          = face->header.gps_section_offset;
+
+    /* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */
+    error = pfr_glyph_load( &slot->glyph, face->root.stream,
+                            gps_offset, gchar->gps_offset, gchar->gps_size );
+
+    if ( !error )
+    {
+      FT_BBox            cbox;
+      FT_Glyph_Metrics*  metrics = &pfrslot->metrics;
+      FT_Pos             advance;
+      FT_Int             em_metrics, em_outline;
+      FT_Bool            scaling;
+
+
+      scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
+
+      /* copy outline data */
+      *outline = slot->glyph.loader->base.outline;
+
+      outline->flags &= ~FT_OUTLINE_OWNER;
+      outline->flags |= FT_OUTLINE_REVERSE_FILL;
+
+      if ( size && pfrsize->metrics.y_ppem < 24 )
+        outline->flags |= FT_OUTLINE_HIGH_PRECISION;
+
+      /* compute the advance vector */
+      metrics->horiAdvance = 0;
+      metrics->vertAdvance = 0;
+
+      advance    = gchar->advance;
+      em_metrics = face->phy_font.metrics_resolution;
+      em_outline = face->phy_font.outline_resolution;
+
+      if ( em_metrics != em_outline )
+        advance = FT_MulDiv( advance, em_outline, em_metrics );
+
+      if ( face->phy_font.flags & PFR_PHY_VERTICAL )
+        metrics->vertAdvance = advance;
+      else
+        metrics->horiAdvance = advance;
+
+      pfrslot->linearHoriAdvance = metrics->horiAdvance;
+      pfrslot->linearVertAdvance = metrics->vertAdvance;
+
+      /* make-up vertical metrics(?) */
+      metrics->vertBearingX = 0;
+      metrics->vertBearingY = 0;
+
+      /* Apply the font matrix, if any.                 */
+      /* TODO: Test existing fonts with unusual matrix  */
+      /* whether we have to adjust Units per EM.        */
+      {
+        FT_Matrix font_matrix;
+
+
+        font_matrix.xx = face->log_font.matrix[0] << 8;
+        font_matrix.yx = face->log_font.matrix[1] << 8;
+        font_matrix.xy = face->log_font.matrix[2] << 8;
+        font_matrix.yy = face->log_font.matrix[3] << 8;
+
+        FT_Outline_Transform( outline, &font_matrix );
+      }
+
+      /* scale when needed */
+      if ( scaling )
+      {
+        FT_Int      n;
+        FT_Fixed    x_scale = pfrsize->metrics.x_scale;
+        FT_Fixed    y_scale = pfrsize->metrics.y_scale;
+        FT_Vector*  vec     = outline->points;
+
+
+        /* scale outline points */
+        for ( n = 0; n < outline->n_points; n++, vec++ )
+        {
+          vec->x = FT_MulFix( vec->x, x_scale );
+          vec->y = FT_MulFix( vec->y, y_scale );
+        }
+
+        /* scale the advance */
+        metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
+        metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
+      }
+
+      /* compute the rest of the metrics */
+      FT_Outline_Get_CBox( outline, &cbox );
+
+      metrics->width        = cbox.xMax - cbox.xMin;
+      metrics->height       = cbox.yMax - cbox.yMin;
+      metrics->horiBearingX = cbox.xMin;
+      metrics->horiBearingY = cbox.yMax - metrics->height;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      KERNING METHOD                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_face_get_kerning( FT_Face     pfrface,        /* PFR_Face */
+                        FT_UInt     glyph1,
+                        FT_UInt     glyph2,
+                        FT_Vector*  kerning )
+  {
+    PFR_Face      face     = (PFR_Face)pfrface;
+    FT_Error      error    = PFR_Err_Ok;
+    PFR_PhyFont   phy_font = &face->phy_font;
+    PFR_KernPair  pairs    = phy_font->kern_pairs;
+    FT_UInt32     idx      = PFR_KERN_INDEX( glyph1, glyph2 );
+    FT_UInt       min, max;
+
+
+    kerning->x = 0;
+    kerning->y = 0;
+
+    min = 0;
+    max = phy_font->num_kern_pairs;
+    
+    while ( min < max )
+    {
+      FT_UInt       mid  = ( min + max ) >> 1;
+      PFR_KernPair  pair = pairs + mid;
+      FT_UInt32     pidx = PFR_KERN_PAIR_INDEX( pair );
+      
+
+      if ( pidx == idx )
+      {
+        kerning->x = pair->kerning;
+        break;
+      }
+      
+      if ( pidx < idx )
+        min = mid + 1;
+      else
+        max = mid;
+    }
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrobjs.h b/nx-X11/extras/freetype2/src/pfr/pfrobjs.h
new file mode 100644
index 000000000..f6aa8b44c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrobjs.h
@@ -0,0 +1,96 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrobjs.h                                                              */
+/*                                                                         */
+/*    FreeType PFR object methods (specification).                         */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 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 __PFROBJS_H__
+#define __PFROBJS_H__
+
+#include "pfrtypes.h"
+
+
+FT_BEGIN_HEADER
+
+  typedef struct PFR_FaceRec_*  PFR_Face;
+
+  typedef struct PFR_SizeRec_*  PFR_Size;
+
+  typedef struct PFR_SlotRec_*  PFR_Slot;
+
+
+  typedef struct  PFR_FaceRec_
+  {
+    FT_FaceRec      root;
+    PFR_HeaderRec   header;
+    PFR_LogFontRec  log_font;
+    PFR_PhyFontRec  phy_font;
+
+  } PFR_FaceRec;
+
+
+  typedef struct  PFR_SizeRec_
+  {
+    FT_SizeRec  root;
+
+  } PFR_SizeRec;
+
+
+  typedef struct  PFR_SlotRec_
+  {
+    FT_GlyphSlotRec  root;
+    PFR_GlyphRec     glyph;
+
+  } PFR_SlotRec;
+
+
+  FT_LOCAL( FT_Error )
+  pfr_face_init( FT_Stream      stream,
+                 FT_Face        face,           /* PFR_Face */
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params );
+
+  FT_LOCAL( void )
+  pfr_face_done( FT_Face  face );               /* PFR_Face */
+
+
+  FT_LOCAL( FT_Error )
+  pfr_face_get_kerning( FT_Face     face,       /* PFR_Face */
+                        FT_UInt     glyph1,
+                        FT_UInt     glyph2,
+                        FT_Vector*  kerning );
+
+
+  FT_LOCAL( FT_Error )
+  pfr_slot_init( FT_GlyphSlot  slot );          /* PFR_Slot */
+
+  FT_LOCAL( void )
+  pfr_slot_done( FT_GlyphSlot  slot );          /* PFR_Slot */
+
+
+  FT_LOCAL( FT_Error )
+  pfr_slot_load( FT_GlyphSlot  slot,            /* PFR_Slot */
+                 FT_Size       size,            /* PFR_Size */
+                 FT_UInt       gindex,
+                 FT_Int32      load_flags );
+
+
+FT_END_HEADER
+
+#endif /* __PFROBJS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrsbit.c b/nx-X11/extras/freetype2/src/pfr/pfrsbit.c
new file mode 100644
index 000000000..da8fdba33
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrsbit.c
@@ -0,0 +1,671 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrsbit.c                                                              */
+/*                                                                         */
+/*    FreeType PFR bitmap loader (body).                                   */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 "pfrsbit.h"
+#include "pfrload.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+
+#include "pfrerror.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pfr
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      PFR BIT WRITER                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct  PFR_BitWriter_
+  {
+    FT_Byte*  line;      /* current line start                    */
+    FT_Int    pitch;     /* line size in bytes                    */
+    FT_Int    width;     /* width in pixels/bits                  */
+    FT_Int    rows;      /* number of remaining rows to scan      */
+    FT_Int    total;     /* total number of bits to draw          */
+
+  } PFR_BitWriterRec, *PFR_BitWriter;
+
+
+  static void
+  pfr_bitwriter_init( PFR_BitWriter  writer,
+                      FT_Bitmap*     target,
+                      FT_Bool        decreasing )
+  {
+    writer->line   = target->buffer;
+    writer->pitch  = target->pitch;
+    writer->width  = target->width;
+    writer->rows   = target->rows;
+    writer->total  = writer->width * writer->rows;
+
+    if ( !decreasing )
+    {
+      writer->line += writer->pitch * ( target->rows-1 );
+      writer->pitch = -writer->pitch;
+    }
+  }
+
+
+  static void
+  pfr_bitwriter_decode_bytes( PFR_BitWriter  writer,
+                              FT_Byte*       p,
+                              FT_Byte*       limit )
+  {
+    FT_Int    n, reload;
+    FT_Int    left = writer->width;
+    FT_Byte*  cur  = writer->line;
+    FT_UInt   mask = 0x80;
+    FT_UInt   val  = 0;
+    FT_UInt   c    = 0;
+
+
+    n = (FT_Int)( limit - p ) * 8;
+    if ( n > writer->total )
+      n = writer->total;
+
+    reload = n & 7;
+
+    for ( ; n > 0; n-- )
+    {
+      if ( ( n & 7 ) == reload )
+        val = *p++;
+
+      if ( val & 0x80 )
+        c |= mask;
+
+      val  <<= 1;
+      mask >>= 1;
+
+      if ( --left <= 0 )
+      {
+        cur[0] = (FT_Byte)c;
+        left   = writer->width;
+        mask   = 0x80;
+
+        writer->line += writer->pitch;
+        cur           = writer->line;
+        c             = 0;
+      }
+      else if ( mask == 0 )
+      {
+        cur[0] = (FT_Byte)c;
+        mask   = 0x80;
+        c      = 0;
+        cur ++;
+      }
+    }
+
+    if ( mask != 0x80 )
+      cur[0] = (FT_Byte)c;
+  }
+
+
+  static void
+  pfr_bitwriter_decode_rle1( PFR_BitWriter  writer,
+                             FT_Byte*       p,
+                             FT_Byte*       limit )
+  {
+    FT_Int    n, phase, count, counts[2], reload;
+    FT_Int    left = writer->width;
+    FT_Byte*  cur  = writer->line;
+    FT_UInt   mask = 0x80;
+    FT_UInt   c    = 0;
+
+
+    n = writer->total;
+
+    phase     = 1;
+    counts[0] = 0;
+    counts[1] = 0;
+    count     = 0;
+    reload    = 1;
+
+    for ( ; n > 0; n-- )
+    {
+      if ( reload )
+      {
+        do
+        {
+          if ( phase )
+          {
+            FT_Int  v;
+
+
+            if ( p >= limit )
+              break;
+
+            v         = *p++;
+            counts[0] = v >> 4;
+            counts[1] = v & 15;
+            phase     = 0;
+            count     = counts[0];
+          }
+          else
+          {
+            phase = 1;
+            count = counts[1];
+          }
+
+        } while ( count == 0 );
+      }
+
+      if ( phase )
+        c |= mask;
+
+      mask >>= 1;
+
+      if ( --left <= 0 )
+      {
+        cur[0] = (FT_Byte) c;
+        left   = writer->width;
+        mask   = 0x80;
+
+        writer->line += writer->pitch;
+        cur           = writer->line;
+        c             = 0;
+      }
+      else if ( mask == 0 )
+      {
+        cur[0] = (FT_Byte)c;
+        mask   = 0x80;
+        c      = 0;
+        cur ++;
+      }
+
+      reload = ( --count <= 0 );
+    }
+
+    if ( mask != 0x80 )
+      cur[0] = (FT_Byte) c;
+  }
+
+
+  static void
+  pfr_bitwriter_decode_rle2( PFR_BitWriter  writer,
+                             FT_Byte*       p,
+                             FT_Byte*       limit )
+  {
+    FT_Int    n, phase, count, reload;
+    FT_Int    left = writer->width;
+    FT_Byte*  cur  = writer->line;
+    FT_UInt   mask = 0x80;
+    FT_UInt   c    = 0;
+
+
+    n = writer->total;
+
+    phase  = 1;
+    count  = 0;
+    reload = 1;
+
+    for ( ; n > 0; n-- )
+    {
+      if ( reload )
+      {
+        do
+        {
+          if ( p >= limit )
+            break;
+
+          count = *p++;
+          phase = phase ^ 1;
+
+        } while ( count == 0 );
+      }
+
+      if ( phase )
+        c |= mask;
+
+      mask >>= 1;
+
+      if ( --left <= 0 )
+      {
+        cur[0] = (FT_Byte) c;
+        c      = 0;
+        mask   = 0x80;
+        left   = writer->width;
+
+        writer->line += writer->pitch;
+        cur           = writer->line;
+      }
+      else if ( mask == 0 )
+      {
+        cur[0] = (FT_Byte)c;
+        c      = 0;
+        mask   = 0x80;
+        cur ++;
+      }
+
+      reload = ( --count <= 0 );
+    }
+
+    if ( mask != 0x80 )
+      cur[0] = (FT_Byte) c;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  BITMAP DATA DECODING                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  pfr_lookup_bitmap_data( FT_Byte*   base,
+                          FT_Byte*   limit,
+                          FT_UInt    count,
+                          FT_UInt    flags,
+                          FT_UInt    char_code,
+                          FT_ULong*  found_offset,
+                          FT_ULong*  found_size )
+  {
+    FT_UInt   left, right, char_len;
+    FT_Bool   two = FT_BOOL( flags & 1 );
+    FT_Byte*  buff;
+
+
+    char_len = 4;
+    if ( two )       char_len += 1;
+    if ( flags & 2 ) char_len += 1;
+    if ( flags & 4 ) char_len += 1;
+
+    left  = 0;
+    right = count;
+
+    while ( left < right )
+    {
+      FT_UInt  middle, code;
+
+
+      middle = ( left + right ) >> 1;
+      buff   = base + middle * char_len;
+
+      /* check that we are not outside of the table -- */
+      /* this is possible with broken fonts...         */
+      if ( buff + char_len > limit )
+        goto Fail;
+
+      if ( two )
+        code = PFR_NEXT_USHORT( buff );
+      else
+        code = PFR_NEXT_BYTE( buff );
+
+      if ( code == char_code )
+        goto Found_It;
+
+      if ( code < char_code )
+        left = middle;
+      else
+        right = middle;
+    }
+
+  Fail:
+    /* Not found */
+    *found_size   = 0;
+    *found_offset = 0;
+    return;
+
+  Found_It:
+    if ( flags & 2 )
+      *found_size = PFR_NEXT_USHORT( buff );
+    else
+      *found_size = PFR_NEXT_BYTE( buff );
+
+    if ( flags & 4 )
+      *found_offset = PFR_NEXT_ULONG( buff );
+    else
+      *found_offset = PFR_NEXT_USHORT( buff );
+  }
+
+
+  /* load bitmap metrics.  "*padvance" must be set to the default value */
+  /* before calling this function...                                    */
+  /*                                                                    */
+  static FT_Error
+  pfr_load_bitmap_metrics( FT_Byte**  pdata,
+                           FT_Byte*   limit,
+                           FT_Long    scaled_advance,
+                           FT_Long   *axpos,
+                           FT_Long   *aypos,
+                           FT_UInt   *axsize,
+                           FT_UInt   *aysize,
+                           FT_Long   *aadvance,
+                           FT_UInt   *aformat )
+  {
+    FT_Error  error = 0;
+    FT_Byte   flags;
+    FT_Char   b;
+    FT_Byte*  p = *pdata;
+    FT_Long   xpos, ypos, advance;
+    FT_UInt   xsize, ysize;
+
+
+    PFR_CHECK( 1 );
+    flags = PFR_NEXT_BYTE( p );
+
+    xpos    = 0;
+    ypos    = 0;
+    xsize   = 0;
+    ysize   = 0;
+    advance = 0;
+
+    switch ( flags & 3 )
+    {
+    case 0:
+      PFR_CHECK( 1 );
+      b    = PFR_NEXT_INT8( p );
+      xpos = b >> 4;
+      ypos = ( (FT_Char)( b << 4 ) ) >> 4;
+      break;
+
+    case 1:
+      PFR_CHECK( 2 );
+      xpos = PFR_NEXT_INT8( p );
+      ypos = PFR_NEXT_INT8( p );
+      break;
+
+    case 2:
+      PFR_CHECK( 4 );
+      xpos = PFR_NEXT_SHORT( p );
+      ypos = PFR_NEXT_SHORT( p );
+      break;
+
+    case 3:
+      PFR_CHECK( 6 );
+      xpos = PFR_NEXT_LONG( p );
+      ypos = PFR_NEXT_LONG( p );
+      break;
+
+    default:
+      ;
+    }
+
+    flags >>= 2;
+    switch ( flags & 3 )
+    {
+    case 0:
+      /* blank image */
+      xsize = 0;
+      ysize = 0;
+      break;
+
+    case 1:
+      PFR_CHECK( 1 );
+      b     = PFR_NEXT_BYTE( p );
+      xsize = ( b >> 4 ) & 0xF;
+      ysize = b & 0xF;
+      break;
+
+    case 2:
+      PFR_CHECK( 2 );
+      xsize = PFR_NEXT_BYTE( p );
+      ysize = PFR_NEXT_BYTE( p );
+      break;
+
+    case 3:
+      PFR_CHECK( 4 );
+      xsize = PFR_NEXT_USHORT( p );
+      ysize = PFR_NEXT_USHORT( p );
+      break;
+
+    default:
+      ;
+    }
+
+    flags >>= 2;
+    switch ( flags & 3 )
+    {
+    case 0:
+      advance = scaled_advance;
+      break;
+
+    case 1:
+      PFR_CHECK( 1 );
+      advance = PFR_NEXT_INT8( p ) << 8;
+      break;
+
+    case 2:
+      PFR_CHECK( 2 );
+      advance = PFR_NEXT_SHORT( p );
+      break;
+
+    case 3:
+      PFR_CHECK( 3 );
+      advance = PFR_NEXT_LONG( p );
+      break;
+
+    default:
+      ;
+    }
+
+    *axpos    = xpos;
+    *aypos    = ypos;
+    *axsize   = xsize;
+    *aysize   = ysize;
+    *aadvance = advance;
+    *aformat  = flags >> 2;
+    *pdata    = p;
+
+  Exit:
+    return error;
+
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_load_bitmap_metrics: invalid glyph data\n" ));
+    goto Exit;
+  }
+
+
+  static FT_Error
+  pfr_load_bitmap_bits( FT_Byte*    p,
+                        FT_Byte*    limit,
+                        FT_UInt     format,
+                        FT_Bool     decreasing,
+                        FT_Bitmap*  target )
+  {
+    FT_Error          error = 0;
+    PFR_BitWriterRec  writer;
+
+
+    if ( target->rows > 0 && target->width > 0 )
+    {
+      pfr_bitwriter_init( &writer, target, decreasing );
+
+      switch ( format )
+      {
+      case 0: /* packed bits */
+        pfr_bitwriter_decode_bytes( &writer, p, limit );
+        break;
+
+      case 1: /* RLE1 */
+        pfr_bitwriter_decode_rle1( &writer, p, limit );
+        break;
+
+      case 2: /* RLE2 */
+        pfr_bitwriter_decode_rle2( &writer, p, limit );
+        break;
+
+      default:
+        FT_ERROR(( "pfr_read_bitmap_data: invalid image type\n" ));
+        error = PFR_Err_Invalid_File_Format;
+      }
+    }
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                     BITMAP LOADING                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL( FT_Error )
+  pfr_slot_load_bitmap( PFR_Slot  glyph,
+                        PFR_Size  size,
+                        FT_UInt   glyph_index )
+  {
+    FT_Error     error;
+    PFR_Face     face   = (PFR_Face) glyph->root.face;
+    FT_Stream    stream = face->root.stream;
+    PFR_PhyFont  phys   = &face->phy_font;
+    FT_ULong     gps_offset;
+    FT_ULong     gps_size;
+    PFR_Char     character;
+    PFR_Strike   strike;
+
+
+    character = &phys->chars[glyph_index];
+
+    /* Look-up a bitmap strike corresponding to the current */
+    /* character dimensions                                 */
+    {
+      FT_UInt  n;
+
+
+      strike = phys->strikes;
+      for ( n = 0; n < phys->num_strikes; n++ )
+      {
+        if ( strike->x_ppm == (FT_UInt)size->root.metrics.x_ppem &&
+             strike->y_ppm == (FT_UInt)size->root.metrics.y_ppem )
+        {
+          goto Found_Strike;
+        }
+
+        strike++;
+      }
+
+      /* couldn't find it */
+      return PFR_Err_Invalid_Argument;
+    }
+
+  Found_Strike:
+
+    /* Now lookup the glyph's position within the file */
+    {
+      FT_UInt  char_len;
+
+
+      char_len = 4;
+      if ( strike->flags & 1 ) char_len += 1;
+      if ( strike->flags & 2 ) char_len += 1;
+      if ( strike->flags & 4 ) char_len += 1;
+
+      /* Access data directly in the frame to speed lookups */
+      if ( FT_STREAM_SEEK( phys->bct_offset + strike->bct_offset ) ||
+           FT_FRAME_ENTER( char_len * strike->num_bitmaps )        )
+        goto Exit;
+
+      pfr_lookup_bitmap_data( stream->cursor,
+                              stream->limit,
+                              strike->num_bitmaps,
+                              strike->flags,
+                              character->char_code,
+                              &gps_offset,
+                              &gps_size );
+
+      FT_FRAME_EXIT();
+
+      if ( gps_size == 0 )
+      {
+        /* Could not find a bitmap program string for this glyph */
+        error = PFR_Err_Invalid_Argument;
+        goto Exit;
+      }
+    }
+
+    /* get the bitmap metrics */
+    {
+      FT_Long   xpos, ypos, advance;
+      FT_UInt   xsize, ysize, format;
+      FT_Byte*  p;
+
+
+      advance = FT_MulDiv( size->root.metrics.x_ppem << 8,
+                           character->advance,
+                           phys->metrics_resolution );
+
+      /* XXX: handle linearHoriAdvance correctly! */
+
+      if ( FT_STREAM_SEEK( face->header.gps_section_offset + gps_offset ) ||
+           FT_FRAME_ENTER( gps_size )                                     )
+        goto Exit;
+
+      p     = stream->cursor;
+      error = pfr_load_bitmap_metrics( &p, stream->limit,
+                                       advance,
+                                       &xpos, &ypos,
+                                       &xsize, &ysize,
+                                       &advance, &format );
+      if ( !error )
+      {
+        glyph->root.format = FT_GLYPH_FORMAT_BITMAP;
+
+        /* Set up glyph bitmap and metrics */
+        glyph->root.bitmap.width      = (FT_Int)xsize;
+        glyph->root.bitmap.rows       = (FT_Int)ysize;
+        glyph->root.bitmap.pitch      = (FT_Long)( xsize + 7 ) >> 3;
+        glyph->root.bitmap.pixel_mode = FT_PIXEL_MODE_MONO;
+
+        glyph->root.metrics.width        = (FT_Long)xsize << 6;
+        glyph->root.metrics.height       = (FT_Long)ysize << 6;
+        glyph->root.metrics.horiBearingX = xpos << 6;
+        glyph->root.metrics.horiBearingY = ypos << 6;
+        glyph->root.metrics.horiAdvance  = FT_PIX_ROUND( ( advance >> 2 ) );
+        glyph->root.metrics.vertBearingX = - glyph->root.metrics.width >> 1;
+        glyph->root.metrics.vertBearingY = 0;
+        glyph->root.metrics.vertAdvance  = size->root.metrics.height;
+
+        glyph->root.bitmap_left = xpos;
+        glyph->root.bitmap_top  = ypos + ysize;
+
+        /* Allocate and read bitmap data */
+        {
+          FT_ULong  len = glyph->root.bitmap.pitch * ysize;
+
+
+          error = ft_glyphslot_alloc_bitmap( &glyph->root, len );
+          if ( !error )
+          {
+            error = pfr_load_bitmap_bits(
+                      p,
+                      stream->limit,
+                      format,
+                      FT_BOOL(face->header.color_flags & 2),
+                      &glyph->root.bitmap );
+          }
+        }
+      }
+
+      FT_FRAME_EXIT();
+    }
+
+  Exit:
+    return error;
+  }
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrsbit.h b/nx-X11/extras/freetype2/src/pfr/pfrsbit.h
new file mode 100644
index 000000000..015e9e6da
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrsbit.h
@@ -0,0 +1,36 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrsbit.h                                                              */
+/*                                                                         */
+/*    FreeType PFR bitmap loader (specification).                          */
+/*                                                                         */
+/*  Copyright 2002 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 __PFRSBIT_H__
+#define __PFRSBIT_H__
+
+#include "pfrobjs.h"
+
+FT_BEGIN_HEADER
+
+  FT_LOCAL( FT_Error )
+  pfr_slot_load_bitmap( PFR_Slot  glyph,
+                        PFR_Size  size,
+                        FT_UInt   glyph_index );
+
+FT_END_HEADER
+
+#endif /* __PFR_SBIT_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/pfrtypes.h b/nx-X11/extras/freetype2/src/pfr/pfrtypes.h
new file mode 100644
index 000000000..a10a2b26c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/pfrtypes.h
@@ -0,0 +1,364 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrtypes.h                                                             */
+/*                                                                         */
+/*    FreeType PFR data structures (specification only).                   */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 __PFRTYPES_H__
+#define __PFRTYPES_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+
+FT_BEGIN_HEADER
+
+  /************************************************************************/
+
+  /* the PFR Header structure */
+  typedef struct  PFR_HeaderRec_
+  {
+    FT_UInt32  signature;
+    FT_UInt    version;
+    FT_UInt    signature2;
+    FT_UInt    header_size;
+
+    FT_UInt    log_dir_size;
+    FT_UInt    log_dir_offset;
+
+    FT_UInt    log_font_max_size;
+    FT_UInt32  log_font_section_size;
+    FT_UInt32  log_font_section_offset;
+
+    FT_UInt32  phy_font_max_size;
+    FT_UInt32  phy_font_section_size;
+    FT_UInt32  phy_font_section_offset;
+
+    FT_UInt    gps_max_size;
+    FT_UInt32  gps_section_size;
+    FT_UInt32  gps_section_offset;
+
+    FT_UInt    max_blue_values;
+    FT_UInt    max_x_orus;
+    FT_UInt    max_y_orus;
+
+    FT_UInt    phy_font_max_size_high;
+    FT_UInt    color_flags;
+
+    FT_UInt32  bct_max_size;
+    FT_UInt32  bct_set_max_size;
+    FT_UInt32  phy_bct_set_max_size;
+
+    FT_UInt    num_phy_fonts;
+    FT_UInt    max_vert_stem_snap;
+    FT_UInt    max_horz_stem_snap;
+    FT_UInt    max_chars;
+
+  } PFR_HeaderRec, *PFR_Header;
+
+
+  /* used in `color_flags' field of the PFR_Header */
+  typedef enum  PFR_HeaderFlags_
+  {
+    PFR_FLAG_BLACK_PIXEL   = 1,
+    PFR_FLAG_INVERT_BITMAP = 2
+
+  } PFR_HeaderFlags;
+
+
+  /************************************************************************/
+
+  typedef struct  PFR_LogFontRec_
+  {
+    FT_UInt32  size;
+    FT_UInt32  offset;
+
+    FT_Int32   matrix[4];
+    FT_UInt    stroke_flags;
+    FT_Int     stroke_thickness;
+    FT_Int     bold_thickness;
+    FT_Int32   miter_limit;
+
+    FT_UInt32  phys_size;
+    FT_UInt32  phys_offset;
+
+  } PFR_LogFontRec, *PFR_LogFont;
+
+
+  typedef enum  PFR_LogFlags_
+  {
+    PFR_LOG_EXTRA_ITEMS  = 0x40,
+    PFR_LOG_2BYTE_BOLD   = 0x20,
+    PFR_LOG_BOLD         = 0x10,
+    PFR_LOG_2BYTE_STROKE = 8,
+    PFR_LOG_STROKE       = 4,
+    PFR_LINE_JOIN_MASK   = 3
+
+  } PFR_LogFlags;
+
+
+  typedef enum  PFR_LineJoinFlags_
+  {
+    PFR_LINE_JOIN_MITER = 0,
+    PFR_LINE_JOIN_ROUND = 1,
+    PFR_LINE_JOIN_BEVEL = 2
+
+  } PFR_LineJoinFlags;
+
+
+  /************************************************************************/
+
+  typedef enum  PFR_BitmapFlags_
+  {
+    PFR_BITMAP_3BYTE_OFFSET   = 4,
+    PFR_BITMAP_2BYTE_SIZE     = 2,
+    PFR_BITMAP_2BYTE_CHARCODE = 1
+
+  } PFR_BitmapFlags;
+
+
+  typedef struct  PFR_BitmapCharRec_
+  {
+    FT_UInt    char_code;
+    FT_UInt    gps_size;
+    FT_UInt32  gps_offset;
+
+  } PFR_BitmapCharRec, *PFR_BitmapChar;
+
+
+  typedef enum  PFR_StrikeFlags_
+  {
+    PFR_STRIKE_2BYTE_COUNT  = 0x10,
+    PFR_STRIKE_3BYTE_OFFSET = 0x08,
+    PFR_STRIKE_3BYTE_SIZE   = 0x04,
+    PFR_STRIKE_2BYTE_YPPM   = 0x02,
+    PFR_STRIKE_2BYTE_XPPM   = 0x01
+
+  } PFR_StrikeFlags;
+
+
+  typedef struct  PFR_StrikeRec_
+  {
+    FT_UInt         x_ppm;
+    FT_UInt         y_ppm;
+    FT_UInt         flags;
+
+    FT_UInt32       gps_size;
+    FT_UInt32       gps_offset;
+
+    FT_UInt32       bct_size;
+    FT_UInt32       bct_offset;
+
+    /* optional */
+    FT_UInt         num_bitmaps;
+    PFR_BitmapChar  bitmaps;
+
+  } PFR_StrikeRec, *PFR_Strike;
+
+
+  /************************************************************************/
+
+  typedef struct  PFR_CharRec_
+  {
+    FT_UInt    char_code;
+    FT_Int     advance;
+    FT_UInt    gps_size;
+    FT_UInt32  gps_offset;
+
+  } PFR_CharRec, *PFR_Char;
+
+
+  /************************************************************************/
+
+  typedef struct  PFR_DimensionRec_
+  {
+    FT_UInt  standard;
+    FT_UInt  num_stem_snaps;
+    FT_Int*  stem_snaps;
+
+  } PFR_DimensionRec, *PFR_Dimension;
+
+  /************************************************************************/
+
+  typedef struct PFR_KernItemRec_*  PFR_KernItem;
+
+  typedef struct  PFR_KernItemRec_
+  {
+    PFR_KernItem  next;
+    FT_UInt       pair_count;
+    FT_UInt       pair_size;
+    FT_Int        base_adj;
+    FT_UInt       flags;
+    FT_UInt32     offset;
+    FT_UInt32     pair1;
+    FT_UInt32     pair2;
+
+  } PFR_KernItemRec;
+
+#define PFR_KERN_INDEX( g1, g2 ) \
+  ( ( (FT_UInt32)(g1) << 16 ) | (FT_UInt16)(g2) )
+
+#define PFR_KERN_PAIR_INDEX( pair )  \
+          PFR_KERN_INDEX( (pair)->glyph1, (pair)->glyph2 )
+
+  typedef struct  PFR_KernPairRec_
+  {
+    FT_UInt    glyph1;
+    FT_UInt    glyph2;
+    FT_Int     kerning;
+
+  } PFR_KernPairRec, *PFR_KernPair;
+
+  /************************************************************************/
+
+  typedef struct  PFR_PhyFontRec_
+  {
+    FT_Memory          memory;
+    FT_UInt32          offset;
+
+    FT_UInt            font_ref_number;
+    FT_UInt            outline_resolution;
+    FT_UInt            metrics_resolution;
+    FT_BBox            bbox;
+    FT_UInt            flags;
+    FT_UInt            standard_advance;
+
+    FT_Int             ascent;   /* optional, bbox.yMax if not present */
+    FT_Int             descent;  /* optional, bbox.yMin if not present */
+    FT_Int             leading;  /* optional, 0 if not present         */
+
+    PFR_DimensionRec   horizontal;
+    PFR_DimensionRec   vertical;
+
+    FT_String*         font_id;
+    FT_String*         family_name;
+    FT_String*         style_name;
+
+    FT_UInt            num_strikes;
+    FT_UInt            max_strikes;
+    PFR_StrikeRec*     strikes;
+
+    FT_UInt            num_blue_values;
+    FT_Int            *blue_values;
+    FT_UInt            blue_fuzz;
+    FT_UInt            blue_scale;
+
+    FT_UInt            num_chars;
+    FT_UInt32          chars_offset;
+    PFR_Char           chars;
+
+    FT_UInt            num_kern_pairs;
+    PFR_KernItem       kern_items;
+    PFR_KernItem*      kern_items_tail;
+    PFR_KernPair       kern_pairs;
+
+    /* not part of the spec, but used during load */
+    FT_UInt32          bct_offset;
+    FT_Byte*           cursor;
+
+  } PFR_PhyFontRec, *PFR_PhyFont;
+
+
+  typedef enum  PFR_PhyFlags_
+  {
+    PFR_PHY_EXTRA_ITEMS      = 0x80,
+    PFR_PHY_3BYTE_GPS_OFFSET = 0x20,
+    PFR_PHY_2BYTE_GPS_SIZE   = 0x10,
+    PFR_PHY_ASCII_CODE       = 0x08,
+    PFR_PHY_PROPORTIONAL     = 0x04,
+    PFR_PHY_2BYTE_CHARCODE   = 0x02,
+    PFR_PHY_VERTICAL         = 0x01
+
+  } PFR_PhyFlags;
+
+
+  typedef enum PFR_KernFlags_
+  {
+    PFR_KERN_2BYTE_CHAR  = 0x01,
+    PFR_KERN_2BYTE_ADJ   = 0x02
+
+  } PFR_KernFlags;
+
+
+  /************************************************************************/
+
+  typedef enum  PFR_GlyphFlags_
+  {
+    PFR_GLYPH_IS_COMPOUND   = 0x80,
+    PFR_GLYPH_EXTRA_ITEMS   = 0x08,
+    PFR_GLYPH_1BYTE_XYCOUNT = 0x04,
+    PFR_GLYPH_XCOUNT        = 0x02,
+    PFR_GLYPH_YCOUNT        = 0x01
+
+  } PFR_GlyphFlags;
+
+
+  /* controlled coordinate */
+  typedef struct  PFR_CoordRec_
+  {
+    FT_UInt  org;
+    FT_UInt  cur;
+
+  } PFR_CoordRec, *PFR_Coord;
+
+
+  typedef struct  PFR_SubGlyphRec_
+  {
+    FT_Fixed   x_scale;
+    FT_Fixed   y_scale;
+    FT_Int     x_delta;
+    FT_Int     y_delta;
+    FT_UInt32  gps_offset;
+    FT_UInt    gps_size;
+
+  } PFR_SubGlyphRec, *PFR_SubGlyph;
+
+
+  typedef enum  PFR_SubgGlyphFlags_
+  {
+    PFR_SUBGLYPH_3BYTE_OFFSET = 0x80,
+    PFR_SUBGLYPH_2BYTE_SIZE   = 0x40,
+    PFR_SUBGLYPH_YSCALE       = 0x20,
+    PFR_SUBGLYPH_XSCALE       = 0x10
+
+  } PFR_SubGlyphFlags;
+
+
+  typedef struct  PFR_GlyphRec_
+  {
+    FT_Byte           format;
+
+    FT_UInt           num_x_control;
+    FT_UInt           num_y_control;
+    FT_UInt           max_xy_control;
+    FT_Pos*           x_control;
+    FT_Pos*           y_control;
+
+
+    FT_UInt           num_subs;
+    FT_UInt           max_subs;
+    PFR_SubGlyphRec*  subs;
+
+    FT_GlyphLoader    loader;
+    FT_Bool           path_begun;
+
+  } PFR_GlyphRec, *PFR_Glyph;
+
+
+FT_END_HEADER
+
+#endif /* __PFRTYPES_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pfr/rules.mk b/nx-X11/extras/freetype2/src/pfr/rules.mk
new file mode 100644
index 000000000..60b96c741
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pfr/rules.mk
@@ -0,0 +1,73 @@
+#
+# FreeType 2 PFR driver configuration rules
+#
+
+
+# Copyright 2002, 2003 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.
+
+
+# pfr driver directory
+#
+PFR_DIR := $(SRC_DIR)/pfr
+
+
+# compilation flags for the driver
+#
+PFR_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(PFR_DIR))
+
+
+# pfr driver sources (i.e., C files)
+#
+PFR_DRV_SRC := $(PFR_DIR)/pfrload.c  \
+               $(PFR_DIR)/pfrgload.c \
+               $(PFR_DIR)/pfrcmap.c  \
+               $(PFR_DIR)/pfrdrivr.c \
+               $(PFR_DIR)/pfrsbit.c  \
+               $(PFR_DIR)/pfrobjs.c
+
+# pfr driver headers
+#
+PFR_DRV_H := $(PFR_DRV_SRC:%.c=%.h) \
+             $(PFR_DIR)/pfrerror.h  \
+             $(PFR_DIR)/pfrtypes.h
+
+
+# Pfr driver object(s)
+#
+#   PFR_DRV_OBJ_M is used during `multi' builds
+#   PFR_DRV_OBJ_S is used during `single' builds
+#
+PFR_DRV_OBJ_M := $(PFR_DRV_SRC:$(PFR_DIR)/%.c=$(OBJ_DIR)/%.$O)
+PFR_DRV_OBJ_S := $(OBJ_DIR)/pfr.$O
+
+# pfr driver source file for single build
+#
+PFR_DRV_SRC_S := $(PFR_DIR)/pfr.c
+
+
+# pfr driver - single object
+#
+$(PFR_DRV_OBJ_S): $(PFR_DRV_SRC_S) $(PFR_DRV_SRC) $(FREETYPE_H) $(PFR_DRV_H)
+	$(PFR_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(PFR_DRV_SRC_S))
+
+
+# pfr driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(PFR_DIR)/%.c $(FREETYPE_H) $(PFR_DRV_H)
+	$(PFR_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(PFR_DRV_OBJ_S)
+DRV_OBJS_M += $(PFR_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/psaux/Jamfile b/nx-X11/extras/freetype2/src/psaux/Jamfile
new file mode 100644
index 000000000..fc834b32c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/psaux Jamfile (c) 2001, 2002 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) psaux ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = psauxmod psobjs t1decode t1cmap ;
+  }
+  else
+  {
+    _sources = psaux ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/psaux Jamfile
diff --git a/nx-X11/extras/freetype2/src/psaux/descrip.mms b/nx-X11/extras/freetype2/src/psaux/descrip.mms
new file mode 100644
index 000000000..bff019243
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 PSaux driver compilation rules for VMS
+#
+
+
+# Copyright 2001, 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.psaux])
+
+OBJS=psaux.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/psaux/module.mk b/nx-X11/extras/freetype2/src/psaux/module.mk
new file mode 100644
index 000000000..29c3e28a9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 PSaux module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_psaux_module
+
+add_psaux_module:
+	$(OPEN_DRIVER)psaux_module_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)psaux     $(ECHO_DRIVER_DESC)Postscript Type 1 & Type 2 helper module$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/psaux/psaux.c b/nx-X11/extras/freetype2/src/psaux/psaux.c
new file mode 100644
index 000000000..992818414
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/psaux.c
@@ -0,0 +1,28 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psaux.c                                                                */
+/*                                                                         */
+/*    FreeType auxiliary PostScript driver component (body only).          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 "psobjs.c"
+#include "psauxmod.c"
+#include "t1decode.c"
+#include "t1cmap.c"
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/psauxerr.h b/nx-X11/extras/freetype2/src/psaux/psauxerr.h
new file mode 100644
index 000000000..d0baa3cbb
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/psauxerr.h
@@ -0,0 +1,41 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psauxerr.h                                                             */
+/*                                                                         */
+/*    PS auxiliary module error codes (specification only).                */
+/*                                                                         */
+/*  Copyright 2001 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 PS auxiliary module error enumeration */
+  /* constants.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __PSAUXERR_H__
+#define __PSAUXERR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  PSaux_Err_
+#define FT_ERR_BASE    FT_Mod_Err_PSaux
+
+#include FT_ERRORS_H
+
+#endif /* __PSAUXERR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/psauxmod.c b/nx-X11/extras/freetype2/src/psaux/psauxmod.c
new file mode 100644
index 000000000..756ec1c56
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/psauxmod.c
@@ -0,0 +1,119 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psauxmod.c                                                             */
+/*                                                                         */
+/*    FreeType auxiliary PostScript module implementation (body).          */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003 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 "psauxmod.h"
+#include "psobjs.h"
+#include "t1decode.h"
+#include "t1cmap.h"
+
+
+  FT_CALLBACK_TABLE_DEF
+  const PS_Table_FuncsRec  ps_table_funcs =
+  {
+    ps_table_new,
+    ps_table_done,
+    ps_table_add,
+    ps_table_release
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const PS_Parser_FuncsRec  ps_parser_funcs =
+  {
+    ps_parser_init,
+    ps_parser_done,
+    ps_parser_skip_spaces,
+    ps_parser_skip_PS_token,
+    ps_parser_to_int,
+    ps_parser_to_fixed,
+    ps_parser_to_bytes,
+    ps_parser_to_coord_array,
+    ps_parser_to_fixed_array,
+    ps_parser_to_token,
+    ps_parser_to_token_array,
+    ps_parser_load_field,
+    ps_parser_load_field_table
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const T1_Builder_FuncsRec  t1_builder_funcs =
+  {
+    t1_builder_init,
+    t1_builder_done,
+    t1_builder_check_points,
+    t1_builder_add_point,
+    t1_builder_add_point1,
+    t1_builder_add_contour,
+    t1_builder_start_point,
+    t1_builder_close_contour
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const T1_Decoder_FuncsRec  t1_decoder_funcs =
+  {
+    t1_decoder_init,
+    t1_decoder_done,
+    t1_decoder_parse_charstrings
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const T1_CMap_ClassesRec  t1_cmap_classes =
+  {
+    &t1_cmap_standard_class_rec,
+    &t1_cmap_expert_class_rec,
+    &t1_cmap_custom_class_rec,
+    &t1_cmap_unicode_class_rec
+  };
+
+
+  static
+  const PSAux_Interface  psaux_interface =
+  {
+    &ps_table_funcs,
+    &ps_parser_funcs,
+    &t1_builder_funcs,
+    &t1_decoder_funcs,
+
+    t1_decrypt,
+    
+    (const T1_CMap_ClassesRec*) &t1_cmap_classes,
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Module_Class  psaux_module_class =
+  {
+    0,
+    sizeof( FT_ModuleRec ),
+    "psaux",
+    0x20000L,
+    0x20000L,
+
+    &psaux_interface,  /* module-specific interface */
+
+    (FT_Module_Constructor)0,
+    (FT_Module_Destructor) 0,
+    (FT_Module_Requester)  0
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/psauxmod.h b/nx-X11/extras/freetype2/src/psaux/psauxmod.h
new file mode 100644
index 000000000..92ac05604
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/psauxmod.h
@@ -0,0 +1,38 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psauxmod.h                                                             */
+/*                                                                         */
+/*    FreeType auxiliary PostScript module implementation (specification). */
+/*                                                                         */
+/*  Copyright 2000-2001 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 __PSAUXMOD_H__
+#define __PSAUXMOD_H__
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Module_Class )  psaux_driver_class;
+
+
+FT_END_HEADER
+
+#endif /* __PSAUXMOD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/psobjs.c b/nx-X11/extras/freetype2/src/psaux/psobjs.c
new file mode 100644
index 000000000..d02986cee
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/psobjs.c
@@ -0,0 +1,1784 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psobjs.c                                                               */
+/*                                                                         */
+/*    Auxiliary functions for PostScript fonts (body).                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_POSTSCRIPT_AUX_H
+#include FT_INTERNAL_DEBUG_H
+
+#include "psobjs.h"
+
+#include "psauxerr.h"
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                             PS_TABLE                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ps_table_new                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a PS_Table.                                            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    table  :: The address of the target table.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    count  :: The table size = the maximum number of elements.         */
+  /*                                                                       */
+  /*    memory :: The memory object to use for all subsequent              */
+  /*              reallocations.                                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  ps_table_new( PS_Table   table,
+                FT_Int     count,
+                FT_Memory  memory )
+  {
+    FT_Error  error;
+
+
+    table->memory = memory;
+    if ( FT_NEW_ARRAY( table->elements, count ) ||
+         FT_NEW_ARRAY( table->lengths,  count ) )
+      goto Exit;
+
+    table->max_elems = count;
+    table->init      = 0xDEADBEEFUL;
+    table->num_elems = 0;
+    table->block     = 0;
+    table->capacity  = 0;
+    table->cursor    = 0;
+
+    *(PS_Table_FuncsRec*)&table->funcs = ps_table_funcs;
+
+  Exit:
+    if ( error )
+      FT_FREE( table->elements );
+
+    return error;
+  }
+
+
+  static void
+  shift_elements( PS_Table  table,
+                  FT_Byte*  old_base )
+  {
+    FT_Long    delta  = (FT_Long)( table->block - old_base );
+    FT_Byte**  offset = table->elements;
+    FT_Byte**  limit  = offset + table->max_elems;
+
+
+    for ( ; offset < limit; offset++ )
+    {
+      if ( offset[0] )
+        offset[0] += delta;
+    }
+  }
+
+
+  static FT_Error
+  reallocate_t1_table( PS_Table  table,
+                       FT_Long   new_size )
+  {
+    FT_Memory  memory   = table->memory;
+    FT_Byte*   old_base = table->block;
+    FT_Error   error;
+
+
+    /* allocate new base block */
+    if ( FT_ALLOC( table->block, new_size ) )
+    {
+      table->block = old_base;
+      return error;
+    }
+
+    /* copy elements and shift offsets */
+    if (old_base )
+    {
+      FT_MEM_COPY( table->block, old_base, table->capacity );
+      shift_elements( table, old_base );
+      FT_FREE( old_base );
+    }
+
+    table->capacity = new_size;
+
+    return PSaux_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ps_table_add                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Adds an object to a PS_Table, possibly growing its memory block.   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    table  :: The target table.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    idx    :: The index of the object in the table.                    */
+  /*                                                                       */
+  /*    object :: The address of the object to copy in memory.             */
+  /*                                                                       */
+  /*    length :: The length in bytes of the source object.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.  An error is returned if a  */
+  /*    reallocation fails.                                                */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  ps_table_add( PS_Table    table,
+                FT_Int      idx,
+                void*       object,
+                FT_PtrDist  length )
+  {
+    if ( idx < 0 || idx > table->max_elems )
+    {
+      FT_ERROR(( "ps_table_add: invalid index\n" ));
+      return PSaux_Err_Invalid_Argument;
+    }
+
+    /* grow the base block if needed */
+    if ( table->cursor + length > table->capacity )
+    {
+      FT_Error   error;
+      FT_Offset  new_size  = table->capacity;
+      FT_Long    in_offset;
+
+
+      in_offset = (FT_Long)((FT_Byte*)object - table->block);
+      if ( (FT_ULong)in_offset >= table->capacity )
+        in_offset = -1;
+
+      while ( new_size < table->cursor + length )
+      {
+        /* increase size by 25% and round up to the nearest multiple
+           of 1024 */
+        new_size += ( new_size >> 2 ) + 1;
+        new_size  = FT_PAD_CEIL( new_size, 1024 );
+      }
+
+      error = reallocate_t1_table( table, new_size );
+      if ( error )
+        return error;
+
+      if ( in_offset >= 0 )
+        object = table->block + in_offset;
+    }
+
+    /* add the object to the base block and adjust offset */
+    table->elements[idx] = table->block + table->cursor;
+    table->lengths [idx] = length;
+    FT_MEM_COPY( table->block + table->cursor, object, length );
+
+    table->cursor += length;
+    return PSaux_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ps_table_done                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes a PS_TableRec (i.e., reallocate it to its current        */
+  /*    cursor).                                                           */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    table :: The target table.                                         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function does NOT release the heap's memory block.  It is up  */
+  /*    to the caller to clean it, or reference it in its own structures.  */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  ps_table_done( PS_Table  table )
+  {
+    FT_Memory  memory = table->memory;
+    FT_Error   error;
+    FT_Byte*   old_base = table->block;
+
+
+    /* should never fail, because rec.cursor <= rec.size */
+    if ( !old_base )
+      return;
+
+    if ( FT_ALLOC( table->block, table->cursor ) )
+      return;
+    FT_MEM_COPY( table->block, old_base, table->cursor );
+    shift_elements( table, old_base );
+
+    table->capacity = table->cursor;
+    FT_FREE( old_base );
+
+    FT_UNUSED( error );
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ps_table_release( PS_Table  table )
+  {
+    FT_Memory  memory = table->memory;
+
+
+    if ( (FT_ULong)table->init == 0xDEADBEEFUL )
+    {
+      FT_FREE( table->block );
+      FT_FREE( table->elements );
+      FT_FREE( table->lengths );
+      table->init = 0;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                            T1 PARSER                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* In the PostScript Language Reference Manual (PLRM) the following */
+  /* characters are called `whitespace characters'.                   */
+#define IS_T1_WHITESPACE( c )  ( (c) == ' '  || (c) == '\t' )
+#define IS_T1_LINESPACE( c )   ( (c) == '\r' || (c) == '\n' || (c) == '\f' )
+#define IS_T1_NULLSPACE( c )   ( (c) == '\0' )
+
+  /* According to the PLRM all whitespace characters are equivalent, */
+  /* except in comments and strings.                                 */
+#define IS_T1_SPACE( c )  ( IS_T1_WHITESPACE( c ) || \
+                            IS_T1_LINESPACE( c )  || \
+                            IS_T1_NULLSPACE( c )  )
+
+
+  /* The following array is used by various functions to quickly convert */
+  /* digits (both decimal and non-decimal) into numbers.                 */
+
+#if 'A' == 65
+  /* ASCII */
+
+  static const char  ft_char_table[128] =
+  {
+    /* 0x00 */
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
+    -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
+    -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
+  };
+
+  /* no character >= 0x80 can represent a valid number */
+#define OP  >=
+
+#endif /* 'A' == 65 */
+
+#if 'A' == 193
+  /* EBCDIC */
+
+  static const char  ft_char_table[128] =
+  {
+    /* 0x80 */
+    -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1,
+    -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
+    -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1,
+    -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
+    -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1,
+     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
+  }
+
+  /* no character < 0x80 can represent a valid number */
+#define OP  <
+
+#endif /* 'A' == 193 */
+
+
+  /* first character must be already part of the comment */
+
+  static void
+  skip_comment( FT_Byte*  *acur,
+                FT_Byte*   limit )
+  {
+    FT_Byte*  cur = *acur;
+
+
+    while ( cur < limit )
+    {
+      if ( IS_T1_LINESPACE( *cur ) )
+        break;
+      cur++;
+    }
+
+    *acur = cur;
+  }
+
+
+  static void
+  skip_spaces( FT_Byte*  *acur,
+               FT_Byte*   limit )
+  {
+    FT_Byte*  cur = *acur;
+
+
+    while ( cur < limit )
+    {
+      if ( !IS_T1_SPACE( *cur ) )
+      {
+        if ( *cur == '%' )
+          /* According to the PLRM, a comment is equal to a space. */
+          skip_comment( &cur, limit );
+        else
+          break;
+      }
+      cur++;
+    }
+
+    *acur = cur;
+  }
+
+
+  /* first character must be `(' */
+
+  static void
+  skip_literal_string( FT_Byte*  *acur,
+                       FT_Byte*   limit )
+  {
+    FT_Byte*  cur   = *acur;
+    FT_Int    embed = 0;
+
+
+    while ( cur < limit )
+    {
+      if ( *cur == '\\' )
+        cur++;
+      else if ( *cur == '(' )
+        embed++;
+      else if ( *cur == ')' )
+      {
+        embed--;
+        if ( embed == 0 )
+        {
+          cur++;
+          break;
+        }
+      }
+      cur++;
+    }
+
+    *acur = cur;
+  }
+
+
+  /* first character must be `<' */
+
+  static void
+  skip_string( PS_Parser  parser )
+  {
+    FT_Byte*  cur   = parser->cursor;
+    FT_Byte*  limit = parser->limit;
+
+
+    while ( ++cur < limit )
+    {
+      int  d;
+
+
+      /* All whitespace characters are ignored. */
+      skip_spaces( &cur, limit );
+      if ( cur >= limit )
+        break;
+
+      if ( *cur OP 0x80 )
+        break;
+
+      d = ft_char_table[*cur & 0x7F];
+      if ( d < 0 || d >= 16 )
+        break;
+    }
+
+    if ( cur < limit && *cur != '>' )
+      parser->error = PSaux_Err_Invalid_File_Format;
+    else
+      cur++;
+
+    parser->cursor = cur;
+  }
+
+
+  /***********************************************************************/
+  /*                                                                     */
+  /* All exported parsing routines handle leading whitespace and stop at */
+  /* the first character which isn't part of the just handled token.     */
+  /*                                                                     */
+  /***********************************************************************/
+
+
+  FT_LOCAL_DEF( void )
+  ps_parser_skip_PS_token( PS_Parser  parser )
+  {
+    /* Note: PostScript allows any non-delimiting, non-whitespace        */
+    /*       character in a name (PS Ref Manual, 3rd ed, p31).           */
+    /*       PostScript delimiters are (, ), <, >, [, ], {, }, /, and %. */
+
+    FT_Byte*  cur   = parser->cursor;
+    FT_Byte*  limit = parser->limit;
+
+
+    skip_spaces( &cur, limit );             /* this also skips comments */
+    if ( cur >= limit )
+      goto Exit;
+
+    /* self-delimiting, single-character tokens */
+    if ( *cur == '[' || *cur == ']' ||
+         *cur == '{' || *cur == '}' )
+    {
+      cur++;
+      goto Exit;
+    }
+
+    if ( *cur == '(' )                              /* (...) */
+    {
+      skip_literal_string( &cur, limit );
+      goto Exit;
+    }
+
+    if ( *cur == '<' )                              /* <...> */
+    {
+      if ( cur + 1 < limit && *(cur + 1) == '<' )   /* << */
+      {
+        cur++;
+        cur++;
+        goto Exit;
+      }
+      parser->cursor = cur;
+      skip_string( parser );
+      return;
+    }
+
+    if ( *cur == '>' )
+    {
+      cur++;
+      if ( cur >= limit || *cur != '>' )             /* >> */
+      {
+        parser->error = PSaux_Err_Invalid_File_Format;
+        goto Exit;
+      }
+      cur++;
+      goto Exit;
+    }
+
+    if ( *cur == '/' )
+      cur++;
+
+    /* anything else */
+    while ( cur < limit )
+    {
+      if ( IS_T1_SPACE( *cur )        ||
+           *cur == '('                ||
+           *cur == '/'                ||
+           *cur == '%'                ||
+           *cur == '[' || *cur == ']' ||
+           *cur == '{' || *cur == '}' ||
+           *cur == '<' || *cur == '>' )
+        break;
+
+      if ( *cur == ')' )
+      {
+        parser->error = PSaux_Err_Invalid_File_Format;
+        goto Exit;
+      }
+
+      cur++;
+    }
+
+  Exit:
+    parser->cursor = cur;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ps_parser_skip_spaces( PS_Parser  parser )
+  {
+    skip_spaces( &parser->cursor, parser->limit );
+  }
+
+
+  /* `token' here means either something between balanced delimiters */
+  /* or the next token; the delimiters are not removed.              */
+
+  FT_LOCAL_DEF( void )
+  ps_parser_to_token( PS_Parser  parser,
+                      T1_Token   token )
+  {
+    FT_Byte*  cur;
+    FT_Byte*  limit;
+    FT_Byte   starter, ender;
+    FT_Int    embed;
+
+
+    token->type  = T1_TOKEN_TYPE_NONE;
+    token->start = 0;
+    token->limit = 0;
+
+    /* first of all, skip leading whitespace */
+    ps_parser_skip_spaces( parser );
+
+    cur   = parser->cursor;
+    limit = parser->limit;
+
+    if ( cur >= limit )
+      return;
+
+    switch ( *cur )
+    {
+      /************* check for literal string *****************/
+    case '(':
+      token->type  = T1_TOKEN_TYPE_STRING;
+      token->start = cur;
+      skip_literal_string( &cur, limit );
+      if ( cur < limit )
+        token->limit = cur;
+      break;
+
+      /************* check for programs/array *****************/
+    case '{':
+      token->type = T1_TOKEN_TYPE_ARRAY;
+      ender = '}';
+      goto Lookup_Ender;
+
+      /************* check for table/array ********************/
+    case '[':
+      token->type = T1_TOKEN_TYPE_ARRAY;
+      ender = ']';
+      /* fall through */
+
+    Lookup_Ender:
+      embed        = 1;
+      starter      = *cur;
+      token->start = cur++;
+
+      /* we need this to catch `[ ]' */
+      parser->cursor = cur;
+      ps_parser_skip_spaces( parser );
+      cur = parser->cursor;
+
+      while ( cur < limit && !parser->error )
+      {
+        if ( *cur == starter )
+          embed++;
+        else if ( *cur == ender )
+        {
+          embed--;
+          if ( embed <= 0 )
+          {
+            token->limit = ++cur;
+            break;
+          }
+        }
+
+        parser->cursor = cur;
+        ps_parser_skip_PS_token( parser );
+        /* we need this to catch `[XXX ]' */
+        ps_parser_skip_spaces  ( parser );
+        cur = parser->cursor;
+      }
+      break;
+
+      /* ************ otherwise, it is any token **************/
+    default:
+      token->start = cur;
+      token->type  = T1_TOKEN_TYPE_ANY;
+      ps_parser_skip_PS_token( parser );
+      cur = parser->cursor;
+      if ( !parser->error )
+        token->limit = cur;
+    }
+
+    if ( !token->limit )
+    {
+      token->start = 0;
+      token->type  = T1_TOKEN_TYPE_NONE;
+    }
+
+    parser->cursor = cur;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ps_parser_to_token_array( PS_Parser  parser,
+                            T1_Token   tokens,
+                            FT_UInt    max_tokens,
+                            FT_Int*    pnum_tokens )
+  {
+    T1_TokenRec  master;
+
+
+    *pnum_tokens = -1;
+
+    /* this also handles leading whitespace */
+    ps_parser_to_token( parser, &master );
+
+    if ( master.type == T1_TOKEN_TYPE_ARRAY )
+    {
+      FT_Byte*  old_cursor = parser->cursor;
+      FT_Byte*  old_limit  = parser->limit;
+      T1_Token  cur        = tokens;
+      T1_Token  limit      = cur + max_tokens;
+
+
+      /* don't include outermost delimiters */
+      parser->cursor = master.start + 1;
+      parser->limit  = master.limit - 1;
+
+      while ( parser->cursor < parser->limit )
+      {
+        T1_TokenRec  token;
+
+
+        ps_parser_to_token( parser, &token );
+        if ( !token.type )
+          break;
+
+        if ( cur < limit )
+          *cur = token;
+
+        cur++;
+      }
+
+      *pnum_tokens = (FT_Int)( cur - tokens );
+
+      parser->cursor = old_cursor;
+      parser->limit  = old_limit;
+    }
+  }
+
+
+  /* first character must be already part of the number */
+
+  static FT_Long
+  ps_radix( FT_Long    radixBase,
+            FT_Byte*  *acur,
+            FT_Byte*   limit )
+  {
+    FT_Long   result = 0;
+    FT_Byte*  cur    = *acur;
+
+
+    if ( radixBase < 2 || radixBase > 36 )
+      return 0;
+
+    while ( cur < limit )
+    {
+      int  d;
+
+
+      if ( *cur OP 0x80 )
+        break;
+
+      d = ft_char_table[*cur & 0x7F];
+      if ( d < 0 || d >= radixBase )
+        break;
+
+      result = result * radixBase + d;
+
+      cur++;
+    }
+
+    *acur = cur;
+
+    return result;
+  }
+
+
+  /* first character must be already part of the number */
+
+  static FT_Long
+  ps_toint( FT_Byte*  *acur,
+            FT_Byte*   limit )
+  {
+    FT_Long   result = 0;
+    FT_Byte*  cur    = *acur;
+    FT_Byte   c;
+
+
+    if ( cur >= limit )
+      goto Exit;
+
+    c = *cur;
+    if ( c == '-' )
+      cur++;
+
+    while ( cur < limit )
+    {
+      int  d;
+
+
+      if ( *cur == '#' )
+      {
+        cur++;
+        result = ps_radix( result, &cur, limit );
+        break;
+      }
+
+      if ( *cur OP 0x80 )
+        break;
+
+      d = ft_char_table[*cur & 0x7F];
+      if ( d < 0 || d >= 10 )
+        break;
+      result = result * 10 + d;
+
+      cur++;
+    };
+
+    if ( c == '-' )
+      result = -result;
+
+  Exit:
+    *acur = cur;
+    return result;
+  }
+
+
+  /* first character must be `<' if `delimiters' is non-zero */
+
+  static FT_Error
+  ps_tobytes( FT_Byte*  *acur,
+              FT_Byte*   limit,
+              FT_Long    max_bytes,
+              FT_Byte*   bytes,
+              FT_Long*   pnum_bytes,
+              FT_Bool    delimiters )
+  {
+    FT_Error  error = PSaux_Err_Ok;
+
+    FT_Byte*  cur = *acur;
+    FT_Long   n   = 0;
+
+
+    if ( cur >= limit )
+      goto Exit;
+
+    if ( delimiters )
+    {
+      if ( *cur != '<' )
+      {
+        error = PSaux_Err_Invalid_File_Format;
+        goto Exit;
+      }
+
+      cur++;
+    }
+
+    max_bytes = max_bytes * 2;
+
+    for ( n = 0; cur < limit; n++, cur++ )
+    {
+      int  d;
+
+
+      if ( n >= max_bytes )
+        /* buffer is full */
+        goto Exit;
+
+      /* All whitespace characters are ignored. */
+      skip_spaces( &cur, limit );
+      if ( cur >= limit )
+        break;
+
+      if ( *cur OP 0x80 )
+        break;
+
+      d = ft_char_table[*cur & 0x7F];
+      if ( d < 0 || d >= 16 )
+        break;
+
+      /* <f> == <f0> != <0f> */
+      bytes[n / 2] = (FT_Byte)( ( n % 2 ) ? bytes[n / 2] + d
+                                          : d * 16 );
+    }
+
+    if ( delimiters )
+    {
+      if ( cur < limit && *cur != '>' )
+      {
+        error = PSaux_Err_Invalid_File_Format;
+        goto Exit;
+      }
+
+      cur++;
+    }
+
+    *acur = cur;
+
+  Exit:
+    *pnum_bytes = ( n + 1 ) / 2;
+
+    return error;
+  }
+
+
+  /* first character must be already part of the number */
+
+  static FT_Long
+  ps_tofixed( FT_Byte*  *acur,
+              FT_Byte*   limit,
+              FT_Long    power_ten )
+  {
+    FT_Byte*  cur  = *acur;
+    FT_Long   num, divider, result;
+    FT_Int    sign = 0;
+
+
+    if ( cur >= limit )
+      return 0;
+
+    /* first of all, check the sign */
+    if ( *cur == '-' && cur + 1 < limit )
+    {
+      sign = 1;
+      cur++;
+    }
+
+    /* then, read the integer part, if any */
+    if ( *cur != '.' )
+      result = ps_toint( &cur, limit ) << 16;
+    else
+      result = 0;
+
+    num     = 0;
+    divider = 1;
+
+    if ( cur >= limit )
+      goto Exit;
+
+    /* read decimal part, if any */
+    if ( *cur == '.' && cur + 1 < limit )
+    {
+      cur++;
+
+      for (;;)
+      {
+        int  d;
+
+
+        if ( *cur OP 0x80 )
+          break;
+
+        d = ft_char_table[*cur & 0x7F];
+        if ( d < 0 || d >= 10 )
+          break;
+
+        if ( divider < 10000000L )
+        {
+          num      = num * 10 + d;
+          divider *= 10;
+        }
+
+        cur++;
+        if ( cur >= limit )
+          break;
+      }
+    }
+
+    /* read exponent, if any */
+    if ( cur + 1 < limit && ( *cur == 'e' || *cur == 'E' ) )
+    {
+      cur++;
+      power_ten += ps_toint( &cur, limit );
+    }
+
+  Exit:
+    /* raise to power of ten if needed */
+    while ( power_ten > 0 )
+    {
+      result = result * 10;
+      num    = num * 10;
+      power_ten--;
+    }
+
+    while ( power_ten < 0 )
+    {
+      result  = result / 10;
+      divider = divider * 10;
+      power_ten++;
+    }
+
+    if ( num )
+      result += FT_DivFix( num, divider );
+
+    if ( sign )
+      result = -result;
+
+    *acur = cur;
+    return result;
+  }
+
+
+  /* first character must be a delimiter or a part of a number */
+
+  static FT_Int
+  ps_tocoordarray( FT_Byte*  *acur,
+                   FT_Byte*   limit,
+                   FT_Int     max_coords,
+                   FT_Short*  coords )
+  {
+    FT_Byte*  cur   = *acur;
+    FT_Int    count = 0;
+    FT_Byte   c, ender;
+
+
+    if ( cur >= limit )
+      goto Exit;
+
+    /* check for the beginning of an array; otherwise, only one number */
+    /* will be read                                                    */
+    c     = *cur;
+    ender = 0;
+
+    if ( c == '[' )
+      ender = ']';
+
+    if ( c == '{' )
+      ender = '}';
+
+    if ( ender )
+      cur++;
+
+    /* now, read the coordinates */
+    while ( cur < limit )
+    {
+      /* skip whitespace in front of data */
+      skip_spaces( &cur, limit );
+      if ( cur >= limit )
+        goto Exit;
+
+      if ( count >= max_coords )
+        break;
+
+      if ( c == ender )
+      {
+        cur++;
+        break;
+      }
+
+      coords[count] = (FT_Short)( ps_tofixed( &cur, limit, 0 ) >> 16 );
+      count++;
+
+      if ( !ender )
+        break;
+    }
+
+  Exit:
+    *acur = cur;
+    return count;
+  }
+
+
+  /* first character must be a delimiter or a part of a number */
+
+  static FT_Int
+  ps_tofixedarray( FT_Byte*  *acur,
+                   FT_Byte*   limit,
+                   FT_Int     max_values,
+                   FT_Fixed*  values,
+                   FT_Int     power_ten )
+  {
+    FT_Byte*  cur   = *acur;
+    FT_Int    count = 0;
+    FT_Byte   c, ender;
+
+
+    if ( cur >= limit )
+      goto Exit;
+
+    /* Check for the beginning of an array.  Otherwise, only one number */
+    /* will be read.                                                    */
+    c     = *cur;
+    ender = 0;
+
+    if ( c == '[' )
+      ender = ']';
+
+    if ( c == '{' )
+      ender = '}';
+
+    if ( ender )
+      cur++;
+
+    /* now, read the values */
+    while ( cur < limit )
+    {
+      /* skip whitespace in front of data */
+      skip_spaces( &cur, limit );
+      if ( cur >= limit )
+        goto Exit;
+
+      if ( count >= max_values )
+        break;
+
+      if ( c == ender )
+      {
+        cur++;
+        break;
+      }
+
+      values[count] = ps_tofixed( &cur, limit, power_ten );
+      count++;
+
+      if ( !ender )
+        break;
+    }
+
+  Exit:
+    *acur = cur;
+    return count;
+  }
+
+
+#if 0
+
+  static FT_String*
+  ps_tostring( FT_Byte**  cursor,
+               FT_Byte*   limit,
+               FT_Memory  memory )
+  {
+    FT_Byte*    cur = *cursor;
+    FT_PtrDist  len = 0;
+    FT_Int      count;
+    FT_String*  result;
+    FT_Error    error;
+
+
+    /* XXX: some stupid fonts have a `Notice' or `Copyright' string     */
+    /*      that simply doesn't begin with an opening parenthesis, even */
+    /*      though they have a closing one!  E.g. "amuncial.pfb"        */
+    /*                                                                  */
+    /*      We must deal with these ill-fated cases there.  Note that   */
+    /*      these fonts didn't work with the old Type 1 driver as the   */
+    /*      notice/copyright was not recognized as a valid string token */
+    /*      and made the old token parser commit errors.                */
+
+    while ( cur < limit && ( *cur == ' ' || *cur == '\t' ) )
+      cur++;
+    if ( cur + 1 >= limit )
+      return 0;
+
+    if ( *cur == '(' )
+      cur++;  /* skip the opening parenthesis, if there is one */
+
+    *cursor = cur;
+    count   = 0;
+
+    /* then, count its length */
+    for ( ; cur < limit; cur++ )
+    {
+      if ( *cur == '(' )
+        count++;
+
+      else if ( *cur == ')' )
+      {
+        count--;
+        if ( count < 0 )
+          break;
+      }
+    }
+
+    len = cur - *cursor;
+    if ( cur >= limit || FT_ALLOC( result, len + 1 ) )
+      return 0;
+
+    /* now copy the string */
+    FT_MEM_COPY( result, *cursor, len );
+    result[len] = '\0';
+    *cursor = cur;
+    return result;
+  }
+
+#endif /* 0 */
+
+
+  static int
+  ps_tobool( FT_Byte*  *acur,
+             FT_Byte*   limit )
+  {
+    FT_Byte*  cur    = *acur;
+    FT_Bool   result = 0;
+
+
+    /* return 1 if we find `true', 0 otherwise */
+    if ( cur + 3 < limit &&
+         cur[0] == 't'   &&
+         cur[1] == 'r'   &&
+         cur[2] == 'u'   &&
+         cur[3] == 'e'   )
+    {
+      result = 1;
+      cur   += 5;
+    }
+    else if ( cur + 4 < limit &&
+              cur[0] == 'f'   &&
+              cur[1] == 'a'   &&
+              cur[2] == 'l'   &&
+              cur[3] == 's'   &&
+              cur[4] == 'e'   )
+    {
+      result = 0;
+      cur   += 6;
+    }
+
+    *acur = cur;
+    return result;
+  }
+
+
+  /* load a simple field (i.e. non-table) into the current list of objects */
+
+  FT_LOCAL_DEF( FT_Error )
+  ps_parser_load_field( PS_Parser       parser,
+                        const T1_Field  field,
+                        void**          objects,
+                        FT_UInt         max_objects,
+                        FT_ULong*       pflags )
+  {
+    T1_TokenRec  token;
+    FT_Byte*     cur;
+    FT_Byte*     limit;
+    FT_UInt      count;
+    FT_UInt      idx;
+    FT_Error     error;
+
+
+    /* this also skips leading whitespace */
+    ps_parser_to_token( parser, &token );
+    if ( !token.type )
+      goto Fail;
+
+    count = 1;
+    idx   = 0;
+    cur   = token.start;
+    limit = token.limit;
+
+    /* we must detect arrays in /FontBBox */
+    if ( field->type == T1_FIELD_TYPE_BBOX )
+    {
+      T1_TokenRec  token2;
+      FT_Byte*     old_cur   = parser->cursor;
+      FT_Byte*     old_limit = parser->limit;
+
+
+      /* don't include delimiters */
+      parser->cursor = token.start + 1;
+      parser->limit  = token.limit - 1;
+
+      ps_parser_to_token( parser, &token2 );
+      parser->cursor = old_cur;
+      parser->limit  = old_limit;
+
+      if ( token2.type == T1_TOKEN_TYPE_ARRAY )
+        goto FieldArray;
+    }
+    else if ( token.type == T1_TOKEN_TYPE_ARRAY )
+    {
+    FieldArray:
+      /* if this is an array and we have no blend, an error occurs */
+      if ( max_objects == 0 )
+        goto Fail;
+
+      count = max_objects;
+      idx   = 1;
+
+      /* don't include delimiters */
+      cur++;
+      limit--;
+    }
+
+    for ( ; count > 0; count--, idx++ )
+    {
+      FT_Byte*    q = (FT_Byte*)objects[idx] + field->offset;
+      FT_Long     val;
+      FT_String*  string;
+
+
+      skip_spaces( &cur, limit );
+
+      switch ( field->type )
+      {
+      case T1_FIELD_TYPE_BOOL:
+        val = ps_tobool( &cur, limit );
+        goto Store_Integer;
+
+      case T1_FIELD_TYPE_FIXED:
+        val = ps_tofixed( &cur, limit, 0 );
+        goto Store_Integer;
+
+      case T1_FIELD_TYPE_FIXED_1000:
+        val = ps_tofixed( &cur, limit, 3 );
+        goto Store_Integer;
+
+      case T1_FIELD_TYPE_INTEGER:
+        val = ps_toint( &cur, limit );
+        /* fall through */
+
+      Store_Integer:
+        switch ( field->size )
+        {
+        case (8 / FT_CHAR_BIT):
+          *(FT_Byte*)q = (FT_Byte)val;
+          break;
+
+        case (16 / FT_CHAR_BIT):
+          *(FT_UShort*)q = (FT_UShort)val;
+          break;
+
+        case (32 / FT_CHAR_BIT):
+          *(FT_UInt32*)q = (FT_UInt32)val;
+          break;
+
+        default:                /* for 64-bit systems */
+          *(FT_Long*)q = val;
+        }
+        break;
+
+      case T1_FIELD_TYPE_STRING:
+      case T1_FIELD_TYPE_KEY:
+        {
+          FT_Memory  memory = parser->memory;
+          FT_UInt    len    = (FT_UInt)( limit - cur );
+
+
+          if ( cur >= limit )
+            break;
+
+          if ( field->type == T1_FIELD_TYPE_KEY )
+          {
+            /* don't include leading `/' */
+            len--;
+            cur++;
+          }
+          else
+          {
+            /* don't include delimiting parentheses */
+            cur++;
+            len -= 2;
+          }
+
+          if ( FT_ALLOC( string, len + 1 ) )
+            goto Exit;
+
+          FT_MEM_COPY( string, cur, len );
+          string[len] = 0;
+
+          *(FT_String**)q = string;
+        }
+        break;
+
+      case T1_FIELD_TYPE_BBOX:
+        {
+          FT_Fixed  temp[4];
+          FT_BBox*  bbox = (FT_BBox*)q;
+
+
+          (void)ps_tofixedarray( &token.start, token.limit, 4, temp, 0 );
+
+          bbox->xMin = FT_RoundFix( temp[0] );
+          bbox->yMin = FT_RoundFix( temp[1] );
+          bbox->xMax = FT_RoundFix( temp[2] );
+          bbox->yMax = FT_RoundFix( temp[3] );
+        }
+        break;
+
+      default:
+        /* an error occured */
+        goto Fail;
+      }
+    }
+
+#if 0  /* obsolete -- keep for reference */
+    if ( pflags )
+      *pflags |= 1L << field->flag_bit;
+#else
+    FT_UNUSED( pflags );
+#endif
+
+    error = PSaux_Err_Ok;
+
+  Exit:
+    return error;
+
+  Fail:
+    error = PSaux_Err_Invalid_File_Format;
+    goto Exit;
+  }
+
+
+#define T1_MAX_TABLE_ELEMENTS  32
+
+
+  FT_LOCAL_DEF( FT_Error )
+  ps_parser_load_field_table( PS_Parser       parser,
+                              const T1_Field  field,
+                              void**          objects,
+                              FT_UInt         max_objects,
+                              FT_ULong*       pflags )
+  {
+    T1_TokenRec  elements[T1_MAX_TABLE_ELEMENTS];
+    T1_Token     token;
+    FT_Int       num_elements;
+    FT_Error     error = PSaux_Err_Ok;
+    FT_Byte*     old_cursor;
+    FT_Byte*     old_limit;
+    T1_FieldRec  fieldrec = *(T1_Field)field;
+
+
+#if 1
+    fieldrec.type = T1_FIELD_TYPE_INTEGER;
+    if ( field->type == T1_FIELD_TYPE_FIXED_ARRAY )
+      fieldrec.type = T1_FIELD_TYPE_FIXED;
+#endif
+
+    ps_parser_to_token_array( parser, elements,
+                              T1_MAX_TABLE_ELEMENTS, &num_elements );
+    if ( num_elements < 0 )
+    {
+      error = PSaux_Err_Ignore;
+      goto Exit;
+    }
+    if ( num_elements > T1_MAX_TABLE_ELEMENTS )
+      num_elements = T1_MAX_TABLE_ELEMENTS;
+
+    old_cursor = parser->cursor;
+    old_limit  = parser->limit;
+
+    /* we store the elements count */
+    *(FT_Byte*)( (FT_Byte*)objects[0] + field->count_offset ) =
+      (FT_Byte)num_elements;
+
+    /* we now load each element, adjusting the field.offset on each one */
+    token = elements;
+    for ( ; num_elements > 0; num_elements--, token++ )
+    {
+      parser->cursor = token->start;
+      parser->limit  = token->limit;
+      ps_parser_load_field( parser, &fieldrec, objects, max_objects, 0 );
+      fieldrec.offset += fieldrec.size;
+    }
+
+#if 0  /* obsolete -- keep for reference */
+    if ( pflags )
+      *pflags |= 1L << field->flag_bit;
+#else
+    FT_UNUSED( pflags );
+#endif
+
+    parser->cursor = old_cursor;
+    parser->limit  = old_limit;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Long )
+  ps_parser_to_int( PS_Parser  parser )
+  {
+    ps_parser_skip_spaces( parser );
+    return ps_toint( &parser->cursor, parser->limit );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  ps_parser_to_bytes( PS_Parser  parser,
+                      FT_Byte*   bytes,
+                      FT_Long    max_bytes,
+                      FT_Long*   pnum_bytes,
+                      FT_Bool    delimiters )
+  {
+    ps_parser_skip_spaces( parser );
+    return ps_tobytes( &parser->cursor,
+                       parser->limit,
+                       max_bytes,
+                       bytes,
+                       pnum_bytes,
+                       delimiters );
+  }
+
+
+  FT_LOCAL_DEF( FT_Fixed )
+  ps_parser_to_fixed( PS_Parser  parser,
+                      FT_Int     power_ten )
+  {
+    ps_parser_skip_spaces( parser );
+    return ps_tofixed( &parser->cursor, parser->limit, power_ten );
+  }
+
+
+  FT_LOCAL_DEF( FT_Int )
+  ps_parser_to_coord_array( PS_Parser  parser,
+                            FT_Int     max_coords,
+                            FT_Short*  coords )
+  {
+    ps_parser_skip_spaces( parser );
+    return ps_tocoordarray( &parser->cursor, parser->limit,
+                            max_coords, coords );
+  }
+
+
+  FT_LOCAL_DEF( FT_Int )
+  ps_parser_to_fixed_array( PS_Parser  parser,
+                            FT_Int     max_values,
+                            FT_Fixed*  values,
+                            FT_Int     power_ten )
+  {
+    ps_parser_skip_spaces( parser );
+    return ps_tofixedarray( &parser->cursor, parser->limit,
+                            max_values, values, power_ten );
+  }
+
+
+#if 0
+
+  FT_LOCAL_DEF( FT_String* )
+  T1_ToString( PS_Parser  parser )
+  {
+    return ps_tostring( &parser->cursor, parser->limit, parser->memory );
+  }
+
+
+  FT_LOCAL_DEF( FT_Bool )
+  T1_ToBool( PS_Parser  parser )
+  {
+    return ps_tobool( &parser->cursor, parser->limit );
+  }
+
+#endif /* 0 */
+
+
+  FT_LOCAL_DEF( void )
+  ps_parser_init( PS_Parser  parser,
+                  FT_Byte*   base,
+                  FT_Byte*   limit,
+                  FT_Memory  memory )
+  {
+    parser->error  = PSaux_Err_Ok;
+    parser->base   = base;
+    parser->limit  = limit;
+    parser->cursor = base;
+    parser->memory = memory;
+    parser->funcs  = ps_parser_funcs;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  ps_parser_done( PS_Parser  parser )
+  {
+    FT_UNUSED( parser );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                            T1 BUILDER                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    t1_builder_init                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given glyph builder.                                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    builder :: A pointer to the glyph builder to initialize.           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: The current face object.                                */
+  /*                                                                       */
+  /*    size    :: The current size object.                                */
+  /*                                                                       */
+  /*    glyph   :: The current glyph object.                               */
+  /*                                                                       */
+  /*    hinting :: Whether hinting should be applied.                      */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  t1_builder_init( T1_Builder    builder,
+                   FT_Face       face,
+                   FT_Size       size,
+                   FT_GlyphSlot  glyph,
+                   FT_Bool       hinting )
+  {
+    builder->parse_state = T1_Parse_Start;
+    builder->load_points = 1;
+
+    builder->face   = face;
+    builder->glyph  = glyph;
+    builder->memory = face->memory;
+
+    if ( glyph )
+    {
+      FT_GlyphLoader  loader = glyph->internal->loader;
+
+
+      builder->loader  = loader;
+      builder->base    = &loader->base.outline;
+      builder->current = &loader->current.outline;
+      FT_GlyphLoader_Rewind( loader );
+
+      builder->hints_globals = size->internal;
+      builder->hints_funcs   = 0;
+
+      if ( hinting )
+        builder->hints_funcs = glyph->internal->glyph_hints;
+    }
+
+    if ( size )
+    {
+      builder->scale_x = size->metrics.x_scale;
+      builder->scale_y = size->metrics.y_scale;
+    }
+
+    builder->pos_x = 0;
+    builder->pos_y = 0;
+
+    builder->left_bearing.x = 0;
+    builder->left_bearing.y = 0;
+    builder->advance.x      = 0;
+    builder->advance.y      = 0;
+
+    builder->funcs = t1_builder_funcs;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    t1_builder_done                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes a given glyph builder.  Its contents can still be used   */
+  /*    after the call, but the function saves important information       */
+  /*    within the corresponding glyph slot.                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    builder :: A pointer to the glyph builder to finalize.             */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  t1_builder_done( T1_Builder  builder )
+  {
+    FT_GlyphSlot  glyph = builder->glyph;
+
+
+    if ( glyph )
+      glyph->outline = *builder->base;
+  }
+
+
+  /* check that there is enough space for `count' more points */
+  FT_LOCAL_DEF( FT_Error )
+  t1_builder_check_points( T1_Builder  builder,
+                           FT_Int      count )
+  {
+    return FT_GlyphLoader_CheckPoints( builder->loader, count, 0 );
+  }
+
+
+  /* add a new point, do not check space */
+  FT_LOCAL_DEF( void )
+  t1_builder_add_point( T1_Builder  builder,
+                        FT_Pos      x,
+                        FT_Pos      y,
+                        FT_Byte     flag )
+  {
+    FT_Outline*  outline = builder->current;
+
+
+    if ( builder->load_points )
+    {
+      FT_Vector*  point   = outline->points + outline->n_points;
+      FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points;
+
+
+      if ( builder->shift )
+      {
+        x >>= 16;
+        y >>= 16;
+      }
+      point->x = x;
+      point->y = y;
+      *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
+
+      builder->last = *point;
+    }
+    outline->n_points++;
+  }
+
+
+  /* check space for a new on-curve point, then add it */
+  FT_LOCAL_DEF( FT_Error )
+  t1_builder_add_point1( T1_Builder  builder,
+                         FT_Pos      x,
+                         FT_Pos      y )
+  {
+    FT_Error  error;
+
+
+    error = t1_builder_check_points( builder, 1 );
+    if ( !error )
+      t1_builder_add_point( builder, x, y, 1 );
+
+    return error;
+  }
+
+
+  /* check space for a new contour, then add it */
+  FT_LOCAL_DEF( FT_Error )
+  t1_builder_add_contour( T1_Builder  builder )
+  {
+    FT_Outline*  outline = builder->current;
+    FT_Error     error;
+
+
+    if ( !builder->load_points )
+    {
+      outline->n_contours++;
+      return PSaux_Err_Ok;
+    }
+
+    error = FT_GlyphLoader_CheckPoints( builder->loader, 0, 1 );
+    if ( !error )
+    {
+      if ( outline->n_contours > 0 )
+        outline->contours[outline->n_contours - 1] =
+          (short)( outline->n_points - 1 );
+
+      outline->n_contours++;
+    }
+
+    return error;
+  }
+
+
+  /* if a path was begun, add its first on-curve point */
+  FT_LOCAL_DEF( FT_Error )
+  t1_builder_start_point( T1_Builder  builder,
+                          FT_Pos      x,
+                          FT_Pos      y )
+  {
+    FT_Error  error = PSaux_Err_Invalid_File_Format;
+
+
+    /* test whether we are building a new contour */
+
+    if ( builder->parse_state == T1_Parse_Have_Path )
+      error = PSaux_Err_Ok;
+    else if ( builder->parse_state == T1_Parse_Have_Moveto )
+    {
+      builder->parse_state = T1_Parse_Have_Path;
+      error = t1_builder_add_contour( builder );
+      if ( !error )
+        error = t1_builder_add_point1( builder, x, y );
+    }
+
+    return error;
+  }
+
+
+  /* close the current contour */
+  FT_LOCAL_DEF( void )
+  t1_builder_close_contour( T1_Builder  builder )
+  {
+    FT_Outline*  outline = builder->current;
+
+
+    /* XXXX: We must not include the last point in the path if it */
+    /*       is located on the first point.                       */
+    if ( outline->n_points > 1 )
+    {
+      FT_Int      first   = 0;
+      FT_Vector*  p1      = outline->points + first;
+      FT_Vector*  p2      = outline->points + outline->n_points - 1;
+      FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points - 1;
+
+
+      if ( outline->n_contours > 1 )
+      {
+        first = outline->contours[outline->n_contours - 2] + 1;
+        p1    = outline->points + first;
+      }
+
+      /* `delete' last point only if it coincides with the first */
+      /* point and it is not a control point (which can happen). */
+      if ( p1->x == p2->x && p1->y == p2->y )
+        if ( *control == FT_CURVE_TAG_ON )
+          outline->n_points--;
+    }
+
+    if ( outline->n_contours > 0 )
+      outline->contours[outline->n_contours - 1] =
+        (short)( outline->n_points - 1 );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                            OTHER                              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( void )
+  t1_decrypt( FT_Byte*   buffer,
+              FT_Offset  length,
+              FT_UShort  seed )
+  {
+    while ( length > 0 )
+    {
+      FT_Byte  plain;
+
+
+      plain     = (FT_Byte)( *buffer ^ ( seed >> 8 ) );
+      seed      = (FT_UShort)( ( *buffer + seed ) * 52845U + 22719 );
+      *buffer++ = plain;
+      length--;
+    }
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/psobjs.h b/nx-X11/extras/freetype2/src/psaux/psobjs.h
new file mode 100644
index 000000000..c2cbf2c79
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/psobjs.h
@@ -0,0 +1,212 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psobjs.h                                                               */
+/*                                                                         */
+/*    Auxiliary functions for PostScript fonts (specification).            */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 __PSOBJS_H__
+#define __PSOBJS_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                             T1_TABLE                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_CALLBACK_TABLE
+  const PS_Table_FuncsRec    ps_table_funcs;
+
+  FT_CALLBACK_TABLE
+  const PS_Parser_FuncsRec   ps_parser_funcs;
+
+  FT_CALLBACK_TABLE
+  const T1_Builder_FuncsRec  t1_builder_funcs;
+
+
+  FT_LOCAL( FT_Error )
+  ps_table_new( PS_Table   table,
+                FT_Int     count,
+                FT_Memory  memory );
+
+  FT_LOCAL( FT_Error )
+  ps_table_add( PS_Table    table,
+                FT_Int      idx,
+                void*       object,
+                FT_PtrDist  length );
+
+  FT_LOCAL( void )
+  ps_table_done( PS_Table  table );
+
+
+  FT_LOCAL( void )
+  ps_table_release( PS_Table  table );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                            T1 PARSER                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL( void )
+  ps_parser_skip_spaces( PS_Parser  parser );
+
+  FT_LOCAL( void )
+  ps_parser_skip_PS_token( PS_Parser  parser );
+
+  FT_LOCAL( void )
+  ps_parser_to_token( PS_Parser  parser,
+                      T1_Token   token );
+
+  FT_LOCAL( void )
+  ps_parser_to_token_array( PS_Parser  parser,
+                            T1_Token   tokens,
+                            FT_UInt    max_tokens,
+                            FT_Int*    pnum_tokens );
+
+  FT_LOCAL( FT_Error )
+  ps_parser_load_field( PS_Parser       parser,
+                        const T1_Field  field,
+                        void**          objects,
+                        FT_UInt         max_objects,
+                        FT_ULong*       pflags );
+
+  FT_LOCAL( FT_Error )
+  ps_parser_load_field_table( PS_Parser       parser,
+                              const T1_Field  field,
+                              void**          objects,
+                              FT_UInt         max_objects,
+                              FT_ULong*       pflags );
+
+  FT_LOCAL( FT_Long )
+  ps_parser_to_int( PS_Parser  parser );
+
+
+  FT_LOCAL( FT_Error )
+  ps_parser_to_bytes( PS_Parser  parser,
+                      FT_Byte*   bytes,
+                      FT_Long    max_bytes,
+                      FT_Long*   pnum_bytes,
+                      FT_Bool    delimiters );
+
+
+  FT_LOCAL( FT_Fixed )
+  ps_parser_to_fixed( PS_Parser  parser,
+                      FT_Int     power_ten );
+
+
+  FT_LOCAL( FT_Int )
+  ps_parser_to_coord_array( PS_Parser  parser,
+                            FT_Int     max_coords,
+                            FT_Short*  coords );
+
+  FT_LOCAL( FT_Int )
+  ps_parser_to_fixed_array( PS_Parser  parser,
+                            FT_Int     max_values,
+                            FT_Fixed*  values,
+                            FT_Int     power_ten );
+
+
+  FT_LOCAL( void )
+  ps_parser_init( PS_Parser  parser,
+                  FT_Byte*   base,
+                  FT_Byte*   limit,
+                  FT_Memory  memory );
+
+  FT_LOCAL( void )
+  ps_parser_done( PS_Parser  parser );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                            T1 BUILDER                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL( void )
+  t1_builder_init( T1_Builder    builder,
+                   FT_Face       face,
+                   FT_Size       size,
+                   FT_GlyphSlot  glyph,
+                   FT_Bool       hinting );
+
+  FT_LOCAL( void )
+  t1_builder_done( T1_Builder  builder );
+
+  FT_LOCAL( FT_Error )
+  t1_builder_check_points( T1_Builder  builder,
+                           FT_Int      count );
+
+  FT_LOCAL( void )
+  t1_builder_add_point( T1_Builder  builder,
+                        FT_Pos      x,
+                        FT_Pos      y,
+                        FT_Byte     flag );
+
+  FT_LOCAL( FT_Error )
+  t1_builder_add_point1( T1_Builder  builder,
+                         FT_Pos      x,
+                         FT_Pos      y );
+
+  FT_LOCAL( FT_Error )
+  t1_builder_add_contour( T1_Builder  builder );
+
+
+  FT_LOCAL( FT_Error )
+  t1_builder_start_point( T1_Builder  builder,
+                          FT_Pos      x,
+                          FT_Pos      y );
+
+
+  FT_LOCAL( void )
+  t1_builder_close_contour( T1_Builder  builder );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                            OTHER                              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL( void )
+  t1_decrypt( FT_Byte*   buffer,
+              FT_Offset  length,
+              FT_UShort  seed );
+
+
+FT_END_HEADER
+
+#endif /* __PSOBJS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/rules.mk b/nx-X11/extras/freetype2/src/psaux/rules.mk
new file mode 100644
index 000000000..7338d3657
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/rules.mk
@@ -0,0 +1,71 @@
+#
+# FreeType 2 PSaux driver configuration rules
+#
+
+
+# Copyright 1996-2000, 2002, 2003 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.
+
+
+# PSAUX driver directory
+#
+PSAUX_DIR := $(SRC_DIR)/psaux
+
+
+# compilation flags for the driver
+#
+PSAUX_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(PSAUX_DIR))
+
+
+# PSAUX driver sources (i.e., C files)
+#
+PSAUX_DRV_SRC := $(PSAUX_DIR)/psobjs.c   \
+                 $(PSAUX_DIR)/t1decode.c \
+                 $(PSAUX_DIR)/t1cmap.c   \
+                 $(PSAUX_DIR)/psauxmod.c
+
+# PSAUX driver headers
+#
+PSAUX_DRV_H := $(PSAUX_DRV_SRC:%c=%h)  \
+               $(PSAUX_DIR)/psauxerr.h
+
+
+# PSAUX driver object(s)
+#
+#   PSAUX_DRV_OBJ_M is used during `multi' builds.
+#   PSAUX_DRV_OBJ_S is used during `single' builds.
+#
+PSAUX_DRV_OBJ_M := $(PSAUX_DRV_SRC:$(PSAUX_DIR)/%.c=$(OBJ_DIR)/%.$O)
+PSAUX_DRV_OBJ_S := $(OBJ_DIR)/psaux.$O
+
+# PSAUX driver source file for single build
+#
+PSAUX_DRV_SRC_S := $(PSAUX_DIR)/psaux.c
+
+
+# PSAUX driver - single object
+#
+$(PSAUX_DRV_OBJ_S): $(PSAUX_DRV_SRC_S) $(PSAUX_DRV_SRC) \
+                   $(FREETYPE_H) $(PSAUX_DRV_H)
+	$(PSAUX_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(PSAUX_DRV_SRC_S))
+
+
+# PSAUX driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(PSAUX_DIR)/%.c $(FREETYPE_H) $(PSAUX_DRV_H)
+	$(PSAUX_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(PSAUX_DRV_OBJ_S)
+DRV_OBJS_M += $(PSAUX_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/psaux/t1cmap.c b/nx-X11/extras/freetype2/src/psaux/t1cmap.c
new file mode 100644
index 000000000..dcd99be49
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/t1cmap.c
@@ -0,0 +1,456 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1cmap.c                                                               */
+/*                                                                         */
+/*    Type 1 character map support (body).                                 */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 "t1cmap.h"
+
+#include FT_INTERNAL_DEBUG_H
+
+#include "psauxerr.h"
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****          TYPE1 STANDARD (AND EXPERT) ENCODING CMAPS           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  t1_cmap_std_init( T1_CMapStd  cmap,
+                    FT_Int      is_expert )
+  {
+    T1_Face             face    = (T1_Face)FT_CMAP_FACE( cmap );
+    FT_Service_PsCMaps  psnames = (FT_Service_PsCMaps)face->psnames;
+
+
+    cmap->num_glyphs    = face->type1.num_glyphs;
+    cmap->glyph_names   = (const char* const*)face->type1.glyph_names;
+    cmap->sid_to_string = psnames->adobe_std_strings;
+    cmap->code_to_sid   = is_expert ? psnames->adobe_expert_encoding
+                                    : psnames->adobe_std_encoding;
+
+    FT_ASSERT( cmap->code_to_sid != NULL );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  t1_cmap_std_done( T1_CMapStd  cmap )
+  {
+    cmap->num_glyphs    = 0;
+    cmap->glyph_names   = NULL;
+    cmap->sid_to_string = NULL;
+    cmap->code_to_sid   = NULL;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_std_char_index( T1_CMapStd  cmap,
+                          FT_UInt32   char_code )
+  {
+    FT_UInt  result = 0;
+
+
+    if ( char_code < 256 )
+    {
+      FT_UInt      code, n;
+      const char*  glyph_name;
+
+
+      /* convert character code to Adobe SID string */
+      code       = cmap->code_to_sid[char_code];
+      glyph_name = cmap->sid_to_string( code );
+
+      /* look for the corresponding glyph name */
+      for ( n = 0; n < cmap->num_glyphs; n++ )
+      {
+        const char* gname = cmap->glyph_names[n];
+
+
+        if ( gname && gname[0] == glyph_name[0]  &&
+             ft_strcmp( gname, glyph_name ) == 0 )
+        {
+          result = n;
+          break;
+        }
+      }
+    }
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_std_char_next( T1_CMapStd   cmap,
+                         FT_UInt32   *pchar_code )
+  {
+    FT_UInt    result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+    while ( char_code < 256 )
+    {
+      result = t1_cmap_std_char_index( cmap, char_code );
+      if ( result != 0 )
+        goto Exit;
+
+      char_code++;
+    }
+    char_code = 0;
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  t1_cmap_standard_init( T1_CMapStd  cmap )
+  {
+    t1_cmap_std_init( cmap, 0 );
+    return 0;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  t1_cmap_standard_class_rec =
+  {
+    sizeof ( T1_CMapStdRec ),
+
+    (FT_CMap_InitFunc)     t1_cmap_standard_init,
+    (FT_CMap_DoneFunc)     t1_cmap_std_done,
+    (FT_CMap_CharIndexFunc)t1_cmap_std_char_index,
+    (FT_CMap_CharNextFunc) t1_cmap_std_char_next
+  };
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  t1_cmap_expert_init( T1_CMapStd  cmap )
+  {
+    t1_cmap_std_init( cmap, 1 );
+    return 0;
+  }
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  t1_cmap_expert_class_rec =
+  {
+    sizeof ( T1_CMapStdRec ),
+
+    (FT_CMap_InitFunc)     t1_cmap_expert_init,
+    (FT_CMap_DoneFunc)     t1_cmap_std_done,
+    (FT_CMap_CharIndexFunc)t1_cmap_std_char_index,
+    (FT_CMap_CharNextFunc) t1_cmap_std_char_next
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    TYPE1 CUSTOM ENCODING CMAP                 *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  t1_cmap_custom_init( T1_CMapCustom  cmap )
+  {
+    T1_Face      face     = (T1_Face)FT_CMAP_FACE( cmap );
+    T1_Encoding  encoding = &face->type1.encoding;
+
+
+    cmap->first   = encoding->code_first;
+    cmap->count   = (FT_UInt)( encoding->code_last - cmap->first + 1 );
+    cmap->indices = encoding->char_index;
+
+    FT_ASSERT( cmap->indices != NULL );
+    FT_ASSERT( encoding->code_first <= encoding->code_last );
+
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  t1_cmap_custom_done( T1_CMapCustom  cmap )
+  {
+    cmap->indices = NULL;
+    cmap->first   = 0;
+    cmap->count   = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_custom_char_index( T1_CMapCustom  cmap,
+                             FT_UInt32      char_code )
+  {
+    FT_UInt    result = 0;
+
+
+    if ( ( char_code >= cmap->first )                  &&
+         ( char_code < ( cmap->first + cmap->count ) ) )
+      result = cmap->indices[char_code];
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_custom_char_next( T1_CMapCustom  cmap,
+                            FT_UInt32     *pchar_code )
+  {
+    FT_UInt    result = 0;
+    FT_UInt32  char_code = *pchar_code;
+
+
+    ++char_code;
+
+    if ( char_code < cmap->first )
+      char_code = cmap->first;
+
+    for ( ; char_code < ( cmap->first + cmap->count ); char_code++ )
+    {
+      result = cmap->indices[char_code];
+      if ( result != 0 )
+        goto Exit;
+    }
+
+    char_code = 0;
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  t1_cmap_custom_class_rec =
+  {
+    sizeof ( T1_CMapCustomRec ),
+
+    (FT_CMap_InitFunc)     t1_cmap_custom_init,
+    (FT_CMap_DoneFunc)     t1_cmap_custom_done,
+    (FT_CMap_CharIndexFunc)t1_cmap_custom_char_index,
+    (FT_CMap_CharNextFunc) t1_cmap_custom_char_next
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****            TYPE1 SYNTHETIC UNICODE ENCODING CMAP              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_CALLBACK_DEF( FT_Int )
+  t1_cmap_uni_pair_compare( const void*  pair1,
+                            const void*  pair2 )
+  {
+    FT_UInt32  u1 = ((T1_CMapUniPair)pair1)->unicode;
+    FT_UInt32  u2 = ((T1_CMapUniPair)pair2)->unicode;
+
+
+    if ( u1 < u2 )
+      return -1;
+
+    if ( u1 > u2 )
+      return +1;
+
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  t1_cmap_unicode_init( T1_CMapUnicode  cmap )
+  {
+    FT_Error            error;
+    FT_UInt             count;
+    T1_Face             face    = (T1_Face)FT_CMAP_FACE( cmap );
+    FT_Memory           memory  = FT_FACE_MEMORY( face );
+    FT_Service_PsCMaps  psnames = (FT_Service_PsCMaps)face->psnames;
+
+
+    cmap->num_pairs = 0;
+    cmap->pairs     = NULL;
+
+    count = face->type1.num_glyphs;
+
+    if ( !FT_NEW_ARRAY( cmap->pairs, count ) )
+    {
+      FT_UInt         n, new_count;
+      T1_CMapUniPair  pair;
+      FT_UInt32       uni_code;
+
+
+      pair = cmap->pairs;
+      for ( n = 0; n < count; n++ )
+      {
+        const char*  gname = face->type1.glyph_names[n];
+
+
+        /* build unsorted pair table by matching glyph names */
+        if ( gname )
+        {
+          uni_code = psnames->unicode_value( gname );
+
+          if ( uni_code != 0 )
+          {
+            pair->unicode = uni_code;
+            pair->gindex  = n;
+            pair++;
+          }
+        }
+      }
+
+      new_count = (FT_UInt)( pair - cmap->pairs );
+      if ( new_count == 0 )
+      {
+        /* there are no unicode characters in here! */
+        FT_FREE( cmap->pairs );
+        error = PSaux_Err_Invalid_Argument;
+      }
+      else
+      {
+        /* re-allocate if the new array is much smaller than the original */
+        /* one                                                            */
+        if ( new_count != count && new_count < count / 2 )
+        {
+          (void)FT_RENEW_ARRAY( cmap->pairs, count, new_count );
+          error = 0;
+        }
+
+        /* sort the pairs table to allow efficient binary searches */
+        ft_qsort( cmap->pairs,
+                  new_count,
+                  sizeof ( T1_CMapUniPairRec ),
+                  t1_cmap_uni_pair_compare );
+
+        cmap->num_pairs = new_count;
+      }
+    }
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  t1_cmap_unicode_done( T1_CMapUnicode  cmap )
+  {
+    FT_Face    face   = FT_CMAP_FACE(cmap);
+    FT_Memory  memory = FT_FACE_MEMORY(face);
+
+    FT_FREE( cmap->pairs );
+    cmap->num_pairs = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_unicode_char_index( T1_CMapUnicode  cmap,
+                              FT_UInt32       char_code )
+  {
+    FT_UInt         min = 0;
+    FT_UInt         max = cmap->num_pairs;
+    FT_UInt         mid;
+    T1_CMapUniPair  pair;
+
+
+    while ( min < max )
+    {
+      mid  = min + ( max - min ) / 2;
+      pair = cmap->pairs + mid;
+
+      if ( pair->unicode == char_code )
+        return pair->gindex;
+
+      if ( pair->unicode < char_code )
+        min = mid + 1;
+      else
+        max = mid;
+    }
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_unicode_char_next( T1_CMapUnicode  cmap,
+                             FT_UInt32      *pchar_code )
+  {
+    FT_UInt    result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+  Restart:
+    {
+      FT_UInt         min = 0;
+      FT_UInt         max = cmap->num_pairs;
+      FT_UInt         mid;
+      T1_CMapUniPair  pair;
+
+
+      while ( min < max )
+      {
+        mid  = min + ( ( max - min ) >> 1 );
+        pair = cmap->pairs + mid;
+
+        if ( pair->unicode == char_code )
+        {
+          result = pair->gindex;
+          if ( result != 0 )
+            goto Exit;
+
+          char_code++;
+          goto Restart;
+        }
+
+        if ( pair->unicode < char_code )
+          min = mid+1;
+        else
+          max = mid;
+      }
+
+      /* we didn't find it, but we have a pair just above it */
+      char_code = 0;
+
+      if ( min < cmap->num_pairs )
+      {
+        pair   = cmap->pairs + min;
+        result = pair->gindex;
+        if ( result != 0 )
+          char_code = pair->unicode;
+      }
+    }
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  t1_cmap_unicode_class_rec =
+  {
+    sizeof ( T1_CMapUnicodeRec ),
+
+    (FT_CMap_InitFunc)     t1_cmap_unicode_init,
+    (FT_CMap_DoneFunc)     t1_cmap_unicode_done,
+    (FT_CMap_CharIndexFunc)t1_cmap_unicode_char_index,
+    (FT_CMap_CharNextFunc) t1_cmap_unicode_char_next
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/t1cmap.h b/nx-X11/extras/freetype2/src/psaux/t1cmap.h
new file mode 100644
index 000000000..aa93d746c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/t1cmap.h
@@ -0,0 +1,123 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1cmap.h                                                               */
+/*                                                                         */
+/*    Type 1 character map support (specification).                        */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 __T1CMAP_H__
+#define __T1CMAP_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****          TYPE1 STANDARD (AND EXPERT) ENCODING CMAPS           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* standard (and expert) encoding cmaps */
+  typedef struct T1_CMapStdRec_*  T1_CMapStd;
+
+  typedef struct  T1_CMapStdRec_
+  {
+    FT_CMapRec                 cmap;
+
+    const FT_UShort*           code_to_sid;
+    PS_Adobe_Std_Strings_Func  sid_to_string;
+
+    FT_UInt                    num_glyphs;
+    const char* const*         glyph_names;
+
+  } T1_CMapStdRec;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  t1_cmap_standard_class_rec;
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  t1_cmap_expert_class_rec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  TYPE1 CUSTOM ENCODING CMAP                   *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct T1_CMapCustomRec_*  T1_CMapCustom;
+
+  typedef struct  T1_CMapCustomRec_
+  {
+    FT_CMapRec  cmap;
+    FT_UInt     first;
+    FT_UInt     count;
+    FT_UShort*  indices;
+
+  } T1_CMapCustomRec;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  t1_cmap_custom_class_rec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****             TYPE1 SYNTHETIC UNICODE ENCODING CMAP             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* unicode (syntehtic) cmaps */
+  typedef struct T1_CMapUnicodeRec_*  T1_CMapUnicode;
+
+  typedef struct  T1_CMapUniPairRec_
+  {
+    FT_UInt32  unicode;
+    FT_UInt    gindex;
+
+  } T1_CMapUniPairRec, *T1_CMapUniPair;
+
+
+  typedef struct  T1_CMapUnicodeRec_
+  {
+    FT_CMapRec      cmap;
+    FT_UInt         num_pairs;
+    T1_CMapUniPair  pairs;
+
+  } T1_CMapUnicodeRec;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  t1_cmap_unicode_class_rec;
+
+ /* */
+
+
+FT_END_HEADER
+
+#endif /* __T1CMAP_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/t1decode.c b/nx-X11/extras/freetype2/src/psaux/t1decode.c
new file mode 100644
index 000000000..c2adf480c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/t1decode.c
@@ -0,0 +1,1165 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1decode.c                                                             */
+/*                                                                         */
+/*    PostScript Type 1 decoding routines (body).                          */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 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_POSTSCRIPT_HINTS_H
+#include FT_OUTLINE_H
+
+#include "t1decode.h"
+#include "psobjs.h"
+
+#include "psauxerr.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_t1decode
+
+
+  typedef enum  T1_Operator_
+  {
+    op_none = 0,
+    op_endchar,
+    op_hsbw,
+    op_seac,
+    op_sbw,
+    op_closepath,
+    op_hlineto,
+    op_hmoveto,
+    op_hvcurveto,
+    op_rlineto,
+    op_rmoveto,
+    op_rrcurveto,
+    op_vhcurveto,
+    op_vlineto,
+    op_vmoveto,
+    op_dotsection,
+    op_hstem,
+    op_hstem3,
+    op_vstem,
+    op_vstem3,
+    op_div,
+    op_callothersubr,
+    op_callsubr,
+    op_pop,
+    op_return,
+    op_setcurrentpoint,
+
+    op_max    /* never remove this one */
+
+  } T1_Operator;
+
+
+  static
+  const FT_Int  t1_args_count[op_max] =
+  {
+    0, /* none */
+    0, /* endchar */
+    2, /* hsbw */
+    5, /* seac */
+    4, /* sbw */
+    0, /* closepath */
+    1, /* hlineto */
+    1, /* hmoveto */
+    4, /* hvcurveto */
+    2, /* rlineto */
+    2, /* rmoveto */
+    6, /* rrcurveto */
+    4, /* vhcurveto */
+    1, /* vlineto */
+    1, /* vmoveto */
+    0, /* dotsection */
+    2, /* hstem */
+    6, /* hstem3 */
+    2, /* vstem */
+    6, /* vstem3 */
+    2, /* div */
+   -1, /* callothersubr */
+    1, /* callsubr */
+    0, /* pop */
+    0, /* return */
+    2  /* setcurrentpoint */
+  };
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    t1_lookup_glyph_by_stdcharcode                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Looks up a given glyph by its StandardEncoding charcode.  Used to  */
+  /*    implement the SEAC Type 1 operator.                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face     :: The current face object.                               */
+  /*                                                                       */
+  /*    charcode :: The character code to look for.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A glyph index in the font face.  Returns -1 if the corresponding   */
+  /*    glyph wasn't found.                                                */
+  /*                                                                       */
+  static FT_Int
+  t1_lookup_glyph_by_stdcharcode( T1_Decoder  decoder,
+                                  FT_Int      charcode )
+  {
+    FT_UInt             n;
+    const FT_String*    glyph_name;
+    FT_Service_PsCMaps  psnames = decoder->psnames;
+
+
+    /* check range of standard char code */
+    if ( charcode < 0 || charcode > 255 )
+      return -1;
+
+    glyph_name = psnames->adobe_std_strings(
+                   psnames->adobe_std_encoding[charcode]);
+
+    for ( n = 0; n < decoder->num_glyphs; n++ )
+    {
+      FT_String*  name = (FT_String*)decoder->glyph_names[n];
+
+
+      if ( name && name[0] == glyph_name[0]  &&
+           ft_strcmp( name, glyph_name ) == 0 )
+        return n;
+    }
+
+    return -1;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    t1operator_seac                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Implements the `seac' Type 1 operator for a Type 1 decoder.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    decoder :: The current CID decoder.                                */
+  /*                                                                       */
+  /*    asb     :: The accent's side bearing.                              */
+  /*                                                                       */
+  /*    adx     :: The horizontal offset of the accent.                    */
+  /*                                                                       */
+  /*    ady     :: The vertical offset of the accent.                      */
+  /*                                                                       */
+  /*    bchar   :: The base character's StandardEncoding charcode.         */
+  /*                                                                       */
+  /*    achar   :: The accent character's StandardEncoding charcode.       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  t1operator_seac( T1_Decoder  decoder,
+                   FT_Pos      asb,
+                   FT_Pos      adx,
+                   FT_Pos      ady,
+                   FT_Int      bchar,
+                   FT_Int      achar )
+  {
+    FT_Error     error;
+    FT_Int       bchar_index, achar_index;
+#if 0
+    FT_Int       n_base_points;
+    FT_Outline*  base = decoder->builder.base;
+#endif
+    FT_Vector    left_bearing, advance;
+
+
+    /* seac weirdness */
+    adx += decoder->builder.left_bearing.x;
+
+    /* `glyph_names' is set to 0 for CID fonts which do not */
+    /* include an encoding.  How can we deal with these?    */
+    if ( decoder->glyph_names == 0 )
+    {
+      FT_ERROR(( "t1operator_seac:" ));
+      FT_ERROR(( " glyph names table not available in this font!\n" ));
+      return PSaux_Err_Syntax_Error;
+    }
+
+    bchar_index = t1_lookup_glyph_by_stdcharcode( decoder, bchar );
+    achar_index = t1_lookup_glyph_by_stdcharcode( decoder, achar );
+
+    if ( bchar_index < 0 || achar_index < 0 )
+    {
+      FT_ERROR(( "t1operator_seac:" ));
+      FT_ERROR(( " invalid seac character code arguments\n" ));
+      return PSaux_Err_Syntax_Error;
+    }
+
+    /* if we are trying to load a composite glyph, do not load the */
+    /* accent character and return the array of subglyphs.         */
+    if ( decoder->builder.no_recurse )
+    {
+      FT_GlyphSlot    glyph  = (FT_GlyphSlot)decoder->builder.glyph;
+      FT_GlyphLoader  loader = glyph->internal->loader;
+      FT_SubGlyph     subg;
+
+
+      /* reallocate subglyph array if necessary */
+      error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 );
+      if ( error )
+        goto Exit;
+
+      subg = loader->current.subglyphs;
+
+      /* subglyph 0 = base character */
+      subg->index = bchar_index;
+      subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
+                    FT_SUBGLYPH_FLAG_USE_MY_METRICS;
+      subg->arg1  = 0;
+      subg->arg2  = 0;
+      subg++;
+
+      /* subglyph 1 = accent character */
+      subg->index = achar_index;
+      subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
+      subg->arg1  = (FT_Int)( adx - asb );
+      subg->arg2  = (FT_Int)ady;
+
+      /* set up remaining glyph fields */
+      glyph->num_subglyphs = 2;
+      glyph->subglyphs     = loader->base.subglyphs;
+      glyph->format        = FT_GLYPH_FORMAT_COMPOSITE;
+
+      loader->current.num_subglyphs = 2;
+      goto Exit;
+    }
+
+    /* First load `bchar' in builder */
+    /* now load the unscaled outline */
+
+    FT_GlyphLoader_Prepare( decoder->builder.loader );  /* prepare loader */
+
+    error = t1_decoder_parse_glyph( decoder, bchar_index );
+    if ( error )
+      goto Exit;
+
+    /* save the left bearing and width of the base character */
+    /* as they will be erased by the next load.              */
+
+    left_bearing = decoder->builder.left_bearing;
+    advance      = decoder->builder.advance;
+
+    decoder->builder.left_bearing.x = 0;
+    decoder->builder.left_bearing.y = 0;
+
+    decoder->builder.pos_x = adx - asb;
+    decoder->builder.pos_y = ady;
+
+    /* Now load `achar' on top of */
+    /* the base outline           */
+    error = t1_decoder_parse_glyph( decoder, achar_index );
+    if ( error )
+      goto Exit;
+
+    /* restore the left side bearing and   */
+    /* advance width of the base character */
+
+    decoder->builder.left_bearing = left_bearing;
+    decoder->builder.advance      = advance;
+
+    decoder->builder.pos_x = 0;
+    decoder->builder.pos_y = 0;
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    t1_decoder_parse_charstrings                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Parses a given Type 1 charstrings program.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    decoder         :: The current Type 1 decoder.                     */
+  /*                                                                       */
+  /*    charstring_base :: The base address of the charstring stream.      */
+  /*                                                                       */
+  /*    charstring_len  :: The length in bytes of the charstring stream.   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  t1_decoder_parse_charstrings( T1_Decoder  decoder,
+                                FT_Byte*    charstring_base,
+                                FT_UInt     charstring_len )
+  {
+    FT_Error         error;
+    T1_Decoder_Zone  zone;
+    FT_Byte*         ip;
+    FT_Byte*         limit;
+    T1_Builder       builder = &decoder->builder;
+    FT_Pos           x, y, orig_x, orig_y;
+
+    T1_Hints_Funcs   hinter;
+
+
+    /* we don't want to touch the source code -- use macro trick */
+#define start_point    t1_builder_start_point
+#define check_points   t1_builder_check_points
+#define add_point      t1_builder_add_point
+#define add_point1     t1_builder_add_point1
+#define add_contour    t1_builder_add_contour
+#define close_contour  t1_builder_close_contour
+
+    /* First of all, initialize the decoder */
+    decoder->top  = decoder->stack;
+    decoder->zone = decoder->zones;
+    zone          = decoder->zones;
+
+    builder->parse_state = T1_Parse_Start;
+
+    hinter = (T1_Hints_Funcs)builder->hints_funcs;
+
+    zone->base           = charstring_base;
+    limit = zone->limit  = charstring_base + charstring_len;
+    ip    = zone->cursor = zone->base;
+
+    error = PSaux_Err_Ok;
+
+    x = orig_x = builder->pos_x;
+    y = orig_y = builder->pos_y;
+
+    /* begin hints recording session, if any */
+    if ( hinter )
+      hinter->open( hinter->hints );
+
+    /* now, execute loop */
+    while ( ip < limit )
+    {
+      FT_Long*     top   = decoder->top;
+      T1_Operator  op    = op_none;
+      FT_Long      value = 0;
+
+
+      /*********************************************************************/
+      /*                                                                   */
+      /* Decode operator or operand                                        */
+      /*                                                                   */
+      /*                                                                   */
+
+      /* first of all, decompress operator or value */
+      switch ( *ip++ )
+      {
+      case 1:
+        op = op_hstem;
+        break;
+
+      case 3:
+        op = op_vstem;
+        break;
+      case 4:
+        op = op_vmoveto;
+        break;
+      case 5:
+        op = op_rlineto;
+        break;
+      case 6:
+        op = op_hlineto;
+        break;
+      case 7:
+        op = op_vlineto;
+        break;
+      case 8:
+        op = op_rrcurveto;
+        break;
+      case 9:
+        op = op_closepath;
+        break;
+      case 10:
+        op = op_callsubr;
+        break;
+      case 11:
+        op = op_return;
+        break;
+
+      case 13:
+        op = op_hsbw;
+        break;
+      case 14:
+        op = op_endchar;
+        break;
+
+      case 15:          /* undocumented, obsolete operator */
+        op = op_none;
+        break;
+
+      case 21:
+        op = op_rmoveto;
+        break;
+      case 22:
+        op = op_hmoveto;
+        break;
+
+      case 30:
+        op = op_vhcurveto;
+        break;
+      case 31:
+        op = op_hvcurveto;
+        break;
+
+      case 12:
+        if ( ip > limit )
+        {
+          FT_ERROR(( "t1_decoder_parse_charstrings: "
+                     "invalid escape (12+EOF)\n" ));
+          goto Syntax_Error;
+        }
+
+        switch ( *ip++ )
+        {
+        case 0:
+          op = op_dotsection;
+          break;
+        case 1:
+          op = op_vstem3;
+          break;
+        case 2:
+          op = op_hstem3;
+          break;
+        case 6:
+          op = op_seac;
+          break;
+        case 7:
+          op = op_sbw;
+          break;
+        case 12:
+          op = op_div;
+          break;
+        case 16:
+          op = op_callothersubr;
+          break;
+        case 17:
+          op = op_pop;
+          break;
+        case 33:
+          op = op_setcurrentpoint;
+          break;
+
+        default:
+          FT_ERROR(( "t1_decoder_parse_charstrings: "
+                     "invalid escape (12+%d)\n",
+                     ip[-1] ));
+          goto Syntax_Error;
+        }
+        break;
+
+      case 255:    /* four bytes integer */
+        if ( ip + 4 > limit )
+        {
+          FT_ERROR(( "t1_decoder_parse_charstrings: "
+                     "unexpected EOF in integer\n" ));
+          goto Syntax_Error;
+        }
+
+        value = (FT_Int32)( ((FT_Long)ip[0] << 24) |
+                            ((FT_Long)ip[1] << 16) |
+                            ((FT_Long)ip[2] << 8 ) |
+                                      ip[3] );
+        ip += 4;
+        break;
+
+      default:
+        if ( ip[-1] >= 32 )
+        {
+          if ( ip[-1] < 247 )
+            value = (FT_Long)ip[-1] - 139;
+          else
+          {
+            if ( ++ip > limit )
+            {
+              FT_ERROR(( "t1_decoder_parse_charstrings: " ));
+              FT_ERROR(( "unexpected EOF in integer\n" ));
+              goto Syntax_Error;
+            }
+
+            if ( ip[-2] < 251 )
+              value =  ( ( (FT_Long)ip[-2] - 247 ) << 8 ) + ip[-1] + 108;
+            else
+              value = -( ( ( (FT_Long)ip[-2] - 251 ) << 8 ) + ip[-1] + 108 );
+          }
+        }
+        else
+        {
+          FT_ERROR(( "t1_decoder_parse_charstrings: "
+                     "invalid byte (%d)\n", ip[-1] ));
+          goto Syntax_Error;
+        }
+      }
+
+      /*********************************************************************/
+      /*                                                                   */
+      /*  Push value on stack, or process operator                         */
+      /*                                                                   */
+      /*                                                                   */
+      if ( op == op_none )
+      {
+        if ( top - decoder->stack >= T1_MAX_CHARSTRINGS_OPERANDS )
+        {
+          FT_ERROR(( "t1_decoder_parse_charstrings: stack overflow!\n" ));
+          goto Syntax_Error;
+        }
+
+        FT_TRACE4(( " %ld", value ));
+
+        *top++       = value;
+        decoder->top = top;
+      }
+      else if ( op == op_callothersubr )  /* callothersubr */
+      {
+        FT_TRACE4(( " callothersubr" ));
+
+        if ( top - decoder->stack < 2 )
+          goto Stack_Underflow;
+
+        top -= 2;
+        switch ( (FT_Int)top[1] )
+        {
+        case 1:                     /* start flex feature */
+          if ( top[0] != 0 )
+            goto Unexpected_OtherSubr;
+
+          decoder->flex_state        = 1;
+          decoder->num_flex_vectors  = 0;
+          if ( start_point( builder, x, y ) ||
+               check_points( builder, 6 )   )
+            goto Fail;
+          break;
+
+        case 2:                     /* add flex vectors */
+          {
+            FT_Int  idx;
+
+
+            if ( top[0] != 0 )
+              goto Unexpected_OtherSubr;
+
+            /* note that we should not add a point for index 0; */
+            /* this will move our current position to the flex  */
+            /* point without adding any point to the outline    */
+            idx = decoder->num_flex_vectors++;
+            if ( idx > 0 && idx < 7 )
+              add_point( builder,
+                         x,
+                         y,
+                         (FT_Byte)( idx == 3 || idx == 6 ) );
+          }
+          break;
+
+        case 0:                     /* end flex feature */
+          if ( top[0] != 3 )
+            goto Unexpected_OtherSubr;
+
+          if ( decoder->flex_state       == 0 ||
+               decoder->num_flex_vectors != 7 )
+          {
+            FT_ERROR(( "t1_decoder_parse_charstrings: "
+                       "unexpected flex end\n" ));
+            goto Syntax_Error;
+          }
+
+          /* now consume the remaining `pop pop setcurpoint' */
+          if ( ip + 6 > limit ||
+               ip[0] != 12 || ip[1] != 17 || /* pop */
+               ip[2] != 12 || ip[3] != 17 || /* pop */
+               ip[4] != 12 || ip[5] != 33 )  /* setcurpoint */
+          {
+            FT_ERROR(( "t1_decoder_parse_charstrings: "
+                       "invalid flex charstring\n" ));
+            goto Syntax_Error;
+          }
+
+          ip += 6;
+          decoder->flex_state = 0;
+          break;
+
+        case 3:                     /* change hints */
+          if ( top[0] != 1 )
+            goto Unexpected_OtherSubr;
+
+          /* eat the following `pop' */
+          if ( ip + 2 > limit )
+          {
+            FT_ERROR(( "t1_decoder_parse_charstrings: "
+                       "invalid escape (12+%d)\n", ip[-1] ));
+            goto Syntax_Error;
+          }
+
+          if ( ip[0] != 12 || ip[1] != 17 )
+          {
+            FT_ERROR(( "t1_decoder_parse_charstrings: " ));
+            FT_ERROR(( "`pop' expected, found (%d %d)\n", ip[0], ip[1] ));
+            goto Syntax_Error;
+          }
+          ip += 2;
+
+          if ( hinter )
+            hinter->reset( hinter->hints, builder->current->n_points );
+
+          break;
+
+        case 12:
+        case 13:
+          /* counter control hints, clear stack */
+          top = decoder->stack;
+          break;
+
+        case 14:
+        case 15:
+        case 16:
+        case 17:
+        case 18:                    /* multiple masters */
+          {
+            PS_Blend  blend = decoder->blend;
+            FT_UInt   num_points, nn, mm;
+            FT_Long*  delta;
+            FT_Long*  values;
+
+
+            if ( !blend )
+            {
+              FT_ERROR(( "t1_decoder_parse_charstrings: " ));
+              FT_ERROR(( "unexpected multiple masters operator!\n" ));
+              goto Syntax_Error;
+            }
+
+            num_points = (FT_UInt)top[1] - 13 + ( top[1] == 18 );
+            if ( top[0] != (FT_Int)( num_points * blend->num_designs ) )
+            {
+              FT_ERROR(( "t1_decoder_parse_charstrings: " ));
+              FT_ERROR(( "incorrect number of mm arguments\n" ));
+              goto Syntax_Error;
+            }
+
+            top -= blend->num_designs * num_points;
+            if ( top < decoder->stack )
+              goto Stack_Underflow;
+
+            /* we want to compute:                                   */
+            /*                                                       */
+            /*  a0*w0 + a1*w1 + ... + ak*wk                          */
+            /*                                                       */
+            /* but we only have the a0, a1-a0, a2-a0, .. ak-a0       */
+            /* however, given that w0 + w1 + ... + wk == 1, we can   */
+            /* rewrite it easily as:                                 */
+            /*                                                       */
+            /*  a0 + (a1-a0)*w1 + (a2-a0)*w2 + .. + (ak-a0)*wk       */
+            /*                                                       */
+            /* where k == num_designs-1                              */
+            /*                                                       */
+            /* I guess that's why it's written in this `compact'     */
+            /* form.                                                 */
+            /*                                                       */
+            delta  = top + num_points;
+            values = top;
+            for ( nn = 0; nn < num_points; nn++ )
+            {
+              FT_Long  tmp = values[0];
+
+
+              for ( mm = 1; mm < blend->num_designs; mm++ )
+                tmp += FT_MulFix( *delta++, blend->weight_vector[mm] );
+
+              *values++ = tmp;
+            }
+            /* note that `top' will be incremented later by calls to `pop' */
+            break;
+          }
+
+        default:
+        Unexpected_OtherSubr:
+          FT_ERROR(( "t1_decoder_parse_charstrings: "
+                     "invalid othersubr [%d %d]!\n", top[0], top[1] ));
+          goto Syntax_Error;
+        }
+        decoder->top = top;
+      }
+      else  /* general operator */
+      {
+        FT_Int  num_args = t1_args_count[op];
+
+
+        if ( top - decoder->stack < num_args )
+          goto Stack_Underflow;
+
+        top -= num_args;
+
+        switch ( op )
+        {
+        case op_endchar:
+          FT_TRACE4(( " endchar" ));
+
+          close_contour( builder );
+
+          /* close hints recording session */
+          if ( hinter )
+          {
+            if (hinter->close( hinter->hints, builder->current->n_points ))
+              goto Syntax_Error;
+
+            /* apply hints to the loaded glyph outline now */
+            hinter->apply( hinter->hints,
+                           builder->current,
+                           (PSH_Globals) builder->hints_globals,
+                           decoder->hint_mode );
+          }
+
+          /* add current outline to the glyph slot */
+          FT_GlyphLoader_Add( builder->loader );
+
+          /* return now! */
+          FT_TRACE4(( "\n\n" ));
+          return PSaux_Err_Ok;
+
+        case op_hsbw:
+          FT_TRACE4(( " hsbw" ));
+
+          builder->parse_state = T1_Parse_Have_Width;
+
+          builder->left_bearing.x += top[0];
+          builder->advance.x       = top[1];
+          builder->advance.y       = 0;
+
+          orig_x = builder->last.x = x = builder->pos_x + top[0];
+          orig_y = builder->last.y = y = builder->pos_y;
+
+          FT_UNUSED( orig_y );
+
+          /* the `metrics_only' indicates that we only want to compute */
+          /* the glyph's metrics (lsb + advance width), not load the   */
+          /* rest of it; so exit immediately                           */
+          if ( builder->metrics_only )
+            return PSaux_Err_Ok;
+
+          break;
+
+        case op_seac:
+          /* return immediately after the processing */
+          return t1operator_seac( decoder, top[0], top[1], top[2],
+                                           (FT_Int)top[3], (FT_Int)top[4] );
+
+        case op_sbw:
+          FT_TRACE4(( " sbw" ));
+
+          builder->parse_state = T1_Parse_Have_Width;
+
+          builder->left_bearing.x += top[0];
+          builder->left_bearing.y += top[1];
+          builder->advance.x       = top[2];
+          builder->advance.y       = top[3];
+
+          builder->last.x = x = builder->pos_x + top[0];
+          builder->last.y = y = builder->pos_y + top[1];
+
+          /* the `metrics_only' indicates that we only want to compute */
+          /* the glyph's metrics (lsb + advance width), not load the   */
+          /* rest of it; so exit immediately                           */
+          if ( builder->metrics_only )
+            return PSaux_Err_Ok;
+
+          break;
+
+        case op_closepath:
+          FT_TRACE4(( " closepath" ));
+
+          close_contour( builder );
+          if ( builder->parse_state != T1_Parse_Have_Path )
+            goto Syntax_Error;
+          builder->parse_state = T1_Parse_Have_Width;
+          break;
+
+        case op_hlineto:
+          FT_TRACE4(( " hlineto" ));
+
+          if ( start_point( builder, x, y ) )
+            goto Fail;
+
+          x += top[0];
+          goto Add_Line;
+
+        case op_hmoveto:
+          FT_TRACE4(( " hmoveto" ));
+
+          x += top[0];
+          if ( !decoder->flex_state )
+          {
+            if ( builder->parse_state == T1_Parse_Start )
+              goto Syntax_Error;
+            builder->parse_state = T1_Parse_Have_Moveto;
+          }
+          break;
+
+        case op_hvcurveto:
+          FT_TRACE4(( " hvcurveto" ));
+
+          if ( start_point( builder, x, y ) ||
+               check_points( builder, 3 )   )
+            goto Fail;
+
+          x += top[0];
+          add_point( builder, x, y, 0 );
+          x += top[1];
+          y += top[2];
+          add_point( builder, x, y, 0 );
+          y += top[3];
+          add_point( builder, x, y, 1 );
+          break;
+
+        case op_rlineto:
+          FT_TRACE4(( " rlineto" ));
+
+          if ( start_point( builder, x, y ) )
+            goto Fail;
+
+          x += top[0];
+          y += top[1];
+
+        Add_Line:
+          if ( add_point1( builder, x, y ) )
+            goto Fail;
+          break;
+
+        case op_rmoveto:
+          FT_TRACE4(( " rmoveto" ));
+
+          x += top[0];
+          y += top[1];
+          if ( !decoder->flex_state )
+          {
+            if ( builder->parse_state == T1_Parse_Start )
+              goto Syntax_Error;
+            builder->parse_state = T1_Parse_Have_Moveto;
+          }
+          break;
+
+        case op_rrcurveto:
+          FT_TRACE4(( " rcurveto" ));
+
+          if ( start_point( builder, x, y ) ||
+               check_points( builder, 3 )   )
+            goto Fail;
+
+          x += top[0];
+          y += top[1];
+          add_point( builder, x, y, 0 );
+
+          x += top[2];
+          y += top[3];
+          add_point( builder, x, y, 0 );
+
+          x += top[4];
+          y += top[5];
+          add_point( builder, x, y, 1 );
+          break;
+
+        case op_vhcurveto:
+          FT_TRACE4(( " vhcurveto" ));
+
+          if ( start_point( builder, x, y ) ||
+               check_points( builder, 3 )   )
+            goto Fail;
+
+          y += top[0];
+          add_point( builder, x, y, 0 );
+          x += top[1];
+          y += top[2];
+          add_point( builder, x, y, 0 );
+          x += top[3];
+          add_point( builder, x, y, 1 );
+          break;
+
+        case op_vlineto:
+          FT_TRACE4(( " vlineto" ));
+
+          if ( start_point( builder, x, y ) )
+            goto Fail;
+
+          y += top[0];
+          goto Add_Line;
+
+        case op_vmoveto:
+          FT_TRACE4(( " vmoveto" ));
+
+          y += top[0];
+          if ( !decoder->flex_state )
+          {
+            if ( builder->parse_state == T1_Parse_Start )
+              goto Syntax_Error;
+            builder->parse_state = T1_Parse_Have_Moveto;
+          }
+          break;
+
+        case op_div:
+          FT_TRACE4(( " div" ));
+
+          if ( top[1] )
+          {
+            *top = top[0] / top[1];
+            ++top;
+          }
+          else
+          {
+            FT_ERROR(( "t1_decoder_parse_charstrings: division by 0\n" ));
+            goto Syntax_Error;
+          }
+          break;
+
+        case op_callsubr:
+          {
+            FT_Int  idx;
+
+
+            FT_TRACE4(( " callsubr" ));
+
+            idx = (FT_Int)top[0];
+            if ( idx < 0 || idx >= (FT_Int)decoder->num_subrs )
+            {
+              FT_ERROR(( "t1_decoder_parse_charstrings: "
+                         "invalid subrs index\n" ));
+              goto Syntax_Error;
+            }
+
+            if ( zone - decoder->zones >= T1_MAX_SUBRS_CALLS )
+            {
+              FT_ERROR(( "t1_decoder_parse_charstrings: "
+                         "too many nested subrs\n" ));
+              goto Syntax_Error;
+            }
+
+            zone->cursor = ip;  /* save current instruction pointer */
+
+            zone++;
+
+            /* The Type 1 driver stores subroutines without the seed bytes. */
+            /* The CID driver stores subroutines with seed bytes.  This     */
+            /* case is taken care of when decoder->subrs_len == 0.          */
+            zone->base = decoder->subrs[idx];
+
+            if ( decoder->subrs_len )
+              zone->limit = zone->base + decoder->subrs_len[idx];
+            else
+            {
+              /* We are using subroutines from a CID font.  We must adjust */
+              /* for the seed bytes.                                       */
+              zone->base  += ( decoder->lenIV >= 0 ? decoder->lenIV : 0 );
+              zone->limit  = decoder->subrs[idx + 1];
+            }
+
+            zone->cursor = zone->base;
+
+            if ( !zone->base )
+            {
+              FT_ERROR(( "t1_decoder_parse_charstrings: "
+                         "invoking empty subrs!\n" ));
+              goto Syntax_Error;
+            }
+
+            decoder->zone = zone;
+            ip            = zone->base;
+            limit         = zone->limit;
+            break;
+          }
+
+        case op_pop:
+          FT_TRACE4(( " pop" ));
+
+          /* theoretically, the arguments are already on the stack */
+          top++;
+          break;
+
+        case op_return:
+          FT_TRACE4(( " return" ));
+
+          if ( zone <= decoder->zones )
+          {
+            FT_ERROR(( "t1_decoder_parse_charstrings: unexpected return\n" ));
+            goto Syntax_Error;
+          }
+
+          zone--;
+          ip            = zone->cursor;
+          limit         = zone->limit;
+          decoder->zone = zone;
+          break;
+
+        case op_dotsection:
+          FT_TRACE4(( " dotsection" ));
+
+          break;
+
+        case op_hstem:
+          FT_TRACE4(( " hstem" ));
+
+          /* record horizontal hint */
+          if ( hinter )
+          {
+            /* top[0] += builder->left_bearing.y; */
+            hinter->stem( hinter->hints, 1, top );
+          }
+
+          break;
+
+        case op_hstem3:
+          FT_TRACE4(( " hstem3" ));
+
+          /* record horizontal counter-controlled hints */
+          if ( hinter )
+            hinter->stem3( hinter->hints, 1, top );
+
+          break;
+
+        case op_vstem:
+          FT_TRACE4(( " vstem" ));
+
+          /* record vertical  hint */
+          if ( hinter )
+          {
+            top[0] += orig_x;
+            hinter->stem( hinter->hints, 0, top );
+          }
+
+          break;
+
+        case op_vstem3:
+          FT_TRACE4(( " vstem3" ));
+
+          /* record vertical counter-controlled hints */
+          if ( hinter )
+          {
+            FT_Pos  dx = orig_x;
+
+
+            top[0] += dx;
+            top[2] += dx;
+            top[4] += dx;
+            hinter->stem3( hinter->hints, 0, top );
+          }
+          break;
+
+        case op_setcurrentpoint:
+          FT_TRACE4(( " setcurrentpoint" ));
+
+          FT_ERROR(( "t1_decoder_parse_charstrings: " ));
+          FT_ERROR(( "unexpected `setcurrentpoint'\n" ));
+          goto Syntax_Error;
+
+        default:
+          FT_ERROR(( "t1_decoder_parse_charstrings: "
+                     "unhandled opcode %d\n", op ));
+          goto Syntax_Error;
+        }
+
+        decoder->top = top;
+
+      } /* general operator processing */
+
+    } /* while ip < limit */
+
+    FT_TRACE4(( "..end..\n\n" ));
+
+  Fail:
+    return error;
+
+  Syntax_Error:
+    return PSaux_Err_Syntax_Error;
+
+  Stack_Underflow:
+    return PSaux_Err_Stack_Underflow;
+  }
+
+
+  /* parse a single Type 1 glyph */
+  FT_LOCAL_DEF( FT_Error )
+  t1_decoder_parse_glyph( T1_Decoder  decoder,
+                          FT_UInt     glyph )
+  {
+    return decoder->parse_callback( decoder, glyph );
+  }
+
+
+  /* initialize T1 decoder */
+  FT_LOCAL_DEF( FT_Error )
+  t1_decoder_init( T1_Decoder           decoder,
+                   FT_Face              face,
+                   FT_Size              size,
+                   FT_GlyphSlot         slot,
+                   FT_Byte**            glyph_names,
+                   PS_Blend             blend,
+                   FT_Bool              hinting,
+                   FT_Render_Mode       hint_mode,
+                   T1_Decoder_Callback  parse_callback )
+  {
+    FT_MEM_ZERO( decoder, sizeof ( *decoder ) );
+
+    /* retrieve PSNames interface from list of current modules */
+    {
+      FT_Service_PsCMaps  psnames = 0;
+
+
+      FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
+      if ( !psnames )
+      {
+        FT_ERROR(( "t1_decoder_init: " ));
+        FT_ERROR(( "the `psnames' module is not available\n" ));
+        return PSaux_Err_Unimplemented_Feature;
+      }
+
+      decoder->psnames = psnames;
+    }
+
+    t1_builder_init( &decoder->builder, face, size, slot, hinting );
+
+    decoder->num_glyphs     = (FT_UInt)face->num_glyphs;
+    decoder->glyph_names    = glyph_names;
+    decoder->hint_mode      = hint_mode;
+    decoder->blend          = blend;
+    decoder->parse_callback = parse_callback;
+
+    decoder->funcs          = t1_decoder_funcs;
+
+    return 0;
+  }
+
+
+  /* finalize T1 decoder */
+  FT_LOCAL_DEF( void )
+  t1_decoder_done( T1_Decoder  decoder )
+  {
+    t1_builder_done( &decoder->builder );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psaux/t1decode.h b/nx-X11/extras/freetype2/src/psaux/t1decode.h
new file mode 100644
index 000000000..00728db50
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psaux/t1decode.h
@@ -0,0 +1,64 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1decode.h                                                             */
+/*                                                                         */
+/*    PostScript Type 1 decoding routines (specification).                 */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003 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 __T1DECODE_H__
+#define __T1DECODE_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_CALLBACK_TABLE
+  const T1_Decoder_FuncsRec  t1_decoder_funcs;
+
+
+  FT_LOCAL( FT_Error )
+  t1_decoder_parse_glyph( T1_Decoder  decoder,
+                          FT_UInt     glyph_index );
+
+  FT_LOCAL( FT_Error )
+  t1_decoder_parse_charstrings( T1_Decoder  decoder,
+                                FT_Byte*    base,
+                                FT_UInt     len );
+
+  FT_LOCAL( FT_Error )
+  t1_decoder_init( T1_Decoder           decoder,
+                   FT_Face              face,
+                   FT_Size              size,
+                   FT_GlyphSlot         slot,
+                   FT_Byte**            glyph_names,
+                   PS_Blend             blend,
+                   FT_Bool              hinting,
+                   FT_Render_Mode       hint_mode,
+                   T1_Decoder_Callback  parse_glyph );
+
+  FT_LOCAL( void )
+  t1_decoder_done( T1_Decoder  decoder );
+
+
+FT_END_HEADER
+
+#endif /* __T1DECODE_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/Jamfile b/nx-X11/extras/freetype2/src/pshinter/Jamfile
new file mode 100644
index 000000000..ee02a144b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/pshinter Jamfile (c) 2001, 2003 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) pshinter ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = pshrec pshglob pshalgo pshmod ;
+  }
+  else
+  {
+    _sources = pshinter ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/pshinter Jamfile
diff --git a/nx-X11/extras/freetype2/src/pshinter/descrip.mms b/nx-X11/extras/freetype2/src/pshinter/descrip.mms
new file mode 100644
index 000000000..205d6cfcc
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 PSHinter driver compilation rules for OpenVMS
+#
+
+
+# Copyright 2001, 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.psnames])
+
+OBJS=pshinter.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/pshinter/module.mk b/nx-X11/extras/freetype2/src/pshinter/module.mk
new file mode 100644
index 000000000..63c7e217f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 PSHinter module definition
+#
+
+
+# Copyright 1996-2001 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.
+
+
+make_module_list: add_pshinter_module
+
+add_pshinter_module:
+	$(OPEN_DRIVER)pshinter_module_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)pshinter  $(ECHO_DRIVER_DESC)Postscript hinter module$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshalgo.c b/nx-X11/extras/freetype2/src/pshinter/pshalgo.c
new file mode 100644
index 000000000..5f077d54d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshalgo.c
@@ -0,0 +1,2091 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshalgo.c                                                              */
+/*                                                                         */
+/*    PostScript hinting algorithm (body).                                 */
+/*                                                                         */
+/*  Copyright 2001, 2002, 2003, 2004 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_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include "pshalgo.h"
+
+#include "pshnterr.h"
+
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pshalgo2
+
+
+#ifdef DEBUG_HINTER
+  PSH_Hint_Table  ps_debug_hint_table = 0;
+  PSH_HintFunc    ps_debug_hint_func  = 0;
+  PSH_Glyph       ps_debug_glyph      = 0;
+#endif
+
+
+#define  COMPUTE_INFLEXS  /* compute inflection points to optimize `S' */
+                          /* and similar glyphs                        */
+#define  STRONGER         /* slightly increase the contrast of smooth  */
+                          /* hinting                                   */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  BASIC HINTS RECORDINGS                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* return true if two stem hints overlap */
+  static FT_Int
+  psh_hint_overlap( PSH_Hint  hint1,
+                    PSH_Hint  hint2 )
+  {
+    return hint1->org_pos + hint1->org_len >= hint2->org_pos &&
+           hint2->org_pos + hint2->org_len >= hint1->org_pos;
+  }
+
+
+  /* destroy hints table */
+  static void
+  psh_hint_table_done( PSH_Hint_Table  table,
+                       FT_Memory       memory )
+  {
+    FT_FREE( table->zones );
+    table->num_zones = 0;
+    table->zone      = 0;
+
+    FT_FREE( table->sort );
+    FT_FREE( table->hints );
+    table->num_hints   = 0;
+    table->max_hints   = 0;
+    table->sort_global = 0;
+  }
+
+
+  /* deactivate all hints in a table */
+  static void
+  psh_hint_table_deactivate( PSH_Hint_Table  table )
+  {
+    FT_UInt   count = table->max_hints;
+    PSH_Hint  hint  = table->hints;
+
+
+    for ( ; count > 0; count--, hint++ )
+    {
+      psh_hint_deactivate( hint );
+      hint->order = -1;
+    }
+  }
+
+
+  /* internal function to record a new hint */
+  static void
+  psh_hint_table_record( PSH_Hint_Table  table,
+                         FT_UInt         idx )
+  {
+    PSH_Hint  hint = table->hints + idx;
+
+
+    if ( idx >= table->max_hints )
+    {
+      FT_ERROR(( "psh_hint_table_record: invalid hint index %d\n", idx ));
+      return;
+    }
+
+    /* ignore active hints */
+    if ( psh_hint_is_active( hint ) )
+      return;
+
+    psh_hint_activate( hint );
+
+    /* now scan the current active hint set to check */
+    /* whether `hint' overlaps with another hint     */
+    {
+      PSH_Hint*  sorted = table->sort_global;
+      FT_UInt    count  = table->num_hints;
+      PSH_Hint   hint2;
+
+
+      hint->parent = 0;
+      for ( ; count > 0; count--, sorted++ )
+      {
+        hint2 = sorted[0];
+
+        if ( psh_hint_overlap( hint, hint2 ) )
+        {
+          hint->parent = hint2;
+          break;
+        }
+      }
+    }
+
+    if ( table->num_hints < table->max_hints )
+      table->sort_global[table->num_hints++] = hint;
+    else
+      FT_ERROR(( "psh_hint_table_record: too many sorted hints!  BUG!\n" ));
+  }
+
+
+  static void
+  psh_hint_table_record_mask( PSH_Hint_Table  table,
+                              PS_Mask         hint_mask )
+  {
+    FT_Int    mask = 0, val = 0;
+    FT_Byte*  cursor = hint_mask->bytes;
+    FT_UInt   idx, limit;
+
+
+    limit = hint_mask->num_bits;
+
+    for ( idx = 0; idx < limit; idx++ )
+    {
+      if ( mask == 0 )
+      {
+        val  = *cursor++;
+        mask = 0x80;
+      }
+
+      if ( val & mask )
+        psh_hint_table_record( table, idx );
+
+      mask >>= 1;
+    }
+  }
+
+
+  /* create hints table */
+  static FT_Error
+  psh_hint_table_init( PSH_Hint_Table  table,
+                       PS_Hint_Table   hints,
+                       PS_Mask_Table   hint_masks,
+                       PS_Mask_Table   counter_masks,
+                       FT_Memory       memory )
+  {
+    FT_UInt   count;
+    FT_Error  error;
+
+    FT_UNUSED( counter_masks );
+
+
+    count = hints->num_hints;
+
+    /* allocate our tables */
+    if ( FT_NEW_ARRAY( table->sort,  2 * count     ) ||
+         FT_NEW_ARRAY( table->hints,     count     ) ||
+         FT_NEW_ARRAY( table->zones, 2 * count + 1 ) )
+      goto Exit;
+
+    table->max_hints   = count;
+    table->sort_global = table->sort + count;
+    table->num_hints   = 0;
+    table->num_zones   = 0;
+    table->zone        = 0;
+
+    /* initialize the `table->hints' array */
+    {
+      PSH_Hint  write = table->hints;
+      PS_Hint   read  = hints->hints;
+
+
+      for ( ; count > 0; count--, write++, read++ )
+      {
+        write->org_pos = read->pos;
+        write->org_len = read->len;
+        write->flags   = read->flags;
+      }
+    }
+
+    /* we now need to determine the initial `parent' stems; first  */
+    /* activate the hints that are given by the initial hint masks */
+    if ( hint_masks )
+    {
+      PS_Mask  mask = hint_masks->masks;
+
+
+      count             = hint_masks->num_masks;
+      table->hint_masks = hint_masks;
+
+      for ( ; count > 0; count--, mask++ )
+        psh_hint_table_record_mask( table, mask );
+    }
+
+    /* finally, do a linear parse in case some hints were left alone */
+    if ( table->num_hints != table->max_hints )
+    {
+      FT_UInt  idx;
+
+
+      FT_ERROR(( "psh_hint_table_init: missing/incorrect hint masks!\n" ));
+
+      count = table->max_hints;
+      for ( idx = 0; idx < count; idx++ )
+        psh_hint_table_record( table, idx );
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  psh_hint_table_activate_mask( PSH_Hint_Table  table,
+                                PS_Mask         hint_mask )
+  {
+    FT_Int    mask = 0, val = 0;
+    FT_Byte*  cursor = hint_mask->bytes;
+    FT_UInt   idx, limit, count;
+
+
+    limit = hint_mask->num_bits;
+    count = 0;
+
+    psh_hint_table_deactivate( table );
+
+    for ( idx = 0; idx < limit; idx++ )
+    {
+      if ( mask == 0 )
+      {
+        val  = *cursor++;
+        mask = 0x80;
+      }
+
+      if ( val & mask )
+      {
+        PSH_Hint  hint = &table->hints[idx];
+
+
+        if ( !psh_hint_is_active( hint ) )
+        {
+          FT_UInt     count2;
+
+#if 0
+          PSH_Hint*  sort = table->sort;
+          PSH_Hint   hint2;
+
+
+          for ( count2 = count; count2 > 0; count2--, sort++ )
+          {
+            hint2 = sort[0];
+            if ( psh_hint_overlap( hint, hint2 ) )
+              FT_ERROR(( "psh_hint_table_activate_mask:"
+                         " found overlapping hints\n" ))
+          }
+#else
+          count2 = 0;
+#endif
+
+          if ( count2 == 0 )
+          {
+            psh_hint_activate( hint );
+            if ( count < table->max_hints )
+              table->sort[count++] = hint;
+            else
+              FT_ERROR(( "psh_hint_tableactivate_mask:"
+                         " too many active hints\n" ));
+          }
+        }
+      }
+
+      mask >>= 1;
+    }
+    table->num_hints = count;
+
+    /* now, sort the hints; they are guaranteed to not overlap */
+    /* so we can compare their "org_pos" field directly        */
+    {
+      FT_Int     i1, i2;
+      PSH_Hint   hint1, hint2;
+      PSH_Hint*  sort = table->sort;
+
+
+      /* a simple bubble sort will do, since in 99% of cases, the hints */
+      /* will be already sorted -- and the sort will be linear          */
+      for ( i1 = 1; i1 < (FT_Int)count; i1++ )
+      {
+        hint1 = sort[i1];
+        for ( i2 = i1 - 1; i2 >= 0; i2-- )
+        {
+          hint2 = sort[i2];
+
+          if ( hint2->org_pos < hint1->org_pos )
+            break;
+
+          sort[i2 + 1] = hint2;
+          sort[i2]     = hint1;
+        }
+      }
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****               HINTS GRID-FITTING AND OPTIMIZATION             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#if 1
+  static FT_Pos
+  psh_dimension_quantize_len( PSH_Dimension  dim,
+                              FT_Pos         len,
+                              FT_Bool        do_snapping )
+  {
+    if ( len <= 64 )
+      len = 64;
+    else
+    {
+      FT_Pos  delta = len - dim->stdw.widths[0].cur;
+
+
+      if ( delta < 0 )
+        delta = -delta;
+
+      if ( delta < 40 )
+      {
+        len = dim->stdw.widths[0].cur;
+        if ( len < 48 )
+          len = 48;
+      }
+
+      if ( len < 3 * 64 )
+      {
+        delta = ( len & 63 );
+        len  &= -64;
+
+        if ( delta < 10 )
+          len += delta;
+
+        else if ( delta < 32 )
+          len += 10;
+
+        else if ( delta < 54 )
+          len += 54;
+
+        else
+          len += delta;
+      }
+      else
+        len = FT_PIX_ROUND( len );
+    }
+
+    if ( do_snapping )
+      len = FT_PIX_ROUND( len );
+
+    return  len;
+  }
+#endif /* 0 */
+
+
+#ifdef DEBUG_HINTER
+
+  static void
+  ps_simple_scale( PSH_Hint_Table  table,
+                   FT_Fixed        scale,
+                   FT_Fixed        delta,
+                   FT_Int          dimension )
+  {
+    PSH_Hint  hint;
+    FT_UInt   count;
+
+
+    for ( count = 0; count < table->max_hints; count++ )
+    {
+      hint = table->hints + count;
+
+      hint->cur_pos = FT_MulFix( hint->org_pos, scale ) + delta;
+      hint->cur_len = FT_MulFix( hint->org_len, scale );
+
+      if ( ps_debug_hint_func )
+        ps_debug_hint_func( hint, dimension );
+    }
+  }
+
+#endif /* DEBUG_HINTER */
+
+
+  static FT_Fixed
+  psh_hint_snap_stem_side_delta( FT_Fixed  pos,
+                                 FT_Fixed  len )
+  {
+    FT_Fixed  delta1 = FT_PIX_ROUND( pos ) - pos;
+    FT_Fixed  delta2 = FT_PIX_ROUND( pos + len ) - pos - len;
+
+
+    if ( FT_ABS( delta1 ) <= FT_ABS( delta2 ) )
+      return delta1;
+    else
+      return delta2;
+  }
+
+
+  static void
+  psh_hint_align( PSH_Hint     hint,
+                  PSH_Globals  globals,
+                  FT_Int       dimension,
+                  PSH_Glyph    glyph )
+  {
+    PSH_Dimension  dim   = &globals->dimension[dimension];
+    FT_Fixed       scale = dim->scale_mult;
+    FT_Fixed       delta = dim->scale_delta;
+
+
+    if ( !psh_hint_is_fitted( hint ) )
+    {
+      FT_Pos  pos = FT_MulFix( hint->org_pos, scale ) + delta;
+      FT_Pos  len = FT_MulFix( hint->org_len, scale );
+
+      FT_Int            do_snapping;
+      FT_Pos            fit_len;
+      PSH_AlignmentRec  align;
+
+
+      /* ignore stem alignments when requested through the hint flags */
+      if ( ( dimension == 0 && !glyph->do_horz_hints ) ||
+           ( dimension == 1 && !glyph->do_vert_hints ) )
+      {
+        hint->cur_pos = pos;
+        hint->cur_len = len;
+
+        psh_hint_set_fitted( hint );
+        return;
+      }
+
+      /* perform stem snapping when requested - this is necessary
+       * for monochrome and LCD hinting modes only
+       */
+      do_snapping = ( dimension == 0 && glyph->do_horz_snapping ) ||
+                    ( dimension == 1 && glyph->do_vert_snapping );
+
+      hint->cur_len = fit_len = len;
+
+      /* check blue zones for horizontal stems */
+      align.align     = PSH_BLUE_ALIGN_NONE;
+      align.align_bot = align.align_top = 0;
+
+      if ( dimension == 1 )
+        psh_blues_snap_stem( &globals->blues,
+                             hint->org_pos + hint->org_len,
+                             hint->org_pos,
+                             &align );
+
+      switch ( align.align )
+      {
+      case PSH_BLUE_ALIGN_TOP:
+        /* the top of the stem is aligned against a blue zone */
+        hint->cur_pos = align.align_top - fit_len;
+        break;
+
+      case PSH_BLUE_ALIGN_BOT:
+        /* the bottom of the stem is aligned against a blue zone */
+        hint->cur_pos = align.align_bot;
+        break;
+
+      case PSH_BLUE_ALIGN_TOP | PSH_BLUE_ALIGN_BOT:
+        /* both edges of the stem are aligned against blue zones */
+        hint->cur_pos = align.align_bot;
+        hint->cur_len = align.align_top - align.align_bot;
+        break;
+
+      default:
+        {
+          PSH_Hint  parent = hint->parent;
+
+
+          if ( parent )
+          {
+            FT_Pos  par_org_center, par_cur_center;
+            FT_Pos  cur_org_center, cur_delta;
+
+
+            /* ensure that parent is already fitted */
+            if ( !psh_hint_is_fitted( parent ) )
+              psh_hint_align( parent, globals, dimension, glyph );
+
+            /* keep original relation between hints, this is, use the */
+            /* scaled distance between the centers of the hints to    */
+            /* compute the new position                               */
+            par_org_center = parent->org_pos + ( parent->org_len >> 1 );
+            par_cur_center = parent->cur_pos + ( parent->cur_len >> 1 );
+            cur_org_center = hint->org_pos   + ( hint->org_len   >> 1 );
+
+            cur_delta = FT_MulFix( cur_org_center - par_org_center, scale );
+            pos       = par_cur_center + cur_delta - ( len >> 1 );
+          }
+
+          hint->cur_pos = pos;
+          hint->cur_len = fit_len;
+
+          /* Stem adjustment tries to snap stem widths to standard
+           * ones.  This is important to prevent unpleasant rounding
+           * artefacts.
+           */
+          if ( glyph->do_stem_adjust )
+          {
+            if ( len <= 64 )
+            {
+              /* the stem is less than one pixel; we will center it
+               * around the nearest pixel center
+               */
+#if 1
+              pos = FT_PIX_FLOOR( pos + ( len >> 1 ) );
+#else
+             /* this seems to be a bug! */
+              pos = pos + FT_PIX_FLOOR( len >> 1 );
+#endif
+              len = 64;
+            }
+            else
+            {
+              len = psh_dimension_quantize_len( dim, len, 0 );
+            }
+          }
+
+          /* now that we have a good hinted stem width, try to position */
+          /* the stem along a pixel grid integer coordinate             */
+          hint->cur_pos = pos + psh_hint_snap_stem_side_delta( pos, len );
+          hint->cur_len = len;
+        }
+      }
+
+      if ( do_snapping )
+      {
+        pos = hint->cur_pos;
+        len = hint->cur_len;
+
+        if ( len < 64 )
+          len = 64;
+        else
+          len = FT_PIX_ROUND( len );
+
+        switch ( align.align )
+        {
+          case PSH_BLUE_ALIGN_TOP:
+            hint->cur_pos = align.align_top - len;
+            hint->cur_len = len;
+            break;
+
+          case PSH_BLUE_ALIGN_BOT:
+            hint->cur_len = len;
+            break;
+
+          case PSH_BLUE_ALIGN_BOT | PSH_BLUE_ALIGN_TOP:
+            /* don't touch */
+            break;
+
+
+          default:
+            hint->cur_len = len;
+            if ( len & 64 )
+              pos = FT_PIX_FLOOR( pos + ( len >> 1 ) ) + 32;
+            else
+              pos = FT_PIX_ROUND( pos + ( len >> 1 ) );
+
+            hint->cur_pos = pos - ( len >> 1 );
+            hint->cur_len = len;
+        }
+      }
+
+      psh_hint_set_fitted( hint );
+
+#ifdef DEBUG_HINTER
+      if ( ps_debug_hint_func )
+        ps_debug_hint_func( hint, dimension );
+#endif
+    }
+  }
+
+
+#if 0  /* not used for now, experimental */
+
+ /*
+  *  A variant to perform "light" hinting (i.e. FT_RENDER_MODE_LIGHT)
+  *  of stems
+  */
+  static void
+  psh_hint_align_light( PSH_Hint     hint,
+                        PSH_Globals  globals,
+                        FT_Int       dimension,
+                        PSH_Glyph    glyph )
+  {
+    PSH_Dimension  dim   = &globals->dimension[dimension];
+    FT_Fixed       scale = dim->scale_mult;
+    FT_Fixed       delta = dim->scale_delta;
+
+
+    if ( !psh_hint_is_fitted( hint ) )
+    {
+      FT_Pos  pos = FT_MulFix( hint->org_pos, scale ) + delta;
+      FT_Pos  len = FT_MulFix( hint->org_len, scale );
+
+      FT_Pos  fit_len;
+
+      PSH_AlignmentRec  align;
+
+
+      /* ignore stem alignments when requested through the hint flags */
+      if ( ( dimension == 0 && !glyph->do_horz_hints ) ||
+           ( dimension == 1 && !glyph->do_vert_hints ) )
+      {
+        hint->cur_pos = pos;
+        hint->cur_len = len;
+
+        psh_hint_set_fitted( hint );
+        return;
+      }
+
+      fit_len = len;
+
+      hint->cur_len = fit_len;
+
+      /* check blue zones for horizontal stems */
+      align.align = PSH_BLUE_ALIGN_NONE;
+      align.align_bot = align.align_top = 0;
+
+      if ( dimension == 1 )
+        psh_blues_snap_stem( &globals->blues,
+                             hint->org_pos + hint->org_len,
+                             hint->org_pos,
+                             &align );
+
+      switch ( align.align )
+      {
+      case PSH_BLUE_ALIGN_TOP:
+        /* the top of the stem is aligned against a blue zone */
+        hint->cur_pos = align.align_top - fit_len;
+        break;
+
+      case PSH_BLUE_ALIGN_BOT:
+        /* the bottom of the stem is aligned against a blue zone */
+        hint->cur_pos = align.align_bot;
+        break;
+
+      case PSH_BLUE_ALIGN_TOP | PSH_BLUE_ALIGN_BOT:
+        /* both edges of the stem are aligned against blue zones */
+        hint->cur_pos = align.align_bot;
+        hint->cur_len = align.align_top - align.align_bot;
+        break;
+
+      default:
+        {
+          PSH_Hint  parent = hint->parent;
+
+
+          if ( parent )
+          {
+            FT_Pos  par_org_center, par_cur_center;
+            FT_Pos  cur_org_center, cur_delta;
+
+
+            /* ensure that parent is already fitted */
+            if ( !psh_hint_is_fitted( parent ) )
+              psh_hint_align_light( parent, globals, dimension, glyph );
+
+            par_org_center = parent->org_pos + ( parent->org_len / 2 );
+            par_cur_center = parent->cur_pos + ( parent->cur_len / 2 );
+            cur_org_center = hint->org_pos   + ( hint->org_len   / 2 );
+
+            cur_delta = FT_MulFix( cur_org_center - par_org_center, scale );
+            pos       = par_cur_center + cur_delta - ( len >> 1 );
+          }
+
+          /* Stems less than one pixel wide are easy -- we want to
+           * make them as dark as possible, so they must fall within
+           * one pixel.  If the stem is split between two pixels
+           * then snap the edge that is nearer to the pixel boundary
+           * to the pixel boundary.
+           */
+          if ( len <= 64 )
+          {
+            if ( ( pos + len + 63 ) / 64  != pos / 64 + 1 )
+              pos += psh_hint_snap_stem_side_delta ( pos, len );
+          }
+
+          /* Position stems other to minimize the amount of mid-grays.
+           * There are, in general, two positions that do this,
+           * illustrated as A) and B) below.
+           *
+           *   +                   +                   +                   +
+           *
+           * A)             |--------------------------------|
+           * B)   |--------------------------------|
+           * C)       |--------------------------------|
+           *
+           * Position A) (split the excess stem equally) should be better
+           * for stems of width N + f where f < 0.5.
+           *
+           * Position B) (split the deficiency equally) should be better
+           * for stems of width N + f where f > 0.5.
+           *
+           * It turns out though that minimizing the total number of lit
+           * pixels is also important, so position C), with one edge
+           * aligned with a pixel boundary is actually preferable
+           * to A).  There are also more possibile positions for C) than
+           * for A) or B), so it involves less distortion of the overall
+           * character shape.
+           */
+          else /* len > 64 */
+          {
+            FT_Fixed  frac_len = len & 63;
+            FT_Fixed  center = pos + ( len >> 1 );
+            FT_Fixed  delta_a, delta_b;
+
+
+            if ( ( len / 64 ) & 1 )
+            {
+              delta_a = FT_PIX_FLOOR( center ) + 32 - center;
+              delta_b = FT_PIX_ROUND( center ) - center;
+            }
+            else
+            {
+              delta_a = FT_PIX_ROUND( center ) - center;
+              delta_b = FT_PIX_FLOOR( center ) + 32 - center;
+            }
+
+            /* We choose between B) and C) above based on the amount
+             * of fractinal stem width; for small amounts, choose
+             * C) always, for large amounts, B) always, and inbetween,
+             * pick whichever one involves less stem movement.
+             */
+            if ( frac_len < 32 )
+            {
+              pos += psh_hint_snap_stem_side_delta ( pos, len );
+            }
+            else if ( frac_len < 48 )
+            {
+              FT_Fixed  side_delta = psh_hint_snap_stem_side_delta ( pos,
+                                                                     len );
+
+              if ( FT_ABS( side_delta ) < FT_ABS( delta_b ) )
+                pos += side_delta;
+              else
+                pos += delta_b;
+            }
+            else
+            {
+              pos += delta_b;
+            }
+          }
+
+          hint->cur_pos = pos;
+        }
+      }  /* switch */
+
+      psh_hint_set_fitted( hint );
+
+#ifdef DEBUG_HINTER
+      if ( ps_debug_hint_func )
+        ps_debug_hint_func( hint, dimension );
+#endif
+    }
+  }
+
+#endif /* 0 */
+
+
+  static void
+  psh_hint_table_align_hints( PSH_Hint_Table  table,
+                              PSH_Globals     globals,
+                              FT_Int          dimension,
+                              PSH_Glyph       glyph )
+  {
+    PSH_Hint       hint;
+    FT_UInt        count;
+
+#ifdef DEBUG_HINTER
+
+    PSH_Dimension  dim   = &globals->dimension[dimension];
+    FT_Fixed       scale = dim->scale_mult;
+    FT_Fixed       delta = dim->scale_delta;
+
+
+    if ( ps_debug_no_vert_hints && dimension == 0 )
+    {
+      ps_simple_scale( table, scale, delta, dimension );
+      return;
+    }
+
+    if ( ps_debug_no_horz_hints && dimension == 1 )
+    {
+      ps_simple_scale( table, scale, delta, dimension );
+      return;
+    }
+
+#endif /* DEBUG_HINTER*/
+
+    hint  = table->hints;
+    count = table->max_hints;
+
+    for ( ; count > 0; count--, hint++ )
+      psh_hint_align( hint, globals, dimension, glyph );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                POINTS INTERPOLATION ROUTINES                  *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#define PSH_ZONE_MIN  -3200000L
+#define PSH_ZONE_MAX  +3200000L
+
+#define xxDEBUG_ZONES
+
+
+#ifdef DEBUG_ZONES
+
+#include <stdio.h>
+
+  static void
+  psh_print_zone( PSH_Zone  zone )
+  {
+    printf( "zone [scale,delta,min,max] = [%.3f,%.3f,%d,%d]\n",
+             zone->scale / 65536.0,
+             zone->delta / 64.0,
+             zone->min,
+             zone->max );
+  }
+
+#else
+
+#define psh_print_zone( x )  do { } while ( 0 )
+
+#endif /* DEBUG_ZONES */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    HINTER GLYPH MANAGEMENT                    *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#ifdef COMPUTE_INFLEXS
+
+  /* compute all inflex points in a given glyph */
+  static void
+  psh_glyph_compute_inflections( PSH_Glyph  glyph )
+  {
+    FT_UInt  n;
+
+
+    for ( n = 0; n < glyph->num_contours; n++ )
+    {
+      PSH_Point  first, start, end, before, after;
+      FT_Angle   angle_in, angle_seg, angle_out;
+      FT_Angle   diff_in, diff_out;
+      FT_Int     finished = 0;
+
+
+      /* we need at least 4 points to create an inflection point */
+      if ( glyph->contours[n].count < 4 )
+        continue;
+
+      /* compute first segment in contour */
+      first = glyph->contours[n].start;
+
+      start = end = first;
+      do
+      {
+        end = end->next;
+        if ( end == first )
+          goto Skip;
+
+      } while ( PSH_POINT_EQUAL_ORG( end, first ) );
+
+      angle_seg = PSH_POINT_ANGLE( start, end );
+
+      /* extend the segment start whenever possible */
+      before = start;
+      do
+      {
+        do
+        {
+          start  = before;
+          before = before->prev;
+          if ( before == first )
+            goto Skip;
+
+        } while ( PSH_POINT_EQUAL_ORG( before, start ) );
+
+        angle_in = PSH_POINT_ANGLE( before, start );
+
+      } while ( angle_in == angle_seg );
+
+      first   = start;
+      diff_in = FT_Angle_Diff( angle_in, angle_seg );
+
+      /* now, process all segments in the contour */
+      do
+      {
+        /* first, extend current segment's end whenever possible */
+        after = end;
+        do
+        {
+          do
+          {
+            end   = after;
+            after = after->next;
+            if ( after == first )
+              finished = 1;
+
+          } while ( PSH_POINT_EQUAL_ORG( end, after ) );
+
+          angle_out = PSH_POINT_ANGLE( end, after );
+
+        } while ( angle_out == angle_seg );
+
+        diff_out = FT_Angle_Diff( angle_seg, angle_out );
+
+        if ( ( diff_in ^ diff_out ) < 0 )
+        {
+          /* diff_in and diff_out have different signs, we have */
+          /* inflection points here...                          */
+
+          do
+          {
+            psh_point_set_inflex( start );
+            start = start->next;
+          }
+          while ( start != end );
+
+          psh_point_set_inflex( start );
+        }
+
+        start     = end;
+        end       = after;
+        angle_seg = angle_out;
+        diff_in   = diff_out;
+
+      } while ( !finished );
+
+    Skip:
+      ;
+    }
+  }
+
+#endif /* COMPUTE_INFLEXS */
+
+
+  static void
+  psh_glyph_done( PSH_Glyph  glyph )
+  {
+    FT_Memory  memory = glyph->memory;
+
+
+    psh_hint_table_done( &glyph->hint_tables[1], memory );
+    psh_hint_table_done( &glyph->hint_tables[0], memory );
+
+    FT_FREE( glyph->points );
+    FT_FREE( glyph->contours );
+
+    glyph->num_points   = 0;
+    glyph->num_contours = 0;
+
+    glyph->memory = 0;
+  }
+
+
+  static int
+  psh_compute_dir( FT_Pos  dx,
+                   FT_Pos  dy )
+  {
+    FT_Pos  ax, ay;
+    int     result = PSH_DIR_NONE;
+
+
+    ax = ( dx >= 0 ) ? dx : -dx;
+    ay = ( dy >= 0 ) ? dy : -dy;
+
+    if ( ay * 12 < ax )
+    {
+      /* |dy| <<< |dx|  means a near-horizontal segment */
+      result = ( dx >= 0 ) ? PSH_DIR_RIGHT : PSH_DIR_LEFT;
+    }
+    else if ( ax * 12 < ay )
+    {
+      /* |dx| <<< |dy|  means a near-vertical segment */
+      result = ( dy >= 0 ) ? PSH_DIR_UP : PSH_DIR_DOWN;
+    }
+
+    return result;
+  }
+
+
+  /* load outline point coordinates into hinter glyph */
+  static void
+  psh_glyph_load_points( PSH_Glyph  glyph,
+                         FT_Int     dimension )
+  {
+    FT_Vector*  vec   = glyph->outline->points;
+    PSH_Point   point = glyph->points;
+    FT_UInt     count = glyph->num_points;
+
+
+    for ( ; count > 0; count--, point++, vec++ )
+    {
+      point->flags2 = 0;
+      point->hint   = NULL;
+      if ( dimension == 0 )
+      {
+        point->org_u = vec->x;
+        point->org_v = vec->y;
+      }
+      else
+      {
+        point->org_u = vec->y;
+        point->org_v = vec->x;
+      }
+
+#ifdef DEBUG_HINTER
+      point->org_x = vec->x;
+      point->org_y = vec->y;
+#endif
+
+    }
+  }
+
+
+  /* save hinted point coordinates back to outline */
+  static void
+  psh_glyph_save_points( PSH_Glyph  glyph,
+                         FT_Int     dimension )
+  {
+    FT_UInt     n;
+    PSH_Point   point = glyph->points;
+    FT_Vector*  vec   = glyph->outline->points;
+    char*       tags  = glyph->outline->tags;
+
+
+    for ( n = 0; n < glyph->num_points; n++ )
+    {
+      if ( dimension == 0 )
+        vec[n].x = point->cur_u;
+      else
+        vec[n].y = point->cur_u;
+
+      if ( psh_point_is_strong( point ) )
+        tags[n] |= (char)( ( dimension == 0 ) ? 32 : 64 );
+
+#ifdef DEBUG_HINTER
+
+      if ( dimension == 0 )
+      {
+        point->cur_x   = point->cur_u;
+        point->flags_x = point->flags2 | point->flags;
+      }
+      else
+      {
+        point->cur_y   = point->cur_u;
+        point->flags_y = point->flags2 | point->flags;
+      }
+
+#endif
+
+      point++;
+    }
+  }
+
+
+  static FT_Error
+  psh_glyph_init( PSH_Glyph    glyph,
+                  FT_Outline*  outline,
+                  PS_Hints     ps_hints,
+                  PSH_Globals  globals )
+  {
+    FT_Error   error;
+    FT_Memory  memory;
+
+
+    /* clear all fields */
+    FT_MEM_ZERO( glyph, sizeof ( *glyph ) );
+
+    memory = glyph->memory = globals->memory;
+
+    /* allocate and setup points + contours arrays */
+    if ( FT_NEW_ARRAY( glyph->points,   outline->n_points   ) ||
+         FT_NEW_ARRAY( glyph->contours, outline->n_contours ) )
+      goto Exit;
+
+    glyph->num_points   = outline->n_points;
+    glyph->num_contours = outline->n_contours;
+
+    {
+      FT_UInt      first = 0, next, n;
+      PSH_Point    points  = glyph->points;
+      PSH_Contour  contour = glyph->contours;
+
+
+      for ( n = 0; n < glyph->num_contours; n++ )
+      {
+        FT_Int     count;
+        PSH_Point  point;
+
+
+        next  = outline->contours[n] + 1;
+        count = next - first;
+
+        contour->start = points + first;
+        contour->count = (FT_UInt)count;
+
+        if ( count > 0 )
+        {
+          point = points + first;
+
+          point->prev    = points + next - 1;
+          point->contour = contour;
+
+          for ( ; count > 1; count-- )
+          {
+            point[0].next = point + 1;
+            point[1].prev = point;
+            point++;
+            point->contour = contour;
+          }
+          point->next = points + first;
+        }
+
+        contour++;
+        first = next;
+      }
+    }
+
+    {
+      PSH_Point   points = glyph->points;
+      PSH_Point   point  = points;
+      FT_Vector*  vec    = outline->points;
+      FT_UInt     n;
+
+
+      for ( n = 0; n < glyph->num_points; n++, point++ )
+      {
+        FT_Int  n_prev = (FT_Int)( point->prev - points );
+        FT_Int  n_next = (FT_Int)( point->next - points );
+        FT_Pos  dxi, dyi, dxo, dyo;
+
+
+        if ( !( outline->tags[n] & FT_CURVE_TAG_ON ) )
+          point->flags = PSH_POINT_OFF;
+
+        dxi = vec[n].x - vec[n_prev].x;
+        dyi = vec[n].y - vec[n_prev].y;
+
+        point->dir_in = (FT_Char)psh_compute_dir( dxi, dyi );
+
+        dxo = vec[n_next].x - vec[n].x;
+        dyo = vec[n_next].y - vec[n].y;
+
+        point->dir_out = (FT_Char)psh_compute_dir( dxo, dyo );
+
+        /* detect smooth points */
+        if ( point->flags & PSH_POINT_OFF )
+          point->flags |= PSH_POINT_SMOOTH;
+        else if ( point->dir_in  != PSH_DIR_NONE ||
+                  point->dir_out != PSH_DIR_NONE )
+        {
+          if ( point->dir_in == point->dir_out )
+            point->flags |= PSH_POINT_SMOOTH;
+        }
+        else
+        {
+          FT_Angle  angle_in, angle_out, diff;
+
+
+          angle_in  = FT_Atan2( dxi, dyi );
+          angle_out = FT_Atan2( dxo, dyo );
+
+          diff = angle_in - angle_out;
+          if ( diff < 0 )
+            diff = -diff;
+
+          if ( diff > FT_ANGLE_PI )
+            diff = FT_ANGLE_2PI - diff;
+
+          if ( diff < FT_ANGLE_PI / 16 )
+            point->flags |= PSH_POINT_SMOOTH;
+        }
+      }
+    }
+
+    glyph->outline = outline;
+    glyph->globals = globals;
+
+#ifdef COMPUTE_INFLEXS
+    psh_glyph_load_points( glyph, 0 );
+    psh_glyph_compute_inflections( glyph );
+#endif /* COMPUTE_INFLEXS */
+
+    /* now deal with hints tables */
+    error = psh_hint_table_init( &glyph->hint_tables [0],
+                                 &ps_hints->dimension[0].hints,
+                                 &ps_hints->dimension[0].masks,
+                                 &ps_hints->dimension[0].counters,
+                                 memory );
+    if ( error )
+      goto Exit;
+
+    error = psh_hint_table_init( &glyph->hint_tables [1],
+                                 &ps_hints->dimension[1].hints,
+                                 &ps_hints->dimension[1].masks,
+                                 &ps_hints->dimension[1].counters,
+                                 memory );
+    if ( error )
+      goto Exit;
+
+  Exit:
+    return error;
+  }
+
+
+  /* compute all extrema in a glyph for a given dimension */
+  static void
+  psh_glyph_compute_extrema( PSH_Glyph  glyph )
+  {
+    FT_UInt  n;
+
+
+    /* first of all, compute all local extrema */
+    for ( n = 0; n < glyph->num_contours; n++ )
+    {
+      PSH_Point  first = glyph->contours[n].start;
+      PSH_Point  point, before, after;
+
+
+      if ( glyph->contours[n].count == 0 )
+        continue;
+
+      point  = first;
+      before = point;
+      after  = point;
+
+      do
+      {
+        before = before->prev;
+        if ( before == first )
+          goto Skip;
+
+      } while ( before->org_u == point->org_u );
+
+      first = point = before->next;
+
+      for (;;)
+      {
+        after = point;
+        do
+        {
+          after = after->next;
+          if ( after == first )
+            goto Next;
+
+        } while ( after->org_u == point->org_u );
+
+        if ( before->org_u < point->org_u )
+        {
+          if ( after->org_u < point->org_u )
+          {
+            /* local maximum */
+            goto Extremum;
+          }
+        }
+        else /* before->org_u > point->org_u */
+        {
+          if ( after->org_u > point->org_u )
+          {
+            /* local minimum */
+          Extremum:
+            do
+            {
+              psh_point_set_extremum( point );
+              point = point->next;
+
+            } while ( point != after );
+          }
+        }
+
+        before = after->prev;
+        point  = after;
+
+      } /* for  */
+
+    Next:
+      ;
+    }
+
+    /* for each extremum, determine its direction along the */
+    /* orthogonal axis                                      */
+    for ( n = 0; n < glyph->num_points; n++ )
+    {
+      PSH_Point  point, before, after;
+
+
+      point  = &glyph->points[n];
+      before = point;
+      after  = point;
+
+      if ( psh_point_is_extremum( point ) )
+      {
+        do
+        {
+          before = before->prev;
+          if ( before == point )
+            goto Skip;
+
+        } while ( before->org_v == point->org_v );
+
+        do
+        {
+          after = after->next;
+          if ( after == point )
+            goto Skip;
+
+        } while ( after->org_v == point->org_v );
+      }
+
+      if ( before->org_v < point->org_v &&
+           after->org_v  > point->org_v )
+      {
+        psh_point_set_positive( point );
+      }
+      else if ( before->org_v > point->org_v &&
+                after->org_v  < point->org_v )
+      {
+        psh_point_set_negative( point );
+      }
+
+    Skip:
+      ;
+    }
+  }
+
+
+  /* major_dir is the direction for points on the bottom/left of the stem; */
+  /* Points on the top/right of the stem will have a direction of          */
+  /* -major_dir.                                                           */
+
+  static void
+  psh_hint_table_find_strong_point( PSH_Hint_Table  table,
+                                    PSH_Point       point,
+                                    FT_Int          threshold,
+                                    FT_Int          major_dir )
+  {
+    PSH_Hint*  sort      = table->sort;
+    FT_UInt    num_hints = table->num_hints;
+    FT_Int     point_dir = 0;
+
+
+    if ( PSH_DIR_COMPARE( point->dir_in, major_dir ) )
+      point_dir = point->dir_in;
+
+    else if ( PSH_DIR_COMPARE( point->dir_out, major_dir ) )
+      point_dir = point->dir_out;
+
+    if ( point_dir )
+    {
+      FT_UInt  flag;
+
+
+      for ( ; num_hints > 0; num_hints--, sort++ )
+      {
+        PSH_Hint  hint = sort[0];
+        FT_Pos    d;
+
+
+        if ( point_dir == major_dir )
+        {
+          flag = PSH_POINT_EDGE_MIN;
+          d    = point->org_u - hint->org_pos;
+
+          if ( FT_ABS( d ) < threshold )
+          {
+          Is_Strong:
+            psh_point_set_strong( point );
+            point->flags2 |= flag;
+            point->hint    = hint;
+            break;
+          }
+        }
+        else if ( point_dir == -major_dir )
+        {
+          flag = PSH_POINT_EDGE_MAX;
+          d    = point->org_u - hint->org_pos - hint->org_len;
+
+          if ( FT_ABS( d ) < threshold )
+            goto Is_Strong;
+        }
+      }
+    }
+
+#if 1
+    else if ( psh_point_is_extremum( point ) )
+    {
+      /* treat extrema as special cases for stem edge alignment */
+      FT_UInt  min_flag, max_flag;
+
+
+      if ( major_dir == PSH_DIR_HORIZONTAL )
+      {
+        min_flag = PSH_POINT_POSITIVE;
+        max_flag = PSH_POINT_NEGATIVE;
+      }
+      else
+      {
+        min_flag = PSH_POINT_NEGATIVE;
+        max_flag = PSH_POINT_POSITIVE;
+      }
+
+      for ( ; num_hints > 0; num_hints--, sort++ )
+      {
+        PSH_Hint  hint = sort[0];
+        FT_Pos    d;
+        FT_Int    flag;
+
+
+        if ( point->flags2 & min_flag )
+        {
+          flag = PSH_POINT_EDGE_MIN;
+          d    = point->org_u - hint->org_pos;
+
+          if ( FT_ABS( d ) < threshold )
+          {
+          Is_Strong2:
+            point->flags2 |= flag;
+            point->hint    = hint;
+            psh_point_set_strong( point );
+            break;
+          }
+        }
+        else if ( point->flags2 & max_flag )
+        {
+          flag = PSH_POINT_EDGE_MAX;
+          d    = point->org_u - hint->org_pos - hint->org_len;
+
+          if ( FT_ABS( d ) < threshold )
+            goto Is_Strong2;
+        }
+
+        if ( point->org_u >= hint->org_pos                 &&
+             point->org_u <= hint->org_pos + hint->org_len )
+        {
+          point->hint = hint;
+        }
+      }
+    }
+
+#endif /* 1 */
+  }
+
+
+  /* the accepted shift for strong points in fractional pixels */
+#define PSH_STRONG_THRESHOLD  32
+
+  /* the maximum shift value in font units */
+#define PSH_STRONG_THRESHOLD_MAXIMUM  30
+
+
+  /* find strong points in a glyph */
+  static void
+  psh_glyph_find_strong_points( PSH_Glyph  glyph,
+                                FT_Int     dimension )
+  {
+    /* a point is `strong' if it is located on a stem edge and       */
+    /* has an `in' or `out' tangent parallel to the hint's direction */
+
+    PSH_Hint_Table  table     = &glyph->hint_tables[dimension];
+    PS_Mask         mask      = table->hint_masks->masks;
+    FT_UInt         num_masks = table->hint_masks->num_masks;
+    FT_UInt         first     = 0;
+    FT_Int          major_dir = dimension == 0 ? PSH_DIR_VERTICAL
+                                               : PSH_DIR_HORIZONTAL;
+    PSH_Dimension   dim       = &glyph->globals->dimension[dimension];
+    FT_Fixed        scale     = dim->scale_mult;
+    FT_Int          threshold;
+
+
+    threshold = (FT_Int)FT_DivFix( PSH_STRONG_THRESHOLD, scale );
+    if ( threshold > PSH_STRONG_THRESHOLD_MAXIMUM )
+      threshold = PSH_STRONG_THRESHOLD_MAXIMUM;
+
+    /* process secondary hints to `selected' points */
+    if ( num_masks > 1 && glyph->num_points > 0 )
+    {
+      first = mask->end_point;
+      mask++;
+      for ( ; num_masks > 1; num_masks--, mask++ )
+      {
+        FT_UInt  next;
+        FT_Int   count;
+
+
+        next  = mask->end_point;
+        count = next - first;
+        if ( count > 0 )
+        {
+          PSH_Point  point = glyph->points + first;
+
+
+          psh_hint_table_activate_mask( table, mask );
+
+          for ( ; count > 0; count--, point++ )
+            psh_hint_table_find_strong_point( table, point,
+                                              threshold, major_dir );
+        }
+        first = next;
+      }
+    }
+
+    /* process primary hints for all points */
+    if ( num_masks == 1 )
+    {
+      FT_UInt    count = glyph->num_points;
+      PSH_Point  point = glyph->points;
+
+
+      psh_hint_table_activate_mask( table, table->hint_masks->masks );
+      for ( ; count > 0; count--, point++ )
+      {
+        if ( !psh_point_is_strong( point ) )
+          psh_hint_table_find_strong_point( table, point,
+                                            threshold, major_dir );
+      }
+    }
+
+    /* now, certain points may have been attached to a hint and */
+    /* not marked as strong; update their flags then            */
+    {
+      FT_UInt    count = glyph->num_points;
+      PSH_Point  point = glyph->points;
+
+
+      for ( ; count > 0; count--, point++ )
+        if ( point->hint && !psh_point_is_strong( point ) )
+          psh_point_set_strong( point );
+    }
+  }
+
+
+  /* find points in a glyph which are in a blue zone and have `in' or */
+  /* `out' tangents parallel to the horizontal axis                   */
+  static void
+  psh_glyph_find_blue_points( PSH_Blues  blues,
+                              PSH_Glyph  glyph )
+  {
+    PSH_Blue_Table  table;
+    PSH_Blue_Zone   zone;
+    FT_UInt         glyph_count = glyph->num_points;
+    FT_UInt         blue_count;
+    PSH_Point       point = glyph->points;
+
+
+    for ( ; glyph_count > 0; glyph_count--, point++ )
+    {
+      FT_Pos  y;
+
+
+      /* check tangents */
+      if ( !PSH_DIR_COMPARE( point->dir_in,  PSH_DIR_HORIZONTAL ) &&
+           !PSH_DIR_COMPARE( point->dir_out, PSH_DIR_HORIZONTAL ) )
+        continue;
+
+      /* skip strong points */
+      if ( psh_point_is_strong( point ) )
+        continue;
+
+      y = point->org_u;
+
+      /* look up top zones */
+      table      = &blues->normal_top;
+      blue_count = table->count;
+      zone       = table->zones;
+
+      for ( ; blue_count > 0; blue_count--, zone++ )
+      {
+        FT_Pos  delta = y - zone->org_bottom;
+
+
+        if ( delta < -blues->blue_fuzz )
+          break;
+
+        if ( y <= zone->org_top + blues->blue_fuzz )
+          if ( blues->no_overshoots || delta <= blues->blue_threshold )
+          {
+            point->cur_u = zone->cur_bottom;
+            psh_point_set_strong( point );
+            psh_point_set_fitted( point );
+          }
+      }
+
+      /* look up bottom zones */
+      table      = &blues->normal_bottom;
+      blue_count = table->count;
+      zone       = table->zones + blue_count - 1;
+
+      for ( ; blue_count > 0; blue_count--, zone-- )
+      {
+        FT_Pos  delta = zone->org_top - y;
+
+
+        if ( delta < -blues->blue_fuzz )
+          break;
+
+        if ( y >= zone->org_bottom - blues->blue_fuzz )
+          if ( blues->no_overshoots || delta < blues->blue_threshold )
+          {
+            point->cur_u = zone->cur_top;
+            psh_point_set_strong( point );
+            psh_point_set_fitted( point );
+          }
+      }
+    }
+  }
+
+
+  /* interpolate strong points with the help of hinted coordinates */
+  static void
+  psh_glyph_interpolate_strong_points( PSH_Glyph  glyph,
+                                       FT_Int     dimension )
+  {
+    PSH_Dimension  dim   = &glyph->globals->dimension[dimension];
+    FT_Fixed       scale = dim->scale_mult;
+
+    FT_UInt        count = glyph->num_points;
+    PSH_Point      point = glyph->points;
+
+
+    for ( ; count > 0; count--, point++ )
+    {
+      PSH_Hint  hint = point->hint;
+
+
+      if ( hint )
+      {
+        FT_Pos  delta;
+
+
+        if ( psh_point_is_edge_min( point ) )
+          point->cur_u = hint->cur_pos;
+
+        else if ( psh_point_is_edge_max( point ) )
+          point->cur_u = hint->cur_pos + hint->cur_len;
+
+        else
+        {
+          delta = point->org_u - hint->org_pos;
+
+          if ( delta <= 0 )
+            point->cur_u = hint->cur_pos + FT_MulFix( delta, scale );
+
+          else if ( delta >= hint->org_len )
+            point->cur_u = hint->cur_pos + hint->cur_len +
+                             FT_MulFix( delta - hint->org_len, scale );
+
+          else if ( hint->org_len > 0 )
+            point->cur_u = hint->cur_pos +
+                             FT_MulDiv( delta, hint->cur_len,
+                                        hint->org_len );
+          else
+            point->cur_u = hint->cur_pos;
+        }
+        psh_point_set_fitted( point );
+      }
+    }
+  }
+
+
+  static void
+  psh_glyph_interpolate_normal_points( PSH_Glyph  glyph,
+                                       FT_Int     dimension )
+  {
+
+#if 1
+    /* first technique: a point is strong if it is a local extremum */
+
+    PSH_Dimension  dim   = &glyph->globals->dimension[dimension];
+    FT_Fixed       scale = dim->scale_mult;
+
+    FT_UInt        count = glyph->num_points;
+    PSH_Point      point = glyph->points;
+
+
+    for ( ; count > 0; count--, point++ )
+    {
+      if ( psh_point_is_strong( point ) )
+        continue;
+
+      /* sometimes, some local extrema are smooth points */
+      if ( psh_point_is_smooth( point ) )
+      {
+        if ( point->dir_in == PSH_DIR_NONE   ||
+             point->dir_in != point->dir_out )
+          continue;
+
+        if ( !psh_point_is_extremum( point ) &&
+             !psh_point_is_inflex( point )   )
+          continue;
+
+        point->flags &= ~PSH_POINT_SMOOTH;
+      }
+
+      /* find best enclosing point coordinates */
+      {
+        PSH_Point  before = 0;
+        PSH_Point  after  = 0;
+
+        FT_Pos     diff_before = -32000;
+        FT_Pos     diff_after  =  32000;
+        FT_Pos     u = point->org_u;
+
+        FT_Int     count2 = glyph->num_points;
+        PSH_Point  cur    = glyph->points;
+
+
+        for ( ; count2 > 0; count2--, cur++ )
+        {
+          if ( psh_point_is_strong( cur ) )
+          {
+            FT_Pos  diff = cur->org_u - u;
+
+
+            if ( diff <= 0 )
+            {
+              if ( diff > diff_before )
+              {
+                diff_before = diff;
+                before      = cur;
+              }
+            }
+
+            else if ( diff >= 0 )
+            {
+              if ( diff < diff_after )
+              {
+                diff_after = diff;
+                after      = cur;
+              }
+            }
+          }
+        }
+
+        if ( !before )
+        {
+          if ( !after )
+            continue;
+
+          /* we are before the first strong point coordinate; */
+          /* simply translate the point                       */
+          point->cur_u = after->cur_u +
+                           FT_MulFix( point->org_u - after->org_u, scale );
+        }
+        else if ( !after )
+        {
+          /* we are after the last strong point coordinate; */
+          /* simply translate the point                     */
+          point->cur_u = before->cur_u +
+                           FT_MulFix( point->org_u - before->org_u, scale );
+        }
+        else
+        {
+          if ( diff_before == 0 )
+            point->cur_u = before->cur_u;
+
+          else if ( diff_after == 0 )
+            point->cur_u = after->cur_u;
+
+          else
+            point->cur_u = before->cur_u +
+                             FT_MulDiv( u - before->org_u,
+                                        after->cur_u - before->cur_u,
+                                        after->org_u - before->org_u );
+        }
+
+        psh_point_set_fitted( point );
+      }
+    }
+
+#endif /* 1 */
+
+  }
+
+
+  /* interpolate other points */
+  static void
+  psh_glyph_interpolate_other_points( PSH_Glyph  glyph,
+                                      FT_Int     dimension )
+  {
+    PSH_Dimension  dim          = &glyph->globals->dimension[dimension];
+    FT_Fixed       scale        = dim->scale_mult;
+    FT_Fixed       delta        = dim->scale_delta;
+    PSH_Contour    contour      = glyph->contours;
+    FT_UInt        num_contours = glyph->num_contours;
+
+
+    for ( ; num_contours > 0; num_contours--, contour++ )
+    {
+      PSH_Point  start = contour->start;
+      PSH_Point  first, next, point;
+      FT_UInt    fit_count;
+
+
+      /* count the number of strong points in this contour */
+      next      = start + contour->count;
+      fit_count = 0;
+      first     = 0;
+
+      for ( point = start; point < next; point++ )
+        if ( psh_point_is_fitted( point ) )
+        {
+          if ( !first )
+            first = point;
+
+          fit_count++;
+        }
+
+      /* if there are less than 2 fitted points in the contour, we */
+      /* simply scale and eventually translate the contour points  */
+      if ( fit_count < 2 )
+      {
+        if ( fit_count == 1 )
+          delta = first->cur_u - FT_MulFix( first->org_u, scale );
+
+        for ( point = start; point < next; point++ )
+          if ( point != first )
+            point->cur_u = FT_MulFix( point->org_u, scale ) + delta;
+
+        goto Next_Contour;
+      }
+
+      /* there are more than 2 strong points in this contour; we */
+      /* need to interpolate weak points between them            */
+      start = first;
+      do
+      {
+        point = first;
+
+        /* skip consecutive fitted points */
+        for (;;)
+        {
+          next = first->next;
+          if ( next == start )
+            goto Next_Contour;
+
+          if ( !psh_point_is_fitted( next ) )
+            break;
+
+          first = next;
+        }
+
+        /* find next fitted point after unfitted one */
+        for (;;)
+        {
+          next = next->next;
+          if ( psh_point_is_fitted( next ) )
+            break;
+        }
+
+        /* now interpolate between them */
+        {
+          FT_Pos    org_a, org_ab, cur_a, cur_ab;
+          FT_Pos    org_c, org_ac, cur_c;
+          FT_Fixed  scale_ab;
+
+
+          if ( first->org_u <= next->org_u )
+          {
+            org_a  = first->org_u;
+            cur_a  = first->cur_u;
+            org_ab = next->org_u - org_a;
+            cur_ab = next->cur_u - cur_a;
+          }
+          else
+          {
+            org_a  = next->org_u;
+            cur_a  = next->cur_u;
+            org_ab = first->org_u - org_a;
+            cur_ab = first->cur_u - cur_a;
+          }
+
+          scale_ab = 0x10000L;
+          if ( org_ab > 0 )
+            scale_ab = FT_DivFix( cur_ab, org_ab );
+
+          point = first->next;
+          do
+          {
+            org_c  = point->org_u;
+            org_ac = org_c - org_a;
+
+            if ( org_ac <= 0 )
+            {
+              /* on the left of the interpolation zone */
+              cur_c = cur_a + FT_MulFix( org_ac, scale );
+            }
+            else if ( org_ac >= org_ab )
+            {
+              /* on the right on the interpolation zone */
+              cur_c = cur_a + cur_ab + FT_MulFix( org_ac - org_ab, scale );
+            }
+            else
+            {
+              /* within the interpolation zone */
+              cur_c = cur_a + FT_MulFix( org_ac, scale_ab );
+            }
+
+            point->cur_u = cur_c;
+
+            point = point->next;
+
+          } while ( point != next );
+        }
+
+        /* keep going until all points in the contours have been processed */
+        first = next;
+
+      } while ( first != start );
+
+    Next_Contour:
+      ;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                     HIGH-LEVEL INTERFACE                      *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_Error
+  ps_hints_apply( PS_Hints        ps_hints,
+                  FT_Outline*     outline,
+                  PSH_Globals     globals,
+                  FT_Render_Mode  hint_mode )
+  {
+    PSH_GlyphRec  glyphrec;
+    PSH_Glyph     glyph = &glyphrec;
+    FT_Error      error;
+#ifdef DEBUG_HINTER
+    FT_Memory     memory;
+#endif
+    FT_Int        dimension;
+
+
+    /* something to do? */
+    if ( outline->n_points == 0 || outline->n_contours == 0 )
+      return PSH_Err_Ok;
+
+#ifdef DEBUG_HINTER
+
+    memory = globals->memory;
+
+    if ( ps_debug_glyph )
+    {
+      psh_glyph_done( ps_debug_glyph );
+      FT_FREE( ps_debug_glyph );
+    }
+
+    if ( FT_NEW( glyph ) )
+      return error;
+
+    ps_debug_glyph = glyph;
+
+#endif /* DEBUG_HINTER */
+
+    error = psh_glyph_init( glyph, outline, ps_hints, globals );
+    if ( error )
+      goto Exit;
+
+    /* try to optimize the y_scale so that the top of non-capital letters
+     * is aligned on a pixel boundary whenever possible
+     */
+    {
+      PSH_Dimension  dim_x = &glyph->globals->dimension[0];
+      PSH_Dimension  dim_y = &glyph->globals->dimension[1];
+
+      FT_Fixed x_scale = dim_x->scale_mult;
+      FT_Fixed y_scale = dim_y->scale_mult;
+
+      FT_Fixed scaled;
+      FT_Fixed fitted;
+
+
+      scaled = FT_MulFix( globals->blues.normal_top.zones->org_ref, y_scale );
+      fitted = FT_PIX_ROUND( scaled );
+
+      if (scaled != fitted ) {
+        y_scale = FT_MulDiv( y_scale, fitted, scaled );
+
+        if ( fitted < scaled )
+          x_scale -= x_scale / 50;
+
+        psh_globals_set_scale( glyph->globals, x_scale, y_scale, 0, 0 );
+      }
+    }
+
+    glyph->do_horz_hints = 1;
+    glyph->do_vert_hints = 1;
+
+    glyph->do_horz_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO ||
+                                       hint_mode == FT_RENDER_MODE_LCD  );
+
+    glyph->do_vert_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO  ||
+                                       hint_mode == FT_RENDER_MODE_LCD_V );
+
+    glyph->do_stem_adjust   = FT_BOOL( hint_mode != FT_RENDER_MODE_LIGHT );
+
+    for ( dimension = 0; dimension < 2; dimension++ )
+    {
+      /* load outline coordinates into glyph */
+      psh_glyph_load_points( glyph, dimension );
+
+      /* compute local extrema */
+      psh_glyph_compute_extrema( glyph );
+
+      /* compute aligned stem/hints positions */
+      psh_hint_table_align_hints( &glyph->hint_tables[dimension],
+                                  glyph->globals,
+                                  dimension,
+                                  glyph );
+
+      /* find strong points, align them, then interpolate others */
+      psh_glyph_find_strong_points( glyph, dimension );
+      if ( dimension == 1 )
+        psh_glyph_find_blue_points( &globals->blues, glyph );
+      psh_glyph_interpolate_strong_points( glyph, dimension );
+      psh_glyph_interpolate_normal_points( glyph, dimension );
+      psh_glyph_interpolate_other_points( glyph, dimension );
+
+      /* save hinted coordinates back to outline */
+      psh_glyph_save_points( glyph, dimension );
+    }
+
+  Exit:
+
+#ifndef DEBUG_HINTER
+    psh_glyph_done( glyph );
+#endif
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshalgo.h b/nx-X11/extras/freetype2/src/pshinter/pshalgo.h
new file mode 100644
index 000000000..f68de7120
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshalgo.h
@@ -0,0 +1,255 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshalgo.h                                                              */
+/*                                                                         */
+/*    PostScript hinting algorithm (specification).                        */
+/*                                                                         */
+/*  Copyright 2001, 2002, 2003 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 __PSHALGO_H__
+#define __PSHALGO_H__
+
+
+#include "pshrec.h"
+#include "pshglob.h"
+#include FT_TRIGONOMETRY_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* handle to Hint structure */
+  typedef struct PSH_HintRec_*  PSH_Hint;
+
+  /* hint bit-flags */
+  typedef enum
+  {
+    PSH_HINT_GHOST  = PS_HINT_FLAG_GHOST,
+    PSH_HINT_BOTTOM = PS_HINT_FLAG_BOTTOM,
+    PSH_HINT_ACTIVE = 4,
+    PSH_HINT_FITTED = 8
+
+  } PSH_Hint_Flags;
+
+
+#define psh_hint_is_active( x )  ( ( (x)->flags & PSH_HINT_ACTIVE ) != 0 )
+#define psh_hint_is_ghost( x )   ( ( (x)->flags & PSH_HINT_GHOST  ) != 0 )
+#define psh_hint_is_fitted( x )  ( ( (x)->flags & PSH_HINT_FITTED ) != 0 )
+
+#define psh_hint_activate( x )    (x)->flags |=  PSH_HINT_ACTIVE
+#define psh_hint_deactivate( x )  (x)->flags &= ~PSH_HINT_ACTIVE
+#define psh_hint_set_fitted( x )  (x)->flags |=  PSH_HINT_FITTED
+
+  /* hint structure */
+  typedef struct  PSH_HintRec_
+  {
+    FT_Int    org_pos;
+    FT_Int    org_len;
+    FT_Pos    cur_pos;
+    FT_Pos    cur_len;
+    FT_UInt   flags;
+    PSH_Hint  parent;
+    FT_Int    order;
+
+  } PSH_HintRec;
+
+
+  /* this is an interpolation zone used for strong points;  */
+  /* weak points are interpolated according to their strong */
+  /* neighbours                                             */
+  typedef struct  PSH_ZoneRec_
+  {
+    FT_Fixed  scale;
+    FT_Fixed  delta;
+    FT_Pos    min;
+    FT_Pos    max;
+
+  } PSH_ZoneRec, *PSH_Zone;
+
+
+  typedef struct  PSH_Hint_TableRec_
+  {
+    FT_UInt        max_hints;
+    FT_UInt        num_hints;
+    PSH_Hint       hints;
+    PSH_Hint*      sort;
+    PSH_Hint*      sort_global;
+    FT_UInt        num_zones;
+    PSH_ZoneRec*   zones;
+    PSH_Zone       zone;
+    PS_Mask_Table  hint_masks;
+    PS_Mask_Table  counter_masks;
+
+  } PSH_Hint_TableRec, *PSH_Hint_Table;
+
+
+  typedef struct PSH_PointRec_*    PSH_Point;
+  typedef struct PSH_ContourRec_*  PSH_Contour;
+
+  enum
+  {
+    PSH_DIR_NONE  =  4,
+    PSH_DIR_UP    = -1,
+    PSH_DIR_DOWN  =  1,
+    PSH_DIR_LEFT  = -2,
+    PSH_DIR_RIGHT =  2
+  };
+
+#define PSH_DIR_HORIZONTAL  2
+#define PSH_DIR_VERTICAL    1
+
+#define PSH_DIR_COMPARE( d1, d2 )   ( (d1) == (d2) || (d1) == -(d2) )
+#define PSH_DIR_IS_HORIZONTAL( d )  PSH_DIR_COMPARE( d, PSH_DIR_HORIZONTAL )
+#define PSH_DIR_IS_VERTICAL( d )    PSH_DIR_COMPARE( d, PSH_DIR_VERTICAL )
+
+
+ /* the following bit-flags are computed once by the glyph */
+ /* analyzer, for both dimensions                          */
+  enum
+  {
+    PSH_POINT_OFF    = 1,   /* point is off the curve */
+    PSH_POINT_SMOOTH = 2,   /* point is smooth        */
+    PSH_POINT_INFLEX = 4    /* point is inflection    */
+  };
+
+#define psh_point_is_smooth( p )  ( (p)->flags & PSH_POINT_SMOOTH )
+#define psh_point_is_off( p )     ( (p)->flags & PSH_POINT_OFF    )
+#define psh_point_is_inflex( p )  ( (p)->flags & PSH_POINT_INFLEX )
+
+#define psh_point_set_smooth( p )  (p)->flags |= PSH_POINT_SMOOTH
+#define psh_point_set_off( p )     (p)->flags |= PSH_POINT_OFF
+#define psh_point_set_inflex( p )  (p)->flags |= PSH_POINT_INFLEX
+
+  /* the following bit-flags are re-computed for each dimension */
+  enum
+  {
+    PSH_POINT_STRONG   = 16,   /* point is strong                           */
+    PSH_POINT_FITTED   = 32,   /* point is already fitted                   */
+    PSH_POINT_EXTREMUM = 64,   /* point is local extremum                   */
+    PSH_POINT_POSITIVE = 128,  /* extremum has positive contour flow        */
+    PSH_POINT_NEGATIVE = 256,  /* extremum has negative contour flow        */
+    PSH_POINT_EDGE_MIN = 512,  /* point is aligned to left/bottom stem edge */
+    PSH_POINT_EDGE_MAX = 1024  /* point is aligned to top/right stem edge   */
+  };
+
+#define psh_point_is_strong( p )    ( (p)->flags2 & PSH_POINT_STRONG )
+#define psh_point_is_fitted( p )    ( (p)->flags2 & PSH_POINT_FITTED )
+#define psh_point_is_extremum( p )  ( (p)->flags2 & PSH_POINT_EXTREMUM )
+#define psh_point_is_positive( p )  ( (p)->flags2 & PSH_POINT_POSITIVE )
+#define psh_point_is_negative( p )  ( (p)->flags2 & PSH_POINT_NEGATIVE )
+#define psh_point_is_edge_min( p )  ( (p)->flags2 & PSH_POINT_EDGE_MIN )
+#define psh_point_is_edge_max( p )  ( (p)->flags2 & PSH_POINT_EDGE_MAX )
+
+#define psh_point_set_strong( p )    (p)->flags2 |= PSH_POINT_STRONG
+#define psh_point_set_fitted( p )    (p)->flags2 |= PSH_POINT_FITTED
+#define psh_point_set_extremum( p )  (p)->flags2 |= PSH_POINT_EXTREMUM
+#define psh_point_set_positive( p )  (p)->flags2 |= PSH_POINT_POSITIVE
+#define psh_point_set_negative( p )  (p)->flags2 |= PSH_POINT_NEGATIVE
+#define psh_point_set_edge_min( p )  (p)->flags2 |= PSH_POINT_EDGE_MIN
+#define psh_point_set_edge_max( p )  (p)->flags2 |= PSH_POINT_EDGE_MAX
+
+
+  typedef struct  PSH_PointRec_
+  {
+    PSH_Point    prev;
+    PSH_Point    next;
+    PSH_Contour  contour;
+    FT_UInt      flags;
+    FT_UInt      flags2;
+    FT_Char      dir_in;
+    FT_Char      dir_out;
+    FT_Angle     angle_in;
+    FT_Angle     angle_out;
+    PSH_Hint     hint;
+    FT_Pos       org_u;
+    FT_Pos       org_v;
+    FT_Pos       cur_u;
+#ifdef DEBUG_HINTER
+    FT_Pos       org_x;
+    FT_Pos       cur_x;
+    FT_Pos       org_y;
+    FT_Pos       cur_y;
+    FT_UInt      flags_x;
+    FT_UInt      flags_y;
+#endif
+
+  } PSH_PointRec;
+
+
+#define PSH_POINT_EQUAL_ORG( a, b )  ( (a)->org_u == (b)->org_u && \
+                                       (a)->org_v == (b)->org_v )
+
+#define PSH_POINT_ANGLE( a, b )  FT_Atan2( (b)->org_u - (a)->org_u,  \
+                                           (b)->org_v - (a)->org_v )
+
+  typedef struct  PSH_ContourRec_
+  {
+    PSH_Point  start;
+    FT_UInt    count;
+
+  } PSH_ContourRec;
+
+
+  typedef struct  PSH_GlyphRec_
+  {
+    FT_UInt            num_points;
+    FT_UInt            num_contours;
+
+    PSH_Point          points;
+    PSH_Contour        contours;
+
+    FT_Memory          memory;
+    FT_Outline*        outline;
+    PSH_Globals        globals;
+    PSH_Hint_TableRec  hint_tables[2];
+
+    FT_Bool            vertical;
+    FT_Int             major_dir;
+    FT_Int             minor_dir;
+
+    FT_Bool            do_horz_hints;
+    FT_Bool            do_vert_hints;
+    FT_Bool            do_horz_snapping;
+    FT_Bool            do_vert_snapping;
+    FT_Bool            do_stem_adjust;
+
+  } PSH_GlyphRec, *PSH_Glyph;
+
+
+#ifdef DEBUG_HINTER
+  extern PSH_Hint_Table  ps_debug_hint_table;
+
+  typedef void
+  (*PSH_HintFunc)( PSH_Hint  hint,
+                   FT_Bool   vertical );
+
+  extern PSH_HintFunc    ps_debug_hint_func;
+
+  extern PSH_Glyph       ps_debug_glyph;
+#endif
+
+
+  extern FT_Error
+  ps_hints_apply( PS_Hints        ps_hints,
+                  FT_Outline*     outline,
+                  PSH_Globals     globals,
+                  FT_Render_Mode  hint_mode );
+
+
+FT_END_HEADER
+
+
+#endif /* __PSHALGO_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshglob.c b/nx-X11/extras/freetype2/src/pshinter/pshglob.c
new file mode 100644
index 000000000..21d45e92f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshglob.c
@@ -0,0 +1,750 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshglob.c                                                              */
+/*                                                                         */
+/*    PostScript hinter global hinting management (body).                  */
+/*    Inspired by the new auto-hinter module.                              */
+/*                                                                         */
+/*  Copyright 2001, 2002, 2003, 2004 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_OBJECTS_H
+#include "pshglob.h"
+
+#ifdef DEBUG_HINTER
+  PSH_Globals  ps_debug_globals = 0;
+#endif
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       STANDARD WIDTHS                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* scale the widths/heights table */
+  static void
+  psh_globals_scale_widths( PSH_Globals  globals,
+                            FT_UInt      direction )
+  {
+    PSH_Dimension  dim   = &globals->dimension[direction];
+    PSH_Widths     stdw  = &dim->stdw;
+    FT_UInt        count = stdw->count;
+    PSH_Width      width = stdw->widths;
+    PSH_Width      stand = width;               /* standard width/height */
+    FT_Fixed       scale = dim->scale_mult;
+
+
+    if ( count > 0 )
+    {
+      width->cur = FT_MulFix( width->org, scale );
+      width->fit = FT_PIX_ROUND( width->cur );
+
+      width++;
+      count--;
+
+      for ( ; count > 0; count--, width++ )
+      {
+        FT_Pos  w, dist;
+
+
+        w    = FT_MulFix( width->org, scale );
+        dist = w - stand->cur;
+
+        if ( dist < 0 )
+          dist = -dist;
+
+        if ( dist < 128 )
+          w = stand->cur;
+
+        width->cur = w;
+        width->fit = FT_PIX_ROUND( w );
+      }
+    }
+  }
+
+
+#if 0
+
+  /* org_width is is font units, result in device pixels, 26.6 format */
+  FT_LOCAL_DEF( FT_Pos )
+  psh_dimension_snap_width( PSH_Dimension  dimension,
+                            FT_Int         org_width )
+  {
+    FT_UInt  n;
+    FT_Pos   width     = FT_MulFix( org_width, dimension->scale_mult );
+    FT_Pos   best      = 64 + 32 + 2;
+    FT_Pos   reference = width;
+
+
+    for ( n = 0; n < dimension->stdw.count; n++ )
+    {
+      FT_Pos  w;
+      FT_Pos  dist;
+
+
+      w = dimension->stdw.widths[n].cur;
+      dist = width - w;
+      if ( dist < 0 )
+        dist = -dist;
+      if ( dist < best )
+      {
+        best      = dist;
+        reference = w;
+      }
+    }
+
+    if ( width >= reference )
+    {
+      width -= 0x21;
+      if ( width < reference )
+        width = reference;
+    }
+    else
+    {
+      width += 0x21;
+      if ( width > reference )
+        width = reference;
+    }
+
+    return width;
+  }
+
+#endif /* 0 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       BLUE ZONES                              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  psh_blues_set_zones_0( PSH_Blues       target,
+                         FT_Bool         is_others,
+                         FT_UInt         read_count,
+                         FT_Short*       read,
+                         PSH_Blue_Table  top_table,
+                         PSH_Blue_Table  bot_table )
+  {
+    FT_UInt  count_top = top_table->count;
+    FT_UInt  count_bot = bot_table->count;
+    FT_Bool  first     = 1;
+
+    FT_UNUSED( target );
+
+
+    for ( ; read_count > 0; read_count -= 2 )
+    {
+      FT_Int         reference, delta;
+      FT_UInt        count;
+      PSH_Blue_Zone  zones, zone;
+      FT_Bool        top;
+
+
+      /* read blue zone entry, and select target top/bottom zone */
+      top = 0;
+      if ( first || is_others )
+      {
+        reference = read[1];
+        delta     = read[0] - reference;
+
+        zones = bot_table->zones;
+        count = count_bot;
+        first = 0;
+      }
+      else
+      {
+        reference = read[0];
+        delta     = read[1] - reference;
+
+        zones = top_table->zones;
+        count = count_top;
+        top   = 1;
+      }
+
+      /* insert into sorted table */
+      zone = zones;
+      for ( ; count > 0; count--, zone++ )
+      {
+        if ( reference < zone->org_ref )
+          break;
+
+        if ( reference == zone->org_ref )
+        {
+          FT_Int  delta0 = zone->org_delta;
+
+
+          /* we have two zones on the same reference position -- */
+          /* only keep the largest one                           */
+          if ( delta < 0 )
+          {
+            if ( delta < delta0 )
+              zone->org_delta = delta;
+          }
+          else
+          {
+            if ( delta > delta0 )
+              zone->org_delta = delta;
+          }
+          goto Skip;
+        }
+      }
+
+      for ( ; count > 0; count-- )
+        zone[count] = zone[count-1];
+
+      zone->org_ref   = reference;
+      zone->org_delta = delta;
+
+      if ( top )
+        count_top++;
+      else
+        count_bot++;
+
+    Skip:
+      read += 2;
+    }
+
+    top_table->count = count_top;
+    bot_table->count = count_bot;
+  }
+
+
+  /* Re-read blue zones from the original fonts and store them into out */
+  /* private structure.  This function re-orders, sanitizes and         */
+  /* fuzz-expands the zones as well.                                    */
+  static void
+  psh_blues_set_zones( PSH_Blues  target,
+                       FT_UInt    count,
+                       FT_Short*  blues,
+                       FT_UInt    count_others,
+                       FT_Short*  other_blues,
+                       FT_Int     fuzz,
+                       FT_Int     family )
+  {
+    PSH_Blue_Table  top_table, bot_table;
+    FT_Int          count_top, count_bot;
+
+
+    if ( family )
+    {
+      top_table = &target->family_top;
+      bot_table = &target->family_bottom;
+    }
+    else
+    {
+      top_table = &target->normal_top;
+      bot_table = &target->normal_bottom;
+    }
+
+    /* read the input blue zones, and build two sorted tables  */
+    /* (one for the top zones, the other for the bottom zones) */
+    top_table->count = 0;
+    bot_table->count = 0;
+
+    /* first, the blues */
+    psh_blues_set_zones_0( target, 0,
+                           count, blues, top_table, bot_table );
+    psh_blues_set_zones_0( target, 1,
+                           count_others, other_blues, top_table, bot_table );
+
+    count_top = top_table->count;
+    count_bot = bot_table->count;
+
+    /* sanitize top table */
+    if ( count_top > 0 )
+    {
+      PSH_Blue_Zone  zone = top_table->zones;
+
+
+      for ( count = count_top; count > 0; count--, zone++ )
+      {
+        FT_Int  delta;
+
+
+        if ( count > 1 )
+        {
+          delta = zone[1].org_ref - zone[0].org_ref;
+          if ( zone->org_delta > delta )
+            zone->org_delta = delta;
+        }
+
+        zone->org_bottom = zone->org_ref;
+        zone->org_top    = zone->org_delta + zone->org_ref;
+      }
+    }
+
+    /* sanitize bottom table */
+    if ( count_bot > 0 )
+    {
+      PSH_Blue_Zone  zone = bot_table->zones;
+
+
+      for ( count = count_bot; count > 0; count--, zone++ )
+      {
+        FT_Int  delta;
+
+
+        if ( count > 1 )
+        {
+          delta = zone[0].org_ref - zone[1].org_ref;
+          if ( zone->org_delta < delta )
+            zone->org_delta = delta;
+        }
+
+        zone->org_top    = zone->org_ref;
+        zone->org_bottom = zone->org_delta + zone->org_ref;
+      }
+    }
+
+    /* expand top and bottom tables with blue fuzz */
+    {
+      FT_Int         dim, top, bot, delta;
+      PSH_Blue_Zone  zone;
+
+
+      zone  = top_table->zones;
+      count = count_top;
+
+      for ( dim = 1; dim >= 0; dim-- )
+      {
+        if ( count > 0 )
+        {
+          /* expand the bottom of the lowest zone normally */
+          zone->org_bottom -= fuzz;
+
+          /* expand the top and bottom of intermediate zones;    */
+          /* checking that the interval is smaller than the fuzz */
+          top = zone->org_top;
+
+          for ( count--; count > 0; count-- )
+          {
+            bot   = zone[1].org_bottom;
+            delta = bot - top;
+
+            if ( delta < 2 * fuzz )
+              zone[0].org_top = zone[1].org_bottom = top + delta / 2;
+            else
+            {
+              zone[0].org_top    = top + fuzz;
+              zone[1].org_bottom = bot - fuzz;
+            }
+
+            zone++;
+            top = zone->org_top;
+          }
+
+          /* expand the top of the highest zone normally */
+          zone->org_top = top + fuzz;
+        }
+        zone  = bot_table->zones;
+        count = count_bot;
+      }
+    }
+  }
+
+
+  /* reset the blues table when the device transform changes */
+  static void
+  psh_blues_scale_zones( PSH_Blues  blues,
+                         FT_Fixed   scale,
+                         FT_Pos     delta )
+  {
+    FT_UInt         count;
+    FT_UInt         num;
+    PSH_Blue_Table  table = 0;
+
+    /*                                                        */
+    /* Determine whether we need to suppress overshoots or    */
+    /* not.  We simply need to compare the vertical scale     */
+    /* parameter to the raw bluescale value.  Here is why:    */
+    /*                                                        */
+    /*   We need to suppress overshoots for all pointsizes.   */
+    /*   At 300dpi that satisfies:                            */
+    /*                                                        */
+    /*      pointsize < 240*bluescale + 0.49                  */
+    /*                                                        */
+    /*   This corresponds to:                                 */
+    /*                                                        */
+    /*      pixelsize < 1000*bluescale + 49/24                */
+    /*                                                        */
+    /*      scale*EM_Size < 1000*bluescale + 49/24            */
+    /*                                                        */
+    /*   However, for normal Type 1 fonts, EM_Size is 1000!   */
+    /*   We thus only check:                                  */
+    /*                                                        */
+    /*      scale < bluescale + 49/24000                      */
+    /*                                                        */
+    /*   which we shorten to                                  */
+    /*                                                        */
+    /*      "scale < bluescale"                               */
+    /*                                                        */
+    /* Note that `blue_scale' is stored 1000 times its real   */
+    /* value, and that `scale' converts from font units to    */
+    /* fractional pixels.                                     */
+    /*                                                        */
+
+    /* 1000 / 64 = 125 / 8 */
+    if ( scale >= 0x20C49BAL )
+      blues->no_overshoots = FT_BOOL( scale < blues->blue_scale * 8 / 125 );
+    else
+      blues->no_overshoots = FT_BOOL( scale * 125 < blues->blue_scale * 8 );
+
+    /*                                                        */
+    /*  The blue threshold is the font units distance under   */
+    /*  which overshoots are suppressed due to the BlueShift  */
+    /*  even if the scale is greater than BlueScale.          */
+    /*                                                        */
+    /*  It is the smallest distance such that                 */
+    /*                                                        */
+    /*    dist <= BlueShift && dist*scale <= 0.5 pixels       */
+    /*                                                        */
+    {
+      FT_Int  threshold = blues->blue_shift;
+
+
+      while ( threshold > 0 && FT_MulFix( threshold, scale ) > 32 )
+        threshold--;
+
+      blues->blue_threshold = threshold;
+    }
+
+    for ( num = 0; num < 4; num++ )
+    {
+      PSH_Blue_Zone  zone;
+
+
+      switch ( num )
+      {
+      case 0:
+        table = &blues->normal_top;
+        break;
+      case 1:
+        table = &blues->normal_bottom;
+        break;
+      case 2:
+        table = &blues->family_top;
+        break;
+      default:
+        table = &blues->family_bottom;
+        break;
+      }
+
+      zone  = table->zones;
+      count = table->count;
+      for ( ; count > 0; count--, zone++ )
+      {
+        zone->cur_top    = FT_MulFix( zone->org_top,    scale ) + delta;
+        zone->cur_bottom = FT_MulFix( zone->org_bottom, scale ) + delta;
+        zone->cur_ref    = FT_MulFix( zone->org_ref,    scale ) + delta;
+        zone->cur_delta  = FT_MulFix( zone->org_delta,  scale );
+
+        /* round scaled reference position */
+        zone->cur_ref = FT_PIX_ROUND( zone->cur_ref );
+
+#if 0
+        if ( zone->cur_ref > zone->cur_top )
+          zone->cur_ref -= 64;
+        else if ( zone->cur_ref < zone->cur_bottom )
+          zone->cur_ref += 64;
+#endif
+      }
+    }
+
+    /* process the families now */
+
+    for ( num = 0; num < 2; num++ )
+    {
+      PSH_Blue_Zone   zone1, zone2;
+      FT_UInt         count1, count2;
+      PSH_Blue_Table  normal, family;
+
+
+      switch ( num )
+      {
+      case 0:
+        normal = &blues->normal_top;
+        family = &blues->family_top;
+        break;
+
+      default:
+        normal = &blues->normal_bottom;
+        family = &blues->family_bottom;
+      }
+
+      zone1  = normal->zones;
+      count1 = normal->count;
+
+      for ( ; count1 > 0; count1--, zone1++ )
+      {
+        /* try to find a family zone whose reference position is less */
+        /* than 1 pixel far from the current zone                     */
+        zone2  = family->zones;
+        count2 = family->count;
+
+        for ( ; count2 > 0; count2--, zone2++ )
+        {
+          FT_Pos  Delta;
+
+
+          Delta = zone1->org_ref - zone2->org_ref;
+          if ( Delta < 0 )
+            Delta = -Delta;
+
+          if ( FT_MulFix( Delta, scale ) < 64 )
+          {
+            zone1->cur_top    = zone2->cur_top;
+            zone1->cur_bottom = zone2->cur_bottom;
+            zone1->cur_ref    = zone2->cur_ref;
+            zone1->cur_delta  = zone2->cur_delta;
+            break;
+          }
+        }
+      }
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  psh_blues_snap_stem( PSH_Blues      blues,
+                       FT_Int         stem_top,
+                       FT_Int         stem_bot,
+                       PSH_Alignment  alignment )
+  {
+    PSH_Blue_Table  table;
+    FT_UInt         count;
+    FT_Pos          delta;
+    PSH_Blue_Zone   zone;
+    FT_Int          no_shoots;
+
+
+    alignment->align = PSH_BLUE_ALIGN_NONE;
+
+    no_shoots = blues->no_overshoots;
+
+    /* look up stem top in top zones table */
+    table = &blues->normal_top;
+    count = table->count;
+    zone  = table->zones;
+
+    for ( ; count > 0; count--, zone++ )
+    {
+      delta = stem_top - zone->org_bottom;
+      if ( delta < -blues->blue_fuzz )
+        break;
+
+      if ( stem_top <= zone->org_top + blues->blue_fuzz )
+      {
+        if ( no_shoots || delta <= blues->blue_threshold )
+        {
+          alignment->align    |= PSH_BLUE_ALIGN_TOP;
+          alignment->align_top = zone->cur_ref;
+        }
+        break;
+      }
+    }
+
+    /* look up stem bottom in bottom zones table */
+    table = &blues->normal_bottom;
+    count = table->count;
+    zone  = table->zones + count-1;
+
+    for ( ; count > 0; count--, zone-- )
+    {
+      delta = zone->org_top - stem_bot;
+      if ( delta < -blues->blue_fuzz )
+        break;
+
+      if ( stem_bot >= zone->org_bottom - blues->blue_fuzz )
+      {
+        if ( no_shoots || delta < blues->blue_threshold )
+        {
+          alignment->align    |= PSH_BLUE_ALIGN_BOT;
+          alignment->align_bot = zone->cur_ref;
+        }
+        break;
+      }
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        GLOBAL HINTS                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  psh_globals_destroy( PSH_Globals  globals )
+  {
+    if ( globals )
+    {
+      FT_Memory  memory;
+
+
+      memory = globals->memory;
+      globals->dimension[0].stdw.count = 0;
+      globals->dimension[1].stdw.count = 0;
+
+      globals->blues.normal_top.count    = 0;
+      globals->blues.normal_bottom.count = 0;
+      globals->blues.family_top.count    = 0;
+      globals->blues.family_bottom.count = 0;
+
+      FT_FREE( globals );
+
+#ifdef DEBUG_HINTER
+      ps_debug_globals = 0;
+#endif
+    }
+  }
+
+
+  static FT_Error
+  psh_globals_new( FT_Memory     memory,
+                   T1_Private*   priv,
+                   PSH_Globals  *aglobals )
+  {
+    PSH_Globals  globals;
+    FT_Error     error;
+
+
+    if ( !FT_NEW( globals ) )
+    {
+      FT_UInt    count;
+      FT_Short*  read;
+
+
+      globals->memory = memory;
+
+      /* copy standard widths */
+      {
+        PSH_Dimension  dim   = &globals->dimension[1];
+        PSH_Width      write = dim->stdw.widths;
+
+
+        write->org = priv->standard_width[0];
+        write++;
+
+        read = priv->snap_widths;
+        for ( count = priv->num_snap_widths; count > 0; count-- )
+        {
+          write->org = *read;
+          write++;
+          read++;
+        }
+
+        dim->stdw.count = priv->num_snap_widths + 1;
+      }
+
+      /* copy standard heights */
+      {
+        PSH_Dimension  dim = &globals->dimension[0];
+        PSH_Width      write = dim->stdw.widths;
+
+
+        write->org = priv->standard_height[0];
+        write++;
+        read = priv->snap_heights;
+        for ( count = priv->num_snap_heights; count > 0; count-- )
+        {
+          write->org = *read;
+          write++;
+          read++;
+        }
+
+        dim->stdw.count = priv->num_snap_heights + 1;
+      }
+
+      /* copy blue zones */
+      psh_blues_set_zones( &globals->blues, priv->num_blue_values,
+                           priv->blue_values, priv->num_other_blues,
+                           priv->other_blues, priv->blue_fuzz, 0 );
+
+      psh_blues_set_zones( &globals->blues, priv->num_family_blues,
+                           priv->family_blues, priv->num_family_other_blues,
+                           priv->family_other_blues, priv->blue_fuzz, 1 );
+
+      globals->blues.blue_scale = priv->blue_scale;
+      globals->blues.blue_shift = priv->blue_shift;
+      globals->blues.blue_fuzz  = priv->blue_fuzz;
+
+      globals->dimension[0].scale_mult  = 0;
+      globals->dimension[0].scale_delta = 0;
+      globals->dimension[1].scale_mult  = 0;
+      globals->dimension[1].scale_delta = 0;
+
+#ifdef DEBUG_HINTER
+      ps_debug_globals = globals;
+#endif
+    }
+
+    *aglobals = globals;
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  psh_globals_set_scale( PSH_Globals  globals,
+                         FT_Fixed     x_scale,
+                         FT_Fixed     y_scale,
+                         FT_Fixed     x_delta,
+                         FT_Fixed     y_delta )
+  {
+    PSH_Dimension  dim = &globals->dimension[0];
+
+
+    dim = &globals->dimension[0];
+    if ( x_scale != dim->scale_mult  ||
+         x_delta != dim->scale_delta )
+    {
+      dim->scale_mult  = x_scale;
+      dim->scale_delta = x_delta;
+
+      psh_globals_scale_widths( globals, 0 );
+    }
+
+    dim = &globals->dimension[1];
+    if ( y_scale != dim->scale_mult  ||
+         y_delta != dim->scale_delta )
+    {
+      dim->scale_mult  = y_scale;
+      dim->scale_delta = y_delta;
+
+      psh_globals_scale_widths( globals, 1 );
+      psh_blues_scale_zones( &globals->blues, y_scale, y_delta );
+    }
+
+    return 0;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  psh_globals_funcs_init( PSH_Globals_FuncsRec*  funcs )
+  {
+    funcs->create    = psh_globals_new;
+    funcs->set_scale = psh_globals_set_scale;
+    funcs->destroy   = psh_globals_destroy;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshglob.h b/nx-X11/extras/freetype2/src/pshinter/pshglob.h
new file mode 100644
index 000000000..c51162615
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshglob.h
@@ -0,0 +1,196 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshglob.h                                                              */
+/*                                                                         */
+/*    PostScript hinter global hinting management.                         */
+/*                                                                         */
+/*  Copyright 2001, 2002, 2003 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 __PSHGLOB_H__
+#define __PSHGLOB_H__
+
+
+#include FT_FREETYPE_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    GLOBAL HINTS INTERNALS                     *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @constant:                                                            */
+  /*    PS_GLOBALS_MAX_BLUE_ZONES                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    The maximum number of blue zones in a font global hints structure. */
+  /*    See @PS_Globals_BluesRec.                                          */
+  /*                                                                       */
+#define PS_GLOBALS_MAX_BLUE_ZONES  16
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @constant:                                                            */
+  /*    PS_GLOBALS_MAX_STD_WIDTHS                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    The maximum number of standard and snap widths in either the       */
+  /*    horizontal or vertical direction.  See @PS_Globals_WidthsRec.      */
+  /*                                                                       */
+#define PS_GLOBALS_MAX_STD_WIDTHS  16
+
+
+  /* standard and snap width */
+  typedef struct  PSH_WidthRec_
+  {
+    FT_Int  org;
+    FT_Pos  cur;
+    FT_Pos  fit;
+
+  } PSH_WidthRec, *PSH_Width;
+
+
+  /* standard and snap widths table */
+  typedef struct  PSH_WidthsRec_
+  {
+    FT_UInt       count;
+    PSH_WidthRec  widths[PS_GLOBALS_MAX_STD_WIDTHS];
+
+  } PSH_WidthsRec, *PSH_Widths;
+
+
+  typedef struct  PSH_DimensionRec_
+  {
+    PSH_WidthsRec  stdw;
+    FT_Fixed       scale_mult;
+    FT_Fixed       scale_delta;
+
+  } PSH_DimensionRec, *PSH_Dimension;
+
+
+  /* blue zone descriptor */
+  typedef struct  PSH_Blue_ZoneRec_
+  {
+    FT_Int  org_ref;
+    FT_Int  org_delta;
+    FT_Int  org_top;
+    FT_Int  org_bottom;
+
+    FT_Pos  cur_ref;
+    FT_Pos  cur_delta;
+    FT_Pos  cur_bottom;
+    FT_Pos  cur_top;
+
+  } PSH_Blue_ZoneRec, *PSH_Blue_Zone;
+
+
+  typedef struct  PSH_Blue_TableRec_
+  {
+    FT_UInt           count;
+    PSH_Blue_ZoneRec  zones[PS_GLOBALS_MAX_BLUE_ZONES];
+
+  } PSH_Blue_TableRec, *PSH_Blue_Table;
+
+
+  /* blue zones table */
+  typedef struct  PSH_BluesRec_
+  {
+    PSH_Blue_TableRec  normal_top;
+    PSH_Blue_TableRec  normal_bottom;
+    PSH_Blue_TableRec  family_top;
+    PSH_Blue_TableRec  family_bottom;
+
+    FT_Fixed           blue_scale;
+    FT_Int             blue_shift;
+    FT_Int             blue_threshold;
+    FT_Int             blue_fuzz;
+    FT_Bool            no_overshoots;
+
+  } PSH_BluesRec, *PSH_Blues;
+
+
+  /* font globals.                                         */
+  /* dimension 0 => X coordinates + vertical hints/stems   */
+  /* dimension 1 => Y coordinates + horizontal hints/stems */
+  typedef struct  PSH_GlobalsRec_
+  {
+    FT_Memory         memory;
+    PSH_DimensionRec  dimension[2];
+    PSH_BluesRec      blues;
+
+  } PSH_GlobalsRec;
+
+
+#define PSH_BLUE_ALIGN_NONE  0
+#define PSH_BLUE_ALIGN_TOP   1
+#define PSH_BLUE_ALIGN_BOT   2
+
+
+  typedef struct  PSH_AlignmentRec_
+  {
+    int     align;
+    FT_Pos  align_top;
+    FT_Pos  align_bot;
+
+  } PSH_AlignmentRec, *PSH_Alignment;
+
+
+  FT_LOCAL( void )
+  psh_globals_funcs_init( PSH_Globals_FuncsRec*  funcs );
+
+
+#if 0
+  /* snap a stem width to fitter coordinates.  `org_width' is in font */
+  /* units.  The result is in device pixels (26.6 format).            */
+  FT_LOCAL( FT_Pos )
+  psh_dimension_snap_width( PSH_Dimension  dimension,
+                            FT_Int         org_width );
+#endif
+
+  FT_LOCAL( FT_Error )
+  psh_globals_set_scale( PSH_Globals  globals,
+                         FT_Fixed     x_scale,
+                         FT_Fixed     y_scale,
+                         FT_Fixed     x_delta,
+                         FT_Fixed     y_delta );
+
+  /* snap a stem to one or two blue zones */
+  FT_LOCAL( void )
+  psh_blues_snap_stem( PSH_Blues      blues,
+                       FT_Int         stem_top,
+                       FT_Int         stem_bot,
+                       PSH_Alignment  alignment );
+  /* */
+
+#ifdef DEBUG_HINTER
+  extern PSH_Globals  ps_debug_globals;
+#endif
+
+
+FT_END_HEADER
+
+
+#endif /* __PSHGLOB_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshinter.c b/nx-X11/extras/freetype2/src/pshinter/pshinter.c
new file mode 100644
index 000000000..8e3f19309
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshinter.c
@@ -0,0 +1,28 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshinter.c                                                             */
+/*                                                                         */
+/*    FreeType PostScript Hinting module                                   */
+/*                                                                         */
+/*  Copyright 2001, 2003 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 "pshrec.c"
+#include "pshglob.c"
+#include "pshalgo.c"
+#include "pshmod.c"
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshmod.c b/nx-X11/extras/freetype2/src/pshinter/pshmod.c
new file mode 100644
index 000000000..5b18684c7
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshmod.c
@@ -0,0 +1,120 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshmod.c                                                               */
+/*                                                                         */
+/*    FreeType PostScript hinter module implementation (body).             */
+/*                                                                         */
+/*  Copyright 2001, 2002 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_OBJECTS_H
+#include "pshrec.h"
+#include "pshalgo.h"
+
+
+  /* the Postscript Hinter module structure */
+  typedef struct  PS_Hinter_Module_Rec_
+  {
+    FT_ModuleRec          root;
+    PS_HintsRec           ps_hints;
+
+    PSH_Globals_FuncsRec  globals_funcs;
+    T1_Hints_FuncsRec     t1_funcs;
+    T2_Hints_FuncsRec     t2_funcs;
+
+  } PS_Hinter_ModuleRec, *PS_Hinter_Module;
+
+
+  /* finalize module */
+  FT_CALLBACK_DEF( void )
+  ps_hinter_done( PS_Hinter_Module  module )
+  {
+    module->t1_funcs.hints = NULL;
+    module->t2_funcs.hints = NULL;
+
+    ps_hints_done( &module->ps_hints );
+  }
+
+
+  /* initialize module, create hints recorder and the interface */
+  FT_CALLBACK_DEF( FT_Error )
+  ps_hinter_init( PS_Hinter_Module  module )
+  {
+    FT_Memory  memory = module->root.memory;
+
+
+    ps_hints_init( &module->ps_hints, memory );
+
+    psh_globals_funcs_init( &module->globals_funcs );
+
+    t1_hints_funcs_init( &module->t1_funcs );
+    module->t1_funcs.hints = (T1_Hints)&module->ps_hints;
+
+    t2_hints_funcs_init( &module->t2_funcs );
+    module->t2_funcs.hints = (T2_Hints)&module->ps_hints;
+
+    return 0;
+  }
+
+
+  /* returns global hints interface */
+  FT_CALLBACK_DEF( PSH_Globals_Funcs )
+  pshinter_get_globals_funcs( FT_Module  module )
+  {
+    return &((PS_Hinter_Module)module)->globals_funcs;
+  }
+
+
+  /* return Type 1 hints interface */
+  FT_CALLBACK_DEF( T1_Hints_Funcs )
+  pshinter_get_t1_funcs( FT_Module  module )
+  {
+    return &((PS_Hinter_Module)module)->t1_funcs;
+  }
+
+
+  /* return Type 2 hints interface */
+  FT_CALLBACK_DEF( T2_Hints_Funcs )
+  pshinter_get_t2_funcs( FT_Module  module )
+  {
+    return &((PS_Hinter_Module)module)->t2_funcs;
+  }
+
+
+  static
+  const PSHinter_Interface  pshinter_interface =
+  {
+    pshinter_get_globals_funcs,
+    pshinter_get_t1_funcs,
+    pshinter_get_t2_funcs
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Module_Class  pshinter_module_class =
+  {
+    0,
+    sizeof ( PS_Hinter_ModuleRec ),
+    "pshinter",
+    0x10000L,
+    0x20000L,
+
+    &pshinter_interface,            /* module-specific interface */
+
+    (FT_Module_Constructor)ps_hinter_init,
+    (FT_Module_Destructor) ps_hinter_done,
+    (FT_Module_Requester)  0        /* no additional interface for now */
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshmod.h b/nx-X11/extras/freetype2/src/pshinter/pshmod.h
new file mode 100644
index 000000000..1a91025b2
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshmod.h
@@ -0,0 +1,39 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshmod.h                                                               */
+/*                                                                         */
+/*    PostScript hinter module interface (specification).                  */
+/*                                                                         */
+/*  Copyright 2001 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 __PSHMOD_H__
+#define __PSHMOD_H__
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Module_Class )  pshinter_module_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __PSHMOD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshnterr.h b/nx-X11/extras/freetype2/src/pshinter/pshnterr.h
new file mode 100644
index 000000000..3c0029fbf
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshnterr.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshnterr.h                                                             */
+/*                                                                         */
+/*    PS Hinter error codes (specification only).                          */
+/*                                                                         */
+/*  Copyright 2003 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 PSHinter error enumeration constants. */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __PSHNTERR_H__
+#define __PSHNTERR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  PSH_Err_
+#define FT_ERR_BASE    FT_Mod_Err_PShinter
+
+#include FT_ERRORS_H
+
+#endif /* __PSHNTERR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshrec.c b/nx-X11/extras/freetype2/src/pshinter/pshrec.c
new file mode 100644
index 000000000..648de18bc
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshrec.c
@@ -0,0 +1,1215 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshrec.c                                                               */
+/*                                                                         */
+/*    FreeType PostScript hints recorder (body).                           */
+/*                                                                         */
+/*  Copyright 2001, 2002, 2003, 2004 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_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include "pshrec.h"
+#include "pshalgo.h"
+
+#include "pshnterr.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pshrec
+
+#ifdef DEBUG_HINTER
+  PS_Hints  ps_debug_hints         = 0;
+  int       ps_debug_no_horz_hints = 0;
+  int       ps_debug_no_vert_hints = 0;
+#endif
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      PS_HINT MANAGEMENT                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* destroy hints table */
+  static void
+  ps_hint_table_done( PS_Hint_Table  table,
+                      FT_Memory      memory )
+  {
+    FT_FREE( table->hints );
+    table->num_hints = 0;
+    table->max_hints = 0;
+  }
+
+
+  /* ensure that a table can contain "count" elements */
+  static FT_Error
+  ps_hint_table_ensure( PS_Hint_Table  table,
+                        FT_UInt        count,
+                        FT_Memory      memory )
+  {
+    FT_UInt   old_max = table->max_hints;
+    FT_UInt   new_max = count;
+    FT_Error  error   = 0;
+
+
+    if ( new_max > old_max )
+    {
+      /* try to grow the table */
+      new_max = FT_PAD_CEIL( new_max, 8 );
+      if ( !FT_RENEW_ARRAY( table->hints, old_max, new_max ) )
+        table->max_hints = new_max;
+    }
+    return error;
+  }
+
+
+  static FT_Error
+  ps_hint_table_alloc( PS_Hint_Table  table,
+                       FT_Memory      memory,
+                       PS_Hint       *ahint )
+  {
+    FT_Error  error = 0;
+    FT_UInt   count;
+    PS_Hint   hint = 0;
+
+
+    count = table->num_hints;
+    count++;
+
+    if ( count >= table->max_hints )
+    {
+      error = ps_hint_table_ensure( table, count, memory );
+      if ( error )
+        goto Exit;
+    }
+
+    hint        = table->hints + count - 1;
+    hint->pos   = 0;
+    hint->len   = 0;
+    hint->flags = 0;
+
+    table->num_hints = count;
+
+  Exit:
+    *ahint = hint;
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      PS_MASK MANAGEMENT                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* destroy mask */
+  static void
+  ps_mask_done( PS_Mask    mask,
+                FT_Memory  memory )
+  {
+    FT_FREE( mask->bytes );
+    mask->num_bits  = 0;
+    mask->max_bits  = 0;
+    mask->end_point = 0;
+  }
+
+
+  /* ensure that a mask can contain "count" bits */
+  static FT_Error
+  ps_mask_ensure( PS_Mask    mask,
+                  FT_UInt    count,
+                  FT_Memory  memory )
+  {
+    FT_UInt   old_max = ( mask->max_bits + 7 ) >> 3;
+    FT_UInt   new_max = ( count          + 7 ) >> 3;
+    FT_Error  error   = 0;
+
+
+    if ( new_max > old_max )
+    {
+      new_max = FT_PAD_CEIL( new_max, 8 );
+      if ( !FT_RENEW_ARRAY( mask->bytes, old_max, new_max ) )
+        mask->max_bits = new_max * 8;
+    }
+    return error;
+  }
+
+
+  /* test a bit value in a given mask */
+  static FT_Int
+  ps_mask_test_bit( PS_Mask  mask,
+                    FT_Int   idx )
+  {
+    if ( (FT_UInt)idx >= mask->num_bits )
+      return 0;
+
+    return mask->bytes[idx >> 3] & ( 0x80 >> ( idx & 7 ) );
+  }
+
+
+  /* clear a given bit */
+  static void
+  ps_mask_clear_bit( PS_Mask  mask,
+                     FT_Int   idx )
+  {
+    FT_Byte*  p;
+
+
+    if ( (FT_UInt)idx >= mask->num_bits )
+      return;
+
+    p    = mask->bytes + ( idx >> 3 );
+    p[0] = (FT_Byte)( p[0] & ~( 0x80 >> ( idx & 7 ) ) );
+  }
+
+
+  /* set a given bit, possibly grow the mask */
+  static FT_Error
+  ps_mask_set_bit( PS_Mask    mask,
+                   FT_Int     idx,
+                   FT_Memory  memory )
+  {
+    FT_Error  error = 0;
+    FT_Byte*  p;
+
+
+    if ( idx < 0 )
+      goto Exit;
+
+    if ( (FT_UInt)idx >= mask->num_bits )
+    {
+      error = ps_mask_ensure( mask, idx + 1, memory );
+      if ( error )
+        goto Exit;
+
+      mask->num_bits = idx + 1;
+    }
+
+    p    = mask->bytes + ( idx >> 3 );
+    p[0] = (FT_Byte)( p[0] | ( 0x80 >> ( idx & 7 ) ) );
+
+  Exit:
+    return error;
+  }
+
+
+  /* destroy mask table */
+  static void
+  ps_mask_table_done( PS_Mask_Table  table,
+                      FT_Memory      memory )
+  {
+    FT_UInt  count = table->max_masks;
+    PS_Mask  mask  = table->masks;
+
+
+    for ( ; count > 0; count--, mask++ )
+      ps_mask_done( mask, memory );
+
+    FT_FREE( table->masks );
+    table->num_masks = 0;
+    table->max_masks = 0;
+  }
+
+
+  /* ensure that a mask table can contain "count" masks */
+  static FT_Error
+  ps_mask_table_ensure( PS_Mask_Table  table,
+                        FT_UInt        count,
+                        FT_Memory      memory )
+  {
+    FT_UInt   old_max = table->max_masks;
+    FT_UInt   new_max = count;
+    FT_Error  error   = 0;
+
+
+    if ( new_max > old_max )
+    {
+      new_max = FT_PAD_CEIL( new_max, 8 );
+      if ( !FT_RENEW_ARRAY( table->masks, old_max, new_max ) )
+        table->max_masks = new_max;
+    }
+    return error;
+  }
+
+
+  /* allocate a new mask in a table */
+  static FT_Error
+  ps_mask_table_alloc( PS_Mask_Table  table,
+                       FT_Memory      memory,
+                       PS_Mask       *amask )
+  {
+    FT_UInt   count;
+    FT_Error  error = 0;
+    PS_Mask   mask  = 0;
+
+
+    count = table->num_masks;
+    count++;
+
+    if ( count > table->max_masks )
+    {
+      error = ps_mask_table_ensure( table, count, memory );
+      if ( error )
+        goto Exit;
+    }
+
+    mask             = table->masks + count - 1;
+    mask->num_bits   = 0;
+    mask->end_point  = 0;
+    table->num_masks = count;
+
+  Exit:
+    *amask = mask;
+    return error;
+  }
+
+
+  /* return last hint mask in a table, create one if the table is empty */
+  static FT_Error
+  ps_mask_table_last( PS_Mask_Table  table,
+                      FT_Memory      memory,
+                      PS_Mask       *amask )
+  {
+    FT_Error  error = 0;
+    FT_UInt   count;
+    PS_Mask   mask;
+
+
+    count = table->num_masks;
+    if ( count == 0 )
+    {
+      error = ps_mask_table_alloc( table, memory, &mask );
+      if ( error )
+        goto Exit;
+    }
+    else
+      mask = table->masks + count - 1;
+
+  Exit:
+    *amask = mask;
+    return error;
+  }
+
+
+  /* set a new mask to a given bit range */
+  static FT_Error
+  ps_mask_table_set_bits( PS_Mask_Table  table,
+                          FT_Byte*       source,
+                          FT_UInt        bit_pos,
+                          FT_UInt        bit_count,
+                          FT_Memory      memory )
+  {
+    FT_Error  error = 0;
+    PS_Mask   mask;
+
+
+    error = ps_mask_table_last( table, memory, &mask );
+    if ( error )
+      goto Exit;
+
+    error = ps_mask_ensure( mask, bit_count, memory );
+    if ( error )
+      goto Exit;
+
+    mask->num_bits = bit_count;
+
+    /* now, copy bits */
+    {
+      FT_Byte*  read  = source + ( bit_pos >> 3 );
+      FT_Int    rmask = 0x80 >> ( bit_pos & 7 );
+      FT_Byte*  write = mask->bytes;
+      FT_Int    wmask = 0x80;
+      FT_Int    val;
+
+
+      for ( ; bit_count > 0; bit_count-- )
+      {
+        val = write[0] & ~wmask;
+
+        if ( read[0] & rmask )
+          val |= wmask;
+
+        write[0] = (FT_Byte)val;
+
+        rmask >>= 1;
+        if ( rmask == 0 )
+        {
+          read++;
+          rmask = 0x80;
+        }
+
+        wmask >>= 1;
+        if ( wmask == 0 )
+        {
+          write++;
+          wmask = 0x80;
+        }
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* test whether two masks in a table intersect */
+  static FT_Int
+  ps_mask_table_test_intersect( PS_Mask_Table  table,
+                                FT_Int         index1,
+                                FT_Int         index2 )
+  {
+    PS_Mask   mask1  = table->masks + index1;
+    PS_Mask   mask2  = table->masks + index2;
+    FT_Byte*  p1     = mask1->bytes;
+    FT_Byte*  p2     = mask2->bytes;
+    FT_UInt   count1 = mask1->num_bits;
+    FT_UInt   count2 = mask2->num_bits;
+    FT_UInt   count;
+
+
+    count = ( count1 <= count2 ) ? count1 : count2;
+    for ( ; count >= 8; count -= 8 )
+    {
+      if ( p1[0] & p2[0] )
+        return 1;
+
+      p1++;
+      p2++;
+    }
+
+    if ( count == 0 )
+      return 0;
+
+    return ( p1[0] & p2[0] ) & ~( 0xFF >> count );
+  }
+
+
+  /* merge two masks, used by ps_mask_table_merge_all */
+  static FT_Error
+  ps_mask_table_merge( PS_Mask_Table  table,
+                       FT_Int         index1,
+                       FT_Int         index2,
+                       FT_Memory      memory )
+  {
+    FT_UInt   temp;
+    FT_Error  error = 0;
+
+
+    /* swap index1 and index2 so that index1 < index2 */
+    if ( index1 > index2 )
+    {
+      temp   = index1;
+      index1 = index2;
+      index2 = temp;
+    }
+
+    if ( index1 < index2 && index1 >= 0 && index2 < (FT_Int)table->num_masks )
+    {
+      /* we need to merge the bitsets of index1 and index2 with a */
+      /* simple union                                             */
+      PS_Mask  mask1  = table->masks + index1;
+      PS_Mask  mask2  = table->masks + index2;
+      FT_UInt  count1 = mask1->num_bits;
+      FT_UInt  count2 = mask2->num_bits;
+      FT_Int   delta;
+
+
+      if ( count2 > 0 )
+      {
+        FT_UInt   pos;
+        FT_Byte*  read;
+        FT_Byte*  write;
+
+
+        /* if "count2" is greater than "count1", we need to grow the */
+        /* first bitset, and clear the highest bits                  */
+        if ( count2 > count1 )
+        {
+          error = ps_mask_ensure( mask1, count2, memory );
+          if ( error )
+            goto Exit;
+
+          for ( pos = count1; pos < count2; pos++ )
+            ps_mask_clear_bit( mask1, pos );
+        }
+
+        /* merge (unite) the bitsets */
+        read  = mask2->bytes;
+        write = mask1->bytes;
+        pos   = (FT_UInt)( ( count2 + 7 ) >> 3 );
+
+        for ( ; pos > 0; pos-- )
+        {
+          write[0] = (FT_Byte)( write[0] | read[0] );
+          write++;
+          read++;
+        }
+      }
+
+      /* Now, remove "mask2" from the list.  We need to keep the masks */
+      /* sorted in order of importance, so move table elements.        */
+      mask2->num_bits  = 0;
+      mask2->end_point = 0;
+
+      delta = table->num_masks - 1 - index2; /* number of masks to move */
+      if ( delta > 0 )
+      {
+        /* move to end of table for reuse */
+        PS_MaskRec  dummy = *mask2;
+
+
+        ft_memmove( mask2, mask2 + 1, delta * sizeof ( PS_MaskRec ) );
+
+        mask2[delta] = dummy;
+      }
+
+      table->num_masks--;
+    }
+    else
+      FT_ERROR(( "ps_mask_table_merge: ignoring invalid indices (%d,%d)\n",
+                 index1, index2 ));
+
+  Exit:
+    return error;
+  }
+
+
+  /* Try to merge all masks in a given table.  This is used to merge */
+  /* all counter masks into independent counter "paths".             */
+  /*                                                                 */
+  static FT_Error
+  ps_mask_table_merge_all( PS_Mask_Table  table,
+                           FT_Memory      memory )
+  {
+    FT_Int    index1, index2;
+    FT_Error  error = 0;
+
+
+    for ( index1 = table->num_masks - 1; index1 > 0; index1-- )
+    {
+      for ( index2 = index1 - 1; index2 >= 0; index2-- )
+      {
+        if ( ps_mask_table_test_intersect( table, index1, index2 ) )
+        {
+          error = ps_mask_table_merge( table, index2, index1, memory );
+          if ( error )
+            goto Exit;
+
+          break;
+        }
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    PS_DIMENSION MANAGEMENT                    *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* finalize a given dimension */
+  static void
+  ps_dimension_done( PS_Dimension  dimension,
+                     FT_Memory     memory )
+  {
+    ps_mask_table_done( &dimension->counters, memory );
+    ps_mask_table_done( &dimension->masks,    memory );
+    ps_hint_table_done( &dimension->hints,    memory );
+  }
+
+
+  /* initialize a given dimension */
+  static void
+  ps_dimension_init( PS_Dimension  dimension )
+  {
+    dimension->hints.num_hints    = 0;
+    dimension->masks.num_masks    = 0;
+    dimension->counters.num_masks = 0;
+  }
+
+
+#if 0
+
+  /* set a bit at a given index in the current hint mask */
+  static FT_Error
+  ps_dimension_set_mask_bit( PS_Dimension  dim,
+                             FT_UInt       idx,
+                             FT_Memory     memory )
+  {
+    PS_Mask  mask;
+    FT_Error  error = 0;
+
+
+    /* get last hint mask */
+    error = ps_mask_table_last( &dim->masks, memory, &mask );
+    if ( error )
+      goto Exit;
+
+    error = ps_mask_set_bit( mask, idx, memory );
+
+  Exit:
+    return error;
+  }
+
+#endif
+
+  /* set the end point in a mask, called from "End" & "Reset" methods */
+  static void
+  ps_dimension_end_mask( PS_Dimension  dim,
+                         FT_UInt       end_point )
+  {
+    FT_UInt  count = dim->masks.num_masks;
+    PS_Mask  mask;
+
+
+    if ( count > 0 )
+    {
+      mask            = dim->masks.masks + count - 1;
+      mask->end_point = end_point;
+    }
+  }
+
+
+  /* set the end point in the current mask, then create a new empty one */
+  /* (called by "Reset" method)                                         */
+  static FT_Error
+  ps_dimension_reset_mask( PS_Dimension  dim,
+                           FT_UInt       end_point,
+                           FT_Memory     memory )
+  {
+    PS_Mask  mask;
+
+
+    /* end current mask */
+    ps_dimension_end_mask( dim, end_point );
+
+    /* allocate new one */
+    return ps_mask_table_alloc( &dim->masks, memory, &mask );
+  }
+
+
+  /* set a new mask, called from the "T2Stem" method */
+  static FT_Error
+  ps_dimension_set_mask_bits( PS_Dimension    dim,
+                              const FT_Byte*  source,
+                              FT_UInt         source_pos,
+                              FT_UInt         source_bits,
+                              FT_UInt         end_point,
+                              FT_Memory       memory )
+  {
+    FT_Error  error = 0;
+
+
+    /* reset current mask, if any */
+    error = ps_dimension_reset_mask( dim, end_point, memory );
+    if ( error )
+      goto Exit;
+
+    /* set bits in new mask */
+    error = ps_mask_table_set_bits( &dim->masks, (FT_Byte*)source,
+                                    source_pos, source_bits, memory );
+
+  Exit:
+    return error;
+  }
+
+
+  /* add a new single stem (called from "T1Stem" method) */
+  static FT_Error
+  ps_dimension_add_t1stem( PS_Dimension  dim,
+                           FT_Int        pos,
+                           FT_Int        len,
+                           FT_Memory     memory,
+                           FT_Int       *aindex )
+  {
+    FT_Error  error = 0;
+    FT_UInt   flags = 0;
+
+
+    /* detect ghost stem */
+    if ( len < 0 )
+    {
+      flags |= PS_HINT_FLAG_GHOST;
+      if ( len == -21 )
+      {
+        flags |= PS_HINT_FLAG_BOTTOM;
+        pos   += len;
+      }
+      len = 0;
+    }
+
+    if ( aindex )
+      *aindex = -1;
+
+    /* now, lookup stem in the current hints table */
+    {
+      PS_Mask  mask;
+      FT_UInt  idx;
+      FT_UInt  max   = dim->hints.num_hints;
+      PS_Hint  hint  = dim->hints.hints;
+
+
+      for ( idx = 0; idx < max; idx++, hint++ )
+      {
+        if ( hint->pos == pos && hint->len == len )
+          break;
+      }
+
+      /* we need to create a new hint in the table */
+      if ( idx >= max )
+      {
+        error = ps_hint_table_alloc( &dim->hints, memory, &hint );
+        if ( error )
+          goto Exit;
+
+        hint->pos   = pos;
+        hint->len   = len;
+        hint->flags = flags;
+      }
+
+      /* now, store the hint in the current mask */
+      error = ps_mask_table_last( &dim->masks, memory, &mask );
+      if ( error )
+        goto Exit;
+
+      error = ps_mask_set_bit( mask, idx, memory );
+      if ( error )
+        goto Exit;
+
+      if ( aindex )
+        *aindex = (FT_Int)idx;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* add a "hstem3/vstem3" counter to our dimension table */
+  static FT_Error
+  ps_dimension_add_counter( PS_Dimension  dim,
+                            FT_Int        hint1,
+                            FT_Int        hint2,
+                            FT_Int        hint3,
+                            FT_Memory     memory )
+  {
+    FT_Error  error   = 0;
+    FT_UInt   count   = dim->counters.num_masks;
+    PS_Mask   counter = dim->counters.masks;
+
+
+    /* try to find an existing counter mask that already uses */
+    /* one of these stems here                                */
+    for ( ; count > 0; count--, counter++ )
+    {
+      if ( ps_mask_test_bit( counter, hint1 ) ||
+           ps_mask_test_bit( counter, hint2 ) ||
+           ps_mask_test_bit( counter, hint3 ) )
+        break;
+    }
+
+    /* creat a new counter when needed */
+    if ( count == 0 )
+    {
+      error = ps_mask_table_alloc( &dim->counters, memory, &counter );
+      if ( error )
+        goto Exit;
+    }
+
+    /* now, set the bits for our hints in the counter mask */
+    error = ps_mask_set_bit( counter, hint1, memory );
+    if ( error )
+      goto Exit;
+
+    error = ps_mask_set_bit( counter, hint2, memory );
+    if ( error )
+      goto Exit;
+
+    error = ps_mask_set_bit( counter, hint3, memory );
+    if ( error )
+      goto Exit;
+
+  Exit:
+    return error;
+  }
+
+
+  /* end of recording session for a given dimension */
+  static FT_Error
+  ps_dimension_end( PS_Dimension  dim,
+                    FT_UInt       end_point,
+                    FT_Memory     memory )
+  {
+    /* end hint mask table */
+    ps_dimension_end_mask( dim, end_point );
+
+    /* merge all counter masks into independent "paths" */
+    return ps_mask_table_merge_all( &dim->counters, memory );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    PS_RECORDER MANAGEMENT                     *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* destroy hints */
+  FT_LOCAL( void )
+  ps_hints_done( PS_Hints  hints )
+  {
+    FT_Memory  memory = hints->memory;
+
+
+    ps_dimension_done( &hints->dimension[0], memory );
+    ps_dimension_done( &hints->dimension[1], memory );
+
+    hints->error  = 0;
+    hints->memory = 0;
+  }
+
+
+  FT_LOCAL( FT_Error )
+  ps_hints_init( PS_Hints   hints,
+                 FT_Memory  memory )
+  {
+    FT_MEM_ZERO( hints, sizeof ( *hints ) );
+    hints->memory = memory;
+    return 0;
+  }
+
+
+  /* initialize a hints for a new session */
+  static void
+  ps_hints_open( PS_Hints      hints,
+                 PS_Hint_Type  hint_type )
+  {
+    switch ( hint_type )
+    {
+    case PS_HINT_TYPE_1:
+    case PS_HINT_TYPE_2:
+      hints->error     = 0;
+      hints->hint_type = hint_type;
+
+      ps_dimension_init( &hints->dimension[0] );
+      ps_dimension_init( &hints->dimension[1] );
+      break;
+
+    default:
+      hints->error     = PSH_Err_Invalid_Argument;
+      hints->hint_type = hint_type;
+
+      FT_ERROR(( "ps_hints_open: invalid charstring type!\n" ));
+      break;
+    }
+  }
+
+
+  /* add one or more stems to the current hints table */
+  static void
+  ps_hints_stem( PS_Hints  hints,
+                 FT_Int    dimension,
+                 FT_UInt   count,
+                 FT_Long*  stems )
+  {
+    if ( !hints->error )
+    {
+      /* limit "dimension" to 0..1 */
+      if ( dimension < 0 || dimension > 1 )
+      {
+        FT_ERROR(( "ps_hints_stem: invalid dimension (%d) used\n",
+                   dimension ));
+        dimension = ( dimension != 0 );
+      }
+
+      /* record the stems in the current hints/masks table */
+      switch ( hints->hint_type )
+      {
+      case PS_HINT_TYPE_1:  /* Type 1 "hstem" or "vstem" operator */
+      case PS_HINT_TYPE_2:  /* Type 2 "hstem" or "vstem" operator */
+        {
+          PS_Dimension  dim = &hints->dimension[dimension];
+
+
+          for ( ; count > 0; count--, stems += 2 )
+          {
+            FT_Error   error;
+            FT_Memory  memory = hints->memory;
+
+
+            error = ps_dimension_add_t1stem(
+                      dim, (FT_Int)stems[0], (FT_Int)stems[1],
+                      memory, NULL );
+            if ( error )
+            {
+              FT_ERROR(( "ps_hints_stem: could not add stem"
+                         " (%d,%d) to hints table\n", stems[0], stems[1] ));
+
+              hints->error = error;
+              return;
+            }
+          }
+          break;
+        }
+
+      default:
+        FT_ERROR(( "ps_hints_stem: called with invalid hint type (%d)\n",
+                   hints->hint_type ));
+        break;
+      }
+    }
+  }
+
+
+  /* add one Type1 counter stem to the current hints table */
+  static void
+  ps_hints_t1stem3( PS_Hints  hints,
+                    FT_Int    dimension,
+                    FT_Long*  stems )
+  {
+    FT_Error  error = 0;
+
+
+    if ( !hints->error )
+    {
+      PS_Dimension  dim;
+      FT_Memory     memory = hints->memory;
+      FT_Int        count;
+      FT_Int        idx[3];
+
+
+      /* limit "dimension" to 0..1 */
+      if ( dimension < 0 || dimension > 1 )
+      {
+        FT_ERROR(( "ps_hints_t1stem3: invalid dimension (%d) used\n",
+                   dimension ));
+        dimension = ( dimension != 0 );
+      }
+
+      dim = &hints->dimension[dimension];
+
+      /* there must be 6 elements in the 'stem' array */
+      if ( hints->hint_type == PS_HINT_TYPE_1 )
+      {
+        /* add the three stems to our hints/masks table */
+        for ( count = 0; count < 3; count++, stems += 2 )
+        {
+          error = ps_dimension_add_t1stem(
+                    dim, (FT_Int)stems[0], (FT_Int)stems[1],
+                    memory, &idx[count] );
+          if ( error )
+            goto Fail;
+        }
+
+        /* now, add the hints to the counters table */
+        error = ps_dimension_add_counter( dim, idx[0], idx[1], idx[2],
+                                          memory );
+        if ( error )
+          goto Fail;
+      }
+      else
+      {
+        FT_ERROR(( "ps_hints_t1stem3: called with invalid hint type!\n" ));
+        error = PSH_Err_Invalid_Argument;
+        goto Fail;
+      }
+    }
+
+    return;
+
+  Fail:
+    FT_ERROR(( "ps_hints_t1stem3: could not add counter stems to table\n" ));
+    hints->error = error;
+  }
+
+
+  /* reset hints (only with Type 1 hints) */
+  static void
+  ps_hints_t1reset( PS_Hints  hints,
+                    FT_UInt   end_point )
+  {
+    FT_Error  error = 0;
+
+
+    if ( !hints->error )
+    {
+      FT_Memory  memory = hints->memory;
+
+
+      if ( hints->hint_type == PS_HINT_TYPE_1 )
+      {
+        error = ps_dimension_reset_mask( &hints->dimension[0],
+                                         end_point, memory );
+        if ( error )
+          goto Fail;
+
+        error = ps_dimension_reset_mask( &hints->dimension[1],
+                                         end_point, memory );
+        if ( error )
+          goto Fail;
+      }
+      else
+      {
+        /* invalid hint type */
+        error = PSH_Err_Invalid_Argument;
+        goto Fail;
+      }
+    }
+    return;
+
+  Fail:
+    hints->error = error;
+  }
+
+
+  /* Type2 "hintmask" operator, add a new hintmask to each direction */
+  static void
+  ps_hints_t2mask( PS_Hints        hints,
+                   FT_UInt         end_point,
+                   FT_UInt         bit_count,
+                   const FT_Byte*  bytes )
+  {
+    FT_Error  error;
+
+
+    if ( !hints->error )
+    {
+      PS_Dimension  dim    = hints->dimension;
+      FT_Memory     memory = hints->memory;
+      FT_UInt       count1 = dim[0].hints.num_hints;
+      FT_UInt       count2 = dim[1].hints.num_hints;
+
+
+      /* check bit count; must be equal to current total hint count */
+      if ( bit_count !=  count1 + count2 )
+      {
+        FT_ERROR(( "ps_hints_t2mask: "
+                   "called with invalid bitcount %d (instead of %d)\n",
+                   bit_count, count1 + count2 ));
+
+        /* simply ignore the operator */
+        return;
+      }
+
+      /* set-up new horizontal and vertical hint mask now */
+      error = ps_dimension_set_mask_bits( &dim[0], bytes, count2, count1,
+                                          end_point, memory );
+      if ( error )
+        goto Fail;
+
+      error = ps_dimension_set_mask_bits( &dim[1], bytes, 0, count2,
+                                          end_point, memory );
+      if ( error )
+        goto Fail;
+    }
+    return;
+
+  Fail:
+    hints->error = error;
+  }
+
+
+  static void
+  ps_hints_t2counter( PS_Hints        hints,
+                      FT_UInt         bit_count,
+                      const FT_Byte*  bytes )
+  {
+    FT_Error  error;
+
+
+    if ( !hints->error )
+    {
+      PS_Dimension  dim    = hints->dimension;
+      FT_Memory     memory = hints->memory;
+      FT_UInt       count1 = dim[0].hints.num_hints;
+      FT_UInt       count2 = dim[1].hints.num_hints;
+
+
+      /* check bit count, must be equal to current total hint count */
+      if ( bit_count !=  count1 + count2 )
+      {
+        FT_ERROR(( "ps_hints_t2counter: "
+                   "called with invalid bitcount %d (instead of %d)\n",
+                   bit_count, count1 + count2 ));
+
+        /* simply ignore the operator */
+        return;
+      }
+
+      /* set-up new horizontal and vertical hint mask now */
+      error = ps_dimension_set_mask_bits( &dim[0], bytes, 0, count1,
+                                          0, memory );
+      if ( error )
+        goto Fail;
+
+      error = ps_dimension_set_mask_bits( &dim[1], bytes, count1, count2,
+                                          0, memory );
+      if ( error )
+        goto Fail;
+    }
+    return;
+
+  Fail:
+    hints->error = error;
+  }
+
+
+  /* end recording session */
+  static FT_Error
+  ps_hints_close( PS_Hints  hints,
+                  FT_UInt   end_point )
+  {
+    FT_Error  error;
+
+
+    error = hints->error;
+    if ( !error )
+    {
+      FT_Memory     memory = hints->memory;
+      PS_Dimension  dim    = hints->dimension;
+
+
+      error = ps_dimension_end( &dim[0], end_point, memory );
+      if ( !error )
+      {
+        error = ps_dimension_end( &dim[1], end_point, memory );
+      }
+    }
+
+#ifdef DEBUG_HINTER
+    if ( !error )
+      ps_debug_hints = hints;
+#endif
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                TYPE 1 HINTS RECORDING INTERFACE               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  t1_hints_open( T1_Hints  hints )
+  {
+    ps_hints_open( (PS_Hints)hints, PS_HINT_TYPE_1 );
+  }
+
+  static void
+  t1_hints_stem( T1_Hints  hints,
+                 FT_Int    dimension,
+                 FT_Long*  coords )
+  {
+    ps_hints_stem( (PS_Hints)hints, dimension, 1, coords );
+  }
+
+
+  FT_LOCAL_DEF( void )
+  t1_hints_funcs_init( T1_Hints_FuncsRec*  funcs )
+  {
+    FT_MEM_ZERO( (char*)funcs, sizeof ( *funcs ) );
+
+    funcs->open  = (T1_Hints_OpenFunc)    t1_hints_open;
+    funcs->close = (T1_Hints_CloseFunc)   ps_hints_close;
+    funcs->stem  = (T1_Hints_SetStemFunc) t1_hints_stem;
+    funcs->stem3 = (T1_Hints_SetStem3Func)ps_hints_t1stem3;
+    funcs->reset = (T1_Hints_ResetFunc)   ps_hints_t1reset;
+    funcs->apply = (T1_Hints_ApplyFunc)   ps_hints_apply;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                TYPE 2 HINTS RECORDING INTERFACE               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  t2_hints_open( T2_Hints  hints )
+  {
+    ps_hints_open( (PS_Hints)hints, PS_HINT_TYPE_2 );
+  }
+
+
+  static void
+  t2_hints_stems( T2_Hints   hints,
+                  FT_Int     dimension,
+                  FT_Int     count,
+                  FT_Fixed*  coords )
+  {
+    FT_Pos  stems[32], y, n;
+    FT_Int  total = count;
+
+
+    y = 0;
+    while ( total > 0 )
+    {
+      /* determine number of stems to write */
+      count = total;
+      if ( count > 16 )
+        count = 16;
+
+      /* compute integer stem positions in font units */
+      for ( n = 0; n < count * 2; n++ )
+      {
+        y       += coords[n];
+        stems[n] = ( y + 0x8000L ) >> 16;
+      }
+
+      /* compute lengths */
+      for ( n = 0; n < count * 2; n += 2 )
+        stems[n + 1] = stems[n + 1] - stems[n];
+
+      /* add them to the current dimension */
+      ps_hints_stem( (PS_Hints)hints, dimension, count, stems );
+
+      total -= count;
+    }
+  }
+
+
+  FT_LOCAL_DEF( void )
+  t2_hints_funcs_init( T2_Hints_FuncsRec*  funcs )
+  {
+    FT_MEM_ZERO( funcs, sizeof ( *funcs ) );
+
+    funcs->open    = (T2_Hints_OpenFunc)   t2_hints_open;
+    funcs->close   = (T2_Hints_CloseFunc)  ps_hints_close;
+    funcs->stems   = (T2_Hints_StemsFunc)  t2_hints_stems;
+    funcs->hintmask= (T2_Hints_MaskFunc)   ps_hints_t2mask;
+    funcs->counter = (T2_Hints_CounterFunc)ps_hints_t2counter;
+    funcs->apply   = (T2_Hints_ApplyFunc)  ps_hints_apply;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/pshrec.h b/nx-X11/extras/freetype2/src/pshinter/pshrec.h
new file mode 100644
index 000000000..0159e9cd5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/pshrec.h
@@ -0,0 +1,176 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshrec.h                                                               */
+/*                                                                         */
+/*    Postscript (Type1/Type2) hints recorder (specification).             */
+/*                                                                         */
+/*  Copyright 2001, 2002, 2003 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /**************************************************************************/
+  /*                                                                        */
+  /*  The functions defined here are called from the Type 1, CID and CFF    */
+  /*  font drivers to record the hints of a given character/glyph.          */
+  /*                                                                        */
+  /*  The hints are recorded in a unified format, and are later processed   */
+  /*  by the "optimizer" and "fitter" to adjust the outlines to the pixel   */
+  /*  grid.                                                                 */
+  /*                                                                        */
+  /**************************************************************************/
+
+
+#ifndef __PSHREC_H__
+#define __PSHREC_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+#include "pshglob.h"
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                 GLYPH HINTS RECORDER INTERNALS                *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* handle to hint record */
+  typedef struct PS_HintRec_*  PS_Hint;
+
+  /* hint types */
+  typedef enum
+  {
+    PS_HINT_TYPE_1 = 1,
+    PS_HINT_TYPE_2 = 2
+
+  } PS_Hint_Type;
+
+
+  /* hint flags */
+  typedef enum
+  {
+    PS_HINT_FLAG_GHOST  = 1,
+    PS_HINT_FLAG_BOTTOM = 2
+
+  } PS_Hint_Flags;
+
+
+  /* hint descriptor */
+  typedef struct  PS_HintRec_
+  {
+    FT_Int   pos;
+    FT_Int   len;
+    FT_UInt  flags;
+
+  } PS_HintRec;
+
+
+#define ps_hint_is_active( x )  ( (x)->flags & PS_HINT_FLAG_ACTIVE )
+#define ps_hint_is_ghost( x )   ( (x)->flags & PS_HINT_FLAG_GHOST  )
+#define ps_hint_is_bottom( x )  ( (x)->flags & PS_HINT_FLAG_BOTTOM )
+
+
+  /* hints table descriptor */
+  typedef struct  PS_Hint_TableRec_
+  {
+    FT_UInt  num_hints;
+    FT_UInt  max_hints;
+    PS_Hint  hints;
+
+  } PS_Hint_TableRec, *PS_Hint_Table;
+
+
+  /* hint and counter mask descriptor */
+  typedef struct  PS_MaskRec_
+  {
+    FT_UInt   num_bits;
+    FT_UInt   max_bits;
+    FT_Byte*  bytes;
+    FT_UInt   end_point;
+
+  } PS_MaskRec, *PS_Mask;
+
+
+  /* masks and counters table descriptor */
+  typedef struct  PS_Mask_TableRec_
+  {
+    FT_UInt  num_masks;
+    FT_UInt  max_masks;
+    PS_Mask  masks;
+
+  } PS_Mask_TableRec, *PS_Mask_Table;
+
+
+ /* dimension-specific hints descriptor */
+  typedef struct  PS_DimensionRec_
+  {
+    PS_Hint_TableRec  hints;
+    PS_Mask_TableRec  masks;
+    PS_Mask_TableRec  counters;
+
+  } PS_DimensionRec, *PS_Dimension;
+
+
+  /* glyph hints descriptor                                */
+  /* dimension 0 => X coordinates + vertical hints/stems   */
+  /* dimension 1 => Y coordinates + horizontal hints/stems */
+  typedef struct  PS_HintsRec_
+  {
+    FT_Memory        memory;
+    FT_Error         error;
+    FT_UInt32        magic;
+    PS_Hint_Type     hint_type;
+    PS_DimensionRec  dimension[2];
+
+  } PS_HintsRec, *PS_Hints;
+
+  /* */
+
+  /* initialize hints recorder */
+  FT_LOCAL( FT_Error )
+  ps_hints_init( PS_Hints   hints,
+                 FT_Memory  memory );
+
+  /* finalize hints recorder */
+  FT_LOCAL( void )
+  ps_hints_done( PS_Hints  hints );
+
+  /* initialize Type1 hints recorder interface */
+  FT_LOCAL( void )
+  t1_hints_funcs_init( T1_Hints_FuncsRec*  funcs );
+
+  /* initialize Type2 hints recorder interface */
+  FT_LOCAL( void )
+  t2_hints_funcs_init( T2_Hints_FuncsRec*  funcs );
+
+
+#ifdef DEBUG_HINTER
+  extern PS_Hints  ps_debug_hints;
+  extern  int      ps_debug_no_horz_hints;
+  extern  int      ps_debug_no_vert_hints;
+#endif
+
+ /* */
+
+
+FT_END_HEADER
+
+
+#endif /* __PS_HINTER_RECORD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/pshinter/rules.mk b/nx-X11/extras/freetype2/src/pshinter/rules.mk
new file mode 100644
index 000000000..57773394a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/pshinter/rules.mk
@@ -0,0 +1,72 @@
+#
+# FreeType 2 PSHinter driver configuration rules
+#
+
+
+# Copyright 2001, 2003 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.
+
+
+# PSHINTER driver directory
+#
+PSHINTER_DIR := $(SRC_DIR)/pshinter
+
+
+# compilation flags for the driver
+#
+PSHINTER_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(PSHINTER_DIR))
+
+
+# PSHINTER driver sources (i.e., C files)
+#
+PSHINTER_DRV_SRC := $(PSHINTER_DIR)/pshrec.c  \
+                    $(PSHINTER_DIR)/pshglob.c \
+                    $(PSHINTER_DIR)/pshmod.c  \
+                    $(PSHINTER_DIR)/pshalgo.c
+
+
+# PSHINTER driver headers
+#
+PSHINTER_DRV_H := $(PSHINTER_DRV_SRC:%c=%h) \
+                  $(PSHINTER_DIR)/pshnterr.h
+
+
+# PSHINTER driver object(s)
+#
+#   PSHINTER_DRV_OBJ_M is used during `multi' builds.
+#   PSHINTER_DRV_OBJ_S is used during `single' builds.
+#
+PSHINTER_DRV_OBJ_M := $(PSHINTER_DRV_SRC:$(PSHINTER_DIR)/%.c=$(OBJ_DIR)/%.$O)
+PSHINTER_DRV_OBJ_S := $(OBJ_DIR)/pshinter.$O
+
+# PSHINTER driver source file for single build
+#
+PSHINTER_DRV_SRC_S := $(PSHINTER_DIR)/pshinter.c
+
+
+# PSHINTER driver - single object
+#
+$(PSHINTER_DRV_OBJ_S): $(PSHINTER_DRV_SRC_S) $(PSHINTER_DRV_SRC) \
+                       $(FREETYPE_H) $(PSHINTER_DRV_H)
+	$(PSHINTER_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(PSHINTER_DRV_SRC_S))
+
+
+# PSHINTER driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(PSHINTER_DIR)/%.c $(FREETYPE_H) $(PSHINTER_DRV_H)
+	$(PSHINTER_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(PSHINTER_DRV_OBJ_S)
+DRV_OBJS_M += $(PSHINTER_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/psnames/Jamfile b/nx-X11/extras/freetype2/src/psnames/Jamfile
new file mode 100644
index 000000000..e75ae1e7a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/psnames Jamfile (c) 2001 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) psnames ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = psmodule ;
+  }
+  else
+  {
+    _sources = psnames ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/psnames Jamfile
diff --git a/nx-X11/extras/freetype2/src/psnames/descrip.mms b/nx-X11/extras/freetype2/src/psnames/descrip.mms
new file mode 100644
index 000000000..6a66b9fa3
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 PSNames driver compilation rules for VMS
+#
+
+
+# Copyright 2001, 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.psnames])
+
+OBJS=psnames.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/psnames/module.mk b/nx-X11/extras/freetype2/src/psnames/module.mk
new file mode 100644
index 000000000..e1e59c46b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 PSnames module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_psnames_module
+
+add_psnames_module:
+	$(OPEN_DRIVER)psnames_module_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)psnames   $(ECHO_DRIVER_DESC)Postscript & Unicode Glyph name handling$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/psnames/psmodule.c b/nx-X11/extras/freetype2/src/psnames/psmodule.c
new file mode 100644
index 000000000..f6d6ae328
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/psmodule.c
@@ -0,0 +1,408 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psmodule.c                                                             */
+/*                                                                         */
+/*    PSNames module implementation (body).                                */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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_OBJECTS_H
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+
+#include "psmodule.h"
+#include "pstables.h"
+
+#include "psnamerr.h"
+
+
+#ifndef FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES
+
+
+#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
+
+
+  /* return the Unicode value corresponding to a given glyph.  Note that */
+  /* we do deal with glyph variants by detecting a non-initial dot in    */
+  /* the name, as in `A.swash' or `e.final', etc.                        */
+  /*                                                                     */
+  static FT_UInt32
+  ps_unicode_value( const char*  glyph_name )
+  {
+    FT_Int  n;
+    char    first = glyph_name[0];
+    char    temp[64];
+
+
+    /* If the name begins with `uni', then the glyph name may be a */
+    /* hard-coded unicode character code.                          */
+    if ( glyph_name[0] == 'u' &&
+         glyph_name[1] == 'n' &&
+         glyph_name[2] == 'i' )
+    {
+      /* determine whether the next four characters following are */
+      /* hexadecimal.                                             */
+
+      /* XXX: Add code to deal with ligatures, i.e. glyph names like */
+      /*      `uniXXXXYYYYZZZZ'...                                   */
+
+      FT_Int       count;
+      FT_ULong     value = 0;
+      const char*  p     = glyph_name + 3;
+
+
+      for ( count = 4; count > 0; count--, p++ )
+      {
+        char          c = *p;
+        unsigned int  d;
+
+
+        d = (unsigned char)c - '0';
+        if ( d >= 10 )
+        {
+          d = (unsigned char)c - 'A';
+          if ( d >= 6 )
+            d = 16;
+          else
+            d += 10;
+        }
+
+        /* exit if a non-uppercase hexadecimal character was found */
+        if ( d >= 16 )
+          break;
+
+        value = ( value << 4 ) + d;
+      }
+
+      /* there must be exactly four hex digits */
+      if ( ( *p == '\0' || *p == '.' ) && count == 0 )
+        return value;
+    }
+
+    /* If the name begins with `u', followed by four to six uppercase */
+    /* hexadicimal digits, it is a hard-coded unicode character code. */
+    if ( glyph_name[0] == 'u' )
+    {
+      FT_Int       count;
+      FT_ULong     value = 0;
+      const char*  p     = glyph_name + 1;
+
+
+      for ( count = 6; count > 0; count--, p++ )
+      {
+        char          c = *p;
+        unsigned int  d;
+
+
+        d = (unsigned char)c - '0';
+        if ( d >= 10 )
+        {
+          d = (unsigned char)c - 'A';
+          if ( d >= 6 )
+            d = 16;
+          else
+            d += 10;
+        }
+
+        if ( d >= 16 )
+          break;
+
+        value = ( value << 4 ) + d;
+      }
+
+      if ( ( *p == '\0' || *p == '.' ) && count <= 2 )
+        return value;
+    }
+
+    /* look for a non-initial dot in the glyph name in order to */
+    /* sort-out variants like `A.swash', `e.final', etc.        */
+    {
+      const char*  p;
+      int          len;
+
+
+      p = glyph_name;
+
+      while ( *p && *p != '.' )
+        p++;
+
+      len = (int)( p - glyph_name );
+
+      if ( *p && len < 64 )
+      {
+        ft_strncpy( temp, glyph_name, len );
+        temp[len]  = 0;
+        glyph_name = temp;
+      }
+    }
+
+    /* now, look up the glyph in the Adobe Glyph List */
+    for ( n = 0; n < NUM_ADOBE_GLYPHS; n++ )
+    {
+      const char*  name = sid_standard_names[n];
+
+
+      if ( first == name[0] && ft_strcmp( glyph_name, name ) == 0 )
+        return ps_names_to_unicode[n];
+    }
+
+    /* not found, there is probably no Unicode value for this glyph name */
+    return 0;
+  }
+
+
+  /* ft_qsort callback to sort the unicode map */
+  FT_CALLBACK_DEF( int )
+  compare_uni_maps( const void*  a,
+                    const void*  b )
+  {
+    PS_UniMap*  map1 = (PS_UniMap*)a;
+    PS_UniMap*  map2 = (PS_UniMap*)b;
+
+
+    return ( map1->unicode - map2->unicode );
+  }
+
+
+  /* Builds a table that maps Unicode values to glyph indices */
+  static FT_Error
+  ps_unicodes_init( FT_Memory     memory,
+                    FT_UInt       num_glyphs,
+                    const char**  glyph_names,
+                    PS_Unicodes*  table )
+  {
+    FT_Error  error;
+
+
+    /* we first allocate the table */
+    table->num_maps = 0;
+    table->maps     = 0;
+
+    if ( !FT_NEW_ARRAY( table->maps, num_glyphs ) )
+    {
+      FT_UInt     n;
+      FT_UInt     count;
+      PS_UniMap*  map;
+      FT_UInt32   uni_char;
+
+
+      map = table->maps;
+
+      for ( n = 0; n < num_glyphs; n++ )
+      {
+        const char*  gname = glyph_names[n];
+
+
+        if ( gname )
+        {
+          uni_char = ps_unicode_value( gname );
+
+          if ( uni_char != 0 && uni_char != 0xFFFFL )
+          {
+            map->unicode     = (FT_UInt)uni_char;
+            map->glyph_index = n;
+            map++;
+          }
+        }
+      }
+
+      /* now, compress the table a bit */
+      count = (FT_UInt)( map - table->maps );
+
+      if ( count > 0 && FT_REALLOC( table->maps,
+                                    num_glyphs * sizeof ( PS_UniMap ),
+                                    count * sizeof ( PS_UniMap ) ) )
+        count = 0;
+
+      if ( count == 0 )
+      {
+        FT_FREE( table->maps );
+        if ( !error )
+          error = PSnames_Err_Invalid_Argument;  /* no unicode chars here! */
+      }
+      else
+        /* sort the table in increasing order of unicode values */
+        ft_qsort( table->maps, count, sizeof ( PS_UniMap ), compare_uni_maps );
+
+      table->num_maps = count;
+    }
+
+    return error;
+  }
+
+
+  static FT_UInt
+  ps_unicodes_char_index( PS_Unicodes*  table,
+                          FT_ULong      unicode )
+  {
+    PS_UniMap  *min, *max, *mid;
+
+
+    /* perform a binary search on the table */
+
+    min = table->maps;
+    max = min + table->num_maps - 1;
+
+    while ( min <= max )
+    {
+      mid = min + ( max - min ) / 2;
+      if ( mid->unicode == unicode )
+        return mid->glyph_index;
+
+      if ( min == max )
+        break;
+
+      if ( mid->unicode < unicode )
+        min = mid + 1;
+      else
+        max = mid - 1;
+    }
+
+    return 0xFFFFU;
+  }
+
+
+  static FT_ULong
+  ps_unicodes_char_next( PS_Unicodes*  table,
+                         FT_ULong      unicode )
+  {
+    PS_UniMap  *min, *max, *mid;
+
+
+    unicode++;
+    /* perform a binary search on the table */
+
+    min = table->maps;
+    max = min + table->num_maps - 1;
+
+    while ( min <= max )
+    {
+      mid = min + ( max - min ) / 2;
+      if ( mid->unicode == unicode )
+        return unicode;
+
+      if ( min == max )
+        break;
+
+      if ( mid->unicode < unicode )
+        min = mid + 1;
+      else
+        max = mid - 1;
+    }
+
+    if ( max < table->maps )
+      max = table->maps;
+
+    while ( max < table->maps + table->num_maps )
+    {
+      if ( unicode < max->unicode )
+        return max->unicode;
+      max++;
+    }
+
+    return 0;
+  }
+
+
+#endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
+
+
+  static const char*
+  ps_get_macintosh_name( FT_UInt  name_index )
+  {
+    if ( name_index >= 258 )
+      name_index = 0;
+
+    return ps_glyph_names[mac_standard_names[name_index]];
+  }
+
+
+  static const char*
+  ps_get_standard_strings( FT_UInt  sid )
+  {
+    return ( sid < NUM_SID_GLYPHS ? sid_standard_names[sid] : 0 );
+  }
+
+
+  static
+  const FT_Service_PsCMapsRec  pscmaps_interface =
+  {
+#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
+
+    (PS_Unicode_ValueFunc)     ps_unicode_value,
+    (PS_Unicodes_InitFunc)     ps_unicodes_init,
+    (PS_Unicodes_CharIndexFunc)ps_unicodes_char_index,
+    (PS_Unicodes_CharNextFunc) ps_unicodes_char_next,
+
+#else
+
+    0,
+    0,
+    0,
+    0,
+
+#endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
+
+    (PS_Macintosh_Name_Func)   ps_get_macintosh_name,
+    (PS_Adobe_Std_Strings_Func)ps_get_standard_strings,
+
+    t1_standard_encoding,
+    t1_expert_encoding
+  };
+
+
+  static const FT_ServiceDescRec  pscmaps_services[] =
+  {
+    { FT_SERVICE_ID_POSTSCRIPT_CMAPS, &pscmaps_interface },
+    { NULL, NULL }
+  };
+
+
+  static FT_Pointer
+  psnames_get_service( FT_Module    module,
+                       const char*  service_id )
+  {
+    FT_UNUSED( module );
+
+    return ft_service_list_lookup( pscmaps_services, service_id );
+  }
+
+#endif /* !FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES */
+
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Module_Class  psnames_module_class =
+  {
+    0,  /* this is not a font driver, nor a renderer */
+    sizeof ( FT_ModuleRec ),
+
+    "psnames",  /* driver name                         */
+    0x10000L,   /* driver version                      */
+    0x20000L,   /* driver requires FreeType 2 or above */
+
+#ifdef FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES
+    0,
+    (FT_Module_Constructor)0,
+    (FT_Module_Destructor) 0,
+    (FT_Module_Requester)  0
+#else
+    (void*)&pscmaps_interface,   /* module specific interface */
+    (FT_Module_Constructor)0,
+    (FT_Module_Destructor) 0,
+    (FT_Module_Requester)  psnames_get_service
+#endif
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psnames/psmodule.h b/nx-X11/extras/freetype2/src/psnames/psmodule.h
new file mode 100644
index 000000000..232fdfb9a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/psmodule.h
@@ -0,0 +1,38 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psmodule.h                                                             */
+/*                                                                         */
+/*    High-level PSNames module interface (specification).                 */
+/*                                                                         */
+/*  Copyright 1996-2001 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 __PSMODULE_H__
+#define __PSMODULE_H__
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Module_Class )  psnames_module_class;
+
+
+FT_END_HEADER
+
+#endif /* __PSMODULE_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psnames/psnamerr.h b/nx-X11/extras/freetype2/src/psnames/psnamerr.h
new file mode 100644
index 000000000..ae1541d96
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/psnamerr.h
@@ -0,0 +1,41 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psnamerr.h                                                             */
+/*                                                                         */
+/*    PS names module error codes (specification only).                    */
+/*                                                                         */
+/*  Copyright 2001 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 PS names module error enumeration     */
+  /* constants.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __PSNAMERR_H__
+#define __PSNAMERR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  PSnames_Err_
+#define FT_ERR_BASE    FT_Mod_Err_PSnames
+
+#include FT_ERRORS_H
+
+#endif /* __PSNAMERR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psnames/psnames.c b/nx-X11/extras/freetype2/src/psnames/psnames.c
new file mode 100644
index 000000000..d6ed998bf
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/psnames.c
@@ -0,0 +1,25 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psnames.c                                                              */
+/*                                                                         */
+/*    FreeType PSNames module component (body only).                       */
+/*                                                                         */
+/*  Copyright 1996-2001 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 "psmodule.c"
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psnames/pstables.h b/nx-X11/extras/freetype2/src/psnames/pstables.h
new file mode 100644
index 000000000..7c0739375
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/pstables.h
@@ -0,0 +1,9437 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pstables.h.new                                                         */
+/*                                                                         */
+/*    PostScript glyph names (specification only).                         */
+/*                                                                         */
+/*  Copyright 2000-2001, 2003 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 has been generated automatically -- do not edit! */
+
+
+  static const char* const  ps_glyph_names[] =
+  {
+    ".null",
+    "nonmarkingreturn",
+    ".notdef",
+    "space",
+    "exclam",
+    "quotedbl",
+    "numbersign",
+    "dollar",
+    "percent",
+    "ampersand",
+    "quoteright",
+    "parenleft",
+    "parenright",
+    "asterisk",
+    "plus",
+    "comma",
+    "hyphen",
+    "period",
+    "slash",
+    "zero",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "colon",
+    "semicolon",
+    "less",
+    "equal",
+    "greater",
+    "question",
+    "at",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "bracketleft",
+    "backslash",
+    "bracketright",
+    "asciicircum",
+    "underscore",
+    "quoteleft",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "braceleft",
+    "bar",
+    "braceright",
+    "asciitilde",
+    "exclamdown",
+    "cent",
+    "sterling",
+    "fraction",
+    "yen",
+    "florin",
+    "section",
+    "currency",
+    "quotesingle",
+    "quotedblleft",
+    "guillemotleft",
+    "guilsinglleft",
+    "guilsinglright",
+    "fi",
+    "fl",
+    "endash",
+    "dagger",
+    "daggerdbl",
+    "periodcentered",
+    "paragraph",
+    "bullet",
+    "quotesinglbase",
+    "quotedblbase",
+    "quotedblright",
+    "guillemotright",
+    "ellipsis",
+    "perthousand",
+    "questiondown",
+    "grave",
+    "acute",
+    "circumflex",
+    "tilde",
+    "macron",
+    "breve",
+    "dotaccent",
+    "dieresis",
+    "ring",
+    "cedilla",
+    "hungarumlaut",
+    "ogonek",
+    "caron",
+    "emdash",
+    "AE",
+    "ordfeminine",
+    "Lslash",
+    "Oslash",
+    "OE",
+    "ordmasculine",
+    "ae",
+    "dotlessi",
+    "lslash",
+    "oslash",
+    "oe",
+    "germandbls",
+    "onesuperior",
+    "logicalnot",
+    "mu",
+    "trademark",
+    "Eth",
+    "onehalf",
+    "plusminus",
+    "Thorn",
+    "onequarter",
+    "divide",
+    "brokenbar",
+    "degree",
+    "thorn",
+    "threequarters",
+    "twosuperior",
+    "registered",
+    "minus",
+    "eth",
+    "multiply",
+    "threesuperior",
+    "copyright",
+    "Aacute",
+    "Acircumflex",
+    "Adieresis",
+    "Agrave",
+    "Aring",
+    "Atilde",
+    "Ccedilla",
+    "Eacute",
+    "Ecircumflex",
+    "Edieresis",
+    "Egrave",
+    "Iacute",
+    "Icircumflex",
+    "Idieresis",
+    "Igrave",
+    "Ntilde",
+    "Oacute",
+    "Ocircumflex",
+    "Odieresis",
+    "Ograve",
+    "Otilde",
+    "Scaron",
+    "Uacute",
+    "Ucircumflex",
+    "Udieresis",
+    "Ugrave",
+    "Yacute",
+    "Ydieresis",
+    "Zcaron",
+    "aacute",
+    "acircumflex",
+    "adieresis",
+    "agrave",
+    "aring",
+    "atilde",
+    "ccedilla",
+    "eacute",
+    "ecircumflex",
+    "edieresis",
+    "egrave",
+    "iacute",
+    "icircumflex",
+    "idieresis",
+    "igrave",
+    "ntilde",
+    "oacute",
+    "ocircumflex",
+    "odieresis",
+    "ograve",
+    "otilde",
+    "scaron",
+    "uacute",
+    "ucircumflex",
+    "udieresis",
+    "ugrave",
+    "yacute",
+    "ydieresis",
+    "zcaron",
+    "exclamsmall",
+    "Hungarumlautsmall",
+    "dollaroldstyle",
+    "dollarsuperior",
+    "ampersandsmall",
+    "Acutesmall",
+    "parenleftsuperior",
+    "parenrightsuperior",
+    "twodotenleader",
+    "onedotenleader",
+    "zerooldstyle",
+    "oneoldstyle",
+    "twooldstyle",
+    "threeoldstyle",
+    "fouroldstyle",
+    "fiveoldstyle",
+    "sixoldstyle",
+    "sevenoldstyle",
+    "eightoldstyle",
+    "nineoldstyle",
+    "commasuperior",
+    "threequartersemdash",
+    "periodsuperior",
+    "questionsmall",
+    "asuperior",
+    "bsuperior",
+    "centsuperior",
+    "dsuperior",
+    "esuperior",
+    "isuperior",
+    "lsuperior",
+    "msuperior",
+    "nsuperior",
+    "osuperior",
+    "rsuperior",
+    "ssuperior",
+    "tsuperior",
+    "ff",
+    "ffi",
+    "ffl",
+    "parenleftinferior",
+    "parenrightinferior",
+    "Circumflexsmall",
+    "hyphensuperior",
+    "Gravesmall",
+    "Asmall",
+    "Bsmall",
+    "Csmall",
+    "Dsmall",
+    "Esmall",
+    "Fsmall",
+    "Gsmall",
+    "Hsmall",
+    "Ismall",
+    "Jsmall",
+    "Ksmall",
+    "Lsmall",
+    "Msmall",
+    "Nsmall",
+    "Osmall",
+    "Psmall",
+    "Qsmall",
+    "Rsmall",
+    "Ssmall",
+    "Tsmall",
+    "Usmall",
+    "Vsmall",
+    "Wsmall",
+    "Xsmall",
+    "Ysmall",
+    "Zsmall",
+    "colonmonetary",
+    "onefitted",
+    "rupiah",
+    "Tildesmall",
+    "exclamdownsmall",
+    "centoldstyle",
+    "Lslashsmall",
+    "Scaronsmall",
+    "Zcaronsmall",
+    "Dieresissmall",
+    "Brevesmall",
+    "Caronsmall",
+    "Dotaccentsmall",
+    "Macronsmall",
+    "figuredash",
+    "hypheninferior",
+    "Ogoneksmall",
+    "Ringsmall",
+    "Cedillasmall",
+    "questiondownsmall",
+    "oneeighth",
+    "threeeighths",
+    "fiveeighths",
+    "seveneighths",
+    "onethird",
+    "twothirds",
+    "zerosuperior",
+    "foursuperior",
+    "fivesuperior",
+    "sixsuperior",
+    "sevensuperior",
+    "eightsuperior",
+    "ninesuperior",
+    "zeroinferior",
+    "oneinferior",
+    "twoinferior",
+    "threeinferior",
+    "fourinferior",
+    "fiveinferior",
+    "sixinferior",
+    "seveninferior",
+    "eightinferior",
+    "nineinferior",
+    "centinferior",
+    "dollarinferior",
+    "periodinferior",
+    "commainferior",
+    "Agravesmall",
+    "Aacutesmall",
+    "Acircumflexsmall",
+    "Atildesmall",
+    "Adieresissmall",
+    "Aringsmall",
+    "AEsmall",
+    "Ccedillasmall",
+    "Egravesmall",
+    "Eacutesmall",
+    "Ecircumflexsmall",
+    "Edieresissmall",
+    "Igravesmall",
+    "Iacutesmall",
+    "Icircumflexsmall",
+    "Idieresissmall",
+    "Ethsmall",
+    "Ntildesmall",
+    "Ogravesmall",
+    "Oacutesmall",
+    "Ocircumflexsmall",
+    "Otildesmall",
+    "Odieresissmall",
+    "OEsmall",
+    "Oslashsmall",
+    "Ugravesmall",
+    "Uacutesmall",
+    "Ucircumflexsmall",
+    "Udieresissmall",
+    "Yacutesmall",
+    "Thornsmall",
+    "Ydieresissmall",
+    "001.000",
+    "001.001",
+    "001.002",
+    "001.003",
+    "Black",
+    "Bold",
+    "Book",
+    "Light",
+    "Medium",
+    "Regular",
+    "Roman",
+    "Semibold",
+
+#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
+
+    "AEacute",
+    "AEmacron",
+    "Abreve",
+    "Abreveacute",
+    "Abrevecyrillic",
+    "Abrevedotbelow",
+    "Abrevegrave",
+    "Abrevehookabove",
+    "Abrevetilde",
+    "Acaron",
+    "Acircle",
+    "Acircumflexacute",
+    "Acircumflexdotbelow",
+    "Acircumflexgrave",
+    "Acircumflexhookabove",
+    "Acircumflextilde",
+    "Acute",
+    "Acyrillic",
+    "Adblgrave",
+    "Adieresiscyrillic",
+    "Adieresismacron",
+    "Adotbelow",
+    "Adotmacron",
+    "Ahookabove",
+    "Aiecyrillic",
+    "Ainvertedbreve",
+    "Alpha",
+    "Alphatonos",
+    "Amacron",
+    "Amonospace",
+    "Aogonek",
+    "Aringacute",
+    "Aringbelow",
+    "Aybarmenian",
+    "Bcircle",
+    "Bdotaccent",
+    "Bdotbelow",
+    "Becyrillic",
+    "Benarmenian",
+    "Beta",
+    "Bhook",
+    "Blinebelow",
+    "Bmonospace",
+    "Btopbar",
+    "Caarmenian",
+    "Cacute",
+    "Caron",
+    "Ccaron",
+    "Ccedillaacute",
+    "Ccircle",
+    "Ccircumflex",
+    "Cdot",
+    "Cdotaccent",
+    "Chaarmenian",
+    "Cheabkhasiancyrillic",
+    "Checyrillic",
+    "Chedescenderabkhasiancyrillic",
+    "Chedescendercyrillic",
+    "Chedieresiscyrillic",
+    "Cheharmenian",
+    "Chekhakassiancyrillic",
+    "Cheverticalstrokecyrillic",
+    "Chi",
+    "Chook",
+    "Cmonospace",
+    "Coarmenian",
+    "DZ",
+    "DZcaron",
+    "Daarmenian",
+    "Dafrican",
+    "Dcaron",
+    "Dcedilla",
+    "Dcircle",
+    "Dcircumflexbelow",
+    "Dcroat",
+    "Ddotaccent",
+    "Ddotbelow",
+    "Decyrillic",
+    "Deicoptic",
+    "Delta",
+    "Deltagreek",
+    "Dhook",
+    "Dieresis",
+    "DieresisAcute",
+    "DieresisGrave",
+    "Digammagreek",
+    "Djecyrillic",
+    "Dlinebelow",
+    "Dmonospace",
+    "Dslash",
+    "Dtopbar",
+    "Dz",
+    "Dzcaron",
+    "Dzeabkhasiancyrillic",
+    "Dzecyrillic",
+    "Dzhecyrillic",
+    "Ebreve",
+    "Ecaron",
+    "Ecedillabreve",
+    "Echarmenian",
+    "Ecircle",
+    "Ecircumflexacute",
+    "Ecircumflexbelow",
+    "Ecircumflexdotbelow",
+    "Ecircumflexgrave",
+    "Ecircumflexhookabove",
+    "Ecircumflextilde",
+    "Ecyrillic",
+    "Edblgrave",
+    "Edot",
+    "Edotaccent",
+    "Edotbelow",
+    "Efcyrillic",
+    "Eharmenian",
+    "Ehookabove",
+    "Eightroman",
+    "Einvertedbreve",
+    "Eiotifiedcyrillic",
+    "Elcyrillic",
+    "Elevenroman",
+    "Emacron",
+    "Emacronacute",
+    "Emacrongrave",
+    "Emcyrillic",
+    "Emonospace",
+    "Encyrillic",
+    "Endescendercyrillic",
+    "Eng",
+    "Enghecyrillic",
+    "Enhookcyrillic",
+    "Eogonek",
+    "Eopen",
+    "Epsilon",
+    "Epsilontonos",
+    "Ercyrillic",
+    "Ereversed",
+    "Ereversedcyrillic",
+    "Escyrillic",
+    "Esdescendercyrillic",
+    "Esh",
+    "Eta",
+    "Etarmenian",
+    "Etatonos",
+    "Etilde",
+    "Etildebelow",
+    "Euro",
+    "Ezh",
+    "Ezhcaron",
+    "Ezhreversed",
+    "Fcircle",
+    "Fdotaccent",
+    "Feharmenian",
+    "Feicoptic",
+    "Fhook",
+    "Fitacyrillic",
+    "Fiveroman",
+    "Fmonospace",
+    "Fourroman",
+    "GBsquare",
+    "Gacute",
+    "Gamma",
+    "Gammaafrican",
+    "Gangiacoptic",
+    "Gbreve",
+    "Gcaron",
+    "Gcedilla",
+    "Gcircle",
+    "Gcircumflex",
+    "Gcommaaccent",
+    "Gdot",
+    "Gdotaccent",
+    "Gecyrillic",
+    "Ghadarmenian",
+    "Ghemiddlehookcyrillic",
+    "Ghestrokecyrillic",
+    "Gheupturncyrillic",
+    "Ghook",
+    "Gimarmenian",
+    "Gjecyrillic",
+    "Gmacron",
+    "Gmonospace",
+    "Grave",
+    "Gsmallhook",
+    "Gstroke",
+    "H18533",
+    "H18543",
+    "H18551",
+    "H22073",
+    "HPsquare",
+    "Haabkhasiancyrillic",
+    "Hadescendercyrillic",
+    "Hardsigncyrillic",
+    "Hbar",
+    "Hbrevebelow",
+    "Hcedilla",
+    "Hcircle",
+    "Hcircumflex",
+    "Hdieresis",
+    "Hdotaccent",
+    "Hdotbelow",
+    "Hmonospace",
+    "Hoarmenian",
+    "Horicoptic",
+    "Hungarumlaut",
+    "Hzsquare",
+    "IAcyrillic",
+    "IJ",
+    "IUcyrillic",
+    "Ibreve",
+    "Icaron",
+    "Icircle",
+    "Icyrillic",
+    "Idblgrave",
+    "Idieresisacute",
+    "Idieresiscyrillic",
+    "Idot",
+    "Idotaccent",
+    "Idotbelow",
+    "Iebrevecyrillic",
+    "Iecyrillic",
+    "Ifraktur",
+    "Ihookabove",
+    "Iicyrillic",
+    "Iinvertedbreve",
+    "Iishortcyrillic",
+    "Imacron",
+    "Imacroncyrillic",
+    "Imonospace",
+    "Iniarmenian",
+    "Iocyrillic",
+    "Iogonek",
+    "Iota",
+    "Iotaafrican",
+    "Iotadieresis",
+    "Iotatonos",
+    "Istroke",
+    "Itilde",
+    "Itildebelow",
+    "Izhitsacyrillic",
+    "Izhitsadblgravecyrillic",
+    "Jaarmenian",
+    "Jcircle",
+    "Jcircumflex",
+    "Jecyrillic",
+    "Jheharmenian",
+    "Jmonospace",
+    "KBsquare",
+    "KKsquare",
+    "Kabashkircyrillic",
+    "Kacute",
+    "Kacyrillic",
+    "Kadescendercyrillic",
+    "Kahookcyrillic",
+    "Kappa",
+    "Kastrokecyrillic",
+    "Kaverticalstrokecyrillic",
+    "Kcaron",
+    "Kcedilla",
+    "Kcircle",
+    "Kcommaaccent",
+    "Kdotbelow",
+    "Keharmenian",
+    "Kenarmenian",
+    "Khacyrillic",
+    "Kheicoptic",
+    "Khook",
+    "Kjecyrillic",
+    "Klinebelow",
+    "Kmonospace",
+    "Koppacyrillic",
+    "Koppagreek",
+    "Ksicyrillic",
+    "LJ",
+    "LL",
+    "Lacute",
+    "Lambda",
+    "Lcaron",
+    "Lcedilla",
+    "Lcircle",
+    "Lcircumflexbelow",
+    "Lcommaaccent",
+    "Ldot",
+    "Ldotaccent",
+    "Ldotbelow",
+    "Ldotbelowmacron",
+    "Liwnarmenian",
+    "Lj",
+    "Ljecyrillic",
+    "Llinebelow",
+    "Lmonospace",
+    "MBsquare",
+    "Macron",
+    "Macute",
+    "Mcircle",
+    "Mdotaccent",
+    "Mdotbelow",
+    "Menarmenian",
+    "Mmonospace",
+    "Mturned",
+    "Mu",
+    "NJ",
+    "Nacute",
+    "Ncaron",
+    "Ncedilla",
+    "Ncircle",
+    "Ncircumflexbelow",
+    "Ncommaaccent",
+    "Ndotaccent",
+    "Ndotbelow",
+    "Nhookleft",
+    "Nineroman",
+    "Nj",
+    "Njecyrillic",
+    "Nlinebelow",
+    "Nmonospace",
+    "Nowarmenian",
+    "Nu",
+    "Obarredcyrillic",
+    "Obarreddieresiscyrillic",
+    "Obreve",
+    "Ocaron",
+    "Ocenteredtilde",
+    "Ocircle",
+    "Ocircumflexacute",
+    "Ocircumflexdotbelow",
+    "Ocircumflexgrave",
+    "Ocircumflexhookabove",
+    "Ocircumflextilde",
+    "Ocyrillic",
+    "Odblacute",
+    "Odblgrave",
+    "Odieresiscyrillic",
+    "Odotbelow",
+    "Oharmenian",
+    "Ohm",
+    "Ohookabove",
+    "Ohorn",
+    "Ohornacute",
+    "Ohorndotbelow",
+    "Ohorngrave",
+    "Ohornhookabove",
+    "Ohorntilde",
+    "Ohungarumlaut",
+    "Oi",
+    "Oinvertedbreve",
+    "Omacron",
+    "Omacronacute",
+    "Omacrongrave",
+    "Omega",
+    "Omegacyrillic",
+    "Omegagreek",
+    "Omegaroundcyrillic",
+    "Omegatitlocyrillic",
+    "Omegatonos",
+    "Omicron",
+    "Omicrontonos",
+    "Omonospace",
+    "Oneroman",
+    "Oogonek",
+    "Oogonekmacron",
+    "Oopen",
+    "Oslashacute",
+    "Ostrokeacute",
+    "Otcyrillic",
+    "Otildeacute",
+    "Otildedieresis",
+    "Pacute",
+    "Pcircle",
+    "Pdotaccent",
+    "Pecyrillic",
+    "Peharmenian",
+    "Pemiddlehookcyrillic",
+    "Phi",
+    "Phook",
+    "Pi",
+    "Piwrarmenian",
+    "Pmonospace",
+    "Psi",
+    "Psicyrillic",
+    "Qcircle",
+    "Qmonospace",
+    "Raarmenian",
+    "Racute",
+    "Rcaron",
+    "Rcedilla",
+    "Rcircle",
+    "Rcommaaccent",
+    "Rdblgrave",
+    "Rdotaccent",
+    "Rdotbelow",
+    "Rdotbelowmacron",
+    "Reharmenian",
+    "Rfraktur",
+    "Rho",
+    "Rinvertedbreve",
+    "Rlinebelow",
+    "Rmonospace",
+    "Rsmallinverted",
+    "Rsmallinvertedsuperior",
+    "SF010000",
+    "SF020000",
+    "SF030000",
+    "SF040000",
+    "SF050000",
+    "SF060000",
+    "SF070000",
+    "SF080000",
+    "SF090000",
+    "SF100000",
+    "SF110000",
+    "SF190000",
+    "SF200000",
+    "SF210000",
+    "SF220000",
+    "SF230000",
+    "SF240000",
+    "SF250000",
+    "SF260000",
+    "SF270000",
+    "SF280000",
+    "SF360000",
+    "SF370000",
+    "SF380000",
+    "SF390000",
+    "SF400000",
+    "SF410000",
+    "SF420000",
+    "SF430000",
+    "SF440000",
+    "SF450000",
+    "SF460000",
+    "SF470000",
+    "SF480000",
+    "SF490000",
+    "SF500000",
+    "SF510000",
+    "SF520000",
+    "SF530000",
+    "SF540000",
+    "Sacute",
+    "Sacutedotaccent",
+    "Sampigreek",
+    "Scarondotaccent",
+    "Scedilla",
+    "Schwa",
+    "Schwacyrillic",
+    "Schwadieresiscyrillic",
+    "Scircle",
+    "Scircumflex",
+    "Scommaaccent",
+    "Sdotaccent",
+    "Sdotbelow",
+    "Sdotbelowdotaccent",
+    "Seharmenian",
+    "Sevenroman",
+    "Shaarmenian",
+    "Shacyrillic",
+    "Shchacyrillic",
+    "Sheicoptic",
+    "Shhacyrillic",
+    "Shimacoptic",
+    "Sigma",
+    "Sixroman",
+    "Smonospace",
+    "Softsigncyrillic",
+    "Stigmagreek",
+    "Tau",
+    "Tbar",
+    "Tcaron",
+    "Tcedilla",
+    "Tcircle",
+    "Tcircumflexbelow",
+    "Tcommaaccent",
+    "Tdotaccent",
+    "Tdotbelow",
+    "Tecyrillic",
+    "Tedescendercyrillic",
+    "Tenroman",
+    "Tetsecyrillic",
+    "Theta",
+    "Thook",
+    "Threeroman",
+    "Tiwnarmenian",
+    "Tlinebelow",
+    "Tmonospace",
+    "Toarmenian",
+    "Tonefive",
+    "Tonesix",
+    "Tonetwo",
+    "Tretroflexhook",
+    "Tsecyrillic",
+    "Tshecyrillic",
+    "Twelveroman",
+    "Tworoman",
+    "Ubreve",
+    "Ucaron",
+    "Ucircle",
+    "Ucircumflexbelow",
+    "Ucyrillic",
+    "Udblacute",
+    "Udblgrave",
+    "Udieresisacute",
+    "Udieresisbelow",
+    "Udieresiscaron",
+    "Udieresiscyrillic",
+    "Udieresisgrave",
+    "Udieresismacron",
+    "Udotbelow",
+    "Uhookabove",
+    "Uhorn",
+    "Uhornacute",
+    "Uhorndotbelow",
+    "Uhorngrave",
+    "Uhornhookabove",
+    "Uhorntilde",
+    "Uhungarumlaut",
+    "Uhungarumlautcyrillic",
+    "Uinvertedbreve",
+    "Ukcyrillic",
+    "Umacron",
+    "Umacroncyrillic",
+    "Umacrondieresis",
+    "Umonospace",
+    "Uogonek",
+    "Upsilon",
+    "Upsilon1",
+    "Upsilonacutehooksymbolgreek",
+    "Upsilonafrican",
+    "Upsilondieresis",
+    "Upsilondieresishooksymbolgreek",
+    "Upsilonhooksymbol",
+    "Upsilontonos",
+    "Uring",
+    "Ushortcyrillic",
+    "Ustraightcyrillic",
+    "Ustraightstrokecyrillic",
+    "Utilde",
+    "Utildeacute",
+    "Utildebelow",
+    "Vcircle",
+    "Vdotbelow",
+    "Vecyrillic",
+    "Vewarmenian",
+    "Vhook",
+    "Vmonospace",
+    "Voarmenian",
+    "Vtilde",
+    "Wacute",
+    "Wcircle",
+    "Wcircumflex",
+    "Wdieresis",
+    "Wdotaccent",
+    "Wdotbelow",
+    "Wgrave",
+    "Wmonospace",
+    "Xcircle",
+    "Xdieresis",
+    "Xdotaccent",
+    "Xeharmenian",
+    "Xi",
+    "Xmonospace",
+    "Yatcyrillic",
+    "Ycircle",
+    "Ycircumflex",
+    "Ydotaccent",
+    "Ydotbelow",
+    "Yericyrillic",
+    "Yerudieresiscyrillic",
+    "Ygrave",
+    "Yhook",
+    "Yhookabove",
+    "Yiarmenian",
+    "Yicyrillic",
+    "Yiwnarmenian",
+    "Ymonospace",
+    "Ytilde",
+    "Yusbigcyrillic",
+    "Yusbigiotifiedcyrillic",
+    "Yuslittlecyrillic",
+    "Yuslittleiotifiedcyrillic",
+    "Zaarmenian",
+    "Zacute",
+    "Zcircle",
+    "Zcircumflex",
+    "Zdot",
+    "Zdotaccent",
+    "Zdotbelow",
+    "Zecyrillic",
+    "Zedescendercyrillic",
+    "Zedieresiscyrillic",
+    "Zeta",
+    "Zhearmenian",
+    "Zhebrevecyrillic",
+    "Zhecyrillic",
+    "Zhedescendercyrillic",
+    "Zhedieresiscyrillic",
+    "Zlinebelow",
+    "Zmonospace",
+    "Zstroke",
+    "aabengali",
+    "aadeva",
+    "aagujarati",
+    "aagurmukhi",
+    "aamatragurmukhi",
+    "aarusquare",
+    "aavowelsignbengali",
+    "aavowelsigndeva",
+    "aavowelsigngujarati",
+    "abbreviationmarkarmenian",
+    "abbreviationsigndeva",
+    "abengali",
+    "abopomofo",
+    "abreve",
+    "abreveacute",
+    "abrevecyrillic",
+    "abrevedotbelow",
+    "abrevegrave",
+    "abrevehookabove",
+    "abrevetilde",
+    "acaron",
+    "acircle",
+    "acircumflexacute",
+    "acircumflexdotbelow",
+    "acircumflexgrave",
+    "acircumflexhookabove",
+    "acircumflextilde",
+    "acutebelowcmb",
+    "acutecmb",
+    "acutecomb",
+    "acutedeva",
+    "acutelowmod",
+    "acutetonecmb",
+    "acyrillic",
+    "adblgrave",
+    "addakgurmukhi",
+    "adeva",
+    "adieresiscyrillic",
+    "adieresismacron",
+    "adotbelow",
+    "adotmacron",
+    "aeacute",
+    "aekorean",
+    "aemacron",
+    "afii00208",
+    "afii08941",
+    "afii10017",
+    "afii10018",
+    "afii10019",
+    "afii10020",
+    "afii10021",
+    "afii10022",
+    "afii10023",
+    "afii10024",
+    "afii10025",
+    "afii10026",
+    "afii10027",
+    "afii10028",
+    "afii10029",
+    "afii10030",
+    "afii10031",
+    "afii10032",
+    "afii10033",
+    "afii10034",
+    "afii10035",
+    "afii10036",
+    "afii10037",
+    "afii10038",
+    "afii10039",
+    "afii10040",
+    "afii10041",
+    "afii10042",
+    "afii10043",
+    "afii10044",
+    "afii10045",
+    "afii10046",
+    "afii10047",
+    "afii10048",
+    "afii10049",
+    "afii10050",
+    "afii10051",
+    "afii10052",
+    "afii10053",
+    "afii10054",
+    "afii10055",
+    "afii10056",
+    "afii10057",
+    "afii10058",
+    "afii10059",
+    "afii10060",
+    "afii10061",
+    "afii10062",
+    "afii10063",
+    "afii10064",
+    "afii10065",
+    "afii10066",
+    "afii10067",
+    "afii10068",
+    "afii10069",
+    "afii10070",
+    "afii10071",
+    "afii10072",
+    "afii10073",
+    "afii10074",
+    "afii10075",
+    "afii10076",
+    "afii10077",
+    "afii10078",
+    "afii10079",
+    "afii10080",
+    "afii10081",
+    "afii10082",
+    "afii10083",
+    "afii10084",
+    "afii10085",
+    "afii10086",
+    "afii10087",
+    "afii10088",
+    "afii10089",
+    "afii10090",
+    "afii10091",
+    "afii10092",
+    "afii10093",
+    "afii10094",
+    "afii10095",
+    "afii10096",
+    "afii10097",
+    "afii10098",
+    "afii10099",
+    "afii10100",
+    "afii10101",
+    "afii10102",
+    "afii10103",
+    "afii10104",
+    "afii10105",
+    "afii10106",
+    "afii10107",
+    "afii10108",
+    "afii10109",
+    "afii10110",
+    "afii10145",
+    "afii10146",
+    "afii10147",
+    "afii10148",
+    "afii10192",
+    "afii10193",
+    "afii10194",
+    "afii10195",
+    "afii10196",
+    "afii10831",
+    "afii10832",
+    "afii10846",
+    "afii299",
+    "afii300",
+    "afii301",
+    "afii57381",
+    "afii57388",
+    "afii57392",
+    "afii57393",
+    "afii57394",
+    "afii57395",
+    "afii57396",
+    "afii57397",
+    "afii57398",
+    "afii57399",
+    "afii57400",
+    "afii57401",
+    "afii57403",
+    "afii57407",
+    "afii57409",
+    "afii57410",
+    "afii57411",
+    "afii57412",
+    "afii57413",
+    "afii57414",
+    "afii57415",
+    "afii57416",
+    "afii57417",
+    "afii57418",
+    "afii57419",
+    "afii57420",
+    "afii57421",
+    "afii57422",
+    "afii57423",
+    "afii57424",
+    "afii57425",
+    "afii57426",
+    "afii57427",
+    "afii57428",
+    "afii57429",
+    "afii57430",
+    "afii57431",
+    "afii57432",
+    "afii57433",
+    "afii57434",
+    "afii57440",
+    "afii57441",
+    "afii57442",
+    "afii57443",
+    "afii57444",
+    "afii57445",
+    "afii57446",
+    "afii57448",
+    "afii57449",
+    "afii57450",
+    "afii57451",
+    "afii57452",
+    "afii57453",
+    "afii57454",
+    "afii57455",
+    "afii57456",
+    "afii57457",
+    "afii57458",
+    "afii57470",
+    "afii57505",
+    "afii57506",
+    "afii57507",
+    "afii57508",
+    "afii57509",
+    "afii57511",
+    "afii57512",
+    "afii57513",
+    "afii57514",
+    "afii57519",
+    "afii57534",
+    "afii57636",
+    "afii57645",
+    "afii57658",
+    "afii57664",
+    "afii57665",
+    "afii57666",
+    "afii57667",
+    "afii57668",
+    "afii57669",
+    "afii57670",
+    "afii57671",
+    "afii57672",
+    "afii57673",
+    "afii57674",
+    "afii57675",
+    "afii57676",
+    "afii57677",
+    "afii57678",
+    "afii57679",
+    "afii57680",
+    "afii57681",
+    "afii57682",
+    "afii57683",
+    "afii57684",
+    "afii57685",
+    "afii57686",
+    "afii57687",
+    "afii57688",
+    "afii57689",
+    "afii57690",
+    "afii57694",
+    "afii57695",
+    "afii57700",
+    "afii57705",
+    "afii57716",
+    "afii57717",
+    "afii57718",
+    "afii57723",
+    "afii57793",
+    "afii57794",
+    "afii57795",
+    "afii57796",
+    "afii57797",
+    "afii57798",
+    "afii57799",
+    "afii57800",
+    "afii57801",
+    "afii57802",
+    "afii57803",
+    "afii57804",
+    "afii57806",
+    "afii57807",
+    "afii57839",
+    "afii57841",
+    "afii57842",
+    "afii57929",
+    "afii61248",
+    "afii61289",
+    "afii61352",
+    "afii61573",
+    "afii61574",
+    "afii61575",
+    "afii61664",
+    "afii63167",
+    "afii64937",
+    "agujarati",
+    "agurmukhi",
+    "ahiragana",
+    "ahookabove",
+    "aibengali",
+    "aibopomofo",
+    "aideva",
+    "aiecyrillic",
+    "aigujarati",
+    "aigurmukhi",
+    "aimatragurmukhi",
+    "ainarabic",
+    "ainfinalarabic",
+    "aininitialarabic",
+    "ainmedialarabic",
+    "ainvertedbreve",
+    "aivowelsignbengali",
+    "aivowelsigndeva",
+    "aivowelsigngujarati",
+    "akatakana",
+    "akatakanahalfwidth",
+    "akorean",
+    "alef",
+    "alefarabic",
+    "alefdageshhebrew",
+    "aleffinalarabic",
+    "alefhamzaabovearabic",
+    "alefhamzaabovefinalarabic",
+    "alefhamzabelowarabic",
+    "alefhamzabelowfinalarabic",
+    "alefhebrew",
+    "aleflamedhebrew",
+    "alefmaddaabovearabic",
+    "alefmaddaabovefinalarabic",
+    "alefmaksuraarabic",
+    "alefmaksurafinalarabic",
+    "alefmaksurainitialarabic",
+    "alefmaksuramedialarabic",
+    "alefpatahhebrew",
+    "alefqamatshebrew",
+    "aleph",
+    "allequal",
+    "alpha",
+    "alphatonos",
+    "amacron",
+    "amonospace",
+    "ampersandmonospace",
+    "amsquare",
+    "anbopomofo",
+    "angbopomofo",
+    "angkhankhuthai",
+    "angle",
+    "anglebracketleft",
+    "anglebracketleftvertical",
+    "anglebracketright",
+    "anglebracketrightvertical",
+    "angleleft",
+    "angleright",
+    "angstrom",
+    "anoteleia",
+    "anudattadeva",
+    "anusvarabengali",
+    "anusvaradeva",
+    "anusvaragujarati",
+    "aogonek",
+    "apaatosquare",
+    "aparen",
+    "apostrophearmenian",
+    "apostrophemod",
+    "apple",
+    "approaches",
+    "approxequal",
+    "approxequalorimage",
+    "approximatelyequal",
+    "araeaekorean",
+    "araeakorean",
+    "arc",
+    "arighthalfring",
+    "aringacute",
+    "aringbelow",
+    "arrowboth",
+    "arrowdashdown",
+    "arrowdashleft",
+    "arrowdashright",
+    "arrowdashup",
+    "arrowdblboth",
+    "arrowdbldown",
+    "arrowdblleft",
+    "arrowdblright",
+    "arrowdblup",
+    "arrowdown",
+    "arrowdownleft",
+    "arrowdownright",
+    "arrowdownwhite",
+    "arrowheaddownmod",
+    "arrowheadleftmod",
+    "arrowheadrightmod",
+    "arrowheadupmod",
+    "arrowhorizex",
+    "arrowleft",
+    "arrowleftdbl",
+    "arrowleftdblstroke",
+    "arrowleftoverright",
+    "arrowleftwhite",
+    "arrowright",
+    "arrowrightdblstroke",
+    "arrowrightheavy",
+    "arrowrightoverleft",
+    "arrowrightwhite",
+    "arrowtableft",
+    "arrowtabright",
+    "arrowup",
+    "arrowupdn",
+    "arrowupdnbse",
+    "arrowupdownbase",
+    "arrowupleft",
+    "arrowupleftofdown",
+    "arrowupright",
+    "arrowupwhite",
+    "arrowvertex",
+    "asciicircummonospace",
+    "asciitildemonospace",
+    "ascript",
+    "ascriptturned",
+    "asmallhiragana",
+    "asmallkatakana",
+    "asmallkatakanahalfwidth",
+    "asteriskaltonearabic",
+    "asteriskarabic",
+    "asteriskmath",
+    "asteriskmonospace",
+    "asterisksmall",
+    "asterism",
+    "asymptoticallyequal",
+    "atmonospace",
+    "atsmall",
+    "aturned",
+    "aubengali",
+    "aubopomofo",
+    "audeva",
+    "augujarati",
+    "augurmukhi",
+    "aulengthmarkbengali",
+    "aumatragurmukhi",
+    "auvowelsignbengali",
+    "auvowelsigndeva",
+    "auvowelsigngujarati",
+    "avagrahadeva",
+    "aybarmenian",
+    "ayin",
+    "ayinaltonehebrew",
+    "ayinhebrew",
+    "babengali",
+    "backslashmonospace",
+    "badeva",
+    "bagujarati",
+    "bagurmukhi",
+    "bahiragana",
+    "bahtthai",
+    "bakatakana",
+    "barmonospace",
+    "bbopomofo",
+    "bcircle",
+    "bdotaccent",
+    "bdotbelow",
+    "beamedsixteenthnotes",
+    "because",
+    "becyrillic",
+    "beharabic",
+    "behfinalarabic",
+    "behinitialarabic",
+    "behiragana",
+    "behmedialarabic",
+    "behmeeminitialarabic",
+    "behmeemisolatedarabic",
+    "behnoonfinalarabic",
+    "bekatakana",
+    "benarmenian",
+    "bet",
+    "beta",
+    "betasymbolgreek",
+    "betdagesh",
+    "betdageshhebrew",
+    "bethebrew",
+    "betrafehebrew",
+    "bhabengali",
+    "bhadeva",
+    "bhagujarati",
+    "bhagurmukhi",
+    "bhook",
+    "bihiragana",
+    "bikatakana",
+    "bilabialclick",
+    "bindigurmukhi",
+    "birusquare",
+    "blackcircle",
+    "blackdiamond",
+    "blackdownpointingtriangle",
+    "blackleftpointingpointer",
+    "blackleftpointingtriangle",
+    "blacklenticularbracketleft",
+    "blacklenticularbracketleftvertical",
+    "blacklenticularbracketright",
+    "blacklenticularbracketrightvertical",
+    "blacklowerlefttriangle",
+    "blacklowerrighttriangle",
+    "blackrectangle",
+    "blackrightpointingpointer",
+    "blackrightpointingtriangle",
+    "blacksmallsquare",
+    "blacksmilingface",
+    "blacksquare",
+    "blackstar",
+    "blackupperlefttriangle",
+    "blackupperrighttriangle",
+    "blackuppointingsmalltriangle",
+    "blackuppointingtriangle",
+    "blank",
+    "blinebelow",
+    "block",
+    "bmonospace",
+    "bobaimaithai",
+    "bohiragana",
+    "bokatakana",
+    "bparen",
+    "bqsquare",
+    "braceex",
+    "braceleftbt",
+    "braceleftmid",
+    "braceleftmonospace",
+    "braceleftsmall",
+    "bracelefttp",
+    "braceleftvertical",
+    "bracerightbt",
+    "bracerightmid",
+    "bracerightmonospace",
+    "bracerightsmall",
+    "bracerighttp",
+    "bracerightvertical",
+    "bracketleftbt",
+    "bracketleftex",
+    "bracketleftmonospace",
+    "bracketlefttp",
+    "bracketrightbt",
+    "bracketrightex",
+    "bracketrightmonospace",
+    "bracketrighttp",
+    "brevebelowcmb",
+    "brevecmb",
+    "breveinvertedbelowcmb",
+    "breveinvertedcmb",
+    "breveinverteddoublecmb",
+    "bridgebelowcmb",
+    "bridgeinvertedbelowcmb",
+    "bstroke",
+    "btopbar",
+    "buhiragana",
+    "bukatakana",
+    "bulletinverse",
+    "bulletoperator",
+    "bullseye",
+    "caarmenian",
+    "cabengali",
+    "cacute",
+    "cadeva",
+    "cagujarati",
+    "cagurmukhi",
+    "calsquare",
+    "candrabindubengali",
+    "candrabinducmb",
+    "candrabindudeva",
+    "candrabindugujarati",
+    "capslock",
+    "careof",
+    "caronbelowcmb",
+    "caroncmb",
+    "carriagereturn",
+    "cbopomofo",
+    "ccaron",
+    "ccedillaacute",
+    "ccircle",
+    "ccircumflex",
+    "ccurl",
+    "cdot",
+    "cdotaccent",
+    "cdsquare",
+    "cedillacmb",
+    "centigrade",
+    "centmonospace",
+    "chaarmenian",
+    "chabengali",
+    "chadeva",
+    "chagujarati",
+    "chagurmukhi",
+    "chbopomofo",
+    "cheabkhasiancyrillic",
+    "checkmark",
+    "checyrillic",
+    "chedescenderabkhasiancyrillic",
+    "chedescendercyrillic",
+    "chedieresiscyrillic",
+    "cheharmenian",
+    "chekhakassiancyrillic",
+    "cheverticalstrokecyrillic",
+    "chi",
+    "chieuchacirclekorean",
+    "chieuchaparenkorean",
+    "chieuchcirclekorean",
+    "chieuchkorean",
+    "chieuchparenkorean",
+    "chochangthai",
+    "chochanthai",
+    "chochingthai",
+    "chochoethai",
+    "chook",
+    "cieucacirclekorean",
+    "cieucaparenkorean",
+    "cieuccirclekorean",
+    "cieuckorean",
+    "cieucparenkorean",
+    "cieucuparenkorean",
+    "circle",
+    "circlemultiply",
+    "circleot",
+    "circleplus",
+    "circlepostalmark",
+    "circlewithlefthalfblack",
+    "circlewithrighthalfblack",
+    "circumflexbelowcmb",
+    "circumflexcmb",
+    "clear",
+    "clickalveolar",
+    "clickdental",
+    "clicklateral",
+    "clickretroflex",
+    "club",
+    "clubsuitblack",
+    "clubsuitwhite",
+    "cmcubedsquare",
+    "cmonospace",
+    "cmsquaredsquare",
+    "coarmenian",
+    "colonmonospace",
+    "colonsign",
+    "colonsmall",
+    "colontriangularhalfmod",
+    "colontriangularmod",
+    "commaabovecmb",
+    "commaaboverightcmb",
+    "commaaccent",
+    "commaarabic",
+    "commaarmenian",
+    "commamonospace",
+    "commareversedabovecmb",
+    "commareversedmod",
+    "commasmall",
+    "commaturnedabovecmb",
+    "commaturnedmod",
+    "compass",
+    "congruent",
+    "contourintegral",
+    "control",
+    "controlACK",
+    "controlBEL",
+    "controlBS",
+    "controlCAN",
+    "controlCR",
+    "controlDC1",
+    "controlDC2",
+    "controlDC3",
+    "controlDC4",
+    "controlDEL",
+    "controlDLE",
+    "controlEM",
+    "controlENQ",
+    "controlEOT",
+    "controlESC",
+    "controlETB",
+    "controlETX",
+    "controlFF",
+    "controlFS",
+    "controlGS",
+    "controlHT",
+    "controlLF",
+    "controlNAK",
+    "controlRS",
+    "controlSI",
+    "controlSO",
+    "controlSOT",
+    "controlSTX",
+    "controlSUB",
+    "controlSYN",
+    "controlUS",
+    "controlVT",
+    "copyrightsans",
+    "copyrightserif",
+    "cornerbracketleft",
+    "cornerbracketlefthalfwidth",
+    "cornerbracketleftvertical",
+    "cornerbracketright",
+    "cornerbracketrighthalfwidth",
+    "cornerbracketrightvertical",
+    "corporationsquare",
+    "cosquare",
+    "coverkgsquare",
+    "cparen",
+    "cruzeiro",
+    "cstretched",
+    "curlyand",
+    "curlyor",
+    "cyrBreve",
+    "cyrFlex",
+    "cyrbreve",
+    "cyrflex",
+    "daarmenian",
+    "dabengali",
+    "dadarabic",
+    "dadeva",
+    "dadfinalarabic",
+    "dadinitialarabic",
+    "dadmedialarabic",
+    "dagesh",
+    "dageshhebrew",
+    "dagujarati",
+    "dagurmukhi",
+    "dahiragana",
+    "dakatakana",
+    "dalarabic",
+    "dalet",
+    "daletdagesh",
+    "daletdageshhebrew",
+    "dalethatafpatah",
+    "dalethatafpatahhebrew",
+    "dalethatafsegol",
+    "dalethatafsegolhebrew",
+    "dalethebrew",
+    "dalethiriq",
+    "dalethiriqhebrew",
+    "daletholam",
+    "daletholamhebrew",
+    "daletpatah",
+    "daletpatahhebrew",
+    "daletqamats",
+    "daletqamatshebrew",
+    "daletqubuts",
+    "daletqubutshebrew",
+    "daletsegol",
+    "daletsegolhebrew",
+    "daletsheva",
+    "daletshevahebrew",
+    "dalettsere",
+    "dalettserehebrew",
+    "dalfinalarabic",
+    "dammaarabic",
+    "dammalowarabic",
+    "dammatanaltonearabic",
+    "dammatanarabic",
+    "danda",
+    "dargahebrew",
+    "dargalefthebrew",
+    "dasiapneumatacyrilliccmb",
+    "dblGrave",
+    "dblanglebracketleft",
+    "dblanglebracketleftvertical",
+    "dblanglebracketright",
+    "dblanglebracketrightvertical",
+    "dblarchinvertedbelowcmb",
+    "dblarrowleft",
+    "dblarrowright",
+    "dbldanda",
+    "dblgrave",
+    "dblgravecmb",
+    "dblintegral",
+    "dbllowline",
+    "dbllowlinecmb",
+    "dbloverlinecmb",
+    "dblprimemod",
+    "dblverticalbar",
+    "dblverticallineabovecmb",
+    "dbopomofo",
+    "dbsquare",
+    "dcaron",
+    "dcedilla",
+    "dcircle",
+    "dcircumflexbelow",
+    "dcroat",
+    "ddabengali",
+    "ddadeva",
+    "ddagujarati",
+    "ddagurmukhi",
+    "ddalarabic",
+    "ddalfinalarabic",
+    "dddhadeva",
+    "ddhabengali",
+    "ddhadeva",
+    "ddhagujarati",
+    "ddhagurmukhi",
+    "ddotaccent",
+    "ddotbelow",
+    "decimalseparatorarabic",
+    "decimalseparatorpersian",
+    "decyrillic",
+    "dehihebrew",
+    "dehiragana",
+    "deicoptic",
+    "dekatakana",
+    "deleteleft",
+    "deleteright",
+    "delta",
+    "deltaturned",
+    "denominatorminusonenumeratorbengali",
+    "dezh",
+    "dhabengali",
+    "dhadeva",
+    "dhagujarati",
+    "dhagurmukhi",
+    "dhook",
+    "dialytikatonos",
+    "dialytikatonoscmb",
+    "diamond",
+    "diamondsuitwhite",
+    "dieresisacute",
+    "dieresisbelowcmb",
+    "dieresiscmb",
+    "dieresisgrave",
+    "dieresistonos",
+    "dihiragana",
+    "dikatakana",
+    "dittomark",
+    "divides",
+    "divisionslash",
+    "djecyrillic",
+    "dkshade",
+    "dlinebelow",
+    "dlsquare",
+    "dmacron",
+    "dmonospace",
+    "dnblock",
+    "dochadathai",
+    "dodekthai",
+    "dohiragana",
+    "dokatakana",
+    "dollarmonospace",
+    "dollarsmall",
+    "dong",
+    "dorusquare",
+    "dotaccentcmb",
+    "dotbelowcmb",
+    "dotbelowcomb",
+    "dotkatakana",
+    "dotlessj",
+    "dotlessjstrokehook",
+    "dotmath",
+    "dottedcircle",
+    "doubleyodpatah",
+    "doubleyodpatahhebrew",
+    "downtackbelowcmb",
+    "downtackmod",
+    "dparen",
+    "dtail",
+    "dtopbar",
+    "duhiragana",
+    "dukatakana",
+    "dz",
+    "dzaltone",
+    "dzcaron",
+    "dzcurl",
+    "dzeabkhasiancyrillic",
+    "dzecyrillic",
+    "dzhecyrillic",
+    "earth",
+    "ebengali",
+    "ebopomofo",
+    "ebreve",
+    "ecandradeva",
+    "ecandragujarati",
+    "ecandravowelsigndeva",
+    "ecandravowelsigngujarati",
+    "ecaron",
+    "ecedillabreve",
+    "echarmenian",
+    "echyiwnarmenian",
+    "ecircle",
+    "ecircumflexacute",
+    "ecircumflexbelow",
+    "ecircumflexdotbelow",
+    "ecircumflexgrave",
+    "ecircumflexhookabove",
+    "ecircumflextilde",
+    "ecyrillic",
+    "edblgrave",
+    "edeva",
+    "edot",
+    "edotaccent",
+    "edotbelow",
+    "eegurmukhi",
+    "eematragurmukhi",
+    "efcyrillic",
+    "egujarati",
+    "eharmenian",
+    "ehbopomofo",
+    "ehiragana",
+    "ehookabove",
+    "eibopomofo",
+    "eightarabic",
+    "eightbengali",
+    "eightcircle",
+    "eightcircleinversesansserif",
+    "eightdeva",
+    "eighteencircle",
+    "eighteenparen",
+    "eighteenperiod",
+    "eightgujarati",
+    "eightgurmukhi",
+    "eighthackarabic",
+    "eighthangzhou",
+    "eighthnotebeamed",
+    "eightideographicparen",
+    "eightmonospace",
+    "eightparen",
+    "eightperiod",
+    "eightpersian",
+    "eightroman",
+    "eightthai",
+    "einvertedbreve",
+    "eiotifiedcyrillic",
+    "ekatakana",
+    "ekatakanahalfwidth",
+    "ekonkargurmukhi",
+    "ekorean",
+    "elcyrillic",
+    "element",
+    "elevencircle",
+    "elevenparen",
+    "elevenperiod",
+    "elevenroman",
+    "ellipsisvertical",
+    "emacron",
+    "emacronacute",
+    "emacrongrave",
+    "emcyrillic",
+    "emdashvertical",
+    "emonospace",
+    "emphasismarkarmenian",
+    "emptyset",
+    "enbopomofo",
+    "encyrillic",
+    "endashvertical",
+    "endescendercyrillic",
+    "eng",
+    "engbopomofo",
+    "enghecyrillic",
+    "enhookcyrillic",
+    "enspace",
+    "eogonek",
+    "eokorean",
+    "eopen",
+    "eopenclosed",
+    "eopenreversed",
+    "eopenreversedclosed",
+    "eopenreversedhook",
+    "eparen",
+    "epsilon",
+    "epsilontonos",
+    "equalmonospace",
+    "equalsmall",
+    "equalsuperior",
+    "equivalence",
+    "erbopomofo",
+    "ercyrillic",
+    "ereversed",
+    "ereversedcyrillic",
+    "escyrillic",
+    "esdescendercyrillic",
+    "esh",
+    "eshcurl",
+    "eshortdeva",
+    "eshortvowelsigndeva",
+    "eshreversedloop",
+    "eshsquatreversed",
+    "esmallhiragana",
+    "esmallkatakana",
+    "esmallkatakanahalfwidth",
+    "estimated",
+    "eta",
+    "etarmenian",
+    "etatonos",
+    "etilde",
+    "etildebelow",
+    "etnahtafoukhhebrew",
+    "etnahtafoukhlefthebrew",
+    "etnahtahebrew",
+    "etnahtalefthebrew",
+    "eturned",
+    "eukorean",
+    "euro",
+    "evowelsignbengali",
+    "evowelsigndeva",
+    "evowelsigngujarati",
+    "exclamarmenian",
+    "exclamdbl",
+    "exclammonospace",
+    "existential",
+    "ezh",
+    "ezhcaron",
+    "ezhcurl",
+    "ezhreversed",
+    "ezhtail",
+    "fadeva",
+    "fagurmukhi",
+    "fahrenheit",
+    "fathaarabic",
+    "fathalowarabic",
+    "fathatanarabic",
+    "fbopomofo",
+    "fcircle",
+    "fdotaccent",
+    "feharabic",
+    "feharmenian",
+    "fehfinalarabic",
+    "fehinitialarabic",
+    "fehmedialarabic",
+    "feicoptic",
+    "female",
+    "fifteencircle",
+    "fifteenparen",
+    "fifteenperiod",
+    "filledbox",
+    "filledrect",
+    "finalkaf",
+    "finalkafdagesh",
+    "finalkafdageshhebrew",
+    "finalkafhebrew",
+    "finalkafqamats",
+    "finalkafqamatshebrew",
+    "finalkafsheva",
+    "finalkafshevahebrew",
+    "finalmem",
+    "finalmemhebrew",
+    "finalnun",
+    "finalnunhebrew",
+    "finalpe",
+    "finalpehebrew",
+    "finaltsadi",
+    "finaltsadihebrew",
+    "firsttonechinese",
+    "fisheye",
+    "fitacyrillic",
+    "fivearabic",
+    "fivebengali",
+    "fivecircle",
+    "fivecircleinversesansserif",
+    "fivedeva",
+    "fivegujarati",
+    "fivegurmukhi",
+    "fivehackarabic",
+    "fivehangzhou",
+    "fiveideographicparen",
+    "fivemonospace",
+    "fiveparen",
+    "fiveperiod",
+    "fivepersian",
+    "fiveroman",
+    "fivethai",
+    "fmonospace",
+    "fmsquare",
+    "fofanthai",
+    "fofathai",
+    "fongmanthai",
+    "forall",
+    "fourarabic",
+    "fourbengali",
+    "fourcircle",
+    "fourcircleinversesansserif",
+    "fourdeva",
+    "fourgujarati",
+    "fourgurmukhi",
+    "fourhackarabic",
+    "fourhangzhou",
+    "fourideographicparen",
+    "fourmonospace",
+    "fournumeratorbengali",
+    "fourparen",
+    "fourperiod",
+    "fourpersian",
+    "fourroman",
+    "fourteencircle",
+    "fourteenparen",
+    "fourteenperiod",
+    "fourthai",
+    "fourthtonechinese",
+    "fparen",
+    "franc",
+    "gabengali",
+    "gacute",
+    "gadeva",
+    "gafarabic",
+    "gaffinalarabic",
+    "gafinitialarabic",
+    "gafmedialarabic",
+    "gagujarati",
+    "gagurmukhi",
+    "gahiragana",
+    "gakatakana",
+    "gamma",
+    "gammalatinsmall",
+    "gammasuperior",
+    "gangiacoptic",
+    "gbopomofo",
+    "gbreve",
+    "gcaron",
+    "gcedilla",
+    "gcircle",
+    "gcircumflex",
+    "gcommaaccent",
+    "gdot",
+    "gdotaccent",
+    "gecyrillic",
+    "gehiragana",
+    "gekatakana",
+    "geometricallyequal",
+    "gereshaccenthebrew",
+    "gereshhebrew",
+    "gereshmuqdamhebrew",
+    "gershayimaccenthebrew",
+    "gershayimhebrew",
+    "getamark",
+    "ghabengali",
+    "ghadarmenian",
+    "ghadeva",
+    "ghagujarati",
+    "ghagurmukhi",
+    "ghainarabic",
+    "ghainfinalarabic",
+    "ghaininitialarabic",
+    "ghainmedialarabic",
+    "ghemiddlehookcyrillic",
+    "ghestrokecyrillic",
+    "gheupturncyrillic",
+    "ghhadeva",
+    "ghhagurmukhi",
+    "ghook",
+    "ghzsquare",
+    "gihiragana",
+    "gikatakana",
+    "gimarmenian",
+    "gimel",
+    "gimeldagesh",
+    "gimeldageshhebrew",
+    "gimelhebrew",
+    "gjecyrillic",
+    "glottalinvertedstroke",
+    "glottalstop",
+    "glottalstopinverted",
+    "glottalstopmod",
+    "glottalstopreversed",
+    "glottalstopreversedmod",
+    "glottalstopreversedsuperior",
+    "glottalstopstroke",
+    "glottalstopstrokereversed",
+    "gmacron",
+    "gmonospace",
+    "gohiragana",
+    "gokatakana",
+    "gparen",
+    "gpasquare",
+    "gradient",
+    "gravebelowcmb",
+    "gravecmb",
+    "gravecomb",
+    "gravedeva",
+    "gravelowmod",
+    "gravemonospace",
+    "gravetonecmb",
+    "greaterequal",
+    "greaterequalorless",
+    "greatermonospace",
+    "greaterorequivalent",
+    "greaterorless",
+    "greateroverequal",
+    "greatersmall",
+    "gscript",
+    "gstroke",
+    "guhiragana",
+    "gukatakana",
+    "guramusquare",
+    "gysquare",
+    "haabkhasiancyrillic",
+    "haaltonearabic",
+    "habengali",
+    "hadescendercyrillic",
+    "hadeva",
+    "hagujarati",
+    "hagurmukhi",
+    "haharabic",
+    "hahfinalarabic",
+    "hahinitialarabic",
+    "hahiragana",
+    "hahmedialarabic",
+    "haitusquare",
+    "hakatakana",
+    "hakatakanahalfwidth",
+    "halantgurmukhi",
+    "hamzaarabic",
+    "hamzadammaarabic",
+    "hamzadammatanarabic",
+    "hamzafathaarabic",
+    "hamzafathatanarabic",
+    "hamzalowarabic",
+    "hamzalowkasraarabic",
+    "hamzalowkasratanarabic",
+    "hamzasukunarabic",
+    "hangulfiller",
+    "hardsigncyrillic",
+    "harpoonleftbarbup",
+    "harpoonrightbarbup",
+    "hasquare",
+    "hatafpatah",
+    "hatafpatah16",
+    "hatafpatah23",
+    "hatafpatah2f",
+    "hatafpatahhebrew",
+    "hatafpatahnarrowhebrew",
+    "hatafpatahquarterhebrew",
+    "hatafpatahwidehebrew",
+    "hatafqamats",
+    "hatafqamats1b",
+    "hatafqamats28",
+    "hatafqamats34",
+    "hatafqamatshebrew",
+    "hatafqamatsnarrowhebrew",
+    "hatafqamatsquarterhebrew",
+    "hatafqamatswidehebrew",
+    "hatafsegol",
+    "hatafsegol17",
+    "hatafsegol24",
+    "hatafsegol30",
+    "hatafsegolhebrew",
+    "hatafsegolnarrowhebrew",
+    "hatafsegolquarterhebrew",
+    "hatafsegolwidehebrew",
+    "hbar",
+    "hbopomofo",
+    "hbrevebelow",
+    "hcedilla",
+    "hcircle",
+    "hcircumflex",
+    "hdieresis",
+    "hdotaccent",
+    "hdotbelow",
+    "he",
+    "heart",
+    "heartsuitblack",
+    "heartsuitwhite",
+    "hedagesh",
+    "hedageshhebrew",
+    "hehaltonearabic",
+    "heharabic",
+    "hehebrew",
+    "hehfinalaltonearabic",
+    "hehfinalalttwoarabic",
+    "hehfinalarabic",
+    "hehhamzaabovefinalarabic",
+    "hehhamzaaboveisolatedarabic",
+    "hehinitialaltonearabic",
+    "hehinitialarabic",
+    "hehiragana",
+    "hehmedialaltonearabic",
+    "hehmedialarabic",
+    "heiseierasquare",
+    "hekatakana",
+    "hekatakanahalfwidth",
+    "hekutaarusquare",
+    "henghook",
+    "herutusquare",
+    "het",
+    "hethebrew",
+    "hhook",
+    "hhooksuperior",
+    "hieuhacirclekorean",
+    "hieuhaparenkorean",
+    "hieuhcirclekorean",
+    "hieuhkorean",
+    "hieuhparenkorean",
+    "hihiragana",
+    "hikatakana",
+    "hikatakanahalfwidth",
+    "hiriq",
+    "hiriq14",
+    "hiriq21",
+    "hiriq2d",
+    "hiriqhebrew",
+    "hiriqnarrowhebrew",
+    "hiriqquarterhebrew",
+    "hiriqwidehebrew",
+    "hlinebelow",
+    "hmonospace",
+    "hoarmenian",
+    "hohipthai",
+    "hohiragana",
+    "hokatakana",
+    "hokatakanahalfwidth",
+    "holam",
+    "holam19",
+    "holam26",
+    "holam32",
+    "holamhebrew",
+    "holamnarrowhebrew",
+    "holamquarterhebrew",
+    "holamwidehebrew",
+    "honokhukthai",
+    "hookabovecomb",
+    "hookcmb",
+    "hookpalatalizedbelowcmb",
+    "hookretroflexbelowcmb",
+    "hoonsquare",
+    "horicoptic",
+    "horizontalbar",
+    "horncmb",
+    "hotsprings",
+    "house",
+    "hparen",
+    "hsuperior",
+    "hturned",
+    "huhiragana",
+    "huiitosquare",
+    "hukatakana",
+    "hukatakanahalfwidth",
+    "hungarumlautcmb",
+    "hv",
+    "hyphenmonospace",
+    "hyphensmall",
+    "hyphentwo",
+    "iacyrillic",
+    "ibengali",
+    "ibopomofo",
+    "ibreve",
+    "icaron",
+    "icircle",
+    "icyrillic",
+    "idblgrave",
+    "ideographearthcircle",
+    "ideographfirecircle",
+    "ideographicallianceparen",
+    "ideographiccallparen",
+    "ideographiccentrecircle",
+    "ideographicclose",
+    "ideographiccomma",
+    "ideographiccommaleft",
+    "ideographiccongratulationparen",
+    "ideographiccorrectcircle",
+    "ideographicearthparen",
+    "ideographicenterpriseparen",
+    "ideographicexcellentcircle",
+    "ideographicfestivalparen",
+    "ideographicfinancialcircle",
+    "ideographicfinancialparen",
+    "ideographicfireparen",
+    "ideographichaveparen",
+    "ideographichighcircle",
+    "ideographiciterationmark",
+    "ideographiclaborcircle",
+    "ideographiclaborparen",
+    "ideographicleftcircle",
+    "ideographiclowcircle",
+    "ideographicmedicinecircle",
+    "ideographicmetalparen",
+    "ideographicmoonparen",
+    "ideographicnameparen",
+    "ideographicperiod",
+    "ideographicprintcircle",
+    "ideographicreachparen",
+    "ideographicrepresentparen",
+    "ideographicresourceparen",
+    "ideographicrightcircle",
+    "ideographicsecretcircle",
+    "ideographicselfparen",
+    "ideographicsocietyparen",
+    "ideographicspace",
+    "ideographicspecialparen",
+    "ideographicstockparen",
+    "ideographicstudyparen",
+    "ideographicsunparen",
+    "ideographicsuperviseparen",
+    "ideographicwaterparen",
+    "ideographicwoodparen",
+    "ideographiczero",
+    "ideographmetalcircle",
+    "ideographmooncircle",
+    "ideographnamecircle",
+    "ideographsuncircle",
+    "ideographwatercircle",
+    "ideographwoodcircle",
+    "ideva",
+    "idieresisacute",
+    "idieresiscyrillic",
+    "idotbelow",
+    "iebrevecyrillic",
+    "iecyrillic",
+    "ieungacirclekorean",
+    "ieungaparenkorean",
+    "ieungcirclekorean",
+    "ieungkorean",
+    "ieungparenkorean",
+    "igujarati",
+    "igurmukhi",
+    "ihiragana",
+    "ihookabove",
+    "iibengali",
+    "iicyrillic",
+    "iideva",
+    "iigujarati",
+    "iigurmukhi",
+    "iimatragurmukhi",
+    "iinvertedbreve",
+    "iishortcyrillic",
+    "iivowelsignbengali",
+    "iivowelsigndeva",
+    "iivowelsigngujarati",
+    "ij",
+    "ikatakana",
+    "ikatakanahalfwidth",
+    "ikorean",
+    "ilde",
+    "iluyhebrew",
+    "imacron",
+    "imacroncyrillic",
+    "imageorapproximatelyequal",
+    "imatragurmukhi",
+    "imonospace",
+    "increment",
+    "infinity",
+    "iniarmenian",
+    "integral",
+    "integralbottom",
+    "integralbt",
+    "integralex",
+    "integraltop",
+    "integraltp",
+    "intersection",
+    "intisquare",
+    "invbullet",
+    "invcircle",
+    "invsmileface",
+    "iocyrillic",
+    "iogonek",
+    "iota",
+    "iotadieresis",
+    "iotadieresistonos",
+    "iotalatin",
+    "iotatonos",
+    "iparen",
+    "irigurmukhi",
+    "ismallhiragana",
+    "ismallkatakana",
+    "ismallkatakanahalfwidth",
+    "issharbengali",
+    "istroke",
+    "iterationhiragana",
+    "iterationkatakana",
+    "itilde",
+    "itildebelow",
+    "iubopomofo",
+    "iucyrillic",
+    "ivowelsignbengali",
+    "ivowelsigndeva",
+    "ivowelsigngujarati",
+    "izhitsacyrillic",
+    "izhitsadblgravecyrillic",
+    "jaarmenian",
+    "jabengali",
+    "jadeva",
+    "jagujarati",
+    "jagurmukhi",
+    "jbopomofo",
+    "jcaron",
+    "jcircle",
+    "jcircumflex",
+    "jcrossedtail",
+    "jdotlessstroke",
+    "jecyrillic",
+    "jeemarabic",
+    "jeemfinalarabic",
+    "jeeminitialarabic",
+    "jeemmedialarabic",
+    "jeharabic",
+    "jehfinalarabic",
+    "jhabengali",
+    "jhadeva",
+    "jhagujarati",
+    "jhagurmukhi",
+    "jheharmenian",
+    "jis",
+    "jmonospace",
+    "jparen",
+    "jsuperior",
+    "kabashkircyrillic",
+    "kabengali",
+    "kacute",
+    "kacyrillic",
+    "kadescendercyrillic",
+    "kadeva",
+    "kaf",
+    "kafarabic",
+    "kafdagesh",
+    "kafdageshhebrew",
+    "kaffinalarabic",
+    "kafhebrew",
+    "kafinitialarabic",
+    "kafmedialarabic",
+    "kafrafehebrew",
+    "kagujarati",
+    "kagurmukhi",
+    "kahiragana",
+    "kahookcyrillic",
+    "kakatakana",
+    "kakatakanahalfwidth",
+    "kappa",
+    "kappasymbolgreek",
+    "kapyeounmieumkorean",
+    "kapyeounphieuphkorean",
+    "kapyeounpieupkorean",
+    "kapyeounssangpieupkorean",
+    "karoriisquare",
+    "kashidaautoarabic",
+    "kashidaautonosidebearingarabic",
+    "kasmallkatakana",
+    "kasquare",
+    "kasraarabic",
+    "kasratanarabic",
+    "kastrokecyrillic",
+    "katahiraprolongmarkhalfwidth",
+    "kaverticalstrokecyrillic",
+    "kbopomofo",
+    "kcalsquare",
+    "kcaron",
+    "kcedilla",
+    "kcircle",
+    "kcommaaccent",
+    "kdotbelow",
+    "keharmenian",
+    "kehiragana",
+    "kekatakana",
+    "kekatakanahalfwidth",
+    "kenarmenian",
+    "kesmallkatakana",
+    "kgreenlandic",
+    "khabengali",
+    "khacyrillic",
+    "khadeva",
+    "khagujarati",
+    "khagurmukhi",
+    "khaharabic",
+    "khahfinalarabic",
+    "khahinitialarabic",
+    "khahmedialarabic",
+    "kheicoptic",
+    "khhadeva",
+    "khhagurmukhi",
+    "khieukhacirclekorean",
+    "khieukhaparenkorean",
+    "khieukhcirclekorean",
+    "khieukhkorean",
+    "khieukhparenkorean",
+    "khokhaithai",
+    "khokhonthai",
+    "khokhuatthai",
+    "khokhwaithai",
+    "khomutthai",
+    "khook",
+    "khorakhangthai",
+    "khzsquare",
+    "kihiragana",
+    "kikatakana",
+    "kikatakanahalfwidth",
+    "kiroguramusquare",
+    "kiromeetorusquare",
+    "kirosquare",
+    "kiyeokacirclekorean",
+    "kiyeokaparenkorean",
+    "kiyeokcirclekorean",
+    "kiyeokkorean",
+    "kiyeokparenkorean",
+    "kiyeoksioskorean",
+    "kjecyrillic",
+    "klinebelow",
+    "klsquare",
+    "kmcubedsquare",
+    "kmonospace",
+    "kmsquaredsquare",
+    "kohiragana",
+    "kohmsquare",
+    "kokaithai",
+    "kokatakana",
+    "kokatakanahalfwidth",
+    "kooposquare",
+    "koppacyrillic",
+    "koreanstandardsymbol",
+    "koroniscmb",
+    "kparen",
+    "kpasquare",
+    "ksicyrillic",
+    "ktsquare",
+    "kturned",
+    "kuhiragana",
+    "kukatakana",
+    "kukatakanahalfwidth",
+    "kvsquare",
+    "kwsquare",
+    "labengali",
+    "lacute",
+    "ladeva",
+    "lagujarati",
+    "lagurmukhi",
+    "lakkhangyaothai",
+    "lamaleffinalarabic",
+    "lamalefhamzaabovefinalarabic",
+    "lamalefhamzaaboveisolatedarabic",
+    "lamalefhamzabelowfinalarabic",
+    "lamalefhamzabelowisolatedarabic",
+    "lamalefisolatedarabic",
+    "lamalefmaddaabovefinalarabic",
+    "lamalefmaddaaboveisolatedarabic",
+    "lamarabic",
+    "lambda",
+    "lambdastroke",
+    "lamed",
+    "lameddagesh",
+    "lameddageshhebrew",
+    "lamedhebrew",
+    "lamedholam",
+    "lamedholamdagesh",
+    "lamedholamdageshhebrew",
+    "lamedholamhebrew",
+    "lamfinalarabic",
+    "lamhahinitialarabic",
+    "laminitialarabic",
+    "lamjeeminitialarabic",
+    "lamkhahinitialarabic",
+    "lamlamhehisolatedarabic",
+    "lammedialarabic",
+    "lammeemhahinitialarabic",
+    "lammeeminitialarabic",
+    "lammeemjeeminitialarabic",
+    "lammeemkhahinitialarabic",
+    "largecircle",
+    "lbar",
+    "lbelt",
+    "lbopomofo",
+    "lcaron",
+    "lcedilla",
+    "lcircle",
+    "lcircumflexbelow",
+    "lcommaaccent",
+    "ldot",
+    "ldotaccent",
+    "ldotbelow",
+    "ldotbelowmacron",
+    "leftangleabovecmb",
+    "lefttackbelowcmb",
+    "lessequal",
+    "lessequalorgreater",
+    "lessmonospace",
+    "lessorequivalent",
+    "lessorgreater",
+    "lessoverequal",
+    "lesssmall",
+    "lezh",
+    "lfblock",
+    "lhookretroflex",
+    "lira",
+    "liwnarmenian",
+    "lj",
+    "ljecyrillic",
+    "ll",
+    "lladeva",
+    "llagujarati",
+    "llinebelow",
+    "llladeva",
+    "llvocalicbengali",
+    "llvocalicdeva",
+    "llvocalicvowelsignbengali",
+    "llvocalicvowelsigndeva",
+    "lmiddletilde",
+    "lmonospace",
+    "lmsquare",
+    "lochulathai",
+    "logicaland",
+    "logicalnotreversed",
+    "logicalor",
+    "lolingthai",
+    "longs",
+    "lowlinecenterline",
+    "lowlinecmb",
+    "lowlinedashed",
+    "lozenge",
+    "lparen",
+    "lsquare",
+    "ltshade",
+    "luthai",
+    "lvocalicbengali",
+    "lvocalicdeva",
+    "lvocalicvowelsignbengali",
+    "lvocalicvowelsigndeva",
+    "lxsquare",
+    "mabengali",
+    "macronbelowcmb",
+    "macroncmb",
+    "macronlowmod",
+    "macronmonospace",
+    "macute",
+    "madeva",
+    "magujarati",
+    "magurmukhi",
+    "mahapakhhebrew",
+    "mahapakhlefthebrew",
+    "mahiragana",
+    "maichattawalowleftthai",
+    "maichattawalowrightthai",
+    "maichattawathai",
+    "maichattawaupperleftthai",
+    "maieklowleftthai",
+    "maieklowrightthai",
+    "maiekthai",
+    "maiekupperleftthai",
+    "maihanakatleftthai",
+    "maihanakatthai",
+    "maitaikhuleftthai",
+    "maitaikhuthai",
+    "maitholowleftthai",
+    "maitholowrightthai",
+    "maithothai",
+    "maithoupperleftthai",
+    "maitrilowleftthai",
+    "maitrilowrightthai",
+    "maitrithai",
+    "maitriupperleftthai",
+    "maiyamokthai",
+    "makatakana",
+    "makatakanahalfwidth",
+    "male",
+    "mansyonsquare",
+    "maqafhebrew",
+    "mars",
+    "masoracirclehebrew",
+    "masquare",
+    "mbopomofo",
+    "mbsquare",
+    "mcircle",
+    "mcubedsquare",
+    "mdotaccent",
+    "mdotbelow",
+    "meemarabic",
+    "meemfinalarabic",
+    "meeminitialarabic",
+    "meemmedialarabic",
+    "meemmeeminitialarabic",
+    "meemmeemisolatedarabic",
+    "meetorusquare",
+    "mehiragana",
+    "meizierasquare",
+    "mekatakana",
+    "mekatakanahalfwidth",
+    "mem",
+    "memdagesh",
+    "memdageshhebrew",
+    "memhebrew",
+    "menarmenian",
+    "merkhahebrew",
+    "merkhakefulahebrew",
+    "merkhakefulalefthebrew",
+    "merkhalefthebrew",
+    "mhook",
+    "mhzsquare",
+    "middledotkatakanahalfwidth",
+    "middot",
+    "mieumacirclekorean",
+    "mieumaparenkorean",
+    "mieumcirclekorean",
+    "mieumkorean",
+    "mieumpansioskorean",
+    "mieumparenkorean",
+    "mieumpieupkorean",
+    "mieumsioskorean",
+    "mihiragana",
+    "mikatakana",
+    "mikatakanahalfwidth",
+    "minusbelowcmb",
+    "minuscircle",
+    "minusmod",
+    "minusplus",
+    "minute",
+    "miribaarusquare",
+    "mirisquare",
+    "mlonglegturned",
+    "mlsquare",
+    "mmcubedsquare",
+    "mmonospace",
+    "mmsquaredsquare",
+    "mohiragana",
+    "mohmsquare",
+    "mokatakana",
+    "mokatakanahalfwidth",
+    "molsquare",
+    "momathai",
+    "moverssquare",
+    "moverssquaredsquare",
+    "mparen",
+    "mpasquare",
+    "mssquare",
+    "mturned",
+    "mu1",
+    "muasquare",
+    "muchgreater",
+    "muchless",
+    "mufsquare",
+    "mugreek",
+    "mugsquare",
+    "muhiragana",
+    "mukatakana",
+    "mukatakanahalfwidth",
+    "mulsquare",
+    "mumsquare",
+    "munahhebrew",
+    "munahlefthebrew",
+    "musicalnote",
+    "musicalnotedbl",
+    "musicflatsign",
+    "musicsharpsign",
+    "mussquare",
+    "muvsquare",
+    "muwsquare",
+    "mvmegasquare",
+    "mvsquare",
+    "mwmegasquare",
+    "mwsquare",
+    "nabengali",
+    "nabla",
+    "nacute",
+    "nadeva",
+    "nagujarati",
+    "nagurmukhi",
+    "nahiragana",
+    "nakatakana",
+    "nakatakanahalfwidth",
+    "napostrophe",
+    "nasquare",
+    "nbopomofo",
+    "nbspace",
+    "ncaron",
+    "ncedilla",
+    "ncircle",
+    "ncircumflexbelow",
+    "ncommaaccent",
+    "ndotaccent",
+    "ndotbelow",
+    "nehiragana",
+    "nekatakana",
+    "nekatakanahalfwidth",
+    "newsheqelsign",
+    "nfsquare",
+    "ngabengali",
+    "ngadeva",
+    "ngagujarati",
+    "ngagurmukhi",
+    "ngonguthai",
+    "nhiragana",
+    "nhookleft",
+    "nhookretroflex",
+    "nieunacirclekorean",
+    "nieunaparenkorean",
+    "nieuncieuckorean",
+    "nieuncirclekorean",
+    "nieunhieuhkorean",
+    "nieunkorean",
+    "nieunpansioskorean",
+    "nieunparenkorean",
+    "nieunsioskorean",
+    "nieuntikeutkorean",
+    "nihiragana",
+    "nikatakana",
+    "nikatakanahalfwidth",
+    "nikhahitleftthai",
+    "nikhahitthai",
+    "ninearabic",
+    "ninebengali",
+    "ninecircle",
+    "ninecircleinversesansserif",
+    "ninedeva",
+    "ninegujarati",
+    "ninegurmukhi",
+    "ninehackarabic",
+    "ninehangzhou",
+    "nineideographicparen",
+    "ninemonospace",
+    "nineparen",
+    "nineperiod",
+    "ninepersian",
+    "nineroman",
+    "nineteencircle",
+    "nineteenparen",
+    "nineteenperiod",
+    "ninethai",
+    "nj",
+    "njecyrillic",
+    "nkatakana",
+    "nkatakanahalfwidth",
+    "nlegrightlong",
+    "nlinebelow",
+    "nmonospace",
+    "nmsquare",
+    "nnabengali",
+    "nnadeva",
+    "nnagujarati",
+    "nnagurmukhi",
+    "nnnadeva",
+    "nohiragana",
+    "nokatakana",
+    "nokatakanahalfwidth",
+    "nonbreakingspace",
+    "nonenthai",
+    "nonuthai",
+    "noonarabic",
+    "noonfinalarabic",
+    "noonghunnaarabic",
+    "noonghunnafinalarabic",
+    "noonhehinitialarabic",
+    "nooninitialarabic",
+    "noonjeeminitialarabic",
+    "noonjeemisolatedarabic",
+    "noonmedialarabic",
+    "noonmeeminitialarabic",
+    "noonmeemisolatedarabic",
+    "noonnoonfinalarabic",
+    "notcontains",
+    "notelement",
+    "notelementof",
+    "notequal",
+    "notgreater",
+    "notgreaternorequal",
+    "notgreaternorless",
+    "notidentical",
+    "notless",
+    "notlessnorequal",
+    "notparallel",
+    "notprecedes",
+    "notsubset",
+    "notsucceeds",
+    "notsuperset",
+    "nowarmenian",
+    "nparen",
+    "nssquare",
+    "nu",
+    "nuhiragana",
+    "nukatakana",
+    "nukatakanahalfwidth",
+    "nuktabengali",
+    "nuktadeva",
+    "nuktagujarati",
+    "nuktagurmukhi",
+    "numbersignmonospace",
+    "numbersignsmall",
+    "numeralsigngreek",
+    "numeralsignlowergreek",
+    "numero",
+    "nun",
+    "nundagesh",
+    "nundageshhebrew",
+    "nunhebrew",
+    "nvsquare",
+    "nwsquare",
+    "nyabengali",
+    "nyadeva",
+    "nyagujarati",
+    "nyagurmukhi",
+    "oangthai",
+    "obarred",
+    "obarredcyrillic",
+    "obarreddieresiscyrillic",
+    "obengali",
+    "obopomofo",
+    "obreve",
+    "ocandradeva",
+    "ocandragujarati",
+    "ocandravowelsigndeva",
+    "ocandravowelsigngujarati",
+    "ocaron",
+    "ocircle",
+    "ocircumflexacute",
+    "ocircumflexdotbelow",
+    "ocircumflexgrave",
+    "ocircumflexhookabove",
+    "ocircumflextilde",
+    "ocyrillic",
+    "odblacute",
+    "odblgrave",
+    "odeva",
+    "odieresiscyrillic",
+    "odotbelow",
+    "oekorean",
+    "ogonekcmb",
+    "ogujarati",
+    "oharmenian",
+    "ohiragana",
+    "ohookabove",
+    "ohorn",
+    "ohornacute",
+    "ohorndotbelow",
+    "ohorngrave",
+    "ohornhookabove",
+    "ohorntilde",
+    "ohungarumlaut",
+    "oi",
+    "oinvertedbreve",
+    "okatakana",
+    "okatakanahalfwidth",
+    "okorean",
+    "olehebrew",
+    "omacron",
+    "omacronacute",
+    "omacrongrave",
+    "omdeva",
+    "omega",
+    "omega1",
+    "omegacyrillic",
+    "omegalatinclosed",
+    "omegaroundcyrillic",
+    "omegatitlocyrillic",
+    "omegatonos",
+    "omgujarati",
+    "omicron",
+    "omicrontonos",
+    "omonospace",
+    "onearabic",
+    "onebengali",
+    "onecircle",
+    "onecircleinversesansserif",
+    "onedeva",
+    "onegujarati",
+    "onegurmukhi",
+    "onehackarabic",
+    "onehangzhou",
+    "oneideographicparen",
+    "onemonospace",
+    "onenumeratorbengali",
+    "oneparen",
+    "oneperiod",
+    "onepersian",
+    "oneroman",
+    "onethai",
+    "oogonek",
+    "oogonekmacron",
+    "oogurmukhi",
+    "oomatragurmukhi",
+    "oopen",
+    "oparen",
+    "openbullet",
+    "option",
+    "orthogonal",
+    "oshortdeva",
+    "oshortvowelsigndeva",
+    "oslashacute",
+    "osmallhiragana",
+    "osmallkatakana",
+    "osmallkatakanahalfwidth",
+    "ostrokeacute",
+    "otcyrillic",
+    "otildeacute",
+    "otildedieresis",
+    "oubopomofo",
+    "overline",
+    "overlinecenterline",
+    "overlinecmb",
+    "overlinedashed",
+    "overlinedblwavy",
+    "overlinewavy",
+    "overscore",
+    "ovowelsignbengali",
+    "ovowelsigndeva",
+    "ovowelsigngujarati",
+    "paampssquare",
+    "paasentosquare",
+    "pabengali",
+    "pacute",
+    "padeva",
+    "pagedown",
+    "pageup",
+    "pagujarati",
+    "pagurmukhi",
+    "pahiragana",
+    "paiyannoithai",
+    "pakatakana",
+    "palatalizationcyrilliccmb",
+    "palochkacyrillic",
+    "pansioskorean",
+    "parallel",
+    "parenleftaltonearabic",
+    "parenleftbt",
+    "parenleftex",
+    "parenleftmonospace",
+    "parenleftsmall",
+    "parenlefttp",
+    "parenleftvertical",
+    "parenrightaltonearabic",
+    "parenrightbt",
+    "parenrightex",
+    "parenrightmonospace",
+    "parenrightsmall",
+    "parenrighttp",
+    "parenrightvertical",
+    "partialdiff",
+    "paseqhebrew",
+    "pashtahebrew",
+    "pasquare",
+    "patah",
+    "patah11",
+    "patah1d",
+    "patah2a",
+    "patahhebrew",
+    "patahnarrowhebrew",
+    "patahquarterhebrew",
+    "patahwidehebrew",
+    "pazerhebrew",
+    "pbopomofo",
+    "pcircle",
+    "pdotaccent",
+    "pe",
+    "pecyrillic",
+    "pedagesh",
+    "pedageshhebrew",
+    "peezisquare",
+    "pefinaldageshhebrew",
+    "peharabic",
+    "peharmenian",
+    "pehebrew",
+    "pehfinalarabic",
+    "pehinitialarabic",
+    "pehiragana",
+    "pehmedialarabic",
+    "pekatakana",
+    "pemiddlehookcyrillic",
+    "perafehebrew",
+    "percentarabic",
+    "percentmonospace",
+    "percentsmall",
+    "periodarmenian",
+    "periodhalfwidth",
+    "periodmonospace",
+    "periodsmall",
+    "perispomenigreekcmb",
+    "perpendicular",
+    "peseta",
+    "pfsquare",
+    "phabengali",
+    "phadeva",
+    "phagujarati",
+    "phagurmukhi",
+    "phi",
+    "phi1",
+    "phieuphacirclekorean",
+    "phieuphaparenkorean",
+    "phieuphcirclekorean",
+    "phieuphkorean",
+    "phieuphparenkorean",
+    "philatin",
+    "phinthuthai",
+    "phisymbolgreek",
+    "phook",
+    "phophanthai",
+    "phophungthai",
+    "phosamphaothai",
+    "pi",
+    "pieupacirclekorean",
+    "pieupaparenkorean",
+    "pieupcieuckorean",
+    "pieupcirclekorean",
+    "pieupkiyeokkorean",
+    "pieupkorean",
+    "pieupparenkorean",
+    "pieupsioskiyeokkorean",
+    "pieupsioskorean",
+    "pieupsiostikeutkorean",
+    "pieupthieuthkorean",
+    "pieuptikeutkorean",
+    "pihiragana",
+    "pikatakana",
+    "pisymbolgreek",
+    "piwrarmenian",
+    "plusbelowcmb",
+    "pluscircle",
+    "plusmod",
+    "plusmonospace",
+    "plussmall",
+    "plussuperior",
+    "pmonospace",
+    "pmsquare",
+    "pohiragana",
+    "pointingindexdownwhite",
+    "pointingindexleftwhite",
+    "pointingindexrightwhite",
+    "pointingindexupwhite",
+    "pokatakana",
+    "poplathai",
+    "postalmark",
+    "postalmarkface",
+    "pparen",
+    "precedes",
+    "prescription",
+    "primemod",
+    "primereversed",
+    "product",
+    "projective",
+    "prolongedkana",
+    "propellor",
+    "propersubset",
+    "propersuperset",
+    "proportion",
+    "proportional",
+    "psi",
+    "psicyrillic",
+    "psilipneumatacyrilliccmb",
+    "pssquare",
+    "puhiragana",
+    "pukatakana",
+    "pvsquare",
+    "pwsquare",
+    "qadeva",
+    "qadmahebrew",
+    "qafarabic",
+    "qaffinalarabic",
+    "qafinitialarabic",
+    "qafmedialarabic",
+    "qamats",
+    "qamats10",
+    "qamats1a",
+    "qamats1c",
+    "qamats27",
+    "qamats29",
+    "qamats33",
+    "qamatsde",
+    "qamatshebrew",
+    "qamatsnarrowhebrew",
+    "qamatsqatanhebrew",
+    "qamatsqatannarrowhebrew",
+    "qamatsqatanquarterhebrew",
+    "qamatsqatanwidehebrew",
+    "qamatsquarterhebrew",
+    "qamatswidehebrew",
+    "qarneyparahebrew",
+    "qbopomofo",
+    "qcircle",
+    "qhook",
+    "qmonospace",
+    "qof",
+    "qofdagesh",
+    "qofdageshhebrew",
+    "qofhatafpatah",
+    "qofhatafpatahhebrew",
+    "qofhatafsegol",
+    "qofhatafsegolhebrew",
+    "qofhebrew",
+    "qofhiriq",
+    "qofhiriqhebrew",
+    "qofholam",
+    "qofholamhebrew",
+    "qofpatah",
+    "qofpatahhebrew",
+    "qofqamats",
+    "qofqamatshebrew",
+    "qofqubuts",
+    "qofqubutshebrew",
+    "qofsegol",
+    "qofsegolhebrew",
+    "qofsheva",
+    "qofshevahebrew",
+    "qoftsere",
+    "qoftserehebrew",
+    "qparen",
+    "quarternote",
+    "qubuts",
+    "qubuts18",
+    "qubuts25",
+    "qubuts31",
+    "qubutshebrew",
+    "qubutsnarrowhebrew",
+    "qubutsquarterhebrew",
+    "qubutswidehebrew",
+    "questionarabic",
+    "questionarmenian",
+    "questiongreek",
+    "questionmonospace",
+    "quotedblmonospace",
+    "quotedblprime",
+    "quotedblprimereversed",
+    "quoteleftreversed",
+    "quotereversed",
+    "quoterightn",
+    "quotesinglemonospace",
+    "raarmenian",
+    "rabengali",
+    "racute",
+    "radeva",
+    "radical",
+    "radicalex",
+    "radoverssquare",
+    "radoverssquaredsquare",
+    "radsquare",
+    "rafe",
+    "rafehebrew",
+    "ragujarati",
+    "ragurmukhi",
+    "rahiragana",
+    "rakatakana",
+    "rakatakanahalfwidth",
+    "ralowerdiagonalbengali",
+    "ramiddlediagonalbengali",
+    "ramshorn",
+    "ratio",
+    "rbopomofo",
+    "rcaron",
+    "rcedilla",
+    "rcircle",
+    "rcommaaccent",
+    "rdblgrave",
+    "rdotaccent",
+    "rdotbelow",
+    "rdotbelowmacron",
+    "referencemark",
+    "reflexsubset",
+    "reflexsuperset",
+    "registersans",
+    "registerserif",
+    "reharabic",
+    "reharmenian",
+    "rehfinalarabic",
+    "rehiragana",
+    "rehyehaleflamarabic",
+    "rekatakana",
+    "rekatakanahalfwidth",
+    "resh",
+    "reshdageshhebrew",
+    "reshhatafpatah",
+    "reshhatafpatahhebrew",
+    "reshhatafsegol",
+    "reshhatafsegolhebrew",
+    "reshhebrew",
+    "reshhiriq",
+    "reshhiriqhebrew",
+    "reshholam",
+    "reshholamhebrew",
+    "reshpatah",
+    "reshpatahhebrew",
+    "reshqamats",
+    "reshqamatshebrew",
+    "reshqubuts",
+    "reshqubutshebrew",
+    "reshsegol",
+    "reshsegolhebrew",
+    "reshsheva",
+    "reshshevahebrew",
+    "reshtsere",
+    "reshtserehebrew",
+    "reversedtilde",
+    "reviahebrew",
+    "reviamugrashhebrew",
+    "revlogicalnot",
+    "rfishhook",
+    "rfishhookreversed",
+    "rhabengali",
+    "rhadeva",
+    "rho",
+    "rhook",
+    "rhookturned",
+    "rhookturnedsuperior",
+    "rhosymbolgreek",
+    "rhotichookmod",
+    "rieulacirclekorean",
+    "rieulaparenkorean",
+    "rieulcirclekorean",
+    "rieulhieuhkorean",
+    "rieulkiyeokkorean",
+    "rieulkiyeoksioskorean",
+    "rieulkorean",
+    "rieulmieumkorean",
+    "rieulpansioskorean",
+    "rieulparenkorean",
+    "rieulphieuphkorean",
+    "rieulpieupkorean",
+    "rieulpieupsioskorean",
+    "rieulsioskorean",
+    "rieulthieuthkorean",
+    "rieultikeutkorean",
+    "rieulyeorinhieuhkorean",
+    "rightangle",
+    "righttackbelowcmb",
+    "righttriangle",
+    "rihiragana",
+    "rikatakana",
+    "rikatakanahalfwidth",
+    "ringbelowcmb",
+    "ringcmb",
+    "ringhalfleft",
+    "ringhalfleftarmenian",
+    "ringhalfleftbelowcmb",
+    "ringhalfleftcentered",
+    "ringhalfright",
+    "ringhalfrightbelowcmb",
+    "ringhalfrightcentered",
+    "rinvertedbreve",
+    "rittorusquare",
+    "rlinebelow",
+    "rlongleg",
+    "rlonglegturned",
+    "rmonospace",
+    "rohiragana",
+    "rokatakana",
+    "rokatakanahalfwidth",
+    "roruathai",
+    "rparen",
+    "rrabengali",
+    "rradeva",
+    "rragurmukhi",
+    "rreharabic",
+    "rrehfinalarabic",
+    "rrvocalicbengali",
+    "rrvocalicdeva",
+    "rrvocalicgujarati",
+    "rrvocalicvowelsignbengali",
+    "rrvocalicvowelsigndeva",
+    "rrvocalicvowelsigngujarati",
+    "rtblock",
+    "rturned",
+    "rturnedsuperior",
+    "ruhiragana",
+    "rukatakana",
+    "rukatakanahalfwidth",
+    "rupeemarkbengali",
+    "rupeesignbengali",
+    "ruthai",
+    "rvocalicbengali",
+    "rvocalicdeva",
+    "rvocalicgujarati",
+    "rvocalicvowelsignbengali",
+    "rvocalicvowelsigndeva",
+    "rvocalicvowelsigngujarati",
+    "sabengali",
+    "sacute",
+    "sacutedotaccent",
+    "sadarabic",
+    "sadeva",
+    "sadfinalarabic",
+    "sadinitialarabic",
+    "sadmedialarabic",
+    "sagujarati",
+    "sagurmukhi",
+    "sahiragana",
+    "sakatakana",
+    "sakatakanahalfwidth",
+    "sallallahoualayhewasallamarabic",
+    "samekh",
+    "samekhdagesh",
+    "samekhdageshhebrew",
+    "samekhhebrew",
+    "saraaathai",
+    "saraaethai",
+    "saraaimaimalaithai",
+    "saraaimaimuanthai",
+    "saraamthai",
+    "saraathai",
+    "saraethai",
+    "saraiileftthai",
+    "saraiithai",
+    "saraileftthai",
+    "saraithai",
+    "saraothai",
+    "saraueeleftthai",
+    "saraueethai",
+    "saraueleftthai",
+    "sarauethai",
+    "sarauthai",
+    "sarauuthai",
+    "sbopomofo",
+    "scarondotaccent",
+    "scedilla",
+    "schwa",
+    "schwacyrillic",
+    "schwadieresiscyrillic",
+    "schwahook",
+    "scircle",
+    "scircumflex",
+    "scommaaccent",
+    "sdotaccent",
+    "sdotbelow",
+    "sdotbelowdotaccent",
+    "seagullbelowcmb",
+    "second",
+    "secondtonechinese",
+    "seenarabic",
+    "seenfinalarabic",
+    "seeninitialarabic",
+    "seenmedialarabic",
+    "segol",
+    "segol13",
+    "segol1f",
+    "segol2c",
+    "segolhebrew",
+    "segolnarrowhebrew",
+    "segolquarterhebrew",
+    "segoltahebrew",
+    "segolwidehebrew",
+    "seharmenian",
+    "sehiragana",
+    "sekatakana",
+    "sekatakanahalfwidth",
+    "semicolonarabic",
+    "semicolonmonospace",
+    "semicolonsmall",
+    "semivoicedmarkkana",
+    "semivoicedmarkkanahalfwidth",
+    "sentisquare",
+    "sentosquare",
+    "sevenarabic",
+    "sevenbengali",
+    "sevencircle",
+    "sevencircleinversesansserif",
+    "sevendeva",
+    "sevengujarati",
+    "sevengurmukhi",
+    "sevenhackarabic",
+    "sevenhangzhou",
+    "sevenideographicparen",
+    "sevenmonospace",
+    "sevenparen",
+    "sevenperiod",
+    "sevenpersian",
+    "sevenroman",
+    "seventeencircle",
+    "seventeenparen",
+    "seventeenperiod",
+    "seventhai",
+    "sfthyphen",
+    "shaarmenian",
+    "shabengali",
+    "shacyrillic",
+    "shaddaarabic",
+    "shaddadammaarabic",
+    "shaddadammatanarabic",
+    "shaddafathaarabic",
+    "shaddafathatanarabic",
+    "shaddakasraarabic",
+    "shaddakasratanarabic",
+    "shade",
+    "shadedark",
+    "shadelight",
+    "shademedium",
+    "shadeva",
+    "shagujarati",
+    "shagurmukhi",
+    "shalshelethebrew",
+    "shbopomofo",
+    "shchacyrillic",
+    "sheenarabic",
+    "sheenfinalarabic",
+    "sheeninitialarabic",
+    "sheenmedialarabic",
+    "sheicoptic",
+    "sheqel",
+    "sheqelhebrew",
+    "sheva",
+    "sheva115",
+    "sheva15",
+    "sheva22",
+    "sheva2e",
+    "shevahebrew",
+    "shevanarrowhebrew",
+    "shevaquarterhebrew",
+    "shevawidehebrew",
+    "shhacyrillic",
+    "shimacoptic",
+    "shin",
+    "shindagesh",
+    "shindageshhebrew",
+    "shindageshshindot",
+    "shindageshshindothebrew",
+    "shindageshsindot",
+    "shindageshsindothebrew",
+    "shindothebrew",
+    "shinhebrew",
+    "shinshindot",
+    "shinshindothebrew",
+    "shinsindot",
+    "shinsindothebrew",
+    "shook",
+    "sigma",
+    "sigma1",
+    "sigmafinal",
+    "sigmalunatesymbolgreek",
+    "sihiragana",
+    "sikatakana",
+    "sikatakanahalfwidth",
+    "siluqhebrew",
+    "siluqlefthebrew",
+    "similar",
+    "sindothebrew",
+    "siosacirclekorean",
+    "siosaparenkorean",
+    "sioscieuckorean",
+    "sioscirclekorean",
+    "sioskiyeokkorean",
+    "sioskorean",
+    "siosnieunkorean",
+    "siosparenkorean",
+    "siospieupkorean",
+    "siostikeutkorean",
+    "sixarabic",
+    "sixbengali",
+    "sixcircle",
+    "sixcircleinversesansserif",
+    "sixdeva",
+    "sixgujarati",
+    "sixgurmukhi",
+    "sixhackarabic",
+    "sixhangzhou",
+    "sixideographicparen",
+    "sixmonospace",
+    "sixparen",
+    "sixperiod",
+    "sixpersian",
+    "sixroman",
+    "sixteencircle",
+    "sixteencurrencydenominatorbengali",
+    "sixteenparen",
+    "sixteenperiod",
+    "sixthai",
+    "slashmonospace",
+    "slong",
+    "slongdotaccent",
+    "smileface",
+    "smonospace",
+    "sofpasuqhebrew",
+    "softhyphen",
+    "softsigncyrillic",
+    "sohiragana",
+    "sokatakana",
+    "sokatakanahalfwidth",
+    "soliduslongoverlaycmb",
+    "solidusshortoverlaycmb",
+    "sorusithai",
+    "sosalathai",
+    "sosothai",
+    "sosuathai",
+    "spacehackarabic",
+    "spade",
+    "spadesuitblack",
+    "spadesuitwhite",
+    "sparen",
+    "squarebelowcmb",
+    "squarecc",
+    "squarecm",
+    "squarediagonalcrosshatchfill",
+    "squarehorizontalfill",
+    "squarekg",
+    "squarekm",
+    "squarekmcapital",
+    "squareln",
+    "squarelog",
+    "squaremg",
+    "squaremil",
+    "squaremm",
+    "squaremsquared",
+    "squareorthogonalcrosshatchfill",
+    "squareupperlefttolowerrightfill",
+    "squareupperrighttolowerleftfill",
+    "squareverticalfill",
+    "squarewhitewithsmallblack",
+    "srsquare",
+    "ssabengali",
+    "ssadeva",
+    "ssagujarati",
+    "ssangcieuckorean",
+    "ssanghieuhkorean",
+    "ssangieungkorean",
+    "ssangkiyeokkorean",
+    "ssangnieunkorean",
+    "ssangpieupkorean",
+    "ssangsioskorean",
+    "ssangtikeutkorean",
+    "sterlingmonospace",
+    "strokelongoverlaycmb",
+    "strokeshortoverlaycmb",
+    "subset",
+    "subsetnotequal",
+    "subsetorequal",
+    "succeeds",
+    "suchthat",
+    "suhiragana",
+    "sukatakana",
+    "sukatakanahalfwidth",
+    "sukunarabic",
+    "summation",
+    "sun",
+    "superset",
+    "supersetnotequal",
+    "supersetorequal",
+    "svsquare",
+    "syouwaerasquare",
+    "tabengali",
+    "tackdown",
+    "tackleft",
+    "tadeva",
+    "tagujarati",
+    "tagurmukhi",
+    "taharabic",
+    "tahfinalarabic",
+    "tahinitialarabic",
+    "tahiragana",
+    "tahmedialarabic",
+    "taisyouerasquare",
+    "takatakana",
+    "takatakanahalfwidth",
+    "tatweelarabic",
+    "tau",
+    "tav",
+    "tavdages",
+    "tavdagesh",
+    "tavdageshhebrew",
+    "tavhebrew",
+    "tbar",
+    "tbopomofo",
+    "tcaron",
+    "tccurl",
+    "tcedilla",
+    "tcheharabic",
+    "tchehfinalarabic",
+    "tchehinitialarabic",
+    "tchehmedialarabic",
+    "tchehmeeminitialarabic",
+    "tcircle",
+    "tcircumflexbelow",
+    "tcommaaccent",
+    "tdieresis",
+    "tdotaccent",
+    "tdotbelow",
+    "tecyrillic",
+    "tedescendercyrillic",
+    "teharabic",
+    "tehfinalarabic",
+    "tehhahinitialarabic",
+    "tehhahisolatedarabic",
+    "tehinitialarabic",
+    "tehiragana",
+    "tehjeeminitialarabic",
+    "tehjeemisolatedarabic",
+    "tehmarbutaarabic",
+    "tehmarbutafinalarabic",
+    "tehmedialarabic",
+    "tehmeeminitialarabic",
+    "tehmeemisolatedarabic",
+    "tehnoonfinalarabic",
+    "tekatakana",
+    "tekatakanahalfwidth",
+    "telephone",
+    "telephoneblack",
+    "telishagedolahebrew",
+    "telishaqetanahebrew",
+    "tencircle",
+    "tenideographicparen",
+    "tenparen",
+    "tenperiod",
+    "tenroman",
+    "tesh",
+    "tet",
+    "tetdagesh",
+    "tetdageshhebrew",
+    "tethebrew",
+    "tetsecyrillic",
+    "tevirhebrew",
+    "tevirlefthebrew",
+    "thabengali",
+    "thadeva",
+    "thagujarati",
+    "thagurmukhi",
+    "thalarabic",
+    "thalfinalarabic",
+    "thanthakhatlowleftthai",
+    "thanthakhatlowrightthai",
+    "thanthakhatthai",
+    "thanthakhatupperleftthai",
+    "theharabic",
+    "thehfinalarabic",
+    "thehinitialarabic",
+    "thehmedialarabic",
+    "thereexists",
+    "therefore",
+    "theta",
+    "theta1",
+    "thetasymbolgreek",
+    "thieuthacirclekorean",
+    "thieuthaparenkorean",
+    "thieuthcirclekorean",
+    "thieuthkorean",
+    "thieuthparenkorean",
+    "thirteencircle",
+    "thirteenparen",
+    "thirteenperiod",
+    "thonangmonthothai",
+    "thook",
+    "thophuthaothai",
+    "thothahanthai",
+    "thothanthai",
+    "thothongthai",
+    "thothungthai",
+    "thousandcyrillic",
+    "thousandsseparatorarabic",
+    "thousandsseparatorpersian",
+    "threearabic",
+    "threebengali",
+    "threecircle",
+    "threecircleinversesansserif",
+    "threedeva",
+    "threegujarati",
+    "threegurmukhi",
+    "threehackarabic",
+    "threehangzhou",
+    "threeideographicparen",
+    "threemonospace",
+    "threenumeratorbengali",
+    "threeparen",
+    "threeperiod",
+    "threepersian",
+    "threeroman",
+    "threethai",
+    "thzsquare",
+    "tihiragana",
+    "tikatakana",
+    "tikatakanahalfwidth",
+    "tikeutacirclekorean",
+    "tikeutaparenkorean",
+    "tikeutcirclekorean",
+    "tikeutkorean",
+    "tikeutparenkorean",
+    "tildebelowcmb",
+    "tildecmb",
+    "tildecomb",
+    "tildedoublecmb",
+    "tildeoperator",
+    "tildeoverlaycmb",
+    "tildeverticalcmb",
+    "timescircle",
+    "tipehahebrew",
+    "tipehalefthebrew",
+    "tippigurmukhi",
+    "titlocyrilliccmb",
+    "tiwnarmenian",
+    "tlinebelow",
+    "tmonospace",
+    "toarmenian",
+    "tohiragana",
+    "tokatakana",
+    "tokatakanahalfwidth",
+    "tonebarextrahighmod",
+    "tonebarextralowmod",
+    "tonebarhighmod",
+    "tonebarlowmod",
+    "tonebarmidmod",
+    "tonefive",
+    "tonesix",
+    "tonetwo",
+    "tonos",
+    "tonsquare",
+    "topatakthai",
+    "tortoiseshellbracketleft",
+    "tortoiseshellbracketleftsmall",
+    "tortoiseshellbracketleftvertical",
+    "tortoiseshellbracketright",
+    "tortoiseshellbracketrightsmall",
+    "tortoiseshellbracketrightvertical",
+    "totaothai",
+    "tpalatalhook",
+    "tparen",
+    "trademarksans",
+    "trademarkserif",
+    "tretroflexhook",
+    "triagdn",
+    "triaglf",
+    "triagrt",
+    "triagup",
+    "ts",
+    "tsadi",
+    "tsadidagesh",
+    "tsadidageshhebrew",
+    "tsadihebrew",
+    "tsecyrillic",
+    "tsere",
+    "tsere12",
+    "tsere1e",
+    "tsere2b",
+    "tserehebrew",
+    "tserenarrowhebrew",
+    "tserequarterhebrew",
+    "tserewidehebrew",
+    "tshecyrillic",
+    "ttabengali",
+    "ttadeva",
+    "ttagujarati",
+    "ttagurmukhi",
+    "tteharabic",
+    "ttehfinalarabic",
+    "ttehinitialarabic",
+    "ttehmedialarabic",
+    "tthabengali",
+    "tthadeva",
+    "tthagujarati",
+    "tthagurmukhi",
+    "tturned",
+    "tuhiragana",
+    "tukatakana",
+    "tukatakanahalfwidth",
+    "tusmallhiragana",
+    "tusmallkatakana",
+    "tusmallkatakanahalfwidth",
+    "twelvecircle",
+    "twelveparen",
+    "twelveperiod",
+    "twelveroman",
+    "twentycircle",
+    "twentyhangzhou",
+    "twentyparen",
+    "twentyperiod",
+    "twoarabic",
+    "twobengali",
+    "twocircle",
+    "twocircleinversesansserif",
+    "twodeva",
+    "twodotleader",
+    "twodotleadervertical",
+    "twogujarati",
+    "twogurmukhi",
+    "twohackarabic",
+    "twohangzhou",
+    "twoideographicparen",
+    "twomonospace",
+    "twonumeratorbengali",
+    "twoparen",
+    "twoperiod",
+    "twopersian",
+    "tworoman",
+    "twostroke",
+    "twothai",
+    "ubar",
+    "ubengali",
+    "ubopomofo",
+    "ubreve",
+    "ucaron",
+    "ucircle",
+    "ucircumflexbelow",
+    "ucyrillic",
+    "udattadeva",
+    "udblacute",
+    "udblgrave",
+    "udeva",
+    "udieresisacute",
+    "udieresisbelow",
+    "udieresiscaron",
+    "udieresiscyrillic",
+    "udieresisgrave",
+    "udieresismacron",
+    "udotbelow",
+    "ugujarati",
+    "ugurmukhi",
+    "uhiragana",
+    "uhookabove",
+    "uhorn",
+    "uhornacute",
+    "uhorndotbelow",
+    "uhorngrave",
+    "uhornhookabove",
+    "uhorntilde",
+    "uhungarumlaut",
+    "uhungarumlautcyrillic",
+    "uinvertedbreve",
+    "ukatakana",
+    "ukatakanahalfwidth",
+    "ukcyrillic",
+    "ukorean",
+    "umacron",
+    "umacroncyrillic",
+    "umacrondieresis",
+    "umatragurmukhi",
+    "umonospace",
+    "underscoredbl",
+    "underscoremonospace",
+    "underscorevertical",
+    "underscorewavy",
+    "union",
+    "universal",
+    "uogonek",
+    "uparen",
+    "upblock",
+    "upperdothebrew",
+    "upsilon",
+    "upsilondieresis",
+    "upsilondieresistonos",
+    "upsilonlatin",
+    "upsilontonos",
+    "uptackbelowcmb",
+    "uptackmod",
+    "uragurmukhi",
+    "uring",
+    "ushortcyrillic",
+    "usmallhiragana",
+    "usmallkatakana",
+    "usmallkatakanahalfwidth",
+    "ustraightcyrillic",
+    "ustraightstrokecyrillic",
+    "utilde",
+    "utildeacute",
+    "utildebelow",
+    "uubengali",
+    "uudeva",
+    "uugujarati",
+    "uugurmukhi",
+    "uumatragurmukhi",
+    "uuvowelsignbengali",
+    "uuvowelsigndeva",
+    "uuvowelsigngujarati",
+    "uvowelsignbengali",
+    "uvowelsigndeva",
+    "uvowelsigngujarati",
+    "vadeva",
+    "vagujarati",
+    "vagurmukhi",
+    "vakatakana",
+    "vav",
+    "vavdagesh",
+    "vavdagesh65",
+    "vavdageshhebrew",
+    "vavhebrew",
+    "vavholam",
+    "vavholamhebrew",
+    "vavvavhebrew",
+    "vavyodhebrew",
+    "vcircle",
+    "vdotbelow",
+    "vecyrillic",
+    "veharabic",
+    "vehfinalarabic",
+    "vehinitialarabic",
+    "vehmedialarabic",
+    "vekatakana",
+    "venus",
+    "verticalbar",
+    "verticallineabovecmb",
+    "verticallinebelowcmb",
+    "verticallinelowmod",
+    "verticallinemod",
+    "vewarmenian",
+    "vhook",
+    "vikatakana",
+    "viramabengali",
+    "viramadeva",
+    "viramagujarati",
+    "visargabengali",
+    "visargadeva",
+    "visargagujarati",
+    "vmonospace",
+    "voarmenian",
+    "voicediterationhiragana",
+    "voicediterationkatakana",
+    "voicedmarkkana",
+    "voicedmarkkanahalfwidth",
+    "vokatakana",
+    "vparen",
+    "vtilde",
+    "vturned",
+    "vuhiragana",
+    "vukatakana",
+    "wacute",
+    "waekorean",
+    "wahiragana",
+    "wakatakana",
+    "wakatakanahalfwidth",
+    "wakorean",
+    "wasmallhiragana",
+    "wasmallkatakana",
+    "wattosquare",
+    "wavedash",
+    "wavyunderscorevertical",
+    "wawarabic",
+    "wawfinalarabic",
+    "wawhamzaabovearabic",
+    "wawhamzaabovefinalarabic",
+    "wbsquare",
+    "wcircle",
+    "wcircumflex",
+    "wdieresis",
+    "wdotaccent",
+    "wdotbelow",
+    "wehiragana",
+    "weierstrass",
+    "wekatakana",
+    "wekorean",
+    "weokorean",
+    "wgrave",
+    "whitebullet",
+    "whitecircle",
+    "whitecircleinverse",
+    "whitecornerbracketleft",
+    "whitecornerbracketleftvertical",
+    "whitecornerbracketright",
+    "whitecornerbracketrightvertical",
+    "whitediamond",
+    "whitediamondcontainingblacksmalldiamond",
+    "whitedownpointingsmalltriangle",
+    "whitedownpointingtriangle",
+    "whiteleftpointingsmalltriangle",
+    "whiteleftpointingtriangle",
+    "whitelenticularbracketleft",
+    "whitelenticularbracketright",
+    "whiterightpointingsmalltriangle",
+    "whiterightpointingtriangle",
+    "whitesmallsquare",
+    "whitesmilingface",
+    "whitesquare",
+    "whitestar",
+    "whitetelephone",
+    "whitetortoiseshellbracketleft",
+    "whitetortoiseshellbracketright",
+    "whiteuppointingsmalltriangle",
+    "whiteuppointingtriangle",
+    "wihiragana",
+    "wikatakana",
+    "wikorean",
+    "wmonospace",
+    "wohiragana",
+    "wokatakana",
+    "wokatakanahalfwidth",
+    "won",
+    "wonmonospace",
+    "wowaenthai",
+    "wparen",
+    "wring",
+    "wsuperior",
+    "wturned",
+    "wynn",
+    "xabovecmb",
+    "xbopomofo",
+    "xcircle",
+    "xdieresis",
+    "xdotaccent",
+    "xeharmenian",
+    "xi",
+    "xmonospace",
+    "xparen",
+    "xsuperior",
+    "yaadosquare",
+    "yabengali",
+    "yadeva",
+    "yaekorean",
+    "yagujarati",
+    "yagurmukhi",
+    "yahiragana",
+    "yakatakana",
+    "yakatakanahalfwidth",
+    "yakorean",
+    "yamakkanthai",
+    "yasmallhiragana",
+    "yasmallkatakana",
+    "yasmallkatakanahalfwidth",
+    "yatcyrillic",
+    "ycircle",
+    "ycircumflex",
+    "ydotaccent",
+    "ydotbelow",
+    "yeharabic",
+    "yehbarreearabic",
+    "yehbarreefinalarabic",
+    "yehfinalarabic",
+    "yehhamzaabovearabic",
+    "yehhamzaabovefinalarabic",
+    "yehhamzaaboveinitialarabic",
+    "yehhamzaabovemedialarabic",
+    "yehinitialarabic",
+    "yehmedialarabic",
+    "yehmeeminitialarabic",
+    "yehmeemisolatedarabic",
+    "yehnoonfinalarabic",
+    "yehthreedotsbelowarabic",
+    "yekorean",
+    "yenmonospace",
+    "yeokorean",
+    "yeorinhieuhkorean",
+    "yerahbenyomohebrew",
+    "yerahbenyomolefthebrew",
+    "yericyrillic",
+    "yerudieresiscyrillic",
+    "yesieungkorean",
+    "yesieungpansioskorean",
+    "yesieungsioskorean",
+    "yetivhebrew",
+    "ygrave",
+    "yhook",
+    "yhookabove",
+    "yiarmenian",
+    "yicyrillic",
+    "yikorean",
+    "yinyang",
+    "yiwnarmenian",
+    "ymonospace",
+    "yod",
+    "yoddagesh",
+    "yoddageshhebrew",
+    "yodhebrew",
+    "yodyodhebrew",
+    "yodyodpatahhebrew",
+    "yohiragana",
+    "yoikorean",
+    "yokatakana",
+    "yokatakanahalfwidth",
+    "yokorean",
+    "yosmallhiragana",
+    "yosmallkatakana",
+    "yosmallkatakanahalfwidth",
+    "yotgreek",
+    "yoyaekorean",
+    "yoyakorean",
+    "yoyakthai",
+    "yoyingthai",
+    "yparen",
+    "ypogegrammeni",
+    "ypogegrammenigreekcmb",
+    "yr",
+    "yring",
+    "ysuperior",
+    "ytilde",
+    "yturned",
+    "yuhiragana",
+    "yuikorean",
+    "yukatakana",
+    "yukatakanahalfwidth",
+    "yukorean",
+    "yusbigcyrillic",
+    "yusbigiotifiedcyrillic",
+    "yuslittlecyrillic",
+    "yuslittleiotifiedcyrillic",
+    "yusmallhiragana",
+    "yusmallkatakana",
+    "yusmallkatakanahalfwidth",
+    "yuyekorean",
+    "yuyeokorean",
+    "yyabengali",
+    "yyadeva",
+    "zaarmenian",
+    "zacute",
+    "zadeva",
+    "zagurmukhi",
+    "zaharabic",
+    "zahfinalarabic",
+    "zahinitialarabic",
+    "zahiragana",
+    "zahmedialarabic",
+    "zainarabic",
+    "zainfinalarabic",
+    "zakatakana",
+    "zaqefgadolhebrew",
+    "zaqefqatanhebrew",
+    "zarqahebrew",
+    "zayin",
+    "zayindagesh",
+    "zayindageshhebrew",
+    "zayinhebrew",
+    "zbopomofo",
+    "zcircle",
+    "zcircumflex",
+    "zcurl",
+    "zdot",
+    "zdotaccent",
+    "zdotbelow",
+    "zecyrillic",
+    "zedescendercyrillic",
+    "zedieresiscyrillic",
+    "zehiragana",
+    "zekatakana",
+    "zeroarabic",
+    "zerobengali",
+    "zerodeva",
+    "zerogujarati",
+    "zerogurmukhi",
+    "zerohackarabic",
+    "zeromonospace",
+    "zeropersian",
+    "zerothai",
+    "zerowidthjoiner",
+    "zerowidthnonjoiner",
+    "zerowidthspace",
+    "zeta",
+    "zhbopomofo",
+    "zhearmenian",
+    "zhebrevecyrillic",
+    "zhecyrillic",
+    "zhedescendercyrillic",
+    "zhedieresiscyrillic",
+    "zihiragana",
+    "zikatakana",
+    "zinorhebrew",
+    "zlinebelow",
+    "zmonospace",
+    "zohiragana",
+    "zokatakana",
+    "zparen",
+    "zretroflexhook",
+    "zstroke",
+    "zuhiragana",
+    "zukatakana",
+
+#endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
+
+    NULL
+  };
+
+
+  static const char* const * const  sid_standard_names = ps_glyph_names + 2;
+
+
+#define NUM_SID_GLYPHS 391
+
+#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
+#define NUM_ADOBE_GLYPHS 4294
+#else
+#define NUM_ADOBE_GLYPHS 391
+#endif
+
+
+  static const unsigned short  mac_standard_names[259] =
+  {
+    2,
+    0,
+    1,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    106,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    126,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    76,
+    77,
+    78,
+    79,
+    80,
+    81,
+    82,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    91,
+    92,
+    93,
+    94,
+    95,
+    96,
+    97,
+    175,
+    177,
+    179,
+    180,
+    188,
+    191,
+    197,
+    202,
+    205,
+    203,
+    204,
+    207,
+    206,
+    208,
+    209,
+    212,
+    210,
+    211,
+    213,
+    216,
+    214,
+    215,
+    217,
+    218,
+    221,
+    219,
+    220,
+    222,
+    224,
+    227,
+    225,
+    226,
+    114,
+    163,
+    99,
+    100,
+    104,
+    118,
+    117,
+    151,
+    167,
+    172,
+    155,
+    127,
+    133,
+    2919,
+    140,
+    143,
+    2413,
+    158,
+    2642,
+    2156,
+    102,
+    154,
+    3092,
+    3681,
+    3192,
+    3153,
+    2415,
+    141,
+    145,
+    741,
+    146,
+    149,
+    125,
+    98,
+    153,
+    3284,
+    103,
+    1353,
+    472,
+    108,
+    122,
+    123,
+    2901,
+    176,
+    178,
+    193,
+    144,
+    150,
+    113,
+    139,
+    107,
+    121,
+    67,
+    10,
+    161,
+    2677,
+    229,
+    200,
+    101,
+    105,
+    109,
+    110,
+    111,
+    112,
+    115,
+    116,
+    119,
+    120,
+    124,
+    174,
+    181,
+    173,
+    182,
+    183,
+    184,
+    185,
+    186,
+    187,
+    189,
+    190,
+    1351,
+    192,
+    195,
+    196,
+    198,
+    147,
+    128,
+    129,
+    130,
+    131,
+    132,
+    134,
+    135,
+    136,
+    137,
+    138,
+    142,
+    148,
+    194,
+    223,
+    201,
+    230,
+    162,
+    156,
+    169,
+    199,
+    228,
+    159,
+    164,
+    168,
+    170,
+    152,
+    166,
+    171,
+    157,
+    160,
+    165,
+    2074,
+    556,
+    2091,
+    609,
+    836,
+    3465,
+    438,
+    1545,
+    440,
+    1560,
+    1767,
+    0
+  };
+
+
+
+  static const unsigned short  ps_names_to_unicode[4295] =
+  {
+    0,
+    0x0020U,
+    0x0021U,
+    0x0022U,
+    0x0023U,
+    0x0024U,
+    0x0025U,
+    0x0026U,
+    0x2019U,
+    0x0028U,
+    0x0029U,
+    0x002AU,
+    0x002BU,
+    0x002CU,
+    0x002DU,
+    0x002EU,
+    0x002FU,
+    0x0030U,
+    0x0031U,
+    0x0032U,
+    0x0033U,
+    0x0034U,
+    0x0035U,
+    0x0036U,
+    0x0037U,
+    0x0038U,
+    0x0039U,
+    0x003AU,
+    0x003BU,
+    0x003CU,
+    0x003DU,
+    0x003EU,
+    0x003FU,
+    0x0040U,
+    0x0041U,
+    0x0042U,
+    0x0043U,
+    0x0044U,
+    0x0045U,
+    0x0046U,
+    0x0047U,
+    0x0048U,
+    0x0049U,
+    0x004AU,
+    0x004BU,
+    0x004CU,
+    0x004DU,
+    0x004EU,
+    0x004FU,
+    0x0050U,
+    0x0051U,
+    0x0052U,
+    0x0053U,
+    0x0054U,
+    0x0055U,
+    0x0056U,
+    0x0057U,
+    0x0058U,
+    0x0059U,
+    0x005AU,
+    0x005BU,
+    0x005CU,
+    0x005DU,
+    0x005EU,
+    0x005FU,
+    0x2018U,
+    0x0061U,
+    0x0062U,
+    0x0063U,
+    0x0064U,
+    0x0065U,
+    0x0066U,
+    0x0067U,
+    0x0068U,
+    0x0069U,
+    0x006AU,
+    0x006BU,
+    0x006CU,
+    0x006DU,
+    0x006EU,
+    0x006FU,
+    0x0070U,
+    0x0071U,
+    0x0072U,
+    0x0073U,
+    0x0074U,
+    0x0075U,
+    0x0076U,
+    0x0077U,
+    0x0078U,
+    0x0079U,
+    0x007AU,
+    0x007BU,
+    0x007CU,
+    0x007DU,
+    0x007EU,
+    0x00A1U,
+    0x00A2U,
+    0x00A3U,
+    0x2044U,
+    0x00A5U,
+    0x0192U,
+    0x00A7U,
+    0x00A4U,
+    0x0027U,
+    0x201CU,
+    0x00ABU,
+    0x2039U,
+    0x203AU,
+    0xFB01U,
+    0xFB02U,
+    0x2013U,
+    0x2020U,
+    0x2021U,
+    0x00B7U,
+    0x00B6U,
+    0x2022U,
+    0x201AU,
+    0x201EU,
+    0x201DU,
+    0x00BBU,
+    0x2026U,
+    0x2030U,
+    0x00BFU,
+    0x0060U,
+    0x00B4U,
+    0x02C6U,
+    0x02DCU,
+    0x00AFU,
+    0x02D8U,
+    0x02D9U,
+    0x00A8U,
+    0x02DAU,
+    0x00B8U,
+    0x02DDU,
+    0x02DBU,
+    0x02C7U,
+    0x2014U,
+    0x00C6U,
+    0x00AAU,
+    0x0141U,
+    0x00D8U,
+    0x0152U,
+    0x00BAU,
+    0x00E6U,
+    0x0131U,
+    0x0142U,
+    0x00F8U,
+    0x0153U,
+    0x00DFU,
+    0x00B9U,
+    0x00ACU,
+    0x00B5U,
+    0x2122U,
+    0x00D0U,
+    0x00BDU,
+    0x00B1U,
+    0x00DEU,
+    0x00BCU,
+    0x00F7U,
+    0x00A6U,
+    0x00B0U,
+    0x00FEU,
+    0x00BEU,
+    0x00B2U,
+    0x00AEU,
+    0x2212U,
+    0x00F0U,
+    0x00D7U,
+    0x00B3U,
+    0x00A9U,
+    0x00C1U,
+    0x00C2U,
+    0x00C4U,
+    0x00C0U,
+    0x00C5U,
+    0x00C3U,
+    0x00C7U,
+    0x00C9U,
+    0x00CAU,
+    0x00CBU,
+    0x00C8U,
+    0x00CDU,
+    0x00CEU,
+    0x00CFU,
+    0x00CCU,
+    0x00D1U,
+    0x00D3U,
+    0x00D4U,
+    0x00D6U,
+    0x00D2U,
+    0x00D5U,
+    0x0160U,
+    0x00DAU,
+    0x00DBU,
+    0x00DCU,
+    0x00D9U,
+    0x00DDU,
+    0x0178U,
+    0x017DU,
+    0x00E1U,
+    0x00E2U,
+    0x00E4U,
+    0x00E0U,
+    0x00E5U,
+    0x00E3U,
+    0x00E7U,
+    0x00E9U,
+    0x00EAU,
+    0x00EBU,
+    0x00E8U,
+    0x00EDU,
+    0x00EEU,
+    0x00EFU,
+    0x00ECU,
+    0x00F1U,
+    0x00F3U,
+    0x00F4U,
+    0x00F6U,
+    0x00F2U,
+    0x00F5U,
+    0x0161U,
+    0x00FAU,
+    0x00FBU,
+    0x00FCU,
+    0x00F9U,
+    0x00FDU,
+    0x00FFU,
+    0x017EU,
+    0xF721U,
+    0xF6F8U,
+    0xF724U,
+    0xF6E4U,
+    0xF726U,
+    0xF7B4U,
+    0x207DU,
+    0x207EU,
+    0x2025U,
+    0x2024U,
+    0xF730U,
+    0xF731U,
+    0xF732U,
+    0xF733U,
+    0xF734U,
+    0xF735U,
+    0xF736U,
+    0xF737U,
+    0xF738U,
+    0xF739U,
+    0xF6E2U,
+    0xF6DEU,
+    0xF6E8U,
+    0xF73FU,
+    0xF6E9U,
+    0xF6EAU,
+    0xF6E0U,
+    0xF6EBU,
+    0xF6ECU,
+    0xF6EDU,
+    0xF6EEU,
+    0xF6EFU,
+    0x207FU,
+    0xF6F0U,
+    0xF6F1U,
+    0xF6F2U,
+    0xF6F3U,
+    0xFB00U,
+    0xFB03U,
+    0xFB04U,
+    0x208DU,
+    0x208EU,
+    0xF6F6U,
+    0xF6E6U,
+    0xF760U,
+    0xF761U,
+    0xF762U,
+    0xF763U,
+    0xF764U,
+    0xF765U,
+    0xF766U,
+    0xF767U,
+    0xF768U,
+    0xF769U,
+    0xF76AU,
+    0xF76BU,
+    0xF76CU,
+    0xF76DU,
+    0xF76EU,
+    0xF76FU,
+    0xF770U,
+    0xF771U,
+    0xF772U,
+    0xF773U,
+    0xF774U,
+    0xF775U,
+    0xF776U,
+    0xF777U,
+    0xF778U,
+    0xF779U,
+    0xF77AU,
+    0x20A1U,
+    0xF6DCU,
+    0xF6DDU,
+    0xF6FEU,
+    0xF7A1U,
+    0xF7A2U,
+    0xF6F9U,
+    0xF6FDU,
+    0xF6FFU,
+    0xF7A8U,
+    0xF6F4U,
+    0xF6F5U,
+    0xF6F7U,
+    0xF7AFU,
+    0x2012U,
+    0xF6E5U,
+    0xF6FBU,
+    0xF6FCU,
+    0xF7B8U,
+    0xF7BFU,
+    0x215BU,
+    0x215CU,
+    0x215DU,
+    0x215EU,
+    0x2153U,
+    0x2154U,
+    0x2070U,
+    0x2074U,
+    0x2075U,
+    0x2076U,
+    0x2077U,
+    0x2078U,
+    0x2079U,
+    0x2080U,
+    0x2081U,
+    0x2082U,
+    0x2083U,
+    0x2084U,
+    0x2085U,
+    0x2086U,
+    0x2087U,
+    0x2088U,
+    0x2089U,
+    0xF6DFU,
+    0xF6E3U,
+    0xF6E7U,
+    0xF6E1U,
+    0xF7E0U,
+    0xF7E1U,
+    0xF7E2U,
+    0xF7E3U,
+    0xF7E4U,
+    0xF7E5U,
+    0xF7E6U,
+    0xF7E7U,
+    0xF7E8U,
+    0xF7E9U,
+    0xF7EAU,
+    0xF7EBU,
+    0xF7ECU,
+    0xF7EDU,
+    0xF7EEU,
+    0xF7EFU,
+    0xF7F0U,
+    0xF7F1U,
+    0xF7F2U,
+    0xF7F3U,
+    0xF7F4U,
+    0xF7F5U,
+    0xF7F6U,
+    0xF6FAU,
+    0xF7F8U,
+    0xF7F9U,
+    0xF7FAU,
+    0xF7FBU,
+    0xF7FCU,
+    0xF7FDU,
+    0xF7FEU,
+    0xF7FFU,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+
+#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
+
+    0x01FCU,
+    0x01E2U,
+    0x0102U,
+    0x1EAEU,
+    0x04D0U,
+    0x1EB6U,
+    0x1EB0U,
+    0x1EB2U,
+    0x1EB4U,
+    0x01CDU,
+    0x24B6U,
+    0x1EA4U,
+    0x1EACU,
+    0x1EA6U,
+    0x1EA8U,
+    0x1EAAU,
+    0xF6C9U,
+    0x0410U,
+    0x0200U,
+    0x04D2U,
+    0x01DEU,
+    0x1EA0U,
+    0x01E0U,
+    0x1EA2U,
+    0x04D4U,
+    0x0202U,
+    0x0391U,
+    0x0386U,
+    0x0100U,
+    0xFF21U,
+    0x0104U,
+    0x01FAU,
+    0x1E00U,
+    0x0531U,
+    0x24B7U,
+    0x1E02U,
+    0x1E04U,
+    0x0411U,
+    0x0532U,
+    0x0392U,
+    0x0181U,
+    0x1E06U,
+    0xFF22U,
+    0x0182U,
+    0x053EU,
+    0x0106U,
+    0xF6CAU,
+    0x010CU,
+    0x1E08U,
+    0x24B8U,
+    0x0108U,
+    0x010AU,
+    0x010AU,
+    0x0549U,
+    0x04BCU,
+    0x0427U,
+    0x04BEU,
+    0x04B6U,
+    0x04F4U,
+    0x0543U,
+    0x04CBU,
+    0x04B8U,
+    0x03A7U,
+    0x0187U,
+    0xFF23U,
+    0x0551U,
+    0x01F1U,
+    0x01C4U,
+    0x0534U,
+    0x0189U,
+    0x010EU,
+    0x1E10U,
+    0x24B9U,
+    0x1E12U,
+    0x0110U,
+    0x1E0AU,
+    0x1E0CU,
+    0x0414U,
+    0x03EEU,
+    0x2206U,
+    0x0394U,
+    0x018AU,
+    0xF6CBU,
+    0xF6CCU,
+    0xF6CDU,
+    0x03DCU,
+    0x0402U,
+    0x1E0EU,
+    0xFF24U,
+    0x0110U,
+    0x018BU,
+    0x01F2U,
+    0x01C5U,
+    0x04E0U,
+    0x0405U,
+    0x040FU,
+    0x0114U,
+    0x011AU,
+    0x1E1CU,
+    0x0535U,
+    0x24BAU,
+    0x1EBEU,
+    0x1E18U,
+    0x1EC6U,
+    0x1EC0U,
+    0x1EC2U,
+    0x1EC4U,
+    0x0404U,
+    0x0204U,
+    0x0116U,
+    0x0116U,
+    0x1EB8U,
+    0x0424U,
+    0x0537U,
+    0x1EBAU,
+    0x2167U,
+    0x0206U,
+    0x0464U,
+    0x041BU,
+    0x216AU,
+    0x0112U,
+    0x1E16U,
+    0x1E14U,
+    0x041CU,
+    0xFF25U,
+    0x041DU,
+    0x04A2U,
+    0x014AU,
+    0x04A4U,
+    0x04C7U,
+    0x0118U,
+    0x0190U,
+    0x0395U,
+    0x0388U,
+    0x0420U,
+    0x018EU,
+    0x042DU,
+    0x0421U,
+    0x04AAU,
+    0x01A9U,
+    0x0397U,
+    0x0538U,
+    0x0389U,
+    0x1EBCU,
+    0x1E1AU,
+    0x20ACU,
+    0x01B7U,
+    0x01EEU,
+    0x01B8U,
+    0x24BBU,
+    0x1E1EU,
+    0x0556U,
+    0x03E4U,
+    0x0191U,
+    0x0472U,
+    0x2164U,
+    0xFF26U,
+    0x2163U,
+    0x3387U,
+    0x01F4U,
+    0x0393U,
+    0x0194U,
+    0x03EAU,
+    0x011EU,
+    0x01E6U,
+    0x0122U,
+    0x24BCU,
+    0x011CU,
+    0x0122U,
+    0x0120U,
+    0x0120U,
+    0x0413U,
+    0x0542U,
+    0x0494U,
+    0x0492U,
+    0x0490U,
+    0x0193U,
+    0x0533U,
+    0x0403U,
+    0x1E20U,
+    0xFF27U,
+    0xF6CEU,
+    0x029BU,
+    0x01E4U,
+    0x25CFU,
+    0x25AAU,
+    0x25ABU,
+    0x25A1U,
+    0x33CBU,
+    0x04A8U,
+    0x04B2U,
+    0x042AU,
+    0x0126U,
+    0x1E2AU,
+    0x1E28U,
+    0x24BDU,
+    0x0124U,
+    0x1E26U,
+    0x1E22U,
+    0x1E24U,
+    0xFF28U,
+    0x0540U,
+    0x03E8U,
+    0xF6CFU,
+    0x3390U,
+    0x042FU,
+    0x0132U,
+    0x042EU,
+    0x012CU,
+    0x01CFU,
+    0x24BEU,
+    0x0406U,
+    0x0208U,
+    0x1E2EU,
+    0x04E4U,
+    0x0130U,
+    0x0130U,
+    0x1ECAU,
+    0x04D6U,
+    0x0415U,
+    0x2111U,
+    0x1EC8U,
+    0x0418U,
+    0x020AU,
+    0x0419U,
+    0x012AU,
+    0x04E2U,
+    0xFF29U,
+    0x053BU,
+    0x0401U,
+    0x012EU,
+    0x0399U,
+    0x0196U,
+    0x03AAU,
+    0x038AU,
+    0x0197U,
+    0x0128U,
+    0x1E2CU,
+    0x0474U,
+    0x0476U,
+    0x0541U,
+    0x24BFU,
+    0x0134U,
+    0x0408U,
+    0x054BU,
+    0xFF2AU,
+    0x3385U,
+    0x33CDU,
+    0x04A0U,
+    0x1E30U,
+    0x041AU,
+    0x049AU,
+    0x04C3U,
+    0x039AU,
+    0x049EU,
+    0x049CU,
+    0x01E8U,
+    0x0136U,
+    0x24C0U,
+    0x0136U,
+    0x1E32U,
+    0x0554U,
+    0x053FU,
+    0x0425U,
+    0x03E6U,
+    0x0198U,
+    0x040CU,
+    0x1E34U,
+    0xFF2BU,
+    0x0480U,
+    0x03DEU,
+    0x046EU,
+    0x01C7U,
+    0xF6BFU,
+    0x0139U,
+    0x039BU,
+    0x013DU,
+    0x013BU,
+    0x24C1U,
+    0x1E3CU,
+    0x013BU,
+    0x013FU,
+    0x013FU,
+    0x1E36U,
+    0x1E38U,
+    0x053CU,
+    0x01C8U,
+    0x0409U,
+    0x1E3AU,
+    0xFF2CU,
+    0x3386U,
+    0xF6D0U,
+    0x1E3EU,
+    0x24C2U,
+    0x1E40U,
+    0x1E42U,
+    0x0544U,
+    0xFF2DU,
+    0x019CU,
+    0x039CU,
+    0x01CAU,
+    0x0143U,
+    0x0147U,
+    0x0145U,
+    0x24C3U,
+    0x1E4AU,
+    0x0145U,
+    0x1E44U,
+    0x1E46U,
+    0x019DU,
+    0x2168U,
+    0x01CBU,
+    0x040AU,
+    0x1E48U,
+    0xFF2EU,
+    0x0546U,
+    0x039DU,
+    0x04E8U,
+    0x04EAU,
+    0x014EU,
+    0x01D1U,
+    0x019FU,
+    0x24C4U,
+    0x1ED0U,
+    0x1ED8U,
+    0x1ED2U,
+    0x1ED4U,
+    0x1ED6U,
+    0x041EU,
+    0x0150U,
+    0x020CU,
+    0x04E6U,
+    0x1ECCU,
+    0x0555U,
+    0x2126U,
+    0x1ECEU,
+    0x01A0U,
+    0x1EDAU,
+    0x1EE2U,
+    0x1EDCU,
+    0x1EDEU,
+    0x1EE0U,
+    0x0150U,
+    0x01A2U,
+    0x020EU,
+    0x014CU,
+    0x1E52U,
+    0x1E50U,
+    0x2126U,
+    0x0460U,
+    0x03A9U,
+    0x047AU,
+    0x047CU,
+    0x038FU,
+    0x039FU,
+    0x038CU,
+    0xFF2FU,
+    0x2160U,
+    0x01EAU,
+    0x01ECU,
+    0x0186U,
+    0x01FEU,
+    0x01FEU,
+    0x047EU,
+    0x1E4CU,
+    0x1E4EU,
+    0x1E54U,
+    0x24C5U,
+    0x1E56U,
+    0x041FU,
+    0x054AU,
+    0x04A6U,
+    0x03A6U,
+    0x01A4U,
+    0x03A0U,
+    0x0553U,
+    0xFF30U,
+    0x03A8U,
+    0x0470U,
+    0x24C6U,
+    0xFF31U,
+    0x054CU,
+    0x0154U,
+    0x0158U,
+    0x0156U,
+    0x24C7U,
+    0x0156U,
+    0x0210U,
+    0x1E58U,
+    0x1E5AU,
+    0x1E5CU,
+    0x0550U,
+    0x211CU,
+    0x03A1U,
+    0x0212U,
+    0x1E5EU,
+    0xFF32U,
+    0x0281U,
+    0x02B6U,
+    0x250CU,
+    0x2514U,
+    0x2510U,
+    0x2518U,
+    0x253CU,
+    0x252CU,
+    0x2534U,
+    0x251CU,
+    0x2524U,
+    0x2500U,
+    0x2502U,
+    0x2561U,
+    0x2562U,
+    0x2556U,
+    0x2555U,
+    0x2563U,
+    0x2551U,
+    0x2557U,
+    0x255DU,
+    0x255CU,
+    0x255BU,
+    0x255EU,
+    0x255FU,
+    0x255AU,
+    0x2554U,
+    0x2569U,
+    0x2566U,
+    0x2560U,
+    0x2550U,
+    0x256CU,
+    0x2567U,
+    0x2568U,
+    0x2564U,
+    0x2565U,
+    0x2559U,
+    0x2558U,
+    0x2552U,
+    0x2553U,
+    0x256BU,
+    0x256AU,
+    0x015AU,
+    0x1E64U,
+    0x03E0U,
+    0x1E66U,
+    0x015EU,
+    0x018FU,
+    0x04D8U,
+    0x04DAU,
+    0x24C8U,
+    0x015CU,
+    0x0218U,
+    0x1E60U,
+    0x1E62U,
+    0x1E68U,
+    0x054DU,
+    0x2166U,
+    0x0547U,
+    0x0428U,
+    0x0429U,
+    0x03E2U,
+    0x04BAU,
+    0x03ECU,
+    0x03A3U,
+    0x2165U,
+    0xFF33U,
+    0x042CU,
+    0x03DAU,
+    0x03A4U,
+    0x0166U,
+    0x0164U,
+    0x0162U,
+    0x24C9U,
+    0x1E70U,
+    0x0162U,
+    0x1E6AU,
+    0x1E6CU,
+    0x0422U,
+    0x04ACU,
+    0x2169U,
+    0x04B4U,
+    0x0398U,
+    0x01ACU,
+    0x2162U,
+    0x054FU,
+    0x1E6EU,
+    0xFF34U,
+    0x0539U,
+    0x01BCU,
+    0x0184U,
+    0x01A7U,
+    0x01AEU,
+    0x0426U,
+    0x040BU,
+    0x216BU,
+    0x2161U,
+    0x016CU,
+    0x01D3U,
+    0x24CAU,
+    0x1E76U,
+    0x0423U,
+    0x0170U,
+    0x0214U,
+    0x01D7U,
+    0x1E72U,
+    0x01D9U,
+    0x04F0U,
+    0x01DBU,
+    0x01D5U,
+    0x1EE4U,
+    0x1EE6U,
+    0x01AFU,
+    0x1EE8U,
+    0x1EF0U,
+    0x1EEAU,
+    0x1EECU,
+    0x1EEEU,
+    0x0170U,
+    0x04F2U,
+    0x0216U,
+    0x0478U,
+    0x016AU,
+    0x04EEU,
+    0x1E7AU,
+    0xFF35U,
+    0x0172U,
+    0x03A5U,
+    0x03D2U,
+    0x03D3U,
+    0x01B1U,
+    0x03ABU,
+    0x03D4U,
+    0x03D2U,
+    0x038EU,
+    0x016EU,
+    0x040EU,
+    0x04AEU,
+    0x04B0U,
+    0x0168U,
+    0x1E78U,
+    0x1E74U,
+    0x24CBU,
+    0x1E7EU,
+    0x0412U,
+    0x054EU,
+    0x01B2U,
+    0xFF36U,
+    0x0548U,
+    0x1E7CU,
+    0x1E82U,
+    0x24CCU,
+    0x0174U,
+    0x1E84U,
+    0x1E86U,
+    0x1E88U,
+    0x1E80U,
+    0xFF37U,
+    0x24CDU,
+    0x1E8CU,
+    0x1E8AU,
+    0x053DU,
+    0x039EU,
+    0xFF38U,
+    0x0462U,
+    0x24CEU,
+    0x0176U,
+    0x1E8EU,
+    0x1EF4U,
+    0x042BU,
+    0x04F8U,
+    0x1EF2U,
+    0x01B3U,
+    0x1EF6U,
+    0x0545U,
+    0x0407U,
+    0x0552U,
+    0xFF39U,
+    0x1EF8U,
+    0x046AU,
+    0x046CU,
+    0x0466U,
+    0x0468U,
+    0x0536U,
+    0x0179U,
+    0x24CFU,
+    0x1E90U,
+    0x017BU,
+    0x017BU,
+    0x1E92U,
+    0x0417U,
+    0x0498U,
+    0x04DEU,
+    0x0396U,
+    0x053AU,
+    0x04C1U,
+    0x0416U,
+    0x0496U,
+    0x04DCU,
+    0x1E94U,
+    0xFF3AU,
+    0x01B5U,
+    0x0986U,
+    0x0906U,
+    0x0A86U,
+    0x0A06U,
+    0x0A3EU,
+    0x3303U,
+    0x09BEU,
+    0x093EU,
+    0x0ABEU,
+    0x055FU,
+    0x0970U,
+    0x0985U,
+    0x311AU,
+    0x0103U,
+    0x1EAFU,
+    0x04D1U,
+    0x1EB7U,
+    0x1EB1U,
+    0x1EB3U,
+    0x1EB5U,
+    0x01CEU,
+    0x24D0U,
+    0x1EA5U,
+    0x1EADU,
+    0x1EA7U,
+    0x1EA9U,
+    0x1EABU,
+    0x0317U,
+    0x0301U,
+    0x0301U,
+    0x0954U,
+    0x02CFU,
+    0x0341U,
+    0x0430U,
+    0x0201U,
+    0x0A71U,
+    0x0905U,
+    0x04D3U,
+    0x01DFU,
+    0x1EA1U,
+    0x01E1U,
+    0x01FDU,
+    0x3150U,
+    0x01E3U,
+    0x2015U,
+    0x20A4U,
+    0x0410U,
+    0x0411U,
+    0x0412U,
+    0x0413U,
+    0x0414U,
+    0x0415U,
+    0x0401U,
+    0x0416U,
+    0x0417U,
+    0x0418U,
+    0x0419U,
+    0x041AU,
+    0x041BU,
+    0x041CU,
+    0x041DU,
+    0x041EU,
+    0x041FU,
+    0x0420U,
+    0x0421U,
+    0x0422U,
+    0x0423U,
+    0x0424U,
+    0x0425U,
+    0x0426U,
+    0x0427U,
+    0x0428U,
+    0x0429U,
+    0x042AU,
+    0x042BU,
+    0x042CU,
+    0x042DU,
+    0x042EU,
+    0x042FU,
+    0x0490U,
+    0x0402U,
+    0x0403U,
+    0x0404U,
+    0x0405U,
+    0x0406U,
+    0x0407U,
+    0x0408U,
+    0x0409U,
+    0x040AU,
+    0x040BU,
+    0x040CU,
+    0x040EU,
+    0xF6C4U,
+    0xF6C5U,
+    0x0430U,
+    0x0431U,
+    0x0432U,
+    0x0433U,
+    0x0434U,
+    0x0435U,
+    0x0451U,
+    0x0436U,
+    0x0437U,
+    0x0438U,
+    0x0439U,
+    0x043AU,
+    0x043BU,
+    0x043CU,
+    0x043DU,
+    0x043EU,
+    0x043FU,
+    0x0440U,
+    0x0441U,
+    0x0442U,
+    0x0443U,
+    0x0444U,
+    0x0445U,
+    0x0446U,
+    0x0447U,
+    0x0448U,
+    0x0449U,
+    0x044AU,
+    0x044BU,
+    0x044CU,
+    0x044DU,
+    0x044EU,
+    0x044FU,
+    0x0491U,
+    0x0452U,
+    0x0453U,
+    0x0454U,
+    0x0455U,
+    0x0456U,
+    0x0457U,
+    0x0458U,
+    0x0459U,
+    0x045AU,
+    0x045BU,
+    0x045CU,
+    0x045EU,
+    0x040FU,
+    0x0462U,
+    0x0472U,
+    0x0474U,
+    0xF6C6U,
+    0x045FU,
+    0x0463U,
+    0x0473U,
+    0x0475U,
+    0xF6C7U,
+    0xF6C8U,
+    0x04D9U,
+    0x200EU,
+    0x200FU,
+    0x200DU,
+    0x066AU,
+    0x060CU,
+    0x0660U,
+    0x0661U,
+    0x0662U,
+    0x0663U,
+    0x0664U,
+    0x0665U,
+    0x0666U,
+    0x0667U,
+    0x0668U,
+    0x0669U,
+    0x061BU,
+    0x061FU,
+    0x0621U,
+    0x0622U,
+    0x0623U,
+    0x0624U,
+    0x0625U,
+    0x0626U,
+    0x0627U,
+    0x0628U,
+    0x0629U,
+    0x062AU,
+    0x062BU,
+    0x062CU,
+    0x062DU,
+    0x062EU,
+    0x062FU,
+    0x0630U,
+    0x0631U,
+    0x0632U,
+    0x0633U,
+    0x0634U,
+    0x0635U,
+    0x0636U,
+    0x0637U,
+    0x0638U,
+    0x0639U,
+    0x063AU,
+    0x0640U,
+    0x0641U,
+    0x0642U,
+    0x0643U,
+    0x0644U,
+    0x0645U,
+    0x0646U,
+    0x0648U,
+    0x0649U,
+    0x064AU,
+    0x064BU,
+    0x064CU,
+    0x064DU,
+    0x064EU,
+    0x064FU,
+    0x0650U,
+    0x0651U,
+    0x0652U,
+    0x0647U,
+    0x06A4U,
+    0x067EU,
+    0x0686U,
+    0x0698U,
+    0x06AFU,
+    0x0679U,
+    0x0688U,
+    0x0691U,
+    0x06BAU,
+    0x06D2U,
+    0x06D5U,
+    0x20AAU,
+    0x05BEU,
+    0x05C3U,
+    0x05D0U,
+    0x05D1U,
+    0x05D2U,
+    0x05D3U,
+    0x05D4U,
+    0x05D5U,
+    0x05D6U,
+    0x05D7U,
+    0x05D8U,
+    0x05D9U,
+    0x05DAU,
+    0x05DBU,
+    0x05DCU,
+    0x05DDU,
+    0x05DEU,
+    0x05DFU,
+    0x05E0U,
+    0x05E1U,
+    0x05E2U,
+    0x05E3U,
+    0x05E4U,
+    0x05E5U,
+    0x05E6U,
+    0x05E7U,
+    0x05E8U,
+    0x05E9U,
+    0x05EAU,
+    0xFB2AU,
+    0xFB2BU,
+    0xFB4BU,
+    0xFB1FU,
+    0x05F0U,
+    0x05F1U,
+    0x05F2U,
+    0xFB35U,
+    0x05B4U,
+    0x05B5U,
+    0x05B6U,
+    0x05BBU,
+    0x05B8U,
+    0x05B7U,
+    0x05B0U,
+    0x05B2U,
+    0x05B1U,
+    0x05B3U,
+    0x05C2U,
+    0x05C1U,
+    0x05B9U,
+    0x05BCU,
+    0x05BDU,
+    0x05BFU,
+    0x05C0U,
+    0x02BCU,
+    0x2105U,
+    0x2113U,
+    0x2116U,
+    0x202CU,
+    0x202DU,
+    0x202EU,
+    0x200CU,
+    0x066DU,
+    0x02BDU,
+    0x0A85U,
+    0x0A05U,
+    0x3042U,
+    0x1EA3U,
+    0x0990U,
+    0x311EU,
+    0x0910U,
+    0x04D5U,
+    0x0A90U,
+    0x0A10U,
+    0x0A48U,
+    0x0639U,
+    0xFECAU,
+    0xFECBU,
+    0xFECCU,
+    0x0203U,
+    0x09C8U,
+    0x0948U,
+    0x0AC8U,
+    0x30A2U,
+    0xFF71U,
+    0x314FU,
+    0x05D0U,
+    0x0627U,
+    0xFB30U,
+    0xFE8EU,
+    0x0623U,
+    0xFE84U,
+    0x0625U,
+    0xFE88U,
+    0x05D0U,
+    0xFB4FU,
+    0x0622U,
+    0xFE82U,
+    0x0649U,
+    0xFEF0U,
+    0xFEF3U,
+    0xFEF4U,
+    0xFB2EU,
+    0xFB2FU,
+    0x2135U,
+    0x224CU,
+    0x03B1U,
+    0x03ACU,
+    0x0101U,
+    0xFF41U,
+    0xFF06U,
+    0x33C2U,
+    0x3122U,
+    0x3124U,
+    0x0E5AU,
+    0x2220U,
+    0x3008U,
+    0xFE3FU,
+    0x3009U,
+    0xFE40U,
+    0x2329U,
+    0x232AU,
+    0x212BU,
+    0x0387U,
+    0x0952U,
+    0x0982U,
+    0x0902U,
+    0x0A82U,
+    0x0105U,
+    0x3300U,
+    0x249CU,
+    0x055AU,
+    0x02BCU,
+    0xF8FFU,
+    0x2250U,
+    0x2248U,
+    0x2252U,
+    0x2245U,
+    0x318EU,
+    0x318DU,
+    0x2312U,
+    0x1E9AU,
+    0x01FBU,
+    0x1E01U,
+    0x2194U,
+    0x21E3U,
+    0x21E0U,
+    0x21E2U,
+    0x21E1U,
+    0x21D4U,
+    0x21D3U,
+    0x21D0U,
+    0x21D2U,
+    0x21D1U,
+    0x2193U,
+    0x2199U,
+    0x2198U,
+    0x21E9U,
+    0x02C5U,
+    0x02C2U,
+    0x02C3U,
+    0x02C4U,
+    0xF8E7U,
+    0x2190U,
+    0x21D0U,
+    0x21CDU,
+    0x21C6U,
+    0x21E6U,
+    0x2192U,
+    0x21CFU,
+    0x279EU,
+    0x21C4U,
+    0x21E8U,
+    0x21E4U,
+    0x21E5U,
+    0x2191U,
+    0x2195U,
+    0x21A8U,
+    0x21A8U,
+    0x2196U,
+    0x21C5U,
+    0x2197U,
+    0x21E7U,
+    0xF8E6U,
+    0xFF3EU,
+    0xFF5EU,
+    0x0251U,
+    0x0252U,
+    0x3041U,
+    0x30A1U,
+    0xFF67U,
+    0x066DU,
+    0x066DU,
+    0x2217U,
+    0xFF0AU,
+    0xFE61U,
+    0x2042U,
+    0x2243U,
+    0xFF20U,
+    0xFE6BU,
+    0x0250U,
+    0x0994U,
+    0x3120U,
+    0x0914U,
+    0x0A94U,
+    0x0A14U,
+    0x09D7U,
+    0x0A4CU,
+    0x09CCU,
+    0x094CU,
+    0x0ACCU,
+    0x093DU,
+    0x0561U,
+    0x05E2U,
+    0xFB20U,
+    0x05E2U,
+    0x09ACU,
+    0xFF3CU,
+    0x092CU,
+    0x0AACU,
+    0x0A2CU,
+    0x3070U,
+    0x0E3FU,
+    0x30D0U,
+    0xFF5CU,
+    0x3105U,
+    0x24D1U,
+    0x1E03U,
+    0x1E05U,
+    0x266CU,
+    0x2235U,
+    0x0431U,
+    0x0628U,
+    0xFE90U,
+    0xFE91U,
+    0x3079U,
+    0xFE92U,
+    0xFC9FU,
+    0xFC08U,
+    0xFC6DU,
+    0x30D9U,
+    0x0562U,
+    0x05D1U,
+    0x03B2U,
+    0x03D0U,
+    0xFB31U,
+    0xFB31U,
+    0x05D1U,
+    0xFB4CU,
+    0x09ADU,
+    0x092DU,
+    0x0AADU,
+    0x0A2DU,
+    0x0253U,
+    0x3073U,
+    0x30D3U,
+    0x0298U,
+    0x0A02U,
+    0x3331U,
+    0x25CFU,
+    0x25C6U,
+    0x25BCU,
+    0x25C4U,
+    0x25C0U,
+    0x3010U,
+    0xFE3BU,
+    0x3011U,
+    0xFE3CU,
+    0x25E3U,
+    0x25E2U,
+    0x25ACU,
+    0x25BAU,
+    0x25B6U,
+    0x25AAU,
+    0x263BU,
+    0x25A0U,
+    0x2605U,
+    0x25E4U,
+    0x25E5U,
+    0x25B4U,
+    0x25B2U,
+    0x2423U,
+    0x1E07U,
+    0x2588U,
+    0xFF42U,
+    0x0E1AU,
+    0x307CU,
+    0x30DCU,
+    0x249DU,
+    0x33C3U,
+    0xF8F4U,
+    0xF8F3U,
+    0xF8F2U,
+    0xFF5BU,
+    0xFE5BU,
+    0xF8F1U,
+    0xFE37U,
+    0xF8FEU,
+    0xF8FDU,
+    0xFF5DU,
+    0xFE5CU,
+    0xF8FCU,
+    0xFE38U,
+    0xF8F0U,
+    0xF8EFU,
+    0xFF3BU,
+    0xF8EEU,
+    0xF8FBU,
+    0xF8FAU,
+    0xFF3DU,
+    0xF8F9U,
+    0x032EU,
+    0x0306U,
+    0x032FU,
+    0x0311U,
+    0x0361U,
+    0x032AU,
+    0x033AU,
+    0x0180U,
+    0x0183U,
+    0x3076U,
+    0x30D6U,
+    0x25D8U,
+    0x2219U,
+    0x25CEU,
+    0x056EU,
+    0x099AU,
+    0x0107U,
+    0x091AU,
+    0x0A9AU,
+    0x0A1AU,
+    0x3388U,
+    0x0981U,
+    0x0310U,
+    0x0901U,
+    0x0A81U,
+    0x21EAU,
+    0x2105U,
+    0x032CU,
+    0x030CU,
+    0x21B5U,
+    0x3118U,
+    0x010DU,
+    0x1E09U,
+    0x24D2U,
+    0x0109U,
+    0x0255U,
+    0x010BU,
+    0x010BU,
+    0x33C5U,
+    0x0327U,
+    0x2103U,
+    0xFFE0U,
+    0x0579U,
+    0x099BU,
+    0x091BU,
+    0x0A9BU,
+    0x0A1BU,
+    0x3114U,
+    0x04BDU,
+    0x2713U,
+    0x0447U,
+    0x04BFU,
+    0x04B7U,
+    0x04F5U,
+    0x0573U,
+    0x04CCU,
+    0x04B9U,
+    0x03C7U,
+    0x3277U,
+    0x3217U,
+    0x3269U,
+    0x314AU,
+    0x3209U,
+    0x0E0AU,
+    0x0E08U,
+    0x0E09U,
+    0x0E0CU,
+    0x0188U,
+    0x3276U,
+    0x3216U,
+    0x3268U,
+    0x3148U,
+    0x3208U,
+    0x321CU,
+    0x25CBU,
+    0x2297U,
+    0x2299U,
+    0x2295U,
+    0x3036U,
+    0x25D0U,
+    0x25D1U,
+    0x032DU,
+    0x0302U,
+    0x2327U,
+    0x01C2U,
+    0x01C0U,
+    0x01C1U,
+    0x01C3U,
+    0x2663U,
+    0x2663U,
+    0x2667U,
+    0x33A4U,
+    0xFF43U,
+    0x33A0U,
+    0x0581U,
+    0xFF1AU,
+    0x20A1U,
+    0xFE55U,
+    0x02D1U,
+    0x02D0U,
+    0x0313U,
+    0x0315U,
+    0xF6C3U,
+    0x060CU,
+    0x055DU,
+    0xFF0CU,
+    0x0314U,
+    0x02BDU,
+    0xFE50U,
+    0x0312U,
+    0x02BBU,
+    0x263CU,
+    0x2245U,
+    0x222EU,
+    0x2303U,
+    0x0006U,
+    0x0007U,
+    0x0008U,
+    0x0018U,
+    0x000DU,
+    0x0011U,
+    0x0012U,
+    0x0013U,
+    0x0014U,
+    0x007FU,
+    0x0010U,
+    0x0019U,
+    0x0005U,
+    0x0004U,
+    0x001BU,
+    0x0017U,
+    0x0003U,
+    0x000CU,
+    0x001CU,
+    0x001DU,
+    0x0009U,
+    0x000AU,
+    0x0015U,
+    0x001EU,
+    0x000FU,
+    0x000EU,
+    0x0002U,
+    0x0001U,
+    0x001AU,
+    0x0016U,
+    0x001FU,
+    0x000BU,
+    0xF8E9U,
+    0xF6D9U,
+    0x300CU,
+    0xFF62U,
+    0xFE41U,
+    0x300DU,
+    0xFF63U,
+    0xFE42U,
+    0x337FU,
+    0x33C7U,
+    0x33C6U,
+    0x249EU,
+    0x20A2U,
+    0x0297U,
+    0x22CFU,
+    0x22CEU,
+    0xF6D1U,
+    0xF6D2U,
+    0xF6D4U,
+    0xF6D5U,
+    0x0564U,
+    0x09A6U,
+    0x0636U,
+    0x0926U,
+    0xFEBEU,
+    0xFEBFU,
+    0xFEC0U,
+    0x05BCU,
+    0x05BCU,
+    0x0AA6U,
+    0x0A26U,
+    0x3060U,
+    0x30C0U,
+    0x062FU,
+    0x05D3U,
+    0xFB33U,
+    0xFB33U,
+    0,
+    0,
+    0,
+    0,
+    0x05D3U,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0xFEAAU,
+    0x064FU,
+    0x064FU,
+    0x064CU,
+    0x064CU,
+    0x0964U,
+    0x05A7U,
+    0x05A7U,
+    0x0485U,
+    0xF6D3U,
+    0x300AU,
+    0xFE3DU,
+    0x300BU,
+    0xFE3EU,
+    0x032BU,
+    0x21D4U,
+    0x21D2U,
+    0x0965U,
+    0xF6D6U,
+    0x030FU,
+    0x222CU,
+    0x2017U,
+    0x0333U,
+    0x033FU,
+    0x02BAU,
+    0x2016U,
+    0x030EU,
+    0x3109U,
+    0x33C8U,
+    0x010FU,
+    0x1E11U,
+    0x24D3U,
+    0x1E13U,
+    0x0111U,
+    0x09A1U,
+    0x0921U,
+    0x0AA1U,
+    0x0A21U,
+    0x0688U,
+    0xFB89U,
+    0x095CU,
+    0x09A2U,
+    0x0922U,
+    0x0AA2U,
+    0x0A22U,
+    0x1E0BU,
+    0x1E0DU,
+    0x066BU,
+    0x066BU,
+    0x0434U,
+    0x05ADU,
+    0x3067U,
+    0x03EFU,
+    0x30C7U,
+    0x232BU,
+    0x2326U,
+    0x03B4U,
+    0x018DU,
+    0x09F8U,
+    0x02A4U,
+    0x09A7U,
+    0x0927U,
+    0x0AA7U,
+    0x0A27U,
+    0x0257U,
+    0x0385U,
+    0x0344U,
+    0x2666U,
+    0x2662U,
+    0xF6D7U,
+    0x0324U,
+    0x0308U,
+    0xF6D8U,
+    0x0385U,
+    0x3062U,
+    0x30C2U,
+    0x3003U,
+    0x2223U,
+    0x2215U,
+    0x0452U,
+    0x2593U,
+    0x1E0FU,
+    0x3397U,
+    0x0111U,
+    0xFF44U,
+    0x2584U,
+    0x0E0EU,
+    0x0E14U,
+    0x3069U,
+    0x30C9U,
+    0xFF04U,
+    0xFE69U,
+    0x20ABU,
+    0x3326U,
+    0x0307U,
+    0x0323U,
+    0x0323U,
+    0x30FBU,
+    0xF6BEU,
+    0x0284U,
+    0x22C5U,
+    0x25CCU,
+    0xFB1FU,
+    0xFB1FU,
+    0x031EU,
+    0x02D5U,
+    0x249FU,
+    0x0256U,
+    0x018CU,
+    0x3065U,
+    0x30C5U,
+    0x01F3U,
+    0x02A3U,
+    0x01C6U,
+    0x02A5U,
+    0x04E1U,
+    0x0455U,
+    0x045FU,
+    0x2641U,
+    0x098FU,
+    0x311CU,
+    0x0115U,
+    0x090DU,
+    0x0A8DU,
+    0x0945U,
+    0x0AC5U,
+    0x011BU,
+    0x1E1DU,
+    0x0565U,
+    0x0587U,
+    0x24D4U,
+    0x1EBFU,
+    0x1E19U,
+    0x1EC7U,
+    0x1EC1U,
+    0x1EC3U,
+    0x1EC5U,
+    0x0454U,
+    0x0205U,
+    0x090FU,
+    0x0117U,
+    0x0117U,
+    0x1EB9U,
+    0x0A0FU,
+    0x0A47U,
+    0x0444U,
+    0x0A8FU,
+    0x0567U,
+    0x311DU,
+    0x3048U,
+    0x1EBBU,
+    0x311FU,
+    0x0668U,
+    0x09EEU,
+    0x2467U,
+    0x2791U,
+    0x096EU,
+    0x2471U,
+    0x2485U,
+    0x2499U,
+    0x0AEEU,
+    0x0A6EU,
+    0x0668U,
+    0x3028U,
+    0x266BU,
+    0x3227U,
+    0xFF18U,
+    0x247BU,
+    0x248FU,
+    0x06F8U,
+    0x2177U,
+    0x0E58U,
+    0x0207U,
+    0x0465U,
+    0x30A8U,
+    0xFF74U,
+    0x0A74U,
+    0x3154U,
+    0x043BU,
+    0x2208U,
+    0x246AU,
+    0x247EU,
+    0x2492U,
+    0x217AU,
+    0x22EEU,
+    0x0113U,
+    0x1E17U,
+    0x1E15U,
+    0x043CU,
+    0xFE31U,
+    0xFF45U,
+    0x055BU,
+    0x2205U,
+    0x3123U,
+    0x043DU,
+    0xFE32U,
+    0x04A3U,
+    0x014BU,
+    0x3125U,
+    0x04A5U,
+    0x04C8U,
+    0x2002U,
+    0x0119U,
+    0x3153U,
+    0x025BU,
+    0x029AU,
+    0x025CU,
+    0x025EU,
+    0x025DU,
+    0x24A0U,
+    0x03B5U,
+    0x03ADU,
+    0xFF1DU,
+    0xFE66U,
+    0x207CU,
+    0x2261U,
+    0x3126U,
+    0x0440U,
+    0x0258U,
+    0x044DU,
+    0x0441U,
+    0x04ABU,
+    0x0283U,
+    0x0286U,
+    0x090EU,
+    0x0946U,
+    0x01AAU,
+    0x0285U,
+    0x3047U,
+    0x30A7U,
+    0xFF6AU,
+    0x212EU,
+    0x03B7U,
+    0x0568U,
+    0x03AEU,
+    0x1EBDU,
+    0x1E1BU,
+    0x0591U,
+    0x0591U,
+    0x0591U,
+    0x0591U,
+    0x01DDU,
+    0x3161U,
+    0x20ACU,
+    0x09C7U,
+    0x0947U,
+    0x0AC7U,
+    0x055CU,
+    0x203CU,
+    0xFF01U,
+    0x2203U,
+    0x0292U,
+    0x01EFU,
+    0x0293U,
+    0x01B9U,
+    0x01BAU,
+    0x095EU,
+    0x0A5EU,
+    0x2109U,
+    0x064EU,
+    0x064EU,
+    0x064BU,
+    0x3108U,
+    0x24D5U,
+    0x1E1FU,
+    0x0641U,
+    0x0586U,
+    0xFED2U,
+    0xFED3U,
+    0xFED4U,
+    0x03E5U,
+    0x2640U,
+    0x246EU,
+    0x2482U,
+    0x2496U,
+    0x25A0U,
+    0x25ACU,
+    0x05DAU,
+    0xFB3AU,
+    0xFB3AU,
+    0x05DAU,
+    0,
+    0,
+    0,
+    0,
+    0x05DDU,
+    0x05DDU,
+    0x05DFU,
+    0x05DFU,
+    0x05E3U,
+    0x05E3U,
+    0x05E5U,
+    0x05E5U,
+    0x02C9U,
+    0x25C9U,
+    0x0473U,
+    0x0665U,
+    0x09EBU,
+    0x2464U,
+    0x278EU,
+    0x096BU,
+    0x0AEBU,
+    0x0A6BU,
+    0x0665U,
+    0x3025U,
+    0x3224U,
+    0xFF15U,
+    0x2478U,
+    0x248CU,
+    0x06F5U,
+    0x2174U,
+    0x0E55U,
+    0xFF46U,
+    0x3399U,
+    0x0E1FU,
+    0x0E1DU,
+    0x0E4FU,
+    0x2200U,
+    0x0664U,
+    0x09EAU,
+    0x2463U,
+    0x278DU,
+    0x096AU,
+    0x0AEAU,
+    0x0A6AU,
+    0x0664U,
+    0x3024U,
+    0x3223U,
+    0xFF14U,
+    0x09F7U,
+    0x2477U,
+    0x248BU,
+    0x06F4U,
+    0x2173U,
+    0x246DU,
+    0x2481U,
+    0x2495U,
+    0x0E54U,
+    0x02CBU,
+    0x24A1U,
+    0x20A3U,
+    0x0997U,
+    0x01F5U,
+    0x0917U,
+    0x06AFU,
+    0xFB93U,
+    0xFB94U,
+    0xFB95U,
+    0x0A97U,
+    0x0A17U,
+    0x304CU,
+    0x30ACU,
+    0x03B3U,
+    0x0263U,
+    0x02E0U,
+    0x03EBU,
+    0x310DU,
+    0x011FU,
+    0x01E7U,
+    0x0123U,
+    0x24D6U,
+    0x011DU,
+    0x0123U,
+    0x0121U,
+    0x0121U,
+    0x0433U,
+    0x3052U,
+    0x30B2U,
+    0x2251U,
+    0x059CU,
+    0x05F3U,
+    0x059DU,
+    0x059EU,
+    0x05F4U,
+    0x3013U,
+    0x0998U,
+    0x0572U,
+    0x0918U,
+    0x0A98U,
+    0x0A18U,
+    0x063AU,
+    0xFECEU,
+    0xFECFU,
+    0xFED0U,
+    0x0495U,
+    0x0493U,
+    0x0491U,
+    0x095AU,
+    0x0A5AU,
+    0x0260U,
+    0x3393U,
+    0x304EU,
+    0x30AEU,
+    0x0563U,
+    0x05D2U,
+    0xFB32U,
+    0xFB32U,
+    0x05D2U,
+    0x0453U,
+    0x01BEU,
+    0x0294U,
+    0x0296U,
+    0x02C0U,
+    0x0295U,
+    0x02C1U,
+    0x02E4U,
+    0x02A1U,
+    0x02A2U,
+    0x1E21U,
+    0xFF47U,
+    0x3054U,
+    0x30B4U,
+    0x24A2U,
+    0x33ACU,
+    0x2207U,
+    0x0316U,
+    0x0300U,
+    0x0300U,
+    0x0953U,
+    0x02CEU,
+    0xFF40U,
+    0x0340U,
+    0x2265U,
+    0x22DBU,
+    0xFF1EU,
+    0x2273U,
+    0x2277U,
+    0x2267U,
+    0xFE65U,
+    0x0261U,
+    0x01E5U,
+    0x3050U,
+    0x30B0U,
+    0x3318U,
+    0x33C9U,
+    0x04A9U,
+    0x06C1U,
+    0x09B9U,
+    0x04B3U,
+    0x0939U,
+    0x0AB9U,
+    0x0A39U,
+    0x062DU,
+    0xFEA2U,
+    0xFEA3U,
+    0x306FU,
+    0xFEA4U,
+    0x332AU,
+    0x30CFU,
+    0xFF8AU,
+    0x0A4DU,
+    0x0621U,
+    0,
+    0,
+    0,
+    0,
+    0x0621U,
+    0,
+    0,
+    0,
+    0x3164U,
+    0x044AU,
+    0x21BCU,
+    0x21C0U,
+    0x33CAU,
+    0x05B2U,
+    0x05B2U,
+    0x05B2U,
+    0x05B2U,
+    0x05B2U,
+    0x05B2U,
+    0x05B2U,
+    0x05B2U,
+    0x05B3U,
+    0x05B3U,
+    0x05B3U,
+    0x05B3U,
+    0x05B3U,
+    0x05B3U,
+    0x05B3U,
+    0x05B3U,
+    0x05B1U,
+    0x05B1U,
+    0x05B1U,
+    0x05B1U,
+    0x05B1U,
+    0x05B1U,
+    0x05B1U,
+    0x05B1U,
+    0x0127U,
+    0x310FU,
+    0x1E2BU,
+    0x1E29U,
+    0x24D7U,
+    0x0125U,
+    0x1E27U,
+    0x1E23U,
+    0x1E25U,
+    0x05D4U,
+    0x2665U,
+    0x2665U,
+    0x2661U,
+    0xFB34U,
+    0xFB34U,
+    0x06C1U,
+    0x0647U,
+    0x05D4U,
+    0xFBA7U,
+    0xFEEAU,
+    0xFEEAU,
+    0xFBA5U,
+    0xFBA4U,
+    0xFBA8U,
+    0xFEEBU,
+    0x3078U,
+    0xFBA9U,
+    0xFEECU,
+    0x337BU,
+    0x30D8U,
+    0xFF8DU,
+    0x3336U,
+    0x0267U,
+    0x3339U,
+    0x05D7U,
+    0x05D7U,
+    0x0266U,
+    0x02B1U,
+    0x327BU,
+    0x321BU,
+    0x326DU,
+    0x314EU,
+    0x320DU,
+    0x3072U,
+    0x30D2U,
+    0xFF8BU,
+    0x05B4U,
+    0x05B4U,
+    0x05B4U,
+    0x05B4U,
+    0x05B4U,
+    0x05B4U,
+    0x05B4U,
+    0x05B4U,
+    0x1E96U,
+    0xFF48U,
+    0x0570U,
+    0x0E2BU,
+    0x307BU,
+    0x30DBU,
+    0xFF8EU,
+    0x05B9U,
+    0x05B9U,
+    0x05B9U,
+    0x05B9U,
+    0x05B9U,
+    0x05B9U,
+    0x05B9U,
+    0x05B9U,
+    0x0E2EU,
+    0x0309U,
+    0x0309U,
+    0x0321U,
+    0x0322U,
+    0x3342U,
+    0x03E9U,
+    0x2015U,
+    0x031BU,
+    0x2668U,
+    0x2302U,
+    0x24A3U,
+    0x02B0U,
+    0x0265U,
+    0x3075U,
+    0x3333U,
+    0x30D5U,
+    0xFF8CU,
+    0x030BU,
+    0x0195U,
+    0xFF0DU,
+    0xFE63U,
+    0x2010U,
+    0x044FU,
+    0x0987U,
+    0x3127U,
+    0x012DU,
+    0x01D0U,
+    0x24D8U,
+    0x0456U,
+    0x0209U,
+    0x328FU,
+    0x328BU,
+    0x323FU,
+    0x323AU,
+    0x32A5U,
+    0x3006U,
+    0x3001U,
+    0xFF64U,
+    0x3237U,
+    0x32A3U,
+    0x322FU,
+    0x323DU,
+    0x329DU,
+    0x3240U,
+    0x3296U,
+    0x3236U,
+    0x322BU,
+    0x3232U,
+    0x32A4U,
+    0x3005U,
+    0x3298U,
+    0x3238U,
+    0x32A7U,
+    0x32A6U,
+    0x32A9U,
+    0x322EU,
+    0x322AU,
+    0x3234U,
+    0x3002U,
+    0x329EU,
+    0x3243U,
+    0x3239U,
+    0x323EU,
+    0x32A8U,
+    0x3299U,
+    0x3242U,
+    0x3233U,
+    0x3000U,
+    0x3235U,
+    0x3231U,
+    0x323BU,
+    0x3230U,
+    0x323CU,
+    0x322CU,
+    0x322DU,
+    0x3007U,
+    0x328EU,
+    0x328AU,
+    0x3294U,
+    0x3290U,
+    0x328CU,
+    0x328DU,
+    0x0907U,
+    0x1E2FU,
+    0x04E5U,
+    0x1ECBU,
+    0x04D7U,
+    0x0435U,
+    0x3275U,
+    0x3215U,
+    0x3267U,
+    0x3147U,
+    0x3207U,
+    0x0A87U,
+    0x0A07U,
+    0x3044U,
+    0x1EC9U,
+    0x0988U,
+    0x0438U,
+    0x0908U,
+    0x0A88U,
+    0x0A08U,
+    0x0A40U,
+    0x020BU,
+    0x0439U,
+    0x09C0U,
+    0x0940U,
+    0x0AC0U,
+    0x0133U,
+    0x30A4U,
+    0xFF72U,
+    0x3163U,
+    0x02DCU,
+    0x05ACU,
+    0x012BU,
+    0x04E3U,
+    0x2253U,
+    0x0A3FU,
+    0xFF49U,
+    0x2206U,
+    0x221EU,
+    0x056BU,
+    0x222BU,
+    0x2321U,
+    0x2321U,
+    0xF8F5U,
+    0x2320U,
+    0x2320U,
+    0x2229U,
+    0x3305U,
+    0x25D8U,
+    0x25D9U,
+    0x263BU,
+    0x0451U,
+    0x012FU,
+    0x03B9U,
+    0x03CAU,
+    0x0390U,
+    0x0269U,
+    0x03AFU,
+    0x24A4U,
+    0x0A72U,
+    0x3043U,
+    0x30A3U,
+    0xFF68U,
+    0x09FAU,
+    0x0268U,
+    0x309DU,
+    0x30FDU,
+    0x0129U,
+    0x1E2DU,
+    0x3129U,
+    0x044EU,
+    0x09BFU,
+    0x093FU,
+    0x0ABFU,
+    0x0475U,
+    0x0477U,
+    0x0571U,
+    0x099CU,
+    0x091CU,
+    0x0A9CU,
+    0x0A1CU,
+    0x3110U,
+    0x01F0U,
+    0x24D9U,
+    0x0135U,
+    0x029DU,
+    0x025FU,
+    0x0458U,
+    0x062CU,
+    0xFE9EU,
+    0xFE9FU,
+    0xFEA0U,
+    0x0698U,
+    0xFB8BU,
+    0x099DU,
+    0x091DU,
+    0x0A9DU,
+    0x0A1DU,
+    0x057BU,
+    0x3004U,
+    0xFF4AU,
+    0x24A5U,
+    0x02B2U,
+    0x04A1U,
+    0x0995U,
+    0x1E31U,
+    0x043AU,
+    0x049BU,
+    0x0915U,
+    0x05DBU,
+    0x0643U,
+    0xFB3BU,
+    0xFB3BU,
+    0xFEDAU,
+    0x05DBU,
+    0xFEDBU,
+    0xFEDCU,
+    0xFB4DU,
+    0x0A95U,
+    0x0A15U,
+    0x304BU,
+    0x04C4U,
+    0x30ABU,
+    0xFF76U,
+    0x03BAU,
+    0x03F0U,
+    0x3171U,
+    0x3184U,
+    0x3178U,
+    0x3179U,
+    0x330DU,
+    0x0640U,
+    0x0640U,
+    0x30F5U,
+    0x3384U,
+    0x0650U,
+    0x064DU,
+    0x049FU,
+    0xFF70U,
+    0x049DU,
+    0x310EU,
+    0x3389U,
+    0x01E9U,
+    0x0137U,
+    0x24DAU,
+    0x0137U,
+    0x1E33U,
+    0x0584U,
+    0x3051U,
+    0x30B1U,
+    0xFF79U,
+    0x056FU,
+    0x30F6U,
+    0x0138U,
+    0x0996U,
+    0x0445U,
+    0x0916U,
+    0x0A96U,
+    0x0A16U,
+    0x062EU,
+    0xFEA6U,
+    0xFEA7U,
+    0xFEA8U,
+    0x03E7U,
+    0x0959U,
+    0x0A59U,
+    0x3278U,
+    0x3218U,
+    0x326AU,
+    0x314BU,
+    0x320AU,
+    0x0E02U,
+    0x0E05U,
+    0x0E03U,
+    0x0E04U,
+    0x0E5BU,
+    0x0199U,
+    0x0E06U,
+    0x3391U,
+    0x304DU,
+    0x30ADU,
+    0xFF77U,
+    0x3315U,
+    0x3316U,
+    0x3314U,
+    0x326EU,
+    0x320EU,
+    0x3260U,
+    0x3131U,
+    0x3200U,
+    0x3133U,
+    0x045CU,
+    0x1E35U,
+    0x3398U,
+    0x33A6U,
+    0xFF4BU,
+    0x33A2U,
+    0x3053U,
+    0x33C0U,
+    0x0E01U,
+    0x30B3U,
+    0xFF7AU,
+    0x331EU,
+    0x0481U,
+    0x327FU,
+    0x0343U,
+    0x24A6U,
+    0x33AAU,
+    0x046FU,
+    0x33CFU,
+    0x029EU,
+    0x304FU,
+    0x30AFU,
+    0xFF78U,
+    0x33B8U,
+    0x33BEU,
+    0x09B2U,
+    0x013AU,
+    0x0932U,
+    0x0AB2U,
+    0x0A32U,
+    0x0E45U,
+    0xFEFCU,
+    0xFEF8U,
+    0xFEF7U,
+    0xFEFAU,
+    0xFEF9U,
+    0xFEFBU,
+    0xFEF6U,
+    0xFEF5U,
+    0x0644U,
+    0x03BBU,
+    0x019BU,
+    0x05DCU,
+    0xFB3CU,
+    0xFB3CU,
+    0x05DCU,
+    0,
+    0,
+    0,
+    0,
+    0xFEDEU,
+    0xFCCAU,
+    0xFEDFU,
+    0xFCC9U,
+    0xFCCBU,
+    0xFDF2U,
+    0xFEE0U,
+    0xFD88U,
+    0xFCCCU,
+    0,
+    0,
+    0x25EFU,
+    0x019AU,
+    0x026CU,
+    0x310CU,
+    0x013EU,
+    0x013CU,
+    0x24DBU,
+    0x1E3DU,
+    0x013CU,
+    0x0140U,
+    0x0140U,
+    0x1E37U,
+    0x1E39U,
+    0x031AU,
+    0x0318U,
+    0x2264U,
+    0x22DAU,
+    0xFF1CU,
+    0x2272U,
+    0x2276U,
+    0x2266U,
+    0xFE64U,
+    0x026EU,
+    0x258CU,
+    0x026DU,
+    0x20A4U,
+    0x056CU,
+    0x01C9U,
+    0x0459U,
+    0xF6C0U,
+    0x0933U,
+    0x0AB3U,
+    0x1E3BU,
+    0x0934U,
+    0x09E1U,
+    0x0961U,
+    0x09E3U,
+    0x0963U,
+    0x026BU,
+    0xFF4CU,
+    0x33D0U,
+    0x0E2CU,
+    0x2227U,
+    0x2310U,
+    0x2228U,
+    0x0E25U,
+    0x017FU,
+    0xFE4EU,
+    0x0332U,
+    0xFE4DU,
+    0x25CAU,
+    0x24A7U,
+    0x2113U,
+    0x2591U,
+    0x0E26U,
+    0x098CU,
+    0x090CU,
+    0x09E2U,
+    0x0962U,
+    0x33D3U,
+    0x09AEU,
+    0x0331U,
+    0x0304U,
+    0x02CDU,
+    0xFFE3U,
+    0x1E3FU,
+    0x092EU,
+    0x0AAEU,
+    0x0A2EU,
+    0x05A4U,
+    0x05A4U,
+    0x307EU,
+    0xF895U,
+    0xF894U,
+    0x0E4BU,
+    0xF893U,
+    0xF88CU,
+    0xF88BU,
+    0x0E48U,
+    0xF88AU,
+    0xF884U,
+    0x0E31U,
+    0xF889U,
+    0x0E47U,
+    0xF88FU,
+    0xF88EU,
+    0x0E49U,
+    0xF88DU,
+    0xF892U,
+    0xF891U,
+    0x0E4AU,
+    0xF890U,
+    0x0E46U,
+    0x30DEU,
+    0xFF8FU,
+    0x2642U,
+    0x3347U,
+    0x05BEU,
+    0x2642U,
+    0x05AFU,
+    0x3383U,
+    0x3107U,
+    0x33D4U,
+    0x24DCU,
+    0x33A5U,
+    0x1E41U,
+    0x1E43U,
+    0x0645U,
+    0xFEE2U,
+    0xFEE3U,
+    0xFEE4U,
+    0xFCD1U,
+    0xFC48U,
+    0x334DU,
+    0x3081U,
+    0x337EU,
+    0x30E1U,
+    0xFF92U,
+    0x05DEU,
+    0xFB3EU,
+    0xFB3EU,
+    0x05DEU,
+    0x0574U,
+    0x05A5U,
+    0x05A6U,
+    0x05A6U,
+    0x05A5U,
+    0x0271U,
+    0x3392U,
+    0xFF65U,
+    0x00B7U,
+    0x3272U,
+    0x3212U,
+    0x3264U,
+    0x3141U,
+    0x3170U,
+    0x3204U,
+    0x316EU,
+    0x316FU,
+    0x307FU,
+    0x30DFU,
+    0xFF90U,
+    0x0320U,
+    0x2296U,
+    0x02D7U,
+    0x2213U,
+    0x2032U,
+    0x334AU,
+    0x3349U,
+    0x0270U,
+    0x3396U,
+    0x33A3U,
+    0xFF4DU,
+    0x339FU,
+    0x3082U,
+    0x33C1U,
+    0x30E2U,
+    0xFF93U,
+    0x33D6U,
+    0x0E21U,
+    0x33A7U,
+    0x33A8U,
+    0x24A8U,
+    0x33ABU,
+    0x33B3U,
+    0x026FU,
+    0x00B5U,
+    0x3382U,
+    0x226BU,
+    0x226AU,
+    0x338CU,
+    0x03BCU,
+    0x338DU,
+    0x3080U,
+    0x30E0U,
+    0xFF91U,
+    0x3395U,
+    0x339BU,
+    0x05A3U,
+    0x05A3U,
+    0x266AU,
+    0x266BU,
+    0x266DU,
+    0x266FU,
+    0x33B2U,
+    0x33B6U,
+    0x33BCU,
+    0x33B9U,
+    0x33B7U,
+    0x33BFU,
+    0x33BDU,
+    0x09A8U,
+    0x2207U,
+    0x0144U,
+    0x0928U,
+    0x0AA8U,
+    0x0A28U,
+    0x306AU,
+    0x30CAU,
+    0xFF85U,
+    0x0149U,
+    0x3381U,
+    0x310BU,
+    0x00A0U,
+    0x0148U,
+    0x0146U,
+    0x24DDU,
+    0x1E4BU,
+    0x0146U,
+    0x1E45U,
+    0x1E47U,
+    0x306DU,
+    0x30CDU,
+    0xFF88U,
+    0x20AAU,
+    0x338BU,
+    0x0999U,
+    0x0919U,
+    0x0A99U,
+    0x0A19U,
+    0x0E07U,
+    0x3093U,
+    0x0272U,
+    0x0273U,
+    0x326FU,
+    0x320FU,
+    0x3135U,
+    0x3261U,
+    0x3136U,
+    0x3134U,
+    0x3168U,
+    0x3201U,
+    0x3167U,
+    0x3166U,
+    0x306BU,
+    0x30CBU,
+    0xFF86U,
+    0xF899U,
+    0x0E4DU,
+    0x0669U,
+    0x09EFU,
+    0x2468U,
+    0x2792U,
+    0x096FU,
+    0x0AEFU,
+    0x0A6FU,
+    0x0669U,
+    0x3029U,
+    0x3228U,
+    0xFF19U,
+    0x247CU,
+    0x2490U,
+    0x06F9U,
+    0x2178U,
+    0x2472U,
+    0x2486U,
+    0x249AU,
+    0x0E59U,
+    0x01CCU,
+    0x045AU,
+    0x30F3U,
+    0xFF9DU,
+    0x019EU,
+    0x1E49U,
+    0xFF4EU,
+    0x339AU,
+    0x09A3U,
+    0x0923U,
+    0x0AA3U,
+    0x0A23U,
+    0x0929U,
+    0x306EU,
+    0x30CEU,
+    0xFF89U,
+    0x00A0U,
+    0x0E13U,
+    0x0E19U,
+    0x0646U,
+    0xFEE6U,
+    0x06BAU,
+    0xFB9FU,
+    0,
+    0xFEE7U,
+    0xFCD2U,
+    0xFC4BU,
+    0xFEE8U,
+    0xFCD5U,
+    0xFC4EU,
+    0xFC8DU,
+    0x220CU,
+    0x2209U,
+    0x2209U,
+    0x2260U,
+    0x226FU,
+    0x2271U,
+    0x2279U,
+    0x2262U,
+    0x226EU,
+    0x2270U,
+    0x2226U,
+    0x2280U,
+    0x2284U,
+    0x2281U,
+    0x2285U,
+    0x0576U,
+    0x24A9U,
+    0x33B1U,
+    0x03BDU,
+    0x306CU,
+    0x30CCU,
+    0xFF87U,
+    0x09BCU,
+    0x093CU,
+    0x0ABCU,
+    0x0A3CU,
+    0xFF03U,
+    0xFE5FU,
+    0x0374U,
+    0x0375U,
+    0x2116U,
+    0x05E0U,
+    0xFB40U,
+    0xFB40U,
+    0x05E0U,
+    0x33B5U,
+    0x33BBU,
+    0x099EU,
+    0x091EU,
+    0x0A9EU,
+    0x0A1EU,
+    0x0E2DU,
+    0x0275U,
+    0x04E9U,
+    0x04EBU,
+    0x0993U,
+    0x311BU,
+    0x014FU,
+    0x0911U,
+    0x0A91U,
+    0x0949U,
+    0x0AC9U,
+    0x01D2U,
+    0x24DEU,
+    0x1ED1U,
+    0x1ED9U,
+    0x1ED3U,
+    0x1ED5U,
+    0x1ED7U,
+    0x043EU,
+    0x0151U,
+    0x020DU,
+    0x0913U,
+    0x04E7U,
+    0x1ECDU,
+    0x315AU,
+    0x0328U,
+    0x0A93U,
+    0x0585U,
+    0x304AU,
+    0x1ECFU,
+    0x01A1U,
+    0x1EDBU,
+    0x1EE3U,
+    0x1EDDU,
+    0x1EDFU,
+    0x1EE1U,
+    0x0151U,
+    0x01A3U,
+    0x020FU,
+    0x30AAU,
+    0xFF75U,
+    0x3157U,
+    0x05ABU,
+    0x014DU,
+    0x1E53U,
+    0x1E51U,
+    0x0950U,
+    0x03C9U,
+    0x03D6U,
+    0x0461U,
+    0x0277U,
+    0x047BU,
+    0x047DU,
+    0x03CEU,
+    0x0AD0U,
+    0x03BFU,
+    0x03CCU,
+    0xFF4FU,
+    0x0661U,
+    0x09E7U,
+    0x2460U,
+    0x278AU,
+    0x0967U,
+    0x0AE7U,
+    0x0A67U,
+    0x0661U,
+    0x3021U,
+    0x3220U,
+    0xFF11U,
+    0x09F4U,
+    0x2474U,
+    0x2488U,
+    0x06F1U,
+    0x2170U,
+    0x0E51U,
+    0x01EBU,
+    0x01EDU,
+    0x0A13U,
+    0x0A4BU,
+    0x0254U,
+    0x24AAU,
+    0x25E6U,
+    0x2325U,
+    0x221FU,
+    0x0912U,
+    0x094AU,
+    0x01FFU,
+    0x3049U,
+    0x30A9U,
+    0xFF6BU,
+    0x01FFU,
+    0x047FU,
+    0x1E4DU,
+    0x1E4FU,
+    0x3121U,
+    0x203EU,
+    0xFE4AU,
+    0x0305U,
+    0xFE49U,
+    0xFE4CU,
+    0xFE4BU,
+    0x00AFU,
+    0x09CBU,
+    0x094BU,
+    0x0ACBU,
+    0x3380U,
+    0x332BU,
+    0x09AAU,
+    0x1E55U,
+    0x092AU,
+    0x21DFU,
+    0x21DEU,
+    0x0AAAU,
+    0x0A2AU,
+    0x3071U,
+    0x0E2FU,
+    0x30D1U,
+    0x0484U,
+    0x04C0U,
+    0x317FU,
+    0x2225U,
+    0xFD3EU,
+    0xF8EDU,
+    0xF8ECU,
+    0xFF08U,
+    0xFE59U,
+    0xF8EBU,
+    0xFE35U,
+    0xFD3FU,
+    0xF8F8U,
+    0xF8F7U,
+    0xFF09U,
+    0xFE5AU,
+    0xF8F6U,
+    0xFE36U,
+    0x2202U,
+    0x05C0U,
+    0x0599U,
+    0x33A9U,
+    0x05B7U,
+    0x05B7U,
+    0x05B7U,
+    0x05B7U,
+    0x05B7U,
+    0x05B7U,
+    0x05B7U,
+    0x05B7U,
+    0x05A1U,
+    0x3106U,
+    0x24DFU,
+    0x1E57U,
+    0x05E4U,
+    0x043FU,
+    0xFB44U,
+    0xFB44U,
+    0x333BU,
+    0xFB43U,
+    0x067EU,
+    0x057AU,
+    0x05E4U,
+    0xFB57U,
+    0xFB58U,
+    0x307AU,
+    0xFB59U,
+    0x30DAU,
+    0x04A7U,
+    0xFB4EU,
+    0x066AU,
+    0xFF05U,
+    0xFE6AU,
+    0x0589U,
+    0xFF61U,
+    0xFF0EU,
+    0xFE52U,
+    0x0342U,
+    0x22A5U,
+    0x20A7U,
+    0x338AU,
+    0x09ABU,
+    0x092BU,
+    0x0AABU,
+    0x0A2BU,
+    0x03C6U,
+    0x03D5U,
+    0x327AU,
+    0x321AU,
+    0x326CU,
+    0x314DU,
+    0x320CU,
+    0x0278U,
+    0x0E3AU,
+    0x03D5U,
+    0x01A5U,
+    0x0E1EU,
+    0x0E1CU,
+    0x0E20U,
+    0x03C0U,
+    0x3273U,
+    0x3213U,
+    0x3176U,
+    0x3265U,
+    0x3172U,
+    0x3142U,
+    0x3205U,
+    0x3174U,
+    0x3144U,
+    0x3175U,
+    0x3177U,
+    0x3173U,
+    0x3074U,
+    0x30D4U,
+    0x03D6U,
+    0x0583U,
+    0x031FU,
+    0x2295U,
+    0x02D6U,
+    0xFF0BU,
+    0xFE62U,
+    0x207AU,
+    0xFF50U,
+    0x33D8U,
+    0x307DU,
+    0x261FU,
+    0x261CU,
+    0x261EU,
+    0x261DU,
+    0x30DDU,
+    0x0E1BU,
+    0x3012U,
+    0x3020U,
+    0x24ABU,
+    0x227AU,
+    0x211EU,
+    0x02B9U,
+    0x2035U,
+    0x220FU,
+    0x2305U,
+    0x30FCU,
+    0x2318U,
+    0x2282U,
+    0x2283U,
+    0x2237U,
+    0x221DU,
+    0x03C8U,
+    0x0471U,
+    0x0486U,
+    0x33B0U,
+    0x3077U,
+    0x30D7U,
+    0x33B4U,
+    0x33BAU,
+    0x0958U,
+    0x05A8U,
+    0x0642U,
+    0xFED6U,
+    0xFED7U,
+    0xFED8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x05B8U,
+    0x059FU,
+    0x3111U,
+    0x24E0U,
+    0x02A0U,
+    0xFF51U,
+    0x05E7U,
+    0xFB47U,
+    0xFB47U,
+    0,
+    0,
+    0,
+    0,
+    0x05E7U,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0x24ACU,
+    0x2669U,
+    0x05BBU,
+    0x05BBU,
+    0x05BBU,
+    0x05BBU,
+    0x05BBU,
+    0x05BBU,
+    0x05BBU,
+    0x05BBU,
+    0x061FU,
+    0x055EU,
+    0x037EU,
+    0xFF1FU,
+    0xFF02U,
+    0x301EU,
+    0x301DU,
+    0x201BU,
+    0x201BU,
+    0x0149U,
+    0xFF07U,
+    0x057CU,
+    0x09B0U,
+    0x0155U,
+    0x0930U,
+    0x221AU,
+    0xF8E5U,
+    0x33AEU,
+    0x33AFU,
+    0x33ADU,
+    0x05BFU,
+    0x05BFU,
+    0x0AB0U,
+    0x0A30U,
+    0x3089U,
+    0x30E9U,
+    0xFF97U,
+    0x09F1U,
+    0x09F0U,
+    0x0264U,
+    0x2236U,
+    0x3116U,
+    0x0159U,
+    0x0157U,
+    0x24E1U,
+    0x0157U,
+    0x0211U,
+    0x1E59U,
+    0x1E5BU,
+    0x1E5DU,
+    0x203BU,
+    0x2286U,
+    0x2287U,
+    0xF8E8U,
+    0xF6DAU,
+    0x0631U,
+    0x0580U,
+    0xFEAEU,
+    0x308CU,
+    0,
+    0x30ECU,
+    0xFF9AU,
+    0x05E8U,
+    0xFB48U,
+    0,
+    0,
+    0,
+    0,
+    0x05E8U,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0x223DU,
+    0x0597U,
+    0x0597U,
+    0x2310U,
+    0x027EU,
+    0x027FU,
+    0x09DDU,
+    0x095DU,
+    0x03C1U,
+    0x027DU,
+    0x027BU,
+    0x02B5U,
+    0x03F1U,
+    0x02DEU,
+    0x3271U,
+    0x3211U,
+    0x3263U,
+    0x3140U,
+    0x313AU,
+    0x3169U,
+    0x3139U,
+    0x313BU,
+    0x316CU,
+    0x3203U,
+    0x313FU,
+    0x313CU,
+    0x316BU,
+    0x313DU,
+    0x313EU,
+    0x316AU,
+    0x316DU,
+    0x221FU,
+    0x0319U,
+    0x22BFU,
+    0x308AU,
+    0x30EAU,
+    0xFF98U,
+    0x0325U,
+    0x030AU,
+    0x02BFU,
+    0x0559U,
+    0x031CU,
+    0x02D3U,
+    0x02BEU,
+    0x0339U,
+    0x02D2U,
+    0x0213U,
+    0x3351U,
+    0x1E5FU,
+    0x027CU,
+    0x027AU,
+    0xFF52U,
+    0x308DU,
+    0x30EDU,
+    0xFF9BU,
+    0x0E23U,
+    0x24ADU,
+    0x09DCU,
+    0x0931U,
+    0x0A5CU,
+    0x0691U,
+    0xFB8DU,
+    0x09E0U,
+    0x0960U,
+    0x0AE0U,
+    0x09C4U,
+    0x0944U,
+    0x0AC4U,
+    0x2590U,
+    0x0279U,
+    0x02B4U,
+    0x308BU,
+    0x30EBU,
+    0xFF99U,
+    0x09F2U,
+    0x09F3U,
+    0x0E24U,
+    0x098BU,
+    0x090BU,
+    0x0A8BU,
+    0x09C3U,
+    0x0943U,
+    0x0AC3U,
+    0x09B8U,
+    0x015BU,
+    0x1E65U,
+    0x0635U,
+    0x0938U,
+    0xFEBAU,
+    0xFEBBU,
+    0xFEBCU,
+    0x0AB8U,
+    0x0A38U,
+    0x3055U,
+    0x30B5U,
+    0xFF7BU,
+    0xFDFAU,
+    0x05E1U,
+    0xFB41U,
+    0xFB41U,
+    0x05E1U,
+    0x0E32U,
+    0x0E41U,
+    0x0E44U,
+    0x0E43U,
+    0x0E33U,
+    0x0E30U,
+    0x0E40U,
+    0xF886U,
+    0x0E35U,
+    0xF885U,
+    0x0E34U,
+    0x0E42U,
+    0xF888U,
+    0x0E37U,
+    0xF887U,
+    0x0E36U,
+    0x0E38U,
+    0x0E39U,
+    0x3119U,
+    0x1E67U,
+    0x015FU,
+    0x0259U,
+    0x04D9U,
+    0x04DBU,
+    0x025AU,
+    0x24E2U,
+    0x015DU,
+    0x0219U,
+    0x1E61U,
+    0x1E63U,
+    0x1E69U,
+    0x033CU,
+    0x2033U,
+    0x02CAU,
+    0x0633U,
+    0xFEB2U,
+    0xFEB3U,
+    0xFEB4U,
+    0x05B6U,
+    0x05B6U,
+    0x05B6U,
+    0x05B6U,
+    0x05B6U,
+    0x05B6U,
+    0x05B6U,
+    0x0592U,
+    0x05B6U,
+    0x057DU,
+    0x305BU,
+    0x30BBU,
+    0xFF7EU,
+    0x061BU,
+    0xFF1BU,
+    0xFE54U,
+    0x309CU,
+    0xFF9FU,
+    0x3322U,
+    0x3323U,
+    0x0667U,
+    0x09EDU,
+    0x2466U,
+    0x2790U,
+    0x096DU,
+    0x0AEDU,
+    0x0A6DU,
+    0x0667U,
+    0x3027U,
+    0x3226U,
+    0xFF17U,
+    0x247AU,
+    0x248EU,
+    0x06F7U,
+    0x2176U,
+    0x2470U,
+    0x2484U,
+    0x2498U,
+    0x0E57U,
+    0x00ADU,
+    0x0577U,
+    0x09B6U,
+    0x0448U,
+    0x0651U,
+    0xFC61U,
+    0xFC5EU,
+    0xFC60U,
+    0,
+    0xFC62U,
+    0xFC5FU,
+    0x2592U,
+    0x2593U,
+    0x2591U,
+    0x2592U,
+    0x0936U,
+    0x0AB6U,
+    0x0A36U,
+    0x0593U,
+    0x3115U,
+    0x0449U,
+    0x0634U,
+    0xFEB6U,
+    0xFEB7U,
+    0xFEB8U,
+    0x03E3U,
+    0x20AAU,
+    0x20AAU,
+    0x05B0U,
+    0x05B0U,
+    0x05B0U,
+    0x05B0U,
+    0x05B0U,
+    0x05B0U,
+    0x05B0U,
+    0x05B0U,
+    0x05B0U,
+    0x04BBU,
+    0x03EDU,
+    0x05E9U,
+    0xFB49U,
+    0xFB49U,
+    0xFB2CU,
+    0xFB2CU,
+    0xFB2DU,
+    0xFB2DU,
+    0x05C1U,
+    0x05E9U,
+    0xFB2AU,
+    0xFB2AU,
+    0xFB2BU,
+    0xFB2BU,
+    0x0282U,
+    0x03C3U,
+    0x03C2U,
+    0x03C2U,
+    0x03F2U,
+    0x3057U,
+    0x30B7U,
+    0xFF7CU,
+    0x05BDU,
+    0x05BDU,
+    0x223CU,
+    0x05C2U,
+    0x3274U,
+    0x3214U,
+    0x317EU,
+    0x3266U,
+    0x317AU,
+    0x3145U,
+    0x317BU,
+    0x3206U,
+    0x317DU,
+    0x317CU,
+    0x0666U,
+    0x09ECU,
+    0x2465U,
+    0x278FU,
+    0x096CU,
+    0x0AECU,
+    0x0A6CU,
+    0x0666U,
+    0x3026U,
+    0x3225U,
+    0xFF16U,
+    0x2479U,
+    0x248DU,
+    0x06F6U,
+    0x2175U,
+    0x246FU,
+    0x09F9U,
+    0x2483U,
+    0x2497U,
+    0x0E56U,
+    0xFF0FU,
+    0x017FU,
+    0x1E9BU,
+    0x263AU,
+    0xFF53U,
+    0x05C3U,
+    0x00ADU,
+    0x044CU,
+    0x305DU,
+    0x30BDU,
+    0xFF7FU,
+    0x0338U,
+    0x0337U,
+    0x0E29U,
+    0x0E28U,
+    0x0E0BU,
+    0x0E2AU,
+    0x0020U,
+    0x2660U,
+    0x2660U,
+    0x2664U,
+    0x24AEU,
+    0x033BU,
+    0x33C4U,
+    0x339DU,
+    0x25A9U,
+    0x25A4U,
+    0x338FU,
+    0x339EU,
+    0x33CEU,
+    0x33D1U,
+    0x33D2U,
+    0x338EU,
+    0x33D5U,
+    0x339CU,
+    0x33A1U,
+    0x25A6U,
+    0x25A7U,
+    0x25A8U,
+    0x25A5U,
+    0x25A3U,
+    0x33DBU,
+    0x09B7U,
+    0x0937U,
+    0x0AB7U,
+    0x3149U,
+    0x3185U,
+    0x3180U,
+    0x3132U,
+    0x3165U,
+    0x3143U,
+    0x3146U,
+    0x3138U,
+    0xFFE1U,
+    0x0336U,
+    0x0335U,
+    0x2282U,
+    0x228AU,
+    0x2286U,
+    0x227BU,
+    0x220BU,
+    0x3059U,
+    0x30B9U,
+    0xFF7DU,
+    0x0652U,
+    0x2211U,
+    0x263CU,
+    0x2283U,
+    0x228BU,
+    0x2287U,
+    0x33DCU,
+    0x337CU,
+    0x09A4U,
+    0x22A4U,
+    0x22A3U,
+    0x0924U,
+    0x0AA4U,
+    0x0A24U,
+    0x0637U,
+    0xFEC2U,
+    0xFEC3U,
+    0x305FU,
+    0xFEC4U,
+    0x337DU,
+    0x30BFU,
+    0xFF80U,
+    0x0640U,
+    0x03C4U,
+    0x05EAU,
+    0xFB4AU,
+    0xFB4AU,
+    0xFB4AU,
+    0x05EAU,
+    0x0167U,
+    0x310AU,
+    0x0165U,
+    0x02A8U,
+    0x0163U,
+    0x0686U,
+    0xFB7BU,
+    0xFB7CU,
+    0xFB7DU,
+    0,
+    0x24E3U,
+    0x1E71U,
+    0x0163U,
+    0x1E97U,
+    0x1E6BU,
+    0x1E6DU,
+    0x0442U,
+    0x04ADU,
+    0x062AU,
+    0xFE96U,
+    0xFCA2U,
+    0xFC0CU,
+    0xFE97U,
+    0x3066U,
+    0xFCA1U,
+    0xFC0BU,
+    0x0629U,
+    0xFE94U,
+    0xFE98U,
+    0xFCA4U,
+    0xFC0EU,
+    0xFC73U,
+    0x30C6U,
+    0xFF83U,
+    0x2121U,
+    0x260EU,
+    0x05A0U,
+    0x05A9U,
+    0x2469U,
+    0x3229U,
+    0x247DU,
+    0x2491U,
+    0x2179U,
+    0x02A7U,
+    0x05D8U,
+    0xFB38U,
+    0xFB38U,
+    0x05D8U,
+    0x04B5U,
+    0x059BU,
+    0x059BU,
+    0x09A5U,
+    0x0925U,
+    0x0AA5U,
+    0x0A25U,
+    0x0630U,
+    0xFEACU,
+    0xF898U,
+    0xF897U,
+    0x0E4CU,
+    0xF896U,
+    0x062BU,
+    0xFE9AU,
+    0xFE9BU,
+    0xFE9CU,
+    0x2203U,
+    0x2234U,
+    0x03B8U,
+    0x03D1U,
+    0x03D1U,
+    0x3279U,
+    0x3219U,
+    0x326BU,
+    0x314CU,
+    0x320BU,
+    0x246CU,
+    0x2480U,
+    0x2494U,
+    0x0E11U,
+    0x01ADU,
+    0x0E12U,
+    0x0E17U,
+    0x0E10U,
+    0x0E18U,
+    0x0E16U,
+    0x0482U,
+    0x066CU,
+    0x066CU,
+    0x0663U,
+    0x09E9U,
+    0x2462U,
+    0x278CU,
+    0x0969U,
+    0x0AE9U,
+    0x0A69U,
+    0x0663U,
+    0x3023U,
+    0x3222U,
+    0xFF13U,
+    0x09F6U,
+    0x2476U,
+    0x248AU,
+    0x06F3U,
+    0x2172U,
+    0x0E53U,
+    0x3394U,
+    0x3061U,
+    0x30C1U,
+    0xFF81U,
+    0x3270U,
+    0x3210U,
+    0x3262U,
+    0x3137U,
+    0x3202U,
+    0x0330U,
+    0x0303U,
+    0x0303U,
+    0x0360U,
+    0x223CU,
+    0x0334U,
+    0x033EU,
+    0x2297U,
+    0x0596U,
+    0x0596U,
+    0x0A70U,
+    0x0483U,
+    0x057FU,
+    0x1E6FU,
+    0xFF54U,
+    0x0569U,
+    0x3068U,
+    0x30C8U,
+    0xFF84U,
+    0x02E5U,
+    0x02E9U,
+    0x02E6U,
+    0x02E8U,
+    0x02E7U,
+    0x01BDU,
+    0x0185U,
+    0x01A8U,
+    0x0384U,
+    0x3327U,
+    0x0E0FU,
+    0x3014U,
+    0xFE5DU,
+    0xFE39U,
+    0x3015U,
+    0xFE5EU,
+    0xFE3AU,
+    0x0E15U,
+    0x01ABU,
+    0x24AFU,
+    0xF8EAU,
+    0xF6DBU,
+    0x0288U,
+    0x25BCU,
+    0x25C4U,
+    0x25BAU,
+    0x25B2U,
+    0x02A6U,
+    0x05E6U,
+    0xFB46U,
+    0xFB46U,
+    0x05E6U,
+    0x0446U,
+    0x05B5U,
+    0x05B5U,
+    0x05B5U,
+    0x05B5U,
+    0x05B5U,
+    0x05B5U,
+    0x05B5U,
+    0x05B5U,
+    0x045BU,
+    0x099FU,
+    0x091FU,
+    0x0A9FU,
+    0x0A1FU,
+    0x0679U,
+    0xFB67U,
+    0xFB68U,
+    0xFB69U,
+    0x09A0U,
+    0x0920U,
+    0x0AA0U,
+    0x0A20U,
+    0x0287U,
+    0x3064U,
+    0x30C4U,
+    0xFF82U,
+    0x3063U,
+    0x30C3U,
+    0xFF6FU,
+    0x246BU,
+    0x247FU,
+    0x2493U,
+    0x217BU,
+    0x2473U,
+    0x5344U,
+    0x2487U,
+    0x249BU,
+    0x0662U,
+    0x09E8U,
+    0x2461U,
+    0x278BU,
+    0x0968U,
+    0x2025U,
+    0xFE30U,
+    0x0AE8U,
+    0x0A68U,
+    0x0662U,
+    0x3022U,
+    0x3221U,
+    0xFF12U,
+    0x09F5U,
+    0x2475U,
+    0x2489U,
+    0x06F2U,
+    0x2171U,
+    0x01BBU,
+    0x0E52U,
+    0x0289U,
+    0x0989U,
+    0x3128U,
+    0x016DU,
+    0x01D4U,
+    0x24E4U,
+    0x1E77U,
+    0x0443U,
+    0x0951U,
+    0x0171U,
+    0x0215U,
+    0x0909U,
+    0x01D8U,
+    0x1E73U,
+    0x01DAU,
+    0x04F1U,
+    0x01DCU,
+    0x01D6U,
+    0x1EE5U,
+    0x0A89U,
+    0x0A09U,
+    0x3046U,
+    0x1EE7U,
+    0x01B0U,
+    0x1EE9U,
+    0x1EF1U,
+    0x1EEBU,
+    0x1EEDU,
+    0x1EEFU,
+    0x0171U,
+    0x04F3U,
+    0x0217U,
+    0x30A6U,
+    0xFF73U,
+    0x0479U,
+    0x315CU,
+    0x016BU,
+    0x04EFU,
+    0x1E7BU,
+    0x0A41U,
+    0xFF55U,
+    0x2017U,
+    0xFF3FU,
+    0xFE33U,
+    0xFE4FU,
+    0x222AU,
+    0x2200U,
+    0x0173U,
+    0x24B0U,
+    0x2580U,
+    0x05C4U,
+    0x03C5U,
+    0x03CBU,
+    0x03B0U,
+    0x028AU,
+    0x03CDU,
+    0x031DU,
+    0x02D4U,
+    0x0A73U,
+    0x016FU,
+    0x045EU,
+    0x3045U,
+    0x30A5U,
+    0xFF69U,
+    0x04AFU,
+    0x04B1U,
+    0x0169U,
+    0x1E79U,
+    0x1E75U,
+    0x098AU,
+    0x090AU,
+    0x0A8AU,
+    0x0A0AU,
+    0x0A42U,
+    0x09C2U,
+    0x0942U,
+    0x0AC2U,
+    0x09C1U,
+    0x0941U,
+    0x0AC1U,
+    0x0935U,
+    0x0AB5U,
+    0x0A35U,
+    0x30F7U,
+    0x05D5U,
+    0xFB35U,
+    0xFB35U,
+    0xFB35U,
+    0x05D5U,
+    0xFB4BU,
+    0xFB4BU,
+    0x05F0U,
+    0x05F1U,
+    0x24E5U,
+    0x1E7FU,
+    0x0432U,
+    0x06A4U,
+    0xFB6BU,
+    0xFB6CU,
+    0xFB6DU,
+    0x30F9U,
+    0x2640U,
+    0x007CU,
+    0x030DU,
+    0x0329U,
+    0x02CCU,
+    0x02C8U,
+    0x057EU,
+    0x028BU,
+    0x30F8U,
+    0x09CDU,
+    0x094DU,
+    0x0ACDU,
+    0x0983U,
+    0x0903U,
+    0x0A83U,
+    0xFF56U,
+    0x0578U,
+    0x309EU,
+    0x30FEU,
+    0x309BU,
+    0xFF9EU,
+    0x30FAU,
+    0x24B1U,
+    0x1E7DU,
+    0x028CU,
+    0x3094U,
+    0x30F4U,
+    0x1E83U,
+    0x3159U,
+    0x308FU,
+    0x30EFU,
+    0xFF9CU,
+    0x3158U,
+    0x308EU,
+    0x30EEU,
+    0x3357U,
+    0x301CU,
+    0xFE34U,
+    0x0648U,
+    0xFEEEU,
+    0x0624U,
+    0xFE86U,
+    0x33DDU,
+    0x24E6U,
+    0x0175U,
+    0x1E85U,
+    0x1E87U,
+    0x1E89U,
+    0x3091U,
+    0x2118U,
+    0x30F1U,
+    0x315EU,
+    0x315DU,
+    0x1E81U,
+    0x25E6U,
+    0x25CBU,
+    0x25D9U,
+    0x300EU,
+    0xFE43U,
+    0x300FU,
+    0xFE44U,
+    0x25C7U,
+    0x25C8U,
+    0x25BFU,
+    0x25BDU,
+    0x25C3U,
+    0x25C1U,
+    0x3016U,
+    0x3017U,
+    0x25B9U,
+    0x25B7U,
+    0x25ABU,
+    0x263AU,
+    0x25A1U,
+    0x2606U,
+    0x260FU,
+    0x3018U,
+    0x3019U,
+    0x25B5U,
+    0x25B3U,
+    0x3090U,
+    0x30F0U,
+    0x315FU,
+    0xFF57U,
+    0x3092U,
+    0x30F2U,
+    0xFF66U,
+    0x20A9U,
+    0xFFE6U,
+    0x0E27U,
+    0x24B2U,
+    0x1E98U,
+    0x02B7U,
+    0x028DU,
+    0x01BFU,
+    0x033DU,
+    0x3112U,
+    0x24E7U,
+    0x1E8DU,
+    0x1E8BU,
+    0x056DU,
+    0x03BEU,
+    0xFF58U,
+    0x24B3U,
+    0x02E3U,
+    0x334EU,
+    0x09AFU,
+    0x092FU,
+    0x3152U,
+    0x0AAFU,
+    0x0A2FU,
+    0x3084U,
+    0x30E4U,
+    0xFF94U,
+    0x3151U,
+    0x0E4EU,
+    0x3083U,
+    0x30E3U,
+    0xFF6CU,
+    0x0463U,
+    0x24E8U,
+    0x0177U,
+    0x1E8FU,
+    0x1EF5U,
+    0x064AU,
+    0x06D2U,
+    0xFBAFU,
+    0xFEF2U,
+    0x0626U,
+    0xFE8AU,
+    0xFE8BU,
+    0xFE8CU,
+    0xFEF3U,
+    0xFEF4U,
+    0xFCDDU,
+    0xFC58U,
+    0xFC94U,
+    0x06D1U,
+    0x3156U,
+    0xFFE5U,
+    0x3155U,
+    0x3186U,
+    0x05AAU,
+    0x05AAU,
+    0x044BU,
+    0x04F9U,
+    0x3181U,
+    0x3183U,
+    0x3182U,
+    0x059AU,
+    0x1EF3U,
+    0x01B4U,
+    0x1EF7U,
+    0x0575U,
+    0x0457U,
+    0x3162U,
+    0x262FU,
+    0x0582U,
+    0xFF59U,
+    0x05D9U,
+    0xFB39U,
+    0xFB39U,
+    0x05D9U,
+    0x05F2U,
+    0xFB1FU,
+    0x3088U,
+    0x3189U,
+    0x30E8U,
+    0xFF96U,
+    0x315BU,
+    0x3087U,
+    0x30E7U,
+    0xFF6EU,
+    0x03F3U,
+    0x3188U,
+    0x3187U,
+    0x0E22U,
+    0x0E0DU,
+    0x24B4U,
+    0x037AU,
+    0x0345U,
+    0x01A6U,
+    0x1E99U,
+    0x02B8U,
+    0x1EF9U,
+    0x028EU,
+    0x3086U,
+    0x318CU,
+    0x30E6U,
+    0xFF95U,
+    0x3160U,
+    0x046BU,
+    0x046DU,
+    0x0467U,
+    0x0469U,
+    0x3085U,
+    0x30E5U,
+    0xFF6DU,
+    0x318BU,
+    0x318AU,
+    0x09DFU,
+    0x095FU,
+    0x0566U,
+    0x017AU,
+    0x095BU,
+    0x0A5BU,
+    0x0638U,
+    0xFEC6U,
+    0xFEC7U,
+    0x3056U,
+    0xFEC8U,
+    0x0632U,
+    0xFEB0U,
+    0x30B6U,
+    0x0595U,
+    0x0594U,
+    0x0598U,
+    0x05D6U,
+    0xFB36U,
+    0xFB36U,
+    0x05D6U,
+    0x3117U,
+    0x24E9U,
+    0x1E91U,
+    0x0291U,
+    0x017CU,
+    0x017CU,
+    0x1E93U,
+    0x0437U,
+    0x0499U,
+    0x04DFU,
+    0x305CU,
+    0x30BCU,
+    0x0660U,
+    0x09E6U,
+    0x0966U,
+    0x0AE6U,
+    0x0A66U,
+    0x0660U,
+    0xFF10U,
+    0x06F0U,
+    0x0E50U,
+    0xFEFFU,
+    0x200CU,
+    0x200BU,
+    0x03B6U,
+    0x3113U,
+    0x056AU,
+    0x04C2U,
+    0x0436U,
+    0x0497U,
+    0x04DDU,
+    0x3058U,
+    0x30B8U,
+    0x05AEU,
+    0x1E95U,
+    0xFF5AU,
+    0x305EU,
+    0x30BEU,
+    0x24B5U,
+    0x0290U,
+    0x01B6U,
+    0x305AU,
+    0x30BAU,
+
+#endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
+    0
+  };
+
+
+
+  static const unsigned short  t1_standard_encoding[257] =
+  {
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    76,
+    77,
+    78,
+    79,
+    80,
+    81,
+    82,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    91,
+    92,
+    93,
+    94,
+    95,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    96,
+    97,
+    98,
+    99,
+    100,
+    101,
+    102,
+    103,
+    104,
+    105,
+    106,
+    107,
+    108,
+    109,
+    110,
+    0,
+    111,
+    112,
+    113,
+    114,
+    0,
+    115,
+    116,
+    117,
+    118,
+    119,
+    120,
+    121,
+    122,
+    0,
+    123,
+    0,
+    124,
+    125,
+    126,
+    127,
+    128,
+    129,
+    130,
+    131,
+    0,
+    132,
+    133,
+    0,
+    134,
+    135,
+    136,
+    137,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    138,
+    0,
+    139,
+    0,
+    0,
+    0,
+    0,
+    140,
+    141,
+    142,
+    143,
+    0,
+    0,
+    0,
+    0,
+    0,
+    144,
+    0,
+    0,
+    0,
+    145,
+    0,
+    0,
+    146,
+    147,
+    148,
+    149,
+    0,
+    0,
+    0,
+    0,
+    0
+  };
+
+
+  static const unsigned short  t1_expert_encoding[257] =
+  {
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    229,
+    230,
+    0,
+    231,
+    232,
+    233,
+    234,
+    235,
+    236,
+    237,
+    238,
+    13,
+    14,
+    15,
+    99,
+    239,
+    240,
+    241,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    27,
+    28,
+    249,
+    250,
+    251,
+    252,
+    0,
+    253,
+    254,
+    255,
+    256,
+    257,
+    0,
+    0,
+    0,
+    258,
+    0,
+    0,
+    259,
+    260,
+    261,
+    262,
+    0,
+    0,
+    263,
+    264,
+    265,
+    0,
+    266,
+    109,
+    110,
+    267,
+    268,
+    269,
+    0,
+    270,
+    271,
+    272,
+    273,
+    274,
+    275,
+    276,
+    277,
+    278,
+    279,
+    280,
+    281,
+    282,
+    283,
+    284,
+    285,
+    286,
+    287,
+    288,
+    289,
+    290,
+    291,
+    292,
+    293,
+    294,
+    295,
+    296,
+    297,
+    298,
+    299,
+    300,
+    301,
+    302,
+    303,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    304,
+    305,
+    306,
+    0,
+    0,
+    307,
+    308,
+    309,
+    310,
+    311,
+    0,
+    312,
+    0,
+    0,
+    313,
+    0,
+    0,
+    314,
+    315,
+    0,
+    0,
+    316,
+    317,
+    318,
+    0,
+    0,
+    0,
+    158,
+    155,
+    163,
+    319,
+    320,
+    321,
+    322,
+    323,
+    324,
+    325,
+    0,
+    0,
+    326,
+    150,
+    164,
+    169,
+    327,
+    328,
+    329,
+    330,
+    331,
+    332,
+    333,
+    334,
+    335,
+    336,
+    337,
+    338,
+    339,
+    340,
+    341,
+    342,
+    343,
+    344,
+    345,
+    346,
+    347,
+    348,
+    349,
+    350,
+    351,
+    352,
+    353,
+    354,
+    355,
+    356,
+    357,
+    358,
+    359,
+    360,
+    361,
+    362,
+    363,
+    364,
+    365,
+    366,
+    367,
+    368,
+    369,
+    370,
+    371,
+    372,
+    373,
+    374,
+    375,
+    376,
+    377,
+    378,
+    0
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/psnames/rules.mk b/nx-X11/extras/freetype2/src/psnames/rules.mk
new file mode 100644
index 000000000..06bd161e3
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/psnames/rules.mk
@@ -0,0 +1,70 @@
+#
+# FreeType 2 PSNames driver configuration rules
+#
+
+
+# Copyright 1996-2000, 2001, 2003 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.
+
+
+# PSNames driver directory
+#
+PSNAMES_DIR := $(SRC_DIR)/psnames
+
+
+# compilation flags for the driver
+#
+PSNAMES_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(PSNAMES_DIR))
+
+
+# PSNames driver sources (i.e., C files)
+#
+PSNAMES_DRV_SRC := $(PSNAMES_DIR)/psmodule.c
+
+
+# PSNames driver headers
+#
+PSNAMES_DRV_H := $(PSNAMES_DRV_SRC:%.c=%.h) \
+                 $(PSNAMES_DIR)/pstables.h  \
+                 $(PSNAMES_DIR)/psnamerr.h
+
+
+# PSNames driver object(s)
+#
+#   PSNAMES_DRV_OBJ_M is used during `multi' builds
+#   PSNAMES_DRV_OBJ_S is used during `single' builds
+#
+PSNAMES_DRV_OBJ_M := $(PSNAMES_DRV_SRC:$(PSNAMES_DIR)/%.c=$(OBJ_DIR)/%.$O)
+PSNAMES_DRV_OBJ_S := $(OBJ_DIR)/psnames.$O
+
+# PSNames driver source file for single build
+#
+PSNAMES_DRV_SRC_S := $(PSNAMES_DIR)/psmodule.c
+
+
+# PSNames driver - single object
+#
+$(PSNAMES_DRV_OBJ_S): $(PSNAMES_DRV_SRC_S) $(PSNAMES_DRV_SRC) \
+                      $(FREETYPE_H) $(PSNAMES_DRV_H)
+	$(PSNAMES_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(PSNAMES_DRV_SRC_S))
+
+
+# PSNames driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(PSNAMES_DIR)/%.c $(FREETYPE_H) $(PSNAMES_DRV_H)
+	$(PSNAMES_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(PSNAMES_DRV_OBJ_S)
+DRV_OBJS_M += $(PSNAMES_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/raster/Jamfile b/nx-X11/extras/freetype2/src/raster/Jamfile
new file mode 100644
index 000000000..01b5c0db0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/raster Jamfile (c) 2001 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) raster ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = ftraster ftrend1 ;
+  }
+  else
+  {
+    _sources = raster ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/raster Jamfile
diff --git a/nx-X11/extras/freetype2/src/raster/descrip.mms b/nx-X11/extras/freetype2/src/raster/descrip.mms
new file mode 100644
index 000000000..d0650ebbf
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 renderer module compilation rules for VMS
+#
+
+
+# Copyright 2001 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.raster])
+
+OBJS=raster.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/raster/ftraster.c b/nx-X11/extras/freetype2/src/raster/ftraster.c
new file mode 100644
index 000000000..0ba27e828
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/ftraster.c
@@ -0,0 +1,3298 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftraster.c                                                             */
+/*                                                                         */
+/*    The FreeType glyph rasterizer (body).                                */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 is a rewrite of the FreeType 1.x scan-line converter             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include "ftraster.h"
+#include FT_INTERNAL_CALC_H   /* for FT_MulDiv only */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A simple technical note on how the raster works                       */
+  /* -----------------------------------------------                       */
+  /*                                                                       */
+  /*   Converting an outline into a bitmap is achieved in several steps:   */
+  /*                                                                       */
+  /*   1 - Decomposing the outline into successive `profiles'.  Each       */
+  /*       profile is simply an array of scanline intersections on a given */
+  /*       dimension.  A profile's main attributes are                     */
+  /*                                                                       */
+  /*       o its scanline position boundaries, i.e. `Ymin' and `Ymax'.     */
+  /*                                                                       */
+  /*       o an array of intersection coordinates for each scanline        */
+  /*         between `Ymin' and `Ymax'.                                    */
+  /*                                                                       */
+  /*       o a direction, indicating whether it was built going `up' or    */
+  /*         `down', as this is very important for filling rules.          */
+  /*                                                                       */
+  /*   2 - Sweeping the target map's scanlines in order to compute segment */
+  /*       `spans' which are then filled.  Additionally, this pass         */
+  /*       performs drop-out control.                                      */
+  /*                                                                       */
+  /*   The outline data is parsed during step 1 only.  The profiles are    */
+  /*   built from the bottom of the render pool, used as a stack.  The     */
+  /*   following graphics shows the profile list under construction:       */
+  /*                                                                       */
+  /*     ____________________________________________________________ _ _  */
+  /*    |         |                   |         |                 |        */
+  /*    | profile | coordinates for   | profile | coordinates for |-->     */
+  /*    |    1    |  profile 1        |    2    |  profile 2      |-->     */
+  /*    |_________|___________________|_________|_________________|__ _ _  */
+  /*                                                                       */
+  /*    ^                                                         ^        */
+  /*    |                                                         |        */
+  /*  start of render pool                                       top       */
+  /*                                                                       */
+  /*   The top of the profile stack is kept in the `top' variable.         */
+  /*                                                                       */
+  /*   As you can see, a profile record is pushed on top of the render     */
+  /*   pool, which is then followed by its coordinates/intersections.  If  */
+  /*   a change of direction is detected in the outline, a new profile is  */
+  /*   generated until the end of the outline.                             */
+  /*                                                                       */
+  /*   Note that when all profiles have been generated, the function       */
+  /*   Finalize_Profile_Table() is used to record, for each profile, its   */
+  /*   bottom-most scanline as well as the scanline above its upmost       */
+  /*   boundary.  These positions are called `y-turns' because they (sort  */
+  /*   of) correspond to local extrema.  They are stored in a sorted list  */
+  /*   built from the top of the render pool as a downwards stack:         */
+  /*                                                                       */
+  /*      _ _ _______________________________________                      */
+  /*                            |                    |                     */
+  /*                         <--| sorted list of     |                     */
+  /*                         <--|  extrema scanlines |                     */
+  /*      _ _ __________________|____________________|                     */
+  /*                                                                       */
+  /*                            ^                    ^                     */
+  /*                            |                    |                     */
+  /*                         maxBuff           sizeBuff = end of pool      */
+  /*                                                                       */
+  /*   This list is later used during the sweep phase in order to          */
+  /*   optimize performance (see technical note on the sweep below).       */
+  /*                                                                       */
+  /*   Of course, the raster detects whether the two stacks collide and    */
+  /*   handles the situation propertly.                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /**                                                                     **/
+  /**  CONFIGURATION MACROS                                               **/
+  /**                                                                     **/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* define DEBUG_RASTER if you want to compile a debugging version */
+#define xxxDEBUG_RASTER
+
+  /* The default render pool size in bytes */
+#define RASTER_RENDER_POOL  8192
+
+  /* undefine FT_RASTER_OPTION_ANTI_ALIASING if you do not want to support */
+  /* 5-levels anti-aliasing                                                */
+#ifdef FT_CONFIG_OPTION_5_GRAY_LEVELS
+#define FT_RASTER_OPTION_ANTI_ALIASING
+#endif
+
+  /* The size of the two-lines intermediate bitmap used */
+  /* for anti-aliasing, in bytes.                       */
+#define RASTER_GRAY_LINES  2048
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /**                                                                     **/
+  /**  OTHER MACROS (do not change)                                       **/
+  /**                                                                     **/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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_raster
+
+
+#ifdef _STANDALONE_
+
+
+  /* This macro is used to indicate that a function parameter is unused. */
+  /* Its purpose is simply to reduce compiler warnings.  Note also that  */
+  /* simply defining it as `(void)x' doesn't avoid warnings with certain */
+  /* ANSI compilers (e.g. LCC).                                          */
+#define FT_UNUSED( x )  (x) = (x)
+
+  /* Disable the tracing mechanism for simplicity -- developers can      */
+  /* activate it easily by redefining these two macros.                  */
+#ifndef FT_ERROR
+#define FT_ERROR( x )  do ; while ( 0 )     /* nothing */
+#endif
+
+#ifndef FT_TRACE
+#define FT_TRACE( x )  do ; while ( 0 )     /* nothing */
+#endif
+
+#define Raster_Err_None          0
+#define Raster_Err_Not_Ini      -1
+#define Raster_Err_Overflow     -2
+#define Raster_Err_Neg_Height   -3
+#define Raster_Err_Invalid      -4
+#define Raster_Err_Unsupported  -5
+
+
+#else /* _STANDALONE_ */
+
+
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H        /* for FT_TRACE() and FT_ERROR() */
+
+#include "rasterrs.h"
+
+#define Raster_Err_None         Raster_Err_Ok
+#define Raster_Err_Not_Ini      Raster_Err_Raster_Uninitialized
+#define Raster_Err_Overflow     Raster_Err_Raster_Overflow
+#define Raster_Err_Neg_Height   Raster_Err_Raster_Negative_Height
+#define Raster_Err_Invalid      Raster_Err_Invalid_Outline
+#define Raster_Err_Unsupported  Raster_Err_Cannot_Render_Glyph
+
+
+#endif /* _STANDALONE_ */
+
+
+#ifndef FT_MEM_SET
+#define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
+#endif
+
+
+  /* FMulDiv means `Fast MulDiv'; it is used in case where `b' is       */
+  /* typically a small value and the result of a*b is known to fit into */
+  /* 32 bits.                                                           */
+#define FMulDiv( a, b, c )  ( (a) * (b) / (c) )
+
+  /* On the other hand, SMulDiv means `Slow MulDiv', and is used typically */
+  /* for clipping computations.  It simply uses the FT_MulDiv() function   */
+  /* defined in `ftcalc.h'.                                                */
+#define SMulDiv  FT_MulDiv
+
+  /* The rasterizer is a very general purpose component; please leave */
+  /* the following redefinitions there (you never know your target    */
+  /* environment).                                                    */
+
+#ifndef TRUE
+#define TRUE   1
+#endif
+
+#ifndef FALSE
+#define FALSE  0
+#endif
+
+#ifndef NULL
+#define NULL  (void*)0
+#endif
+
+#ifndef SUCCESS
+#define SUCCESS  0
+#endif
+
+#ifndef FAILURE
+#define FAILURE  1
+#endif
+
+
+#define MaxBezier  32   /* The maximum number of stacked Bezier curves. */
+                        /* Setting this constant to more than 32 is a   */
+                        /* pure waste of space.                         */
+
+#define Pixel_Bits  6   /* fractional bits of *input* coordinates */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /**                                                                     **/
+  /**  SIMPLE TYPE DECLARATIONS                                           **/
+  /**                                                                     **/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef int             Int;
+  typedef unsigned int    UInt;
+  typedef short           Short;
+  typedef unsigned short  UShort, *PUShort;
+  typedef long            Long, *PLong;
+  typedef unsigned long   ULong;
+
+  typedef unsigned char   Byte, *PByte;
+  typedef char            Bool;
+
+
+  typedef union  Alignment_
+  {
+    long    l;
+    void*   p;
+    void  (*f)(void);
+
+  } Alignment, *PAlignment;
+
+
+  typedef struct  TPoint_
+  {
+    Long  x;
+    Long  y;
+
+  } TPoint;
+
+
+  typedef enum  TFlow_
+  {
+    Flow_None = 0,
+    Flow_Up   = 1,
+    Flow_Down = -1
+
+  } TFlow;
+
+
+  /* States of each line, arc, and profile */
+  typedef enum  TStates_
+  {
+    Unknown_State,
+    Ascending_State,
+    Descending_State,
+    Flat_State
+
+  } TStates;
+
+
+  typedef struct TProfile_  TProfile;
+  typedef TProfile*         PProfile;
+
+  struct  TProfile_
+  {
+    FT_F26Dot6  X;           /* current coordinate during sweep        */
+    PProfile    link;        /* link to next profile - various purpose */
+    PLong       offset;      /* start of profile's data in render pool */
+    int         flow;        /* Profile orientation: Asc/Descending    */
+    long        height;      /* profile's height in scanlines          */
+    long        start;       /* profile's starting scanline            */
+
+    unsigned    countL;      /* number of lines to step before this    */
+                             /* profile becomes drawable               */
+
+    PProfile    next;        /* next profile in same contour, used     */
+                             /* during drop-out control                */
+  };
+
+  typedef PProfile   TProfileList;
+  typedef PProfile*  PProfileList;
+
+
+  /* Simple record used to implement a stack of bands, required */
+  /* by the sub-banding mechanism                               */
+  typedef struct  TBand_
+  {
+    Short  y_min;   /* band's minimum */
+    Short  y_max;   /* band's maximum */
+
+  } TBand;
+
+
+#define AlignProfileSize \
+  ( ( sizeof ( TProfile ) + sizeof ( Alignment ) - 1 ) / sizeof ( long ) )
+
+
+#ifdef TT_STATIC_RASTER
+
+
+#define RAS_ARGS       /* void */
+#define RAS_ARG        /* void */
+
+#define RAS_VARS       /* void */
+#define RAS_VAR        /* void */
+
+#define FT_UNUSED_RASTER  do ; while ( 0 )
+
+
+#else /* TT_STATIC_RASTER */
+
+
+#define RAS_ARGS       TRaster_Instance*  raster,
+#define RAS_ARG        TRaster_Instance*  raster
+
+#define RAS_VARS       raster,
+#define RAS_VAR        raster
+
+#define FT_UNUSED_RASTER  FT_UNUSED( raster )
+
+
+#endif /* TT_STATIC_RASTER */
+
+
+  typedef struct TRaster_Instance_  TRaster_Instance;
+
+
+  /* prototypes used for sweep function dispatch */
+  typedef void
+  Function_Sweep_Init( RAS_ARGS Short*  min,
+                                Short*  max );
+
+  typedef void
+  Function_Sweep_Span( RAS_ARGS Short       y,
+                                FT_F26Dot6  x1,
+                                FT_F26Dot6  x2,
+                                PProfile    left,
+                                PProfile    right );
+
+  typedef void
+  Function_Sweep_Step( RAS_ARG );
+
+
+  /* NOTE: These operations are only valid on 2's complement processors */
+
+#define FLOOR( x )    ( (x) & -ras.precision )
+#define CEILING( x )  ( ( (x) + ras.precision - 1 ) & -ras.precision )
+#define TRUNC( x )    ( (signed long)(x) >> ras.precision_bits )
+#define FRAC( x )     ( (x) & ( ras.precision - 1 ) )
+#define SCALED( x )   ( ( (x) << ras.scale_shift ) - ras.precision_half )
+
+  /* Note that I have moved the location of some fields in the */
+  /* structure to ensure that the most used variables are used */
+  /* at the top.  Thus, their offset can be coded with less    */
+  /* opcodes, and it results in a smaller executable.          */
+
+  struct  TRaster_Instance_
+  {
+    Int       precision_bits;       /* precision related variables         */
+    Int       precision;
+    Int       precision_half;
+    Long      precision_mask;
+    Int       precision_shift;
+    Int       precision_step;
+    Int       precision_jitter;
+
+    Int       scale_shift;          /* == precision_shift   for bitmaps    */
+                                    /* == precision_shift+1 for pixmaps    */
+
+    PLong     buff;                 /* The profiles buffer                 */
+    PLong     sizeBuff;             /* Render pool size                    */
+    PLong     maxBuff;              /* Profiles buffer size                */
+    PLong     top;                  /* Current cursor in buffer            */
+
+    FT_Error  error;
+
+    Int       numTurns;             /* number of Y-turns in outline        */
+
+    TPoint*   arc;                  /* current Bezier arc pointer          */
+
+    UShort    bWidth;               /* target bitmap width                 */
+    PByte     bTarget;              /* target bitmap buffer                */
+    PByte     gTarget;              /* target pixmap buffer                */
+
+    Long      lastX, lastY, minY, maxY;
+
+    UShort    num_Profs;            /* current number of profiles          */
+
+    Bool      fresh;                /* signals a fresh new profile which   */
+                                    /* 'start' field must be completed     */
+    Bool      joint;                /* signals that the last arc ended     */
+                                    /* exactly on a scanline.  Allows      */
+                                    /* removal of doublets                 */
+    PProfile  cProfile;             /* current profile                     */
+    PProfile  fProfile;             /* head of linked list of profiles     */
+    PProfile  gProfile;             /* contour's first profile in case     */
+                                    /* of impact                           */
+
+    TStates   state;                /* rendering state                     */
+
+    FT_Bitmap   target;             /* description of target bit/pixmap    */
+    FT_Outline  outline;
+
+    Long      traceOfs;             /* current offset in target bitmap     */
+    Long      traceG;               /* current offset in target pixmap     */
+
+    Short     traceIncr;            /* sweep's increment in target bitmap  */
+
+    Short     gray_min_x;           /* current min x during gray rendering */
+    Short     gray_max_x;           /* current max x during gray rendering */
+
+    /* dispatch variables */
+
+    Function_Sweep_Init*  Proc_Sweep_Init;
+    Function_Sweep_Span*  Proc_Sweep_Span;
+    Function_Sweep_Span*  Proc_Sweep_Drop;
+    Function_Sweep_Step*  Proc_Sweep_Step;
+
+    Byte      dropOutControl;       /* current drop_out control method     */
+
+    Bool      second_pass;          /* indicates wether a horizontal pass  */
+                                    /* should be performed to control      */
+                                    /* drop-out accurately when calling    */
+                                    /* Render_Glyph.  Note that there is   */
+                                    /* no horizontal pass during gray      */
+                                    /* rendering.                          */
+
+    TPoint    arcs[3 * MaxBezier + 1]; /* The Bezier stack                 */
+
+    TBand     band_stack[16];       /* band stack used for sub-banding     */
+    Int       band_top;             /* band stack top                      */
+
+    Int       count_table[256];     /* Look-up table used to quickly count */
+                                    /* set bits in a gray 2x2 cell         */
+
+    void*     memory;
+
+#ifdef FT_RASTER_OPTION_ANTI_ALIASING
+
+    Byte      grays[5];             /* Palette of gray levels used for     */
+                                    /* render.                             */
+
+    Byte      gray_lines[RASTER_GRAY_LINES];
+                                /* Intermediate table used to render the   */
+                                /* graylevels pixmaps.                     */
+                                /* gray_lines is a buffer holding two      */
+                                /* monochrome scanlines                    */
+
+    Short     gray_width;       /* width in bytes of one monochrome        */
+                                /* intermediate scanline of gray_lines.    */
+                                /* Each gray pixel takes 2 bits long there */
+
+                       /* The gray_lines must hold 2 lines, thus with size */
+                       /* in bytes of at least `gray_width*2'.             */
+
+#endif /* FT_RASTER_ANTI_ALIASING */
+
+#if 0
+    PByte       flags;              /* current flags table                 */
+    PUShort     outs;               /* current outlines table              */
+    FT_Vector*  coords;
+
+    UShort      nPoints;            /* number of points in current glyph   */
+    Short       nContours;          /* number of contours in current glyph */
+#endif
+
+  };
+
+
+#ifdef FT_CONFIG_OPTION_STATIC_RASTER
+
+  static TRaster_Instance  cur_ras;
+#define ras  cur_ras
+
+#else
+
+#define ras  (*raster)
+
+#endif /* FT_CONFIG_OPTION_STATIC_RASTER */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /**                                                                     **/
+  /**  PROFILES COMPUTATION                                               **/
+  /**                                                                     **/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Set_High_Precision                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Sets precision variables according to param flag.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    High :: Set to True for high precision (typically for ppem < 18),  */
+  /*            false otherwise.                                           */
+  /*                                                                       */
+  static void
+  Set_High_Precision( RAS_ARGS Int  High )
+  {
+    if ( High )
+    {
+      ras.precision_bits   = 10;
+      ras.precision_step   = 128;
+      ras.precision_jitter = 24;
+    }
+    else
+    {
+      ras.precision_bits   = 6;
+      ras.precision_step   = 32;
+      ras.precision_jitter = 2;
+    }
+
+    FT_TRACE6(( "Set_High_Precision(%s)\n", High ? "true" : "false" ));
+
+    ras.precision       = 1 << ras.precision_bits;
+    ras.precision_half  = ras.precision / 2;
+    ras.precision_shift = ras.precision_bits - Pixel_Bits;
+    ras.precision_mask  = -ras.precision;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    New_Profile                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new profile in the render pool.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    aState :: The state/orientation of the new profile.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*   SUCCESS on success.  FAILURE in case of overflow or of incoherent   */
+  /*   profile.                                                            */
+  /*                                                                       */
+  static Bool
+  New_Profile( RAS_ARGS TStates  aState )
+  {
+    if ( !ras.fProfile )
+    {
+      ras.cProfile  = (PProfile)ras.top;
+      ras.fProfile  = ras.cProfile;
+      ras.top      += AlignProfileSize;
+    }
+
+    if ( ras.top >= ras.maxBuff )
+    {
+      ras.error = Raster_Err_Overflow;
+      return FAILURE;
+    }
+
+    switch ( aState )
+    {
+    case Ascending_State:
+      ras.cProfile->flow = Flow_Up;
+      FT_TRACE6(( "New ascending profile = %lx\n", (long)ras.cProfile ));
+      break;
+
+    case Descending_State:
+      ras.cProfile->flow = Flow_Down;
+      FT_TRACE6(( "New descending profile = %lx\n", (long)ras.cProfile ));
+      break;
+
+    default:
+      FT_ERROR(( "New_Profile: invalid profile direction!\n" ));
+      ras.error = Raster_Err_Invalid;
+      return FAILURE;
+    }
+
+    ras.cProfile->start  = 0;
+    ras.cProfile->height = 0;
+    ras.cProfile->offset = ras.top;
+    ras.cProfile->link   = (PProfile)0;
+    ras.cProfile->next   = (PProfile)0;
+
+    if ( !ras.gProfile )
+      ras.gProfile = ras.cProfile;
+
+    ras.state = aState;
+    ras.fresh = TRUE;
+    ras.joint = FALSE;
+
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    End_Profile                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes the current profile.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success.  FAILURE in case of overflow or incoherency.   */
+  /*                                                                       */
+  static Bool
+  End_Profile( RAS_ARG )
+  {
+    Long      h;
+    PProfile  oldProfile;
+
+
+    h = (Long)( ras.top - ras.cProfile->offset );
+
+    if ( h < 0 )
+    {
+      FT_ERROR(( "End_Profile: negative height encountered!\n" ));
+      ras.error = Raster_Err_Neg_Height;
+      return FAILURE;
+    }
+
+    if ( h > 0 )
+    {
+      FT_TRACE6(( "Ending profile %lx, start = %ld, height = %ld\n",
+                  (long)ras.cProfile, ras.cProfile->start, h ));
+
+      oldProfile           = ras.cProfile;
+      ras.cProfile->height = h;
+      ras.cProfile         = (PProfile)ras.top;
+
+      ras.top             += AlignProfileSize;
+
+      ras.cProfile->height = 0;
+      ras.cProfile->offset = ras.top;
+      oldProfile->next     = ras.cProfile;
+      ras.num_Profs++;
+    }
+
+    if ( ras.top >= ras.maxBuff )
+    {
+      FT_TRACE1(( "overflow in End_Profile\n" ));
+      ras.error = Raster_Err_Overflow;
+      return FAILURE;
+    }
+
+    ras.joint = FALSE;
+
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Insert_Y_Turn                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Inserts a salient into the sorted list placed on top of the render */
+  /*    pool.                                                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    New y scanline position.                                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success.  FAILURE in case of overflow.                  */
+  /*                                                                       */
+  static Bool
+  Insert_Y_Turn( RAS_ARGS Int  y )
+  {
+    PLong  y_turns;
+    Int    y2, n;
+
+
+    n       = ras.numTurns - 1;
+    y_turns = ras.sizeBuff - ras.numTurns;
+
+    /* look for first y value that is <= */
+    while ( n >= 0 && y < y_turns[n] )
+      n--;
+
+    /* if it is <, simply insert it, ignore if == */
+    if ( n >= 0 && y > y_turns[n] )
+      while ( n >= 0 )
+      {
+        y2 = (Int)y_turns[n];
+        y_turns[n] = y;
+        y = y2;
+        n--;
+      }
+
+    if ( n < 0 )
+    {
+      ras.maxBuff--;
+      if ( ras.maxBuff <= ras.top )
+      {
+        ras.error = Raster_Err_Overflow;
+        return FAILURE;
+      }
+      ras.numTurns++;
+      ras.sizeBuff[-ras.numTurns] = y;
+    }
+
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Finalize_Profile_Table                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Adjusts all links in the profiles list.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success.  FAILURE in case of overflow.                  */
+  /*                                                                       */
+  static Bool
+  Finalize_Profile_Table( RAS_ARG )
+  {
+    Int       bottom, top;
+    UShort    n;
+    PProfile  p;
+
+
+    n = ras.num_Profs;
+
+    if ( n > 1 )
+    {
+      p = ras.fProfile;
+      while ( n > 0 )
+      {
+        if ( n > 1 )
+          p->link = (PProfile)( p->offset + p->height );
+        else
+          p->link = NULL;
+
+        switch ( p->flow )
+        {
+        case Flow_Down:
+          bottom     = (Int)( p->start - p->height + 1 );
+          top        = (Int)p->start;
+          p->start   = bottom;
+          p->offset += p->height - 1;
+          break;
+
+        case Flow_Up:
+        default:
+          bottom = (Int)p->start;
+          top    = (Int)( p->start + p->height - 1 );
+        }
+
+        if ( Insert_Y_Turn( RAS_VARS bottom )   ||
+             Insert_Y_Turn( RAS_VARS top + 1 )  )
+          return FAILURE;
+
+        p = p->link;
+        n--;
+      }
+    }
+    else
+      ras.fProfile = NULL;
+
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Split_Conic                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Subdivides one conic Bezier into two joint sub-arcs in the Bezier  */
+  /*    stack.                                                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    None (subdivided Bezier is taken from the top of the stack).       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This routine is the `beef' of this component.  It is  _the_ inner  */
+  /*    loop that should be optimized to hell to get the best performance. */
+  /*                                                                       */
+  static void
+  Split_Conic( TPoint*  base )
+  {
+    Long  a, b;
+
+
+    base[4].x = base[2].x;
+    b = base[1].x;
+    a = base[3].x = ( base[2].x + b ) / 2;
+    b = base[1].x = ( base[0].x + b ) / 2;
+    base[2].x = ( a + b ) / 2;
+
+    base[4].y = base[2].y;
+    b = base[1].y;
+    a = base[3].y = ( base[2].y + b ) / 2;
+    b = base[1].y = ( base[0].y + b ) / 2;
+    base[2].y = ( a + b ) / 2;
+
+    /* hand optimized.  gcc doesn't seem to be too good at common      */
+    /* expression substitution and instruction scheduling ;-)          */
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Split_Cubic                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Subdivides a third-order Bezier arc into two joint sub-arcs in the */
+  /*    Bezier stack.                                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This routine is the `beef' of the component.  It is one of _the_   */
+  /*    inner loops that should be optimized like hell to get the best     */
+  /*    performance.                                                       */
+  /*                                                                       */
+  static void
+  Split_Cubic( TPoint*  base )
+  {
+    Long  a, b, c, d;
+
+
+    base[6].x = base[3].x;
+    c = base[1].x;
+    d = base[2].x;
+    base[1].x = a = ( base[0].x + c + 1 ) >> 1;
+    base[5].x = b = ( base[3].x + d + 1 ) >> 1;
+    c = ( c + d + 1 ) >> 1;
+    base[2].x = a = ( a + c + 1 ) >> 1;
+    base[4].x = b = ( b + c + 1 ) >> 1;
+    base[3].x = ( a + b + 1 ) >> 1;
+
+    base[6].y = base[3].y;
+    c = base[1].y;
+    d = base[2].y;
+    base[1].y = a = ( base[0].y + c + 1 ) >> 1;
+    base[5].y = b = ( base[3].y + d + 1 ) >> 1;
+    c = ( c + d + 1 ) >> 1;
+    base[2].y = a = ( a + c + 1 ) >> 1;
+    base[4].y = b = ( b + c + 1 ) >> 1;
+    base[3].y = ( a + b + 1 ) >> 1;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Line_Up                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the x-coordinates of an ascending line segment and stores */
+  /*    them in the render pool.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    x1   :: The x-coordinate of the segment's start point.             */
+  /*                                                                       */
+  /*    y1   :: The y-coordinate of the segment's start point.             */
+  /*                                                                       */
+  /*    x2   :: The x-coordinate of the segment's end point.               */
+  /*                                                                       */
+  /*    y2   :: The y-coordinate of the segment's end point.               */
+  /*                                                                       */
+  /*    miny :: A lower vertical clipping bound value.                     */
+  /*                                                                       */
+  /*    maxy :: An upper vertical clipping bound value.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success, FAILURE on render pool overflow.               */
+  /*                                                                       */
+  static Bool
+  Line_Up( RAS_ARGS Long  x1,
+                    Long  y1,
+                    Long  x2,
+                    Long  y2,
+                    Long  miny,
+                    Long  maxy )
+  {
+    Long   Dx, Dy;
+    Int    e1, e2, f1, f2, size;     /* XXX: is `Short' sufficient? */
+    Long   Ix, Rx, Ax;
+
+    PLong  top;
+
+
+    Dx = x2 - x1;
+    Dy = y2 - y1;
+
+    if ( Dy <= 0 || y2 < miny || y1 > maxy )
+      return SUCCESS;
+
+    if ( y1 < miny )
+    {
+      /* Take care: miny-y1 can be a very large value; we use     */
+      /*            a slow MulDiv function to avoid clipping bugs */
+      x1 += SMulDiv( Dx, miny - y1, Dy );
+      e1  = (Int)TRUNC( miny );
+      f1  = 0;
+    }
+    else
+    {
+      e1 = (Int)TRUNC( y1 );
+      f1 = (Int)FRAC( y1 );
+    }
+
+    if ( y2 > maxy )
+    {
+      /* x2 += FMulDiv( Dx, maxy - y2, Dy );  UNNECESSARY */
+      e2  = (Int)TRUNC( maxy );
+      f2  = 0;
+    }
+    else
+    {
+      e2 = (Int)TRUNC( y2 );
+      f2 = (Int)FRAC( y2 );
+    }
+
+    if ( f1 > 0 )
+    {
+      if ( e1 == e2 )
+        return SUCCESS;
+      else
+      {
+        x1 += FMulDiv( Dx, ras.precision - f1, Dy );
+        e1 += 1;
+      }
+    }
+    else
+      if ( ras.joint )
+      {
+        ras.top--;
+        ras.joint = FALSE;
+      }
+
+    ras.joint = (char)( f2 == 0 );
+
+    if ( ras.fresh )
+    {
+      ras.cProfile->start = e1;
+      ras.fresh           = FALSE;
+    }
+
+    size = e2 - e1 + 1;
+    if ( ras.top + size >= ras.maxBuff )
+    {
+      ras.error = Raster_Err_Overflow;
+      return FAILURE;
+    }
+
+    if ( Dx > 0 )
+    {
+      Ix = ( ras.precision * Dx ) / Dy;
+      Rx = ( ras.precision * Dx ) % Dy;
+      Dx = 1;
+    }
+    else
+    {
+      Ix = -( ( ras.precision * -Dx ) / Dy );
+      Rx =    ( ras.precision * -Dx ) % Dy;
+      Dx = -1;
+    }
+
+    Ax  = -Dy;
+    top = ras.top;
+
+    while ( size > 0 )
+    {
+      *top++ = x1;
+
+      x1 += Ix;
+      Ax += Rx;
+      if ( Ax >= 0 )
+      {
+        Ax -= Dy;
+        x1 += Dx;
+      }
+      size--;
+    }
+
+    ras.top = top;
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Line_Down                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the x-coordinates of an descending line segment and       */
+  /*    stores them in the render pool.                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    x1   :: The x-coordinate of the segment's start point.             */
+  /*                                                                       */
+  /*    y1   :: The y-coordinate of the segment's start point.             */
+  /*                                                                       */
+  /*    x2   :: The x-coordinate of the segment's end point.               */
+  /*                                                                       */
+  /*    y2   :: The y-coordinate of the segment's end point.               */
+  /*                                                                       */
+  /*    miny :: A lower vertical clipping bound value.                     */
+  /*                                                                       */
+  /*    maxy :: An upper vertical clipping bound value.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success, FAILURE on render pool overflow.               */
+  /*                                                                       */
+  static Bool
+  Line_Down( RAS_ARGS Long  x1,
+                      Long  y1,
+                      Long  x2,
+                      Long  y2,
+                      Long  miny,
+                      Long  maxy )
+  {
+    Bool  result, fresh;
+
+
+    fresh  = ras.fresh;
+
+    result = Line_Up( RAS_VARS x1, -y1, x2, -y2, -maxy, -miny );
+
+    if ( fresh && !ras.fresh )
+      ras.cProfile->start = -ras.cProfile->start;
+
+    return result;
+  }
+
+
+  /* A function type describing the functions used to split Bezier arcs */
+  typedef void  (*TSplitter)( TPoint*  base );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Bezier_Up                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the x-coordinates of an ascending Bezier arc and stores   */
+  /*    them in the render pool.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    degree   :: The degree of the Bezier arc (either 2 or 3).          */
+  /*                                                                       */
+  /*    splitter :: The function to split Bezier arcs.                     */
+  /*                                                                       */
+  /*    miny     :: A lower vertical clipping bound value.                 */
+  /*                                                                       */
+  /*    maxy     :: An upper vertical clipping bound value.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success, FAILURE on render pool overflow.               */
+  /*                                                                       */
+  static Bool
+  Bezier_Up( RAS_ARGS Int        degree,
+                      TSplitter  splitter,
+                      Long       miny,
+                      Long       maxy )
+  {
+    Long   y1, y2, e, e2, e0;
+    Short  f1;
+
+    TPoint*  arc;
+    TPoint*  start_arc;
+
+    PLong top;
+
+
+    arc = ras.arc;
+    y1  = arc[degree].y;
+    y2  = arc[0].y;
+    top = ras.top;
+
+    if ( y2 < miny || y1 > maxy )
+      goto Fin;
+
+    e2 = FLOOR( y2 );
+
+    if ( e2 > maxy )
+      e2 = maxy;
+
+    e0 = miny;
+
+    if ( y1 < miny )
+      e = miny;
+    else
+    {
+      e  = CEILING( y1 );
+      f1 = (Short)( FRAC( y1 ) );
+      e0 = e;
+
+      if ( f1 == 0 )
+      {
+        if ( ras.joint )
+        {
+          top--;
+          ras.joint = FALSE;
+        }
+
+        *top++ = arc[degree].x;
+
+        e += ras.precision;
+      }
+    }
+
+    if ( ras.fresh )
+    {
+      ras.cProfile->start = TRUNC( e0 );
+      ras.fresh = FALSE;
+    }
+
+    if ( e2 < e )
+      goto Fin;
+
+    if ( ( top + TRUNC( e2 - e ) + 1 ) >= ras.maxBuff )
+    {
+      ras.top   = top;
+      ras.error = Raster_Err_Overflow;
+      return FAILURE;
+    }
+
+    start_arc = arc;
+
+    while ( arc >= start_arc && e <= e2 )
+    {
+      ras.joint = FALSE;
+
+      y2 = arc[0].y;
+
+      if ( y2 > e )
+      {
+        y1 = arc[degree].y;
+        if ( y2 - y1 >= ras.precision_step )
+        {
+          splitter( arc );
+          arc += degree;
+        }
+        else
+        {
+          *top++ = arc[degree].x + FMulDiv( arc[0].x-arc[degree].x,
+                                            e - y1, y2 - y1 );
+          arc -= degree;
+          e   += ras.precision;
+        }
+      }
+      else
+      {
+        if ( y2 == e )
+        {
+          ras.joint  = TRUE;
+          *top++     = arc[0].x;
+
+          e += ras.precision;
+        }
+        arc -= degree;
+      }
+    }
+
+  Fin:
+    ras.top  = top;
+    ras.arc -= degree;
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Bezier_Down                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the x-coordinates of an descending Bezier arc and stores  */
+  /*    them in the render pool.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    degree   :: The degree of the Bezier arc (either 2 or 3).          */
+  /*                                                                       */
+  /*    splitter :: The function to split Bezier arcs.                     */
+  /*                                                                       */
+  /*    miny     :: A lower vertical clipping bound value.                 */
+  /*                                                                       */
+  /*    maxy     :: An upper vertical clipping bound value.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success, FAILURE on render pool overflow.               */
+  /*                                                                       */
+  static Bool
+  Bezier_Down( RAS_ARGS Int        degree,
+                        TSplitter  splitter,
+                        Long       miny,
+                        Long       maxy )
+  {
+    TPoint*  arc = ras.arc;
+    Bool     result, fresh;
+
+
+    arc[0].y = -arc[0].y;
+    arc[1].y = -arc[1].y;
+    arc[2].y = -arc[2].y;
+    if ( degree > 2 )
+      arc[3].y = -arc[3].y;
+
+    fresh = ras.fresh;
+
+    result = Bezier_Up( RAS_VARS degree, splitter, -maxy, -miny );
+
+    if ( fresh && !ras.fresh )
+      ras.cProfile->start = -ras.cProfile->start;
+
+    arc[0].y = -arc[0].y;
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Line_To                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Injects a new line segment and adjusts Profiles list.              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*   x :: The x-coordinate of the segment's end point (its start point   */
+  /*        is stored in `LastX').                                         */
+  /*                                                                       */
+  /*   y :: The y-coordinate of the segment's end point (its start point   */
+  /*        is stored in `LastY').                                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*   SUCCESS on success, FAILURE on render pool overflow or incorrect    */
+  /*   profile.                                                            */
+  /*                                                                       */
+  static Bool
+  Line_To( RAS_ARGS Long  x,
+                    Long  y )
+  {
+    /* First, detect a change of direction */
+
+    switch ( ras.state )
+    {
+    case Unknown_State:
+      if ( y > ras.lastY )
+      {
+        if ( New_Profile( RAS_VARS Ascending_State ) )
+          return FAILURE;
+      }
+      else
+      {
+        if ( y < ras.lastY )
+          if ( New_Profile( RAS_VARS Descending_State ) )
+            return FAILURE;
+      }
+      break;
+
+    case Ascending_State:
+      if ( y < ras.lastY )
+      {
+        if ( End_Profile( RAS_VAR )                   ||
+             New_Profile( RAS_VARS Descending_State ) )
+          return FAILURE;
+      }
+      break;
+
+    case Descending_State:
+      if ( y > ras.lastY )
+      {
+        if ( End_Profile( RAS_VAR )                  ||
+             New_Profile( RAS_VARS Ascending_State ) )
+          return FAILURE;
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    /* Then compute the lines */
+
+    switch ( ras.state )
+    {
+    case Ascending_State:
+      if ( Line_Up( RAS_VARS ras.lastX, ras.lastY,
+                    x, y, ras.minY, ras.maxY ) )
+        return FAILURE;
+      break;
+
+    case Descending_State:
+      if ( Line_Down( RAS_VARS ras.lastX, ras.lastY,
+                      x, y, ras.minY, ras.maxY ) )
+        return FAILURE;
+      break;
+
+    default:
+      ;
+    }
+
+    ras.lastX = x;
+    ras.lastY = y;
+
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Conic_To                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Injects a new conic arc and adjusts the profile list.              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*   cx :: The x-coordinate of the arc's new control point.              */
+  /*                                                                       */
+  /*   cy :: The y-coordinate of the arc's new control point.              */
+  /*                                                                       */
+  /*   x  :: The x-coordinate of the arc's end point (its start point is   */
+  /*         stored in `LastX').                                           */
+  /*                                                                       */
+  /*   y  :: The y-coordinate of the arc's end point (its start point is   */
+  /*         stored in `LastY').                                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*   SUCCESS on success, FAILURE on render pool overflow or incorrect    */
+  /*   profile.                                                            */
+  /*                                                                       */
+  static Bool
+  Conic_To( RAS_ARGS Long  cx,
+                     Long  cy,
+                     Long  x,
+                     Long  y )
+  {
+    Long     y1, y2, y3, x3, ymin, ymax;
+    TStates  state_bez;
+
+
+    ras.arc      = ras.arcs;
+    ras.arc[2].x = ras.lastX;
+    ras.arc[2].y = ras.lastY;
+    ras.arc[1].x = cx; ras.arc[1].y = cy;
+    ras.arc[0].x = x;  ras.arc[0].y = y;
+
+    do
+    {
+      y1 = ras.arc[2].y;
+      y2 = ras.arc[1].y;
+      y3 = ras.arc[0].y;
+      x3 = ras.arc[0].x;
+
+      /* first, categorize the Bezier arc */
+
+      if ( y1 <= y3 )
+      {
+        ymin = y1;
+        ymax = y3;
+      }
+      else
+      {
+        ymin = y3;
+        ymax = y1;
+      }
+
+      if ( y2 < ymin || y2 > ymax )
+      {
+        /* this arc has no given direction, split it! */
+        Split_Conic( ras.arc );
+        ras.arc += 2;
+      }
+      else if ( y1 == y3 )
+      {
+        /* this arc is flat, ignore it and pop it from the Bezier stack */
+        ras.arc -= 2;
+      }
+      else
+      {
+        /* the arc is y-monotonous, either ascending or descending */
+        /* detect a change of direction                            */
+        state_bez = y1 < y3 ? Ascending_State : Descending_State;
+        if ( ras.state != state_bez )
+        {
+          /* finalize current profile if any */
+          if ( ras.state != Unknown_State   &&
+               End_Profile( RAS_VAR ) )
+            goto Fail;
+
+          /* create a new profile */
+          if ( New_Profile( RAS_VARS state_bez ) )
+            goto Fail;
+        }
+
+        /* now call the appropriate routine */
+        if ( state_bez == Ascending_State )
+        {
+          if ( Bezier_Up( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) )
+            goto Fail;
+        }
+        else
+          if ( Bezier_Down( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) )
+            goto Fail;
+      }
+
+    } while ( ras.arc >= ras.arcs );
+
+    ras.lastX = x3;
+    ras.lastY = y3;
+
+    return SUCCESS;
+
+  Fail:
+    return FAILURE;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Cubic_To                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Injects a new cubic arc and adjusts the profile list.              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*   cx1 :: The x-coordinate of the arc's first new control point.       */
+  /*                                                                       */
+  /*   cy1 :: The y-coordinate of the arc's first new control point.       */
+  /*                                                                       */
+  /*   cx2 :: The x-coordinate of the arc's second new control point.      */
+  /*                                                                       */
+  /*   cy2 :: The y-coordinate of the arc's second new control point.      */
+  /*                                                                       */
+  /*   x   :: The x-coordinate of the arc's end point (its start point is  */
+  /*          stored in `LastX').                                          */
+  /*                                                                       */
+  /*   y   :: The y-coordinate of the arc's end point (its start point is  */
+  /*          stored in `LastY').                                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*   SUCCESS on success, FAILURE on render pool overflow or incorrect    */
+  /*   profile.                                                            */
+  /*                                                                       */
+  static Bool
+  Cubic_To( RAS_ARGS Long  cx1,
+                     Long  cy1,
+                     Long  cx2,
+                     Long  cy2,
+                     Long  x,
+                     Long  y )
+  {
+    Long     y1, y2, y3, y4, x4, ymin1, ymax1, ymin2, ymax2;
+    TStates  state_bez;
+
+
+    ras.arc      = ras.arcs;
+    ras.arc[3].x = ras.lastX;
+    ras.arc[3].y = ras.lastY;
+    ras.arc[2].x = cx1; ras.arc[2].y = cy1;
+    ras.arc[1].x = cx2; ras.arc[1].y = cy2;
+    ras.arc[0].x = x;   ras.arc[0].y = y;
+
+    do
+    {
+      y1 = ras.arc[3].y;
+      y2 = ras.arc[2].y;
+      y3 = ras.arc[1].y;
+      y4 = ras.arc[0].y;
+      x4 = ras.arc[0].x;
+
+      /* first, categorize the Bezier arc */
+
+      if ( y1 <= y4 )
+      {
+        ymin1 = y1;
+        ymax1 = y4;
+      }
+      else
+      {
+        ymin1 = y4;
+        ymax1 = y1;
+      }
+
+      if ( y2 <= y3 )
+      {
+        ymin2 = y2;
+        ymax2 = y3;
+      }
+      else
+      {
+        ymin2 = y3;
+        ymax2 = y2;
+      }
+
+      if ( ymin2 < ymin1 || ymax2 > ymax1 )
+      {
+        /* this arc has no given direction, split it! */
+        Split_Cubic( ras.arc );
+        ras.arc += 3;
+      }
+      else if ( y1 == y4 )
+      {
+        /* this arc is flat, ignore it and pop it from the Bezier stack */
+        ras.arc -= 3;
+      }
+      else
+      {
+        state_bez = ( y1 <= y4 ) ? Ascending_State : Descending_State;
+
+        /* detect a change of direction */
+        if ( ras.state != state_bez )
+        {
+          if ( ras.state != Unknown_State   &&
+               End_Profile( RAS_VAR ) )
+            goto Fail;
+
+          if ( New_Profile( RAS_VARS state_bez ) )
+            goto Fail;
+        }
+
+        /* compute intersections */
+        if ( state_bez == Ascending_State )
+        {
+          if ( Bezier_Up( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) )
+            goto Fail;
+        }
+        else
+          if ( Bezier_Down( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) )
+            goto Fail;
+      }
+
+    } while ( ras.arc >= ras.arcs );
+
+    ras.lastX = x4;
+    ras.lastY = y4;
+
+    return SUCCESS;
+
+  Fail:
+    return FAILURE;
+  }
+
+
+#undef  SWAP_
+#define SWAP_( x, y )  do                \
+                       {                 \
+                         Long  swap = x; \
+                                         \
+                                         \
+                         x = y;          \
+                         y = swap;       \
+                       } while ( 0 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Decompose_Curve                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Scans the outline arays in order to emit individual segments and   */
+  /*    Beziers by calling Line_To() and Bezier_To().  It handles all      */
+  /*    weird cases, like when the first point is off the curve, or when   */
+  /*    there are simply no `on' points in the contour!                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    first   :: The index of the first point in the contour.            */
+  /*                                                                       */
+  /*    last    :: The index of the last point in the contour.             */
+  /*                                                                       */
+  /*    flipped :: If set, flip the direction of the curve.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success, FAILURE on error.                              */
+  /*                                                                       */
+  static Bool
+  Decompose_Curve( RAS_ARGS UShort  first,
+                            UShort  last,
+                            int     flipped )
+  {
+    FT_Vector   v_last;
+    FT_Vector   v_control;
+    FT_Vector   v_start;
+
+    FT_Vector*  points;
+    FT_Vector*  point;
+    FT_Vector*  limit;
+    char*       tags;
+
+    unsigned    tag;       /* current point's state           */
+
+
+    points = ras.outline.points;
+    limit  = points + last;
+
+    v_start.x = SCALED( points[first].x );
+    v_start.y = SCALED( points[first].y );
+    v_last.x  = SCALED( points[last].x );
+    v_last.y  = SCALED( points[last].y );
+
+    if ( flipped )
+    {
+      SWAP_( v_start.x, v_start.y );
+      SWAP_( v_last.x, v_last.y );
+    }
+
+    v_control = v_start;
+
+    point = points + first;
+    tags  = ras.outline.tags  + first;
+    tag   = FT_CURVE_TAG( tags[0] );
+
+    /* A contour cannot start with a cubic control point! */
+    if ( tag == FT_CURVE_TAG_CUBIC )
+      goto Invalid_Outline;
+
+    /* check first point to determine origin */
+    if ( tag == FT_CURVE_TAG_CONIC )
+    {
+      /* first point is conic control.  Yes, this happens. */
+      if ( FT_CURVE_TAG( ras.outline.tags[last] ) == FT_CURVE_TAG_ON )
+      {
+        /* start at last point if it is on the curve */
+        v_start = v_last;
+        limit--;
+      }
+      else
+      {
+        /* if both first and last points are conic,         */
+        /* start at their middle and record its position    */
+        /* for closure                                      */
+        v_start.x = ( v_start.x + v_last.x ) / 2;
+        v_start.y = ( v_start.y + v_last.y ) / 2;
+
+        v_last = v_start;
+      }
+      point--;
+      tags--;
+    }
+
+    ras.lastX = v_start.x;
+    ras.lastY = v_start.y;
+
+    while ( point < limit )
+    {
+      point++;
+      tags++;
+
+      tag = FT_CURVE_TAG( tags[0] );
+
+      switch ( tag )
+      {
+      case FT_CURVE_TAG_ON:  /* emit a single line_to */
+        {
+          Long  x, y;
+
+
+          x = SCALED( point->x );
+          y = SCALED( point->y );
+          if ( flipped )
+            SWAP_( x, y );
+
+          if ( Line_To( RAS_VARS x, y ) )
+            goto Fail;
+          continue;
+        }
+
+      case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
+        v_control.x = SCALED( point[0].x );
+        v_control.y = SCALED( point[0].y );
+
+        if ( flipped )
+          SWAP_( v_control.x, v_control.y );
+
+      Do_Conic:
+        if ( point < limit )
+        {
+          FT_Vector  v_middle;
+          Long       x, y;
+
+
+          point++;
+          tags++;
+          tag = FT_CURVE_TAG( tags[0] );
+
+          x = SCALED( point[0].x );
+          y = SCALED( point[0].y );
+
+          if ( flipped )
+            SWAP_( x, y );
+
+          if ( tag == FT_CURVE_TAG_ON )
+          {
+            if ( Conic_To( RAS_VARS v_control.x, v_control.y, x, y ) )
+              goto Fail;
+            continue;
+          }
+
+          if ( tag != FT_CURVE_TAG_CONIC )
+            goto Invalid_Outline;
+
+          v_middle.x = ( v_control.x + x ) / 2;
+          v_middle.y = ( v_control.y + y ) / 2;
+
+          if ( Conic_To( RAS_VARS v_control.x, v_control.y,
+                                  v_middle.x,  v_middle.y ) )
+            goto Fail;
+
+          v_control.x = x;
+          v_control.y = y;
+
+          goto Do_Conic;
+        }
+
+        if ( Conic_To( RAS_VARS v_control.x, v_control.y,
+                                v_start.x,   v_start.y ) )
+          goto Fail;
+
+        goto Close;
+
+      default:  /* FT_CURVE_TAG_CUBIC */
+        {
+          Long  x1, y1, x2, y2, x3, y3;
+
+
+          if ( point + 1 > limit                             ||
+               FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
+            goto Invalid_Outline;
+
+          point += 2;
+          tags  += 2;
+
+          x1 = SCALED( point[-2].x );
+          y1 = SCALED( point[-2].y );
+          x2 = SCALED( point[-1].x );
+          y2 = SCALED( point[-1].y );
+          x3 = SCALED( point[ 0].x );
+          y3 = SCALED( point[ 0].y );
+
+          if ( flipped )
+          {
+            SWAP_( x1, y1 );
+            SWAP_( x2, y2 );
+            SWAP_( x3, y3 );
+          }
+
+          if ( point <= limit )
+          {
+            if ( Cubic_To( RAS_VARS x1, y1, x2, y2, x3, y3 ) )
+              goto Fail;
+            continue;
+          }
+
+          if ( Cubic_To( RAS_VARS x1, y1, x2, y2, v_start.x, v_start.y ) )
+            goto Fail;
+          goto Close;
+        }
+      }
+    }
+
+    /* close the contour with a line segment */
+    if ( Line_To( RAS_VARS v_start.x, v_start.y ) )
+      goto Fail;
+
+  Close:
+    return SUCCESS;
+
+  Invalid_Outline:
+    ras.error = Raster_Err_Invalid;
+
+  Fail:
+    return FAILURE;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Convert_Glyph                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts a glyph into a series of segments and arcs and makes a    */
+  /*    profiles list with them.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    flipped :: If set, flip the direction of curve.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS on success, FAILURE if any error was encountered during    */
+  /*    rendering.                                                         */
+  /*                                                                       */
+  static Bool
+  Convert_Glyph( RAS_ARGS int  flipped )
+  {
+    int       i;
+    unsigned  start;
+
+    PProfile  lastProfile;
+
+
+    ras.fProfile = NULL;
+    ras.joint    = FALSE;
+    ras.fresh    = FALSE;
+
+    ras.maxBuff  = ras.sizeBuff - AlignProfileSize;
+
+    ras.numTurns = 0;
+
+    ras.cProfile         = (PProfile)ras.top;
+    ras.cProfile->offset = ras.top;
+    ras.num_Profs        = 0;
+
+    start = 0;
+
+    for ( i = 0; i < ras.outline.n_contours; i++ )
+    {
+      ras.state    = Unknown_State;
+      ras.gProfile = NULL;
+
+      if ( Decompose_Curve( RAS_VARS (unsigned short)start,
+                            ras.outline.contours[i],
+                            flipped ) )
+        return FAILURE;
+
+      start = ras.outline.contours[i] + 1;
+
+      /* We must now see whether the extreme arcs join or not */
+      if ( FRAC( ras.lastY ) == 0 &&
+           ras.lastY >= ras.minY  &&
+           ras.lastY <= ras.maxY  )
+        if ( ras.gProfile && ras.gProfile->flow == ras.cProfile->flow )
+          ras.top--;
+        /* Note that ras.gProfile can be nil if the contour was too small */
+        /* to be drawn.                                                   */
+
+      lastProfile = ras.cProfile;
+      if ( End_Profile( RAS_VAR ) )
+        return FAILURE;
+
+      /* close the `next profile in contour' linked list */
+      if ( ras.gProfile )
+        lastProfile->next = ras.gProfile;
+    }
+
+    if ( Finalize_Profile_Table( RAS_VAR ) )
+      return FAILURE;
+
+    return (Bool)( ras.top < ras.maxBuff ? SUCCESS : FAILURE );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /**                                                                     **/
+  /**  SCAN-LINE SWEEPS AND DRAWING                                       **/
+  /**                                                                     **/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Init_Linked                                                          */
+  /*                                                                       */
+  /*    Initializes an empty linked list.                                  */
+  /*                                                                       */
+  static void
+  Init_Linked( TProfileList*  l )
+  {
+    *l = NULL;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  InsNew                                                               */
+  /*                                                                       */
+  /*    Inserts a new profile in a linked list.                            */
+  /*                                                                       */
+  static void
+  InsNew( PProfileList  list,
+          PProfile      profile )
+  {
+    PProfile  *old, current;
+    Long       x;
+
+
+    old     = list;
+    current = *old;
+    x       = profile->X;
+
+    while ( current )
+    {
+      if ( x < current->X )
+        break;
+      old     = &current->link;
+      current = *old;
+    }
+
+    profile->link = current;
+    *old          = profile;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  DelOld                                                               */
+  /*                                                                       */
+  /*    Removes an old profile from a linked list.                         */
+  /*                                                                       */
+  static void
+  DelOld( PProfileList  list,
+          PProfile      profile )
+  {
+    PProfile  *old, current;
+
+
+    old     = list;
+    current = *old;
+
+    while ( current )
+    {
+      if ( current == profile )
+      {
+        *old = current->link;
+        return;
+      }
+
+      old     = &current->link;
+      current = *old;
+    }
+
+    /* we should never get there, unless the profile was not part of */
+    /* the list.                                                     */
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Sort                                                                 */
+  /*                                                                       */
+  /*    Sorts a trace list.  In 95%, the list is already sorted.  We need  */
+  /*    an algorithm which is fast in this case.  Bubble sort is enough    */
+  /*    and simple.                                                        */
+  /*                                                                       */
+  static void
+  Sort( PProfileList  list )
+  {
+    PProfile  *old, current, next;
+
+
+    /* First, set the new X coordinate of each profile */
+    current = *list;
+    while ( current )
+    {
+      current->X       = *current->offset;
+      current->offset += current->flow;
+      current->height--;
+      current = current->link;
+    }
+
+    /* Then sort them */
+    old     = list;
+    current = *old;
+
+    if ( !current )
+      return;
+
+    next = current->link;
+
+    while ( next )
+    {
+      if ( current->X <= next->X )
+      {
+        old     = &current->link;
+        current = *old;
+
+        if ( !current )
+          return;
+      }
+      else
+      {
+        *old          = next;
+        current->link = next->link;
+        next->link    = current;
+
+        old     = list;
+        current = *old;
+      }
+
+      next = current->link;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Vertical Sweep Procedure Set                                         */
+  /*                                                                       */
+  /*  These four routines are used during the vertical black/white sweep   */
+  /*  phase by the generic Draw_Sweep() function.                          */
+  /*                                                                       */
+  /*************************************************************************/
+
+  static void
+  Vertical_Sweep_Init( RAS_ARGS Short*  min,
+                                Short*  max )
+  {
+    Long  pitch = ras.target.pitch;
+
+    FT_UNUSED( max );
+
+
+    ras.traceIncr = (Short)-pitch;
+    ras.traceOfs  = -*min * pitch;
+    if ( pitch > 0 )
+      ras.traceOfs += ( ras.target.rows - 1 ) * pitch;
+
+    ras.gray_min_x = 0;
+    ras.gray_max_x = 0;
+  }
+
+
+  static void
+  Vertical_Sweep_Span( RAS_ARGS Short       y,
+                                FT_F26Dot6  x1,
+                                FT_F26Dot6  x2,
+                                PProfile    left,
+                                PProfile    right )
+  {
+    Long   e1, e2;
+    int    c1, c2;
+    Byte   f1, f2;
+    Byte*  target;
+
+    FT_UNUSED( y );
+    FT_UNUSED( left );
+    FT_UNUSED( right );
+
+
+    /* Drop-out control */
+
+    e1 = TRUNC( CEILING( x1 ) );
+
+    if ( x2 - x1 - ras.precision <= ras.precision_jitter )
+      e2 = e1;
+    else
+      e2 = TRUNC( FLOOR( x2 ) );
+
+    if ( e2 >= 0 && e1 < ras.bWidth )
+    {
+      if ( e1 < 0 )
+        e1 = 0;
+      if ( e2 >= ras.bWidth )
+        e2 = ras.bWidth - 1;
+
+      c1 = (Short)( e1 >> 3 );
+      c2 = (Short)( e2 >> 3 );
+
+      f1 = (Byte)  ( 0xFF >> ( e1 & 7 ) );
+      f2 = (Byte) ~( 0x7F >> ( e2 & 7 ) );
+
+      if ( ras.gray_min_x > c1 ) ras.gray_min_x = (short)c1;
+      if ( ras.gray_max_x < c2 ) ras.gray_max_x = (short)c2;
+
+      target = ras.bTarget + ras.traceOfs + c1;
+      c2 -= c1;
+
+      if ( c2 > 0 )
+      {
+        target[0] |= f1;
+
+        /* memset() is slower than the following code on many platforms. */
+        /* This is due to the fact that, in the vast majority of cases,  */
+        /* the span length in bytes is relatively small.                 */
+        c2--;
+        while ( c2 > 0 )
+        {
+          *(++target) = 0xFF;
+          c2--;
+        }
+        target[1] |= f2;
+      }
+      else
+        *target |= ( f1 & f2 );
+    }
+  }
+
+
+  static void
+  Vertical_Sweep_Drop( RAS_ARGS Short       y,
+                                FT_F26Dot6  x1,
+                                FT_F26Dot6  x2,
+                                PProfile    left,
+                                PProfile    right )
+  {
+    Long   e1, e2;
+    Short  c1, f1;
+
+
+    /* Drop-out control */
+
+    e1 = CEILING( x1 );
+    e2 = FLOOR  ( x2 );
+
+    if ( e1 > e2 )
+    {
+      if ( e1 == e2 + ras.precision )
+      {
+        switch ( ras.dropOutControl )
+        {
+        case 1:
+          e1 = e2;
+          break;
+
+        case 4:
+          e1 = CEILING( (x1 + x2 + 1) / 2 );
+          break;
+
+        case 2:
+        case 5:
+          /* Drop-out Control Rule #4 */
+
+          /* The spec is not very clear regarding rule #4.  It      */
+          /* presents a method that is way too costly to implement  */
+          /* while the general idea seems to get rid of `stubs'.    */
+          /*                                                        */
+          /* Here, we only get rid of stubs recognized if:          */
+          /*                                                        */
+          /*  upper stub:                                           */
+          /*                                                        */
+          /*   - P_Left and P_Right are in the same contour         */
+          /*   - P_Right is the successor of P_Left in that contour */
+          /*   - y is the top of P_Left and P_Right                 */
+          /*                                                        */
+          /*  lower stub:                                           */
+          /*                                                        */
+          /*   - P_Left and P_Right are in the same contour         */
+          /*   - P_Left is the successor of P_Right in that contour */
+          /*   - y is the bottom of P_Left                          */
+          /*                                                        */
+
+          /* FIXXXME: uncommenting this line solves the disappearing */
+          /*          bit problem in the `7' of verdana 10pts, but   */
+          /*          makes a new one in the `C' of arial 14pts      */
+
+#if 0
+          if ( x2 - x1 < ras.precision_half )
+#endif
+          {
+            /* upper stub test */
+            if ( left->next == right && left->height <= 0 )
+              return;
+
+            /* lower stub test */
+            if ( right->next == left && left->start == y )
+              return;
+          }
+
+          /* check that the rightmost pixel isn't set */
+
+          e1 = TRUNC( e1 );
+
+          c1 = (Short)( e1 >> 3 );
+          f1 = (Short)( e1 &  7 );
+
+          if ( e1 >= 0 && e1 < ras.bWidth                      &&
+               ras.bTarget[ras.traceOfs + c1] & ( 0x80 >> f1 ) )
+            return;
+
+          if ( ras.dropOutControl == 2 )
+            e1 = e2;
+          else
+            e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
+
+          break;
+
+        default:
+          return;  /* unsupported mode */
+        }
+      }
+      else
+        return;
+    }
+
+    e1 = TRUNC( e1 );
+
+    if ( e1 >= 0 && e1 < ras.bWidth )
+    {
+      c1 = (Short)( e1 >> 3 );
+      f1 = (Short)( e1 & 7 );
+
+      if ( ras.gray_min_x > c1 ) ras.gray_min_x = c1;
+      if ( ras.gray_max_x < c1 ) ras.gray_max_x = c1;
+
+      ras.bTarget[ras.traceOfs + c1] |= (char)( 0x80 >> f1 );
+    }
+  }
+
+
+  static void
+  Vertical_Sweep_Step( RAS_ARG )
+  {
+    ras.traceOfs += ras.traceIncr;
+  }
+
+
+  /***********************************************************************/
+  /*                                                                     */
+  /*  Horizontal Sweep Procedure Set                                     */
+  /*                                                                     */
+  /*  These four routines are used during the horizontal black/white     */
+  /*  sweep phase by the generic Draw_Sweep() function.                  */
+  /*                                                                     */
+  /***********************************************************************/
+
+  static void
+  Horizontal_Sweep_Init( RAS_ARGS Short*  min,
+                                  Short*  max )
+  {
+    /* nothing, really */
+    FT_UNUSED( raster );
+    FT_UNUSED( min );
+    FT_UNUSED( max );
+  }
+
+
+  static void
+  Horizontal_Sweep_Span( RAS_ARGS Short       y,
+                                  FT_F26Dot6  x1,
+                                  FT_F26Dot6  x2,
+                                  PProfile    left,
+                                  PProfile    right )
+  {
+    Long   e1, e2;
+    PByte  bits;
+    Byte   f1;
+
+    FT_UNUSED( left );
+    FT_UNUSED( right );
+
+
+    if ( x2 - x1 < ras.precision )
+    {
+      e1 = CEILING( x1 );
+      e2 = FLOOR  ( x2 );
+
+      if ( e1 == e2 )
+      {
+        bits = ras.bTarget + ( y >> 3 );
+        f1   = (Byte)( 0x80 >> ( y & 7 ) );
+
+        e1 = TRUNC( e1 );
+
+        if ( e1 >= 0 && e1 < ras.target.rows )
+        {
+          PByte  p;
+
+
+          p = bits - e1*ras.target.pitch;
+          if ( ras.target.pitch > 0 )
+            p += ( ras.target.rows - 1 ) * ras.target.pitch;
+
+          p[0] |= f1;
+        }
+      }
+    }
+  }
+
+
+  static void
+  Horizontal_Sweep_Drop( RAS_ARGS Short       y,
+                                  FT_F26Dot6  x1,
+                                  FT_F26Dot6  x2,
+                                  PProfile    left,
+                                  PProfile    right )
+  {
+    Long   e1, e2;
+    PByte  bits;
+    Byte   f1;
+
+
+    /* During the horizontal sweep, we only take care of drop-outs */
+
+    e1 = CEILING( x1 );
+    e2 = FLOOR  ( x2 );
+
+    if ( e1 > e2 )
+    {
+      if ( e1 == e2 + ras.precision )
+      {
+        switch ( ras.dropOutControl )
+        {
+        case 1:
+          e1 = e2;
+          break;
+
+        case 4:
+          e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
+          break;
+
+        case 2:
+        case 5:
+
+          /* Drop-out Control Rule #4 */
+
+          /* The spec is not very clear regarding rule #4.  It      */
+          /* presents a method that is way too costly to implement  */
+          /* while the general idea seems to get rid of `stubs'.    */
+          /*                                                        */
+
+          /* rightmost stub test */
+          if ( left->next == right && left->height <= 0 )
+            return;
+
+          /* leftmost stub test */
+          if ( right->next == left && left->start == y )
+            return;
+
+          /* check that the rightmost pixel isn't set */
+
+          e1 = TRUNC( e1 );
+
+          bits = ras.bTarget + ( y >> 3 );
+          f1   = (Byte)( 0x80 >> ( y & 7 ) );
+
+          bits -= e1 * ras.target.pitch;
+          if ( ras.target.pitch > 0 )
+            bits += ( ras.target.rows - 1 ) * ras.target.pitch;
+
+          if ( e1 >= 0              &&
+               e1 < ras.target.rows &&
+               *bits & f1 )
+            return;
+
+          if ( ras.dropOutControl == 2 )
+            e1 = e2;
+          else
+            e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
+
+          break;
+
+        default:
+          return;  /* unsupported mode */
+        }
+      }
+      else
+        return;
+    }
+
+    bits = ras.bTarget + ( y >> 3 );
+    f1   = (Byte)( 0x80 >> ( y & 7 ) );
+
+    e1 = TRUNC( e1 );
+
+    if ( e1 >= 0 && e1 < ras.target.rows )
+    {
+      bits -= e1 * ras.target.pitch;
+      if ( ras.target.pitch > 0 )
+        bits += ( ras.target.rows - 1 ) * ras.target.pitch;
+
+      bits[0] |= f1;
+    }
+  }
+
+
+  static void
+  Horizontal_Sweep_Step( RAS_ARG )
+  {
+    /* Nothing, really */
+    FT_UNUSED( raster );
+  }
+
+
+#ifdef FT_RASTER_OPTION_ANTI_ALIASING
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Vertical Gray Sweep Procedure Set                                    */
+  /*                                                                       */
+  /*  These two routines are used during the vertical gray-levels sweep    */
+  /*  phase by the generic Draw_Sweep() function.                          */
+  /*                                                                       */
+  /*  NOTES                                                                */
+  /*                                                                       */
+  /*  - The target pixmap's width *must* be a multiple of 4.               */
+  /*                                                                       */
+  /*  - You have to use the function Vertical_Sweep_Span() for the gray    */
+  /*    span call.                                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+  static void
+  Vertical_Gray_Sweep_Init( RAS_ARGS Short*  min,
+                                     Short*  max )
+  {
+    Long  pitch, byte_len;
+
+
+    *min = *min & -2;
+    *max = ( *max + 3 ) & -2;
+
+    ras.traceOfs  = 0;
+    pitch         = ras.target.pitch;
+    byte_len      = -pitch;
+    ras.traceIncr = (Short)byte_len;
+    ras.traceG    = ( *min / 2 ) * byte_len;
+
+    if ( pitch > 0 )
+    {
+      ras.traceG += ( ras.target.rows - 1 ) * pitch;
+      byte_len    = -byte_len;
+    }
+
+    ras.gray_min_x =  (Short)byte_len;
+    ras.gray_max_x = -(Short)byte_len;
+  }
+
+
+  static void
+  Vertical_Gray_Sweep_Step( RAS_ARG )
+  {
+    Int    c1, c2;
+    PByte  pix, bit, bit2;
+    Int*   count = ras.count_table;
+    Byte*  grays;
+
+
+    ras.traceOfs += ras.gray_width;
+
+    if ( ras.traceOfs > ras.gray_width )
+    {
+      pix   = ras.gTarget + ras.traceG + ras.gray_min_x * 4;
+      grays = ras.grays;
+
+      if ( ras.gray_max_x >= 0 )
+      {
+        Long   last_pixel = ras.target.width - 1;
+        Int    last_cell  = last_pixel >> 2;
+        Int    last_bit   = last_pixel & 3;
+        Bool   over       = 0;
+
+
+        if ( ras.gray_max_x >= last_cell && last_bit != 3 )
+        {
+          ras.gray_max_x = last_cell - 1;
+          over = 1;
+        }
+
+        if ( ras.gray_min_x < 0 )
+          ras.gray_min_x = 0;
+
+        bit   = ras.bTarget + ras.gray_min_x;
+        bit2  = bit + ras.gray_width;
+
+        c1 = ras.gray_max_x - ras.gray_min_x;
+
+        while ( c1 >= 0 )
+        {
+          c2 = count[*bit] + count[*bit2];
+
+          if ( c2 )
+          {
+            pix[0] = grays[(c2 >> 12) & 0x000F];
+            pix[1] = grays[(c2 >> 8 ) & 0x000F];
+            pix[2] = grays[(c2 >> 4 ) & 0x000F];
+            pix[3] = grays[ c2        & 0x000F];
+
+            *bit  = 0;
+            *bit2 = 0;
+          }
+
+          bit++;
+          bit2++;
+          pix += 4;
+          c1--;
+        }
+
+        if ( over )
+        {
+          c2 = count[*bit] + count[*bit2];
+          if ( c2 )
+          {
+            switch ( last_bit )
+            {
+            case 2:
+              pix[2] = grays[(c2 >> 4 ) & 0x000F];
+            case 1:
+              pix[1] = grays[(c2 >> 8 ) & 0x000F];
+            default:
+              pix[0] = grays[(c2 >> 12) & 0x000F];
+            }
+
+            *bit  = 0;
+            *bit2 = 0;
+          }
+        }
+      }
+
+      ras.traceOfs = 0;
+      ras.traceG  += ras.traceIncr;
+
+      ras.gray_min_x =  32000;
+      ras.gray_max_x = -32000;
+    }
+  }
+
+
+  static void
+  Horizontal_Gray_Sweep_Span( RAS_ARGS Short       y,
+                                       FT_F26Dot6  x1,
+                                       FT_F26Dot6  x2,
+                                       PProfile    left,
+                                       PProfile    right )
+  {
+    /* nothing, really */
+    FT_UNUSED( raster );
+    FT_UNUSED( y );
+    FT_UNUSED( x1 );
+    FT_UNUSED( x2 );
+    FT_UNUSED( left );
+    FT_UNUSED( right );
+  }
+
+
+  static void
+  Horizontal_Gray_Sweep_Drop( RAS_ARGS Short       y,
+                                       FT_F26Dot6  x1,
+                                       FT_F26Dot6  x2,
+                                       PProfile    left,
+                                       PProfile    right )
+  {
+    Long   e1, e2;
+    PByte  pixel;
+    Byte   color;
+
+
+    /* During the horizontal sweep, we only take care of drop-outs */
+    e1 = CEILING( x1 );
+    e2 = FLOOR  ( x2 );
+
+    if ( e1 > e2 )
+    {
+      if ( e1 == e2 + ras.precision )
+      {
+        switch ( ras.dropOutControl )
+        {
+        case 1:
+          e1 = e2;
+          break;
+
+        case 4:
+          e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
+          break;
+
+        case 2:
+        case 5:
+
+          /* Drop-out Control Rule #4 */
+
+          /* The spec is not very clear regarding rule #4.  It      */
+          /* presents a method that is way too costly to implement  */
+          /* while the general idea seems to get rid of `stubs'.    */
+          /*                                                        */
+
+          /* rightmost stub test */
+          if ( left->next == right && left->height <= 0 )
+            return;
+
+          /* leftmost stub test */
+          if ( right->next == left && left->start == y )
+            return;
+
+          if ( ras.dropOutControl == 2 )
+            e1 = e2;
+          else
+            e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
+
+          break;
+
+        default:
+          return;  /* unsupported mode */
+        }
+      }
+      else
+        return;
+    }
+
+    if ( e1 >= 0 )
+    {
+      if ( x2 - x1 >= ras.precision_half )
+        color = ras.grays[2];
+      else
+        color = ras.grays[1];
+
+      e1 = TRUNC( e1 ) / 2;
+      if ( e1 < ras.target.rows )
+      {
+        pixel = ras.gTarget - e1 * ras.target.pitch + y / 2;
+        if ( ras.target.pitch > 0 )
+          pixel += ( ras.target.rows - 1 ) * ras.target.pitch;
+
+        if ( pixel[0] == ras.grays[0] )
+          pixel[0] = color;
+      }
+    }
+  }
+
+
+#endif /* FT_RASTER_OPTION_ANTI_ALIASING */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Generic Sweep Drawing routine                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+  static Bool
+  Draw_Sweep( RAS_ARG )
+  {
+    Short         y, y_change, y_height;
+
+    PProfile      P, Q, P_Left, P_Right;
+
+    Short         min_Y, max_Y, top, bottom, dropouts;
+
+    Long          x1, x2, xs, e1, e2;
+
+    TProfileList  waiting;
+    TProfileList  draw_left, draw_right;
+
+
+    /* Init empty linked lists */
+
+    Init_Linked( &waiting );
+
+    Init_Linked( &draw_left  );
+    Init_Linked( &draw_right );
+
+    /* first, compute min and max Y */
+
+    P     = ras.fProfile;
+    max_Y = (Short)TRUNC( ras.minY );
+    min_Y = (Short)TRUNC( ras.maxY );
+
+    while ( P )
+    {
+      Q = P->link;
+
+      bottom = (Short)P->start;
+      top    = (Short)( P->start + P->height - 1 );
+
+      if ( min_Y > bottom ) min_Y = bottom;
+      if ( max_Y < top    ) max_Y = top;
+
+      P->X = 0;
+      InsNew( &waiting, P );
+
+      P = Q;
+    }
+
+    /* Check the Y-turns */
+    if ( ras.numTurns == 0 )
+    {
+      ras.error = Raster_Err_Invalid;
+      return FAILURE;
+    }
+
+    /* Now inits the sweep */
+
+    ras.Proc_Sweep_Init( RAS_VARS &min_Y, &max_Y );
+
+    /* Then compute the distance of each profile from min_Y */
+
+    P = waiting;
+
+    while ( P )
+    {
+      P->countL = (UShort)( P->start - min_Y );
+      P = P->link;
+    }
+
+    /* Let's go */
+
+    y        = min_Y;
+    y_height = 0;
+
+    if ( ras.numTurns > 0 &&
+         ras.sizeBuff[-ras.numTurns] == min_Y )
+      ras.numTurns--;
+
+    while ( ras.numTurns > 0 )
+    {
+      /* look in the waiting list for new activations */
+
+      P = waiting;
+
+      while ( P )
+      {
+        Q = P->link;
+        P->countL -= y_height;
+        if ( P->countL == 0 )
+        {
+          DelOld( &waiting, P );
+
+          switch ( P->flow )
+          {
+          case Flow_Up:
+            InsNew( &draw_left,  P );
+            break;
+
+          case Flow_Down:
+            InsNew( &draw_right, P );
+            break;
+          }
+        }
+
+        P = Q;
+      }
+
+      /* Sort the drawing lists */
+
+      Sort( &draw_left );
+      Sort( &draw_right );
+
+      y_change = (Short)ras.sizeBuff[-ras.numTurns--];
+      y_height = (Short)( y_change - y );
+
+      while ( y < y_change )
+      {
+        /* Let's trace */
+
+        dropouts = 0;
+
+        P_Left  = draw_left;
+        P_Right = draw_right;
+
+        while ( P_Left )
+        {
+          x1 = P_Left ->X;
+          x2 = P_Right->X;
+
+          if ( x1 > x2 )
+          {
+            xs = x1;
+            x1 = x2;
+            x2 = xs;
+          }
+
+          if ( x2 - x1 <= ras.precision )
+          {
+            e1 = FLOOR( x1 );
+            e2 = CEILING( x2 );
+
+            if ( ras.dropOutControl != 0                 &&
+                 ( e1 > e2 || e2 == e1 + ras.precision ) )
+            {
+              /* a drop out was detected */
+
+              P_Left ->X = x1;
+              P_Right->X = x2;
+
+              /* mark profile for drop-out processing */
+              P_Left->countL = 1;
+              dropouts++;
+
+              goto Skip_To_Next;
+            }
+          }
+
+          ras.Proc_Sweep_Span( RAS_VARS y, x1, x2, P_Left, P_Right );
+
+        Skip_To_Next:
+
+          P_Left  = P_Left->link;
+          P_Right = P_Right->link;
+        }
+
+        /* now perform the dropouts _after_ the span drawing -- */
+        /* drop-outs processing has been moved out of the loop  */
+        /* for performance tuning                               */
+        if ( dropouts > 0 )
+          goto Scan_DropOuts;
+
+      Next_Line:
+
+        ras.Proc_Sweep_Step( RAS_VAR );
+
+        y++;
+
+        if ( y < y_change )
+        {
+          Sort( &draw_left  );
+          Sort( &draw_right );
+        }
+      }
+
+      /* Now finalize the profiles that needs it */
+
+      P = draw_left;
+      while ( P )
+      {
+        Q = P->link;
+        if ( P->height == 0 )
+          DelOld( &draw_left, P );
+        P = Q;
+      }
+
+      P = draw_right;
+      while ( P )
+      {
+        Q = P->link;
+        if ( P->height == 0 )
+          DelOld( &draw_right, P );
+        P = Q;
+      }
+    }
+
+    /* for gray-scaling, flushes the bitmap scanline cache */
+    while ( y <= max_Y )
+    {
+      ras.Proc_Sweep_Step( RAS_VAR );
+      y++;
+    }
+
+    return SUCCESS;
+
+  Scan_DropOuts:
+
+    P_Left  = draw_left;
+    P_Right = draw_right;
+
+    while ( P_Left )
+    {
+      if ( P_Left->countL )
+      {
+        P_Left->countL = 0;
+#if 0
+        dropouts--;  /* -- this is useful when debugging only */
+#endif
+        ras.Proc_Sweep_Drop( RAS_VARS y,
+                                      P_Left->X,
+                                      P_Right->X,
+                                      P_Left,
+                                      P_Right );
+      }
+
+      P_Left  = P_Left->link;
+      P_Right = P_Right->link;
+    }
+
+    goto Next_Line;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Render_Single_Pass                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Performs one sweep with sub-banding.                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    flipped :: If set, flip the direction of the outline.              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Renderer error code.                                               */
+  /*                                                                       */
+  static int
+  Render_Single_Pass( RAS_ARGS Bool  flipped )
+  {
+    Short  i, j, k;
+
+
+    while ( ras.band_top >= 0 )
+    {
+      ras.maxY = (Long)ras.band_stack[ras.band_top].y_max * ras.precision;
+      ras.minY = (Long)ras.band_stack[ras.band_top].y_min * ras.precision;
+
+      ras.top = ras.buff;
+
+      ras.error = Raster_Err_None;
+
+      if ( Convert_Glyph( RAS_VARS flipped ) )
+      {
+        if ( ras.error != Raster_Err_Overflow )
+          return FAILURE;
+
+        ras.error = Raster_Err_None;
+
+        /* sub-banding */
+
+#ifdef DEBUG_RASTER
+        ClearBand( RAS_VARS TRUNC( ras.minY ), TRUNC( ras.maxY ) );
+#endif
+
+        i = ras.band_stack[ras.band_top].y_min;
+        j = ras.band_stack[ras.band_top].y_max;
+
+        k = (Short)( ( i + j ) / 2 );
+
+        if ( ras.band_top >= 7 || k < i )
+        {
+          ras.band_top = 0;
+          ras.error    = Raster_Err_Invalid;
+
+          return ras.error;
+        }
+
+        ras.band_stack[ras.band_top + 1].y_min = k;
+        ras.band_stack[ras.band_top + 1].y_max = j;
+
+        ras.band_stack[ras.band_top].y_max = (Short)( k - 1 );
+
+        ras.band_top++;
+      }
+      else
+      {
+        if ( ras.fProfile )
+          if ( Draw_Sweep( RAS_VAR ) )
+             return ras.error;
+        ras.band_top--;
+      }
+    }
+
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Render_Glyph                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Renders a glyph in a bitmap.  Sub-banding if needed.               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  Render_Glyph( RAS_ARG )
+  {
+    FT_Error  error;
+
+
+    Set_High_Precision( RAS_VARS ras.outline.flags &
+                        FT_OUTLINE_HIGH_PRECISION );
+    ras.scale_shift    = ras.precision_shift;
+    ras.dropOutControl = 2;
+    ras.second_pass    = (FT_Byte)( !( ras.outline.flags &
+                                       FT_OUTLINE_SINGLE_PASS ) );
+
+    /* Vertical Sweep */
+    ras.Proc_Sweep_Init = Vertical_Sweep_Init;
+    ras.Proc_Sweep_Span = Vertical_Sweep_Span;
+    ras.Proc_Sweep_Drop = Vertical_Sweep_Drop;
+    ras.Proc_Sweep_Step = Vertical_Sweep_Step;
+
+    ras.band_top            = 0;
+    ras.band_stack[0].y_min = 0;
+    ras.band_stack[0].y_max = (short)( ras.target.rows - 1 );
+
+    ras.bWidth  = (unsigned short)ras.target.width;
+    ras.bTarget = (Byte*)ras.target.buffer;
+
+    if ( ( error = Render_Single_Pass( RAS_VARS 0 ) ) != 0 )
+      return error;
+
+    /* Horizontal Sweep */
+    if ( ras.second_pass && ras.dropOutControl != 0 )
+    {
+      ras.Proc_Sweep_Init = Horizontal_Sweep_Init;
+      ras.Proc_Sweep_Span = Horizontal_Sweep_Span;
+      ras.Proc_Sweep_Drop = Horizontal_Sweep_Drop;
+      ras.Proc_Sweep_Step = Horizontal_Sweep_Step;
+
+      ras.band_top            = 0;
+      ras.band_stack[0].y_min = 0;
+      ras.band_stack[0].y_max = (short)( ras.target.width - 1 );
+
+      if ( ( error = Render_Single_Pass( RAS_VARS 1 ) ) != 0 )
+        return error;
+    }
+
+    return Raster_Err_Ok;
+  }
+
+
+#ifdef FT_RASTER_OPTION_ANTI_ALIASING
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Render_Gray_Glyph                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Renders a glyph with grayscaling.  Sub-banding if needed.          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  Render_Gray_Glyph( RAS_ARG )
+  {
+    Long      pixel_width;
+    FT_Error  error;
+
+
+    Set_High_Precision( RAS_VARS ras.outline.flags &
+                        FT_OUTLINE_HIGH_PRECISION );
+    ras.scale_shift    = ras.precision_shift + 1;
+    ras.dropOutControl = 2;
+    ras.second_pass    = !( ras.outline.flags & FT_OUTLINE_SINGLE_PASS );
+
+    /* Vertical Sweep */
+
+    ras.band_top            = 0;
+    ras.band_stack[0].y_min = 0;
+    ras.band_stack[0].y_max = 2 * ras.target.rows - 1;
+
+    ras.bWidth  = ras.gray_width;
+    pixel_width = 2 * ( ( ras.target.width + 3 ) >> 2 );
+
+    if ( ras.bWidth > pixel_width )
+      ras.bWidth = pixel_width;
+
+    ras.bWidth  = ras.bWidth * 8;
+    ras.bTarget = (Byte*)ras.gray_lines;
+    ras.gTarget = (Byte*)ras.target.buffer;
+
+    ras.Proc_Sweep_Init = Vertical_Gray_Sweep_Init;
+    ras.Proc_Sweep_Span = Vertical_Sweep_Span;
+    ras.Proc_Sweep_Drop = Vertical_Sweep_Drop;
+    ras.Proc_Sweep_Step = Vertical_Gray_Sweep_Step;
+
+    error = Render_Single_Pass( RAS_VARS 0 );
+    if ( error )
+      return error;
+
+    /* Horizontal Sweep */
+    if ( ras.second_pass && ras.dropOutControl != 0 )
+    {
+      ras.Proc_Sweep_Init = Horizontal_Sweep_Init;
+      ras.Proc_Sweep_Span = Horizontal_Gray_Sweep_Span;
+      ras.Proc_Sweep_Drop = Horizontal_Gray_Sweep_Drop;
+      ras.Proc_Sweep_Step = Horizontal_Sweep_Step;
+
+      ras.band_top            = 0;
+      ras.band_stack[0].y_min = 0;
+      ras.band_stack[0].y_max = ras.target.width * 2 - 1;
+
+      error = Render_Single_Pass( RAS_VARS 1 );
+      if ( error )
+        return error;
+    }
+
+    return Raster_Err_Ok;
+  }
+
+#else /* !FT_RASTER_OPTION_ANTI_ALIASING */
+
+  FT_LOCAL_DEF( FT_Error )
+  Render_Gray_Glyph( RAS_ARG )
+  {
+    FT_UNUSED_RASTER;
+
+    return Raster_Err_Cannot_Render_Glyph;
+  }
+
+#endif /* !FT_RASTER_OPTION_ANTI_ALIASING */
+
+
+  static void
+  ft_black_init( TRaster_Instance*  raster )
+  {
+    FT_UInt  n;
+    FT_ULong c;
+
+
+    /* setup count table */
+    for ( n = 0; n < 256; n++ )
+    {
+      c = ( n & 0x55 ) + ( ( n & 0xAA ) >> 1 );
+
+      c = ( ( c << 6 ) & 0x3000 ) |
+          ( ( c << 4 ) & 0x0300 ) |
+          ( ( c << 2 ) & 0x0030 ) |
+                   (c  & 0x0003 );
+
+      raster->count_table[n] = (UInt)c;
+    }
+
+#ifdef FT_RASTER_OPTION_ANTI_ALIASING
+
+    /* set default 5-levels gray palette */
+    for ( n = 0; n < 5; n++ )
+      raster->grays[n] = n * 255 / 4;
+
+    raster->gray_width = RASTER_GRAY_LINES / 2;
+
+#endif
+  }
+
+
+  /**** RASTER OBJECT CREATION: In standalone mode, we simply use *****/
+  /****                         a static object.                  *****/
+
+
+#ifdef _STANDALONE_
+
+
+  static int
+  ft_black_new( void*      memory,
+                FT_Raster  *araster )
+  {
+     static FT_RasterRec_  the_raster;
+
+
+     *araster = &the_raster;
+     FT_MEM_ZERO( &the_raster, sizeof ( the_raster ) );
+     ft_black_init( &the_raster );
+
+     return 0;
+  }
+
+
+  static void
+  ft_black_done( FT_Raster  raster )
+  {
+    /* nothing */
+    raster->init = 0;
+  }
+
+
+#else /* _STANDALONE_ */
+
+
+  static int
+  ft_black_new( FT_Memory           memory,
+                TRaster_Instance**  araster )
+  {
+    FT_Error           error;
+    TRaster_Instance*  raster;
+
+
+    *araster = 0;
+    if ( !FT_NEW( raster ) )
+    {
+      raster->memory = memory;
+      ft_black_init( raster );
+
+      *araster = raster;
+    }
+
+    return error;
+  }
+
+
+  static void
+  ft_black_done( TRaster_Instance*  raster )
+  {
+    FT_Memory  memory = (FT_Memory)raster->memory;
+    FT_FREE( raster );
+  }
+
+
+#endif /* _STANDALONE_ */
+
+
+  static void
+  ft_black_reset( TRaster_Instance*  raster,
+                  const char*        pool_base,
+                  long               pool_size )
+  {
+    if ( raster && pool_base && pool_size >= 4096 )
+    {
+      /* save the pool */
+      raster->buff     = (PLong)pool_base;
+      raster->sizeBuff = raster->buff + pool_size / sizeof ( Long );
+    }
+  }
+
+
+  static void
+  ft_black_set_mode( TRaster_Instance*  raster,
+                     unsigned long      mode,
+                     const char*        palette )
+  {
+#ifdef FT_RASTER_OPTION_ANTI_ALIASING
+
+    if ( mode == FT_MAKE_TAG( 'p', 'a', 'l', '5' ) )
+    {
+      /* set 5-levels gray palette */
+      raster->grays[0] = palette[0];
+      raster->grays[1] = palette[1];
+      raster->grays[2] = palette[2];
+      raster->grays[3] = palette[3];
+      raster->grays[4] = palette[4];
+    }
+
+#else
+
+    FT_UNUSED( raster );
+    FT_UNUSED( mode );
+    FT_UNUSED( palette );
+
+#endif
+  }
+
+
+  static int
+  ft_black_render( TRaster_Instance*  raster,
+                   FT_Raster_Params*  params )
+  {
+    FT_Outline*  outline    = (FT_Outline*)params->source;
+    FT_Bitmap*   target_map = params->target;
+
+
+    if ( !raster || !raster->buff || !raster->sizeBuff )
+      return Raster_Err_Not_Ini;
+
+    /* return immediately if the outline is empty */
+    if ( outline->n_points == 0 || outline->n_contours <= 0 )
+      return Raster_Err_None;
+
+    if ( !outline || !outline->contours || !outline->points )
+      return Raster_Err_Invalid;
+
+    if ( outline->n_points != outline->contours[outline->n_contours - 1] + 1 )
+      return Raster_Err_Invalid;
+
+    /* this version of the raster does not support direct rendering, sorry */
+    if ( params->flags & FT_RASTER_FLAG_DIRECT )
+      return Raster_Err_Unsupported;
+
+    if ( !target_map || !target_map->buffer )
+      return Raster_Err_Invalid;
+
+    ras.outline  = *outline;
+    ras.target   = *target_map;
+
+    return ( ( params->flags & FT_RASTER_FLAG_AA )
+               ? Render_Gray_Glyph( raster )
+               : Render_Glyph( raster ) );
+  }
+
+
+  const FT_Raster_Funcs  ft_standard_raster =
+  {
+    FT_GLYPH_FORMAT_OUTLINE,
+    (FT_Raster_New_Func)     ft_black_new,
+    (FT_Raster_Reset_Func)   ft_black_reset,
+    (FT_Raster_Set_Mode_Func)ft_black_set_mode,
+    (FT_Raster_Render_Func)  ft_black_render,
+    (FT_Raster_Done_Func)    ft_black_done
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/raster/ftraster.h b/nx-X11/extras/freetype2/src/raster/ftraster.h
new file mode 100644
index 000000000..80fe46deb
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/ftraster.h
@@ -0,0 +1,46 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftraster.h                                                             */
+/*                                                                         */
+/*    The FreeType glyph rasterizer (specification).                       */
+/*                                                                         */
+/*  Copyright 1996-2001 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 __FTRASTER_H__
+#define __FTRASTER_H__
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_IMAGE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Uncomment the following line if you are using ftraster.c as a         */
+  /* standalone module, fully independent of FreeType.                     */
+  /*                                                                       */
+/* #define _STANDALONE_ */
+
+  FT_EXPORT_VAR( const FT_Raster_Funcs )  ft_standard_raster;
+
+
+FT_END_HEADER
+
+#endif /* __FTRASTER_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/raster/ftrend1.c b/nx-X11/extras/freetype2/src/raster/ftrend1.c
new file mode 100644
index 000000000..a17ef9b61
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/ftrend1.c
@@ -0,0 +1,273 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftrend1.c                                                              */
+/*                                                                         */
+/*    The FreeType glyph rasterizer interface (body).                      */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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_OBJECTS_H
+#include FT_OUTLINE_H
+#include "ftrend1.h"
+#include "ftraster.h"
+
+#include "rasterrs.h"
+
+
+  /* initialize renderer -- init its raster */
+  static FT_Error
+  ft_raster1_init( FT_Renderer  render )
+  {
+    FT_Library  library = FT_MODULE_LIBRARY( render );
+
+
+    render->clazz->raster_class->raster_reset( render->raster,
+                                               library->raster_pool,
+                                               library->raster_pool_size );
+
+    return Raster_Err_Ok;
+  }
+
+
+  /* set render-specific mode */
+  static FT_Error
+  ft_raster1_set_mode( FT_Renderer  render,
+                       FT_ULong     mode_tag,
+                       FT_Pointer   data )
+  {
+    /* we simply pass it to the raster */
+    return render->clazz->raster_class->raster_set_mode( render->raster,
+                                                         mode_tag,
+                                                         data );
+  }
+
+
+  /* transform a given glyph image */
+  static FT_Error
+  ft_raster1_transform( FT_Renderer   render,
+                        FT_GlyphSlot  slot,
+                        FT_Matrix*    matrix,
+                        FT_Vector*    delta )
+  {
+    FT_Error error = Raster_Err_Ok;
+
+
+    if ( slot->format != render->glyph_format )
+    {
+      error = Raster_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    if ( matrix )
+      FT_Outline_Transform( &slot->outline, matrix );
+
+    if ( delta )
+      FT_Outline_Translate( &slot->outline, delta->x, delta->y );
+
+  Exit:
+    return error;
+  }
+
+
+  /* return the glyph's control box */
+  static void
+  ft_raster1_get_cbox( FT_Renderer   render,
+                       FT_GlyphSlot  slot,
+                       FT_BBox*      cbox )
+  {
+    FT_MEM_ZERO( cbox, sizeof ( *cbox ) );
+
+    if ( slot->format == render->glyph_format )
+      FT_Outline_Get_CBox( &slot->outline, cbox );
+  }
+
+
+  /* convert a slot's glyph image into a bitmap */
+  static FT_Error
+  ft_raster1_render( FT_Renderer     render,
+                     FT_GlyphSlot    slot,
+                     FT_Render_Mode  mode,
+                     FT_Vector*      origin )
+  {
+    FT_Error     error;
+    FT_Outline*  outline;
+    FT_BBox      cbox;
+    FT_UInt      width, height, pitch;
+    FT_Bitmap*   bitmap;
+    FT_Memory    memory;
+
+    FT_Raster_Params  params;
+
+
+    /* check glyph image format */
+    if ( slot->format != render->glyph_format )
+    {
+      error = Raster_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* check rendering mode */
+    if ( mode != FT_RENDER_MODE_MONO )
+    {
+      /* raster1 is only capable of producing monochrome bitmaps */
+      if ( render->clazz == &ft_raster1_renderer_class )
+        return Raster_Err_Cannot_Render_Glyph;
+    }
+    else
+    {
+      /* raster5 is only capable of producing 5-gray-levels bitmaps */
+      if ( render->clazz == &ft_raster5_renderer_class )
+        return Raster_Err_Cannot_Render_Glyph;
+    }
+
+    outline = &slot->outline;
+
+    /* translate the outline to the new origin if needed */
+    if ( origin )
+      FT_Outline_Translate( outline, origin->x, origin->y );
+
+    /* compute the control box, and grid fit it */
+    FT_Outline_Get_CBox( outline, &cbox );
+
+    cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
+    cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
+    cbox.xMax = FT_PIX_CEIL( cbox.xMax );
+    cbox.yMax = FT_PIX_CEIL( cbox.yMax );
+
+    width  = (FT_UInt)( ( cbox.xMax - cbox.xMin ) >> 6 );
+    height = (FT_UInt)( ( cbox.yMax - cbox.yMin ) >> 6 );
+    bitmap = &slot->bitmap;
+    memory = render->root.memory;
+
+    /* release old bitmap buffer */
+    if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
+    {
+      FT_FREE( bitmap->buffer );
+      slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
+    }
+
+    /* allocate new one, depends on pixel format */
+    if ( !( mode & FT_RENDER_MODE_MONO ) )
+    {
+      /* we pad to 32 bits, only for backwards compatibility with FT 1.x */
+      pitch = FT_PAD_CEIL( width, 4 );
+      bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
+      bitmap->num_grays  = 256;
+    }
+    else
+    {
+      pitch = ( ( width + 15 ) >> 4 ) << 1;
+      bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
+    }
+
+    bitmap->width = width;
+    bitmap->rows  = height;
+    bitmap->pitch = pitch;
+
+    if ( FT_ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
+      goto Exit;
+
+    slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
+
+    /* translate outline to render it into the bitmap */
+    FT_Outline_Translate( outline, -cbox.xMin, -cbox.yMin );
+
+    /* set up parameters */
+    params.target = bitmap;
+    params.source = outline;
+    params.flags  = 0;
+
+    if ( bitmap->pixel_mode == FT_PIXEL_MODE_GRAY )
+      params.flags |= FT_RASTER_FLAG_AA;
+
+    /* render outline into the bitmap */
+    error = render->raster_render( render->raster, &params );
+
+    FT_Outline_Translate( outline, cbox.xMin, cbox.yMin );
+
+    if ( error )
+      goto Exit;
+
+    slot->format      = FT_GLYPH_FORMAT_BITMAP;
+    slot->bitmap_left = (FT_Int)( cbox.xMin >> 6 );
+    slot->bitmap_top  = (FT_Int)( cbox.yMax >> 6 );
+
+  Exit:
+    return error;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Renderer_Class  ft_raster1_renderer_class =
+  {
+    {
+      FT_MODULE_RENDERER,
+      sizeof( FT_RendererRec ),
+
+      "raster1",
+      0x10000L,
+      0x20000L,
+
+      0,    /* module specific interface */
+
+      (FT_Module_Constructor)ft_raster1_init,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  0
+    },
+
+    FT_GLYPH_FORMAT_OUTLINE,
+
+    (FT_Renderer_RenderFunc)   ft_raster1_render,
+    (FT_Renderer_TransformFunc)ft_raster1_transform,
+    (FT_Renderer_GetCBoxFunc)  ft_raster1_get_cbox,
+    (FT_Renderer_SetModeFunc)  ft_raster1_set_mode,
+
+    (FT_Raster_Funcs*)    &ft_standard_raster
+  };
+
+
+  /* This renderer is _NOT_ part of the default modules; you will need */
+  /* to register it by hand in your application.  It should only be    */
+  /* used for backwards-compatibility with FT 1.x anyway.              */
+  /*                                                                   */
+  FT_CALLBACK_TABLE_DEF
+  const FT_Renderer_Class  ft_raster5_renderer_class =
+  {
+    {
+      FT_MODULE_RENDERER,
+      sizeof( FT_RendererRec ),
+
+      "raster5",
+      0x10000L,
+      0x20000L,
+
+      0,    /* module specific interface */
+
+      (FT_Module_Constructor)ft_raster1_init,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  0
+    },
+
+    FT_GLYPH_FORMAT_OUTLINE,
+
+    (FT_Renderer_RenderFunc)   ft_raster1_render,
+    (FT_Renderer_TransformFunc)ft_raster1_transform,
+    (FT_Renderer_GetCBoxFunc)  ft_raster1_get_cbox,
+    (FT_Renderer_SetModeFunc)  ft_raster1_set_mode,
+
+    (FT_Raster_Funcs*)    &ft_standard_raster
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/raster/ftrend1.h b/nx-X11/extras/freetype2/src/raster/ftrend1.h
new file mode 100644
index 000000000..76e9a5f58
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/ftrend1.h
@@ -0,0 +1,44 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftrend1.h                                                              */
+/*                                                                         */
+/*    The FreeType glyph rasterizer interface (specification).             */
+/*                                                                         */
+/*  Copyright 1996-2001 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 __FTREND1_H__
+#define __FTREND1_H__
+
+
+#include <ft2build.h>
+#include FT_RENDER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Renderer_Class )  ft_raster1_renderer_class;
+
+  /* this renderer is _NOT_ part of the default modules, you'll need */
+  /* to register it by hand in your application.  It should only be  */
+  /* used for backwards-compatibility with FT 1.x anyway.            */
+  /*                                                                 */
+  FT_EXPORT_VAR( const FT_Renderer_Class )  ft_raster5_renderer_class;
+
+
+FT_END_HEADER
+
+#endif /* __FTREND1_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/raster/module.mk b/nx-X11/extras/freetype2/src/raster/module.mk
new file mode 100644
index 000000000..8a3136413
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 renderer module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_raster_module
+
+add_raster_module:
+	$(OPEN_DRIVER)ft_raster1_renderer_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)raster    $(ECHO_DRIVER_DESC)monochrome bitmap renderer$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/raster/raster.c b/nx-X11/extras/freetype2/src/raster/raster.c
new file mode 100644
index 000000000..f13a67a20
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/raster.c
@@ -0,0 +1,26 @@
+/***************************************************************************/
+/*                                                                         */
+/*  raster.c                                                               */
+/*                                                                         */
+/*    FreeType monochrome rasterer module component (body only).           */
+/*                                                                         */
+/*  Copyright 1996-2001 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 "ftraster.c"
+#include "ftrend1.c"
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/raster/rasterrs.h b/nx-X11/extras/freetype2/src/raster/rasterrs.h
new file mode 100644
index 000000000..5df9a7ab1
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/rasterrs.h
@@ -0,0 +1,41 @@
+/***************************************************************************/
+/*                                                                         */
+/*  rasterrs.h                                                             */
+/*                                                                         */
+/*    monochrome renderer error codes (specification only).                */
+/*                                                                         */
+/*  Copyright 2001 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 monochrome renderer error enumeration */
+  /* constants.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __RASTERRS_H__
+#define __RASTERRS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  Raster_Err_
+#define FT_ERR_BASE    FT_Mod_Err_Raster
+
+#include FT_ERRORS_H
+
+#endif /* __RASTERRS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/raster/rules.mk b/nx-X11/extras/freetype2/src/raster/rules.mk
new file mode 100644
index 000000000..0dc8782ea
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/raster/rules.mk
@@ -0,0 +1,69 @@
+#
+# FreeType 2 renderer module build rules
+#
+
+
+# Copyright 1996-2000, 2001, 2003 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.
+
+
+# raster driver directory
+#
+RASTER_DIR := $(SRC_DIR)/raster
+
+# compilation flags for the driver
+#
+RASTER_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(RASTER_DIR))
+
+
+# raster driver sources (i.e., C files)
+#
+RASTER_DRV_SRC := $(RASTER_DIR)/ftraster.c \
+                  $(RASTER_DIR)/ftrend1.c
+
+
+# raster driver headers
+#
+RASTER_DRV_H := $(RASTER_DRV_SRC:%.c=%.h) \
+                $(RASTER_DIR)/rasterrs.h
+
+
+# raster driver object(s)
+#
+#   RASTER_DRV_OBJ_M is used during `multi' builds.
+#   RASTER_DRV_OBJ_S is used during `single' builds.
+#
+RASTER_DRV_OBJ_M := $(RASTER_DRV_SRC:$(RASTER_DIR)/%.c=$(OBJ_DIR)/%.$O)
+RASTER_DRV_OBJ_S := $(OBJ_DIR)/raster.$O
+
+# raster driver source file for single build
+#
+RASTER_DRV_SRC_S := $(RASTER_DIR)/raster.c
+
+
+# raster driver - single object
+#
+$(RASTER_DRV_OBJ_S): $(RASTER_DRV_SRC_S) $(RASTER_DRV_SRC) \
+                     $(FREETYPE_H) $(RASTER_DRV_H)
+	$(RASTER_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(RASTER_DRV_SRC_S))
+
+
+# raster driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(RASTER_DIR)/%.c $(FREETYPE_H) $(RASTER_DRV_H)
+	$(RASTER_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(RASTER_DRV_OBJ_S)
+DRV_OBJS_M += $(RASTER_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/sfnt/Jamfile b/nx-X11/extras/freetype2/src/sfnt/Jamfile
new file mode 100644
index 000000000..257b3442c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/sfnt Jamfile (c) 2001, 2002, 2004 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) sfnt ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = sfobjs sfdriver ttcmap0 ttpost ttload ttsbit ;
+  }
+  else
+  {
+    _sources = sfnt ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/sfnt Jamfile
diff --git a/nx-X11/extras/freetype2/src/sfnt/descrip.mms b/nx-X11/extras/freetype2/src/sfnt/descrip.mms
new file mode 100644
index 000000000..811c8b3ee
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 SFNT driver compilation rules for VMS
+#
+
+
+# Copyright 2001, 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.sfnt])
+
+OBJS=sfnt.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/sfnt/module.mk b/nx-X11/extras/freetype2/src/sfnt/module.mk
new file mode 100644
index 000000000..52607e2af
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 SFNT module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_sfnt_module
+
+add_sfnt_module:
+	$(OPEN_DRIVER)sfnt_module_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)sfnt      $(ECHO_DRIVER_DESC)helper module for TrueType & OpenType formats$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/sfnt/rules.mk b/nx-X11/extras/freetype2/src/sfnt/rules.mk
new file mode 100644
index 000000000..f13238549
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/rules.mk
@@ -0,0 +1,73 @@
+#
+# FreeType 2 SFNT driver configuration rules
+#
+
+
+# Copyright 1996-2000, 2002, 2003 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.
+
+
+# SFNT driver directory
+#
+SFNT_DIR := $(SRC_DIR)/sfnt
+
+
+# compilation flags for the driver
+#
+SFNT_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(SFNT_DIR))
+
+
+# SFNT driver sources (i.e., C files)
+#
+SFNT_DRV_SRC := $(SFNT_DIR)/ttload.c   \
+                $(SFNT_DIR)/ttcmap0.c  \
+                $(SFNT_DIR)/ttsbit.c   \
+                $(SFNT_DIR)/ttpost.c   \
+                $(SFNT_DIR)/sfobjs.c   \
+                $(SFNT_DIR)/sfdriver.c
+
+# SFNT driver headers
+#
+SFNT_DRV_H := $(SFNT_DRV_SRC:%c=%h) \
+              $(SFNT_DIR)/sferrors.h
+
+
+# SFNT driver object(s)
+#
+#   SFNT_DRV_OBJ_M is used during `multi' builds.
+#   SFNT_DRV_OBJ_S is used during `single' builds.
+#
+SFNT_DRV_OBJ_M := $(SFNT_DRV_SRC:$(SFNT_DIR)/%.c=$(OBJ_DIR)/%.$O)
+SFNT_DRV_OBJ_S := $(OBJ_DIR)/sfnt.$O
+
+# SFNT driver source file for single build
+#
+SFNT_DRV_SRC_S := $(SFNT_DIR)/sfnt.c
+
+
+# SFNT driver - single object
+#
+$(SFNT_DRV_OBJ_S): $(SFNT_DRV_SRC_S) $(SFNT_DRV_SRC) \
+                   $(FREETYPE_H) $(SFNT_DRV_H)
+	$(SFNT_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(SFNT_DRV_SRC_S))
+
+
+# SFNT driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(SFNT_DIR)/%.c $(FREETYPE_H) $(SFNT_DRV_H)
+	$(SFNT_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(SFNT_DRV_OBJ_S)
+DRV_OBJS_M += $(SFNT_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/sfnt/sfdriver.c b/nx-X11/extras/freetype2/src/sfnt/sfdriver.c
new file mode 100644
index 000000000..7da53d2f1
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/sfdriver.c
@@ -0,0 +1,400 @@
+/***************************************************************************/
+/*                                                                         */
+/*  sfdriver.c                                                             */
+/*                                                                         */
+/*    High-level SFNT driver interface (body).                             */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_SFNT_H
+#include FT_INTERNAL_OBJECTS_H
+
+#include "sfdriver.h"
+#include "ttload.h"
+#include "sfobjs.h"
+
+#include "sferrors.h"
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+#include "ttsbit.h"
+#endif
+
+#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
+#include "ttpost.h"
+#endif
+
+#include "ttcmap0.h"
+
+#include FT_SERVICE_GLYPH_DICT_H
+#include FT_SERVICE_POSTSCRIPT_NAME_H
+#include FT_SERVICE_SFNT_H
+#include FT_SERVICE_TT_CMAP_H
+
+
+ /*
+  *  SFNT TABLE SERVICE
+  *
+  */
+
+  static void*
+  get_sfnt_table( TT_Face      face,
+                  FT_Sfnt_Tag  tag )
+  {
+    void*  table;
+
+
+    switch ( tag )
+    {
+    case ft_sfnt_head:
+      table = &face->header;
+      break;
+
+    case ft_sfnt_hhea:
+      table = &face->horizontal;
+      break;
+
+    case ft_sfnt_vhea:
+      table = face->vertical_info ? &face->vertical : 0;
+      break;
+
+    case ft_sfnt_os2:
+      table = face->os2.version == 0xFFFFU ? 0 : &face->os2;
+      break;
+
+    case ft_sfnt_post:
+      table = &face->postscript;
+      break;
+
+    case ft_sfnt_maxp:
+      table = &face->max_profile;
+      break;
+
+    case ft_sfnt_pclt:
+      table = face->pclt.Version ? &face->pclt : 0;
+      break;
+
+    default:
+      table = 0;
+    }
+
+    return table;
+  }
+
+
+  static const FT_Service_SFNT_TableRec  sfnt_service_sfnt_table =
+  {
+    (FT_SFNT_TableLoadFunc)tt_face_load_any,
+    (FT_SFNT_TableGetFunc) get_sfnt_table
+  };
+
+
+#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
+
+ /*
+  *  GLYPH DICT SERVICE
+  *
+  */
+
+  static FT_Error
+  sfnt_get_glyph_name( TT_Face     face,
+                       FT_UInt     glyph_index,
+                       FT_Pointer  buffer,
+                       FT_UInt     buffer_max )
+  {
+    FT_String*  gname;
+    FT_Error    error;
+
+
+    error = tt_face_get_ps_name( face, glyph_index, &gname );
+    if ( !error && buffer_max > 0 )
+    {
+      FT_UInt  len = (FT_UInt)( ft_strlen( gname ) );
+
+
+      if ( len >= buffer_max )
+        len = buffer_max - 1;
+
+      FT_MEM_COPY( buffer, gname, len );
+      ((FT_Byte*)buffer)[len] = 0;
+    }
+
+    return error;
+  }
+
+
+  static const FT_Service_GlyphDictRec  sfnt_service_glyph_dict =
+  {
+    (FT_GlyphDict_GetNameFunc)  sfnt_get_glyph_name,
+    (FT_GlyphDict_NameIndexFunc)NULL
+  };
+
+#endif /* TT_CONFIG_OPTION_POSTSCRIPT_NAMES */
+
+
+ /*
+  *  POSTSCRIPT NAME SERVICE
+  *
+  */
+
+  static const char*
+  sfnt_get_ps_name( TT_Face  face )
+  {
+    FT_Int       n, found_win, found_apple;
+    const char*  result = NULL;
+
+
+    /* shouldn't happen, but just in case to avoid memory leaks */
+    if ( face->postscript_name )
+      return face->postscript_name;
+
+    /* scan the name table to see whether we have a Postscript name here, */
+    /* either in Macintosh or Windows platform encodings                  */
+    found_win   = -1;
+    found_apple = -1;
+
+    for ( n = 0; n < face->num_names; n++ )
+    {
+      TT_NameEntryRec*  name = face->name_table.names + n;
+
+
+      if ( name->nameID == 6 && name->stringLength > 0 )
+      {
+        if ( name->platformID == 3     &&
+             name->encodingID == 1     &&
+             name->languageID == 0x409 )
+          found_win = n;
+
+        if ( name->platformID == 1 &&
+             name->encodingID == 0 &&
+             name->languageID == 0 )
+          found_apple = n;
+      }
+    }
+
+    if ( found_win != -1 )
+    {
+      FT_Memory         memory = face->root.memory;
+      TT_NameEntryRec*  name   = face->name_table.names + found_win;
+      FT_UInt           len    = name->stringLength / 2;
+      FT_Error          error  = SFNT_Err_Ok;
+
+      FT_UNUSED( error );
+
+
+      if ( !FT_ALLOC( result, name->stringLength + 1 ) )
+      {
+        FT_Stream   stream = face->name_table.stream;
+        FT_String*  r      = (FT_String*)result;
+        FT_Byte*    p      = (FT_Byte*)name->string;
+
+
+        if ( FT_STREAM_SEEK( name->stringOffset ) ||
+             FT_FRAME_ENTER( name->stringLength ) )
+        {
+          FT_FREE( result );
+          name->stringLength = 0;
+          name->stringOffset = 0;
+          FT_FREE( name->string );
+
+          goto Exit;
+        }
+
+        p = (FT_Byte*)stream->cursor;
+
+        for ( ; len > 0; len--, p += 2 )
+        {
+          if ( p[0] == 0 && p[1] >= 32 && p[1] < 128 )
+            *r++ = p[1];
+        }
+        *r = '\0';
+
+        FT_FRAME_EXIT();
+      }
+      goto Exit;
+    }
+
+    if ( found_apple != -1 )
+    {
+      FT_Memory         memory = face->root.memory;
+      TT_NameEntryRec*  name   = face->name_table.names + found_apple;
+      FT_UInt           len    = name->stringLength;
+      FT_Error          error  = SFNT_Err_Ok;
+
+      FT_UNUSED( error );
+
+
+      if ( !FT_ALLOC( result, len + 1 ) )
+      {
+        FT_Stream  stream = face->name_table.stream;
+
+
+        if ( FT_STREAM_SEEK( name->stringOffset ) ||
+             FT_STREAM_READ( result, len )        )
+        {
+          name->stringOffset = 0;
+          name->stringLength = 0;
+          FT_FREE( name->string );
+          FT_FREE( result );
+          goto Exit;
+        }
+        ((char*)result)[len] = '\0';
+      }
+    }
+
+  Exit:
+    face->postscript_name = result;
+    return result;
+  }
+
+  static const FT_Service_PsFontNameRec  sfnt_service_ps_name =
+  {
+    (FT_PsName_GetFunc)sfnt_get_ps_name
+  };
+
+
+ /*
+  *  TT CMAP INFO
+  *
+  */
+  static const FT_Service_TTCMapsRec  tt_service_get_cmap_info =
+  {
+    (TT_CMap_Info_GetFunc)tt_get_cmap_info
+  };
+
+
+ /*
+  *  SERVICE LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  sfnt_services[] =
+  {
+    { FT_SERVICE_ID_SFNT_TABLE,           &sfnt_service_sfnt_table },
+    { FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &sfnt_service_ps_name },
+#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
+    { FT_SERVICE_ID_GLYPH_DICT,           &sfnt_service_glyph_dict },
+#endif
+    { FT_SERVICE_ID_TT_CMAP,              &tt_service_get_cmap_info },
+
+    { NULL, NULL }
+  };
+
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  sfnt_get_interface( FT_Module    module,
+                      const char*  module_interface )
+  {
+    FT_UNUSED( module );
+
+    if ( ft_strcmp( module_interface, "get_sfnt" ) == 0 )
+      return (FT_Module_Interface)get_sfnt_table;
+
+    if ( ft_strcmp( module_interface, "load_sfnt" ) == 0 )
+      return (FT_Module_Interface)tt_face_load_any;
+
+    return ft_service_list_lookup( sfnt_services, module_interface );
+  }
+
+
+  static
+  const SFNT_Interface  sfnt_interface =
+  {
+    tt_face_goto_table,
+
+    sfnt_init_face,
+    sfnt_load_face,
+    sfnt_done_face,
+    sfnt_get_interface,
+
+    tt_face_load_any,
+    tt_face_load_sfnt_header,
+    tt_face_load_directory,
+
+    tt_face_load_header,
+    tt_face_load_metrics_header,
+    tt_face_load_cmap,
+    tt_face_load_max_profile,
+    tt_face_load_os2,
+    tt_face_load_postscript,
+
+    tt_face_load_names,
+    tt_face_free_names,
+
+    tt_face_load_hdmx,
+    tt_face_free_hdmx,
+
+    tt_face_load_kern,
+    tt_face_load_gasp,
+    tt_face_load_pclt,
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    /* see `ttload.h' */
+    tt_face_load_bitmap_header,
+
+    /* see `ttsbit.h' and `sfnt.h' */
+    tt_face_set_sbit_strike,
+    tt_face_load_sbit_strikes,
+    tt_find_sbit_image,
+    tt_load_sbit_metrics,
+    tt_face_load_sbit_image,
+    tt_face_free_sbit_strikes,
+
+#else /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+    0,
+    0,
+    0,
+    0, 
+    0, 
+    0,
+    0,
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
+
+    /* see `ttpost.h' */
+    tt_face_get_ps_name,
+    tt_face_free_ps_names,
+
+#else /* TT_CONFIG_OPTION_POSTSCRIPT_NAMES */
+
+    0,
+    0,
+
+#endif /* TT_CONFIG_OPTION_POSTSCRIPT_NAMES */
+
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Module_Class  sfnt_module_class =
+  {
+    0,  /* not a font driver or renderer */
+    sizeof( FT_ModuleRec ),
+
+    "sfnt",     /* driver name                            */
+    0x10000L,   /* driver version 1.0                     */
+    0x20000L,   /* driver requires FreeType 2.0 or higher */
+
+    (const void*)&sfnt_interface,  /* module specific interface */
+
+    (FT_Module_Constructor)0,
+    (FT_Module_Destructor) 0,
+    (FT_Module_Requester)  sfnt_get_interface
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/sfdriver.h b/nx-X11/extras/freetype2/src/sfnt/sfdriver.h
new file mode 100644
index 000000000..92db79694
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/sfdriver.h
@@ -0,0 +1,38 @@
+/***************************************************************************/
+/*                                                                         */
+/*  sfdriver.h                                                             */
+/*                                                                         */
+/*    High-level SFNT driver interface (specification).                    */
+/*                                                                         */
+/*  Copyright 1996-2001 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 __SFDRIVER_H__
+#define __SFDRIVER_H__
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Module_Class )  sfnt_module_class;
+
+
+FT_END_HEADER
+
+#endif /* __SFDRIVER_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/sferrors.h b/nx-X11/extras/freetype2/src/sfnt/sferrors.h
new file mode 100644
index 000000000..fd2736b6c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/sferrors.h
@@ -0,0 +1,39 @@
+/***************************************************************************/
+/*                                                                         */
+/*  sferrors.h                                                             */
+/*                                                                         */
+/*    SFNT error codes (specification only).                               */
+/*                                                                         */
+/*  Copyright 2001 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 SFNT error enumeration constants.     */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __SFERRORS_H__
+#define __SFERRORS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  SFNT_Err_
+#define FT_ERR_BASE    FT_Mod_Err_SFNT
+
+#include FT_ERRORS_H
+
+#endif /* __SFERRORS_H__ */
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/sfnt.c b/nx-X11/extras/freetype2/src/sfnt/sfnt.c
new file mode 100644
index 000000000..90c1bee91
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/sfnt.c
@@ -0,0 +1,36 @@
+/***************************************************************************/
+/*                                                                         */
+/*  sfnt.c                                                                 */
+/*                                                                         */
+/*    Single object library component.                                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 "ttload.c"
+#include "ttcmap0.c"
+#include "sfobjs.c"
+#include "sfdriver.c"
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+#include "ttsbit.c"
+#endif
+
+#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
+#include "ttpost.c"
+#endif
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/sfobjs.c b/nx-X11/extras/freetype2/src/sfnt/sfobjs.c
new file mode 100644
index 000000000..aef3f5dfb
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/sfobjs.c
@@ -0,0 +1,854 @@
+/***************************************************************************/
+/*                                                                         */
+/*  sfobjs.c                                                               */
+/*                                                                         */
+/*    SFNT object management (base).                                       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 "sfobjs.h"
+#include "ttload.h"
+#include "ttcmap0.h"
+#include FT_INTERNAL_SFNT_H
+#include FT_TRUETYPE_IDS_H
+#include FT_TRUETYPE_TAGS_H
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+#include "sferrors.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_sfobjs
+
+
+
+  /* convert a UTF-16 name entry to ASCII */
+  static FT_String*
+  tt_name_entry_ascii_from_utf16( TT_NameEntry  entry,
+                                  FT_Memory     memory )
+  {
+    FT_String*  string;
+    FT_UInt     len, code, n;
+    FT_Byte*    read = (FT_Byte*)entry->string;
+
+
+    len = (FT_UInt)entry->stringLength / 2;
+
+    if ( FT_MEM_NEW_ARRAY( string, len + 1 ) )
+      return NULL;
+
+    for ( n = 0; n < len; n++ )
+    {
+      code = FT_NEXT_USHORT( read );
+      if ( code < 32 || code > 127 )
+        code = '?';
+
+      string[n] = (char)code;
+    }
+
+    string[len] = 0;
+
+    return string;
+  }
+
+
+  /* convert a UCS-4 name entry to ASCII */
+  static FT_String*
+  tt_name_entry_ascii_from_ucs4( TT_NameEntry  entry,
+                                 FT_Memory     memory )
+  {
+    FT_String*  string;
+    FT_UInt     len, code, n;
+    FT_Byte*    read = (FT_Byte*)entry->string;
+
+
+    len = (FT_UInt)entry->stringLength / 4;
+
+    if ( FT_MEM_NEW_ARRAY( string, len + 1 ) )
+      return NULL;
+
+    for ( n = 0; n < len; n++ )
+    {
+      code = (FT_UInt)FT_NEXT_ULONG( read );
+      if ( code < 32 || code > 127 )
+        code = '?';
+
+      string[n] = (char)code;
+    }
+
+    string[len] = 0;
+
+    return string;
+  }
+
+
+  /* convert an Apple Roman or symbol name entry to ASCII */
+  static FT_String*
+  tt_name_entry_ascii_from_other( TT_NameEntry  entry,
+                                  FT_Memory     memory )
+  {
+    FT_String*  string;
+    FT_UInt     len, code, n;
+    FT_Byte*    read = (FT_Byte*)entry->string;
+
+
+    len = (FT_UInt)entry->stringLength;
+
+    if ( FT_MEM_NEW_ARRAY( string, len + 1 ) )
+      return NULL;
+
+    for ( n = 0; n < len; n++ )
+    {
+      code = *read++;
+      if ( code < 32 || code > 127 )
+        code = '?';
+
+      string[n] = (char)code;
+    }
+
+    string[len] = 0;
+
+    return string;
+  }
+
+
+  typedef FT_String*  (*TT_NameEntry_ConvertFunc)( TT_NameEntry  entry,
+                                                   FT_Memory     memory );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_get_name                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns a given ENGLISH name record in ASCII.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the source face object.                      */
+  /*                                                                       */
+  /*    nameid :: The name id of the name record to return.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Character string.  NULL if no name is present.                     */
+  /*                                                                       */
+  static FT_String*
+  tt_face_get_name( TT_Face    face,
+                    FT_UShort  nameid )
+  {
+    FT_Memory         memory = face->root.memory;
+    FT_String*        result = NULL;
+    FT_UShort         n;
+    TT_NameEntryRec*  rec;
+    FT_Int            found_apple   = -1;
+    FT_Int            found_win     = -1;
+    FT_Int            found_unicode = -1;
+
+    FT_Bool           is_english = 0;
+
+    TT_NameEntry_ConvertFunc  convert;
+
+
+    rec = face->name_table.names;
+    for ( n = 0; n < face->num_names; n++, rec++ )
+    {
+      /* According to the OpenType 1.3 specification, only Microsoft or  */
+      /* Apple platform IDs might be used in the `name' table.  The      */
+      /* `Unicode' platform is reserved for the `cmap' table, and the    */
+      /* `Iso' one is deprecated.                                        */
+      /*                                                                 */
+      /* However, the Apple TrueType specification doesn't say the same  */
+      /* thing and goes to suggest that all Unicode `name' table entries */
+      /* should be coded in UTF-16 (in big-endian format I suppose).     */
+      /*                                                                 */
+      if ( rec->nameID == nameid && rec->stringLength > 0 )
+      {
+        switch ( rec->platformID )
+        {
+        case TT_PLATFORM_APPLE_UNICODE:
+        case TT_PLATFORM_ISO:
+          /* there is `languageID' to check there.  We should use this */
+          /* field only as a last solution when nothing else is        */
+          /* available.                                                */
+          /*                                                           */
+          found_unicode = n;
+          break;
+
+        case TT_PLATFORM_MACINTOSH:
+          if ( rec->languageID == TT_MAC_LANGID_ENGLISH )
+            found_apple = n;
+
+          break;
+
+        case TT_PLATFORM_MICROSOFT:
+          /* we only take a non-English name when there is nothing */
+          /* else available in the font                            */
+          /*                                                       */
+          if ( found_win == -1 || ( rec->languageID & 0x3FF ) == 0x009 )
+          {
+            switch ( rec->encodingID )
+            {
+            case TT_MS_ID_SYMBOL_CS:
+            case TT_MS_ID_UNICODE_CS:
+            case TT_MS_ID_UCS_4:
+              is_english = ( rec->languageID & 0x3FF ) == 0x009;
+              found_win  = n;
+              break;
+
+            default:
+              ;
+            }
+          }
+          break;
+
+        default:
+          ;
+        }
+      }
+    }
+
+    /* some fonts contain invalid Unicode or Macintosh formatted entries; */
+    /* we will thus favor names encoded in Windows formats if available   */
+    /* (provided it is an English name)                                   */
+    /*                                                                    */
+    convert = NULL;
+    if ( found_win >= 0 && !( found_apple >= 0 && !is_english ) )
+    {
+      rec = face->name_table.names + found_win;
+      switch ( rec->encodingID )
+      {
+      case TT_MS_ID_UNICODE_CS:
+      case TT_MS_ID_SYMBOL_CS:
+        convert = tt_name_entry_ascii_from_utf16;
+        break;
+
+      case TT_MS_ID_UCS_4:
+        convert = tt_name_entry_ascii_from_ucs4;
+        break;
+
+      default:
+        ;
+      }
+    }
+    else if ( found_apple >= 0 )
+    {
+      rec     = face->name_table.names + found_apple;
+      convert = tt_name_entry_ascii_from_other;
+    }
+    else if ( found_unicode >= 0 )
+    {
+      rec     = face->name_table.names + found_unicode;
+      convert = tt_name_entry_ascii_from_utf16;
+    }
+
+    if ( rec && convert )
+    {
+      if ( rec->string == NULL )
+      {
+        FT_Error   error  = SFNT_Err_Ok;
+        FT_Stream  stream = face->name_table.stream;
+
+        FT_UNUSED( error );
+
+
+        if ( FT_QNEW_ARRAY ( rec->string, rec->stringLength ) ||
+             FT_STREAM_SEEK( rec->stringOffset )              ||
+             FT_STREAM_READ( rec->string, rec->stringLength ) )
+        {
+          FT_FREE( rec->string );
+          rec->stringLength = 0;
+          result            = NULL;
+          goto Exit;
+        }
+      }
+
+      result = convert( rec, memory );
+    }
+
+  Exit:
+    return result;
+  }
+
+
+  static FT_Encoding
+  sfnt_find_encoding( int  platform_id,
+                      int  encoding_id )
+  {
+    typedef struct  TEncoding
+    {
+      int          platform_id;
+      int          encoding_id;
+      FT_Encoding  encoding;
+
+    } TEncoding;
+
+    static
+    const TEncoding  tt_encodings[] =
+    {
+      { TT_PLATFORM_ISO,           -1,                  FT_ENCODING_UNICODE },
+
+      { TT_PLATFORM_APPLE_UNICODE, -1,                  FT_ENCODING_UNICODE },
+
+      { TT_PLATFORM_MACINTOSH,     TT_MAC_ID_ROMAN,     FT_ENCODING_APPLE_ROMAN },
+
+      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_SYMBOL_CS,  FT_ENCODING_MS_SYMBOL },
+      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_UCS_4,      FT_ENCODING_UNICODE },
+      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_UNICODE_CS, FT_ENCODING_UNICODE },
+      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_SJIS,       FT_ENCODING_SJIS },
+      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_GB2312,     FT_ENCODING_GB2312 },
+      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_BIG_5,      FT_ENCODING_BIG5 },
+      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_WANSUNG,    FT_ENCODING_WANSUNG },
+      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_JOHAB,      FT_ENCODING_JOHAB }
+    };
+
+    const TEncoding  *cur, *limit;
+
+
+    cur   = tt_encodings;
+    limit = cur + sizeof ( tt_encodings ) / sizeof ( tt_encodings[0] );
+
+    for ( ; cur < limit; cur++ )
+    {
+      if ( cur->platform_id == platform_id )
+      {
+        if ( cur->encoding_id == encoding_id ||
+             cur->encoding_id == -1          )
+          return cur->encoding;
+      }
+    }
+
+    return FT_ENCODING_NONE;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  sfnt_init_face( FT_Stream      stream,
+                  TT_Face        face,
+                  FT_Int         face_index,
+                  FT_Int         num_params,
+                  FT_Parameter*  params )
+  {
+    FT_Error         error;
+    FT_Library       library = face->root.driver->root.library;
+    SFNT_Service     sfnt;
+    SFNT_HeaderRec   sfnt_header;
+
+    /* for now, parameters are unused */
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+
+
+    sfnt = (SFNT_Service)face->sfnt;
+    if ( !sfnt )
+    {
+      sfnt = (SFNT_Service)FT_Get_Module_Interface( library, "sfnt" );
+      if ( !sfnt )
+      {
+        error = SFNT_Err_Invalid_File_Format;
+        goto Exit;
+      }
+
+      face->sfnt       = sfnt;
+      face->goto_table = sfnt->goto_table;
+    }
+
+    FT_FACE_FIND_GLOBAL_SERVICE( face, face->psnames, POSTSCRIPT_CMAPS );
+
+    /* check that we have a valid TrueType file */
+    error = sfnt->load_sfnt_header( face, stream, face_index, &sfnt_header );
+    if ( error )
+      goto Exit;
+
+    face->format_tag = sfnt_header.format_tag;
+    face->num_tables = sfnt_header.num_tables;
+
+    /* Load font directory */
+    error = sfnt->load_directory( face, stream, &sfnt_header );
+    if ( error )
+      goto Exit;
+
+    face->root.num_faces = face->ttc_header.count;
+    if ( face->root.num_faces < 1 )
+      face->root.num_faces = 1;
+
+  Exit:
+    return error;
+  }
+
+
+#undef  LOAD_
+#define LOAD_( x )  ( ( error = sfnt->load_##x( face, stream ) ) \
+                      != SFNT_Err_Ok )
+
+
+  FT_LOCAL_DEF( FT_Error )
+  sfnt_load_face( FT_Stream      stream,
+                  TT_Face        face,
+                  FT_Int         face_index,
+                  FT_Int         num_params,
+                  FT_Parameter*  params )
+  {
+    FT_Error      error, psnames_error;
+    FT_Bool       has_outline;
+    FT_Bool       is_apple_sbit;
+
+    SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
+
+    FT_UNUSED( face_index );
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+
+
+    /* Load tables */
+
+    /* We now support two SFNT-based bitmapped font formats.  They */
+    /* are recognized easily as they do not include a `glyf'       */
+    /* table.                                                      */
+    /*                                                             */
+    /* The first format comes from Apple, and uses a table named   */
+    /* `bhed' instead of `head' to store the font header (using    */
+    /* the same format).  It also doesn't include horizontal and   */
+    /* vertical metrics tables (i.e. `hhea' and `vhea' tables are  */
+    /* missing).                                                   */
+    /*                                                             */
+    /* The other format comes from Microsoft, and is used with     */
+    /* WinCE/PocketPC.  It looks like a standard TTF, except that  */
+    /* it doesn't contain outlines.                                */
+    /*                                                             */
+
+    /* do we have outlines in there? */
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    has_outline   = FT_BOOL( face->root.internal->incremental_interface != 0 ||
+                             tt_face_lookup_table( face, TTAG_glyf )    != 0 ||
+                             tt_face_lookup_table( face, TTAG_CFF )     != 0 );
+#else
+    has_outline   = FT_BOOL( tt_face_lookup_table( face, TTAG_glyf ) != 0 ||
+                             tt_face_lookup_table( face, TTAG_CFF )  != 0 );
+#endif
+
+    is_apple_sbit = 0;
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    /* if this font doesn't contain outlines, we try to load */
+    /* a `bhed' table                                        */
+    if ( !has_outline )
+      is_apple_sbit = FT_BOOL( !LOAD_( bitmap_header ) );
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+    /* load the font header (`head' table) if this isn't an Apple */
+    /* sbit font file                                             */
+    if ( !is_apple_sbit && LOAD_( header ) )
+      goto Exit;
+
+    /* the following tables are often not present in embedded TrueType */
+    /* fonts within PDF documents, so don't check for them.            */
+    (void)LOAD_( max_profile );
+    (void)LOAD_( charmaps );
+
+    /* the following tables are optional in PCL fonts -- */
+    /* don't check for errors                            */
+    (void)LOAD_( names );
+    psnames_error = LOAD_( psnames );
+
+    /* do not load the metrics headers and tables if this is an Apple */
+    /* sbit font file                                                 */
+    if ( !is_apple_sbit )
+    {
+      /* load the `hhea' and `hmtx' tables at once */
+      error = sfnt->load_metrics( face, stream, 0 );
+      if ( error )
+        goto Exit;
+
+      /* try to load the `vhea' and `vmtx' tables at once */
+      error = sfnt->load_metrics( face, stream, 1 );
+      if ( error )
+        goto Exit;
+
+      if ( LOAD_( os2 ) )
+        goto Exit;
+    }
+
+    /* the optional tables */
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    /* embedded bitmap support. */
+    if ( sfnt->load_sbits && LOAD_( sbits ) )
+    {
+      /* return an error if this font file has no outlines */
+      if ( error == SFNT_Err_Table_Missing && has_outline )
+        error = SFNT_Err_Ok;
+      else
+        goto Exit;
+    }
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+    if ( LOAD_( hdmx )    ||
+         LOAD_( gasp )    ||
+         LOAD_( kerning ) ||
+         LOAD_( pclt )    )
+      goto Exit;
+
+    face->root.family_name = tt_face_get_name( face,
+                                               TT_NAME_ID_FONT_FAMILY );
+    face->root.style_name  = tt_face_get_name( face,
+                                               TT_NAME_ID_FONT_SUBFAMILY );
+
+    /* now set up root fields */
+    {
+      FT_Face    root = &face->root;
+      FT_Int32   flags = 0;
+      FT_Memory  memory;
+
+
+      memory = root->memory;
+
+      /*********************************************************************/
+      /*                                                                   */
+      /* Compute face flags.                                               */
+      /*                                                                   */
+      if ( has_outline == TRUE )
+        flags = FT_FACE_FLAG_SCALABLE;    /* scalable outlines */
+
+      flags |= FT_FACE_FLAG_SFNT      |   /* SFNT file format  */
+               FT_FACE_FLAG_HORIZONTAL;   /* horizontal data   */
+
+#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
+      if ( psnames_error == SFNT_Err_Ok &&
+           face->postscript.FormatType != 0x00030000L )
+        flags |= FT_FACE_FLAG_GLYPH_NAMES;
+#endif
+
+      /* fixed width font? */
+      if ( face->postscript.isFixedPitch )
+        flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      /* vertical information? */
+      if ( face->vertical_info )
+        flags |= FT_FACE_FLAG_VERTICAL;
+
+      /* kerning available ? */
+      if ( face->kern_pairs )
+        flags |= FT_FACE_FLAG_KERNING;
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+      /* Don't bother to load the tables unless somebody asks for them. */
+      /* No need to do work which will (probably) not be used.          */
+      if ( tt_face_lookup_table( face, TTAG_glyf ) != 0 &&
+           tt_face_lookup_table( face, TTAG_fvar ) != 0 &&
+           tt_face_lookup_table( face, TTAG_gvar ) != 0 )
+        flags |= FT_FACE_FLAG_MULTIPLE_MASTERS;
+#endif
+
+      root->face_flags = flags;
+
+      /*********************************************************************/
+      /*                                                                   */
+      /* Compute style flags.                                              */
+      /*                                                                   */
+      flags = 0;
+      if ( has_outline == TRUE && face->os2.version != 0xFFFFU )
+      {
+        /* we have an OS/2 table; use the `fsSelection' field */
+        if ( face->os2.fsSelection & 1 )
+          flags |= FT_STYLE_FLAG_ITALIC;
+
+        if ( face->os2.fsSelection & 32 )
+          flags |= FT_STYLE_FLAG_BOLD;
+      }
+      else
+      {
+        /* this is an old Mac font, use the header field */
+        if ( face->header.Mac_Style & 1 )
+          flags |= FT_STYLE_FLAG_BOLD;
+
+        if ( face->header.Mac_Style & 2 )
+          flags |= FT_STYLE_FLAG_ITALIC;
+      }
+
+      root->style_flags = flags;
+
+      /*********************************************************************/
+      /*                                                                   */
+      /* Polish the charmaps.                                              */
+      /*                                                                   */
+      /*   Try to set the charmap encoding according to the platform &     */
+      /*   encoding ID of each charmap.                                    */
+      /*                                                                   */
+
+      tt_face_build_cmaps( face );  /* ignore errors */
+
+
+      /* set the encoding fields */
+      {
+        FT_Int  m;
+
+
+        for ( m = 0; m < root->num_charmaps; m++ )
+        {
+          FT_CharMap  charmap = root->charmaps[m];
+
+
+          charmap->encoding = sfnt_find_encoding( charmap->platform_id,
+                                                  charmap->encoding_id );
+
+#if 0
+          if ( root->charmap     == NULL &&
+               charmap->encoding == FT_ENCODING_UNICODE )
+          {
+            /* set 'root->charmap' to the first Unicode encoding we find */
+            root->charmap = charmap;
+          }
+#endif
+        }
+      }
+
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+      if ( face->num_sbit_strikes )
+      {
+        FT_ULong  n;
+
+
+        root->face_flags |= FT_FACE_FLAG_FIXED_SIZES;
+
+#if 0
+        /* XXX: I don't know criteria whether layout is horizontal */
+        /*      or vertical.                                       */
+        if ( has_outline.... )
+        {
+          ...
+          root->face_flags |= FT_FACE_FLAG_VERTICAL;
+        }
+#endif
+        root->num_fixed_sizes = (FT_Int)face->num_sbit_strikes;
+
+        if ( FT_NEW_ARRAY( root->available_sizes, face->num_sbit_strikes ) )
+          goto Exit;
+
+        for ( n = 0 ; n < face->num_sbit_strikes ; n++ )
+        {
+          FT_Bitmap_Size*  bsize  = root->available_sizes + n;
+          TT_SBit_Strike   strike = face->sbit_strikes + n;
+          FT_UShort        fupem  = face->header.Units_Per_EM;
+          FT_Short         height = (FT_Short)( face->horizontal.Ascender -
+                                                face->horizontal.Descender +
+                                                face->horizontal.Line_Gap );
+          FT_Short         avg    = face->os2.xAvgCharWidth;
+
+
+          /* assume 72dpi */
+          bsize->height =
+            (FT_Short)( ( height * strike->y_ppem + fupem/2 ) / fupem );
+          bsize->width  =
+            (FT_Short)( ( avg * strike->y_ppem + fupem/2 ) / fupem );
+          bsize->size   = strike->y_ppem << 6;
+          bsize->x_ppem = strike->x_ppem << 6;
+          bsize->y_ppem = strike->y_ppem << 6;
+        }
+      }
+      else
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+      {
+        root->num_fixed_sizes = 0;
+        root->available_sizes = 0;
+      }
+
+      /*********************************************************************/
+      /*                                                                   */
+      /*  Set up metrics.                                                  */
+      /*                                                                   */
+      if ( has_outline == TRUE )
+      {
+        /* XXX What about if outline header is missing */
+        /*     (e.g. sfnt wrapped bitmap)?             */
+        root->bbox.xMin    = face->header.xMin;
+        root->bbox.yMin    = face->header.yMin;
+        root->bbox.xMax    = face->header.xMax;
+        root->bbox.yMax    = face->header.yMax;
+        root->units_per_EM = face->header.Units_Per_EM;
+
+
+        /* XXX: Computing the ascender/descender/height is very different */
+        /*      from what the specification tells you.  Apparently, we    */
+        /*      must be careful because                                   */
+        /*                                                                */
+        /*      - not all fonts have an OS/2 table; in this case, we take */
+        /*        the values in the horizontal header.  However, these    */
+        /*        values very often are not reliable.                     */
+        /*                                                                */
+        /*      - otherwise, the correct typographic values are in the    */
+        /*        sTypoAscender, sTypoDescender & sTypoLineGap fields.    */
+        /*                                                                */
+        /*        However, certains fonts have these fields set to 0.     */
+        /*        Rather, they have usWinAscent & usWinDescent correctly  */
+        /*        set (but with different values).                        */
+        /*                                                                */
+        /*      As an example, Arial Narrow is implemented through four   */
+        /*      files ARIALN.TTF, ARIALNI.TTF, ARIALNB.TTF & ARIALNBI.TTF */
+        /*                                                                */
+        /*      Strangely, all fonts have the same values in their        */
+        /*      sTypoXXX fields, except ARIALNB which sets them to 0.     */
+        /*                                                                */
+        /*      On the other hand, they all have different                */
+        /*      usWinAscent/Descent values -- as a conclusion, the OS/2   */
+        /*      table cannot be used to compute the text height reliably! */
+        /*                                                                */
+
+        /* The ascender/descender/height are computed from the OS/2 table */
+        /* when found.  Otherwise, they're taken from the horizontal      */
+        /* header.                                                        */
+        /*                                                                */
+
+        root->ascender  = face->horizontal.Ascender;
+        root->descender = face->horizontal.Descender;
+
+        root->height    = (FT_Short)( root->ascender - root->descender +
+                                      face->horizontal.Line_Gap );
+
+#if 0
+        /* if the line_gap is 0, we add an extra 15% to the text height --  */
+        /* this computation is based on various versions of Times New Roman */
+        if ( face->horizontal.Line_Gap == 0 )
+          root->height = (FT_Short)( ( root->height * 115 + 50 ) / 100 );
+#endif
+
+#if 0
+
+        /* some fonts have the OS/2 "sTypoAscender", "sTypoDescender" & */
+        /* "sTypoLineGap" fields set to 0, like ARIALNB.TTF             */
+        if ( face->os2.version != 0xFFFFU && root->ascender )
+        {
+          FT_Int  height;
+
+
+          root->ascender  =  face->os2.sTypoAscender;
+          root->descender = -face->os2.sTypoDescender;
+
+          height = root->ascender + root->descender + face->os2.sTypoLineGap;
+          if ( height > root->height )
+            root->height = height;
+        }
+
+#endif /* 0 */
+
+        root->max_advance_width   = face->horizontal.advance_Width_Max;
+
+        root->max_advance_height  = (FT_Short)( face->vertical_info
+                                      ? face->vertical.advance_Height_Max
+                                      : root->height );
+
+        root->underline_position  = face->postscript.underlinePosition;
+        root->underline_thickness = face->postscript.underlineThickness;
+
+        /* root->max_points   -- already set up */
+        /* root->max_contours -- already set up */
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+#undef LOAD_
+
+
+  FT_LOCAL_DEF( void )
+  sfnt_done_face( TT_Face  face )
+  {
+    FT_Memory     memory = face->root.memory;
+    SFNT_Service  sfnt   = (SFNT_Service)face->sfnt;
+
+
+    if ( sfnt )
+    {
+      /* destroy the postscript names table if it is loaded */
+      if ( sfnt->free_psnames )
+        sfnt->free_psnames( face );
+
+      /* destroy the embedded bitmaps table if it is loaded */
+      if ( sfnt->free_sbits )
+        sfnt->free_sbits( face );
+    }
+
+    /* freeing the kerning table */
+    FT_FREE( face->kern_pairs );
+    face->num_kern_pairs = 0;
+
+    /* freeing the collection table */
+    FT_FREE( face->ttc_header.offsets );
+    face->ttc_header.count = 0;
+
+    /* freeing table directory */
+    FT_FREE( face->dir_tables );
+    face->num_tables = 0;
+
+    {
+      FT_Stream  stream = FT_FACE_STREAM( face );
+
+
+      /* simply release the 'cmap' table frame */
+      FT_FRAME_RELEASE( face->cmap_table );
+      face->cmap_size = 0;
+    }
+
+    /* freeing the horizontal metrics */
+    FT_FREE( face->horizontal.long_metrics );
+    FT_FREE( face->horizontal.short_metrics );
+
+    /* freeing the vertical ones, if any */
+    if ( face->vertical_info )
+    {
+      FT_FREE( face->vertical.long_metrics  );
+      FT_FREE( face->vertical.short_metrics );
+      face->vertical_info = 0;
+    }
+
+    /* freeing the gasp table */
+    FT_FREE( face->gasp.gaspRanges );
+    face->gasp.numRanges = 0;
+
+    /* freeing the name table */
+    sfnt->free_names( face );
+
+    /* freeing the hdmx table */
+    sfnt->free_hdmx( face );
+
+    /* freeing family and style name */
+    FT_FREE( face->root.family_name );
+    FT_FREE( face->root.style_name );
+
+    /* freeing sbit size table */
+    FT_FREE( face->root.available_sizes );
+    face->root.num_fixed_sizes = 0;
+
+    FT_FREE( face->postscript_name );
+
+    face->sfnt = 0;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/sfobjs.h b/nx-X11/extras/freetype2/src/sfnt/sfobjs.h
new file mode 100644
index 000000000..6241c93b3
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/sfobjs.h
@@ -0,0 +1,54 @@
+/***************************************************************************/
+/*                                                                         */
+/*  sfobjs.h                                                               */
+/*                                                                         */
+/*    SFNT object management (specification).                              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __SFOBJS_H__
+#define __SFOBJS_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_SFNT_H
+#include FT_INTERNAL_OBJECTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( FT_Error )
+  sfnt_init_face( FT_Stream      stream,
+                  TT_Face        face,
+                  FT_Int         face_index,
+                  FT_Int         num_params,
+                  FT_Parameter*  params );
+
+  FT_LOCAL( FT_Error )
+  sfnt_load_face( FT_Stream      stream,
+                  TT_Face        face,
+                  FT_Int         face_index,
+                  FT_Int         num_params,
+                  FT_Parameter*  params );
+
+  FT_LOCAL( void )
+  sfnt_done_face( TT_Face  face );
+
+
+FT_END_HEADER
+
+#endif /* __SFDRIVER_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/ttcmap0.c b/nx-X11/extras/freetype2/src/sfnt/ttcmap0.c
new file mode 100644
index 000000000..dd1c76aaa
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/ttcmap0.c
@@ -0,0 +1,1991 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttcmap0.c                                                              */
+/*                                                                         */
+/*    TrueType new character mapping table (cmap) support (body).          */
+/*                                                                         */
+/*  Copyright 2002, 2003 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_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+#include "ttload.h"
+#include "ttcmap0.h"
+
+#include "sferrors.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_ttcmap
+
+
+#define TT_PEEK_SHORT   FT_PEEK_SHORT
+#define TT_PEEK_USHORT  FT_PEEK_USHORT
+#define TT_PEEK_LONG    FT_PEEK_LONG
+#define TT_PEEK_ULONG   FT_PEEK_ULONG
+
+#define TT_NEXT_SHORT   FT_NEXT_SHORT
+#define TT_NEXT_USHORT  FT_NEXT_USHORT
+#define TT_NEXT_LONG    FT_NEXT_LONG
+#define TT_NEXT_ULONG   FT_NEXT_ULONG
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap_init( TT_CMap   cmap,
+                FT_Byte*  table )
+  {
+    cmap->data = table;
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           FORMAT 0                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET         TYPE          DESCRIPTION                */
+  /*                                                                       */
+  /*   format      0              USHORT        must be 0                  */
+  /*   length      2              USHORT        table length in bytes      */
+  /*   language    4              USHORT        Mac language code          */
+  /*   glyph_ids   6              BYTE[256]     array of glyph indices     */
+  /*               262                                                     */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_0
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap0_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*  p      = table + 2;
+    FT_UInt   length = TT_NEXT_USHORT( p );
+
+
+    if ( table + length > valid->limit || length < 262 )
+      FT_INVALID_TOO_SHORT;
+
+    /* check glyph indices whenever necessary */
+    if ( valid->level >= FT_VALIDATE_TIGHT )
+    {
+      FT_UInt  n, idx;
+
+
+      p = table + 6;
+      for ( n = 0; n < 256; n++ )
+      {
+        idx = *p++;
+        if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
+          FT_INVALID_GLYPH_ID;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap0_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*  table = cmap->data;
+
+
+    return char_code < 256 ? table[6 + char_code] : 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap0_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table    = cmap->data;
+    FT_UInt32  charcode = *pchar_code;
+    FT_UInt32  result   = 0;
+    FT_UInt    gindex   = 0;
+
+
+    table += 6;  /* go to glyph ids */
+    while ( ++charcode < 256 )
+    {
+      gindex = table[charcode];
+      if ( gindex != 0 )
+      {
+        result = charcode;
+        break;
+      }
+    }
+
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap0_get_info( TT_CMap       cmap,
+                     TT_CMapInfo  *cmap_info )
+  {
+    FT_Byte*  p = cmap->data + 4;
+
+
+    cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap0_class_rec =
+  {
+    {
+      sizeof( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap0_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap0_char_next
+    },
+    0,
+    (TT_CMap_ValidateFunc)   tt_cmap0_validate,
+    (TT_CMap_Info_GetFunc)   tt_cmap0_get_info
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_0 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 2                             *****/
+  /*****                                                               *****/
+  /***** This is used for certain CJK encodings that encode text in a  *****/
+  /***** mixed 8/16 bits encoding along the following lines:           *****/
+  /*****                                                               *****/
+  /***** * Certain byte values correspond to an 8-bit character code   *****/
+  /*****   (typically in the range 0..127 for ASCII compatibility).    *****/
+  /*****                                                               *****/
+  /***** * Certain byte values signal the first byte of a 2-byte       *****/
+  /*****   character code (but these values are also valid as the      *****/
+  /*****   second byte of a 2-byte character).                         *****/
+  /*****                                                               *****/
+  /***** The following charmap lookup and iteration functions all      *****/
+  /***** assume that the value "charcode" correspond to following:     *****/
+  /*****                                                               *****/
+  /*****   - For one byte characters, "charcode" is simply the         *****/
+  /*****     character code.                                           *****/
+  /*****                                                               *****/
+  /*****   - For two byte characters, "charcode" is the 2-byte         *****/
+  /*****     character code in big endian format.  More exactly:       *****/
+  /*****                                                               *****/
+  /*****       (charcode >> 8)    is the first byte value              *****/
+  /*****       (charcode & 0xFF)  is the second byte value             *****/
+  /*****                                                               *****/
+  /***** Note that not all values of "charcode" are valid according    *****/
+  /***** to these rules, and the function moderately check the         *****/
+  /***** arguments.                                                    *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET         TYPE            DESCRIPTION              */
+  /*                                                                       */
+  /*   format      0              USHORT          must be 2                */
+  /*   length      2              USHORT          table length in bytes    */
+  /*   language    4              USHORT          Mac language code        */
+  /*   keys        6              USHORT[256]     sub-header keys          */
+  /*   subs        518            SUBHEAD[NSUBS]  sub-headers array        */
+  /*   glyph_ids   518+NSUB*8     USHORT[]        glyph id array           */
+  /*                                                                       */
+  /* The `keys' table is used to map charcode high-bytes to sub-headers.   */
+  /* The value of `NSUBS' is the number of sub-headers defined in the      */
+  /* table and is computed by finding the maximum of the `keys' table.     */
+  /*                                                                       */
+  /* Note that for any n, `keys[n]' is a byte offset within the `subs'     */
+  /* table, i.e., it is the corresponding sub-header index multiplied      */
+  /* by 8.                                                                 */
+  /*                                                                       */
+  /* Each sub-header has the following format:                             */
+  /*                                                                       */
+  /*   NAME        OFFSET      TYPE            DESCRIPTION                 */
+  /*                                                                       */
+  /*   first       0           USHORT          first valid low-byte        */
+  /*   count       2           USHORT          number of valid low-bytes   */
+  /*   delta       4           SHORT           see below                   */
+  /*   offset      6           USHORT          see below                   */
+  /*                                                                       */
+  /* A sub-header defines, for each high-byte, the range of valid          */
+  /* low-bytes within the charmap.  Note that the range defined by `first' */
+  /* and `count' must be completely included in the interval [0..255]      */
+  /* according to the specification.                                       */
+  /*                                                                       */
+  /* If a character code is contained within a given sub-header, then      */
+  /* mapping it to a glyph index is done as follows:                       */
+  /*                                                                       */
+  /* * The value of `offset' is read.  This is a _byte_ distance from the  */
+  /*   location of the `offset' field itself into a slice of the           */
+  /*   `glyph_ids' table.  Let's call it `slice' (it's a USHORT[] too).    */
+  /*                                                                       */
+  /* * The value `slice[char.lo - first]' is read.  If it is 0, there is   */
+  /*   no glyph for the charcode.  Otherwise, the value of `delta' is      */
+  /*   added to it (modulo 65536) to form a new glyph index.               */
+  /*                                                                       */
+  /* It is up to the validation routine to check that all offsets fall     */
+  /* within the glyph ids table (and not within the `subs' table itself or */
+  /* outside of the CMap).                                                 */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_2
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap2_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*  p      = table + 2;           /* skip format */
+    FT_UInt   length = TT_PEEK_USHORT( p );
+    FT_UInt   n, max_subs;
+    FT_Byte*  keys;                         /* keys table */
+    FT_Byte*  subs;                         /* sub-headers */
+    FT_Byte*  glyph_ids;                    /* glyph id array */
+
+
+    if ( table + length > valid->limit || length < 6 + 512 )
+      FT_INVALID_TOO_SHORT;
+
+    keys = table + 6;
+
+    /* parse keys to compute sub-headers count */
+    p        = keys;
+    max_subs = 0;
+    for ( n = 0; n < 256; n++ )
+    {
+      FT_UInt  idx = TT_NEXT_USHORT( p );
+
+
+      /* value must be multiple of 8 */
+      if ( valid->level >= FT_VALIDATE_PARANOID && ( idx & 7 ) != 0 )
+        FT_INVALID_DATA;
+
+      idx >>= 3;
+
+      if ( idx > max_subs )
+        max_subs = idx;
+    }
+
+    FT_ASSERT( p == table + 518 );
+
+    subs      = p;
+    glyph_ids = subs + (max_subs + 1) * 8;
+    if ( glyph_ids > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    /* parse sub-headers */
+    for ( n = 0; n <= max_subs; n++ )
+    {
+      FT_UInt   first_code, code_count, offset;
+      FT_Int    delta;
+      FT_Byte*  ids;
+
+
+      first_code = TT_NEXT_USHORT( p );
+      code_count = TT_NEXT_USHORT( p );
+      delta      = TT_NEXT_SHORT( p );
+      offset     = TT_NEXT_USHORT( p );
+
+      /* check range within 0..255 */
+      if ( valid->level >= FT_VALIDATE_PARANOID )
+      {
+        if ( first_code >= 256 || first_code + code_count > 256 )
+          FT_INVALID_DATA;
+      }
+
+      /* check offset */
+      if ( offset != 0 )
+      {
+        ids = p - 2 + offset;
+        if ( ids < glyph_ids || ids + code_count*2 > table + length )
+          FT_INVALID_OFFSET;
+
+        /* check glyph ids */
+        if ( valid->level >= FT_VALIDATE_TIGHT )
+        {
+          FT_Byte*  limit = p + code_count * 2;
+          FT_UInt   idx;
+
+
+          for ( ; p < limit; )
+          {
+            idx = TT_NEXT_USHORT( p );
+            if ( idx != 0 )
+            {
+              idx = ( idx + delta ) & 0xFFFFU;
+              if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
+                FT_INVALID_GLYPH_ID;
+            }
+          }
+        }
+      }
+    }
+  }
+
+
+  /* return sub header corresponding to a given character code */
+  /* NULL on invalid charcode                                  */
+  static FT_Byte*
+  tt_cmap2_get_subheader( FT_Byte*   table,
+                          FT_UInt32  char_code )
+  {
+    FT_Byte*  result = NULL;
+
+
+    if ( char_code < 0x10000UL )
+    {
+      FT_UInt   char_lo = (FT_UInt)( char_code & 0xFF );
+      FT_UInt   char_hi = (FT_UInt)( char_code >> 8 );
+      FT_Byte*  p       = table + 6;    /* keys table */
+      FT_Byte*  subs    = table + 518;  /* subheaders table */
+      FT_Byte*  sub;
+
+
+      if ( char_hi == 0 )
+      {
+        /* an 8-bit character code -- we use subHeader 0 in this case */
+        /* to test whether the character code is in the charmap       */
+        /*                                                            */
+        sub = subs;  /* jump to first sub-header */
+
+        /* check that the sub-header for this byte is 0, which */
+        /* indicates that it's really a valid one-byte value   */
+        /* Otherwise, return 0                                 */
+        /*                                                     */
+        p += char_lo * 2;
+        if ( TT_PEEK_USHORT( p ) != 0 )
+          goto Exit;
+      }
+      else
+      {
+        /* a 16-bit character code */
+
+        /* jump to key entry  */
+        p  += char_hi * 2;
+        /* jump to sub-header */
+        sub = subs + ( FT_PAD_FLOOR( TT_PEEK_USHORT( p ), 8 ) );
+
+        /* check that the high byte isn't a valid one-byte value */
+        if ( sub == subs )
+          goto Exit;
+      }
+      result = sub;
+    }
+  Exit:
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap2_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*  table   = cmap->data;
+    FT_UInt   result  = 0;
+    FT_Byte*  subheader;
+
+
+    subheader = tt_cmap2_get_subheader( table, char_code );
+    if ( subheader )
+    {
+      FT_Byte*  p   = subheader;
+      FT_UInt   idx = (FT_UInt)(char_code & 0xFF);
+      FT_UInt   start, count;
+      FT_Int    delta;
+      FT_UInt   offset;
+
+
+      start  = TT_NEXT_USHORT( p );
+      count  = TT_NEXT_USHORT( p );
+      delta  = TT_NEXT_SHORT ( p );
+      offset = TT_PEEK_USHORT( p );
+
+      idx -= start;
+      if ( idx < count && offset != 0 )
+      {
+        p  += offset + 2 * idx;
+        idx = TT_PEEK_USHORT( p );
+
+        if ( idx != 0 )
+          result = (FT_UInt)( idx + delta ) & 0xFFFFU;
+      }
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap2_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pcharcode )
+  {
+    FT_Byte*   table    = cmap->data;
+    FT_UInt    gindex   = 0;
+    FT_UInt32  result   = 0;
+    FT_UInt32  charcode = *pcharcode + 1;
+    FT_Byte*   subheader;
+
+
+    while ( charcode < 0x10000UL )
+    {
+      subheader = tt_cmap2_get_subheader( table, charcode );
+      if ( subheader )
+      {
+        FT_Byte*  p       = subheader;
+        FT_UInt   start   = TT_NEXT_USHORT( p );
+        FT_UInt   count   = TT_NEXT_USHORT( p );
+        FT_Int    delta   = TT_NEXT_SHORT ( p );
+        FT_UInt   offset  = TT_PEEK_USHORT( p );
+        FT_UInt   char_lo = (FT_UInt)( charcode & 0xFF );
+        FT_UInt   pos, idx;
+
+
+        if ( offset == 0 )
+          goto Next_SubHeader;
+
+        if ( char_lo < start )
+        {
+          char_lo = start;
+          pos     = 0;
+        }
+        else
+          pos = (FT_UInt)( char_lo - start );
+
+        p       += offset + pos * 2;
+        charcode = FT_PAD_FLOOR( charcode, 256 ) + char_lo;
+
+        for ( ; pos < count; pos++, charcode++ )
+        {
+          idx = TT_NEXT_USHORT( p );
+
+          if ( idx != 0 )
+          {
+            gindex = ( idx + delta ) & 0xFFFFU;
+            if ( gindex != 0 )
+            {
+              result = charcode;
+              goto Exit;
+            }
+          }
+        }
+      }
+
+      /* jump to next sub-header, i.e. higher byte value */
+    Next_SubHeader:
+      charcode = FT_PAD_FLOOR( charcode, 256 ) + 256;
+    }
+
+  Exit:
+    *pcharcode = result;
+
+    return gindex;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap2_get_info( TT_CMap       cmap,
+                     TT_CMapInfo  *cmap_info )
+  {
+    FT_Byte*  p = cmap->data + 4;
+
+
+    cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap2_class_rec =
+  {
+    {
+      sizeof( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap2_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap2_char_next
+    },
+    2,
+    (TT_CMap_ValidateFunc)   tt_cmap2_validate,
+    (TT_CMap_Info_GetFunc)   tt_cmap2_get_info
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_2 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           FORMAT 4                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME          OFFSET         TYPE              DESCRIPTION          */
+  /*                                                                       */
+  /*   format        0              USHORT            must be 4            */
+  /*   length        2              USHORT            table length         */
+  /*                                                  in bytes             */
+  /*   language      4              USHORT            Mac language code    */
+  /*                                                                       */
+  /*   segCountX2    6              USHORT            2*NUM_SEGS           */
+  /*   searchRange   8              USHORT            2*(1 << LOG_SEGS)    */
+  /*   entrySelector 10             USHORT            LOG_SEGS             */
+  /*   rangeShift    12             USHORT            segCountX2 -         */
+  /*                                                    searchRange        */
+  /*                                                                       */
+  /*   endCount      14             USHORT[NUM_SEGS]  end charcode for     */
+  /*                                                  each segment; last   */
+  /*                                                  is 0xFFFF            */
+  /*                                                                       */
+  /*   pad           14+NUM_SEGS*2  USHORT            padding              */
+  /*                                                                       */
+  /*   startCount    16+NUM_SEGS*2  USHORT[NUM_SEGS]  first charcode for   */
+  /*                                                  each segment         */
+  /*                                                                       */
+  /*   idDelta       16+NUM_SEGS*4  SHORT[NUM_SEGS]   delta for each       */
+  /*                                                  segment              */
+  /*   idOffset      16+NUM_SEGS*6  SHORT[NUM_SEGS]   range offset for     */
+  /*                                                  each segment; can be */
+  /*                                                  zero                 */
+  /*                                                                       */
+  /*   glyphIds      16+NUM_SEGS*8  USHORT[]          array of glyph id    */
+  /*                                                  ranges               */
+  /*                                                                       */
+  /* Character codes are modelled by a series of ordered (increasing)      */
+  /* intervals called segments.  Each segment has start and end codes,     */
+  /* provided by the `startCount' and `endCount' arrays.  Segments must    */
+  /* not be overlapping and the last segment should always contain the     */
+  /* `0xFFFF' endCount.                                                    */
+  /*                                                                       */
+  /* The fields `searchRange', `entrySelector' and `rangeShift' are better */
+  /* ignored (they are traces of over-engineering in the TrueType          */
+  /* specification).                                                       */
+  /*                                                                       */
+  /* Each segment also has a signed `delta', as well as an optional offset */
+  /* within the `glyphIds' table.                                          */
+  /*                                                                       */
+  /* If a segment's idOffset is 0, the glyph index corresponding to any    */
+  /* charcode within the segment is obtained by adding the value of        */
+  /* `idDelta' directly to the charcode, modulo 65536.                     */
+  /*                                                                       */
+  /* Otherwise, a glyph index is taken from the glyph ids sub-array for    */
+  /* the segment, and the value of `idDelta' is added to it.               */
+  /*                                                                       */
+  /*                                                                       */
+  /* Finally, note that certain fonts contain invalid charmaps that        */
+  /* contain end=0xFFFF, start=0xFFFF, delta=0x0001, offset=0xFFFF at the  */
+  /* of their charmaps (e.g. opens___.ttf which comes with OpenOffice.org) */
+  /* we need special code to deal with them correctly...                   */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_4
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap4_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*  p      = table + 2;               /* skip format */
+    FT_UInt   length = TT_NEXT_USHORT( p );
+    FT_Byte   *ends, *starts, *offsets, *deltas, *glyph_ids;
+    FT_UInt   num_segs;
+
+
+    /* in certain fonts, the `length' field is invalid and goes */
+    /* out of bound.  We try to correct this here...            */
+    if ( length < 16 )
+      FT_INVALID_TOO_SHORT;
+
+    if ( table + length > valid->limit )
+    {
+      if ( valid->level >= FT_VALIDATE_TIGHT )
+        FT_INVALID_TOO_SHORT;
+
+      length = (FT_UInt)( valid->limit - table );
+    }
+
+    p        = table + 6;
+    num_segs = TT_NEXT_USHORT( p );   /* read segCountX2 */
+
+    if ( valid->level >= FT_VALIDATE_PARANOID )
+    {
+      /* check that we have an even value here */
+      if ( num_segs & 1 )
+        FT_INVALID_DATA;
+    }
+
+    num_segs /= 2;
+
+    /* check the search parameters - even though we never use them */
+    /*                                                             */
+    if ( valid->level >= FT_VALIDATE_PARANOID )
+    {
+      /* check the values of 'searchRange', 'entrySelector', 'rangeShift' */
+      FT_UInt  search_range   = TT_NEXT_USHORT( p );
+      FT_UInt  entry_selector = TT_NEXT_USHORT( p );
+      FT_UInt  range_shift    = TT_NEXT_USHORT( p );
+
+
+      if ( ( search_range | range_shift ) & 1 )  /* must be even values */
+        FT_INVALID_DATA;
+
+      search_range /= 2;
+      range_shift  /= 2;
+
+      /* `search range' is the greatest power of 2 that is <= num_segs */
+
+      if ( search_range                > num_segs                 ||
+           search_range * 2            < num_segs                 ||
+           search_range + range_shift != num_segs                 ||
+           search_range               != ( 1U << entry_selector ) )
+        FT_INVALID_DATA;
+    }
+
+    ends      = table   + 14;
+    starts    = table   + 16 + num_segs * 2;
+    deltas    = starts  + num_segs * 2;
+    offsets   = deltas  + num_segs * 2;
+    glyph_ids = offsets + num_segs * 2;
+
+    if ( glyph_ids > table + length )
+      FT_INVALID_TOO_SHORT;
+
+    /* check last segment, its end count must be FFFF */
+    if ( valid->level >= FT_VALIDATE_PARANOID )
+    {
+      p = ends + ( num_segs - 1 ) * 2;
+      if ( TT_PEEK_USHORT( p ) != 0xFFFFU )
+        FT_INVALID_DATA;
+    }
+
+    /* check that segments are sorted in increasing order and do not */
+    /* overlap; check also the offsets                               */
+    {
+      FT_UInt  start, end, last = 0, offset, n;
+      FT_Int   delta;
+
+
+      for ( n = 0; n < num_segs; n++ )
+      {
+        p = starts + n * 2;
+        start = TT_PEEK_USHORT( p );
+        p = ends + n * 2;
+        end = TT_PEEK_USHORT( p );
+        p = deltas + n * 2;
+        delta = TT_PEEK_SHORT( p );
+        p = offsets + n * 2;
+        offset = TT_PEEK_USHORT( p );
+
+        if ( start > end )
+          FT_INVALID_DATA;
+
+        /* this test should be performed at default validation level;  */
+        /* unfortunately, some popular Asian fonts present overlapping */
+        /* ranges in their charmaps                                    */
+        /*                                                             */
+        if ( valid->level >= FT_VALIDATE_TIGHT )
+        {
+          if ( n > 0 && start <= last )
+            FT_INVALID_DATA;
+        }
+
+        if ( offset && offset != 0xFFFFU )
+        {
+          p += offset;  /* start of glyph id array */
+
+          /* check that we point within the glyph ids table only */
+          if ( valid->level >= FT_VALIDATE_TIGHT )
+          {
+            if ( p < glyph_ids                                ||
+                 p + ( end - start + 1 ) * 2 > table + length )
+              FT_INVALID_DATA;
+          }
+          else
+          {
+            if ( p < glyph_ids                              ||
+                 p + ( end - start + 1 ) * 2 > valid->limit )
+              FT_INVALID_DATA;
+          }
+
+          /* check glyph indices within the segment range */
+          if ( valid->level >= FT_VALIDATE_TIGHT )
+          {
+            FT_UInt  i, idx;
+
+
+            for ( i = start; i < end; i++ )
+            {
+              idx = FT_NEXT_USHORT( p );
+              if ( idx != 0 )
+              {
+                idx = (FT_UInt)( idx + delta ) & 0xFFFFU;
+
+                if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
+                  FT_INVALID_GLYPH_ID;
+              }
+            }
+          }
+        }
+        else if ( offset == 0xFFFFU )
+        {
+          /* Some fonts (erroneously?) use a range offset of 0xFFFF */
+          /* to mean missing glyph in cmap table                    */
+          /*                                                        */
+          if ( valid->level >= FT_VALIDATE_PARANOID                     ||
+               n != num_segs - 1                                        ||
+               !( start == 0xFFFFU && end == 0xFFFFU && delta == 0x1U ) )
+            FT_INVALID_DATA;
+        }
+
+        last = end;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap4_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*  table  = cmap->data;
+    FT_UInt   result = 0;
+
+
+    if ( char_code < 0x10000UL )
+    {
+      FT_UInt   idx, num_segs2;
+      FT_Int    delta;
+      FT_UInt   code = (FT_UInt)char_code;
+      FT_Byte*  p;
+
+
+      p         = table + 6;
+      num_segs2 = FT_PAD_FLOOR( TT_PEEK_USHORT( p ), 2 );  /* be paranoid! */
+
+#if 1
+      /* Some fonts have more than 170 segments in their charmaps! */
+      /* We changed this function to use a more efficient binary   */
+      /* search for improving performance                          */
+      {
+        FT_UInt  min = 0;
+        FT_UInt  max = num_segs2 >> 1;
+        FT_UInt  mid, start, end, offset;
+
+
+        while ( min < max )
+        {
+          mid   = ( min + max ) >> 1;
+          p     = table + 14 + mid * 2;
+          end   = TT_NEXT_USHORT( p );
+          p    += num_segs2;
+          start = TT_PEEK_USHORT( p);
+
+          if ( code < start )
+            max = mid;
+          else if ( code > end )
+            min = mid + 1;
+          else
+          {
+            /* we found the segment */
+            idx = code;
+
+            p += num_segs2;
+            delta = TT_PEEK_SHORT( p );
+
+            p += num_segs2;
+            offset = TT_PEEK_USHORT( p );
+
+            if ( offset == 0xFFFFU )
+              goto Exit;
+
+            if ( offset != 0 )
+            {
+              p  += offset + 2 * ( idx - start );
+              idx = TT_PEEK_USHORT( p );
+            }
+
+            if ( idx != 0 )
+              result = (FT_UInt)( idx + delta ) & 0xFFFFU;
+
+            goto Exit;
+          }
+        }
+      }
+
+#else /* 0 - old code */
+
+      {
+        FT_UInt   n;
+        FT_Byte*  q;
+
+
+        p = table + 14;               /* ends table   */
+        q = table + 16 + num_segs2;   /* starts table */
+
+
+        for ( n = 0; n < num_segs2; n += 2 )
+        {
+          FT_UInt  end   = TT_NEXT_USHORT( p );
+          FT_UInt  start = TT_NEXT_USHORT( q );
+          FT_UInt  offset;
+
+
+          if ( code < start )
+            break;
+
+          if ( code <= end )
+          {
+            idx = code;
+
+            p = q + num_segs2 - 2;
+            delta = TT_PEEK_SHORT( p );
+            p += num_segs2;
+            offset = TT_PEEK_USHORT( p );
+
+            if ( offset == 0xFFFFU )
+              goto Exit;
+
+            if ( offset != 0 )
+            {
+              p  += offset + 2 * ( idx - start );
+              idx = TT_PEEK_USHORT( p );
+            }
+
+            if ( idx != 0 )
+              result = (FT_UInt)( idx + delta ) & 0xFFFFU;
+          }
+        }
+      }
+
+#endif /* 0 */
+
+    }
+
+  Exit:
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap4_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table     = cmap->data;
+    FT_UInt32  result    = 0;
+    FT_UInt    gindex    = 0;
+    FT_UInt32  char_code = *pchar_code;
+    FT_Byte*   p;
+    FT_UInt    code, num_segs2;
+
+
+    if ( char_code >= 0xFFFFUL )
+      goto Exit;
+
+    code      = (FT_UInt)char_code + 1;
+    p         = table + 6;
+    num_segs2 = FT_PAD_FLOOR( TT_PEEK_USHORT(p), 2 );  /* ensure even-ness */
+
+#if 1
+
+    for (;;)
+    {
+      /* Some fonts have more than 170 segments in their charmaps! */
+      /* We changed this function to use a more efficient binary   */
+      /* search                                                    */
+      FT_UInt  offset;
+      FT_Int   delta;
+      FT_UInt  min = 0;
+      FT_UInt  max = num_segs2 >> 1;
+      FT_UInt  mid, start, end;
+      FT_UInt  hi;
+
+
+      /* we begin by finding the segment which end is
+         closer to our code point */
+      hi = max + 1;
+      while ( min < max )
+      {
+        mid = ( min + max ) >> 1;
+        p   = table + 14 + mid * 2;
+        end = TT_PEEK_USHORT( p );
+
+        if ( end < code )
+          min = mid + 1;
+        else
+        {
+          hi  = mid;
+          max = mid;
+        }
+      }
+
+      if ( hi > max )
+      {
+        /* the point is behind the last segment;
+           we will exit right now */
+        goto Exit;
+      }
+
+      p   = table + 14 + hi * 2;
+      end = TT_PEEK_USHORT( p );
+
+      p    += 2 + num_segs2;
+      start = TT_PEEK_USHORT( p );
+
+      if ( code < start )
+        code = start;
+
+      p    += num_segs2;
+      delta = TT_PEEK_USHORT( p );
+
+      p     += num_segs2;
+      offset = TT_PEEK_USHORT( p );
+
+      if ( offset != 0 && offset != 0xFFFFU )
+      {
+        /* parse the glyph ids array for non-zero index */
+        p += offset + ( code - start ) * 2;
+        while ( code <= end )
+        {
+          gindex = TT_NEXT_USHORT( p );
+          if ( gindex != 0 )
+          {
+            gindex = (FT_UInt)( gindex + delta ) & 0xFFFFU;
+            if ( gindex != 0 )
+            {
+              result = code;
+              goto Exit;
+            }
+          }
+          code++;
+        }
+      }
+      else if ( offset == 0xFFFFU )
+      {
+        /* an offset of 0xFFFF means an empty glyph in certain fonts! */
+        code = end + 1;
+      }
+      else  /* offset == 0 */
+      {
+        gindex = (FT_UInt)( code + delta ) & 0xFFFFU;
+        if ( gindex != 0 )
+        {
+          result = code;
+          goto Exit;
+        }
+        code++;
+      }
+    }
+
+#else   /* old code -- kept for reference */
+
+    for ( ;; )
+    {
+      FT_UInt   offset, n;
+      FT_Int    delta;
+      FT_Byte*  q;
+
+
+      p = table + 14;              /* ends table  */
+      q = table + 16 + num_segs2;  /* starts table */
+
+      for ( n = 0; n < num_segs2; n += 2 )
+      {
+        FT_UInt  end   = TT_NEXT_USHORT( p );
+        FT_UInt  start = TT_NEXT_USHORT( q );
+
+
+        if ( code < start )
+          code = start;
+
+        if ( code <= end )
+        {
+          p = q + num_segs2 - 2;
+          delta = TT_PEEK_SHORT( p );
+          p += num_segs2;
+          offset = TT_PEEK_USHORT( p );
+
+          if ( offset != 0 && offset != 0xFFFFU )
+          {
+            /* parse the glyph ids array for non-0 index */
+            p += offset + ( code - start ) * 2;
+            while ( code <= end )
+            {
+              gindex = TT_NEXT_USHORT( p );
+              if ( gindex != 0 )
+              {
+                gindex = (FT_UInt)( gindex + delta ) & 0xFFFFU;
+                if ( gindex != 0 )
+                  break;
+              }
+              code++;
+            }
+          }
+          else if ( offset == 0xFFFFU )
+          {
+            /* an offset of 0xFFFF means an empty glyph in certain fonts! */
+            code = end;
+            break;
+          }
+          else
+            gindex = (FT_UInt)( code + delta ) & 0xFFFFU;
+
+          if ( gindex == 0 )
+            break;
+
+          result = code;
+          goto Exit;
+        }
+      }
+      /* loop to next trial charcode */
+      if ( code >= 0xFFFFU )
+        break;
+
+      code++;
+    }
+
+#endif /* !1 */
+
+  Exit:
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap4_get_info( TT_CMap       cmap,
+                     TT_CMapInfo  *cmap_info )
+  {
+    FT_Byte*  p = cmap->data + 4;
+
+
+    cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap4_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap4_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap4_char_next
+    },
+    4,
+    (TT_CMap_ValidateFunc)   tt_cmap4_validate,
+    (TT_CMap_Info_GetFunc)   tt_cmap4_get_info
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_4 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 6                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET          TYPE             DESCRIPTION            */
+  /*                                                                       */
+  /*   format       0              USHORT           must be 4              */
+  /*   length       2              USHORT           table length in bytes  */
+  /*   language     4              USHORT           Mac language code      */
+  /*                                                                       */
+  /*   first        6              USHORT           first segment code     */
+  /*   count        8              USHORT           segment size in chars  */
+  /*   glyphIds     10             USHORT[count]    glyph ids              */
+  /*                                                                       */
+  /* A very simplified segment mapping.                                    */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_6
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap6_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*  p;
+    FT_UInt   length, count;
+
+
+    if ( table + 10 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    p      = table + 2;
+    length = TT_NEXT_USHORT( p );
+
+    p      = table + 8;             /* skip language and start index */
+    count  = TT_NEXT_USHORT( p );
+
+    if ( table + length > valid->limit || length < 10 + count * 2 )
+      FT_INVALID_TOO_SHORT;
+
+    /* check glyph indices */
+    if ( valid->level >= FT_VALIDATE_TIGHT )
+    {
+      FT_UInt  gindex;
+
+
+      for ( ; count > 0; count-- )
+      {
+        gindex = TT_NEXT_USHORT( p );
+        if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
+          FT_INVALID_GLYPH_ID;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap6_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*  table  = cmap->data;
+    FT_UInt   result = 0;
+    FT_Byte*  p      = table + 6;
+    FT_UInt   start  = TT_NEXT_USHORT( p );
+    FT_UInt   count  = TT_NEXT_USHORT( p );
+    FT_UInt   idx    = (FT_UInt)( char_code - start );
+
+
+    if ( idx < count )
+    {
+      p += 2 * idx;
+      result = TT_PEEK_USHORT( p );
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap6_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table     = cmap->data;
+    FT_UInt32  result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+    FT_UInt    gindex    = 0;
+
+    FT_Byte*   p         = table + 6;
+    FT_UInt    start     = TT_NEXT_USHORT( p );
+    FT_UInt    count     = TT_NEXT_USHORT( p );
+    FT_UInt    idx;
+
+
+    if ( char_code >= 0x10000UL )
+      goto Exit;
+
+    if ( char_code < start )
+      char_code = start;
+
+    idx = (FT_UInt)( char_code - start );
+    p  += 2 * idx;
+
+    for ( ; idx < count; idx++ )
+    {
+      gindex = TT_NEXT_USHORT( p );
+      if ( gindex != 0 )
+      {
+        result = char_code;
+        break;
+      }
+      char_code++;
+    }
+
+  Exit:
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap6_get_info( TT_CMap       cmap,
+                     TT_CMapInfo  *cmap_info )
+  {
+    FT_Byte*  p = cmap->data + 4;
+
+
+    cmap_info->language = (FT_ULong)TT_PEEK_USHORT( p );
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap6_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap6_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap6_char_next
+    },
+    6,
+    (TT_CMap_ValidateFunc)   tt_cmap6_validate,
+    (TT_CMap_Info_GetFunc)   tt_cmap6_get_info
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_6 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 8                             *****/
+  /*****                                                               *****/
+  /***** It's hard to completely understand what the OpenType spec     *****/
+  /***** says about this format, but here is my conclusion.            *****/
+  /*****                                                               *****/
+  /***** The purpose of this format is to easily map UTF-16 text to    *****/
+  /***** glyph indices.  Basically, the `char_code' must be in one of  *****/
+  /***** the following formats:                                        *****/
+  /*****                                                               *****/
+  /*****   - A 16-bit value that isn't part of the Unicode Surrogates  *****/
+  /*****     Area (i.e. U+D800-U+DFFF).                                *****/
+  /*****                                                               *****/
+  /*****   - A 32-bit value, made of two surrogate values, i.e.. if    *****/
+  /*****     `char_code = (char_hi << 16) | char_lo', then both        *****/
+  /*****     `char_hi' and `char_lo' must be in the Surrogates Area.   *****/
+  /*****      Area.                                                    *****/
+  /*****                                                               *****/
+  /***** The 'is32' table embedded in the charmap indicates whether a  *****/
+  /***** given 16-bit value is in the surrogates area or not.          *****/
+  /*****                                                               *****/
+  /***** So, for any given `char_code', we can assert the following:   *****/
+  /*****                                                               *****/
+  /*****   If `char_hi == 0' then we must have `is32[char_lo] == 0'.   *****/
+  /*****                                                               *****/
+  /*****   If `char_hi != 0' then we must have both                    *****/
+  /*****   `is32[char_hi] != 0' and `is32[char_lo] != 0'.              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET         TYPE        DESCRIPTION                  */
+  /*                                                                       */
+  /*   format      0              USHORT      must be 8                    */
+  /*   reseved     2              USHORT      reserved                     */
+  /*   length      4              ULONG       length in bytes              */
+  /*   language    8              ULONG       Mac language code            */
+  /*   is32        12             BYTE[8192]  32-bitness bitmap            */
+  /*   count       8204           ULONG       number of groups             */
+  /*                                                                       */
+  /* This header is followed by 'count' groups of the following format:    */
+  /*                                                                       */
+  /*   start       0              ULONG       first charcode               */
+  /*   end         4              ULONG       last charcode                */
+  /*   startId     8              ULONG       start glyph id for the group */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_8
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap8_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*   p = table + 4;
+    FT_Byte*   is32;
+    FT_UInt32  length;
+    FT_UInt32  num_groups;
+
+
+    if ( table + 16 + 8192 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    length = TT_NEXT_ULONG( p );
+    if ( table + length > valid->limit || length < 8208 )
+      FT_INVALID_TOO_SHORT;
+
+    is32       = table + 12;
+    p          = is32  + 8192;          /* skip `is32' array */
+    num_groups = TT_NEXT_ULONG( p );
+
+    if ( p + num_groups * 12 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    /* check groups, they must be in increasing order */
+    {
+      FT_UInt32  n, start, end, start_id, count, last = 0;
+
+
+      for ( n = 0; n < num_groups; n++ )
+      {
+        FT_UInt   hi, lo;
+
+
+        start    = TT_NEXT_ULONG( p );
+        end      = TT_NEXT_ULONG( p );
+        start_id = TT_NEXT_ULONG( p );
+
+        if ( start > end )
+          FT_INVALID_DATA;
+
+        if ( n > 0 && start <= last )
+          FT_INVALID_DATA;
+
+        if ( valid->level >= FT_VALIDATE_TIGHT )
+        {
+          if ( start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) )
+            FT_INVALID_GLYPH_ID;
+
+          count = (FT_UInt32)( end - start + 1 );
+
+          if ( start & ~0xFFFFU )
+          {
+            /* start_hi != 0; check that is32[i] is 1 for each i in */
+            /* the `hi' and `lo' of the range [start..end]          */
+            for ( ; count > 0; count--, start++ )
+            {
+              hi = (FT_UInt)( start >> 16 );
+              lo = (FT_UInt)( start & 0xFFFFU );
+
+              if ( (is32[hi >> 3] & ( 0x80 >> ( hi & 7 ) ) ) == 0 )
+                FT_INVALID_DATA;
+
+              if ( (is32[lo >> 3] & ( 0x80 >> ( lo & 7 ) ) ) == 0 )
+                FT_INVALID_DATA;
+            }
+          }
+          else
+          {
+            /* start_hi == 0; check that is32[i] is 0 for each i in */
+            /* the range [start..end]                               */
+
+            /* end_hi cannot be != 0! */
+            if ( end & ~0xFFFFU )
+              FT_INVALID_DATA;
+
+            for ( ; count > 0; count--, start++ )
+            {
+              lo = (FT_UInt)( start & 0xFFFFU );
+
+              if ( (is32[lo >> 3] & ( 0x80 >> ( lo & 7 ) ) ) != 0 )
+                FT_INVALID_DATA;
+            }
+          }
+        }
+
+        last = end;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap8_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*   table      = cmap->data;
+    FT_UInt    result     = 0;
+    FT_Byte*   p          = table + 8204;
+    FT_UInt32  num_groups = TT_NEXT_ULONG( p );
+    FT_UInt32  start, end, start_id;
+
+
+    for ( ; num_groups > 0; num_groups-- )
+    {
+      start    = TT_NEXT_ULONG( p );
+      end      = TT_NEXT_ULONG( p );
+      start_id = TT_NEXT_ULONG( p );
+
+      if ( char_code < start )
+        break;
+
+      if ( char_code <= end )
+      {
+        result = (FT_UInt)( start_id + char_code - start );
+        break;
+      }
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap8_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_UInt32  result     = 0;
+    FT_UInt32  char_code  = *pchar_code + 1;
+    FT_UInt    gindex     = 0;
+    FT_Byte*   table      = cmap->data;
+    FT_Byte*   p          = table + 8204;
+    FT_UInt32  num_groups = TT_NEXT_ULONG( p );
+    FT_UInt32  start, end, start_id;
+
+
+    p = table + 8208;
+
+    for ( ; num_groups > 0; num_groups-- )
+    {
+      start    = TT_NEXT_ULONG( p );
+      end      = TT_NEXT_ULONG( p );
+      start_id = TT_NEXT_ULONG( p );
+
+      if ( char_code < start )
+        char_code = start;
+
+      if ( char_code <= end )
+      {
+        gindex = (FT_UInt)( char_code - start + start_id );
+        if ( gindex != 0 )
+        {
+          result = char_code;
+          goto Exit;
+        }
+      }
+    }
+
+  Exit:
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap8_get_info( TT_CMap       cmap,
+                     TT_CMapInfo  *cmap_info )
+  {
+    FT_Byte*  p = cmap->data + 8;
+
+
+    cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap8_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap8_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap8_char_next
+    },
+    8,
+    (TT_CMap_ValidateFunc)   tt_cmap8_validate,
+    (TT_CMap_Info_GetFunc)   tt_cmap8_get_info
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_8 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 10                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME      OFFSET  TYPE               DESCRIPTION                    */
+  /*                                                                       */
+  /*   format     0      USHORT             must be 10                     */
+  /*   reserved   2      USHORT             reserved                       */
+  /*   length     4      ULONG              length in bytes                */
+  /*   language   8      ULONG              Mac language code              */
+  /*                                                                       */
+  /*   start     12      ULONG              first char in range            */
+  /*   count     16      ULONG              number of chars in range       */
+  /*   glyphIds  20      USHORT[count]      glyph indices covered          */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_10
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap10_validate( FT_Byte*      table,
+                      FT_Validator  valid )
+  {
+    FT_Byte*  p = table + 4;
+    FT_ULong  length, count;
+
+
+    if ( table + 20 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    length = TT_NEXT_ULONG( p );
+    p      = table + 16;
+    count  = TT_NEXT_ULONG( p );
+
+    if ( table + length > valid->limit || length < 20 + count * 2 )
+      FT_INVALID_TOO_SHORT;
+
+    /* check glyph indices */
+    if ( valid->level >= FT_VALIDATE_TIGHT )
+    {
+      FT_UInt  gindex;
+
+
+      for ( ; count > 0; count-- )
+      {
+        gindex = TT_NEXT_USHORT( p );
+        if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
+          FT_INVALID_GLYPH_ID;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap10_char_index( TT_CMap    cmap,
+                        FT_UInt32  char_code )
+  {
+    FT_Byte*   table  = cmap->data;
+    FT_UInt    result = 0;
+    FT_Byte*   p      = table + 12;
+    FT_UInt32  start  = TT_NEXT_ULONG( p );
+    FT_UInt32  count  = TT_NEXT_ULONG( p );
+    FT_UInt32  idx    = (FT_ULong)( char_code - start );
+
+
+    if ( idx < count )
+    {
+      p     += 2 * idx;
+      result = TT_PEEK_USHORT( p );
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap10_char_next( TT_CMap     cmap,
+                       FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table     = cmap->data;
+    FT_UInt32  char_code = *pchar_code + 1;
+    FT_UInt    gindex    = 0;
+    FT_Byte*   p         = table + 12;
+    FT_UInt32  start     = TT_NEXT_ULONG( p );
+    FT_UInt32  count     = TT_NEXT_ULONG( p );
+    FT_UInt32  idx;
+
+
+    if ( char_code < start )
+      char_code = start;
+
+    idx = (FT_UInt32)( char_code - start );
+    p  += 2 * idx;
+
+    for ( ; idx < count; idx++ )
+    {
+      gindex = TT_NEXT_USHORT( p );
+      if ( gindex != 0 )
+        break;
+      char_code++;
+    }
+
+    *pchar_code = char_code;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap10_get_info( TT_CMap       cmap,
+                      TT_CMapInfo  *cmap_info )
+  {
+    FT_Byte*  p = cmap->data + 8;
+
+
+    cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap10_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap10_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap10_char_next
+    },
+    10,
+    (TT_CMap_ValidateFunc)   tt_cmap10_validate,
+    (TT_CMap_Info_GetFunc)   tt_cmap10_get_info
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_10 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 12                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET     TYPE       DESCRIPTION                       */
+  /*                                                                       */
+  /*   format      0          USHORT     must be 12                        */
+  /*   reserved    2          USHORT     reserved                          */
+  /*   length      4          ULONG      length in bytes                   */
+  /*   language    8          ULONG      Mac language code                 */
+  /*   count       12         ULONG      number of groups                  */
+  /*               16                                                      */
+  /*                                                                       */
+  /* This header is followed by `count' groups of the following format:    */
+  /*                                                                       */
+  /*   start       0          ULONG      first charcode                    */
+  /*   end         4          ULONG      last charcode                     */
+  /*   startId     8          ULONG      start glyph id for the group      */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_12
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap12_validate( FT_Byte*      table,
+                      FT_Validator  valid )
+  {
+    FT_Byte*   p;
+    FT_ULong   length;
+    FT_ULong   num_groups;
+
+
+    if ( table + 16 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    p      = table + 4;
+    length = TT_NEXT_ULONG( p );
+
+    p          = table + 12;
+    num_groups = TT_NEXT_ULONG( p );
+
+    if ( table + length > valid->limit || length < 16 + 12 * num_groups )
+      FT_INVALID_TOO_SHORT;
+
+    /* check groups, they must be in increasing order */
+    {
+      FT_ULong  n, start, end, start_id, last = 0;
+
+
+      for ( n = 0; n < num_groups; n++ )
+      {
+        start    = TT_NEXT_ULONG( p );
+        end      = TT_NEXT_ULONG( p );
+        start_id = TT_NEXT_ULONG( p );
+
+        if ( start > end )
+          FT_INVALID_DATA;
+
+        if ( n > 0 && start <= last )
+          FT_INVALID_DATA;
+
+        if ( valid->level >= FT_VALIDATE_TIGHT )
+        {
+          if ( start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) )
+            FT_INVALID_GLYPH_ID;
+        }
+
+        last = end;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap12_char_index( TT_CMap    cmap,
+                        FT_UInt32  char_code )
+  {
+    FT_UInt    result     = 0;
+    FT_Byte*   table      = cmap->data;
+    FT_Byte*   p          = table + 12;
+    FT_UInt32  num_groups = TT_NEXT_ULONG( p );
+    FT_UInt32  start, end, start_id;
+
+
+    for ( ; num_groups > 0; num_groups-- )
+    {
+      start    = TT_NEXT_ULONG( p );
+      end      = TT_NEXT_ULONG( p );
+      start_id = TT_NEXT_ULONG( p );
+
+      if ( char_code < start )
+        break;
+
+      if ( char_code <= end )
+      {
+        result = (FT_UInt)( start_id + char_code - start );
+        break;
+      }
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap12_char_next( TT_CMap     cmap,
+                       FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table      = cmap->data;
+    FT_UInt32  result     = 0;
+    FT_UInt32  char_code  = *pchar_code + 1;
+    FT_UInt    gindex     = 0;
+    FT_Byte*   p          = table + 12;
+    FT_UInt32  num_groups = TT_NEXT_ULONG( p );
+    FT_UInt32  start, end, start_id;
+
+
+    p = table + 16;
+
+    for ( ; num_groups > 0; num_groups-- )
+    {
+      start    = TT_NEXT_ULONG( p );
+      end      = TT_NEXT_ULONG( p );
+      start_id = TT_NEXT_ULONG( p );
+
+      if ( char_code < start )
+        char_code = start;
+
+      if ( char_code <= end )
+      {
+        gindex = (FT_UInt)(char_code - start + start_id);
+        if ( gindex != 0 )
+        {
+          result = char_code;
+          goto Exit;
+        }
+      }
+    }
+
+  Exit:
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap12_get_info( TT_CMap       cmap,
+                      TT_CMapInfo  *cmap_info )
+  {
+    FT_Byte*  p = cmap->data + 8;
+
+
+    cmap_info->language = (FT_ULong)TT_PEEK_ULONG( p );
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap12_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap12_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap12_char_next
+    },
+    12,
+    (TT_CMap_ValidateFunc)   tt_cmap12_validate,
+    (TT_CMap_Info_GetFunc)   tt_cmap12_get_info
+  };
+
+
+#endif /* TT_CONFIG_CMAP_FORMAT_12 */
+
+
+  static const TT_CMap_Class  tt_cmap_classes[] =
+  {
+#ifdef TT_CONFIG_CMAP_FORMAT_0
+    &tt_cmap0_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_2
+    &tt_cmap2_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_4
+    &tt_cmap4_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_6
+    &tt_cmap6_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_8
+    &tt_cmap8_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_10
+    &tt_cmap10_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_12
+    &tt_cmap12_class_rec,
+#endif
+
+    NULL,
+  };
+
+
+  /* parse the `cmap' table and build the corresponding TT_CMap objects */
+  /* in the current face                                                */
+  /*                                                                    */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_build_cmaps( TT_Face  face )
+  {
+    FT_Byte*           table = face->cmap_table;
+    FT_Byte*           limit = table + face->cmap_size;
+    FT_UInt volatile   num_cmaps;
+    FT_Byte* volatile  p     = table;
+
+
+    if ( p + 4 > limit )
+      return SFNT_Err_Invalid_Table;
+
+    /* only recognize format 0 */
+    if ( TT_NEXT_USHORT( p ) != 0 )
+    {
+      p -= 2;
+      FT_ERROR(( "tt_face_build_cmaps: unsupported `cmap' table format = %d\n",
+                 TT_PEEK_USHORT( p ) ));
+      return SFNT_Err_Invalid_Table;
+    }
+
+    num_cmaps = TT_NEXT_USHORT( p );
+
+    for ( ; num_cmaps > 0 && p + 8 <= limit; num_cmaps-- )
+    {
+      FT_CharMapRec  charmap;
+      FT_UInt32      offset;
+
+
+      charmap.platform_id = TT_NEXT_USHORT( p );
+      charmap.encoding_id = TT_NEXT_USHORT( p );
+      charmap.face        = FT_FACE( face );
+      charmap.encoding    = FT_ENCODING_NONE;  /* will be filled later */
+      offset              = TT_NEXT_ULONG( p );
+
+      if ( offset && table + offset + 2 < limit )
+      {
+        FT_Byte*                       cmap   = table + offset;
+        volatile FT_UInt               format = TT_PEEK_USHORT( cmap );
+        const TT_CMap_Class* volatile  pclazz = tt_cmap_classes;
+        TT_CMap_Class                  clazz;
+
+
+        for ( ; *pclazz; pclazz++ )
+        {
+          clazz = *pclazz;
+          if ( clazz->format == format )
+          {
+            volatile TT_ValidatorRec  valid;
+
+
+            ft_validator_init( FT_VALIDATOR( &valid ), cmap, limit,
+                               FT_VALIDATE_DEFAULT );
+
+            valid.num_glyphs = (FT_UInt)face->root.num_glyphs;
+
+            if ( ft_setjmp( FT_VALIDATOR( &valid )->jump_buffer ) == 0 )
+            {
+              /* validate this cmap sub-table */
+              clazz->validate( cmap, FT_VALIDATOR( &valid ) );
+            }
+
+            if ( valid.validator.error == 0 )
+              (void)FT_CMap_New( (FT_CMap_Class)clazz, cmap, &charmap, NULL );
+            else
+            {
+              FT_ERROR(( "tt_face_build_cmaps:" ));
+              FT_ERROR(( " broken cmap sub-table ignored!\n" ));
+            }
+            break;
+          }
+        }
+      }
+    }
+
+    return 0;
+  }
+
+
+  FT_LOCAL( FT_Error )
+  tt_get_cmap_info( FT_CharMap    charmap,
+                    TT_CMapInfo  *cmap_info )
+  {
+    FT_CMap        cmap  = (FT_CMap)charmap;
+    TT_CMap_Class  clazz = (TT_CMap_Class)cmap->clazz;
+
+
+    return clazz->get_cmap_info( charmap, cmap_info );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/ttcmap0.h b/nx-X11/extras/freetype2/src/sfnt/ttcmap0.h
new file mode 100644
index 000000000..6ca9ca110
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/ttcmap0.h
@@ -0,0 +1,80 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttcmap0.h                                                              */
+/*                                                                         */
+/*    TrueType new character mapping table (cmap) support (specification). */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 __TTCMAP0_H__
+#define __TTCMAP0_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_SERVICE_TT_CMAP_H
+
+FT_BEGIN_HEADER
+
+  typedef struct  TT_CMapRec_
+  {
+    FT_CMapRec  cmap;
+    FT_Byte*    data;           /* pointer to in-memory cmap table */
+
+  } TT_CMapRec, *TT_CMap;
+
+  typedef const struct TT_CMap_ClassRec_*  TT_CMap_Class;
+
+
+  typedef FT_Error
+  (*TT_CMap_ValidateFunc)( FT_Byte*      data,
+                           FT_Validator  valid );
+
+  typedef struct  TT_CMap_ClassRec_
+  {
+    FT_CMap_ClassRec      clazz;
+    FT_UInt               format;
+    TT_CMap_ValidateFunc  validate;
+    TT_CMap_Info_GetFunc  get_cmap_info;
+
+  } TT_CMap_ClassRec;
+
+
+  typedef struct  TT_ValidatorRec_
+  {
+    FT_ValidatorRec  validator;
+    FT_UInt          num_glyphs;
+
+  } TT_ValidatorRec, *TT_Validator;
+
+
+#define TT_VALIDATOR( x )          ((TT_Validator)( x ))
+#define TT_VALID_GLYPH_COUNT( x )  TT_VALIDATOR( x )->num_glyphs
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_build_cmaps( TT_Face  face );
+
+  /* used in tt-cmaps service */
+  FT_LOCAL( FT_Error )
+  tt_get_cmap_info( FT_CharMap    charmap,
+                    TT_CMapInfo  *cmap_info );
+
+
+FT_END_HEADER
+
+#endif /* __TTCMAP0_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/ttload.c b/nx-X11/extras/freetype2/src/sfnt/ttload.c
new file mode 100644
index 000000000..fa5c6a71a
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/ttload.c
@@ -0,0 +1,1912 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttload.c                                                               */
+/*                                                                         */
+/*    Load the basic TrueType tables, i.e., tables that can be either in   */
+/*    TTF or OTF fonts (body).                                             */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_TRUETYPE_TAGS_H
+#include "ttload.h"
+
+#include "sferrors.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_ttload
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_lookup_table                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Looks for a TrueType table by name.                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A face object handle.                                      */
+  /*                                                                       */
+  /*    tag  :: The searched tag.                                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A pointer to the table directory entry.  0 if not found.           */
+  /*                                                                       */
+  FT_LOCAL_DEF( TT_Table  )
+  tt_face_lookup_table( TT_Face   face,
+                        FT_ULong  tag  )
+  {
+    TT_Table  entry;
+    TT_Table  limit;
+
+
+    FT_TRACE3(( "tt_face_lookup_table: %08p, `%c%c%c%c' -- ",
+                face,
+                (FT_Char)( tag >> 24 ),
+                (FT_Char)( tag >> 16 ),
+                (FT_Char)( tag >> 8  ),
+                (FT_Char)( tag       ) ));
+
+    entry = face->dir_tables;
+    limit = entry + face->num_tables;
+
+    for ( ; entry < limit; entry++ )
+    {
+      /* For compatibility with Windows, we consider 0-length */
+      /* tables the same as missing tables.                   */
+      if ( entry->Tag == tag && entry->Length != 0 )
+      {
+        FT_TRACE3(( "found table.\n" ));
+        return entry;
+      }
+    }
+
+    FT_TRACE3(( "could not find table!\n" ));
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_goto_table                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Looks for a TrueType table by name, then seek a stream to it.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A face object handle.                                    */
+  /*                                                                       */
+  /*    tag    :: The searched tag.                                        */
+  /*                                                                       */
+  /*    stream :: The stream to seek when the table is found.              */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    length :: The length of the table if found, undefined otherwise.   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_goto_table( TT_Face    face,
+                      FT_ULong   tag,
+                      FT_Stream  stream,
+                      FT_ULong*  length )
+  {
+    TT_Table  table;
+    FT_Error  error;
+
+
+    table = tt_face_lookup_table( face, tag );
+    if ( table )
+    {
+      if ( length )
+        *length = table->Length;
+
+      if ( FT_STREAM_SEEK( table->Offset ) )
+       goto Exit;
+    }
+    else
+      error = SFNT_Err_Table_Missing;
+
+  Exit:
+    return error;
+  }
+
+
+ /* In theory, we should check the values of `search_range',               */
+ /* `entry_selector', and `range_shift' to detect non-SFNT based files     */
+ /* whose header might also start with 0x100000L (yes, these exist).       */
+ /*                                                                        */
+ /* Very unfortunately, many TrueType fonts don't have these fields        */
+ /* set correctly and we must ignore them to support them.  An alternative */
+ /* way to check the font file is thus to:                                 */
+ /*                                                                        */
+ /* - check that `num_tables' is valid                                     */
+ /* - look for a "head" table, check its size, and parse it to             */
+ /*   see if its "magic" field is correctly set                            */
+ /*                                                                        */
+ /* When checking directory entries, ignore the tables `glyx' and `locx'   */
+ /* which are hacked-out versions of `glyf' and `loca' in some PostScript  */
+ /* Type 42 fonts, and will generally be invalid.                          */
+ /*                                                                        */
+  static FT_Error
+  sfnt_dir_check( FT_Stream  stream,
+                  FT_ULong   offset,
+                  FT_UInt    num_tables )
+   {
+    FT_Error        error;
+    FT_UInt         nn, has_head = 0;
+
+    const FT_ULong  glyx_tag = FT_MAKE_TAG( 'g', 'l', 'y', 'x' );
+    const FT_ULong  locx_tag = FT_MAKE_TAG( 'l', 'o', 'c', 'x' );
+
+    static const FT_Frame_Field  sfnt_dir_entry_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_TableRec
+
+      FT_FRAME_START( 16 ),
+        FT_FRAME_ULONG( Tag ),
+        FT_FRAME_ULONG( CheckSum ),
+        FT_FRAME_ULONG( Offset ),
+        FT_FRAME_ULONG( Length ),
+      FT_FRAME_END
+    };
+
+
+    /* if 'num_tables' is 0, read the table count from the file */
+    if ( num_tables == 0 )
+    {
+      if ( FT_STREAM_SEEK( offset )     ||
+           FT_STREAM_SKIP( 4 )          ||
+           FT_READ_USHORT( num_tables ) ||
+           FT_STREAM_SKIP( 6 )          )
+        goto Bad_Format;
+
+      if ( offset + 12 + num_tables*16 > stream->size )
+        goto Bad_Format;
+    }
+    else if ( FT_STREAM_SEEK( offset + 12 ) )
+      goto Bad_Format;
+
+    for ( nn = 0; nn < num_tables; nn++ )
+    {
+      TT_TableRec  table;
+
+
+      if ( FT_STREAM_READ_FIELDS( sfnt_dir_entry_fields, &table ) )
+        goto Bad_Format;
+
+      if ( table.Offset + table.Length > stream->size     &&
+           table.Tag != glyx_tag && table.Tag != locx_tag )
+        goto Bad_Format;
+
+      if ( table.Tag == TTAG_head )
+      {
+        FT_UInt32  magic;
+
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+      head_retry:
+#endif  /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+        has_head = 1;
+
+        /* The table length should be 0x36, but certain font tools
+         * make it 0x38, so we will just check that it is greater.
+         *
+         * Note that according to the specification,
+         * the table must be padded to 32-bit lengths, but this doesn't
+         * apply to the value of its "Length" field!
+         */
+        if ( table.Length < 0x36                 ||
+             FT_STREAM_SEEK( table.Offset + 12 ) ||
+             FT_READ_ULONG( magic )              ||
+             magic != 0x5F0F3CF5UL               )
+          goto Bad_Format;
+
+        if ( FT_STREAM_SEEK( offset + 28 + 16*nn ) )
+          goto Bad_Format;
+      }
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+      else if ( table.Tag == TTAG_bhed )
+        goto head_retry;
+#endif  /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */      
+    }
+
+    if ( has_head == 0 )
+      goto Bad_Format;
+
+  Exit:
+    return  error;
+
+  Bad_Format:
+    error = SFNT_Err_Unknown_File_Format;
+    goto Exit;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_sfnt_header                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the header of a SFNT font file.  Supports collections.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: A handle to the target face object.                  */
+  /*                                                                       */
+  /*    stream     :: The input stream.                                    */
+  /*                                                                       */
+  /*    face_index :: If the font is a collection, the number of the font  */
+  /*                  in the collection.  Must be zero otherwise.          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    sfnt       :: The SFNT header.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream cursor must be at the font file's origin.               */
+  /*                                                                       */
+  /*    This function recognizes fonts embedded in a `TrueType collection' */
+  /*                                                                       */
+  /*    The header will be checked whether it is valid by looking at the   */
+  /*    values of `search_range', `entry_selector', and `range_shift'.     */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_sfnt_header( TT_Face      face,
+                            FT_Stream    stream,
+                            FT_Long      face_index,
+                            SFNT_Header  sfnt )
+  {
+    FT_Error   error;
+    FT_ULong   font_format_tag, format_tag, offset;
+    FT_Memory  memory = stream->memory;
+
+    static const FT_Frame_Field  sfnt_header_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  SFNT_HeaderRec
+
+      FT_FRAME_START( 8 ),
+        FT_FRAME_USHORT( num_tables ),
+        FT_FRAME_USHORT( search_range ),
+        FT_FRAME_USHORT( entry_selector ),
+        FT_FRAME_USHORT( range_shift ),
+      FT_FRAME_END
+    };
+
+    static const FT_Frame_Field  ttc_header_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TTC_HeaderRec
+
+      FT_FRAME_START( 8 ),
+        FT_FRAME_LONG( version ),
+        FT_FRAME_LONG( count   ),
+      FT_FRAME_END
+    };
+
+
+    FT_TRACE2(( "tt_face_load_sfnt_header: %08p, %ld\n",
+                face, face_index ));
+
+    face->ttc_header.tag     = 0;
+    face->ttc_header.version = 0;
+    face->ttc_header.count   = 0;
+
+    face->num_tables = 0;
+
+    /* First of all, read the first 4 bytes.  If it is `ttcf', then the   */
+    /* file is a TrueType collection, otherwise it is a single-face font. */
+    /*                                                                    */
+    offset = FT_STREAM_POS();
+
+    if ( FT_READ_ULONG( font_format_tag ) )
+      goto Exit;
+
+    format_tag = font_format_tag;
+
+    if ( font_format_tag == TTAG_ttcf )
+    {
+      FT_Int  n;
+
+
+      FT_TRACE3(( "tt_face_load_sfnt_header: file is a collection\n" ));
+
+      /* It is a TrueType collection, i.e. a file containing several */
+      /* font files.  Read the font directory now                    */
+      if ( FT_STREAM_READ_FIELDS( ttc_header_fields, &face->ttc_header ) )
+        goto Exit;
+
+      /* now read the offsets of each font in the file */
+      if ( FT_NEW_ARRAY( face->ttc_header.offsets, face->ttc_header.count ) ||
+           FT_FRAME_ENTER( face->ttc_header.count * 4L )                    )
+        goto Exit;
+
+      for ( n = 0; n < face->ttc_header.count; n++ )
+        face->ttc_header.offsets[n] = FT_GET_ULONG();
+
+      FT_FRAME_EXIT();
+
+      /* check face index */
+      if ( face_index >= face->ttc_header.count )
+      {
+        error = SFNT_Err_Bad_Argument;
+        goto Exit;
+      }
+
+      /* seek to the appropriate TrueType file, then read tag */
+      offset = face->ttc_header.offsets[face_index];
+
+      if ( FT_STREAM_SEEK( offset )   ||
+           FT_READ_LONG( format_tag ) )
+        goto Exit;
+    }
+
+    /* the format tag was read, now check the rest of the header */
+    sfnt->format_tag = format_tag;
+    sfnt->offset     = offset;
+
+    if ( FT_STREAM_READ_FIELDS( sfnt_header_fields, sfnt ) )
+      goto Exit;
+
+    /* now check the sfnt directory */
+    error = sfnt_dir_check( stream, offset, sfnt->num_tables );
+    if ( error )
+    {
+      FT_TRACE2(( "tt_face_load_sfnt_header: file is not SFNT!\n" ));
+      error = SFNT_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* disallow face index values > 0 for non-TTC files */
+    if ( font_format_tag != TTAG_ttcf && face_index > 0 )
+      error = SFNT_Err_Bad_Argument;
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_directory                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the table directory into a face object.                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /*    sfnt   :: The SFNT directory header.                               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream cursor must be at the font file's origin.               */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_directory( TT_Face      face,
+                          FT_Stream    stream,
+                          SFNT_Header  sfnt )
+  {
+    FT_Error     error;
+    FT_Memory    memory = stream->memory;
+
+    TT_TableRec  *entry, *limit;
+
+
+    FT_TRACE2(( "tt_face_load_directory: %08p\n", face ));
+
+    FT_TRACE2(( "-- Tables count:   %12u\n",  sfnt->num_tables ));
+    FT_TRACE2(( "-- Format version: %08lx\n", sfnt->format_tag ));
+
+    face->num_tables = sfnt->num_tables;
+
+    if ( FT_QNEW_ARRAY( face->dir_tables, face->num_tables ) )
+      goto Exit;
+
+    if ( FT_STREAM_SEEK( sfnt->offset + 12 )      ||
+         FT_FRAME_ENTER( face->num_tables * 16L ) )
+      goto Exit;
+
+    entry = face->dir_tables;
+    limit = entry + face->num_tables;
+
+    for ( ; entry < limit; entry++ )
+    {                    /* loop through the tables and get all entries */
+      entry->Tag      = FT_GET_TAG4();
+      entry->CheckSum = FT_GET_ULONG();
+      entry->Offset   = FT_GET_LONG();
+      entry->Length   = FT_GET_LONG();
+
+      FT_TRACE2(( "  %c%c%c%c  -  %08lx  -  %08lx\n",
+                  (FT_Char)( entry->Tag >> 24 ),
+                  (FT_Char)( entry->Tag >> 16 ),
+                  (FT_Char)( entry->Tag >> 8  ),
+                  (FT_Char)( entry->Tag       ),
+                  entry->Offset,
+                  entry->Length ));
+    }
+
+    FT_FRAME_EXIT();
+
+    FT_TRACE2(( "Directory loaded\n\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_any                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads any font table into client memory.                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: The face object to look for.                             */
+  /*                                                                       */
+  /*    tag    :: The tag of table to load.  Use the value 0 if you want   */
+  /*              to access the whole font file, else set this parameter   */
+  /*              to a valid TrueType table tag that you can forge with    */
+  /*              the MAKE_TT_TAG macro.                                   */
+  /*                                                                       */
+  /*    offset :: The starting offset in the table (or the file if         */
+  /*              tag == 0).                                               */
+  /*                                                                       */
+  /*    length :: The address of the decision variable:                    */
+  /*                                                                       */
+  /*                If length == NULL:                                     */
+  /*                  Loads the whole table.  Returns an error if          */
+  /*                  `offset' == 0!                                       */
+  /*                                                                       */
+  /*                If *length == 0:                                       */
+  /*                  Exits immediately; returning the length of the given */
+  /*                  table or of the font file, depending on the value of */
+  /*                  `tag'.                                               */
+  /*                                                                       */
+  /*                If *length != 0:                                       */
+  /*                  Loads the next `length' bytes of table or font,      */
+  /*                  starting at offset `offset' (in table or font too).  */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    buffer :: The address of target buffer.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_any( TT_Face    face,
+                    FT_ULong   tag,
+                    FT_Long    offset,
+                    FT_Byte*   buffer,
+                    FT_ULong*  length )
+  {
+    FT_Error   error;
+    FT_Stream  stream;
+    TT_Table   table;
+    FT_ULong   size;
+
+
+    if ( tag != 0 )
+    {
+      /* look for tag in font directory */
+      table = tt_face_lookup_table( face, tag );
+      if ( !table )
+      {
+        error = SFNT_Err_Table_Missing;
+        goto Exit;
+      }
+
+      offset += table->Offset;
+      size    = table->Length;
+    }
+    else
+      /* tag == 0 -- the user wants to access the font file directly */
+      size = face->root.stream->size;
+
+    if ( length && *length == 0 )
+    {
+      *length = size;
+
+      return SFNT_Err_Ok;
+    }
+
+    if ( length )
+      size = *length;
+
+    stream = face->root.stream;
+    /* the `if' is syntactic sugar for picky compilers */
+    if ( FT_STREAM_READ_AT( offset, buffer, size ) )
+      goto Exit;
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_generic_header                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the TrueType table `head' or `bhed'.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  tt_face_load_generic_header( TT_Face    face,
+                               FT_Stream  stream,
+                               FT_ULong   tag )
+  {
+    FT_Error    error;
+    TT_Header*  header;
+
+    static const FT_Frame_Field  header_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_Header
+
+      FT_FRAME_START( 54 ),
+        FT_FRAME_ULONG ( Table_Version ),
+        FT_FRAME_ULONG ( Font_Revision ),
+        FT_FRAME_LONG  ( CheckSum_Adjust ),
+        FT_FRAME_LONG  ( Magic_Number ),
+        FT_FRAME_USHORT( Flags ),
+        FT_FRAME_USHORT( Units_Per_EM ),
+        FT_FRAME_LONG  ( Created[0] ),
+        FT_FRAME_LONG  ( Created[1] ),
+        FT_FRAME_LONG  ( Modified[0] ),
+        FT_FRAME_LONG  ( Modified[1] ),
+        FT_FRAME_SHORT ( xMin ),
+        FT_FRAME_SHORT ( yMin ),
+        FT_FRAME_SHORT ( xMax ),
+        FT_FRAME_SHORT ( yMax ),
+        FT_FRAME_USHORT( Mac_Style ),
+        FT_FRAME_USHORT( Lowest_Rec_PPEM ),
+        FT_FRAME_SHORT ( Font_Direction ),
+        FT_FRAME_SHORT ( Index_To_Loc_Format ),
+        FT_FRAME_SHORT ( Glyph_Data_Format ),
+      FT_FRAME_END
+    };
+
+
+    FT_TRACE2(( "tt_face_load_generic_header: "
+                "%08p, looking up font table `%c%c%c%c'.\n",
+                face,
+                (FT_Char)( tag >> 24 ),
+                (FT_Char)( tag >> 16 ),
+                (FT_Char)( tag >> 8  ),
+                (FT_Char)( tag       ) ));
+
+    error = face->goto_table( face, tag, stream, 0 );
+    if ( error )
+    {
+      FT_TRACE2(( "tt_face_load_generic_header: Font table is missing!\n" ));
+      goto Exit;
+    }
+
+    header = &face->header;
+
+    if ( FT_STREAM_READ_FIELDS( header_fields, header ) )
+      goto Exit;
+
+    FT_TRACE2(( "    Units per EM: %8u\n", header->Units_Per_EM ));
+    FT_TRACE2(( "    IndexToLoc:   %8d\n", header->Index_To_Loc_Format ));
+    FT_TRACE2(( "tt_face_load_generic_header: Font table loaded.\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_header( TT_Face    face,
+                       FT_Stream  stream )
+  {
+    return tt_face_load_generic_header( face, stream, TTAG_head );
+  }
+
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_bitmap_header( TT_Face    face,
+                              FT_Stream  stream )
+  {
+    return tt_face_load_generic_header( face, stream, TTAG_bhed );
+  }
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_max_profile                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the maximum profile into a face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_max_profile( TT_Face    face,
+                            FT_Stream  stream )
+  {
+    FT_Error        error;
+    TT_MaxProfile*  maxProfile = &face->max_profile;
+
+    const FT_Frame_Field  maxp_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_MaxProfile
+
+      FT_FRAME_START( 6 ),
+        FT_FRAME_LONG  ( version ),
+        FT_FRAME_USHORT( numGlyphs ),
+      FT_FRAME_END
+    };
+
+    const FT_Frame_Field  maxp_fields_extra[] =
+    {
+      FT_FRAME_START( 26 ),
+        FT_FRAME_USHORT( maxPoints ),
+        FT_FRAME_USHORT( maxContours ),
+        FT_FRAME_USHORT( maxCompositePoints ),
+        FT_FRAME_USHORT( maxCompositeContours ),
+        FT_FRAME_USHORT( maxZones ),
+        FT_FRAME_USHORT( maxTwilightPoints ),
+        FT_FRAME_USHORT( maxStorage ),
+        FT_FRAME_USHORT( maxFunctionDefs ),
+        FT_FRAME_USHORT( maxInstructionDefs ),
+        FT_FRAME_USHORT( maxStackElements ),
+        FT_FRAME_USHORT( maxSizeOfInstructions ),
+        FT_FRAME_USHORT( maxComponentElements ),
+        FT_FRAME_USHORT( maxComponentDepth ),
+      FT_FRAME_END
+    };
+
+
+    FT_TRACE2(( "Load_TT_MaxProfile: %08p\n", face ));
+
+    error = face->goto_table( face, TTAG_maxp, stream, 0 );
+    if ( error )
+      goto Exit;
+
+    if ( FT_STREAM_READ_FIELDS( maxp_fields, maxProfile ) )
+      goto Exit;
+
+    face->root.num_glyphs = maxProfile->numGlyphs;
+
+    maxProfile->maxPoints             = 0;
+    maxProfile->maxContours           = 0;
+    maxProfile->maxCompositePoints    = 0;
+    maxProfile->maxCompositeContours  = 0;
+    maxProfile->maxZones              = 0;
+    maxProfile->maxTwilightPoints     = 0;
+    maxProfile->maxStorage            = 0;
+    maxProfile->maxFunctionDefs       = 0;
+    maxProfile->maxInstructionDefs    = 0;
+    maxProfile->maxStackElements      = 0;
+    maxProfile->maxSizeOfInstructions = 0;
+    maxProfile->maxComponentElements  = 0;
+    maxProfile->maxComponentDepth     = 0;
+
+    if ( maxProfile->version >= 0x10000L )
+    {
+      if ( FT_STREAM_READ_FIELDS( maxp_fields_extra, maxProfile ) )
+        goto Exit;
+
+      /* XXX: an adjustment that is necessary to load certain */
+      /*      broken fonts like `Keystrokes MT' :-(           */
+      /*                                                      */
+      /*   We allocate 64 function entries by default when    */
+      /*   the maxFunctionDefs field is null.                 */
+
+      if ( maxProfile->maxFunctionDefs == 0 )
+        maxProfile->maxFunctionDefs = 64;
+
+      face->root.internal->max_points =
+        (FT_UShort)FT_MAX( maxProfile->maxCompositePoints,
+                           maxProfile->maxPoints );
+
+      face->root.internal->max_contours =
+        (FT_Short)FT_MAX( maxProfile->maxCompositeContours,
+                          maxProfile->maxContours );
+
+      face->max_components = (FT_ULong)maxProfile->maxComponentElements +
+                             maxProfile->maxComponentDepth;
+
+      /* XXX: some fonts have maxComponents set to 0; we will */
+      /*      then use 16 of them by default.                 */
+      if ( face->max_components == 0 )
+        face->max_components = 16;
+
+      /* We also increase maxPoints and maxContours in order to support */
+      /* some broken fonts.                                             */
+      face->root.internal->max_points   += (FT_UShort)8;
+      face->root.internal->max_contours += (FT_Short) 4;
+    }
+
+    FT_TRACE2(( "MAXP loaded.\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_metrics                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the horizontal or vertical metrics table into a face object. */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face     :: A handle to the target face object.                    */
+  /*                                                                       */
+  /*    stream   :: The input stream.                                      */
+  /*                                                                       */
+  /*    vertical :: A boolean flag.  If set, load vertical metrics.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  tt_face_load_metrics( TT_Face    face,
+                        FT_Stream  stream,
+                        FT_Bool    vertical )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+
+    FT_ULong   table_len;
+    FT_Long    num_shorts, num_longs, num_shorts_checked;
+
+    TT_LongMetrics *   longs;
+    TT_ShortMetrics**  shorts;
+
+
+    FT_TRACE2(( "TT_Load_%s_Metrics: %08p\n", vertical ? "Vertical"
+                                                       : "Horizontal",
+                                              face ));
+
+    if ( vertical )
+    {
+      /* The table is optional, quit silently if it wasn't found       */
+      /*                                                               */
+      /* XXX: Some fonts have a valid vertical header with a non-null  */
+      /*      `number_of_VMetrics' fields, but no corresponding `vmtx' */
+      /*      table to get the metrics from (e.g. mingliu).            */
+      /*                                                               */
+      /*      For safety, we set the field to 0!                       */
+      /*                                                               */
+      error = face->goto_table( face, TTAG_vmtx, stream, &table_len );
+      if ( error )
+      {
+        /* Set number_Of_VMetrics to 0! */
+        FT_TRACE2(( "  no vertical header in file.\n" ));
+        face->vertical.number_Of_VMetrics = 0;
+        error = SFNT_Err_Ok;
+        goto Exit;
+      }
+
+      num_longs = face->vertical.number_Of_VMetrics;
+      longs     = (TT_LongMetrics *)&face->vertical.long_metrics;
+      shorts    = (TT_ShortMetrics**)&face->vertical.short_metrics;
+    }
+    else
+    {
+      error = face->goto_table( face, TTAG_hmtx, stream, &table_len );
+      if ( error )
+      {
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+        /* If this is an incrementally loaded font and there are */
+        /* overriding metrics tolerate a missing 'hmtx' table.   */
+        if ( face->root.internal->incremental_interface &&
+             face->root.internal->incremental_interface->funcs->
+               get_glyph_metrics )
+        {
+          face->horizontal.number_Of_HMetrics = 0;
+          error = SFNT_Err_Ok;
+          goto Exit;
+        }
+#endif
+
+        FT_ERROR(( " no horizontal metrics in file!\n" ));
+        error = SFNT_Err_Hmtx_Table_Missing;
+        goto Exit;
+      }
+
+      num_longs = face->horizontal.number_Of_HMetrics;
+      longs     = (TT_LongMetrics *)&face->horizontal.long_metrics;
+      shorts    = (TT_ShortMetrics**)&face->horizontal.short_metrics;
+    }
+
+    /* never trust derived values */
+
+    num_shorts         = face->max_profile.numGlyphs - num_longs;
+    num_shorts_checked = ( table_len - num_longs * 4L ) / 2;
+
+    if ( num_shorts < 0 )
+    {
+      FT_ERROR(( "TT_Load_%s_Metrics: more metrics than glyphs!\n",
+                 vertical ? "Vertical"
+                          : "Horizontal" ));
+
+      error = vertical ? SFNT_Err_Invalid_Vert_Metrics
+                       : SFNT_Err_Invalid_Horiz_Metrics;
+      goto Exit;
+    }
+
+    if ( FT_QNEW_ARRAY( *longs,  num_longs  ) ||
+         FT_QNEW_ARRAY( *shorts, num_shorts ) )
+      goto Exit;
+
+    if ( FT_FRAME_ENTER( table_len ) )
+      goto Exit;
+
+    {
+      TT_LongMetrics  cur   = *longs;
+      TT_LongMetrics  limit = cur + num_longs;
+
+
+      for ( ; cur < limit; cur++ )
+      {
+        cur->advance = FT_GET_USHORT();
+        cur->bearing = FT_GET_SHORT();
+      }
+    }
+
+    /* do we have an inconsistent number of metric values? */
+    {
+      TT_ShortMetrics*  cur   = *shorts;
+      TT_ShortMetrics*  limit = cur +
+                                FT_MIN( num_shorts, num_shorts_checked );
+
+
+      for ( ; cur < limit; cur++ )
+        *cur = FT_GET_SHORT();
+
+      /* we fill up the missing left side bearings with the     */
+      /* last valid value.  Since this will occur for buggy CJK */
+      /* fonts usually only, nothing serious will happen        */
+      if ( num_shorts > num_shorts_checked && num_shorts_checked > 0 )
+      {
+        FT_Short  val = (*shorts)[num_shorts_checked - 1];
+
+
+        limit = *shorts + num_shorts;
+        for ( ; cur < limit; cur++ )
+          *cur = val;
+      }
+    }
+
+    FT_FRAME_EXIT();
+
+    FT_TRACE2(( "loaded\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_metrics_header                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the horizontal or vertical header in a face object.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face     :: A handle to the target face object.                    */
+  /*                                                                       */
+  /*    stream   :: The input stream.                                      */
+  /*                                                                       */
+  /*    vertical :: A boolean flag.  If set, load vertical metrics.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_metrics_header( TT_Face    face,
+                               FT_Stream  stream,
+                               FT_Bool    vertical )
+  {
+    FT_Error        error;
+    TT_HoriHeader*  header;
+
+    const FT_Frame_Field  metrics_header_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_HoriHeader
+
+      FT_FRAME_START( 36 ),
+        FT_FRAME_ULONG ( Version ),
+        FT_FRAME_SHORT ( Ascender ),
+        FT_FRAME_SHORT ( Descender ),
+        FT_FRAME_SHORT ( Line_Gap ),
+        FT_FRAME_USHORT( advance_Width_Max ),
+        FT_FRAME_SHORT ( min_Left_Side_Bearing ),
+        FT_FRAME_SHORT ( min_Right_Side_Bearing ),
+        FT_FRAME_SHORT ( xMax_Extent ),
+        FT_FRAME_SHORT ( caret_Slope_Rise ),
+        FT_FRAME_SHORT ( caret_Slope_Run ),
+        FT_FRAME_SHORT ( caret_Offset ),
+        FT_FRAME_SHORT ( Reserved[0] ),
+        FT_FRAME_SHORT ( Reserved[1] ),
+        FT_FRAME_SHORT ( Reserved[2] ),
+        FT_FRAME_SHORT ( Reserved[3] ),
+        FT_FRAME_SHORT ( metric_Data_Format ),
+        FT_FRAME_USHORT( number_Of_HMetrics ),
+      FT_FRAME_END
+    };
+
+
+    FT_TRACE2(( vertical ? "Vertical header " : "Horizontal header " ));
+
+    if ( vertical )
+    {
+      face->vertical_info = 0;
+
+      /* The vertical header table is optional, so return quietly if */
+      /* we don't find it.                                           */
+      error = face->goto_table( face, TTAG_vhea, stream, 0 );
+      if ( error )
+      {
+        error = SFNT_Err_Ok;
+        goto Exit;
+      }
+
+      face->vertical_info = 1;
+      header = (TT_HoriHeader*)&face->vertical;
+    }
+    else
+    {
+      /* The horizontal header is mandatory; return an error if we */
+      /* don't find it.                                            */
+      error = face->goto_table( face, TTAG_hhea, stream, 0 );
+      if ( error )
+      {
+        error = SFNT_Err_Horiz_Header_Missing;
+        goto Exit;
+      }
+
+      header = &face->horizontal;
+    }
+
+    if ( FT_STREAM_READ_FIELDS( metrics_header_fields, header ) )
+      goto Exit;
+
+    header->long_metrics  = NULL;
+    header->short_metrics = NULL;
+
+    FT_TRACE2(( "loaded\n" ));
+
+    /* Now try to load the corresponding metrics */
+
+    error = tt_face_load_metrics( face, stream, vertical );
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_names                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the name records.                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_names( TT_Face    face,
+                      FT_Stream  stream )
+  {
+    FT_Error      error;
+    FT_Memory     memory = stream->memory;
+    FT_ULong      table_pos, table_len;
+    FT_ULong      storage_start, storage_limit;
+    FT_UInt       count;
+    TT_NameTable  table;
+
+    static const FT_Frame_Field  name_table_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_NameTableRec
+
+      FT_FRAME_START( 6 ),
+        FT_FRAME_USHORT( format ),
+        FT_FRAME_USHORT( numNameRecords ),
+        FT_FRAME_USHORT( storageOffset ),
+      FT_FRAME_END
+    };
+
+    static const FT_Frame_Field  name_record_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_NameEntryRec
+
+      /* no FT_FRAME_START */
+        FT_FRAME_USHORT( platformID ),
+        FT_FRAME_USHORT( encodingID ),
+        FT_FRAME_USHORT( languageID ),
+        FT_FRAME_USHORT( nameID ),
+        FT_FRAME_USHORT( stringLength ),
+        FT_FRAME_USHORT( stringOffset ),
+      FT_FRAME_END
+    };
+
+
+    table         = &face->name_table;
+    table->stream = stream;
+
+    FT_TRACE2(( "Names " ));
+
+    error = face->goto_table( face, TTAG_name, stream, &table_len );
+    if ( error )
+    {
+      /* The name table is required so indicate failure. */
+      FT_TRACE2(( "is missing!\n" ));
+      error = SFNT_Err_Name_Table_Missing;
+      goto Exit;
+    }
+
+    table_pos = FT_STREAM_POS();
+
+
+    if ( FT_STREAM_READ_FIELDS( name_table_fields, table ) )
+      goto Exit;
+
+    /* Some popular Asian fonts have an invalid `storageOffset' value   */
+    /* (it should be at least "6 + 12*num_names").  However, the string */
+    /* offsets, computed as "storageOffset + entry->stringOffset", are  */
+    /* valid pointers within the name table...                          */
+    /*                                                                  */
+    /* We thus can't check `storageOffset' right now.                   */
+    /*                                                                  */
+    storage_start = table_pos + 6 + 12*table->numNameRecords;
+    storage_limit = table_pos + table_len;
+
+    if ( storage_start > storage_limit )
+    {
+      FT_ERROR(( "tt_face_load_names: invalid `name' table\n" ));
+      error = SFNT_Err_Name_Table_Missing;
+      goto Exit;
+    }
+
+    /* Allocate the array of name records. */
+    count                 = table->numNameRecords;
+    table->numNameRecords = 0;
+
+    if ( FT_NEW_ARRAY( table->names, count ) ||
+         FT_FRAME_ENTER( count * 12 )        )
+      goto Exit;
+
+    /* Load the name records and determine how much storage is needed */
+    /* to hold the strings themselves.                                */
+    {
+      TT_NameEntryRec*  entry = table->names;
+
+
+      for ( ; count > 0; count-- )
+      {
+        if ( FT_STREAM_READ_FIELDS( name_record_fields, entry ) )
+          continue;
+
+        /* check that the name is not empty */
+        if ( entry->stringLength == 0 )
+          continue;
+
+        /* check that the name string is within the table */
+        entry->stringOffset += table_pos + table->storageOffset;
+        if ( entry->stringOffset                       < storage_start ||
+             entry->stringOffset + entry->stringLength > storage_limit )
+        {
+          /* invalid entry - ignore it */
+          entry->stringOffset = 0;
+          entry->stringLength = 0;
+          continue;
+        }
+
+        entry++;
+      }
+
+      table->numNameRecords = (FT_UInt)( entry - table->names );
+    }
+
+    FT_FRAME_EXIT();
+
+    FT_TRACE2(( "loaded\n" ));
+
+    /* everything went well, update face->num_names */
+    face->num_names = (FT_UShort) table->numNameRecords;
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_free_names                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Frees the name records.                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the target face object.                        */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  tt_face_free_names( TT_Face  face )
+  {
+    FT_Memory     memory = face->root.driver->root.memory;
+    TT_NameTable  table  = &face->name_table;
+    TT_NameEntry  entry  = table->names;
+    FT_UInt       count  = table->numNameRecords;
+
+
+    if ( table->names )
+    {
+      for ( ; count > 0; count--, entry++ )
+      {
+        FT_FREE( entry->string );
+        entry->stringLength = 0;
+      }
+
+      /* free strings table */
+      FT_FREE( table->names );
+    }
+
+    table->numNameRecords = 0;
+    table->format         = 0;
+    table->storageOffset  = 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_cmap                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the cmap directory in a face object.  The cmaps itselves are */
+  /*    loaded on demand in the `ttcmap.c' module.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: A handle to the input stream.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_cmap( TT_Face    face,
+                     FT_Stream  stream )
+  {
+    FT_Error  error;
+
+
+    error = face->goto_table( face, TTAG_cmap, stream, &face->cmap_size );
+    if ( error )
+    {
+      FT_TRACE2(( "No `cmap' table in font !\n" ));
+      error = SFNT_Err_CMap_Table_Missing;
+      goto Exit;
+    }
+
+    if ( !FT_FRAME_EXTRACT( face->cmap_size, face->cmap_table ) )
+      FT_TRACE2(( "`cmap' table loaded\n" ));
+    else
+    {
+      FT_ERROR(( "`cmap' table is too short!\n" ));
+      face->cmap_size = 0;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_os2                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the OS2 table.                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: A handle to the input stream.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_os2( TT_Face    face,
+                    FT_Stream  stream )
+  {
+    FT_Error  error;
+    TT_OS2*   os2;
+
+    const FT_Frame_Field  os2_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_OS2
+
+      FT_FRAME_START( 78 ),
+        FT_FRAME_USHORT( version ),
+        FT_FRAME_SHORT ( xAvgCharWidth ),
+        FT_FRAME_USHORT( usWeightClass ),
+        FT_FRAME_USHORT( usWidthClass ),
+        FT_FRAME_SHORT ( fsType ),
+        FT_FRAME_SHORT ( ySubscriptXSize ),
+        FT_FRAME_SHORT ( ySubscriptYSize ),
+        FT_FRAME_SHORT ( ySubscriptXOffset ),
+        FT_FRAME_SHORT ( ySubscriptYOffset ),
+        FT_FRAME_SHORT ( ySuperscriptXSize ),
+        FT_FRAME_SHORT ( ySuperscriptYSize ),
+        FT_FRAME_SHORT ( ySuperscriptXOffset ),
+        FT_FRAME_SHORT ( ySuperscriptYOffset ),
+        FT_FRAME_SHORT ( yStrikeoutSize ),
+        FT_FRAME_SHORT ( yStrikeoutPosition ),
+        FT_FRAME_SHORT ( sFamilyClass ),
+        FT_FRAME_BYTE  ( panose[0] ),
+        FT_FRAME_BYTE  ( panose[1] ),
+        FT_FRAME_BYTE  ( panose[2] ),
+        FT_FRAME_BYTE  ( panose[3] ),
+        FT_FRAME_BYTE  ( panose[4] ),
+        FT_FRAME_BYTE  ( panose[5] ),
+        FT_FRAME_BYTE  ( panose[6] ),
+        FT_FRAME_BYTE  ( panose[7] ),
+        FT_FRAME_BYTE  ( panose[8] ),
+        FT_FRAME_BYTE  ( panose[9] ),
+        FT_FRAME_ULONG ( ulUnicodeRange1 ),
+        FT_FRAME_ULONG ( ulUnicodeRange2 ),
+        FT_FRAME_ULONG ( ulUnicodeRange3 ),
+        FT_FRAME_ULONG ( ulUnicodeRange4 ),
+        FT_FRAME_BYTE  ( achVendID[0] ),
+        FT_FRAME_BYTE  ( achVendID[1] ),
+        FT_FRAME_BYTE  ( achVendID[2] ),
+        FT_FRAME_BYTE  ( achVendID[3] ),
+
+        FT_FRAME_USHORT( fsSelection ),
+        FT_FRAME_USHORT( usFirstCharIndex ),
+        FT_FRAME_USHORT( usLastCharIndex ),
+        FT_FRAME_SHORT ( sTypoAscender ),
+        FT_FRAME_SHORT ( sTypoDescender ),
+        FT_FRAME_SHORT ( sTypoLineGap ),
+        FT_FRAME_USHORT( usWinAscent ),
+        FT_FRAME_USHORT( usWinDescent ),
+      FT_FRAME_END
+    };
+
+    const FT_Frame_Field  os2_fields_extra[] =
+    {
+      FT_FRAME_START( 8 ),
+        FT_FRAME_ULONG( ulCodePageRange1 ),
+        FT_FRAME_ULONG( ulCodePageRange2 ),
+      FT_FRAME_END
+    };
+
+    const FT_Frame_Field  os2_fields_extra2[] =
+    {
+      FT_FRAME_START( 10 ),
+        FT_FRAME_SHORT ( sxHeight ),
+        FT_FRAME_SHORT ( sCapHeight ),
+        FT_FRAME_USHORT( usDefaultChar ),
+        FT_FRAME_USHORT( usBreakChar ),
+        FT_FRAME_USHORT( usMaxContext ),
+      FT_FRAME_END
+    };
+
+
+    FT_TRACE2(( "OS/2 Table " ));
+
+    /* We now support old Mac fonts where the OS/2 table doesn't  */
+    /* exist.  Simply put, we set the `version' field to 0xFFFF   */
+    /* and test this value each time we need to access the table. */
+    error = face->goto_table( face, TTAG_OS2, stream, 0 );
+    if ( error )
+    {
+      FT_TRACE2(( "is missing!\n" ));
+      face->os2.version = 0xFFFFU;
+      error = SFNT_Err_Ok;
+      goto Exit;
+    }
+
+    os2 = &face->os2;
+
+    if ( FT_STREAM_READ_FIELDS( os2_fields, os2 ) )
+      goto Exit;
+
+    os2->ulCodePageRange1 = 0;
+    os2->ulCodePageRange2 = 0;
+    os2->sxHeight         = 0;
+    os2->sCapHeight       = 0;
+    os2->usDefaultChar    = 0;
+    os2->usBreakChar      = 0;
+    os2->usMaxContext     = 0;
+
+    if ( os2->version >= 0x0001 )
+    {
+      /* only version 1 tables */
+      if ( FT_STREAM_READ_FIELDS( os2_fields_extra, os2 ) )
+        goto Exit;
+
+      if ( os2->version >= 0x0002 )
+      {
+        /* only version 2 tables */
+        if ( FT_STREAM_READ_FIELDS( os2_fields_extra2, os2 ) )
+          goto Exit;
+      }
+    }
+
+    FT_TRACE2(( "loaded\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_postscript                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the Postscript table.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: A handle to the input stream.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_postscript( TT_Face    face,
+                           FT_Stream  stream )
+  {
+    FT_Error        error;
+    TT_Postscript*  post = &face->postscript;
+
+    static const FT_Frame_Field  post_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_Postscript
+
+      FT_FRAME_START( 32 ),
+        FT_FRAME_ULONG( FormatType ),
+        FT_FRAME_ULONG( italicAngle ),
+        FT_FRAME_SHORT( underlinePosition ),
+        FT_FRAME_SHORT( underlineThickness ),
+        FT_FRAME_ULONG( isFixedPitch ),
+        FT_FRAME_ULONG( minMemType42 ),
+        FT_FRAME_ULONG( maxMemType42 ),
+        FT_FRAME_ULONG( minMemType1 ),
+        FT_FRAME_ULONG( maxMemType1 ),
+      FT_FRAME_END
+    };
+
+
+    FT_TRACE2(( "PostScript " ));
+
+    error = face->goto_table( face, TTAG_post, stream, 0 );
+    if ( error )
+      return SFNT_Err_Post_Table_Missing;
+
+    if ( FT_STREAM_READ_FIELDS( post_fields, post ) )
+      return error;
+
+    /* we don't load the glyph names, we do that in another */
+    /* module (ttpost).                                     */
+    FT_TRACE2(( "loaded\n" ));
+
+    return SFNT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_pclt                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the PCL 5 Table.                                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: A handle to the input stream.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_pclt( TT_Face    face,
+                     FT_Stream  stream )
+  {
+    static const FT_Frame_Field  pclt_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_PCLT
+
+      FT_FRAME_START( 54 ),
+        FT_FRAME_ULONG ( Version ),
+        FT_FRAME_ULONG ( FontNumber ),
+        FT_FRAME_USHORT( Pitch ),
+        FT_FRAME_USHORT( xHeight ),
+        FT_FRAME_USHORT( Style ),
+        FT_FRAME_USHORT( TypeFamily ),
+        FT_FRAME_USHORT( CapHeight ),
+        FT_FRAME_BYTES ( TypeFace, 16 ),
+        FT_FRAME_BYTES ( CharacterComplement, 8 ),
+        FT_FRAME_BYTES ( FileName, 6 ),
+        FT_FRAME_CHAR  ( StrokeWeight ),
+        FT_FRAME_CHAR  ( WidthType ),
+        FT_FRAME_BYTE  ( SerifStyle ),
+        FT_FRAME_BYTE  ( Reserved ),
+      FT_FRAME_END
+    };
+
+    FT_Error  error;
+    TT_PCLT*  pclt = &face->pclt;
+
+
+    FT_TRACE2(( "PCLT " ));
+
+    /* optional table */
+    error = face->goto_table( face, TTAG_PCLT, stream, 0 );
+    if ( error )
+    {
+      FT_TRACE2(( "missing (optional)\n" ));
+      pclt->Version = 0;
+      return SFNT_Err_Ok;
+    }
+
+    if ( FT_STREAM_READ_FIELDS( pclt_fields, pclt ) )
+      goto Exit;
+
+    FT_TRACE2(( "loaded\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_gasp                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the `gasp' table into a face object.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_gasp( TT_Face    face,
+                     FT_Stream  stream )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+
+    FT_UInt        j,num_ranges;
+    TT_GaspRange   gaspranges;
+
+
+    FT_TRACE2(( "tt_face_load_gasp: %08p\n", face ));
+
+    /* the gasp table is optional */
+    error = face->goto_table( face, TTAG_gasp, stream, 0 );
+    if ( error )
+      return SFNT_Err_Ok;
+
+    if ( FT_FRAME_ENTER( 4L ) )
+      goto Exit;
+
+    face->gasp.version   = FT_GET_USHORT();
+    face->gasp.numRanges = FT_GET_USHORT();
+
+    FT_FRAME_EXIT();
+
+    num_ranges = face->gasp.numRanges;
+    FT_TRACE3(( "number of ranges = %d\n", num_ranges ));
+
+    if ( FT_QNEW_ARRAY( gaspranges, num_ranges ) ||
+         FT_FRAME_ENTER( num_ranges * 4L )      )
+      goto Exit;
+
+    face->gasp.gaspRanges = gaspranges;
+
+    for ( j = 0; j < num_ranges; j++ )
+    {
+      gaspranges[j].maxPPEM  = FT_GET_USHORT();
+      gaspranges[j].gaspFlag = FT_GET_USHORT();
+
+      FT_TRACE3(( " [max:%d flag:%d]",
+                    gaspranges[j].maxPPEM,
+                    gaspranges[j].gaspFlag ));
+    }
+    FT_TRACE3(( "\n" ));
+
+    FT_FRAME_EXIT();
+    FT_TRACE2(( "GASP loaded\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( int )
+  tt_kern_pair_compare( const void*  a,
+                        const void*  b );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_kern                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the first kerning table with format 0 in the font.  Only     */
+  /*    accepts the first horizontal kerning table.  Developers should use */
+  /*    the `ftxkern' extension to access other kerning tables in the font */
+  /*    file, if they really want to.                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  
+#undef  TT_KERN_INDEX
+#define TT_KERN_INDEX( g1, g2 )  ( ( (FT_ULong)g1 << 16 ) | g2 )
+
+
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_kern( TT_Face    face,
+                     FT_Stream  stream )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+
+    FT_UInt    n, num_tables;
+
+
+    /* the kern table is optional; exit silently if it is missing */
+    error = face->goto_table( face, TTAG_kern, stream, 0 );
+    if ( error )
+      return SFNT_Err_Ok;
+
+    if ( FT_FRAME_ENTER( 4L ) )
+      goto Exit;
+
+    (void)FT_GET_USHORT();         /* version */
+    num_tables = FT_GET_USHORT();
+
+    FT_FRAME_EXIT();
+
+    for ( n = 0; n < num_tables; n++ )
+    {
+      FT_UInt  coverage;
+      FT_UInt  length;
+
+
+      if ( FT_FRAME_ENTER( 6L ) )
+        goto Exit;
+
+      (void)FT_GET_USHORT();           /* version                 */
+      length   = FT_GET_USHORT() - 6;  /* substract header length */
+      coverage = FT_GET_USHORT();
+
+      FT_FRAME_EXIT();
+
+      if ( coverage == 0x0001 )
+      {
+        FT_UInt        num_pairs;
+        TT_Kern0_Pair  pair;
+        TT_Kern0_Pair  limit;
+
+
+        /* found a horizontal format 0 kerning table! */
+        if ( FT_FRAME_ENTER( 8L ) )
+          goto Exit;
+
+        num_pairs = FT_GET_USHORT();
+
+        /* skip the rest */
+
+        FT_FRAME_EXIT();
+
+        /* allocate array of kerning pairs */
+        if ( FT_QNEW_ARRAY( face->kern_pairs, num_pairs ) ||
+             FT_FRAME_ENTER( 6L * num_pairs )             )
+          goto Exit;
+
+        pair  = face->kern_pairs;
+        limit = pair + num_pairs;
+        for ( ; pair < limit; pair++ )
+        {
+          pair->left  = FT_GET_USHORT();
+          pair->right = FT_GET_USHORT();
+          pair->value = FT_GET_USHORT();
+        }
+
+        FT_FRAME_EXIT();
+
+        face->num_kern_pairs   = num_pairs;
+        face->kern_table_index = n;
+
+        /* ensure that the kerning pair table is sorted (yes, some */
+        /* fonts have unsorted tables!)                            */
+
+#if 1
+        if ( num_pairs > 0 )     
+        {
+          TT_Kern0_Pair  pair0 = face->kern_pairs;
+          FT_ULong       prev  = TT_KERN_INDEX( pair0->left, pair0->right );
+          
+
+          for ( pair0++; pair0 < limit; pair0++ )
+          {
+            FT_ULong  next = TT_KERN_INDEX( pair0->left, pair0->right );
+            
+
+            if ( next < prev )
+              goto SortIt;
+              
+            prev = next;
+          }
+          goto Exit;
+          
+        SortIt:
+          ft_qsort( (void*)face->kern_pairs, (int)num_pairs,
+                    sizeof ( TT_Kern0_PairRec ), tt_kern_pair_compare );
+        }
+#else        
+        {
+          TT_Kern0_Pair  pair0    = face->kern_pairs;
+          FT_UInt        i;
+          
+
+          for ( i = 1; i < num_pairs; i++, pair0++ )
+          {
+            if ( tt_kern_pair_compare( pair0, pair0 + 1 ) != -1 )
+            {
+              ft_qsort( (void*)face->kern_pairs, (int)num_pairs,
+                        sizeof ( TT_Kern0_PairRec ), tt_kern_pair_compare );
+              break;
+            }
+          }
+        }
+#endif
+
+        goto Exit;
+      }
+
+      if ( FT_STREAM_SKIP( length ) )
+        goto Exit;
+    }
+
+    /* no kern table found -- doesn't matter */
+    face->kern_table_index = -1;
+    face->num_kern_pairs   = 0;
+    face->kern_pairs       = NULL;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( int )
+  tt_kern_pair_compare( const void*  a,
+                        const void*  b )
+  {
+    TT_Kern0_Pair  pair1 = (TT_Kern0_Pair)a;
+    TT_Kern0_Pair  pair2 = (TT_Kern0_Pair)b;
+
+    FT_ULong  index1 = TT_KERN_INDEX( pair1->left, pair1->right );
+    FT_ULong  index2 = TT_KERN_INDEX( pair2->left, pair2->right );
+
+
+    return ( index1 < index2 ? -1 :
+           ( index1 > index2 ?  1 : 0 ));
+  }
+
+
+#undef TT_KERN_INDEX
+  
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_hdmx                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the horizontal device metrics table.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: A handle to the input stream.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_hdmx( TT_Face    face,
+                     FT_Stream  stream )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+
+    TT_Hdmx    hdmx = &face->hdmx;
+    FT_Short   num_records;
+    FT_Long    num_glyphs;
+    FT_Long    record_size;
+
+
+    hdmx->version     = 0;
+    hdmx->num_records = 0;
+    hdmx->records     = 0;
+
+    /* this table is optional */
+    error = face->goto_table( face, TTAG_hdmx, stream, 0 );
+    if ( error )
+      return SFNT_Err_Ok;
+
+    if ( FT_FRAME_ENTER( 8L ) )
+      goto Exit;
+
+    hdmx->version     = FT_GET_USHORT();
+    num_records       = FT_GET_SHORT();
+    record_size       = FT_GET_LONG();
+
+    FT_FRAME_EXIT();
+
+    /* Only recognize format 0 */
+    if ( hdmx->version != 0 )
+      goto Exit;
+
+    if ( FT_QNEW_ARRAY( hdmx->records, num_records ) )
+      goto Exit;
+
+    hdmx->num_records = num_records;
+    num_glyphs   = face->root.num_glyphs;
+    record_size -= num_glyphs + 2;
+
+    {
+      TT_HdmxEntry  cur   = hdmx->records;
+      TT_HdmxEntry  limit = cur + hdmx->num_records;
+
+
+      for ( ; cur < limit; cur++ )
+      {
+        /* read record */
+        if ( FT_READ_BYTE( cur->ppem      ) ||
+             FT_READ_BYTE( cur->max_width ) )
+          goto Exit;
+
+        if ( FT_QALLOC( cur->widths, num_glyphs )       ||
+             FT_STREAM_READ( cur->widths, num_glyphs ) )
+          goto Exit;
+
+        /* skip padding bytes */
+        if ( record_size > 0 && FT_STREAM_SKIP( record_size ) )
+            goto Exit;
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_free_hdmx                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Frees the horizontal device metrics table.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the target face object.                        */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  tt_face_free_hdmx( TT_Face  face )
+  {
+    if ( face )
+    {
+      FT_Int     n;
+      FT_Memory  memory = face->root.driver->root.memory;
+
+
+      for ( n = 0; n < face->hdmx.num_records; n++ )
+        FT_FREE( face->hdmx.records[n].widths );
+
+      FT_FREE( face->hdmx.records );
+      face->hdmx.num_records = 0;
+    }
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/ttload.h b/nx-X11/extras/freetype2/src/sfnt/ttload.h
new file mode 100644
index 000000000..27c41b50b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/ttload.h
@@ -0,0 +1,137 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttload.h                                                               */
+/*                                                                         */
+/*    Load the basic TrueType tables, i.e., tables that can be either in   */
+/*    TTF or OTF fonts (specification).                                    */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __TTLOAD_H__
+#define __TTLOAD_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( TT_Table  )
+  tt_face_lookup_table( TT_Face   face,
+                        FT_ULong  tag );
+
+  FT_LOCAL( FT_Error )
+  tt_face_goto_table( TT_Face    face,
+                      FT_ULong   tag,
+                      FT_Stream  stream,
+                      FT_ULong*  length );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_sfnt_header( TT_Face      face,
+                            FT_Stream    stream,
+                            FT_Long      face_index,
+                            SFNT_Header  sfnt );
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_directory( TT_Face      face,
+                          FT_Stream    stream,
+                          SFNT_Header  sfnt );
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_any( TT_Face    face,
+                    FT_ULong   tag,
+                    FT_Long    offset,
+                    FT_Byte*   buffer,
+                    FT_ULong*  length );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_header( TT_Face    face,
+                       FT_Stream  stream );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_metrics_header( TT_Face    face,
+                               FT_Stream  stream,
+                               FT_Bool    vertical );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_cmap( TT_Face    face,
+                     FT_Stream  stream );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_max_profile( TT_Face    face,
+                            FT_Stream  stream );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_names( TT_Face    face,
+                      FT_Stream  stream );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_os2( TT_Face    face,
+                    FT_Stream  stream );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_postscript( TT_Face    face,
+                           FT_Stream  stream );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_hdmx( TT_Face    face,
+                     FT_Stream  stream );
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_pclt( TT_Face    face,
+                     FT_Stream  stream );
+
+  FT_LOCAL( void )
+  tt_face_free_names( TT_Face  face );
+
+
+  FT_LOCAL( void )
+  tt_face_free_hdmx ( TT_Face  face );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_kern( TT_Face    face,
+                     FT_Stream  stream );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_gasp( TT_Face    face,
+                     FT_Stream  stream );
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_bitmap_header( TT_Face    face,
+                              FT_Stream  stream );
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+
+FT_END_HEADER
+
+#endif /* __TTLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/ttpost.c b/nx-X11/extras/freetype2/src/sfnt/ttpost.c
new file mode 100644
index 000000000..3d526db4c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/ttpost.c
@@ -0,0 +1,521 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttpost.c                                                               */
+/*                                                                         */
+/*    Postcript name table processing for TrueType and OpenType fonts      */
+/*    (body).                                                              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The post table is not completely loaded by the core engine.  This     */
+  /* file loads the missing PS glyph names and implements an API to access */
+  /* them.                                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_STREAM_H
+#include FT_TRUETYPE_TAGS_H
+#include "ttpost.h"
+#include "ttload.h"
+
+#include "sferrors.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_ttpost
+
+
+  /* If this configuration macro is defined, we rely on the `PSNames' */
+  /* module to grab the glyph names.                                  */
+
+#ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
+
+
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+
+#define MAC_NAME( x )  ( (FT_String*)psnames->macintosh_name( x ) )
+
+
+#else /* FT_CONFIG_OPTION_POSTSCRIPT_NAMES */
+
+
+   /* Otherwise, we ignore the `PSNames' module, and provide our own  */
+   /* table of Mac names.  Thus, it is possible to build a version of */
+   /* FreeType without the Type 1 driver & PSNames module.            */
+
+#define MAC_NAME( x )  tt_post_default_names[x]
+
+  /* the 258 default Mac PS glyph names */
+
+  static const FT_String*  tt_post_default_names[258] =
+  {
+    /*   0 */
+    ".notdef", ".null", "CR", "space", "exclam",
+    "quotedbl", "numbersign", "dollar", "percent", "ampersand",
+    /*  10 */
+    "quotesingle", "parenleft", "parenright", "asterisk", "plus",
+    "comma", "hyphen", "period", "slash", "zero",
+    /*  20 */
+    "one", "two", "three", "four", "five",
+    "six", "seven", "eight", "nine", "colon",
+    /*  30 */
+    "semicolon", "less", "equal", "greater", "question",
+    "at", "A", "B", "C", "D",
+    /*  40 */
+    "E", "F", "G", "H", "I",
+    "J", "K", "L", "M", "N",
+    /*  50 */
+    "O", "P", "Q", "R", "S",
+    "T", "U", "V", "W", "X",
+    /*  60 */
+    "Y", "Z", "bracketleft", "backslash", "bracketright",
+    "asciicircum", "underscore", "grave", "a", "b",
+    /*  70 */
+    "c", "d", "e", "f", "g",
+    "h", "i", "j", "k", "l",
+    /*  80 */
+    "m", "n", "o", "p", "q",
+    "r", "s", "t", "u", "v",
+    /*  90 */
+    "w", "x", "y", "z", "braceleft",
+    "bar", "braceright", "asciitilde", "Adieresis", "Aring",
+    /* 100 */
+    "Ccedilla", "Eacute", "Ntilde", "Odieresis", "Udieresis",
+    "aacute", "agrave", "acircumflex", "adieresis", "atilde",
+    /* 110 */
+    "aring", "ccedilla", "eacute", "egrave", "ecircumflex",
+    "edieresis", "iacute", "igrave", "icircumflex", "idieresis",
+    /* 120 */
+    "ntilde", "oacute", "ograve", "ocircumflex", "odieresis",
+    "otilde", "uacute", "ugrave", "ucircumflex", "udieresis",
+    /* 130 */
+    "dagger", "degree", "cent", "sterling", "section",
+    "bullet", "paragraph", "germandbls", "registered", "copyright",
+    /* 140 */
+    "trademark", "acute", "dieresis", "notequal", "AE",
+    "Oslash", "infinity", "plusminus", "lessequal", "greaterequal",
+    /* 150 */
+    "yen", "mu", "partialdiff", "summation", "product",
+    "pi", "integral", "ordfeminine", "ordmasculine", "Omega",
+    /* 160 */
+    "ae", "oslash", "questiondown", "exclamdown", "logicalnot",
+    "radical", "florin", "approxequal", "Delta", "guillemotleft",
+    /* 170 */
+    "guillemotright", "ellipsis", "nbspace", "Agrave", "Atilde",
+    "Otilde", "OE", "oe", "endash", "emdash",
+    /* 180 */
+    "quotedblleft", "quotedblright", "quoteleft", "quoteright", "divide",
+    "lozenge", "ydieresis", "Ydieresis", "fraction", "currency",
+    /* 190 */
+    "guilsinglleft", "guilsinglright", "fi", "fl", "daggerdbl",
+    "periodcentered", "quotesinglbase", "quotedblbase", "perthousand", "Acircumflex",
+    /* 200 */
+    "Ecircumflex", "Aacute", "Edieresis", "Egrave", "Iacute",
+    "Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex",
+    /* 210 */
+    "apple", "Ograve", "Uacute", "Ucircumflex", "Ugrave",
+    "dotlessi", "circumflex", "tilde", "macron", "breve",
+    /* 220 */
+    "dotaccent", "ring", "cedilla", "hungarumlaut", "ogonek",
+    "caron", "Lslash", "lslash", "Scaron", "scaron",
+    /* 230 */
+    "Zcaron", "zcaron", "brokenbar", "Eth", "eth",
+    "Yacute", "yacute", "Thorn", "thorn", "minus",
+    /* 240 */
+    "multiply", "onesuperior", "twosuperior", "threesuperior", "onehalf",
+    "onequarter", "threequarters", "franc", "Gbreve", "gbreve",
+    /* 250 */
+    "Idot", "Scedilla", "scedilla", "Cacute", "cacute",
+    "Ccaron", "ccaron", "dmacron",
+  };
+
+
+#endif /* FT_CONFIG_OPTION_POSTSCRIPT_NAMES */
+
+
+  static FT_Error
+  load_format_20( TT_Face    face,
+                  FT_Stream  stream )
+  {
+    FT_Memory   memory = stream->memory;
+    FT_Error    error;
+
+    FT_Int      num_glyphs;
+    FT_UShort   num_names;
+
+    FT_UShort*  glyph_indices = 0;
+    FT_Char**   name_strings  = 0;
+
+
+    if ( FT_READ_USHORT( num_glyphs ) )
+      goto Exit;
+
+    /* UNDOCUMENTED!  The number of glyphs in this table can be smaller */
+    /* than the value in the maxp table (cf. cyberbit.ttf).             */
+
+    /* There already exist fonts which have more than 32768 glyph names */
+    /* in this table, so the test for this threshold has been dropped.  */
+
+    if ( num_glyphs > face->root.num_glyphs )
+    {
+      error = SFNT_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    /* load the indices */
+    {
+      FT_Int  n;
+
+
+      if ( FT_NEW_ARRAY ( glyph_indices, num_glyphs ) ||
+           FT_FRAME_ENTER( num_glyphs * 2L )          )
+        goto Fail;
+
+      for ( n = 0; n < num_glyphs; n++ )
+        glyph_indices[n] = FT_GET_USHORT();
+
+      FT_FRAME_EXIT();
+    }
+
+    /* compute number of names stored in table */
+    {
+      FT_Int  n;
+
+
+      num_names = 0;
+
+      for ( n = 0; n < num_glyphs; n++ )
+      {
+        FT_Int  idx;
+
+
+        idx = glyph_indices[n];
+        if ( idx >= 258 )
+        {
+          idx -= 257;
+          if ( idx > num_names )
+            num_names = (FT_UShort)idx;
+        }
+      }
+    }
+
+    /* now load the name strings */
+    {
+      FT_UShort  n;
+
+
+      if ( FT_NEW_ARRAY( name_strings, num_names ) )
+        goto Fail;
+
+      for ( n = 0; n < num_names; n++ )
+      {
+        FT_UInt  len;
+
+
+        if ( FT_READ_BYTE  ( len )                    ||
+             FT_NEW_ARRAY( name_strings[n], len + 1 ) ||
+             FT_STREAM_READ  ( name_strings[n], len ) )
+          goto Fail1;
+
+        name_strings[n][len] = '\0';
+      }
+    }
+
+    /* all right, set table fields and exit successfuly */
+    {
+      TT_Post_20  table = &face->postscript_names.names.format_20;
+
+
+      table->num_glyphs    = (FT_UShort)num_glyphs;
+      table->num_names     = (FT_UShort)num_names;
+      table->glyph_indices = glyph_indices;
+      table->glyph_names   = name_strings;
+    }
+    return SFNT_Err_Ok;
+
+  Fail1:
+    {
+      FT_UShort  n;
+
+
+      for ( n = 0; n < num_names; n++ )
+        FT_FREE( name_strings[n] );
+    }
+
+  Fail:
+    FT_FREE( name_strings );
+    FT_FREE( glyph_indices );
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  load_format_25( TT_Face    face,
+                  FT_Stream  stream )
+  {
+    FT_Memory  memory = stream->memory;
+    FT_Error   error;
+
+    FT_Int     num_glyphs;
+    FT_Char*   offset_table = 0;
+
+
+    /* UNDOCUMENTED!  This value appears only in the Apple TT specs. */
+    if ( FT_READ_USHORT( num_glyphs ) )
+      goto Exit;
+
+    /* check the number of glyphs */
+    if ( num_glyphs > face->root.num_glyphs || num_glyphs > 258 )
+    {
+      error = SFNT_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    if ( FT_ALLOC( offset_table, num_glyphs )       ||
+         FT_STREAM_READ( offset_table, num_glyphs ) )
+      goto Fail;
+
+    /* now check the offset table */
+    {
+      FT_Int  n;
+
+
+      for ( n = 0; n < num_glyphs; n++ )
+      {
+        FT_Long  idx = (FT_Long)n + offset_table[n];
+
+
+        if ( idx < 0 || idx > num_glyphs )
+        {
+          error = SFNT_Err_Invalid_File_Format;
+          goto Fail;
+        }
+      }
+    }
+
+    /* OK, set table fields and exit successfuly */
+    {
+      TT_Post_25  table = &face->postscript_names.names.format_25;
+
+
+      table->num_glyphs = (FT_UShort)num_glyphs;
+      table->offsets    = offset_table;
+    }
+
+    return SFNT_Err_Ok;
+
+  Fail:
+    FT_FREE( offset_table );
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  load_post_names( TT_Face  face )
+  {
+    FT_Stream  stream;
+    FT_Error   error;
+    FT_Fixed   format;
+
+
+    /* get a stream for the face's resource */
+    stream = face->root.stream;
+
+    /* seek to the beginning of the PS names table */
+    error = face->goto_table( face, TTAG_post, stream, 0 );
+    if ( error )
+      goto Exit;
+
+    format = face->postscript.FormatType;
+
+    /* go to beginning of subtable */
+    if ( FT_STREAM_SKIP( 32 ) )
+      goto Exit;
+
+    /* now read postscript table */
+    if ( format == 0x00020000L )
+      error = load_format_20( face, stream );
+    else if ( format == 0x00028000L )
+      error = load_format_25( face, stream );
+    else
+      error = SFNT_Err_Invalid_File_Format;
+
+    face->postscript_names.loaded = 1;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  tt_face_free_ps_names( TT_Face  face )
+  {
+    FT_Memory      memory = face->root.memory;
+    TT_Post_Names  names  = &face->postscript_names;
+    FT_Fixed       format;
+
+
+    if ( names->loaded )
+    {
+      format = face->postscript.FormatType;
+
+      if ( format == 0x00020000L )
+      {
+        TT_Post_20  table = &names->names.format_20;
+        FT_UShort   n;
+
+
+        FT_FREE( table->glyph_indices );
+        table->num_glyphs = 0;
+
+        for ( n = 0; n < table->num_names; n++ )
+          FT_FREE( table->glyph_names[n] );
+
+        FT_FREE( table->glyph_names );
+        table->num_names = 0;
+      }
+      else if ( format == 0x00028000L )
+      {
+        TT_Post_25  table = &names->names.format_25;
+
+
+        FT_FREE( table->offsets );
+        table->num_glyphs = 0;
+      }
+    }
+    names->loaded = 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_get_ps_name                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Gets the PostScript glyph name of a glyph.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the parent face.                             */
+  /*                                                                       */
+  /*    idx    :: The glyph index.                                         */
+  /*                                                                       */
+  /*    PSname :: The address of a string pointer.  Will be NULL in case   */
+  /*              of error, otherwise it is a pointer to the glyph name.   */
+  /*                                                                       */
+  /*              You must not modify the returned string!                 */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_get_ps_name( TT_Face      face,
+                       FT_UInt      idx,
+                       FT_String**  PSname )
+  {
+    FT_Error         error;
+    TT_Post_Names    names;
+    FT_Fixed         format;
+
+#ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
+    FT_Service_PsCMaps  psnames;
+#endif
+
+
+    if ( !face )
+      return SFNT_Err_Invalid_Face_Handle;
+
+    if ( idx >= (FT_UInt)face->root.num_glyphs )
+      return SFNT_Err_Invalid_Glyph_Index;
+
+#ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
+    psnames = (FT_Service_PsCMaps)face->psnames;
+    if ( !psnames )
+      return SFNT_Err_Unimplemented_Feature;
+#endif
+
+    names = &face->postscript_names;
+
+    /* `.notdef' by default */
+    *PSname = MAC_NAME( 0 );
+
+    format = face->postscript.FormatType;
+
+    if ( format == 0x00010000L )
+    {
+      if ( idx < 258 )                    /* paranoid checking */
+        *PSname = MAC_NAME( idx );
+    }
+    else if ( format == 0x00020000L )
+    {
+      TT_Post_20  table = &names->names.format_20;
+
+
+      if ( !names->loaded )
+      {
+        error = load_post_names( face );
+        if ( error )
+          goto End;
+      }
+
+      if ( idx < (FT_UInt)table->num_glyphs )
+      {
+        FT_UShort  name_index = table->glyph_indices[idx];
+
+
+        if ( name_index < 258 )
+          *PSname = MAC_NAME( name_index );
+        else
+          *PSname = (FT_String*)table->glyph_names[name_index - 258];
+      }
+    }
+    else if ( format == 0x00028000L )
+    {
+      TT_Post_25  table = &names->names.format_25;
+
+
+      if ( !names->loaded )
+      {
+        error = load_post_names( face );
+        if ( error )
+          goto End;
+      }
+
+      if ( idx < (FT_UInt)table->num_glyphs )    /* paranoid checking */
+      {
+        idx    += table->offsets[idx];
+        *PSname = MAC_NAME( idx );
+      }
+    }
+
+    /* nothing to do for format == 0x00030000L */
+
+  End:
+    return SFNT_Err_Ok;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/ttpost.h b/nx-X11/extras/freetype2/src/sfnt/ttpost.h
new file mode 100644
index 000000000..6f06d75a7
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/ttpost.h
@@ -0,0 +1,46 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttpost.h                                                               */
+/*                                                                         */
+/*    Postcript name table processing for TrueType and OpenType fonts      */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __TTPOST_H__
+#define __TTPOST_H__
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_get_ps_name( TT_Face      face,
+                       FT_UInt      idx,
+                       FT_String**  PSname );
+
+  FT_LOCAL( void )
+  tt_face_free_ps_names( TT_Face  face );
+
+
+FT_END_HEADER
+
+#endif /* __TTPOST_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/ttsbit.c b/nx-X11/extras/freetype2/src/sfnt/ttsbit.c
new file mode 100644
index 000000000..444c27acc
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/ttsbit.c
@@ -0,0 +1,1467 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttsbit.c                                                               */
+/*                                                                         */
+/*    TrueType and OpenType embedded bitmap support (body).                */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_TRUETYPE_TAGS_H
+#include "ttsbit.h"
+
+#include "sferrors.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_ttsbit
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    blit_sbit                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Blits a bitmap from an input stream into a given target.  Supports */
+  /*    x and y offsets as well as byte padded lines.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    target      :: The target bitmap/pixmap.                           */
+  /*                                                                       */
+  /*    source      :: The input packed bitmap data.                       */
+  /*                                                                       */
+  /*    line_bits   :: The number of bits per line.                        */
+  /*                                                                       */
+  /*    byte_padded :: A flag which is true if lines are byte-padded.      */
+  /*                                                                       */
+  /*    x_offset    :: The horizontal offset.                              */
+  /*                                                                       */
+  /*    y_offset    :: The vertical offset.                                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    IMPORTANT: The x and y offsets are relative to the top corner of   */
+  /*               the target bitmap (unlike the normal TrueType           */
+  /*               convention).  A positive y offset indicates a downwards */
+  /*               direction!                                              */
+  /*                                                                       */
+  static void
+  blit_sbit( FT_Bitmap*  target,
+             FT_Byte*    source,
+             FT_Int      line_bits,
+             FT_Bool     byte_padded,
+             FT_Int      x_offset,
+             FT_Int      y_offset )
+  {
+    FT_Byte*   line_buff;
+    FT_Int     line_incr;
+    FT_Int     height;
+
+    FT_UShort  acc;
+    FT_UInt    loaded;
+
+
+    /* first of all, compute starting write position */
+    line_incr = target->pitch;
+    line_buff = target->buffer;
+
+    if ( line_incr < 0 )
+      line_buff -= line_incr * ( target->rows - 1 );
+
+    line_buff += ( x_offset >> 3 ) + y_offset * line_incr;
+
+    /***********************************************************************/
+    /*                                                                     */
+    /* We use the extra-classic `accumulator' trick to extract the bits    */
+    /* from the source byte stream.                                        */
+    /*                                                                     */
+    /* Namely, the variable `acc' is a 16-bit accumulator containing the   */
+    /* last `loaded' bits from the input stream.  The bits are shifted to  */
+    /* the upmost position in `acc'.                                       */
+    /*                                                                     */
+    /***********************************************************************/
+
+    acc    = 0;  /* clear accumulator   */
+    loaded = 0;  /* no bits were loaded */
+
+    for ( height = target->rows; height > 0; height-- )
+    {
+      FT_Byte*  cur   = line_buff;        /* current write cursor          */
+      FT_Int    count = line_bits;        /* # of bits to extract per line */
+      FT_Byte   shift = (FT_Byte)( x_offset & 7 ); /* current write shift  */
+      FT_Byte   space = (FT_Byte)( 8 - shift );
+
+
+      /* first of all, read individual source bytes */
+      if ( count >= 8 )
+      {
+        count -= 8;
+        {
+          do
+          {
+            FT_Byte  val;
+
+
+            /* ensure that there are at least 8 bits in the accumulator */
+            if ( loaded < 8 )
+            {
+              acc    |= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded ));
+              loaded += 8;
+            }
+
+            /* now write one byte */
+            val = (FT_Byte)( acc >> 8 );
+            if ( shift )
+            {
+              cur[0] |= (FT_Byte)( val >> shift );
+              cur[1] |= (FT_Byte)( val << space );
+            }
+            else
+              cur[0] |= val;
+
+            cur++;
+            acc   <<= 8;  /* remove bits from accumulator */
+            loaded -= 8;
+            count  -= 8;
+
+          } while ( count >= 0 );
+        }
+
+        /* restore `count' to correct value */
+        count += 8;
+      }
+
+      /* now write remaining bits (count < 8) */
+      if ( count > 0 )
+      {
+        FT_Byte  val;
+
+
+        /* ensure that there are at least `count' bits in the accumulator */
+        if ( (FT_Int)loaded < count )
+        {
+          acc    |= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded ));
+          loaded += 8;
+        }
+
+        /* now write remaining bits */
+        val     = (FT_Byte)( ( (FT_Byte)( acc >> 8 ) ) & ~( 0xFF >> count ) );
+        cur[0] |= (FT_Byte)( val >> shift );
+
+        if ( count > space )
+          cur[1] |= (FT_Byte)( val << space );
+
+        acc   <<= count;
+        loaded -= count;
+      }
+
+      /* now, skip to next line */
+      if ( byte_padded )
+      {
+        acc    = 0;
+        loaded = 0;   /* clear accumulator on byte-padded lines */
+      }
+
+      line_buff += line_incr;
+    }
+  }
+
+
+  const FT_Frame_Field  sbit_metrics_fields[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_SBit_MetricsRec
+
+    FT_FRAME_START( 8 ),
+      FT_FRAME_BYTE( height ),
+      FT_FRAME_BYTE( width ),
+
+      FT_FRAME_CHAR( horiBearingX ),
+      FT_FRAME_CHAR( horiBearingY ),
+      FT_FRAME_BYTE( horiAdvance ),
+
+      FT_FRAME_CHAR( vertBearingX ),
+      FT_FRAME_CHAR( vertBearingY ),
+      FT_FRAME_BYTE( vertAdvance ),
+    FT_FRAME_END
+  };
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Load_SBit_Const_Metrics                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the metrics for `EBLC' index tables format 2 and 5.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    range  :: The target range.                                        */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Load_SBit_Const_Metrics( TT_SBit_Range  range,
+                           FT_Stream      stream )
+  {
+    FT_Error  error;
+
+
+    if ( FT_READ_ULONG( range->image_size ) )
+      return error;
+
+    return FT_STREAM_READ_FIELDS( sbit_metrics_fields, &range->metrics );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Load_SBit_Range_Codes                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the range codes for `EBLC' index tables format 4 and 5.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    range        :: The target range.                                  */
+  /*                                                                       */
+  /*    stream       :: The input stream.                                  */
+  /*                                                                       */
+  /*    load_offsets :: A flag whether to load the glyph offset table.     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Load_SBit_Range_Codes( TT_SBit_Range  range,
+                         FT_Stream      stream,
+                         FT_Bool        load_offsets )
+  {
+    FT_Error   error;
+    FT_ULong   count, n, size;
+    FT_Memory  memory = stream->memory;
+
+
+    if ( FT_READ_ULONG( count ) )
+      goto Exit;
+
+    range->num_glyphs = count;
+
+    /* Allocate glyph offsets table if needed */
+    if ( load_offsets )
+    {
+      if ( FT_NEW_ARRAY( range->glyph_offsets, count ) )
+        goto Exit;
+
+      size = count * 4L;
+    }
+    else
+      size = count * 2L;
+
+    /* Allocate glyph codes table and access frame */
+    if ( FT_NEW_ARRAY ( range->glyph_codes, count ) ||
+         FT_FRAME_ENTER( size )                     )
+      goto Exit;
+
+    for ( n = 0; n < count; n++ )
+    {
+      range->glyph_codes[n] = FT_GET_USHORT();
+
+      if ( load_offsets )
+        range->glyph_offsets[n] = (FT_ULong)range->image_offset +
+                                  FT_GET_USHORT();
+    }
+
+    FT_FRAME_EXIT();
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Load_SBit_Range                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads a given `EBLC' index/range table.                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    range  :: The target range.                                        */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Load_SBit_Range( TT_SBit_Range  range,
+                   FT_Stream      stream )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+
+
+    switch( range->index_format )
+    {
+    case 1:   /* variable metrics with 4-byte offsets */
+    case 3:   /* variable metrics with 2-byte offsets */
+      {
+        FT_ULong  num_glyphs, n;
+        FT_Int    size_elem;
+        FT_Bool   large = FT_BOOL( range->index_format == 1 );
+
+
+        num_glyphs        = range->last_glyph - range->first_glyph + 1L;
+        range->num_glyphs = num_glyphs;
+        num_glyphs++;                       /* XXX: BEWARE - see spec */
+
+        size_elem = large ? 4 : 2;
+
+        if ( FT_NEW_ARRAY( range->glyph_offsets, num_glyphs ) ||
+             FT_FRAME_ENTER( num_glyphs * size_elem )         )
+          goto Exit;
+
+        for ( n = 0; n < num_glyphs; n++ )
+          range->glyph_offsets[n] = (FT_ULong)( range->image_offset +
+                                                ( large ? FT_GET_ULONG()
+                                                        : FT_GET_USHORT() ) );
+        FT_FRAME_EXIT();
+      }
+      break;
+
+    case 2:   /* all glyphs have identical metrics */
+      error = Load_SBit_Const_Metrics( range, stream );
+      break;
+
+    case 4:
+      error = Load_SBit_Range_Codes( range, stream, 1 );
+      break;
+
+    case 5:
+      error = Load_SBit_Const_Metrics( range, stream )   ||
+              Load_SBit_Range_Codes( range, stream, 0 );
+      break;
+
+    default:
+      error = SFNT_Err_Invalid_File_Format;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_sbit_strikes                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the table of embedded bitmap sizes for this face.            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: The target face object.                                  */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_sbit_strikes( TT_Face    face,
+                             FT_Stream  stream )
+  {
+    FT_Error   error  = 0;
+    FT_Memory  memory = stream->memory;
+    FT_Fixed   version;
+    FT_ULong   num_strikes;
+    FT_ULong   table_base;
+
+    const FT_Frame_Field  sbit_line_metrics_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_SBit_LineMetricsRec
+
+      /* no FT_FRAME_START */
+        FT_FRAME_CHAR( ascender ),
+        FT_FRAME_CHAR( descender ),
+        FT_FRAME_BYTE( max_width ),
+
+        FT_FRAME_CHAR( caret_slope_numerator ),
+        FT_FRAME_CHAR( caret_slope_denominator ),
+        FT_FRAME_CHAR( caret_offset ),
+
+        FT_FRAME_CHAR( min_origin_SB ),
+        FT_FRAME_CHAR( min_advance_SB ),
+        FT_FRAME_CHAR( max_before_BL ),
+        FT_FRAME_CHAR( min_after_BL ),
+        FT_FRAME_CHAR( pads[0] ),
+        FT_FRAME_CHAR( pads[1] ),
+      FT_FRAME_END
+    };
+
+    const FT_Frame_Field  strike_start_fields[] =
+    {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_SBit_StrikeRec
+
+      /* no FT_FRAME_START */
+        FT_FRAME_ULONG( ranges_offset ),
+        FT_FRAME_SKIP_LONG,
+        FT_FRAME_ULONG( num_ranges ),
+        FT_FRAME_ULONG( color_ref ),
+      FT_FRAME_END
+    };
+
+    const FT_Frame_Field  strike_end_fields[] =
+    {
+      /* no FT_FRAME_START */
+        FT_FRAME_USHORT( start_glyph ),
+        FT_FRAME_USHORT( end_glyph ),
+        FT_FRAME_BYTE  ( x_ppem ),
+        FT_FRAME_BYTE  ( y_ppem ),
+        FT_FRAME_BYTE  ( bit_depth ),
+        FT_FRAME_CHAR  ( flags ),
+      FT_FRAME_END
+    };
+
+
+    face->num_sbit_strikes = 0;
+
+    /* this table is optional */
+    error = face->goto_table( face, TTAG_EBLC, stream, 0 );
+    if ( error )
+      error = face->goto_table( face, TTAG_bloc, stream, 0 );
+    if ( error )
+      goto Exit;
+
+    table_base = FT_STREAM_POS();
+    if ( FT_FRAME_ENTER( 8L ) )
+      goto Exit;
+
+    version     = FT_GET_LONG();
+    num_strikes = FT_GET_ULONG();
+
+    FT_FRAME_EXIT();
+
+    /* check version number and strike count */
+    if ( version     != 0x00020000L ||
+         num_strikes >= 0x10000L    )
+    {
+      FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version!\n" ));
+      error = SFNT_Err_Invalid_File_Format;
+
+      goto Exit;
+    }
+
+    /* allocate the strikes table */
+    if ( FT_NEW_ARRAY( face->sbit_strikes, num_strikes ) )
+      goto Exit;
+
+    face->num_sbit_strikes = num_strikes;
+
+    /* now read each strike table separately */
+    {
+      TT_SBit_Strike  strike = face->sbit_strikes;
+      FT_ULong        count  = num_strikes;
+
+
+      if ( FT_FRAME_ENTER( 48L * num_strikes ) )
+        goto Exit;
+
+      while ( count > 0 )
+      {
+        if ( FT_STREAM_READ_FIELDS( strike_start_fields, strike )             ||
+             FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->hori ) ||
+             FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->vert ) ||
+             FT_STREAM_READ_FIELDS( strike_end_fields, strike )               )
+          break;
+
+        count--;
+        strike++;
+      }
+
+      FT_FRAME_EXIT();
+    }
+
+    /* allocate the index ranges for each strike table */
+    {
+      TT_SBit_Strike  strike = face->sbit_strikes;
+      FT_ULong        count  = num_strikes;
+
+
+      while ( count > 0 )
+      {
+        TT_SBit_Range  range;
+        FT_ULong       count2 = strike->num_ranges;
+
+
+        if ( FT_NEW_ARRAY( strike->sbit_ranges, strike->num_ranges ) )
+          goto Exit;
+
+        /* read each range */
+        if ( FT_STREAM_SEEK( table_base + strike->ranges_offset ) ||
+             FT_FRAME_ENTER( strike->num_ranges * 8L )            )
+          goto Exit;
+
+        range = strike->sbit_ranges;
+        while ( count2 > 0 )
+        {
+          range->first_glyph  = FT_GET_USHORT();
+          range->last_glyph   = FT_GET_USHORT();
+          range->table_offset = table_base + strike->ranges_offset +
+                                  FT_GET_ULONG();
+          count2--;
+          range++;
+        }
+
+        FT_FRAME_EXIT();
+
+        /* Now, read each index table */
+        count2 = strike->num_ranges;
+        range  = strike->sbit_ranges;
+        while ( count2 > 0 )
+        {
+          /* Read the header */
+          if ( FT_STREAM_SEEK( range->table_offset ) ||
+               FT_FRAME_ENTER( 8L )                  )
+            goto Exit;
+
+          range->index_format = FT_GET_USHORT();
+          range->image_format = FT_GET_USHORT();
+          range->image_offset = FT_GET_ULONG();
+
+          FT_FRAME_EXIT();
+
+          error = Load_SBit_Range( range, stream );
+          if ( error )
+            goto Exit;
+
+          count2--;
+          range++;
+        }
+
+        count--;
+        strike++;
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_free_sbit_strikes                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Releases the embedded bitmap tables.                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: The target face object.                                    */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  tt_face_free_sbit_strikes( TT_Face  face )
+  {
+    FT_Memory       memory       = face->root.memory;
+    TT_SBit_Strike  strike       = face->sbit_strikes;
+    TT_SBit_Strike  strike_limit = strike + face->num_sbit_strikes;
+
+
+    if ( strike )
+    {
+      for ( ; strike < strike_limit; strike++ )
+      {
+        TT_SBit_Range  range       = strike->sbit_ranges;
+        TT_SBit_Range  range_limit = range + strike->num_ranges;
+
+
+        if ( range )
+        {
+          for ( ; range < range_limit; range++ )
+          {
+            /* release the glyph offsets and codes tables */
+            /* where appropriate                          */
+            FT_FREE( range->glyph_offsets );
+            FT_FREE( range->glyph_codes );
+          }
+        }
+        FT_FREE( strike->sbit_ranges );
+        strike->num_ranges = 0;
+      }
+      FT_FREE( face->sbit_strikes );
+    }
+    face->num_sbit_strikes = 0;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_set_sbit_strike( TT_Face    face,
+                           FT_UInt    x_ppem,
+                           FT_UInt    y_ppem,
+                           FT_ULong  *astrike_index )
+  {
+    FT_ULong  i;
+
+
+    if ( x_ppem > 255 ||
+         y_ppem < 1 || y_ppem > 255 )
+      return SFNT_Err_Invalid_PPem;
+
+    for ( i = 0; i < face->num_sbit_strikes; i++ )
+    {
+      if ( ( (FT_UInt)face->sbit_strikes[i].y_ppem == y_ppem )     &&
+           ( ( x_ppem == 0 )                                     ||
+             ( (FT_UInt)face->sbit_strikes[i].x_ppem == x_ppem ) ) )
+      {
+        *astrike_index = i;
+        return SFNT_Err_Ok;
+      }
+    }
+
+    return SFNT_Err_Invalid_PPem;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    find_sbit_range                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Scans a given strike's ranges and return, for a given glyph        */
+  /*    index, the corresponding sbit range, and `EBDT' offset.            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph_index   :: The glyph index.                                  */
+  /*                                                                       */
+  /*    strike        :: The source/current sbit strike.                   */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    arange        :: The sbit range containing the glyph index.        */
+  /*                                                                       */
+  /*    aglyph_offset :: The offset of the glyph data in `EBDT' table.     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means the glyph index was found.           */
+  /*                                                                       */
+  static FT_Error
+  find_sbit_range( FT_UInt          glyph_index,
+                   TT_SBit_Strike   strike,
+                   TT_SBit_Range   *arange,
+                   FT_ULong        *aglyph_offset )
+  {
+    TT_SBit_RangeRec  *range, *range_limit;
+
+
+    /* check whether the glyph index is within this strike's */
+    /* glyph range                                           */
+    if ( glyph_index < (FT_UInt)strike->start_glyph ||
+         glyph_index > (FT_UInt)strike->end_glyph   )
+      goto Fail;
+
+    /* scan all ranges in strike */
+    range       = strike->sbit_ranges;
+    range_limit = range + strike->num_ranges;
+    if ( !range )
+      goto Fail;
+
+    for ( ; range < range_limit; range++ )
+    {
+      if ( glyph_index >= (FT_UInt)range->first_glyph &&
+           glyph_index <= (FT_UInt)range->last_glyph  )
+      {
+        FT_UShort  delta = (FT_UShort)( glyph_index - range->first_glyph );
+
+
+        switch ( range->index_format )
+        {
+        case 1:
+        case 3:
+          *aglyph_offset = range->glyph_offsets[delta];
+          break;
+
+        case 2:
+          *aglyph_offset = range->image_offset +
+                           range->image_size * delta;
+          break;
+
+        case 4:
+        case 5:
+          {
+            FT_ULong  n;
+
+
+            for ( n = 0; n < range->num_glyphs; n++ )
+            {
+              if ( (FT_UInt)range->glyph_codes[n] == glyph_index )
+              {
+                if ( range->index_format == 4 )
+                  *aglyph_offset = range->glyph_offsets[n];
+                else
+                  *aglyph_offset = range->image_offset +
+                                   n * range->image_size;
+                goto Found;
+              }
+            }
+          }
+
+        /* fall-through */
+        default:
+          goto Fail;
+        }
+
+      Found:
+        /* return successfully! */
+        *arange  = range;
+        return 0;
+      }
+    }
+
+  Fail:
+    *arange        = 0;
+    *aglyph_offset = 0;
+
+    return SFNT_Err_Invalid_Argument;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_find_sbit_image                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Checks whether an embedded bitmap (an `sbit') exists for a given   */
+  /*    glyph, at a given strike.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face          :: The target face object.                           */
+  /*                                                                       */
+  /*    glyph_index   :: The glyph index.                                  */
+  /*                                                                       */
+  /*    strike_index  :: The current strike index.                         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    arange        :: The SBit range containing the glyph index.        */
+  /*                                                                       */
+  /*    astrike       :: The SBit strike containing the glyph index.       */
+  /*                                                                       */
+  /*    aglyph_offset :: The offset of the glyph data in `EBDT' table.     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.  Returns                    */
+  /*    SFNT_Err_Invalid_Argument if no sbit exists for the requested      */
+  /*    glyph.                                                             */
+  /*                                                                       */
+  FT_LOCAL( FT_Error )
+  tt_find_sbit_image( TT_Face          face,
+                      FT_UInt          glyph_index,
+                      FT_ULong         strike_index,
+                      TT_SBit_Range   *arange,
+                      TT_SBit_Strike  *astrike,
+                      FT_ULong        *aglyph_offset )
+  {
+    FT_Error        error;
+    TT_SBit_Strike  strike;
+
+
+    if ( !face->sbit_strikes                        ||
+         ( face->num_sbit_strikes <= strike_index ) )
+      goto Fail;
+
+    strike = &face->sbit_strikes[strike_index];
+
+    error = find_sbit_range( glyph_index, strike,
+                             arange, aglyph_offset );
+    if ( error )
+      goto Fail;
+
+    *astrike = strike;
+
+    return SFNT_Err_Ok;
+
+  Fail:
+    /* no embedded bitmap for this glyph in face */
+    *arange        = 0;
+    *astrike       = 0;
+    *aglyph_offset = 0;
+
+    return SFNT_Err_Invalid_Argument;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_load_sbit_metrics                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Gets the big metrics for a given SBit.                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream      :: The input stream.                                   */
+  /*                                                                       */
+  /*    range       :: The SBit range containing the glyph.                */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    big_metrics :: A big SBit metrics structure for the glyph.         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream cursor must be positioned at the glyph's offset within  */
+  /*    the `EBDT' table before the call.                                  */
+  /*                                                                       */
+  /*    If the image format uses variable metrics, the stream cursor is    */
+  /*    positioned just after the metrics header in the `EBDT' table on    */
+  /*    function exit.                                                     */
+  /*                                                                       */
+  FT_LOCAL( FT_Error )
+  tt_load_sbit_metrics( FT_Stream        stream,
+                        TT_SBit_Range    range,
+                        TT_SBit_Metrics  metrics )
+  {
+    FT_Error  error = SFNT_Err_Ok;
+
+
+    switch ( range->image_format )
+    {
+    case 1:
+    case 2:
+    case 8:
+      /* variable small metrics */
+      {
+        TT_SBit_SmallMetricsRec  smetrics;
+
+        const FT_Frame_Field  sbit_small_metrics_fields[] =
+        {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  TT_SBit_SmallMetricsRec
+
+          FT_FRAME_START( 5 ),
+            FT_FRAME_BYTE( height ),
+            FT_FRAME_BYTE( width ),
+            FT_FRAME_CHAR( bearingX ),
+            FT_FRAME_CHAR( bearingY ),
+            FT_FRAME_BYTE( advance ),
+          FT_FRAME_END
+        };
+
+
+        /* read small metrics */
+        if ( FT_STREAM_READ_FIELDS( sbit_small_metrics_fields, &smetrics ) )
+          goto Exit;
+
+        /* convert it to a big metrics */
+        metrics->height       = smetrics.height;
+        metrics->width        = smetrics.width;
+        metrics->horiBearingX = smetrics.bearingX;
+        metrics->horiBearingY = smetrics.bearingY;
+        metrics->horiAdvance  = smetrics.advance;
+
+        /* these metrics are made up at a higher level when */
+        /* needed.                                          */
+        metrics->vertBearingX = 0;
+        metrics->vertBearingY = 0;
+        metrics->vertAdvance  = 0;
+      }
+      break;
+
+    case 6:
+    case 7:
+    case 9:
+      /* variable big metrics */
+      if ( FT_STREAM_READ_FIELDS( sbit_metrics_fields, metrics ) )
+        goto Exit;
+      break;
+
+    case 5:
+    default:  /* constant metrics */
+      if ( range->index_format == 2 || range->index_format == 5 )
+        *metrics = range->metrics;
+      else
+        return SFNT_Err_Invalid_File_Format;
+   }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    crop_bitmap                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Crops a bitmap to its tightest bounding box, and adjusts its       */
+  /*    metrics.                                                           */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    map     :: The bitmap.                                             */
+  /*                                                                       */
+  /*    metrics :: The corresponding metrics structure.                    */
+  /*                                                                       */
+  static void
+  crop_bitmap( FT_Bitmap*       map,
+               TT_SBit_Metrics  metrics )
+  {
+    /***********************************************************************/
+    /*                                                                     */
+    /* In this situation, some bounding boxes of embedded bitmaps are too  */
+    /* large.  We need to crop it to a reasonable size.                    */
+    /*                                                                     */
+    /*      ---------                                                      */
+    /*      |       |                -----                                 */
+    /*      |  ***  |                |***|                                 */
+    /*      |   *   |                | * |                                 */
+    /*      |   *   |    ------>     | * |                                 */
+    /*      |   *   |                | * |                                 */
+    /*      |   *   |                | * |                                 */
+    /*      |  ***  |                |***|                                 */
+    /*      ---------                -----                                 */
+    /*                                                                     */
+    /***********************************************************************/
+
+    FT_Int    rows, count;
+    FT_Long   line_len;
+    FT_Byte*  line;
+
+
+    /***********************************************************************/
+    /*                                                                     */
+    /* first of all, check the top-most lines of the bitmap, and remove    */
+    /* them if they're empty.                                              */
+    /*                                                                     */
+    {
+      line     = (FT_Byte*)map->buffer;
+      rows     = map->rows;
+      line_len = map->pitch;
+
+
+      for ( count = 0; count < rows; count++ )
+      {
+        FT_Byte*  cur   = line;
+        FT_Byte*  limit = line + line_len;
+
+
+        for ( ; cur < limit; cur++ )
+          if ( cur[0] )
+            goto Found_Top;
+
+        /* the current line was empty - skip to next one */
+        line  = limit;
+      }
+
+    Found_Top:
+      /* check that we have at least one filled line */
+      if ( count >= rows )
+        goto Empty_Bitmap;
+
+      /* now, crop the empty upper lines */
+      if ( count > 0 )
+      {
+        line = (FT_Byte*)map->buffer;
+
+        FT_MEM_MOVE( line, line + count * line_len,
+                     ( rows - count ) * line_len );
+
+        metrics->height       = (FT_Byte)( metrics->height - count );
+        metrics->horiBearingY = (FT_Char)( metrics->horiBearingY - count );
+        metrics->vertBearingY = (FT_Char)( metrics->vertBearingY - count );
+
+        map->rows -= count;
+        rows      -= count;
+      }
+    }
+
+    /***********************************************************************/
+    /*                                                                     */
+    /* second, crop the lower lines                                        */
+    /*                                                                     */
+    {
+      line = (FT_Byte*)map->buffer + ( rows - 1 ) * line_len;
+
+      for ( count = 0; count < rows; count++ )
+      {
+        FT_Byte*  cur   = line;
+        FT_Byte*  limit = line + line_len;
+
+
+        for ( ; cur < limit; cur++ )
+          if ( cur[0] )
+            goto Found_Bottom;
+
+        /* the current line was empty - skip to previous one */
+        line -= line_len;
+      }
+
+    Found_Bottom:
+      if ( count > 0 )
+      {
+        metrics->height  = (FT_Byte)( metrics->height - count );
+        rows            -= count;
+        map->rows       -= count;
+      }
+    }
+
+    /***********************************************************************/
+    /*                                                                     */
+    /* third, get rid of the space on the left side of the glyph           */
+    /*                                                                     */
+    do
+    {
+      FT_Byte*  limit;
+
+
+      line  = (FT_Byte*)map->buffer;
+      limit = line + rows * line_len;
+
+      for ( ; line < limit; line += line_len )
+        if ( line[0] & 0x80 )
+          goto Found_Left;
+
+      /* shift the whole glyph one pixel to the left */
+      line  = (FT_Byte*)map->buffer;
+      limit = line + rows * line_len;
+
+      for ( ; line < limit; line += line_len )
+      {
+        FT_Int    n, width = map->width;
+        FT_Byte   old;
+        FT_Byte*  cur = line;
+
+
+        old = (FT_Byte)(cur[0] << 1);
+        for ( n = 8; n < width; n += 8 )
+        {
+          FT_Byte  val;
+
+
+          val    = cur[1];
+          cur[0] = (FT_Byte)( old | ( val >> 7 ) );
+          old    = (FT_Byte)( val << 1 );
+          cur++;
+        }
+        cur[0] = old;
+      }
+
+      map->width--;
+      metrics->horiBearingX++;
+      metrics->vertBearingX++;
+      metrics->width--;
+
+    } while ( map->width > 0 );
+
+  Found_Left:
+
+    /***********************************************************************/
+    /*                                                                     */
+    /* finally, crop the bitmap width to get rid of the space on the right */
+    /* side of the glyph.                                                  */
+    /*                                                                     */
+    do
+    {
+      FT_Int    right = map->width - 1;
+      FT_Byte*  limit;
+      FT_Byte   mask;
+
+
+      line  = (FT_Byte*)map->buffer + ( right >> 3 );
+      limit = line + rows * line_len;
+      mask  = (FT_Byte)( 0x80 >> ( right & 7 ) );
+
+      for ( ; line < limit; line += line_len )
+        if ( line[0] & mask )
+          goto Found_Right;
+
+      /* crop the whole glyph to the right */
+      map->width--;
+      metrics->width--;
+
+    } while ( map->width > 0 );
+
+  Found_Right:
+    /* all right, the bitmap was cropped */
+    return;
+
+  Empty_Bitmap:
+    map->width      = 0;
+    map->rows       = 0;
+    map->pitch      = 0;
+    map->pixel_mode = FT_PIXEL_MODE_MONO;
+  }
+
+
+  static FT_Error
+  Load_SBit_Single( FT_Bitmap*       map,
+                    FT_Int           x_offset,
+                    FT_Int           y_offset,
+                    FT_Int           pix_bits,
+                    FT_UShort        image_format,
+                    TT_SBit_Metrics  metrics,
+                    FT_Stream        stream )
+  {
+    FT_Error  error;
+
+
+    /* check that the source bitmap fits into the target pixmap */
+    if ( x_offset < 0 || x_offset + metrics->width  > map->width ||
+         y_offset < 0 || y_offset + metrics->height > map->rows  )
+    {
+      error = SFNT_Err_Invalid_Argument;
+
+      goto Exit;
+    }
+
+    {
+      FT_Int   glyph_width  = metrics->width;
+      FT_Int   glyph_height = metrics->height;
+      FT_Int   glyph_size;
+      FT_Int   line_bits    = pix_bits * glyph_width;
+      FT_Bool  pad_bytes    = 0;
+
+
+      /* compute size of glyph image */
+      switch ( image_format )
+      {
+      case 1:  /* byte-padded formats */
+      case 6:
+        {
+          FT_Int  line_length;
+
+
+          switch ( pix_bits )
+          {
+          case 1:
+            line_length = ( glyph_width + 7 ) >> 3;
+            break;
+          case 2:
+            line_length = ( glyph_width + 3 ) >> 2;
+            break;
+          case 4:
+            line_length = ( glyph_width + 1 ) >> 1;
+            break;
+          default:
+            line_length =   glyph_width;
+          }
+
+          glyph_size = glyph_height * line_length;
+          pad_bytes  = 1;
+        }
+        break;
+
+      case 2:
+      case 5:
+      case 7:
+        line_bits  =   glyph_width  * pix_bits;
+        glyph_size = ( glyph_height * line_bits + 7 ) >> 3;
+        break;
+
+      default:  /* invalid format */
+        return SFNT_Err_Invalid_File_Format;
+      }
+
+      /* Now read data and draw glyph into target pixmap       */
+      if ( FT_FRAME_ENTER( glyph_size ) )
+        goto Exit;
+
+      /* don't forget to multiply `x_offset' by `map->pix_bits' as */
+      /* the sbit blitter doesn't make a difference between pixmap */
+      /* depths.                                                   */
+      blit_sbit( map, (FT_Byte*)stream->cursor, line_bits, pad_bytes,
+                 x_offset * pix_bits, y_offset );
+
+      FT_FRAME_EXIT();
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  Load_SBit_Image( TT_SBit_Strike   strike,
+                   TT_SBit_Range    range,
+                   FT_ULong         ebdt_pos,
+                   FT_ULong         glyph_offset,
+                   FT_GlyphSlot     slot,
+                   FT_Int           x_offset,
+                   FT_Int           y_offset,
+                   FT_Stream        stream,
+                   TT_SBit_Metrics  metrics,
+                   FT_Int           depth )
+  {
+    FT_Memory   memory = stream->memory;
+    FT_Bitmap*  map    = &slot->bitmap;
+    FT_Error    error;
+
+
+    /* place stream at beginning of glyph data and read metrics */
+    if ( FT_STREAM_SEEK( ebdt_pos + glyph_offset ) )
+      goto Exit;
+
+    error = tt_load_sbit_metrics( stream, range, metrics );
+    if ( error )
+      goto Exit;
+
+    /* This function is recursive.  At the top-level call, we  */
+    /* compute the dimensions of the higher-level glyph to     */
+    /* allocate the final pixmap buffer.                       */
+    if ( depth == 0 )
+    {
+      FT_Long  size;
+
+
+      map->width = metrics->width;
+      map->rows  = metrics->height;
+
+      switch ( strike->bit_depth )
+      {
+      case 1:
+        map->pixel_mode = FT_PIXEL_MODE_MONO;
+        map->pitch      = ( map->width + 7 ) >> 3;
+        break;
+
+      case 2:
+        map->pixel_mode = FT_PIXEL_MODE_GRAY2;
+        map->pitch      = ( map->width + 3 ) >> 2;
+        break;
+
+      case 4:
+        map->pixel_mode = FT_PIXEL_MODE_GRAY4;
+        map->pitch      = ( map->width + 1 ) >> 1;
+        break;
+
+      case 8:
+        map->pixel_mode = FT_PIXEL_MODE_GRAY;
+        map->pitch      = map->width;
+        break;
+
+      default:
+        return SFNT_Err_Invalid_File_Format;
+      }
+
+      size = map->rows * map->pitch;
+
+      /* check that there is no empty image */
+      if ( size == 0 )
+        goto Exit;     /* exit successfully! */
+
+      error = ft_glyphslot_alloc_bitmap( slot, size );
+      if (error)
+        goto Exit;
+    }
+
+    switch ( range->image_format )
+    {
+    case 1:  /* single sbit image - load it */
+    case 2:
+    case 5:
+    case 6:
+    case 7:
+      return Load_SBit_Single( map, x_offset, y_offset, strike->bit_depth,
+                               range->image_format, metrics, stream );
+
+    case 8:  /* compound format */
+      FT_Stream_Skip( stream, 1L );
+      /* fallthrough */
+
+    case 9:
+      break;
+
+    default: /* invalid image format */
+      return SFNT_Err_Invalid_File_Format;
+    }
+
+    /* All right, we have a compound format.  First of all, read */
+    /* the array of elements.                                    */
+    {
+      TT_SBit_Component  components;
+      TT_SBit_Component  comp;
+      FT_UShort          num_components, count;
+
+
+      if ( FT_READ_USHORT( num_components )           ||
+           FT_NEW_ARRAY( components, num_components ) )
+        goto Exit;
+
+      count = num_components;
+
+      if ( FT_FRAME_ENTER( 4L * num_components ) )
+        goto Fail_Memory;
+
+      for ( comp = components; count > 0; count--, comp++ )
+      {
+        comp->glyph_code = FT_GET_USHORT();
+        comp->x_offset   = FT_GET_CHAR();
+        comp->y_offset   = FT_GET_CHAR();
+      }
+
+      FT_FRAME_EXIT();
+
+      /* Now recursively load each element glyph */
+      count = num_components;
+      comp  = components;
+      for ( ; count > 0; count--, comp++ )
+      {
+        TT_SBit_Range       elem_range;
+        TT_SBit_MetricsRec  elem_metrics;
+        FT_ULong            elem_offset;
+
+
+        /* find the range for this element */
+        error = find_sbit_range( comp->glyph_code,
+                                 strike,
+                                 &elem_range,
+                                 &elem_offset );
+        if ( error )
+          goto Fail_Memory;
+
+        /* now load the element, recursively */
+        error = Load_SBit_Image( strike,
+                                 elem_range,
+                                 ebdt_pos,
+                                 elem_offset,
+                                 slot,
+                                 x_offset + comp->x_offset,
+                                 y_offset + comp->y_offset,
+                                 stream,
+                                 &elem_metrics,
+                                 depth + 1 );
+        if ( error )
+          goto Fail_Memory;
+      }
+
+    Fail_Memory:
+      FT_FREE( components );
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_sbit_image                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads a given glyph sbit image from the font resource.  This also  */
+  /*    returns its metrics.                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face         :: The target face object.                            */
+  /*                                                                       */
+  /*    strike_index :: The current strike index.                          */
+  /*                                                                       */
+  /*    glyph_index  :: The current glyph index.                           */
+  /*                                                                       */
+  /*    load_flags   :: The glyph load flags (the code checks for the flag */
+  /*                    FT_LOAD_CROP_BITMAP).                              */
+  /*                                                                       */
+  /*    stream       :: The input stream.                                  */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    map          :: The target pixmap.                                 */
+  /*                                                                       */
+  /*    metrics      :: A big sbit metrics structure for the glyph image.  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.  Returns an error if no     */
+  /*    glyph sbit exists for the index.                                   */
+  /*                                                                       */
+  /*  <Note>                                                               */
+  /*    The `map.buffer' field is always freed before the glyph is loaded. */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_sbit_image( TT_Face              face,
+                           FT_ULong             strike_index,
+                           FT_UInt              glyph_index,
+                           FT_UInt              load_flags,
+                           FT_Stream            stream,
+                           FT_Bitmap           *map,
+                           TT_SBit_MetricsRec  *metrics )
+  {
+    FT_Error        error;
+    FT_ULong        ebdt_pos, glyph_offset;
+
+    TT_SBit_Strike  strike;
+    TT_SBit_Range   range;
+
+
+    /* Check whether there is a glyph sbit for the current index */
+    error = tt_find_sbit_image( face, glyph_index, strike_index,
+                                &range, &strike, &glyph_offset );
+    if ( error )
+      goto Exit;
+
+    /* now, find the location of the `EBDT' table in */
+    /* the font file                                 */
+    error = face->goto_table( face, TTAG_EBDT, stream, 0 );
+    if ( error )
+      error = face->goto_table( face, TTAG_bdat, stream, 0 );
+    if (error)
+      goto Exit;
+
+    ebdt_pos = FT_STREAM_POS();
+
+    error = Load_SBit_Image( strike, range, ebdt_pos, glyph_offset,
+                             face->root.glyph, 0, 0, stream, metrics, 0 );
+    if ( error )
+      goto Exit;
+
+    /* setup vertical metrics if needed */
+    if ( strike->flags & 1 )
+    {
+      /* in case of a horizontal strike only */
+      FT_Int  advance;
+
+
+      advance = strike->hori.ascender - strike->hori.descender;
+
+      /* some heuristic values */
+
+      metrics->vertBearingX = (FT_Char)(-metrics->width / 2 );
+      metrics->vertBearingY = (FT_Char)( advance / 10 );
+      metrics->vertAdvance  = (FT_Char)( advance * 12 / 10 );
+    }
+
+    /* Crop the bitmap now, unless specified otherwise */
+    if ( load_flags & FT_LOAD_CROP_BITMAP )
+      crop_bitmap( map, metrics );
+
+  Exit:
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/sfnt/ttsbit.h b/nx-X11/extras/freetype2/src/sfnt/ttsbit.h
new file mode 100644
index 000000000..f1b63b7ec
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/sfnt/ttsbit.h
@@ -0,0 +1,72 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttsbit.h                                                               */
+/*                                                                         */
+/*    TrueType and OpenType embedded bitmap support (specification).       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 __TTSBIT_H__
+#define __TTSBIT_H__
+
+
+#include <ft2build.h>
+#include "ttload.h"
+
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_sbit_strikes( TT_Face    face,
+                             FT_Stream  stream );
+
+  FT_LOCAL( void )
+  tt_face_free_sbit_strikes( TT_Face  face );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_set_sbit_strike( TT_Face    face,
+                           FT_UInt    x_ppem,
+                           FT_UInt    y_ppem,
+                           FT_ULong  *astrike_index );
+
+  FT_LOCAL( FT_Error )
+  tt_find_sbit_image( TT_Face          face,
+                      FT_UInt          glyph_index,
+                      FT_ULong         strike_index,
+                      TT_SBit_Range   *arange,
+                      TT_SBit_Strike  *astrike,
+                      FT_ULong        *aglyph_offset );
+
+  FT_LOCAL( FT_Error )
+  tt_load_sbit_metrics( FT_Stream        stream,
+                        TT_SBit_Range    range,
+                        TT_SBit_Metrics  metrics );
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_sbit_image( TT_Face              face,
+                           FT_ULong             strike_index,
+                           FT_UInt              glyph_index,
+                           FT_UInt              load_flags,
+                           FT_Stream            stream,
+                           FT_Bitmap           *map,
+                           TT_SBit_MetricsRec  *metrics );
+
+
+FT_END_HEADER
+
+#endif /* __TTSBIT_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/smooth/Jamfile b/nx-X11/extras/freetype2/src/smooth/Jamfile
new file mode 100644
index 000000000..5ab9b60c7
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/smooth Jamfile (c) 2001 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) smooth ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = ftgrays ftsmooth ;
+  }
+  else
+  {
+    _sources = smooth ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/smooth Jamfile
diff --git a/nx-X11/extras/freetype2/src/smooth/descrip.mms b/nx-X11/extras/freetype2/src/smooth/descrip.mms
new file mode 100644
index 000000000..9ebc7ff22
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 smooth renderer module compilation rules for VMS
+#
+
+
+# Copyright 2001 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.smooth])
+
+OBJS=smooth.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/smooth/ftgrays.c b/nx-X11/extras/freetype2/src/smooth/ftgrays.c
new file mode 100644
index 000000000..499cc8cb5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/ftgrays.c
@@ -0,0 +1,2159 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgrays.c                                                              */
+/*                                                                         */
+/*    A new `perfect' anti-aliasing renderer (body).                       */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003 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 can be compiled without the rest of the FreeType engine, by */
+  /* defining the _STANDALONE_ macro when compiling it.  You also need to  */
+  /* put the files `ftgrays.h' and `ftimage.h' into the current            */
+  /* compilation directory.  Typically, you could do something like        */
+  /*                                                                       */
+  /* - copy `src/smooth/ftgrays.c' (this file) to your current directory   */
+  /*                                                                       */
+  /* - copy `include/freetype/ftimage.h' and `src/smooth/ftgrays.h' to the */
+  /*   same directory                                                      */
+  /*                                                                       */
+  /* - compile `ftgrays' with the _STANDALONE_ macro defined, as in        */
+  /*                                                                       */
+  /*     cc -c -D_STANDALONE_ ftgrays.c                                    */
+  /*                                                                       */
+  /* The renderer can be initialized with a call to                        */
+  /* `ft_gray_raster.raster_new'; an anti-aliased bitmap can be generated  */
+  /* with a call to `ft_gray_raster.raster_render'.                        */
+  /*                                                                       */
+  /* See the comments and documentation in the file `ftimage.h' for more   */
+  /* details on how the raster works.                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This is a new anti-aliasing scan-converter for FreeType 2.  The       */
+  /* algorithm used here is _very_ different from the one in the standard  */
+  /* `ftraster' module.  Actually, `ftgrays' computes the _exact_          */
+  /* coverage of the outline on each pixel cell.                           */
+  /*                                                                       */
+  /* It is based on ideas that I initially found in Raph Levien's          */
+  /* excellent LibArt graphics library (see http://www.levien.com/libart   */
+  /* for more information, though the web pages do not tell anything       */
+  /* about the renderer; you'll have to dive into the source code to       */
+  /* understand how it works).                                             */
+  /*                                                                       */
+  /* Note, however, that this is a _very_ different implementation         */
+  /* compared to Raph's.  Coverage information is stored in a very         */
+  /* different way, and I don't use sorted vector paths.  Also, it doesn't */
+  /* use floating point values.                                            */
+  /*                                                                       */
+  /* This renderer has the following advantages:                           */
+  /*                                                                       */
+  /* - It doesn't need an intermediate bitmap.  Instead, one can supply a  */
+  /*   callback function that will be called by the renderer to draw gray  */
+  /*   spans on any target surface.  You can thus do direct composition on */
+  /*   any kind of bitmap, provided that you give the renderer the right   */
+  /*   callback.                                                           */
+  /*                                                                       */
+  /* - A perfect anti-aliaser, i.e., it computes the _exact_ coverage on   */
+  /*   each pixel cell.                                                    */
+  /*                                                                       */
+  /* - It performs a single pass on the outline (the `standard' FT2        */
+  /*   renderer makes two passes).                                         */
+  /*                                                                       */
+  /* - It can easily be modified to render to _any_ number of gray levels  */
+  /*   cheaply.                                                            */
+  /*                                                                       */
+  /* - For small (< 20) pixel sizes, it is faster than the standard        */
+  /*   renderer.                                                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+
+/* experimental support for gamma correction within the rasterizer */
+#define xxxGRAYS_USE_GAMMA
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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_smooth
+
+
+#define ErrRaster_MemoryOverflow   -4
+
+
+#ifdef _STANDALONE_
+
+#include <string.h>             /* for ft_memcpy() */
+#include <setjmp.h>
+#include <limits.h>
+#define FT_UINT_MAX  UINT_MAX
+
+#define ft_memset   memset
+
+#define ft_setjmp   setjmp
+#define ft_longjmp  longjmp
+#define ft_jmp_buf  jmp_buf
+
+
+#define ErrRaster_Invalid_Mode     -2
+#define ErrRaster_Invalid_Outline  -1
+
+#define FT_BEGIN_HEADER
+#define FT_END_HEADER
+
+#include "ftimage.h"
+#include "ftgrays.h"
+
+  /* This macro is used to indicate that a function parameter is unused. */
+  /* Its purpose is simply to reduce compiler warnings.  Note also that  */
+  /* simply defining it as `(void)x' doesn't avoid warnings with certain */
+  /* ANSI compilers (e.g. LCC).                                          */
+#define FT_UNUSED( x )  (x) = (x)
+
+  /* Disable the tracing mechanism for simplicity -- developers can      */
+  /* activate it easily by redefining these two macros.                  */
+#ifndef FT_ERROR
+#define FT_ERROR( x )  do ; while ( 0 )     /* nothing */
+#endif
+
+#ifndef FT_TRACE
+#define FT_TRACE( x )  do ; while ( 0 )     /* nothing */
+#endif
+
+
+#else /* _STANDALONE_ */
+
+
+#include <ft2build.h>
+#include "ftgrays.h"
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_OUTLINE_H
+
+#include "ftsmerrs.h"
+
+#define ErrRaster_Invalid_Mode     Smooth_Err_Cannot_Render_Glyph
+#define ErrRaster_Invalid_Outline  Smooth_Err_Invalid_Outline
+
+
+#endif /* _STANDALONE_ */
+
+
+#ifndef FT_MEM_SET
+#define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
+#endif
+
+#ifndef FT_MEM_ZERO
+#define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
+#endif
+
+  /* define this to dump debugging information */
+#define xxxDEBUG_GRAYS
+
+  /* as usual, for the speed hungry :-) */
+
+#ifndef FT_STATIC_RASTER
+
+
+#define RAS_ARG   PRaster  raster
+#define RAS_ARG_  PRaster  raster,
+
+#define RAS_VAR   raster
+#define RAS_VAR_  raster,
+
+#define ras       (*raster)
+
+
+#else /* FT_STATIC_RASTER */
+
+
+#define RAS_ARG   /* empty */
+#define RAS_ARG_  /* empty */
+#define RAS_VAR   /* empty */
+#define RAS_VAR_  /* empty */
+
+  static TRaster  ras;
+
+
+#endif /* FT_STATIC_RASTER */
+
+
+  /* must be at least 6 bits! */
+#define PIXEL_BITS  8
+
+#define ONE_PIXEL       ( 1L << PIXEL_BITS )
+#define PIXEL_MASK      ( -1L << PIXEL_BITS )
+#define TRUNC( x )      ( (TCoord)((x) >> PIXEL_BITS) )
+#define SUBPIXELS( x )  ( (TPos)(x) << PIXEL_BITS )
+#define FLOOR( x )      ( (x) & -ONE_PIXEL )
+#define CEILING( x )    ( ( (x) + ONE_PIXEL - 1 ) & -ONE_PIXEL )
+#define ROUND( x )      ( ( (x) + ONE_PIXEL / 2 ) & -ONE_PIXEL )
+
+#if PIXEL_BITS >= 6
+#define UPSCALE( x )    ( (x) << ( PIXEL_BITS - 6 ) )
+#define DOWNSCALE( x )  ( (x) >> ( PIXEL_BITS - 6 ) )
+#else
+#define UPSCALE( x )    ( (x) >> ( 6 - PIXEL_BITS ) )
+#define DOWNSCALE( x )  ( (x) << ( 6 - PIXEL_BITS ) )
+#endif
+
+  /* Define this if you want to use a more compact storage scheme.  This   */
+  /* increases the number of cells available in the render pool but slows  */
+  /* down the rendering a bit.  It is useful if you have a really tiny     */
+  /* render pool.                                                          */
+#undef GRAYS_COMPACT
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*   TYPE DEFINITIONS                                                    */
+  /*                                                                       */
+
+  /* don't change the following types to FT_Int or FT_Pos, since we might */
+  /* need to define them to "float" or "double" when experimenting with   */
+  /* new algorithms                                                       */
+
+  typedef int   TCoord;   /* integer scanline/pixel coordinate */
+  typedef long  TPos;     /* sub-pixel coordinate              */
+
+  /* determine the type used to store cell areas.  This normally takes at */
+  /* least PIXEL_BYTES*2 + 1.  On 16-bit systems, we need to use `long'   */
+  /* instead of `int', otherwise bad things happen                        */
+
+#if PIXEL_BITS <= 7
+
+  typedef int   TArea;
+
+#else /* PIXEL_BITS >= 8 */
+
+  /* approximately determine the size of integers using an ANSI-C header */
+#if FT_UINT_MAX == 0xFFFFU
+  typedef long  TArea;
+#else
+  typedef int  TArea;
+#endif
+
+#endif /* PIXEL_BITS >= 8 */
+
+
+  /* maximal number of gray spans in a call to the span callback */
+#define FT_MAX_GRAY_SPANS  32
+
+
+#ifdef GRAYS_COMPACT
+
+  typedef struct  TCell_
+  {
+    short  x     : 14;
+    short  y     : 14;
+    int    cover : PIXEL_BITS + 2;
+    int    area  : PIXEL_BITS * 2 + 2;
+
+  } TCell, *PCell;
+
+#else /* GRAYS_COMPACT */
+
+  typedef struct  TCell_
+  {
+    TCoord  x;
+    TCoord  y;
+    int     cover;
+    TArea   area;
+
+  } TCell, *PCell;
+
+#endif /* GRAYS_COMPACT */
+
+
+  typedef struct  TRaster_
+  {
+    PCell   cells;
+    int     max_cells;
+    int     num_cells;
+
+    TPos    min_ex, max_ex;
+    TPos    min_ey, max_ey;
+
+    TArea   area;
+    int     cover;
+    int     invalid;
+
+    TCoord  ex, ey;
+    TCoord  cx, cy;
+    TPos    x,  y;
+
+    TPos    last_ey;
+
+    FT_Vector   bez_stack[32 * 3 + 1];
+    int         lev_stack[32];
+
+    FT_Outline  outline;
+    FT_Bitmap   target;
+    FT_BBox     clip_box;
+
+    FT_Span     gray_spans[FT_MAX_GRAY_SPANS];
+    int         num_gray_spans;
+
+    FT_Raster_Span_Func  render_span;
+    void*                render_span_data;
+    int                  span_y;
+
+    int  band_size;
+    int  band_shoot;
+    int  conic_level;
+    int  cubic_level;
+
+    void*       memory;
+    ft_jmp_buf  jump_buffer;
+
+#ifdef GRAYS_USE_GAMMA
+    unsigned char  gamma[257];
+#endif
+
+  } TRaster, *PRaster;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Initialize the cells table.                                           */
+  /*                                                                       */
+  static void
+  gray_init_cells( RAS_ARG_ void*  buffer,
+                   long            byte_size )
+  {
+    ras.cells     = (PCell)buffer;
+    ras.max_cells = (int)( byte_size / sizeof ( TCell ) );
+    ras.num_cells = 0;
+    ras.area      = 0;
+    ras.cover     = 0;
+    ras.invalid   = 1;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Compute the outline bounding box.                                     */
+  /*                                                                       */
+  static void
+  gray_compute_cbox( RAS_ARG )
+  {
+    FT_Outline*  outline = &ras.outline;
+    FT_Vector*   vec     = outline->points;
+    FT_Vector*   limit   = vec + outline->n_points;
+
+
+    if ( outline->n_points <= 0 )
+    {
+      ras.min_ex = ras.max_ex = 0;
+      ras.min_ey = ras.max_ey = 0;
+      return;
+    }
+
+    ras.min_ex = ras.max_ex = vec->x;
+    ras.min_ey = ras.max_ey = vec->y;
+
+    vec++;
+
+    for ( ; vec < limit; vec++ )
+    {
+      TPos  x = vec->x;
+      TPos  y = vec->y;
+
+
+      if ( x < ras.min_ex ) ras.min_ex = x;
+      if ( x > ras.max_ex ) ras.max_ex = x;
+      if ( y < ras.min_ey ) ras.min_ey = y;
+      if ( y > ras.max_ey ) ras.max_ey = y;
+    }
+
+    /* truncate the bounding box to integer pixels */
+    ras.min_ex = ras.min_ex >> 6;
+    ras.min_ey = ras.min_ey >> 6;
+    ras.max_ex = ( ras.max_ex + 63 ) >> 6;
+    ras.max_ey = ( ras.max_ey + 63 ) >> 6;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Record the current cell in the table.                                 */
+  /*                                                                       */
+  static void
+  gray_record_cell( RAS_ARG )
+  {
+    PCell  cell;
+
+
+    if ( !ras.invalid && ( ras.area | ras.cover ) )
+    {
+      if ( ras.num_cells >= ras.max_cells )
+        ft_longjmp( ras.jump_buffer, 1 );
+
+      cell        = ras.cells + ras.num_cells++;
+      cell->x     = (TCoord)(ras.ex - ras.min_ex);
+      cell->y     = (TCoord)(ras.ey - ras.min_ey);
+      cell->area  = ras.area;
+      cell->cover = ras.cover;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Set the current cell to a new position.                               */
+  /*                                                                       */
+  static void
+  gray_set_cell( RAS_ARG_ TCoord  ex,
+                          TCoord  ey )
+  {
+    int  invalid, record, clean;
+
+
+    /* Move the cell pointer to a new position.  We set the `invalid'      */
+    /* flag to indicate that the cell isn't part of those we're interested */
+    /* in during the render phase.  This means that:                       */
+    /*                                                                     */
+    /* . the new vertical position must be within min_ey..max_ey-1.        */
+    /* . the new horizontal position must be strictly less than max_ex     */
+    /*                                                                     */
+    /* Note that if a cell is to the left of the clipping region, it is    */
+    /* actually set to the (min_ex-1) horizontal position.                 */
+
+    record  = 0;
+    clean   = 1;
+
+    invalid = ( ey < ras.min_ey || ey >= ras.max_ey || ex >= ras.max_ex );
+    if ( !invalid )
+    {
+      /* All cells that are on the left of the clipping region go to the */
+      /* min_ex - 1 horizontal position.                                 */
+      if ( ex < ras.min_ex )
+        ex = (TCoord)(ras.min_ex - 1);
+
+      /* if our position is new, then record the previous cell */
+      if ( ex != ras.ex || ey != ras.ey )
+        record = 1;
+      else
+        clean = ras.invalid;  /* do not clean if we didn't move from */
+                              /* a valid cell                        */
+    }
+
+    /* record the previous cell if needed (i.e., if we changed the cell */
+    /* position, of changed the `invalid' flag)                         */
+    if ( ras.invalid != invalid || record )
+      gray_record_cell( RAS_VAR );
+
+    if ( clean )
+    {
+      ras.area  = 0;
+      ras.cover = 0;
+    }
+
+    ras.invalid = invalid;
+    ras.ex      = ex;
+    ras.ey      = ey;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Start a new contour at a given cell.                                  */
+  /*                                                                       */
+  static void
+  gray_start_cell( RAS_ARG_  TCoord  ex,
+                             TCoord  ey )
+  {
+    if ( ex < ras.min_ex )
+      ex = (TCoord)(ras.min_ex - 1);
+
+    ras.area    = 0;
+    ras.cover   = 0;
+    ras.ex      = ex;
+    ras.ey      = ey;
+    ras.last_ey = SUBPIXELS( ey );
+    ras.invalid = 0;
+
+    gray_set_cell( RAS_VAR_ ex, ey );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Render a scanline as one or more cells.                               */
+  /*                                                                       */
+  static void
+  gray_render_scanline( RAS_ARG_  TCoord  ey,
+                                  TPos    x1,
+                                  TCoord  y1,
+                                  TPos    x2,
+                                  TCoord  y2 )
+  {
+    TCoord  ex1, ex2, fx1, fx2, delta;
+    long    p, first, dx;
+    int     incr, lift, mod, rem;
+
+
+    dx = x2 - x1;
+
+    ex1 = TRUNC( x1 ); /* if (ex1 >= ras.max_ex) ex1 = ras.max_ex-1; */
+    ex2 = TRUNC( x2 ); /* if (ex2 >= ras.max_ex) ex2 = ras.max_ex-1; */
+    fx1 = (TCoord)( x1 - SUBPIXELS( ex1 ) );
+    fx2 = (TCoord)( x2 - SUBPIXELS( ex2 ) );
+
+    /* trivial case.  Happens often */
+    if ( y1 == y2 )
+    {
+      gray_set_cell( RAS_VAR_ ex2, ey );
+      return;
+    }
+
+    /* everything is located in a single cell.  That is easy! */
+    /*                                                        */
+    if ( ex1 == ex2 )
+    {
+      delta      = y2 - y1;
+      ras.area  += (TArea)( fx1 + fx2 ) * delta;
+      ras.cover += delta;
+      return;
+    }
+
+    /* ok, we'll have to render a run of adjacent cells on the same */
+    /* scanline...                                                  */
+    /*                                                              */
+    p     = ( ONE_PIXEL - fx1 ) * ( y2 - y1 );
+    first = ONE_PIXEL;
+    incr  = 1;
+
+    if ( dx < 0 )
+    {
+      p     = fx1 * ( y2 - y1 );
+      first = 0;
+      incr  = -1;
+      dx    = -dx;
+    }
+
+    delta = (TCoord)( p / dx );
+    mod   = (TCoord)( p % dx );
+    if ( mod < 0 )
+    {
+      delta--;
+      mod += (TCoord)dx;
+    }
+
+    ras.area  += (TArea)( fx1 + first ) * delta;
+    ras.cover += delta;
+
+    ex1 += incr;
+    gray_set_cell( RAS_VAR_ ex1, ey );
+    y1  += delta;
+
+    if ( ex1 != ex2 )
+    {
+      p    = ONE_PIXEL * ( y2 - y1 + delta );
+      lift = (TCoord)( p / dx );
+      rem  = (TCoord)( p % dx );
+      if ( rem < 0 )
+      {
+        lift--;
+        rem += (TCoord)dx;
+      }
+
+      mod -= (int)dx;
+
+      while ( ex1 != ex2 )
+      {
+        delta = lift;
+        mod  += rem;
+        if ( mod >= 0 )
+        {
+          mod -= (TCoord)dx;
+          delta++;
+        }
+
+        ras.area  += (TArea)ONE_PIXEL * delta;
+        ras.cover += delta;
+        y1        += delta;
+        ex1       += incr;
+        gray_set_cell( RAS_VAR_ ex1, ey );
+      }
+    }
+
+    delta      = y2 - y1;
+    ras.area  += (TArea)( fx2 + ONE_PIXEL - first ) * delta;
+    ras.cover += delta;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Render a given line as a series of scanlines.                         */
+  /*                                                                       */
+  static void
+  gray_render_line( RAS_ARG_ TPos  to_x,
+                             TPos  to_y )
+  {
+    TCoord  ey1, ey2, fy1, fy2;
+    TPos    dx, dy, x, x2;
+    long    p, first;
+    int     delta, rem, mod, lift, incr;
+
+
+    ey1 = TRUNC( ras.last_ey );
+    ey2 = TRUNC( to_y ); /* if (ey2 >= ras.max_ey) ey2 = ras.max_ey-1; */
+    fy1 = (TCoord)( ras.y - ras.last_ey );
+    fy2 = (TCoord)( to_y - SUBPIXELS( ey2 ) );
+
+    dx = to_x - ras.x;
+    dy = to_y - ras.y;
+
+    /* XXX: we should do something about the trivial case where dx == 0, */
+    /*      as it happens very often!                                    */
+
+    /* perform vertical clipping */
+    {
+      TCoord  min, max;
+
+
+      min = ey1;
+      max = ey2;
+      if ( ey1 > ey2 )
+      {
+        min = ey2;
+        max = ey1;
+      }
+      if ( min >= ras.max_ey || max < ras.min_ey )
+        goto End;
+    }
+
+    /* everything is on a single scanline */
+    if ( ey1 == ey2 )
+    {
+      gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, to_x, fy2 );
+      goto End;
+    }
+
+    /* vertical line - avoid calling gray_render_scanline */
+    incr = 1;
+
+    if ( dx == 0 )
+    {
+      TCoord  ex     = TRUNC( ras.x );
+      TCoord  two_fx = (TCoord)( ( ras.x - SUBPIXELS( ex ) ) << 1 );
+      TPos    area;
+
+
+      first = ONE_PIXEL;
+      if ( dy < 0 )
+      {
+        first = 0;
+        incr  = -1;
+      }
+
+      delta      = (int)( first - fy1 );
+      ras.area  += (TArea)two_fx * delta;
+      ras.cover += delta;
+      ey1       += incr;
+
+      gray_set_cell( raster, ex, ey1 );
+
+      delta = (int)( first + first - ONE_PIXEL );
+      area  = (TArea)two_fx * delta;
+      while ( ey1 != ey2 )
+      {
+        ras.area  += area;
+        ras.cover += delta;
+        ey1       += incr;
+        gray_set_cell( raster, ex, ey1 );
+      }
+
+      delta      = (int)( fy2 - ONE_PIXEL + first );
+      ras.area  += (TArea)two_fx * delta;
+      ras.cover += delta;
+      goto End;
+    }
+
+    /* ok, we have to render several scanlines */
+    p     = ( ONE_PIXEL - fy1 ) * dx;
+    first = ONE_PIXEL;
+    incr  = 1;
+
+    if ( dy < 0 )
+    {
+      p     = fy1 * dx;
+      first = 0;
+      incr  = -1;
+      dy    = -dy;
+    }
+
+    delta = (int)( p / dy );
+    mod   = (int)( p % dy );
+    if ( mod < 0 )
+    {
+      delta--;
+      mod += (TCoord)dy;
+    }
+
+    x = ras.x + delta;
+    gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, (TCoord)first );
+
+    ey1 += incr;
+    gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
+
+    if ( ey1 != ey2 )
+    {
+      p     = ONE_PIXEL * dx;
+      lift  = (int)( p / dy );
+      rem   = (int)( p % dy );
+      if ( rem < 0 )
+      {
+        lift--;
+        rem += (int)dy;
+      }
+      mod -= (int)dy;
+
+      while ( ey1 != ey2 )
+      {
+        delta = lift;
+        mod  += rem;
+        if ( mod >= 0 )
+        {
+          mod -= (int)dy;
+          delta++;
+        }
+
+        x2 = x + delta;
+        gray_render_scanline( RAS_VAR_ ey1, x,
+                                       (TCoord)( ONE_PIXEL - first ), x2,
+                                       (TCoord)first );
+        x = x2;
+
+        ey1 += incr;
+        gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
+      }
+    }
+
+    gray_render_scanline( RAS_VAR_ ey1, x,
+                                   (TCoord)( ONE_PIXEL - first ), to_x,
+                                   fy2 );
+
+  End:
+    ras.x       = to_x;
+    ras.y       = to_y;
+    ras.last_ey = SUBPIXELS( ey2 );
+  }
+
+
+  static void
+  gray_split_conic( FT_Vector*  base )
+  {
+    TPos  a, b;
+
+
+    base[4].x = base[2].x;
+    b = base[1].x;
+    a = base[3].x = ( base[2].x + b ) / 2;
+    b = base[1].x = ( base[0].x + b ) / 2;
+    base[2].x = ( a + b ) / 2;
+
+    base[4].y = base[2].y;
+    b = base[1].y;
+    a = base[3].y = ( base[2].y + b ) / 2;
+    b = base[1].y = ( base[0].y + b ) / 2;
+    base[2].y = ( a + b ) / 2;
+  }
+
+
+  static void
+  gray_render_conic( RAS_ARG_ FT_Vector*  control,
+                              FT_Vector*  to )
+  {
+    TPos        dx, dy;
+    int         top, level;
+    int*        levels;
+    FT_Vector*  arc;
+
+
+    dx = DOWNSCALE( ras.x ) + to->x - ( control->x << 1 );
+    if ( dx < 0 )
+      dx = -dx;
+    dy = DOWNSCALE( ras.y ) + to->y - ( control->y << 1 );
+    if ( dy < 0 )
+      dy = -dy;
+    if ( dx < dy )
+      dx = dy;
+
+    level = 1;
+    dx = dx / ras.conic_level;
+    while ( dx > 0 )
+    {
+      dx >>= 2;
+      level++;
+    }
+
+    /* a shortcut to speed things up */
+    if ( level <= 1 )
+    {
+      /* we compute the mid-point directly in order to avoid */
+      /* calling gray_split_conic()                          */
+      TPos   to_x, to_y, mid_x, mid_y;
+
+
+      to_x  = UPSCALE( to->x );
+      to_y  = UPSCALE( to->y );
+      mid_x = ( ras.x + to_x + 2 * UPSCALE( control->x ) ) / 4;
+      mid_y = ( ras.y + to_y + 2 * UPSCALE( control->y ) ) / 4;
+
+      gray_render_line( RAS_VAR_ mid_x, mid_y );
+      gray_render_line( RAS_VAR_ to_x, to_y );
+      return;
+    }
+
+    arc       = ras.bez_stack;
+    levels    = ras.lev_stack;
+    top       = 0;
+    levels[0] = level;
+
+    arc[0].x = UPSCALE( to->x );
+    arc[0].y = UPSCALE( to->y );
+    arc[1].x = UPSCALE( control->x );
+    arc[1].y = UPSCALE( control->y );
+    arc[2].x = ras.x;
+    arc[2].y = ras.y;
+
+    while ( top >= 0 )
+    {
+      level = levels[top];
+      if ( level > 1 )
+      {
+        /* check that the arc crosses the current band */
+        TPos  min, max, y;
+
+
+        min = max = arc[0].y;
+
+        y = arc[1].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+
+        y = arc[2].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+
+        if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < ras.min_ey )
+          goto Draw;
+
+        gray_split_conic( arc );
+        arc += 2;
+        top++;
+        levels[top] = levels[top - 1] = level - 1;
+        continue;
+      }
+
+    Draw:
+      {
+        TPos  to_x, to_y, mid_x, mid_y;
+
+
+        to_x  = arc[0].x;
+        to_y  = arc[0].y;
+        mid_x = ( ras.x + to_x + 2 * arc[1].x ) / 4;
+        mid_y = ( ras.y + to_y + 2 * arc[1].y ) / 4;
+
+        gray_render_line( RAS_VAR_ mid_x, mid_y );
+        gray_render_line( RAS_VAR_ to_x, to_y );
+
+        top--;
+        arc -= 2;
+      }
+    }
+    return;
+  }
+
+
+  static void
+  gray_split_cubic( FT_Vector*  base )
+  {
+    TPos  a, b, c, d;
+
+
+    base[6].x = base[3].x;
+    c = base[1].x;
+    d = base[2].x;
+    base[1].x = a = ( base[0].x + c ) / 2;
+    base[5].x = b = ( base[3].x + d ) / 2;
+    c = ( c + d ) / 2;
+    base[2].x = a = ( a + c ) / 2;
+    base[4].x = b = ( b + c ) / 2;
+    base[3].x = ( a + b ) / 2;
+
+    base[6].y = base[3].y;
+    c = base[1].y;
+    d = base[2].y;
+    base[1].y = a = ( base[0].y + c ) / 2;
+    base[5].y = b = ( base[3].y + d ) / 2;
+    c = ( c + d ) / 2;
+    base[2].y = a = ( a + c ) / 2;
+    base[4].y = b = ( b + c ) / 2;
+    base[3].y = ( a + b ) / 2;
+  }
+
+
+  static void
+  gray_render_cubic( RAS_ARG_ FT_Vector*  control1,
+                              FT_Vector*  control2,
+                              FT_Vector*  to )
+  {
+    TPos        dx, dy, da, db;
+    int         top, level;
+    int*        levels;
+    FT_Vector*  arc;
+
+
+    dx = DOWNSCALE( ras.x ) + to->x - ( control1->x << 1 );
+    if ( dx < 0 )
+      dx = -dx;
+    dy = DOWNSCALE( ras.y ) + to->y - ( control1->y << 1 );
+    if ( dy < 0 )
+      dy = -dy;
+    if ( dx < dy )
+      dx = dy;
+    da = dx;
+
+    dx = DOWNSCALE( ras.x ) + to->x - 3 * ( control1->x + control2->x );
+    if ( dx < 0 )
+      dx = -dx;
+    dy = DOWNSCALE( ras.y ) + to->y - 3 * ( control1->x + control2->y );
+    if ( dy < 0 )
+      dy = -dy;
+    if ( dx < dy )
+      dx = dy;
+    db = dx;
+
+    level = 1;
+    da    = da / ras.cubic_level;
+    db    = db / ras.conic_level;
+    while ( da > 0 || db > 0 )
+    {
+      da >>= 2;
+      db >>= 3;
+      level++;
+    }
+
+    if ( level <= 1 )
+    {
+      TPos   to_x, to_y, mid_x, mid_y;
+
+
+      to_x  = UPSCALE( to->x );
+      to_y  = UPSCALE( to->y );
+      mid_x = ( ras.x + to_x +
+                3 * UPSCALE( control1->x + control2->x ) ) / 8;
+      mid_y = ( ras.y + to_y +
+                3 * UPSCALE( control1->y + control2->y ) ) / 8;
+
+      gray_render_line( RAS_VAR_ mid_x, mid_y );
+      gray_render_line( RAS_VAR_ to_x, to_y );
+      return;
+    }
+
+    arc      = ras.bez_stack;
+    arc[0].x = UPSCALE( to->x );
+    arc[0].y = UPSCALE( to->y );
+    arc[1].x = UPSCALE( control2->x );
+    arc[1].y = UPSCALE( control2->y );
+    arc[2].x = UPSCALE( control1->x );
+    arc[2].y = UPSCALE( control1->y );
+    arc[3].x = ras.x;
+    arc[3].y = ras.y;
+
+    levels    = ras.lev_stack;
+    top       = 0;
+    levels[0] = level;
+
+    while ( top >= 0 )
+    {
+      level = levels[top];
+      if ( level > 1 )
+      {
+        /* check that the arc crosses the current band */
+        TPos  min, max, y;
+
+
+        min = max = arc[0].y;
+        y = arc[1].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+        y = arc[2].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+        y = arc[3].y;
+        if ( y < min ) min = y;
+        if ( y > max ) max = y;
+        if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < 0 )
+          goto Draw;
+        gray_split_cubic( arc );
+        arc += 3;
+        top ++;
+        levels[top] = levels[top - 1] = level - 1;
+        continue;
+      }
+
+    Draw:
+      {
+        TPos  to_x, to_y, mid_x, mid_y;
+
+
+        to_x  = arc[0].x;
+        to_y  = arc[0].y;
+        mid_x = ( ras.x + to_x + 3 * ( arc[1].x + arc[2].x ) ) / 8;
+        mid_y = ( ras.y + to_y + 3 * ( arc[1].y + arc[2].y ) ) / 8;
+
+        gray_render_line( RAS_VAR_ mid_x, mid_y );
+        gray_render_line( RAS_VAR_ to_x, to_y );
+        top --;
+        arc -= 3;
+      }
+    }
+    return;
+  }
+
+
+  /* a macro comparing two cell pointers.  Returns true if a <= b. */
+#if 1
+
+#define PACK( a )          ( ( (long)(a)->y << 16 ) + (a)->x )
+#define LESS_THAN( a, b )  ( PACK( a ) < PACK( b ) )
+
+#else /* 1 */
+
+#define LESS_THAN( a, b )  ( (a)->y < (b)->y || \
+                             ( (a)->y == (b)->y && (a)->x < (b)->x ) )
+
+#endif /* 1 */
+
+#define SWAP_CELLS( a, b, temp )  do             \
+                                  {              \
+                                    temp = *(a); \
+                                    *(a) = *(b); \
+                                    *(b) = temp; \
+                                  } while ( 0 )
+#define DEBUG_SORT
+#define QUICK_SORT
+
+#ifdef SHELL_SORT
+
+  /* a simple shell sort algorithm that works directly on our */
+  /* cells table                                              */
+  static void
+  gray_shell_sort ( PCell  cells,
+                    int    count )
+  {
+    PCell  i, j, limit = cells + count;
+    TCell  temp;
+    int    gap;
+
+
+    /* compute initial gap */
+    for ( gap = 0; ++gap < count; gap *= 3 )
+      ;
+
+    while ( gap /= 3 )
+    {
+      for ( i = cells + gap; i < limit; i++ )
+      {
+        for ( j = i - gap; ; j -= gap )
+        {
+          PCell  k = j + gap;
+
+
+          if ( LESS_THAN( j, k ) )
+            break;
+
+          SWAP_CELLS( j, k, temp );
+
+          if ( j < cells + gap )
+            break;
+        }
+      }
+    }
+  }
+
+#endif /* SHELL_SORT */
+
+
+#ifdef QUICK_SORT
+
+  /* This is a non-recursive quicksort that directly process our cells     */
+  /* array.  It should be faster than calling the stdlib qsort(), and we   */
+  /* can even tailor our insertion threshold...                            */
+
+#define QSORT_THRESHOLD  9  /* below this size, a sub-array will be sorted */
+                            /* through a normal insertion sort             */
+
+  static void
+  gray_quick_sort( PCell  cells,
+                   int    count )
+  {
+    PCell   stack[40];  /* should be enough ;-) */
+    PCell*  top;        /* top of stack */
+    PCell   base, limit;
+    TCell   temp;
+
+
+    limit = cells + count;
+    base  = cells;
+    top   = stack;
+
+    for (;;)
+    {
+      int    len = (int)( limit - base );
+      PCell  i, j, pivot;
+
+
+      if ( len > QSORT_THRESHOLD )
+      {
+        /* we use base + len/2 as the pivot */
+        pivot = base + len / 2;
+        SWAP_CELLS( base, pivot, temp );
+
+        i = base + 1;
+        j = limit - 1;
+
+        /* now ensure that *i <= *base <= *j */
+        if ( LESS_THAN( j, i ) )
+          SWAP_CELLS( i, j, temp );
+
+        if ( LESS_THAN( base, i ) )
+          SWAP_CELLS( base, i, temp );
+
+        if ( LESS_THAN( j, base ) )
+          SWAP_CELLS( base, j, temp );
+
+        for (;;)
+        {
+          do i++; while ( LESS_THAN( i, base ) );
+          do j--; while ( LESS_THAN( base, j ) );
+
+          if ( i > j )
+            break;
+
+          SWAP_CELLS( i, j, temp );
+        }
+
+        SWAP_CELLS( base, j, temp );
+
+        /* now, push the largest sub-array */
+        if ( j - base > limit - i )
+        {
+          top[0] = base;
+          top[1] = j;
+          base   = i;
+        }
+        else
+        {
+          top[0] = i;
+          top[1] = limit;
+          limit  = j;
+        }
+        top += 2;
+      }
+      else
+      {
+        /* the sub-array is small, perform insertion sort */
+        j = base;
+        i = j + 1;
+
+        for ( ; i < limit; j = i, i++ )
+        {
+          for ( ; LESS_THAN( j + 1, j ); j-- )
+          {
+            SWAP_CELLS( j + 1, j, temp );
+            if ( j == base )
+              break;
+          }
+        }
+        if ( top > stack )
+        {
+          top  -= 2;
+          base  = top[0];
+          limit = top[1];
+        }
+        else
+          break;
+      }
+    }
+  }
+
+#endif /* QUICK_SORT */
+
+
+#ifdef DEBUG_GRAYS
+#ifdef DEBUG_SORT
+
+  static int
+  gray_check_sort( PCell  cells,
+                   int    count )
+  {
+    PCell  p, q;
+
+
+    for ( p = cells + count - 2; p >= cells; p-- )
+    {
+      q = p + 1;
+      if ( !LESS_THAN( p, q ) )
+        return 0;
+    }
+    return 1;
+  }
+
+#endif /* DEBUG_SORT */
+#endif /* DEBUG_GRAYS */
+
+
+  static int
+  gray_move_to( FT_Vector*  to,
+                FT_Raster   raster )
+  {
+    TPos  x, y;
+
+
+    /* record current cell, if any */
+    gray_record_cell( (PRaster)raster );
+
+    /* start to a new position */
+    x = UPSCALE( to->x );
+    y = UPSCALE( to->y );
+
+    gray_start_cell( (PRaster)raster, TRUNC( x ), TRUNC( y ) );
+
+    ((PRaster)raster)->x = x;
+    ((PRaster)raster)->y = y;
+    return 0;
+  }
+
+
+  static int
+  gray_line_to( FT_Vector*  to,
+                FT_Raster   raster )
+  {
+    gray_render_line( (PRaster)raster,
+                      UPSCALE( to->x ), UPSCALE( to->y ) );
+    return 0;
+  }
+
+
+  static int
+  gray_conic_to( FT_Vector*  control,
+                 FT_Vector*  to,
+                 FT_Raster   raster )
+  {
+    gray_render_conic( (PRaster)raster, control, to );
+    return 0;
+  }
+
+
+  static int
+  gray_cubic_to( FT_Vector*  control1,
+                 FT_Vector*  control2,
+                 FT_Vector*  to,
+                 FT_Raster   raster )
+  {
+    gray_render_cubic( (PRaster)raster, control1, control2, to );
+    return 0;
+  }
+
+
+  static void
+  gray_render_span( int       y,
+                    int       count,
+                    FT_Span*  spans,
+                    PRaster   raster )
+  {
+    unsigned char*  p;
+    FT_Bitmap*      map = &raster->target;
+
+
+    /* first of all, compute the scanline offset */
+    p = (unsigned char*)map->buffer - y * map->pitch;
+    if ( map->pitch >= 0 )
+      p += ( map->rows - 1 ) * map->pitch;
+
+    for ( ; count > 0; count--, spans++ )
+    {
+      unsigned char  coverage = spans->coverage;
+
+
+#ifdef GRAYS_USE_GAMMA
+      coverage = raster->gamma[coverage];
+#endif
+
+      if ( coverage )
+#if 1
+        FT_MEM_SET( p + spans->x, (unsigned char)coverage, spans->len );
+#else /* 1 */
+      {
+        q     = p + spans->x;
+        limit = q + spans->len;
+        for ( ; q < limit; q++ )
+          q[0] = (unsigned char)coverage;
+      }
+#endif /* 1 */
+    }
+  }
+
+
+#ifdef DEBUG_GRAYS
+
+#include <stdio.h>
+
+  static void
+  gray_dump_cells( RAS_ARG )
+  {
+    PCell  cell, limit;
+    int    y = -1;
+
+
+    cell  = ras.cells;
+    limit = cell + ras.num_cells;
+
+    for ( ; cell < limit; cell++ )
+    {
+      if ( cell->y != y )
+      {
+        fprintf( stderr, "\n%2d: ", cell->y );
+        y = cell->y;
+      }
+      fprintf( stderr, "[%d %d %d]",
+               cell->x, cell->area, cell->cover );
+    }
+    fprintf(stderr, "\n" );
+  }
+
+#endif /* DEBUG_GRAYS */
+
+
+  static void
+  gray_hline( RAS_ARG_ TCoord  x,
+                       TCoord  y,
+                       TPos    area,
+                       int     acount )
+  {
+    FT_Span*   span;
+    int        count;
+    int        coverage;
+
+
+    /* compute the coverage line's coverage, depending on the    */
+    /* outline fill rule                                         */
+    /*                                                           */
+    /* the coverage percentage is area/(PIXEL_BITS*PIXEL_BITS*2) */
+    /*                                                           */
+    coverage = (int)( area >> ( PIXEL_BITS * 2 + 1 - 8 ) );
+                                                    /* use range 0..256 */
+    if ( coverage < 0 )
+      coverage = -coverage;
+
+    if ( ras.outline.flags & FT_OUTLINE_EVEN_ODD_FILL )
+    {
+      coverage &= 511;
+
+      if ( coverage > 256 )
+        coverage = 512 - coverage;
+      else if ( coverage == 256 )
+        coverage = 255;
+    }
+    else
+    {
+      /* normal non-zero winding rule */
+      if ( coverage >= 256 )
+        coverage = 255;
+    }
+
+    y += (TCoord)ras.min_ey;
+    x += (TCoord)ras.min_ex;
+
+    if ( coverage )
+    {
+      /* see if we can add this span to the current list */
+      count = ras.num_gray_spans;
+      span  = ras.gray_spans + count - 1;
+      if ( count > 0                          &&
+           ras.span_y == y                    &&
+           (int)span->x + span->len == (int)x &&
+           span->coverage == coverage )
+      {
+        span->len = (unsigned short)( span->len + acount );
+        return;
+      }
+
+      if ( ras.span_y != y || count >= FT_MAX_GRAY_SPANS )
+      {
+        if ( ras.render_span && count > 0 )
+          ras.render_span( ras.span_y, count, ras.gray_spans,
+                           ras.render_span_data );
+        /* ras.render_span( span->y, ras.gray_spans, count ); */
+
+#ifdef DEBUG_GRAYS
+
+        if ( ras.span_y >= 0 )
+        {
+          int  n;
+
+
+          fprintf( stderr, "y=%3d ", ras.span_y );
+          span = ras.gray_spans;
+          for ( n = 0; n < count; n++, span++ )
+            fprintf( stderr, "[%d..%d]:%02x ",
+                     span->x, span->x + span->len - 1, span->coverage );
+          fprintf( stderr, "\n" );
+        }
+
+#endif /* DEBUG_GRAYS */
+
+        ras.num_gray_spans = 0;
+        ras.span_y         = y;
+
+        count = 0;
+        span  = ras.gray_spans;
+      }
+      else
+        span++;
+
+      /* add a gray span to the current list */
+      span->x        = (short)x;
+      span->len      = (unsigned short)acount;
+      span->coverage = (unsigned char)coverage;
+      ras.num_gray_spans++;
+    }
+  }
+
+
+  static void
+  gray_sweep( RAS_ARG_ FT_Bitmap*  target )
+  {
+    TCoord  x, y, cover;
+    TArea   area;
+    PCell   start, cur, limit;
+
+    FT_UNUSED( target );
+
+
+    if ( ras.num_cells == 0 )
+      return;
+
+    cur   = ras.cells;
+    limit = cur + ras.num_cells;
+
+    cover              = 0;
+    ras.span_y         = -1;
+    ras.num_gray_spans = 0;
+
+    for (;;)
+    {
+      start  = cur;
+      y      = start->y;
+      x      = start->x;
+
+      area   = start->area;
+      cover += start->cover;
+
+      /* accumulate all start cells */
+      for (;;)
+      {
+        ++cur;
+        if ( cur >= limit || cur->y != start->y || cur->x != start->x )
+          break;
+
+        area  += cur->area;
+        cover += cur->cover;
+      }
+
+      /* if the start cell has a non-null area, we must draw an */
+      /* individual gray pixel there                            */
+      if ( area && x >= 0 )
+      {
+        gray_hline( RAS_VAR_ x, y, cover * ( ONE_PIXEL * 2 ) - area, 1 );
+        x++;
+      }
+
+      if ( x < 0 )
+        x = 0;
+
+      if ( cur < limit && start->y == cur->y )
+      {
+        /* draw a gray span between the start cell and the current one */
+        if ( cur->x > x )
+          gray_hline( RAS_VAR_ x, y,
+                      cover * ( ONE_PIXEL * 2 ), cur->x - x );
+      }
+      else
+      {
+        /* draw a gray span until the end of the clipping region */
+        if ( cover && x < ras.max_ex - ras.min_ex )
+          gray_hline( RAS_VAR_ x, y,
+                      cover * ( ONE_PIXEL * 2 ),
+                      (int)( ras.max_ex - x - ras.min_ex ) );
+        cover = 0;
+      }
+
+      if ( cur >= limit )
+        break;
+    }
+
+    if ( ras.render_span && ras.num_gray_spans > 0 )
+      ras.render_span( ras.span_y, ras.num_gray_spans,
+                       ras.gray_spans, ras.render_span_data );
+
+#ifdef DEBUG_GRAYS
+
+    {
+      int       n;
+      FT_Span*  span;
+
+
+      fprintf( stderr, "y=%3d ", ras.span_y );
+      span = ras.gray_spans;
+      for ( n = 0; n < ras.num_gray_spans; n++, span++ )
+        fprintf( stderr, "[%d..%d]:%02x ",
+                 span->x, span->x + span->len - 1, span->coverage );
+      fprintf( stderr, "\n" );
+    }
+
+#endif /* DEBUG_GRAYS */
+
+  }
+
+
+#ifdef _STANDALONE_
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  The following function should only compile in stand_alone mode,      */
+  /*  i.e., when building this component without the rest of FreeType.     */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Decompose                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Walks over an outline's structure to decompose it into individual  */
+  /*    segments and Bezier arcs.  This function is also able to emit      */
+  /*    `move to' and `close to' operations to indicate the start and end  */
+  /*    of new contours in the outline.                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline        :: A pointer to the source target.                  */
+  /*                                                                       */
+  /*    func_interface :: A table of `emitters', i.e,. function pointers   */
+  /*                      called during decomposition to indicate path     */
+  /*                      operations.                                      */
+  /*                                                                       */
+  /*    user           :: A typeless pointer which is passed to each       */
+  /*                      emitter during the decomposition.  It can be     */
+  /*                      used to store the state during the               */
+  /*                      decomposition.                                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means sucess.                                       */
+  /*                                                                       */
+  static
+  int  FT_Outline_Decompose( FT_Outline*              outline,
+                             const FT_Outline_Funcs*  func_interface,
+                             void*                    user )
+  {
+#undef SCALED
+#if 0
+#define SCALED( x )  ( ( (x) << shift ) - delta )
+#else
+#define SCALED( x )  (x)
+#endif
+
+    FT_Vector   v_last;
+    FT_Vector   v_control;
+    FT_Vector   v_start;
+
+    FT_Vector*  point;
+    FT_Vector*  limit;
+    char*       tags;
+
+    int   n;         /* index of contour in outline     */
+    int   first;     /* index of first point in contour */
+    int   error;
+    char  tag;       /* current point's state           */
+
+#if 0
+    int   shift = func_interface->shift;
+    TPos  delta = func_interface->delta;
+#endif
+
+
+    first = 0;
+
+    for ( n = 0; n < outline->n_contours; n++ )
+    {
+      int  last;  /* index of last point in contour */
+
+
+      last  = outline->contours[n];
+      limit = outline->points + last;
+
+      v_start = outline->points[first];
+      v_last  = outline->points[last];
+
+      v_start.x = SCALED( v_start.x ); v_start.y = SCALED( v_start.y );
+      v_last.x  = SCALED( v_last.x );  v_last.y  = SCALED( v_last.y );
+
+      v_control = v_start;
+
+      point = outline->points + first;
+      tags  = outline->tags  + first;
+      tag   = FT_CURVE_TAG( tags[0] );
+
+      /* A contour cannot start with a cubic control point! */
+      if ( tag == FT_CURVE_TAG_CUBIC )
+        goto Invalid_Outline;
+
+      /* check first point to determine origin */
+      if ( tag == FT_CURVE_TAG_CONIC )
+      {
+        /* first point is conic control.  Yes, this happens. */
+        if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON )
+        {
+          /* start at last point if it is on the curve */
+          v_start = v_last;
+          limit--;
+        }
+        else
+        {
+          /* if both first and last points are conic,         */
+          /* start at their middle and record its position    */
+          /* for closure                                      */
+          v_start.x = ( v_start.x + v_last.x ) / 2;
+          v_start.y = ( v_start.y + v_last.y ) / 2;
+
+          v_last = v_start;
+        }
+        point--;
+        tags--;
+      }
+
+      error = func_interface->move_to( &v_start, user );
+      if ( error )
+        goto Exit;
+
+      while ( point < limit )
+      {
+        point++;
+        tags++;
+
+        tag = FT_CURVE_TAG( tags[0] );
+        switch ( tag )
+        {
+        case FT_CURVE_TAG_ON:  /* emit a single line_to */
+          {
+            FT_Vector  vec;
+
+
+            vec.x = SCALED( point->x );
+            vec.y = SCALED( point->y );
+
+            error = func_interface->line_to( &vec, user );
+            if ( error )
+              goto Exit;
+            continue;
+          }
+
+        case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
+          {
+            v_control.x = SCALED( point->x );
+            v_control.y = SCALED( point->y );
+
+          Do_Conic:
+            if ( point < limit )
+            {
+              FT_Vector  vec;
+              FT_Vector  v_middle;
+
+
+              point++;
+              tags++;
+              tag = FT_CURVE_TAG( tags[0] );
+
+              vec.x = SCALED( point->x );
+              vec.y = SCALED( point->y );
+
+              if ( tag == FT_CURVE_TAG_ON )
+              {
+                error = func_interface->conic_to( &v_control, &vec, user );
+                if ( error )
+                  goto Exit;
+                continue;
+              }
+
+              if ( tag != FT_CURVE_TAG_CONIC )
+                goto Invalid_Outline;
+
+              v_middle.x = ( v_control.x + vec.x ) / 2;
+              v_middle.y = ( v_control.y + vec.y ) / 2;
+
+              error = func_interface->conic_to( &v_control, &v_middle, user );
+              if ( error )
+                goto Exit;
+
+              v_control = vec;
+              goto Do_Conic;
+            }
+
+            error = func_interface->conic_to( &v_control, &v_start, user );
+            goto Close;
+          }
+
+        default:  /* FT_CURVE_TAG_CUBIC */
+          {
+            FT_Vector  vec1, vec2;
+
+
+            if ( point + 1 > limit                             ||
+                 FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
+              goto Invalid_Outline;
+
+            point += 2;
+            tags  += 2;
+
+            vec1.x = SCALED( point[-2].x ); vec1.y = SCALED( point[-2].y );
+            vec2.x = SCALED( point[-1].x ); vec2.y = SCALED( point[-1].y );
+
+            if ( point <= limit )
+            {
+              FT_Vector  vec;
+
+
+              vec.x = SCALED( point->x );
+              vec.y = SCALED( point->y );
+
+              error = func_interface->cubic_to( &vec1, &vec2, &vec, user );
+              if ( error )
+                goto Exit;
+              continue;
+            }
+
+            error = func_interface->cubic_to( &vec1, &vec2, &v_start, user );
+            goto Close;
+          }
+        }
+      }
+
+      /* close the contour with a line segment */
+      error = func_interface->line_to( &v_start, user );
+
+   Close:
+      if ( error )
+        goto Exit;
+
+      first = last + 1;
+    }
+
+    return 0;
+
+  Exit:
+    return error;
+
+  Invalid_Outline:
+    return ErrRaster_Invalid_Outline;
+  }
+
+#endif /* _STANDALONE_ */
+
+
+  typedef struct  TBand_
+  {
+    TPos  min, max;
+
+  } TBand;
+
+
+  static int
+  gray_convert_glyph_inner( RAS_ARG )
+  {
+    static
+    const FT_Outline_Funcs  func_interface =
+    {
+      (FT_Outline_MoveTo_Func) gray_move_to,
+      (FT_Outline_LineTo_Func) gray_line_to,
+      (FT_Outline_ConicTo_Func)gray_conic_to,
+      (FT_Outline_CubicTo_Func)gray_cubic_to,
+      0,
+      0
+    };
+
+    volatile int  error = 0;
+
+    if ( ft_setjmp( ras.jump_buffer ) == 0 )
+    {
+      error = FT_Outline_Decompose( &ras.outline, &func_interface, &ras );
+      gray_record_cell( RAS_VAR );
+    }
+    else
+    {
+      error = ErrRaster_MemoryOverflow;
+    }
+
+    return error;
+  }
+
+
+  static int
+  gray_convert_glyph( RAS_ARG )
+  {
+    TBand            bands[40];
+    TBand* volatile  band;
+    int volatile     n, num_bands;
+    TPos volatile    min, max, max_y;
+    FT_BBox*         clip;
+
+
+    /* Set up state in the raster object */
+    gray_compute_cbox( RAS_VAR );
+
+    /* clip to target bitmap, exit if nothing to do */
+    clip = &ras.clip_box;
+
+    if ( ras.max_ex <= clip->xMin || ras.min_ex >= clip->xMax ||
+         ras.max_ey <= clip->yMin || ras.min_ey >= clip->yMax )
+      return 0;
+
+    if ( ras.min_ex < clip->xMin ) ras.min_ex = clip->xMin;
+    if ( ras.min_ey < clip->yMin ) ras.min_ey = clip->yMin;
+
+    if ( ras.max_ex > clip->xMax ) ras.max_ex = clip->xMax;
+    if ( ras.max_ey > clip->yMax ) ras.max_ey = clip->yMax;
+
+    /* simple heuristic used to speed-up the bezier decomposition -- see */
+    /* the code in gray_render_conic() and gray_render_cubic() for more  */
+    /* details                                                           */
+    ras.conic_level = 32;
+    ras.cubic_level = 16;
+
+    {
+      int level = 0;
+
+
+      if ( ras.max_ex > 24 || ras.max_ey > 24 )
+        level++;
+      if ( ras.max_ex > 120 || ras.max_ey > 120 )
+        level++;
+
+      ras.conic_level <<= level;
+      ras.cubic_level <<= level;
+    }
+
+    /* setup vertical bands */
+    num_bands = (int)( ( ras.max_ey - ras.min_ey ) / ras.band_size );
+    if ( num_bands == 0 )  num_bands = 1;
+    if ( num_bands >= 39 ) num_bands = 39;
+
+    ras.band_shoot = 0;
+
+    min   = ras.min_ey;
+    max_y = ras.max_ey;
+
+    for ( n = 0; n < num_bands; n++, min = max )
+    {
+      max = min + ras.band_size;
+      if ( n == num_bands - 1 || max > max_y )
+        max = max_y;
+
+      bands[0].min = min;
+      bands[0].max = max;
+      band         = bands;
+
+      while ( band >= bands )
+      {
+        TPos  bottom, top, middle;
+        int   error;
+
+
+        ras.num_cells = 0;
+        ras.invalid   = 1;
+        ras.min_ey    = band->min;
+        ras.max_ey    = band->max;
+
+#if 1
+        error = gray_convert_glyph_inner( RAS_VAR );
+#else
+        error = FT_Outline_Decompose( outline, &func_interface, &ras ) ||
+                gray_record_cell( RAS_VAR );
+#endif
+
+        if ( !error )
+        {
+#ifdef SHELL_SORT
+          gray_shell_sort( ras.cells, ras.num_cells );
+#else
+          gray_quick_sort( ras.cells, ras.num_cells );
+#endif
+
+#ifdef DEBUG_GRAYS
+          gray_check_sort( ras.cells, ras.num_cells );
+          gray_dump_cells( RAS_VAR );
+#endif
+
+          gray_sweep( RAS_VAR_  &ras.target );
+          band--;
+          continue;
+        }
+        else if ( error != ErrRaster_MemoryOverflow )
+          return 1;
+
+        /* render pool overflow, we will reduce the render band by half */
+        bottom = band->min;
+        top    = band->max;
+        middle = bottom + ( ( top - bottom ) >> 1 );
+
+        /* waoow! This is too complex for a single scanline, something */
+        /* must be really rotten here!                                 */
+        if ( middle == bottom )
+        {
+#ifdef DEBUG_GRAYS
+          fprintf( stderr, "Rotten glyph!\n" );
+#endif
+          return 1;
+        }
+
+        if ( bottom-top >= ras.band_size )
+          ras.band_shoot++;
+
+        band[1].min = bottom;
+        band[1].max = middle;
+        band[0].min = middle;
+        band[0].max = top;
+        band++;
+      }
+    }
+
+    if ( ras.band_shoot > 8 && ras.band_size > 16 )
+      ras.band_size = ras.band_size / 2;
+
+    return 0;
+  }
+
+
+  extern int
+  gray_raster_render( PRaster            raster,
+                      FT_Raster_Params*  params )
+  {
+    FT_Outline*  outline = (FT_Outline*)params->source;
+    FT_Bitmap*   target_map = params->target;
+
+
+    if ( !raster || !raster->cells || !raster->max_cells )
+      return -1;
+
+    /* return immediately if the outline is empty */
+    if ( outline->n_points == 0 || outline->n_contours <= 0 )
+      return 0;
+
+    if ( !outline || !outline->contours || !outline->points )
+      return ErrRaster_Invalid_Outline;
+
+    if ( outline->n_points !=
+           outline->contours[outline->n_contours - 1] + 1 )
+      return ErrRaster_Invalid_Outline;
+
+    /* if direct mode is not set, we must have a target bitmap */
+    if ( ( params->flags & FT_RASTER_FLAG_DIRECT ) == 0 &&
+         ( !target_map || !target_map->buffer )         )
+      return -1;
+
+    /* this version does not support monochrome rendering */
+    if ( !( params->flags & FT_RASTER_FLAG_AA ) )
+      return ErrRaster_Invalid_Mode;
+
+    /* compute clipping box */
+    if ( ( params->flags & FT_RASTER_FLAG_DIRECT ) == 0 )
+    {
+      /* compute clip box from target pixmap */
+      ras.clip_box.xMin = 0;
+      ras.clip_box.yMin = 0;
+      ras.clip_box.xMax = target_map->width;
+      ras.clip_box.yMax = target_map->rows;
+    }
+    else if ( params->flags & FT_RASTER_FLAG_CLIP )
+    {
+      ras.clip_box = params->clip_box;
+    }
+    else
+    {
+      ras.clip_box.xMin = -32768L;
+      ras.clip_box.yMin = -32768L;
+      ras.clip_box.xMax =  32767L;
+      ras.clip_box.yMax =  32767L;
+    }
+
+    ras.outline   = *outline;
+    ras.num_cells = 0;
+    ras.invalid   = 1;
+
+    if ( target_map )
+      ras.target = *target_map;
+
+    ras.render_span      = (FT_Raster_Span_Func)gray_render_span;
+    ras.render_span_data = &ras;
+
+    if ( params->flags & FT_RASTER_FLAG_DIRECT )
+    {
+      ras.render_span      = (FT_Raster_Span_Func)params->gray_spans;
+      ras.render_span_data = params->user;
+    }
+
+    return gray_convert_glyph( (PRaster)raster );
+  }
+
+
+  /**** RASTER OBJECT CREATION: In standalone mode, we simply use *****/
+  /****                         a static object.                  *****/
+
+#ifdef GRAYS_USE_GAMMA
+
+  /* initialize the "gamma" table. Yes, this is really a crummy function */
+  /* but the results look pretty good for something that simple.         */
+  /*                                                                     */
+#define M_MAX  255
+#define M_X    128
+#define M_Y    192
+
+  static void
+  grays_init_gamma( PRaster  raster )
+  {
+    unsigned int  x, a;
+
+
+    for ( x = 0; x < 256; x++ )
+    {
+      if ( x <= M_X )
+        a = ( x * M_Y + M_X / 2) / M_X;
+      else
+        a = M_Y + ( ( x - M_X ) * ( M_MAX - M_Y ) +
+            ( M_MAX - M_X ) / 2 ) / ( M_MAX - M_X );
+
+      raster->gamma[x] = (unsigned char)a;
+    }
+  }
+
+#endif /* GRAYS_USE_GAMMA */
+
+#ifdef _STANDALONE_
+
+  static int
+  gray_raster_new( void*       memory,
+                   FT_Raster*  araster )
+  {
+    static TRaster  the_raster;
+
+    FT_UNUSED( memory );
+
+
+    *araster = (FT_Raster)&the_raster;
+    FT_MEM_ZERO( &the_raster, sizeof ( the_raster ) );
+
+#ifdef GRAYS_USE_GAMMA
+    grays_init_gamma( (PRaster)*araster );
+#endif
+
+    return 0;
+  }
+
+
+  static void
+  gray_raster_done( FT_Raster  raster )
+  {
+    /* nothing */
+    FT_UNUSED( raster );
+  }
+
+#else /* _STANDALONE_ */
+
+  static int
+  gray_raster_new( FT_Memory   memory,
+                   FT_Raster*  araster )
+  {
+    FT_Error  error;
+    PRaster   raster;
+
+
+    *araster = 0;
+    if ( !FT_ALLOC( raster, sizeof ( TRaster ) ) )
+    {
+      raster->memory = memory;
+      *araster = (FT_Raster)raster;
+
+#ifdef GRAYS_USE_GAMMA
+      grays_init_gamma( raster );
+#endif
+    }
+
+    return error;
+  }
+
+
+  static void
+  gray_raster_done( FT_Raster  raster )
+  {
+    FT_Memory  memory = (FT_Memory)((PRaster)raster)->memory;
+
+
+    FT_FREE( raster );
+  }
+
+#endif /* _STANDALONE_ */
+
+
+  static void
+  gray_raster_reset( FT_Raster    raster,
+                     const char*  pool_base,
+                     long         pool_size )
+  {
+    PRaster  rast = (PRaster)raster;
+
+
+    if ( raster && pool_base && pool_size >= 4096 )
+      gray_init_cells( rast, (char*)pool_base, pool_size );
+
+    rast->band_size  = (int)( ( pool_size / sizeof ( TCell ) ) / 8 );
+  }
+
+
+  const FT_Raster_Funcs  ft_grays_raster =
+  {
+    FT_GLYPH_FORMAT_OUTLINE,
+
+    (FT_Raster_New_Func)     gray_raster_new,
+    (FT_Raster_Reset_Func)   gray_raster_reset,
+    (FT_Raster_Set_Mode_Func)0,
+    (FT_Raster_Render_Func)  gray_raster_render,
+    (FT_Raster_Done_Func)    gray_raster_done
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/smooth/ftgrays.h b/nx-X11/extras/freetype2/src/smooth/ftgrays.h
new file mode 100644
index 000000000..2d409543d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/ftgrays.h
@@ -0,0 +1,57 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgrays.h                                                              */
+/*                                                                         */
+/*    FreeType smooth renderer declaration                                 */
+/*                                                                         */
+/*  Copyright 1996-2001 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 __FTGRAYS_H__
+#define __FTGRAYS_H__
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+
+#ifdef _STANDALONE_
+#include "ftimage.h"
+#else
+#include <ft2build.h>
+#include FT_IMAGE_H
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* To make ftgrays.h independent from configuration files we check       */
+  /* whether FT_EXPORT_VAR has been defined already.                       */
+  /*                                                                       */
+  /* On some systems and compilers (Win32 mostly), an extra keyword is     */
+  /* necessary to compile the library as a DLL.                            */
+  /*                                                                       */
+#ifndef FT_EXPORT_VAR
+#define FT_EXPORT_VAR( x )  extern  x
+#endif
+
+  FT_EXPORT_VAR( const FT_Raster_Funcs )  ft_grays_raster;
+
+
+#ifdef __cplusplus
+  }
+#endif
+
+#endif /* __FTGRAYS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/smooth/ftsmerrs.h b/nx-X11/extras/freetype2/src/smooth/ftsmerrs.h
new file mode 100644
index 000000000..0c2a2ecd9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/ftsmerrs.h
@@ -0,0 +1,41 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsmerrs.h                                                             */
+/*                                                                         */
+/*    smooth renderer error codes (specification only).                    */
+/*                                                                         */
+/*  Copyright 2001 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 smooth renderer error enumeration     */
+  /* constants.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __FTSMERRS_H__
+#define __FTSMERRS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  Smooth_Err_
+#define FT_ERR_BASE    FT_Mod_Err_Smooth
+
+#include FT_ERRORS_H
+
+#endif /* __FTSMERRS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/smooth/ftsmooth.c b/nx-X11/extras/freetype2/src/smooth/ftsmooth.c
new file mode 100644
index 000000000..af8783e29
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/ftsmooth.c
@@ -0,0 +1,374 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsmooth.c                                                             */
+/*                                                                         */
+/*    Anti-aliasing renderer interface (body).                             */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002, 2003, 2004 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_OBJECTS_H
+#include FT_OUTLINE_H
+#include "ftsmooth.h"
+#include "ftgrays.h"
+
+#include "ftsmerrs.h"
+
+
+  /* initialize renderer -- init its raster */
+  static FT_Error
+  ft_smooth_init( FT_Renderer  render )
+  {
+    FT_Library  library = FT_MODULE_LIBRARY( render );
+
+
+    render->clazz->raster_class->raster_reset( render->raster,
+                                               library->raster_pool,
+                                               library->raster_pool_size );
+
+    return 0;
+  }
+
+
+  /* sets render-specific mode */
+  static FT_Error
+  ft_smooth_set_mode( FT_Renderer  render,
+                      FT_ULong     mode_tag,
+                      FT_Pointer   data )
+  {
+    /* we simply pass it to the raster */
+    return render->clazz->raster_class->raster_set_mode( render->raster,
+                                                         mode_tag,
+                                                         data );
+  }
+
+  /* transform a given glyph image */
+  static FT_Error
+  ft_smooth_transform( FT_Renderer   render,
+                       FT_GlyphSlot  slot,
+                       FT_Matrix*    matrix,
+                       FT_Vector*    delta )
+  {
+    FT_Error  error = Smooth_Err_Ok;
+
+
+    if ( slot->format != render->glyph_format )
+    {
+      error = Smooth_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    if ( matrix )
+      FT_Outline_Transform( &slot->outline, matrix );
+
+    if ( delta )
+      FT_Outline_Translate( &slot->outline, delta->x, delta->y );
+
+  Exit:
+    return error;
+  }
+
+
+  /* return the glyph's control box */
+  static void
+  ft_smooth_get_cbox( FT_Renderer   render,
+                      FT_GlyphSlot  slot,
+                      FT_BBox*      cbox )
+  {
+    FT_MEM_ZERO( cbox, sizeof ( *cbox ) );
+
+    if ( slot->format == render->glyph_format )
+      FT_Outline_Get_CBox( &slot->outline, cbox );
+  }
+
+
+  /* convert a slot's glyph image into a bitmap */
+  static FT_Error
+  ft_smooth_render_generic( FT_Renderer     render,
+                            FT_GlyphSlot    slot,
+                            FT_Render_Mode  mode,
+                            FT_Vector*      origin,
+                            FT_Render_Mode  required_mode,
+                            FT_Int          hmul,
+                            FT_Int          vmul )
+  {
+    FT_Error     error;
+    FT_Outline*  outline = NULL;
+    FT_BBox      cbox;
+    FT_UInt      width, height, pitch;
+    FT_Bitmap*   bitmap;
+    FT_Memory    memory;
+
+    FT_Raster_Params  params;
+
+
+    /* check glyph image format */
+    if ( slot->format != render->glyph_format )
+    {
+      error = Smooth_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* check mode */
+    if ( mode != required_mode )
+      return Smooth_Err_Cannot_Render_Glyph;
+
+    outline = &slot->outline;
+
+    /* translate the outline to the new origin if needed */
+    if ( origin )
+      FT_Outline_Translate( outline, origin->x, origin->y );
+
+    /* compute the control box, and grid fit it */
+    FT_Outline_Get_CBox( outline, &cbox );
+
+    cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
+    cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
+    cbox.xMax = FT_PIX_CEIL( cbox.xMax );
+    cbox.yMax = FT_PIX_CEIL( cbox.yMax );
+
+    width  = (FT_UInt)( ( cbox.xMax - cbox.xMin ) >> 6 );
+    height = (FT_UInt)( ( cbox.yMax - cbox.yMin ) >> 6 );
+    bitmap = &slot->bitmap;
+    memory = render->root.memory;
+
+    /* release old bitmap buffer */
+    if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
+    {
+      FT_FREE( bitmap->buffer );
+      slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
+    }
+
+    /* allocate new one, depends on pixel format */
+    pitch = width;
+    if ( hmul )
+    {
+      width = width * hmul;
+      pitch = FT_PAD_CEIL( width, 4 );
+    }
+
+    if ( vmul )
+      height *= vmul;
+
+    bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
+    bitmap->num_grays  = 256;
+    bitmap->width      = width;
+    bitmap->rows       = height;
+    bitmap->pitch      = pitch;
+
+    if ( FT_ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
+      goto Exit;
+
+    slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
+
+    /* translate outline to render it into the bitmap */
+    FT_Outline_Translate( outline, -cbox.xMin, -cbox.yMin );
+
+    /* set up parameters */
+    params.target = bitmap;
+    params.source = outline;
+    params.flags  = FT_RASTER_FLAG_AA;
+
+    /* implode outline if needed */
+    {
+      FT_Int      n;
+      FT_Vector*  vec;
+
+
+      if ( hmul )
+        for ( vec = outline->points, n = 0; n < outline->n_points; n++, vec++ )
+          vec->x *= hmul;
+
+      if ( vmul )
+        for ( vec = outline->points, n = 0; n < outline->n_points; n++, vec++ )
+          vec->y *= vmul;
+    }
+
+    /* render outline into the bitmap */
+    error = render->raster_render( render->raster, &params );
+
+    /* deflate outline if needed */
+    {
+      FT_Int      n;
+      FT_Vector*  vec;
+
+
+      if ( hmul )
+        for ( vec = outline->points, n = 0; n < outline->n_points; n++, vec++ )
+          vec->x /= hmul;
+
+      if ( vmul )
+        for ( vec = outline->points, n = 0; n < outline->n_points; n++, vec++ )
+          vec->y /= vmul;
+    }
+
+    FT_Outline_Translate( outline, cbox.xMin, cbox.yMin );
+
+    if ( error )
+      goto Exit;
+
+    slot->format      = FT_GLYPH_FORMAT_BITMAP;
+    slot->bitmap_left = (FT_Int)( cbox.xMin >> 6 );
+    slot->bitmap_top  = (FT_Int)( cbox.yMax >> 6 );
+
+  Exit:
+    if ( outline && origin )
+      FT_Outline_Translate( outline, -origin->x, -origin->y );
+
+    return error;
+  }
+
+
+  /* convert a slot's glyph image into a bitmap */
+  static FT_Error
+  ft_smooth_render( FT_Renderer     render,
+                    FT_GlyphSlot    slot,
+                    FT_Render_Mode  mode,
+                    FT_Vector*      origin )
+  {
+    if ( mode == FT_RENDER_MODE_LIGHT )
+      mode = FT_RENDER_MODE_NORMAL;
+
+    return ft_smooth_render_generic( render, slot, mode, origin,
+                                     FT_RENDER_MODE_NORMAL,
+                                     0, 0 );
+  }
+
+
+  /* convert a slot's glyph image into a horizontal LCD bitmap */
+  static FT_Error
+  ft_smooth_render_lcd( FT_Renderer     render,
+                        FT_GlyphSlot    slot,
+                        FT_Render_Mode  mode,
+                        FT_Vector*      origin )
+  {
+    FT_Error  error;
+
+    error = ft_smooth_render_generic( render, slot, mode, origin,
+                                      FT_RENDER_MODE_LCD,
+                                      3, 0 );
+    if ( !error )
+      slot->bitmap.pixel_mode = FT_PIXEL_MODE_LCD;
+
+    return error;
+  }
+
+
+  /* convert a slot's glyph image into a vertical LCD bitmap */
+  static FT_Error
+  ft_smooth_render_lcd_v( FT_Renderer     render,
+                          FT_GlyphSlot    slot,
+                          FT_Render_Mode  mode,
+                          FT_Vector*      origin )
+  {
+    FT_Error  error;
+
+    error = ft_smooth_render_generic( render, slot, mode, origin,
+                                      FT_RENDER_MODE_LCD_V,
+                                      0, 3 );
+    if ( !error )
+      slot->bitmap.pixel_mode = FT_PIXEL_MODE_LCD_V;
+
+    return error;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Renderer_Class  ft_smooth_renderer_class =
+  {
+    {
+      FT_MODULE_RENDERER,
+      sizeof( FT_RendererRec ),
+
+      "smooth",
+      0x10000L,
+      0x20000L,
+
+      0,    /* module specific interface */
+
+      (FT_Module_Constructor)ft_smooth_init,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  0
+    },
+
+    FT_GLYPH_FORMAT_OUTLINE,
+
+    (FT_Renderer_RenderFunc)   ft_smooth_render,
+    (FT_Renderer_TransformFunc)ft_smooth_transform,
+    (FT_Renderer_GetCBoxFunc)  ft_smooth_get_cbox,
+    (FT_Renderer_SetModeFunc)  ft_smooth_set_mode,
+
+    (FT_Raster_Funcs*)    &ft_grays_raster
+  };
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Renderer_Class  ft_smooth_lcd_renderer_class =
+  {
+    {
+      FT_MODULE_RENDERER,
+      sizeof( FT_RendererRec ),
+
+      "smooth-lcd",
+      0x10000L,
+      0x20000L,
+
+      0,    /* module specific interface */
+
+      (FT_Module_Constructor)ft_smooth_init,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  0
+    },
+
+    FT_GLYPH_FORMAT_OUTLINE,
+
+    (FT_Renderer_RenderFunc)   ft_smooth_render_lcd,
+    (FT_Renderer_TransformFunc)ft_smooth_transform,
+    (FT_Renderer_GetCBoxFunc)  ft_smooth_get_cbox,
+    (FT_Renderer_SetModeFunc)  ft_smooth_set_mode,
+
+    (FT_Raster_Funcs*)    &ft_grays_raster
+  };
+
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Renderer_Class  ft_smooth_lcdv_renderer_class =
+  {
+    {
+      FT_MODULE_RENDERER,
+      sizeof( FT_RendererRec ),
+
+      "smooth-lcdv",
+      0x10000L,
+      0x20000L,
+
+      0,    /* module specific interface */
+
+      (FT_Module_Constructor)ft_smooth_init,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  0
+    },
+
+    FT_GLYPH_FORMAT_OUTLINE,
+
+    (FT_Renderer_RenderFunc)   ft_smooth_render_lcd_v,
+    (FT_Renderer_TransformFunc)ft_smooth_transform,
+    (FT_Renderer_GetCBoxFunc)  ft_smooth_get_cbox,
+    (FT_Renderer_SetModeFunc)  ft_smooth_set_mode,
+
+    (FT_Raster_Funcs*)    &ft_grays_raster
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/smooth/ftsmooth.h b/nx-X11/extras/freetype2/src/smooth/ftsmooth.h
new file mode 100644
index 000000000..62cced448
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/ftsmooth.h
@@ -0,0 +1,49 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsmooth.h                                                             */
+/*                                                                         */
+/*    Anti-aliasing renderer interface (specification).                    */
+/*                                                                         */
+/*  Copyright 1996-2001 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 __FTSMOOTH_H__
+#define __FTSMOOTH_H__
+
+
+#include <ft2build.h>
+#include FT_RENDER_H
+
+
+FT_BEGIN_HEADER
+
+
+#ifndef FT_CONFIG_OPTION_NO_STD_RASTER
+  FT_EXPORT_VAR( const FT_Renderer_Class )  ft_std_renderer_class;
+#endif
+
+#ifndef FT_CONFIG_OPTION_NO_SMOOTH_RASTER
+  FT_EXPORT_VAR( const FT_Renderer_Class )  ft_smooth_renderer_class;
+
+  FT_EXPORT_VAR( const FT_Renderer_Class )  ft_smooth_lcd_renderer_class;
+
+  FT_EXPORT_VAR( const FT_Renderer_Class )  ft_smooth_lcd_v_renderer_class;
+#endif
+
+
+
+FT_END_HEADER
+
+#endif /* __FTSMOOTH_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/smooth/module.mk b/nx-X11/extras/freetype2/src/smooth/module.mk
new file mode 100644
index 000000000..ead77cf30
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 smooth renderer module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_smooth_renderer
+
+add_smooth_renderer:
+	$(OPEN_DRIVER)ft_smooth_renderer_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)smooth    $(ECHO_DRIVER_DESC)anti-aliased bitmap renderer$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/smooth/rules.mk b/nx-X11/extras/freetype2/src/smooth/rules.mk
new file mode 100644
index 000000000..4f27f01db
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/rules.mk
@@ -0,0 +1,69 @@
+#
+# FreeType 2 smooth renderer module build rules
+#
+
+
+# Copyright 1996-2000, 2001, 2003 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.
+
+
+# smooth driver directory
+#
+SMOOTH_DIR := $(SRC_DIR)/smooth
+
+# compilation flags for the driver
+#
+SMOOTH_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(SMOOTH_DIR))
+
+
+# smooth driver sources (i.e., C files)
+#
+SMOOTH_DRV_SRC := $(SMOOTH_DIR)/ftgrays.c  \
+                  $(SMOOTH_DIR)/ftsmooth.c
+
+
+# smooth driver headers
+#
+SMOOTH_DRV_H := $(SMOOTH_DRV_SRC:%c=%h)  \
+                $(SMOOTH_DIR)/ftsmerrs.h
+
+
+# smooth driver object(s)
+#
+#   SMOOTH_DRV_OBJ_M is used during `multi' builds.
+#   SMOOTH_DRV_OBJ_S is used during `single' builds.
+#
+SMOOTH_DRV_OBJ_M := $(SMOOTH_DRV_SRC:$(SMOOTH_DIR)/%.c=$(OBJ_DIR)/%.$O)
+SMOOTH_DRV_OBJ_S := $(OBJ_DIR)/smooth.$O
+
+# smooth driver source file for single build
+#
+SMOOTH_DRV_SRC_S := $(SMOOTH_DIR)/smooth.c
+
+
+# smooth driver - single object
+#
+$(SMOOTH_DRV_OBJ_S): $(SMOOTH_DRV_SRC_S) $(SMOOTH_DRV_SRC) \
+                     $(FREETYPE_H) $(SMOOTH_DRV_H)
+	$(SMOOTH_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(SMOOTH_DRV_SRC_S))
+
+
+# smooth driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(SMOOTH_DIR)/%.c $(FREETYPE_H) $(SMOOTH_DRV_H)
+	$(SMOOTH_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(SMOOTH_DRV_OBJ_S)
+DRV_OBJS_M += $(SMOOTH_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/smooth/smooth.c b/nx-X11/extras/freetype2/src/smooth/smooth.c
new file mode 100644
index 000000000..ff6be3e40
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/smooth/smooth.c
@@ -0,0 +1,26 @@
+/***************************************************************************/
+/*                                                                         */
+/*  smooth.c                                                               */
+/*                                                                         */
+/*    FreeType anti-aliasing rasterer module component (body only).        */
+/*                                                                         */
+/*  Copyright 1996-2001 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 "ftgrays.c"
+#include "ftsmooth.c"
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/tools/cordic.py b/nx-X11/extras/freetype2/src/tools/cordic.py
new file mode 100644
index 000000000..1906b6b1f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/cordic.py
@@ -0,0 +1,79 @@
+# compute arctangent table for CORDIC computations in fttrigon.c
+import sys, math
+
+#units  = 64*65536.0   # don't change !!
+units  = 256
+scale  = units/math.pi
+shrink = 1.0
+comma  = ""
+
+def calc_val( x ):
+    global units, shrink
+    angle  = math.atan(x)
+    shrink = shrink * math.cos(angle)
+    return angle/math.pi * units
+
+def  print_val( n, x ):
+    global comma
+
+    lo  = int(x)
+    hi  = lo + 1
+    alo = math.atan(lo)
+    ahi = math.atan(hi)
+    ax  = math.atan(2.0**n)
+
+    errlo = abs( alo - ax )
+    errhi = abs( ahi - ax )
+
+    if ( errlo < errhi ):
+      hi = lo
+
+    sys.stdout.write( comma + repr( int(hi) ) )
+    comma = ", "
+
+
+print ""
+print "table of arctan( 1/2^n ) for PI = " + repr(units/65536.0) + " units"
+
+# compute range of "i"
+r = [-1]
+r = r + range(32)
+
+for n in r:
+
+    if n >= 0:
+        x = 1.0/(2.0**n)    # tangent value
+    else:
+        x = 2.0**(-n)
+
+    angle  = math.atan(x)    # arctangent
+    angle2 = angle*scale     # arctangent in FT_Angle units
+
+    # determine which integer value for angle gives the best tangent
+    lo  = int(angle2)
+    hi  = lo + 1
+    tlo = math.tan(lo/scale)
+    thi = math.tan(hi/scale)
+
+    errlo = abs( tlo - x )
+    errhi = abs( thi - x )
+
+    angle2 = hi
+    if errlo < errhi:
+        angle2 = lo
+
+    if angle2 <= 0:
+        break
+
+    sys.stdout.write( comma + repr( int(angle2) ) )
+    comma = ", "
+
+    shrink = shrink * math.cos( angle2/scale)
+
+
+print
+print "shrink factor    = " + repr( shrink )
+print "shrink factor 2  = " + repr( shrink * (2.0**32) )
+print "expansion factor = " + repr(1/shrink)
+print ""
+   
\ No newline at end of file
diff --git a/nx-X11/extras/freetype2/src/tools/docmaker/.cvsignore b/nx-X11/extras/freetype2/src/tools/docmaker/.cvsignore
new file mode 100644
index 000000000..0d20b6487
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/docmaker/.cvsignore
@@ -0,0 +1 @@
+*.pyc
diff --git a/nx-X11/extras/freetype2/src/tools/docmaker/content.py b/nx-X11/extras/freetype2/src/tools/docmaker/content.py
new file mode 100644
index 000000000..ebfeb8bf4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/docmaker/content.py
@@ -0,0 +1,585 @@
+#
+#  this file contains routines used to parse the content of documentation
+#  comment block and build a more structured objects out of them
+#
+
+from sources import *
+from utils import *
+import string, re
+
+
+# this regular expresion is used to detect code sequences. these
+# are simply code fragments embedded in '{' and '}' like in:
+#
+#  {
+#    x = y + z;
+#    if ( zookoo == 2 )
+#    {
+#      foobar();
+#    }
+#  }
+#
+# note that identation of the starting and ending accolades must be
+# exactly the same. the code sequence can contain accolades at greater
+# indentation
+#
+re_code_start = re.compile( r"(\s*){\s*$" )
+re_code_end   = re.compile( r"(\s*)}\s*$" )
+
+
+# this regular expression is used to isolate identifiers from
+# other text
+#
+re_identifier = re.compile( r'(\w*)' )
+
+
+#############################################################################
+#
+# The DocCode class is used to store source code lines.
+#
+#   'self.lines' contains a set of source code lines that will be dumped as
+#   HTML in a <PRE> tag.
+#
+#   The object is filled line by line by the parser; it strips the leading
+#   "margin" space from each input line before storing it in 'self.lines'.
+#
+class DocCode:
+
+    def __init__( self, margin, lines ):
+        self.lines  = []
+        self.words  = None
+
+        # remove margin spaces
+        for l in lines:
+            if string.strip( l[:margin] ) == "":
+                l = l[margin:]
+            self.lines.append( l )
+
+    def dump( self, prefix = "", width=60 ):
+        lines = self.dump_lines( 0, width )
+        for l in lines:
+            print prefix + l
+    
+    def dump_lines( self, margin=0, width=60 ):
+        result = []
+        for l in self.lines:
+            result.append( " "*margin + l )
+        return result
+    
+
+
+#############################################################################
+#
+# The DocPara class is used to store "normal" text paragraph.
+#
+#   'self.words' contains the list of words that make up the paragraph
+#
+class DocPara:
+
+    def __init__( self, lines ):
+        self.lines = None
+        self.words = []
+        for l in lines:
+            l = string.strip(l)
+            self.words.extend( string.split( l ) )
+
+    def dump( self, prefix = "", width = 60 ):
+        lines = self.dump_lines( 0, width )
+        for l in lines:
+            print prefix + l
+    
+    def dump_lines( self, margin=0, width = 60 ):
+        cur    = ""  # current line
+        col    = 0   # current width
+        result = []
+
+        for word in self.words:
+            ln = len(word)
+            if col > 0:
+                ln = ln+1
+
+            if col + ln > width:
+                result.append( " "*margin + cur )
+                cur = word
+                col = len(word)
+            else:
+                if col > 0:
+                    cur = cur + " "
+                cur = cur + word
+                col = col + ln
+
+        if col > 0:
+            result.append( " "*margin + cur )
+            
+        return result
+
+    
+
+
+#############################################################################
+#
+#  The DocField class is used to store a list containing either DocPara or
+#  DocCode objects. Each DocField also has an optional "name" which is used
+#  when the object corresponds to a field of value definition
+#
+class DocField:
+
+    def __init__( self, name, lines ):
+
+        self.name  = name  # can be None for normal paragraphs/sources
+        self.items = []     # list of items
+
+        mode_none  = 0   # start parsing mode
+        mode_code  = 1   # parsing code sequences
+        mode_para  = 3   # parsing normal paragraph
+
+        margin     = -1  # current code sequence indentation
+        cur_lines  = []
+
+        # now analyze the markup lines to see if they contain paragraphs,
+        # code sequences or fields definitions
+        #
+        start = 0
+        mode  = mode_none
+        for l in lines:
+
+            # are we parsing a code sequence ?
+            if mode == mode_code:
+
+                m = re_code_end.match( l )
+                if m and len(m.group(1)) <= margin:
+                    # that's it, we finised the code sequence
+                    code = DocCode( 0, cur_lines )
+                    self.items.append( code )
+                    margin    = -1
+                    cur_lines = []
+                    mode      = mode_none
+                else:
+                    # nope, continue the code sequence
+                    cur_lines.append( l[margin:] )
+            else:
+                # start of code sequence ?
+                m = re_code_start.match( l )
+                if m:
+                    # save current lines
+                    if cur_lines:
+                        para = DocPara( cur_lines )
+                        self.items.append( para )
+                        cur_lines = []
+
+                    # switch to code extraction mode
+                    margin = len(m.group(1))
+                    mode   = mode_code
+
+                else:
+                    if not string.split( l ) and cur_lines:
+                        # if the line is empty, we end the current paragraph,
+                        # if any
+                        para = DocPara( cur_lines )
+                        self.items.append( para )
+                        cur_lines = []
+                    else:
+                        # otherwise, simply add the line to the current
+                        # paragraph
+                        cur_lines.append( l )
+
+        if mode == mode_code:
+            # unexpected end of code sequence
+            code = DocCode( margin, cur_lines )
+            self.items.append( code )
+
+        elif cur_lines:
+            para = DocPara( cur_lines )
+            self.items.append( para )
+
+    def dump( self, prefix = "" ):
+        if self.field:
+            print prefix + self.field + " ::"
+            prefix = prefix + "----"
+
+        first = 1
+        for p in self.items:
+            if not first:
+                print ""
+            p.dump( prefix )
+            first = 0
+
+    def dump_lines( self, margin=0, width=60 ):
+        result = []
+        nl     = None
+        for p in self.items:
+            if nl:
+                result.append( "" )
+                
+            result.extend( p.dump_lines( margin, width ) )
+            nl = 1
+            
+        return result
+
+# this regular expression is used to detect field definitions
+#
+re_field  = re.compile( r"\s*(\w*)\s*::" )
+
+
+
+class DocMarkup:
+
+    def __init__( self, tag, lines ):
+        self.tag       = string.lower(tag)
+        self.fields    = []
+
+        cur_lines = []
+        field     = None
+        mode      = 0
+
+        for l in lines:
+            m = re_field.match( l )
+            if m:
+                # we detected the start of a new field definition
+
+                # first, save the current one
+                if cur_lines:
+                    f = DocField( field, cur_lines )
+                    self.fields.append( f )
+                    cur_lines = []
+                    field     = None
+
+                field     = m.group(1)   # record field name
+                ln        = len(m.group(0))
+                l         = " "*ln + l[ln:]
+                cur_lines = [ l ]
+            else:
+                cur_lines.append( l )
+
+        if field or cur_lines:
+            f = DocField( field, cur_lines )
+            self.fields.append( f )
+
+    def get_name( self ):
+        try:
+            return self.fields[0].items[0].words[0]
+
+        except:
+            return None
+        
+    def get_start( self ):
+        try:
+            result = ""
+            for word in self.fields[0].items[0].words:
+                result = result + " " + word
+            return result[1:]
+        
+        except:
+            return "ERROR"
+
+    def dump( self, margin ):
+        print " "*margin + "<" + self.tag + ">"
+        for f in self.fields:
+            f.dump( "  " )
+        print " "*margin + "</" + self.tag + ">"
+
+
+
+
+class DocChapter:
+
+    def __init__( self, block ):
+        self.block    = block
+        self.sections = []
+        if block:
+            self.name     = block.name
+            self.title    = block.get_markup_words( "title" )
+            self.order    = block.get_markup_words( "sections" )
+        else:
+            self.name     = "Other"
+            self.title    = string.split( "Miscellaneous" )
+            self.order    = []
+
+
+
+class DocSection:
+
+    def __init__( self, name = "Other" ):
+        self.name        = name
+        self.blocks      = {}
+        self.block_names = []  # ordered block names in section
+        self.defs        = []
+        self.abstract    = ""
+        self.description = ""
+        self.order       = []
+        self.title       = "ERROR"
+        self.chapter     = None
+
+    def add_def( self, block ):
+        self.defs.append( block )
+
+    def add_block( self, block ):
+        self.block_names.append( block.name )
+        self.blocks[ block.name ] = block
+
+    def process( self ):
+        # lookup one block that contains a valid section description
+        for block in self.defs:
+            title = block.get_markup_text( "Title" )
+            if title:
+                self.title       = title
+                self.abstract    = block.get_markup_words( "abstract" )
+                self.description = block.get_markup_items( "description" )
+                self.order       = block.get_markup_words( "order" )
+                return
+
+    def reorder( self ):
+
+        self.block_names = sort_order_list( self.block_names, self.order )
+
+
+class ContentProcessor:
+
+    def __init__( self ):
+        """initialize a block content processor"""
+        self.reset()
+
+        self.sections = {}    # dictionary of documentation sections
+        self.section  = None  # current documentation section
+
+        self.chapters = []        # list of chapters
+
+    def set_section( self, section_name ):
+        """set current section during parsing"""
+        if not self.sections.has_key( section_name ):
+            section = DocSection( section_name )
+            self.sections[ section_name ] = section
+            self.section                  = section
+        else:
+            self.section = self.sections[ section_name ]
+
+    def add_chapter( self, block ):
+        chapter = DocChapter( block )
+        self.chapters.append( chapter )
+
+
+    def reset( self ):
+        """reset the content processor for a new block"""
+        self.markups      = []
+        self.markup       = None
+        self.markup_lines = []
+
+    def add_markup( self ):
+        """add a new markup section"""
+        if self.markup and self.markup_lines:
+
+            # get rid of last line of markup if it's empty
+            marks = self.markup_lines
+            if len(marks) > 0 and not string.strip(marks[-1]):
+                self.markup_lines = marks[:-1]
+
+            m = DocMarkup( self.markup, self.markup_lines )
+
+            self.markups.append( m )
+
+            self.markup       = None
+            self.markup_lines = []
+
+
+    def process_content( self, content ):
+        """process a block content and return a list of DocMarkup objects
+           corresponding to it"""
+        markup       = None
+        markup_lines = []
+        first        = 1
+
+        for line in content:
+            found = None
+            for t in re_markup_tags:
+                m = t.match( line )
+                if m:
+                    found  = string.lower(m.group(1))
+                    prefix = len(m.group(0))
+                    line   = " "*prefix + line[prefix:]   # remove markup from line
+                    break
+
+            # is it the start of a new markup section ?
+            if found:
+                first = 0
+                self.add_markup()  # add current markup content
+                self.markup = found
+                if len(string.strip( line )) > 0:
+                    self.markup_lines.append( line )
+            elif first == 0:
+                self.markup_lines.append( line )
+
+        self.add_markup()
+
+        return self.markups
+
+
+    def  parse_sources( self, source_processor ):
+        blocks = source_processor.blocks
+        count  = len(blocks)
+        for n in range(count):
+
+            source = blocks[n]
+            if source.content:
+                # this is a documentation comment, we need to catch
+                # all following normal blocks in the "follow" list
+                #
+                follow = []
+                m = n+1
+                while m < count and not blocks[m].content:
+                    follow.append( blocks[m] )
+                    m = m+1
+
+                doc_block = DocBlock( source, follow, self )
+
+
+    def  finish( self ):
+
+        # process all sections to extract their abstract, description
+        # and ordered list of items
+        #
+        for sec in self.sections.values():
+            sec.process()
+
+        # process chapters to check that all sections are correctly
+        # listed there
+        for chap in self.chapters:
+            for sec in chap.order:
+                if self.sections.has_key(sec):
+                    section = self.sections[ sec ]
+                    section.chapter = chap
+                    section.reorder()
+                    chap.sections.append( section )
+                else:
+                    sys.stderr.write( "WARNING: chapter '" +
+                        chap.name + "' in " + chap.block.location() + \
+                        " lists unknown section '" + sec + "'\n" )
+
+        # check that all sections are in a chapter
+        #
+        others = []
+        for sec in self.sections.values():
+            if not sec.chapter:
+                others.append(sec)
+
+        # create a new special chapter for all remaining sections
+        # when necessary
+        #
+        if others:
+            chap = DocChapter( None )
+            chap.sections = others
+            self.chapters.append( chap )
+
+
+
+class DocBlock:
+
+    def __init__( self, source, follow, processor ):
+
+        processor.reset()
+
+        self.source    = source
+        self.code      = []
+        self.type      = "ERRTYPE"
+        self.name      = "ERRNAME"
+        self.section   = processor.section
+        self.markups   = processor.process_content( source.content )
+
+        # compute block type from first markup tag
+        try:
+            self.type = self.markups[0].tag
+        except:
+            pass
+
+
+        # compute block name from first markup paragraph
+        try:
+            markup = self.markups[0]
+            para   = markup.fields[0].items[0]
+            name   = para.words[0]
+            m = re_identifier.match( name )
+            if m:
+                name = m.group(1)
+            self.name = name
+        except:
+            pass
+
+        # detect new section starts
+        if self.type == "section":
+            processor.set_section( self.name )
+            processor.section.add_def( self )
+
+        # detect new chapter
+        elif self.type == "chapter":
+            processor.add_chapter( self )
+
+        else:
+            processor.section.add_block( self )
+
+        # now, compute the source lines relevant to this documentation
+        # block. We keep normal comments in for obvious reasons (??)
+        source = []
+        for b in follow:
+            if b.format:
+                break
+            for l in b.lines:
+                # we use "/* */" as a separator
+                if re_source_sep.match( l ):
+                    break
+                source.append( l )
+
+        # now strip the leading and trailing empty lines from the sources
+        start = 0
+        end   = len( source )-1
+
+        while start < end and not string.strip( source[start] ):
+            start = start + 1
+
+        while start < end and not string.strip( source[end] ):
+            end = end - 1
+
+        source = source[start:end+1]
+
+        self.code = source
+
+
+    def location( self ):
+        return self.source.location()
+
+
+
+    def get_markup( self, tag_name ):
+        """return the DocMarkup corresponding to a given tag in a block"""
+        for m in self.markups:
+            if m.tag == string.lower(tag_name):
+                return m
+        return None
+
+
+    def get_markup_name( self, tag_name ):
+        """return the name of a given primary markup in a block"""
+        try:
+            m = self.get_markup( tag_name )
+            return m.get_name()
+        except:
+            return None
+
+
+    def get_markup_words( self, tag_name ):
+        try:
+            m = self.get_markup( tag_name )
+            return m.fields[0].items[0].words
+        except:
+            return []
+
+
+    def get_markup_text( self, tag_name ):
+        result = self.get_markup_words( tag_name )
+        return string.join( result )
+
+
+    def get_markup_items( self, tag_name ):
+        try:
+            m = self.get_markup( tag_name )
+            return m.fields[0].items
+        except:
+            return None
diff --git a/nx-X11/extras/freetype2/src/tools/docmaker/docbeauty.py b/nx-X11/extras/freetype2/src/tools/docmaker/docbeauty.py
new file mode 100644
index 000000000..94b266b6d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/docmaker/docbeauty.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+#
+#  DocBeauty (c) 2003, 2004 David Turner <david@freetype.org>
+#
+# This program is used to beautify the documentation comments used
+# in the FreeType 2 public headers.
+#
+
+from sources   import *
+from content   import *
+from utils     import *
+
+import utils
+
+import sys, os, time, string, getopt
+
+content_processor = ContentProcessor()
+
+
+def beautify_block( block ):
+    if block.content:
+        content_processor.reset()
+
+        markups = content_processor.process_content( block.content )
+        text    = []
+        first   = 1
+
+        for markup in markups:
+            text.extend( markup.beautify( first ) )
+            first = 0
+        
+        # now beautify the documentation "borders" themselves
+        lines = [ " /*************************************************************************" ]
+        for l in text:
+            lines.append( "  *" + l )
+        lines.append( "  */" )
+        
+        block.lines = lines
+        
+
+def usage():
+    print "\nDocBeauty 0.1 Usage information\n"
+    print "  docbeauty [options] file1 [ file2 ... ]\n"
+    print "using the following options:\n"
+    print "  -h : print this page"
+    print "  -b : backup original files with the 'orig' extension"
+    print ""
+    print "  --backup : same as -b"
+    
+
+def main( argv ):
+    """main program loop"""
+
+    global output_dir
+
+    try:
+        opts, args = getopt.getopt( sys.argv[1:],
+                                    "hb",
+                                    [ "help", "backup" ] )
+
+    except getopt.GetoptError:
+        usage()
+        sys.exit( 2 )
+
+    if args == []:
+        usage()
+        sys.exit( 1 )
+
+    # process options
+    #
+    output_dir = None
+    do_backup  = None
+
+    for opt in opts:
+        if opt[0] in ( "-h", "--help" ):
+            usage()
+            sys.exit( 0 )
+
+        if opt[0] in ( "-b", "--backup" ):
+            do_backup = 1
+
+    # create context and processor
+    source_processor  = SourceProcessor()
+
+    # retrieve the list of files to process
+    file_list = make_file_list( args )
+    for filename in file_list:
+        source_processor.parse_file( filename )
+        for block in source_processor.blocks:
+            beautify_block( block )
+        new_name = filename + ".new"
+        ok       = None
+        try:
+            file = open( new_name, "wt" )
+            for block in source_processor.blocks:
+                for line in block.lines:
+                    file.write( line )
+                    file.write( "\n" )
+            file.close()
+        except:
+            ok = 0
+
+# if called from the command line
+#
+if __name__ == '__main__':
+    main( sys.argv )
+
+
+# eof
diff --git a/nx-X11/extras/freetype2/src/tools/docmaker/docmaker.py b/nx-X11/extras/freetype2/src/tools/docmaker/docmaker.py
new file mode 100644
index 000000000..9da4bbf8e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/docmaker/docmaker.py
@@ -0,0 +1,107 @@
+#!/usr/bin/env python
+#
+#  DocMaker (c) 2002, 2004 David Turner <david@freetype.org>
+#
+# This program is a re-write of the original DocMaker took used
+# to generate the API Reference of the FreeType font engine
+# by converting in-source comments into structured HTML.
+#
+# This new version is capable of outputting XML data, as well
+# as accepts more liberal formatting options.
+#
+# It also uses regular expression matching and substitution
+# to speed things significantly.
+#
+
+from sources   import *
+from content   import *
+from utils     import *
+from formatter import *
+from tohtml    import *
+
+import utils
+
+import sys, os, time, string, glob, getopt
+
+
+def usage():
+    print "\nDocMaker Usage information\n"
+    print "  docmaker [options] file1 [ file2 ... ]\n"
+    print "using the following options:\n"
+    print "  -h : print this page"
+    print "  -t : set project title, as in '-t \"My Project\"'"
+    print "  -o : set output directory, as in '-o mydir'"
+    print "  -p : set documentation prefix, as in '-p ft2'"
+    print ""
+    print "  --title  : same as -t, as in '--title=\"My Project\"'"
+    print "  --output : same as -o, as in '--output=mydir'"
+    print "  --prefix : same as -p, as in '--prefix=ft2'"
+    
+
+def main( argv ):
+    """main program loop"""
+
+    global output_dir
+
+    try:
+        opts, args = getopt.getopt( sys.argv[1:],
+                                    "ht:o:p:",
+                                    [ "help", "title=", "output=", "prefix=" ] )
+
+    except getopt.GetoptError:
+        usage()
+        sys.exit( 2 )
+
+    if args == []:
+        usage()
+        sys.exit( 1 )
+
+    # process options
+    #
+    project_title  = "Project"
+    project_prefix = None
+    output_dir     = None
+
+    for opt in opts:
+        if opt[0] in ( "-h", "--help" ):
+            usage()
+            sys.exit( 0 )
+
+        if opt[0] in ( "-t", "--title" ):
+            project_title = opt[1]
+
+        if opt[0] in ( "-o", "--output" ):
+            utils.output_dir = opt[1]
+
+        if opt[0] in ( "-p", "--prefix" ):
+            project_prefix = opt[1]
+
+    check_output( )
+
+    # create context and processor
+    source_processor  = SourceProcessor()
+    content_processor = ContentProcessor()
+
+    # retrieve the list of files to process
+    file_list = make_file_list( args )
+    for filename in file_list:
+        source_processor.parse_file( filename )
+        content_processor.parse_sources( source_processor )
+        
+    # process sections
+    content_processor.finish()
+
+    formatter = HtmlFormatter( content_processor, project_title, project_prefix )
+
+    formatter.toc_dump()
+    formatter.index_dump()
+    formatter.section_dump_all()
+
+
+# if called from the command line
+#
+if __name__ == '__main__':
+    main( sys.argv )
+
+
+# eof
diff --git a/nx-X11/extras/freetype2/src/tools/docmaker/formatter.py b/nx-X11/extras/freetype2/src/tools/docmaker/formatter.py
new file mode 100644
index 000000000..63ecddc97
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/docmaker/formatter.py
@@ -0,0 +1,203 @@
+from sources import *
+from content import *
+from utils   import *
+
+# This is the base Formatter class. its purpose is to convert
+# a content processor's data into specific documents (i.e. table of
+# contents, global index, and individual API reference indices).
+#
+# You'll need to sub-class it to output anything sensible.  For example,
+# the file tohtml.py contains the definition of the HtmlFormatter sub-class
+# used to output, you guessed it, HTML.
+#
+
+class Formatter:
+
+    def __init__( self, processor ):
+
+        self.processor   = processor
+        self.identifiers = {}
+        self.chapters    = processor.chapters
+        self.sections    = processor.sections.values()
+        self.block_index = []
+
+        # store all blocks in a dictionary
+        self.blocks      = []
+        for section in self.sections:
+            for block in section.blocks.values():
+                self.add_identifier( block.name, block )
+                    
+                # add enumeration values to the index, since this is useful
+                for markup in block.markups:
+                    if markup.tag == 'values':
+                        for field in markup.fields:
+                            self.add_identifier( field.name, block )
+
+
+        self.block_index = self.identifiers.keys()
+        self.block_index.sort( index_sort )
+
+
+    def add_identifier( self, name, block ):
+        if self.identifiers.has_key( name ):
+            # duplicate name !!
+            sys.stderr.write( \
+               "WARNING: duplicate definition for '" + name + "' in " + \
+               block.location() + ", previous definition in " +         \
+               self.identifiers[ name ].location() + "\n" )
+        else:
+            self.identifiers[name] = block
+              
+
+    #
+    #  Formatting the table of contents
+    #
+
+    def  toc_enter( self ):
+        pass
+    
+    def  toc_chapter_enter( self, chapter ):
+        pass
+    
+    def  toc_section_enter( self, section ):
+        pass
+        
+    def  toc_section_exit( self, section ):
+        pass
+        
+    def  toc_chapter_exit( self, chapter ):
+        pass
+
+    def  toc_index( self, index_filename ):
+        pass
+    
+    def  toc_exit( self ):
+        pass
+
+    def  toc_dump( self, toc_filename = None, index_filename = None ):
+        
+        output = None
+        if toc_filename:
+            output = open_output( toc_filename )
+        
+        self.toc_enter()
+    
+        for chap in self.processor.chapters:
+    
+            self.toc_chapter_enter( chap )
+    
+            for section in chap.sections:
+                self.toc_section_enter( section )
+                self.toc_section_exit( section )
+    
+            self.toc_chapter_exit ( chap )
+    
+        self.toc_index( index_filename )
+    
+        self.toc_exit()
+
+        if output:
+            close_output( output )
+    
+    #
+    #  Formatting the index
+    #
+
+    def  index_enter( self ):
+        pass
+
+    def  index_name_enter( self, name ):
+        pass
+
+    def  index_name_exit( self, name ):
+        pass
+
+    def  index_exit( self ):
+        pass
+
+    def  index_dump( self, index_filename = None ):
+        
+        output = None
+        if index_filename:
+            output = open_output( index_filename )
+
+        self.index_enter()
+
+        for name in self.block_index:
+            self.index_name_enter( name )
+            self.index_name_exit ( name )
+
+        self.index_exit()
+     
+        if output:
+            close_output( output )
+     
+    #
+    #  Formatting a section
+    #
+    def  section_enter( self, section ):
+        pass
+    
+    def  block_enter( self, block ):
+        pass
+    
+    def  markup_enter( self, markup, block = None ):
+        pass
+    
+    def  field_enter( self, field, markup = None, block = None ):
+        pass
+        
+    def  field_exit( self, field, markup = None, block = None ):
+        pass
+    
+    def  markup_exit( self, markup, block = None ):
+        pass
+        
+    def  block_exit( self, block ):
+        pass
+
+    def  section_exit( self, section ):
+        pass
+
+
+    def  section_dump( self, section, section_filename = None ):
+        
+        output = None
+        if section_filename:
+            output = open_output( section_filename )
+        
+        self.section_enter( section )
+
+        for name in section.block_names:
+            block = self.identifiers[ name ]
+            self.block_enter( block )
+
+            for markup in block.markups[1:]:   # always ignore first markup !!
+                self.markup_enter( markup, block )
+
+                for field in markup.fields:
+                    self.field_enter( field, markup, block )
+
+                    self.field_exit ( field, markup, block )
+
+                self.markup_exit( markup, block )
+
+            self.block_exit( block )
+
+        self.section_exit ( section )
+
+        if output:
+            close_output( output )
+
+
+    def section_dump_all( self ):
+        for section in self.sections:
+            self.section_dump( section )
+
+    #
+    #  Formatting a block
+    #
+
+
+
+
diff --git a/nx-X11/extras/freetype2/src/tools/docmaker/sources.py b/nx-X11/extras/freetype2/src/tools/docmaker/sources.py
new file mode 100644
index 000000000..492300562
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/docmaker/sources.py
@@ -0,0 +1,355 @@
+#
+# this file contains definitions of classes needed to decompose
+# C sources files into a series of multi-line "blocks". There are
+# two kinds of blocks:
+#
+#   - normal blocks, which contain source code or ordinary comments
+#
+#   - documentation blocks, which have restricted formatting, and
+#     whose text always start with a documentation markup tag like
+#     "<Function>", "<Type>", etc..
+#
+# the routines used to process the content of documentation blocks
+# are not contained here, but in "content.py"
+#
+# the classes and methods found here only deal with text parsing
+# and basic documentation block extraction
+#
+import fileinput, re, sys, os, string
+
+
+
+
+
+
+################################################################
+##
+##  BLOCK FORMAT PATTERN
+##
+##   A simple class containing compiled regular expressions used
+##   to detect potential documentation format block comments within
+##   C source code
+##
+##   note that the 'column' pattern must contain a group that will
+##   be used to "unbox" the content of documentation comment blocks
+##
+class SourceBlockFormat:
+
+    def __init__( self, id, start, column, end ):
+        """create a block pattern, used to recognize special documentation blocks"""
+
+        self.id     = id
+        self.start  = re.compile( start, re.VERBOSE )
+        self.column = re.compile( column, re.VERBOSE )
+        self.end    = re.compile( end, re.VERBOSE )
+
+
+
+#
+# format 1 documentation comment blocks look like the following:
+#
+#    /************************************/
+#    /*                                  */
+#    /*                                  */
+#    /*                                  */
+#    /************************************/
+#
+# we define a few regular expressions here to detect them
+#
+
+start = r'''
+  \s*       # any number of whitespace
+  /\*{2,}/  # followed by '/' and at least two asterisks then '/'
+  \s*$      # eventually followed by whitespace
+'''
+
+column = r'''
+  \s*      # any number of whitespace
+  /\*{1}   # followed by '/' and precisely one asterisk
+  ([^*].*) # followed by anything (group 1)
+  \*{1}/   # followed by one asterisk and a '/'
+  \s*$     # enventually followed by whitespace
+'''
+
+re_source_block_format1 = SourceBlockFormat( 1, start, column, start )
+
+#
+# format 2 documentation comment blocks look like the following:
+#
+#    /************************************ (at least 2 asterisks)
+#     *
+#     *
+#     *
+#     *
+#     **/       (1 or more asterisks at the end)
+#
+# we define a few regular expressions here to detect them
+#
+start = r'''
+  \s*     # any number of whitespace
+  /\*{2,} # followed by '/' and at least two asterisks
+  \s*$    # eventually followed by whitespace
+'''
+
+column = r'''
+  \s*         # any number of whitespace
+  \*{1}       # followed by precisely one asterisk
+  (.*)        # then anything (group1)
+'''
+
+end = r'''
+  \s*     # any number of whitespace
+  \*+/    # followed by at least one asterisk, then '/'
+'''
+
+re_source_block_format2 = SourceBlockFormat( 2, start, column, end )
+
+#
+# the list of supported documentation block formats, we could add new ones
+# relatively easily
+#
+re_source_block_formats = [ re_source_block_format1, re_source_block_format2 ]
+
+
+#
+# the following regular expressions corresponds to markup tags
+# within the documentation comment blocks. they're equivalent
+# despite their different syntax
+#
+# notice how each markup tag _must_ begin a new line
+#
+re_markup_tag1 = re.compile( r'''\s*<(\w*)>''' )  # <xxxx> format
+re_markup_tag2 = re.compile( r'''\s*@(\w*):''' )  # @xxxx: format
+
+#
+# the list of supported markup tags, we could add new ones relatively
+# easily
+#
+re_markup_tags = [ re_markup_tag1, re_markup_tag2 ]
+
+#
+# used to detect a cross-reference, after markup tags have been stripped
+#
+re_crossref = re.compile( r'@(\w*)(.*)' )
+
+#
+# used to detect italic and bold styles in paragraph text
+#
+re_italic = re.compile( r'_(\w+)_' )
+re_bold   = re.compile( r'\*(\w+)\*' )
+
+#
+# used to detect the end of commented source lines
+#
+re_source_sep = re.compile( r'\s*/\*\s*\*/' )
+
+#
+# used to perform cross-reference within source output
+#
+re_source_crossref = re.compile( r'(\W*)(\w*)' )
+
+#
+# a list of reserved source keywords
+#
+re_source_keywords = re.compile( '''( typedef |
+                                       struct |
+                                       enum   |
+                                       union  |
+                                       const  |
+                                       char   |
+                                       int    |
+                                       short  |
+                                       long   |
+                                       void   |
+                                       signed |
+                                       unsigned |
+                                       \#include |
+                                       \#define  |
+                                       \#undef   |
+                                       \#if      |
+                                       \#ifdef   |
+                                       \#ifndef  |
+                                       \#else    |
+                                       \#endif   )''', re.VERBOSE )
+
+################################################################
+##
+##  SOURCE BLOCK CLASS
+##
+##   A SourceProcessor is in charge or reading a C source file
+##   and decomposing it into a series of different "SourceBlocks".
+##   each one of these blocks can be made of the following data:
+##
+##   - A documentation comment block that starts with "/**" and
+##     whose exact format will be discussed later
+##
+##   - normal sources lines, include comments
+##
+##   the important fields in a text block are the following ones:
+##
+##     self.lines   : a list of text lines for the corresponding block
+##
+##     self.content : for documentation comment blocks only, this is the
+##                    block content that has been "unboxed" from its
+##                    decoration. This is None for all other blocks
+##                    (i.e. sources or ordinary comments with no starting
+##                     markup tag)
+##
+class SourceBlock:
+    def __init__( self, processor, filename, lineno, lines ):
+        self.processor = processor
+        self.filename  = filename
+        self.lineno    = lineno
+        self.lines     = lines[:]
+        self.format    = processor.format
+        self.content   = []
+
+        if self.format == None:
+            return
+
+        words = []
+
+        # extract comment lines
+        lines = []
+
+        for line0 in self.lines:
+            m = self.format.column.match( line0 )
+            if m:
+                lines.append( m.group(1) )
+
+        # now, look for a markup tag
+        for l in lines:
+            l = string.strip(l)
+            if len(l) > 0:
+                for tag in re_markup_tags:
+                    if tag.match( l ):
+                        self.content = lines
+                return
+
+    def location( self ):
+        return "(" + self.filename + ":" + repr(self.lineno) + ")"
+
+
+    # debugging only - not used in normal operations
+    def dump( self ):
+
+        if self.content:
+            print "{{{content start---"
+            for l in self.content:
+                print l
+            print "---content end}}}"
+            return
+
+        fmt = ""
+        if self.format:
+            fmt = repr(self.format.id) + " "
+
+        for line in self.lines:
+            print line
+
+
+################################################################
+##
+##  SOURCE PROCESSOR CLASS
+##
+##   The SourceProcessor is in charge or reading a C source file
+##   and decomposing it into a series of different "SourceBlock"
+##   objects.
+##
+##   each one of these blocks can be made of the following data:
+##
+##   - A documentation comment block that starts with "/**" and
+##     whose exact format will be discussed later
+##
+##   - normal sources lines, include comments
+##
+##
+class SourceProcessor:
+
+    def  __init__( self ):
+        """initialize a source processor"""
+        self.blocks   = []
+        self.filename = None
+        self.format   = None
+        self.lines    = []
+
+    def  reset( self ):
+        """reset a block processor, clean all its blocks"""
+        self.blocks = []
+        self.format = None
+
+
+    def  parse_file( self, filename ):
+        """parse a C source file, and adds its blocks to the processor's list"""
+
+        self.reset()
+
+        self.filename = filename
+
+        fileinput.close()
+        self.format    = None
+        self.lineno    = 0
+        self.lines     = []
+
+        for line in fileinput.input( filename ):
+
+            # strip trailing newlines, important on Windows machines !!
+            if  line[-1] == '\012':
+                line = line[0:-1]
+
+            if self.format == None:
+                self.process_normal_line( line )
+
+            else:
+                if self.format.end.match( line ):
+                    # that's a normal block end, add it to lines and
+                    # create a new block
+                    self.lines.append( line )
+                    self.add_block_lines()
+
+                elif self.format.column.match( line ):
+                    # that's a normal column line, add it to 'lines'
+                    self.lines.append( line )
+
+                else:
+                    # humm.. this is an unexcepted block end,
+                    # create a new block, but don't process the line
+                    self.add_block_lines()
+
+                    # we need to process the line again
+                    self.process_normal_line( line )
+
+        # record the last lines
+        self.add_block_lines()
+
+
+
+    def process_normal_line( self, line ):
+        """process a normal line and check if it's the start of a new block"""
+        for f in re_source_block_formats:
+          if f.start.match( line ):
+            self.add_block_lines()
+            self.format = f
+            self.lineno = fileinput.filelineno()
+
+        self.lines.append( line )
+
+
+
+    def add_block_lines( self ):
+        """add the current accumulated lines, and create a new block"""
+        if self.lines != []:
+            block = SourceBlock( self, self.filename, self.lineno, self.lines )
+
+            self.blocks.append( block )
+            self.format = None
+            self.lines  = []
+
+
+    # debugging only, not used in normal operations
+    def dump( self ):
+        """print all blocks in a processor"""
+        for b in self.blocks:
+            b.dump()
+
+# eof
diff --git a/nx-X11/extras/freetype2/src/tools/docmaker/tohtml.py b/nx-X11/extras/freetype2/src/tools/docmaker/tohtml.py
new file mode 100644
index 000000000..2a3cf239b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/docmaker/tohtml.py
@@ -0,0 +1,489 @@
+from sources import *
+from content import *
+from formatter import *
+
+import time
+
+# The following defines the HTML header used by all generated pages.
+#
+html_header_1 = """\
+<!doctype html public "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<title>"""
+
+html_header_2= """ API Reference</title>
+<style type="text/css">
+  body { font-family: Verdana, Geneva, Arial, Helvetica, serif;
+         color: #000000;
+         background: #FFFFFF; }
+
+  p { text-align: justify; }
+  h1 { text-align: center; }
+  li { text-align: justify; }
+
+  a:link { color: #0000EF; }
+  a:visited { color: #51188E; }
+  a:hover { color: #FF0000; }
+
+  span.keyword { font-family: monospace;
+                 text-align: left;
+                 white-space: pre;
+                 color: darkblue; }
+
+  pre.colored { color: blue; }
+
+  ul.empty { list-style-type: none; }
+</style>
+</head>
+<body>
+<center><h1>"""
+
+html_header_3=""" API Reference</h1></center>
+"""
+
+
+
+# The HTML footer used by all generated pages.
+#
+html_footer = """\
+</body>
+</html>"""
+
+# The header and footer used for each section.
+#
+section_title_header = "<center><h1>"
+section_title_footer = "</h1></center>"
+
+# The header and footer used for code segments.
+#
+code_header = '<pre class="colored">'
+code_footer = '</pre>'
+
+# Paragraph header and footer.
+#
+para_header = "<p>"
+para_footer = "</p>"
+
+# Block header and footer.
+#
+block_header = '<table align=center width="75%"><tr><td>'
+block_footer = '</td></tr></table><hr width="75%">'
+
+# Description header/footer.
+#
+description_header = '<table align=center width="87%"><tr><td>'
+description_footer = "</td></tr></table><br>"
+
+# Marker header/inter/footer combination.
+#
+marker_header = '<table align=center width="87%" cellpadding=5><tr bgcolor="#EEEEFF"><td><em><b>'
+marker_inter  = "</b></em></td></tr><tr><td>"
+marker_footer = "</td></tr></table>"
+
+# Source code extracts header/footer.
+#
+source_header = '<table align=center width="87%"><tr bgcolor="#D6E8FF"><td><pre>\n'
+source_footer = "\n</pre></table><br>"
+
+# Chapter header/inter/footer.
+#
+chapter_header = '<br><table align=center width="75%"><tr><td><h2>'
+chapter_inter  = '</h2><ul class="empty"><li>'
+chapter_footer = '</li></ul></td></tr></table>'
+
+
+# source language keyword coloration/styling
+#
+keyword_prefix = '<span class="keyword">'
+keyword_suffix = '</span>'
+
+section_synopsis_header = '<h2>Synopsis</h2>'
+section_synopsis_footer = ''
+
+# Translate a single line of source to HTML.  This will convert
+# a "<" into "&lt.", ">" into "&gt.", etc.
+#
+def html_quote( line ):
+    result = string.replace( line,   "&", "&amp;" )
+    result = string.replace( result, "<", "&lt;" )
+    result = string.replace( result, ">", "&gt;" )
+    return result
+
+
+# same as 'html_quote', but ignores left and right brackets
+#
+def html_quote0( line ):
+    return string.replace( line, "&", "&amp;" )
+
+
+def dump_html_code( lines, prefix = "" ):
+    # clean the last empty lines
+    #
+    l = len( self.lines )
+    while l > 0 and string.strip( self.lines[l - 1] ) == "":
+        l = l - 1
+
+    # The code footer should be directly appended to the last code
+    # line to avoid an additional blank line.
+    #
+    print prefix + code_header,
+    for line in self.lines[0 : l+1]:
+        print '\n' + prefix + html_quote(line),
+    print prefix + code_footer,
+
+
+
+class HtmlFormatter(Formatter):
+
+    def __init__( self, processor, project_title, file_prefix ):
+
+        Formatter.__init__( self, processor )
+
+        global html_header_1, html_header_2, html_header_3, html_footer
+
+        if file_prefix:
+            file_prefix = file_prefix + "-"
+        else:
+            file_prefix = ""
+
+        self.project_title = project_title
+        self.file_prefix   = file_prefix
+        self.html_header   = html_header_1 + project_title + html_header_2 + \
+                             project_title + html_header_3
+
+        self.html_footer = "<center><font size=""-2"">generated on " +   \
+                            time.asctime( time.localtime( time.time() ) ) + \
+                           "</font></center>" + html_footer
+
+        self.columns = 3
+
+    def  make_section_url( self, section ):
+        return self.file_prefix + section.name + ".html"
+
+
+    def  make_block_url( self, block ):
+        return self.make_section_url( block.section ) + "#" + block.name
+
+
+    def  make_html_words( self, words ):
+        """ convert a series of simple words into some HTML text """
+        line = ""
+        if words:
+            line = html_quote( words[0] )
+            for w in words[1:]:
+                line = line + " " + html_quote( w )
+
+        return line
+
+
+    def  make_html_word( self, word ):
+        """analyze a simple word to detect cross-references and styling"""
+        # look for cross-references
+        #
+        m = re_crossref.match( word )
+        if m:
+            try:
+                name = m.group(1)
+                rest = m.group(2)
+                block = self.identifiers[ name ]
+                url   = self.make_block_url( block )
+                return '<a href="' + url + '">' + name + '</a>' + rest
+            except:
+                return '?' + name + '?' + rest
+
+        # look for italics and bolds
+        m = re_italic.match( word )
+        if m:
+            name = m.group(1)
+            return '<i>'+name+'</i>'
+
+        m = re_bold.match( word )
+        if m:
+            name = m.group(1)
+            return '<b>'+name+'</b>'
+
+        return html_quote(word)
+
+
+    def  make_html_para( self, words ):
+        """ convert a paragraph's words into tagged HTML text, handle xrefs """
+        line = ""
+        if words:
+            line = self.make_html_word( words[0] )
+            for word in words[1:]:
+                line = line + " " + self.make_html_word( word )
+
+        return "<p>" + line + "</p>"
+
+
+    def  make_html_code( self, lines ):
+        """ convert a code sequence to HTML """
+        line = code_header + '\n'
+        for l in lines:
+            line = line + html_quote( l ) + '\n'
+
+        return line + code_footer
+
+
+    def  make_html_items( self, items ):
+        """ convert a field's content into some valid HTML """
+        lines = []
+        for item in items:
+            if item.lines:
+                lines.append( self.make_html_code( item.lines ) )
+            else:
+                lines.append( self.make_html_para( item.words ) )
+
+        return string.join( lines, '\n' )
+
+
+    def  print_html_items( self, items ):
+        print self.make_html_items( items )
+
+
+    def print_html_field( self, field ):
+        if field.name:
+            print "<table><tr valign=top><td><b>"+field.name+"</b></td><td>"
+
+        print self.make_html_items( field.items )
+
+        if field.name:
+            print "</td></tr></table>"
+
+
+    def html_source_quote( self, line, block_name = None ):
+        result = ""
+        while line:
+            m = re_source_crossref.match( line )
+            if m:
+                name   = m.group(2)
+                prefix = html_quote( m.group(1) )
+                length = len( m.group(0) )
+
+                if name == block_name:
+                    # this is the current block name, if any
+                    result = result + prefix + '<b>' + name + '</b>'
+
+                elif re_source_keywords.match(name):
+                    # this is a C keyword
+                    result = result + prefix + keyword_prefix + name + keyword_suffix
+
+                elif self.identifiers.has_key(name):
+                    # this is a known identifier
+                    block = self.identifiers[name]
+                    result = result + prefix + '<a href="' + \
+                             self.make_block_url(block) + '">' + name + '</a>'
+                else:
+                    result = result + html_quote(line[ : length ])
+
+                line = line[ length : ]
+            else:
+                result = result + html_quote(line)
+                line   = []
+
+        return result
+
+
+    def print_html_field_list( self, fields ):
+        print "<table cellpadding=3>"
+        for field in fields:
+            print "<tr valign=top><td><b>" + field.name + "</b></td><td>"
+            self.print_html_items( field.items )
+            print "</td></tr>"
+        print "</table>"
+
+
+    def print_html_markup( self, markup ):
+        table_fields = []
+        for field in markup.fields:
+            if field.name:
+                # we begin a new series of field or value definitions, we
+                # will record them in the 'table_fields' list before outputting
+                # all of them as a single table
+                #
+                table_fields.append( field )
+
+            else:
+                if table_fields:
+                    self.print_html_field_list( table_fields )
+                    table_fields = []
+
+                self.print_html_items( field.items )
+
+        if table_fields:
+            self.print_html_field_list( table_fields )
+
+    #
+    #  Formatting the index
+    #
+
+    def  index_enter( self ):
+        print self.html_header
+        self.index_items = {}
+
+    def  index_name_enter( self, name ):
+        block = self.identifiers[ name ]
+        url   = self.make_block_url( block )
+        self.index_items[ name ] = url
+
+    def  index_exit( self ):
+
+        # block_index already contains the sorted list of index names
+        count = len( self.block_index )
+        rows  = (count + self.columns - 1)/self.columns
+
+        print "<table align=center border=0 cellpadding=0 cellspacing=0>"
+        for r in range(rows):
+            line = "<tr>"
+            for c in range(self.columns):
+                i = r + c*rows
+                if i < count:
+                    bname = self.block_index[ r + c*rows ]
+                    url   = self.index_items[ bname ]
+                    line = line + '<td><a href="' + url + '">' + bname + '</a></td>'
+                else:
+                    line = line + '<td></td>'
+            line = line + "</tr>"
+            print line
+
+        print "</table>"
+        print self.html_footer
+        self.index_items = {}
+
+    def  index_dump( self, index_filename = None ):
+
+        if index_filename == None:
+            index_filename = self.file_prefix + "index.html"
+
+        Formatter.index_dump( self, index_filename )
+
+    #
+    #  Formatting the table of content
+    #
+    def  toc_enter( self ):
+        print self.html_header
+        print "<center><h1>Table of Contents</h1></center>"
+
+    def  toc_chapter_enter( self, chapter ):
+        print  chapter_header + string.join(chapter.title) + chapter_inter
+        print "<table cellpadding=5>"
+
+    def  toc_section_enter( self, section ):
+        print "<tr valign=top><td>"
+        print '<a href="' + self.make_section_url( section ) + '">' + \
+               section.title + '</a></td><td>'
+
+        print self.make_html_para( section.abstract )
+
+    def  toc_section_exit( self, section ):
+        print "</td></tr>"
+
+    def  toc_chapter_exit( self, chapter ):
+        print "</table>"
+        print  chapter_footer
+
+    def  toc_index( self, index_filename ):
+        print chapter_header + '<a href="' + index_filename + '">Global Index</a>' + chapter_inter + chapter_footer
+
+    def  toc_exit( self ):
+        print self.html_footer
+
+    def  toc_dump( self, toc_filename = None, index_filename = None ):
+        if toc_filename == None:
+            toc_filename = self.file_prefix + "toc.html"
+
+        if index_filename == None:
+            index_filename = self.file_prefix + "index.html"
+
+        Formatter.toc_dump( self, toc_filename, index_filename )
+
+    #
+    #  Formatting sections
+    #
+    def  section_enter( self, section ):
+        print self.html_header
+
+        print section_title_header
+        print section.title
+        print section_title_footer
+
+        # print section synopsys
+        print section_synopsis_header
+        print "<table align=center cellspacing=5 cellpadding=0 border=0>"
+
+        maxwidth = 0
+        for b in section.blocks.values():
+            if len(b.name) > maxwidth:
+                maxwidth = len(b.name)
+
+        width  = 70  # XXX magic number
+        columns = width / maxwidth
+        if columns < 1:
+            columns = 1
+
+        count   = len(section.block_names)
+        rows    = (count + columns-1)/columns
+        for r in range(rows):
+            line = "<tr>"
+            for c in range(columns):
+                i = r + c*rows
+                line = line + '<td></td><td>'
+                if i < count:
+                    name = section.block_names[i]
+                    line = line + '<a href="#' + name + '">' + name + '</a>'
+
+                line = line + '</td>'
+            line = line + "</tr>"
+            print line
+
+        print "</table><br><br>"
+        print section_synopsis_footer
+
+        print description_header
+        print self.make_html_items( section.description )
+        print description_footer
+
+    def  block_enter( self, block ):
+        print block_header
+
+        # place html anchor if needed
+        if block.name:
+            print '<h4><a name="' + block.name + '">' + block.name + '</a></h4>'
+
+        # dump the block C source lines now
+        if block.code:
+            print source_header
+            for l in block.code:
+                print self.html_source_quote( l, block.name )
+            print source_footer
+
+
+    def  markup_enter( self, markup, block ):
+        if markup.tag == "description":
+            print description_header
+        else:
+            print marker_header + markup.tag + marker_inter
+
+        self.print_html_markup( markup )
+
+    def  markup_exit( self, markup, block ):
+        if markup.tag == "description":
+            print description_footer
+        else:
+            print marker_footer
+
+    def  block_exit( self, block ):
+        print block_footer
+
+
+    def  section_exit( self, section ):
+        print html_footer
+
+
+    def section_dump_all( self ):
+        for section in self.sections:
+            self.section_dump( section, self.file_prefix + section.name + '.html' )
+        
diff --git a/nx-X11/extras/freetype2/src/tools/docmaker/utils.py b/nx-X11/extras/freetype2/src/tools/docmaker/utils.py
new file mode 100644
index 000000000..c3e9e2700
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/docmaker/utils.py
@@ -0,0 +1,128 @@
+import string, sys, os, glob
+
+# current output directory
+#
+output_dir = None
+
+
+# This function is used to sort the index.  It is a simple lexicographical
+# sort, except that it places capital letters before lowercase ones.
+#
+def index_sort( s1, s2 ):
+    if not s1:
+        return -1
+
+    if not s2:
+        return 1
+
+    l1 = len( s1 )
+    l2 = len( s2 )
+    m1 = string.lower( s1 )
+    m2 = string.lower( s2 )
+
+    for i in range( l1 ):
+        if i >= l2 or m1[i] > m2[i]:
+            return 1
+
+        if m1[i] < m2[i]:
+            return -1
+
+        if s1[i] < s2[i]:
+            return -1
+
+        if s1[i] > s2[i]:
+            return 1
+
+    if l2 > l1:
+        return -1
+
+    return 0
+
+# Sort input_list, placing the elements of order_list in front.
+#
+def sort_order_list( input_list, order_list ):
+    new_list = order_list[:]
+    for id in input_list:
+        if not id in order_list:
+            new_list.append( id )
+    return new_list
+
+
+
+# Open the standard output to a given project documentation file.  Use
+# "output_dir" to determine the filename location if necessary and save the
+# old stdout in a tuple that is returned by this function.
+#
+def open_output( filename ):
+    global output_dir
+
+    if output_dir and output_dir != "":
+        filename = output_dir + os.sep + filename
+
+    old_stdout = sys.stdout
+    new_file   = open( filename, "w" )
+    sys.stdout = new_file
+
+    return ( new_file, old_stdout )
+
+
+# Close the output that was returned by "close_output".
+#
+def close_output( output ):
+    output[0].close()
+    sys.stdout = output[1]
+
+
+# Check output directory.
+#
+def check_output( ):
+    global output_dir
+    if output_dir:
+        if output_dir != "":
+            if not os.path.isdir( output_dir ):
+                sys.stderr.write( "argument" + " '" + output_dir + "' " +
+                                  "is not a valid directory" )
+                sys.exit( 2 )
+        else:
+            output_dir = None
+
+def file_exists( pathname ):
+    """checks that a given file exists"""
+    result = 1
+    try:
+        file = open( pathname, "r" )
+        file.close()
+    except:
+        result = None
+        sys.stderr.write( pathname + " couldn't be accessed\n" )
+
+    return result
+
+
+def make_file_list( args = None ):
+    """builds a list of input files from command-line arguments"""
+
+    file_list = []
+    # sys.stderr.write( repr( sys.argv[1 :] ) + '\n' )
+
+    if not args:
+        args = sys.argv[1 :]
+
+    for pathname in args:
+        if string.find( pathname, '*' ) >= 0:
+            newpath = glob.glob( pathname )
+            newpath.sort()  # sort files -- this is important because
+                            # of the order of files
+        else:
+            newpath = [pathname]
+            
+        file_list.extend( newpath )
+
+    if len( file_list ) == 0:
+        file_list = None
+    else:
+        # now filter the file list to remove non-existing ones
+        file_list = filter( file_exists, file_list )
+    
+    return file_list
+
diff --git a/nx-X11/extras/freetype2/src/tools/glnames.py b/nx-X11/extras/freetype2/src/tools/glnames.py
new file mode 100644
index 000000000..e8e80ec6c
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/glnames.py
@@ -0,0 +1,4954 @@
+#!/usr/bin/env python
+#
+
+#
+# FreeType 2 glyph name builder
+#
+
+
+# Copyright 1996-2000, 2003 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.
+
+
+"""\
+
+usage: %s <output-file>
+
+  This very simple python script is used to generate the glyph names
+  tables defined in the PSNames module.
+
+  Its single argument is the name of the header file to be created.
+"""
+
+
+import sys, string
+
+
+# This table is used to name the glyphs according to the Macintosh
+# specification.  It is used by the TrueType Postscript names table.
+#
+# See http://fonts.apple.com/TTRefMan/RM06/Chap6post.html
+# for the official list.
+#
+mac_standard_names = \
+[
+  # 0
+  ".notdef", ".null", "nonmarkingreturn", "space", "exclam",
+  "quotedbl", "numbersign", "dollar", "percent", "ampersand",
+
+  # 10
+  "quotesingle", "parenleft", "parenright", "asterisk", "plus",
+  "comma", "hyphen", "period", "slash", "zero",
+
+  # 20
+  "one", "two", "three", "four", "five",
+  "six", "seven", "eight", "nine", "colon",
+
+  # 30
+  "semicolon", "less", "equal", "greater", "question",
+  "at", "A", "B", "C", "D",
+
+  # 40
+  "E", "F", "G", "H", "I",
+  "J", "K", "L", "M", "N",
+
+  # 50
+  "O", "P", "Q", "R", "S",
+  "T", "U", "V", "W", "X",
+
+  # 60
+  "Y", "Z", "bracketleft", "backslash", "bracketright",
+  "asciicircum", "underscore", "grave", "a", "b",
+
+  # 70
+  "c", "d", "e", "f", "g",
+  "h", "i", "j", "k", "l",
+
+  # 80
+  "m", "n", "o", "p", "q",
+  "r", "s", "t", "u", "v",
+
+  # 90
+  "w", "x", "y", "z", "braceleft",
+  "bar", "braceright", "asciitilde", "Adieresis", "Aring",
+
+  # 100
+  "Ccedilla", "Eacute", "Ntilde", "Odieresis", "Udieresis",
+  "aacute", "agrave", "acircumflex", "adieresis", "atilde",
+
+  # 110
+  "aring", "ccedilla", "eacute", "egrave", "ecircumflex",
+  "edieresis", "iacute", "igrave", "icircumflex", "idieresis",
+
+  # 120
+  "ntilde", "oacute", "ograve", "ocircumflex", "odieresis",
+  "otilde", "uacute", "ugrave", "ucircumflex", "udieresis",
+
+  # 130
+  "dagger", "degree", "cent", "sterling", "section",
+  "bullet", "paragraph", "germandbls", "registered", "copyright",
+
+  # 140
+  "trademark", "acute", "dieresis", "notequal", "AE",
+  "Oslash", "infinity", "plusminus", "lessequal", "greaterequal",
+
+  # 150
+  "yen", "mu", "partialdiff", "summation", "product",
+  "pi", "integral", "ordfeminine", "ordmasculine", "Omega",
+
+  # 160
+  "ae", "oslash", "questiondown", "exclamdown", "logicalnot",
+  "radical", "florin", "approxequal", "Delta", "guillemotleft",
+
+  # 170
+  "guillemotright", "ellipsis", "nonbreakingspace", "Agrave", "Atilde",
+  "Otilde", "OE", "oe", "endash", "emdash",
+
+  # 180
+  "quotedblleft", "quotedblright", "quoteleft", "quoteright", "divide",
+  "lozenge", "ydieresis", "Ydieresis", "fraction", "currency",
+
+  # 190
+  "guilsinglleft", "guilsinglright", "fi", "fl", "daggerdbl",
+  "periodcentered", "quotesinglbase", "quotedblbase", "perthousand",
+    "Acircumflex",
+
+  # 200
+  "Ecircumflex", "Aacute", "Edieresis", "Egrave", "Iacute",
+  "Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex",
+
+  # 210
+  "apple", "Ograve", "Uacute", "Ucircumflex", "Ugrave",
+  "dotlessi", "circumflex", "tilde", "macron", "breve",
+
+  # 220
+  "dotaccent", "ring", "cedilla", "hungarumlaut", "ogonek",
+  "caron", "Lslash", "lslash", "Scaron", "scaron",
+
+  # 230
+  "Zcaron", "zcaron", "brokenbar", "Eth", "eth",
+  "Yacute", "yacute", "Thorn", "thorn", "minus",
+
+  # 240
+  "multiply", "onesuperior", "twosuperior", "threesuperior", "onehalf",
+  "onequarter", "threequarters", "franc", "Gbreve", "gbreve",
+
+  # 250
+  "Idotaccent", "Scedilla", "scedilla", "Cacute", "cacute",
+  "Ccaron", "ccaron", "dcroat"
+]
+
+
+# The list of standard "SID" glyph names.  For the official list,
+# see Annex A of document at
+# http://partners.adobe.com/asn/developer/pdfs/tn/5176.CFF.pdf.
+#
+sid_standard_names = \
+[
+  # 0
+  ".notdef", "space", "exclam", "quotedbl", "numbersign",
+  "dollar", "percent", "ampersand", "quoteright", "parenleft",
+
+  # 10
+  "parenright", "asterisk", "plus", "comma", "hyphen",
+  "period", "slash", "zero", "one", "two",
+
+  # 20
+  "three", "four", "five", "six", "seven",
+  "eight", "nine", "colon", "semicolon", "less",
+
+  # 30
+  "equal", "greater", "question", "at", "A",
+  "B", "C", "D", "E", "F",
+
+  # 40
+  "G", "H", "I", "J", "K",
+  "L", "M", "N", "O", "P",
+
+  # 50
+  "Q", "R", "S", "T", "U",
+  "V", "W", "X", "Y", "Z",
+
+  # 60
+  "bracketleft", "backslash", "bracketright", "asciicircum", "underscore",
+  "quoteleft", "a", "b", "c", "d",
+
+  # 70
+  "e", "f", "g", "h", "i",
+  "j", "k", "l", "m", "n",
+
+  # 80
+  "o", "p", "q", "r", "s",
+  "t", "u", "v", "w", "x",
+
+  # 90
+  "y", "z", "braceleft", "bar", "braceright",
+  "asciitilde", "exclamdown", "cent", "sterling", "fraction",
+
+  # 100
+  "yen", "florin", "section", "currency", "quotesingle",
+  "quotedblleft", "guillemotleft", "guilsinglleft", "guilsinglright", "fi",
+
+  # 110
+  "fl", "endash", "dagger", "daggerdbl", "periodcentered",
+  "paragraph", "bullet", "quotesinglbase", "quotedblbase", "quotedblright",
+
+  # 120
+  "guillemotright", "ellipsis", "perthousand", "questiondown", "grave",
+  "acute", "circumflex", "tilde", "macron", "breve",
+
+  # 130
+  "dotaccent", "dieresis", "ring", "cedilla", "hungarumlaut",
+  "ogonek", "caron", "emdash", "AE", "ordfeminine",
+
+  # 140
+  "Lslash", "Oslash", "OE", "ordmasculine", "ae",
+  "dotlessi", "lslash", "oslash", "oe", "germandbls",
+
+  # 150
+  "onesuperior", "logicalnot", "mu", "trademark", "Eth",
+  "onehalf", "plusminus", "Thorn", "onequarter", "divide",
+
+  # 160
+  "brokenbar", "degree", "thorn", "threequarters", "twosuperior",
+  "registered", "minus", "eth", "multiply", "threesuperior",
+
+  # 170
+  "copyright", "Aacute", "Acircumflex", "Adieresis", "Agrave",
+  "Aring", "Atilde", "Ccedilla", "Eacute", "Ecircumflex",
+
+  # 180
+  "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis",
+  "Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis",
+
+  # 190
+  "Ograve", "Otilde", "Scaron", "Uacute", "Ucircumflex",
+  "Udieresis", "Ugrave", "Yacute", "Ydieresis", "Zcaron",
+
+  # 200
+  "aacute", "acircumflex", "adieresis", "agrave", "aring",
+  "atilde", "ccedilla", "eacute", "ecircumflex", "edieresis",
+
+  # 210
+  "egrave", "iacute", "icircumflex", "idieresis", "igrave",
+  "ntilde", "oacute", "ocircumflex", "odieresis", "ograve",
+
+  # 220
+  "otilde", "scaron", "uacute", "ucircumflex", "udieresis",
+  "ugrave", "yacute", "ydieresis", "zcaron", "exclamsmall",
+
+  # 230
+  "Hungarumlautsmall", "dollaroldstyle", "dollarsuperior", "ampersandsmall",
+    "Acutesmall",
+  "parenleftsuperior", "parenrightsuperior", "twodotenleader",
+    "onedotenleader", "zerooldstyle",
+
+  # 240
+  "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle",
+    "fiveoldstyle",
+  "sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle",
+    "commasuperior",
+
+  # 250
+  "threequartersemdash", "periodsuperior", "questionsmall", "asuperior",
+    "bsuperior",
+  "centsuperior", "dsuperior", "esuperior", "isuperior", "lsuperior",
+
+  # 260
+  "msuperior", "nsuperior", "osuperior", "rsuperior", "ssuperior",
+  "tsuperior", "ff", "ffi", "ffl", "parenleftinferior",
+
+  # 270
+  "parenrightinferior", "Circumflexsmall", "hyphensuperior", "Gravesmall",
+    "Asmall",
+  "Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall",
+
+  # 280
+  "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall",
+  "Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall",
+
+  # 290
+  "Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall",
+  "Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall",
+
+  # 300
+  "colonmonetary", "onefitted", "rupiah", "Tildesmall", "exclamdownsmall",
+  "centoldstyle", "Lslashsmall", "Scaronsmall", "Zcaronsmall",
+    "Dieresissmall",
+
+  # 310
+  "Brevesmall", "Caronsmall", "Dotaccentsmall", "Macronsmall", "figuredash",
+  "hypheninferior", "Ogoneksmall", "Ringsmall", "Cedillasmall",
+    "questiondownsmall",
+
+  # 320
+  "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird",
+  "twothirds", "zerosuperior", "foursuperior", "fivesuperior",
+    "sixsuperior",
+
+  # 330
+  "sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior",
+    "oneinferior",
+  "twoinferior", "threeinferior", "fourinferior", "fiveinferior",
+    "sixinferior",
+
+  # 340
+  "seveninferior", "eightinferior", "nineinferior", "centinferior",
+    "dollarinferior",
+  "periodinferior", "commainferior", "Agravesmall", "Aacutesmall",
+    "Acircumflexsmall",
+
+  # 350
+  "Atildesmall", "Adieresissmall", "Aringsmall", "AEsmall", "Ccedillasmall",
+  "Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall",
+    "Igravesmall",
+
+  # 360
+  "Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall",
+    "Ntildesmall",
+  "Ogravesmall", "Oacutesmall", "Ocircumflexsmall", "Otildesmall",
+    "Odieresissmall",
+
+  # 370
+  "OEsmall", "Oslashsmall", "Ugravesmall", "Uacutesmall",
+    "Ucircumflexsmall",
+  "Udieresissmall", "Yacutesmall", "Thornsmall", "Ydieresissmall",
+    "001.000",
+
+  # 380
+  "001.001", "001.002", "001.003", "Black", "Bold",
+  "Book", "Light", "Medium", "Regular", "Roman",
+
+  # 390
+  "Semibold"
+]
+
+
+# This table maps character codes of the Adobe Standard Type 1
+# encoding to glyph indices in the sid_standard_names table.
+#
+t1_standard_encoding = \
+[
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   1,   2,   3,   4,   5,   6,   7,   8,
+    9,  10,  11,  12,  13,  14,  15,  16,  17,  18,
+
+   19,  20,  21,  22,  23,  24,  25,  26,  27,  28,
+   29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
+   39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
+   49,  50,  51,  52,  53,  54,  55,  56,  57,  58,
+   59,  60,  61,  62,  63,  64,  65,  66,  67,  68,
+
+   69,  70,  71,  72,  73,  74,  75,  76,  77,  78,
+   79,  80,  81,  82,  83,  84,  85,  86,  87,  88,
+   89,  90,  91,  92,  93,  94,  95,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,  96,  97,  98,  99, 100, 101, 102, 103, 104,
+  105, 106, 107, 108, 109, 110,   0, 111, 112, 113,
+  114,   0, 115, 116, 117, 118, 119, 120, 121, 122,
+    0, 123,   0, 124, 125, 126, 127, 128, 129, 130,
+
+  131,   0, 132, 133,   0, 134, 135, 136, 137,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0, 138,   0, 139,   0,   0,
+    0,   0, 140, 141, 142, 143,   0,   0,   0,   0,
+    0, 144,   0,   0,   0, 145,   0,   0, 146, 147,
+
+  148, 149,   0,   0,   0,   0
+]
+
+
+# This table maps character codes of the Adobe Expert Type 1
+# encoding to glyph indices in the sid_standard_names table.
+#
+t1_expert_encoding = \
+[
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   1, 229, 230,   0, 231, 232, 233, 234,
+  235, 236, 237, 238,  13,  14,  15,  99, 239, 240,
+
+  241, 242, 243, 244, 245, 246, 247, 248,  27,  28,
+  249, 250, 251, 252,   0, 253, 254, 255, 256, 257,
+    0,   0,   0, 258,   0,   0, 259, 260, 261, 262,
+    0,   0, 263, 264, 265,   0, 266, 109, 110, 267,
+  268, 269,   0, 270, 271, 272, 273, 274, 275, 276,
+
+  277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
+  287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
+  297, 298, 299, 300, 301, 302, 303,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0, 304, 305, 306,   0,   0, 307, 308, 309, 310,
+  311,   0, 312,   0,   0, 313,   0,   0, 314, 315,
+    0,   0, 316, 317, 318,   0,   0,   0, 158, 155,
+  163, 319, 320, 321, 322, 323, 324, 325,   0,   0,
+
+  326, 150, 164, 169, 327, 328, 329, 330, 331, 332,
+  333, 334, 335, 336, 337, 338, 339, 340, 341, 342,
+  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
+  353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
+  363, 364, 365, 366, 367, 368, 369, 370, 371, 372,
+
+  373, 374, 375, 376, 377, 378
+]
+
+
+# This data has been taken literally from the file `glyphlist.txt',
+# version 2.0, 22 Sept 2002.  It is available from
+#
+#   http://partners.adobe.com/asn/developer/typeforum/unicodegn.html
+#
+adobe_glyph_list = """\
+A;0041
+AE;00C6
+AEacute;01FC
+AEmacron;01E2
+AEsmall;F7E6
+Aacute;00C1
+Aacutesmall;F7E1
+Abreve;0102
+Abreveacute;1EAE
+Abrevecyrillic;04D0
+Abrevedotbelow;1EB6
+Abrevegrave;1EB0
+Abrevehookabove;1EB2
+Abrevetilde;1EB4
+Acaron;01CD
+Acircle;24B6
+Acircumflex;00C2
+Acircumflexacute;1EA4
+Acircumflexdotbelow;1EAC
+Acircumflexgrave;1EA6
+Acircumflexhookabove;1EA8
+Acircumflexsmall;F7E2
+Acircumflextilde;1EAA
+Acute;F6C9
+Acutesmall;F7B4
+Acyrillic;0410
+Adblgrave;0200
+Adieresis;00C4
+Adieresiscyrillic;04D2
+Adieresismacron;01DE
+Adieresissmall;F7E4
+Adotbelow;1EA0
+Adotmacron;01E0
+Agrave;00C0
+Agravesmall;F7E0
+Ahookabove;1EA2
+Aiecyrillic;04D4
+Ainvertedbreve;0202
+Alpha;0391
+Alphatonos;0386
+Amacron;0100
+Amonospace;FF21
+Aogonek;0104
+Aring;00C5
+Aringacute;01FA
+Aringbelow;1E00
+Aringsmall;F7E5
+Asmall;F761
+Atilde;00C3
+Atildesmall;F7E3
+Aybarmenian;0531
+B;0042
+Bcircle;24B7
+Bdotaccent;1E02
+Bdotbelow;1E04
+Becyrillic;0411
+Benarmenian;0532
+Beta;0392
+Bhook;0181
+Blinebelow;1E06
+Bmonospace;FF22
+Brevesmall;F6F4
+Bsmall;F762
+Btopbar;0182
+C;0043
+Caarmenian;053E
+Cacute;0106
+Caron;F6CA
+Caronsmall;F6F5
+Ccaron;010C
+Ccedilla;00C7
+Ccedillaacute;1E08
+Ccedillasmall;F7E7
+Ccircle;24B8
+Ccircumflex;0108
+Cdot;010A
+Cdotaccent;010A
+Cedillasmall;F7B8
+Chaarmenian;0549
+Cheabkhasiancyrillic;04BC
+Checyrillic;0427
+Chedescenderabkhasiancyrillic;04BE
+Chedescendercyrillic;04B6
+Chedieresiscyrillic;04F4
+Cheharmenian;0543
+Chekhakassiancyrillic;04CB
+Cheverticalstrokecyrillic;04B8
+Chi;03A7
+Chook;0187
+Circumflexsmall;F6F6
+Cmonospace;FF23
+Coarmenian;0551
+Csmall;F763
+D;0044
+DZ;01F1
+DZcaron;01C4
+Daarmenian;0534
+Dafrican;0189
+Dcaron;010E
+Dcedilla;1E10
+Dcircle;24B9
+Dcircumflexbelow;1E12
+Dcroat;0110
+Ddotaccent;1E0A
+Ddotbelow;1E0C
+Decyrillic;0414
+Deicoptic;03EE
+Delta;2206
+Deltagreek;0394
+Dhook;018A
+Dieresis;F6CB
+DieresisAcute;F6CC
+DieresisGrave;F6CD
+Dieresissmall;F7A8
+Digammagreek;03DC
+Djecyrillic;0402
+Dlinebelow;1E0E
+Dmonospace;FF24
+Dotaccentsmall;F6F7
+Dslash;0110
+Dsmall;F764
+Dtopbar;018B
+Dz;01F2
+Dzcaron;01C5
+Dzeabkhasiancyrillic;04E0
+Dzecyrillic;0405
+Dzhecyrillic;040F
+E;0045
+Eacute;00C9
+Eacutesmall;F7E9
+Ebreve;0114
+Ecaron;011A
+Ecedillabreve;1E1C
+Echarmenian;0535
+Ecircle;24BA
+Ecircumflex;00CA
+Ecircumflexacute;1EBE
+Ecircumflexbelow;1E18
+Ecircumflexdotbelow;1EC6
+Ecircumflexgrave;1EC0
+Ecircumflexhookabove;1EC2
+Ecircumflexsmall;F7EA
+Ecircumflextilde;1EC4
+Ecyrillic;0404
+Edblgrave;0204
+Edieresis;00CB
+Edieresissmall;F7EB
+Edot;0116
+Edotaccent;0116
+Edotbelow;1EB8
+Efcyrillic;0424
+Egrave;00C8
+Egravesmall;F7E8
+Eharmenian;0537
+Ehookabove;1EBA
+Eightroman;2167
+Einvertedbreve;0206
+Eiotifiedcyrillic;0464
+Elcyrillic;041B
+Elevenroman;216A
+Emacron;0112
+Emacronacute;1E16
+Emacrongrave;1E14
+Emcyrillic;041C
+Emonospace;FF25
+Encyrillic;041D
+Endescendercyrillic;04A2
+Eng;014A
+Enghecyrillic;04A4
+Enhookcyrillic;04C7
+Eogonek;0118
+Eopen;0190
+Epsilon;0395
+Epsilontonos;0388
+Ercyrillic;0420
+Ereversed;018E
+Ereversedcyrillic;042D
+Escyrillic;0421
+Esdescendercyrillic;04AA
+Esh;01A9
+Esmall;F765
+Eta;0397
+Etarmenian;0538
+Etatonos;0389
+Eth;00D0
+Ethsmall;F7F0
+Etilde;1EBC
+Etildebelow;1E1A
+Euro;20AC
+Ezh;01B7
+Ezhcaron;01EE
+Ezhreversed;01B8
+F;0046
+Fcircle;24BB
+Fdotaccent;1E1E
+Feharmenian;0556
+Feicoptic;03E4
+Fhook;0191
+Fitacyrillic;0472
+Fiveroman;2164
+Fmonospace;FF26
+Fourroman;2163
+Fsmall;F766
+G;0047
+GBsquare;3387
+Gacute;01F4
+Gamma;0393
+Gammaafrican;0194
+Gangiacoptic;03EA
+Gbreve;011E
+Gcaron;01E6
+Gcedilla;0122
+Gcircle;24BC
+Gcircumflex;011C
+Gcommaaccent;0122
+Gdot;0120
+Gdotaccent;0120
+Gecyrillic;0413
+Ghadarmenian;0542
+Ghemiddlehookcyrillic;0494
+Ghestrokecyrillic;0492
+Gheupturncyrillic;0490
+Ghook;0193
+Gimarmenian;0533
+Gjecyrillic;0403
+Gmacron;1E20
+Gmonospace;FF27
+Grave;F6CE
+Gravesmall;F760
+Gsmall;F767
+Gsmallhook;029B
+Gstroke;01E4
+H;0048
+H18533;25CF
+H18543;25AA
+H18551;25AB
+H22073;25A1
+HPsquare;33CB
+Haabkhasiancyrillic;04A8
+Hadescendercyrillic;04B2
+Hardsigncyrillic;042A
+Hbar;0126
+Hbrevebelow;1E2A
+Hcedilla;1E28
+Hcircle;24BD
+Hcircumflex;0124
+Hdieresis;1E26
+Hdotaccent;1E22
+Hdotbelow;1E24
+Hmonospace;FF28
+Hoarmenian;0540
+Horicoptic;03E8
+Hsmall;F768
+Hungarumlaut;F6CF
+Hungarumlautsmall;F6F8
+Hzsquare;3390
+I;0049
+IAcyrillic;042F
+IJ;0132
+IUcyrillic;042E
+Iacute;00CD
+Iacutesmall;F7ED
+Ibreve;012C
+Icaron;01CF
+Icircle;24BE
+Icircumflex;00CE
+Icircumflexsmall;F7EE
+Icyrillic;0406
+Idblgrave;0208
+Idieresis;00CF
+Idieresisacute;1E2E
+Idieresiscyrillic;04E4
+Idieresissmall;F7EF
+Idot;0130
+Idotaccent;0130
+Idotbelow;1ECA
+Iebrevecyrillic;04D6
+Iecyrillic;0415
+Ifraktur;2111
+Igrave;00CC
+Igravesmall;F7EC
+Ihookabove;1EC8
+Iicyrillic;0418
+Iinvertedbreve;020A
+Iishortcyrillic;0419
+Imacron;012A
+Imacroncyrillic;04E2
+Imonospace;FF29
+Iniarmenian;053B
+Iocyrillic;0401
+Iogonek;012E
+Iota;0399
+Iotaafrican;0196
+Iotadieresis;03AA
+Iotatonos;038A
+Ismall;F769
+Istroke;0197
+Itilde;0128
+Itildebelow;1E2C
+Izhitsacyrillic;0474
+Izhitsadblgravecyrillic;0476
+J;004A
+Jaarmenian;0541
+Jcircle;24BF
+Jcircumflex;0134
+Jecyrillic;0408
+Jheharmenian;054B
+Jmonospace;FF2A
+Jsmall;F76A
+K;004B
+KBsquare;3385
+KKsquare;33CD
+Kabashkircyrillic;04A0
+Kacute;1E30
+Kacyrillic;041A
+Kadescendercyrillic;049A
+Kahookcyrillic;04C3
+Kappa;039A
+Kastrokecyrillic;049E
+Kaverticalstrokecyrillic;049C
+Kcaron;01E8
+Kcedilla;0136
+Kcircle;24C0
+Kcommaaccent;0136
+Kdotbelow;1E32
+Keharmenian;0554
+Kenarmenian;053F
+Khacyrillic;0425
+Kheicoptic;03E6
+Khook;0198
+Kjecyrillic;040C
+Klinebelow;1E34
+Kmonospace;FF2B
+Koppacyrillic;0480
+Koppagreek;03DE
+Ksicyrillic;046E
+Ksmall;F76B
+L;004C
+LJ;01C7
+LL;F6BF
+Lacute;0139
+Lambda;039B
+Lcaron;013D
+Lcedilla;013B
+Lcircle;24C1
+Lcircumflexbelow;1E3C
+Lcommaaccent;013B
+Ldot;013F
+Ldotaccent;013F
+Ldotbelow;1E36
+Ldotbelowmacron;1E38
+Liwnarmenian;053C
+Lj;01C8
+Ljecyrillic;0409
+Llinebelow;1E3A
+Lmonospace;FF2C
+Lslash;0141
+Lslashsmall;F6F9
+Lsmall;F76C
+M;004D
+MBsquare;3386
+Macron;F6D0
+Macronsmall;F7AF
+Macute;1E3E
+Mcircle;24C2
+Mdotaccent;1E40
+Mdotbelow;1E42
+Menarmenian;0544
+Mmonospace;FF2D
+Msmall;F76D
+Mturned;019C
+Mu;039C
+N;004E
+NJ;01CA
+Nacute;0143
+Ncaron;0147
+Ncedilla;0145
+Ncircle;24C3
+Ncircumflexbelow;1E4A
+Ncommaaccent;0145
+Ndotaccent;1E44
+Ndotbelow;1E46
+Nhookleft;019D
+Nineroman;2168
+Nj;01CB
+Njecyrillic;040A
+Nlinebelow;1E48
+Nmonospace;FF2E
+Nowarmenian;0546
+Nsmall;F76E
+Ntilde;00D1
+Ntildesmall;F7F1
+Nu;039D
+O;004F
+OE;0152
+OEsmall;F6FA
+Oacute;00D3
+Oacutesmall;F7F3
+Obarredcyrillic;04E8
+Obarreddieresiscyrillic;04EA
+Obreve;014E
+Ocaron;01D1
+Ocenteredtilde;019F
+Ocircle;24C4
+Ocircumflex;00D4
+Ocircumflexacute;1ED0
+Ocircumflexdotbelow;1ED8
+Ocircumflexgrave;1ED2
+Ocircumflexhookabove;1ED4
+Ocircumflexsmall;F7F4
+Ocircumflextilde;1ED6
+Ocyrillic;041E
+Odblacute;0150
+Odblgrave;020C
+Odieresis;00D6
+Odieresiscyrillic;04E6
+Odieresissmall;F7F6
+Odotbelow;1ECC
+Ogoneksmall;F6FB
+Ograve;00D2
+Ogravesmall;F7F2
+Oharmenian;0555
+Ohm;2126
+Ohookabove;1ECE
+Ohorn;01A0
+Ohornacute;1EDA
+Ohorndotbelow;1EE2
+Ohorngrave;1EDC
+Ohornhookabove;1EDE
+Ohorntilde;1EE0
+Ohungarumlaut;0150
+Oi;01A2
+Oinvertedbreve;020E
+Omacron;014C
+Omacronacute;1E52
+Omacrongrave;1E50
+Omega;2126
+Omegacyrillic;0460
+Omegagreek;03A9
+Omegaroundcyrillic;047A
+Omegatitlocyrillic;047C
+Omegatonos;038F
+Omicron;039F
+Omicrontonos;038C
+Omonospace;FF2F
+Oneroman;2160
+Oogonek;01EA
+Oogonekmacron;01EC
+Oopen;0186
+Oslash;00D8
+Oslashacute;01FE
+Oslashsmall;F7F8
+Osmall;F76F
+Ostrokeacute;01FE
+Otcyrillic;047E
+Otilde;00D5
+Otildeacute;1E4C
+Otildedieresis;1E4E
+Otildesmall;F7F5
+P;0050
+Pacute;1E54
+Pcircle;24C5
+Pdotaccent;1E56
+Pecyrillic;041F
+Peharmenian;054A
+Pemiddlehookcyrillic;04A6
+Phi;03A6
+Phook;01A4
+Pi;03A0
+Piwrarmenian;0553
+Pmonospace;FF30
+Psi;03A8
+Psicyrillic;0470
+Psmall;F770
+Q;0051
+Qcircle;24C6
+Qmonospace;FF31
+Qsmall;F771
+R;0052
+Raarmenian;054C
+Racute;0154
+Rcaron;0158
+Rcedilla;0156
+Rcircle;24C7
+Rcommaaccent;0156
+Rdblgrave;0210
+Rdotaccent;1E58
+Rdotbelow;1E5A
+Rdotbelowmacron;1E5C
+Reharmenian;0550
+Rfraktur;211C
+Rho;03A1
+Ringsmall;F6FC
+Rinvertedbreve;0212
+Rlinebelow;1E5E
+Rmonospace;FF32
+Rsmall;F772
+Rsmallinverted;0281
+Rsmallinvertedsuperior;02B6
+S;0053
+SF010000;250C
+SF020000;2514
+SF030000;2510
+SF040000;2518
+SF050000;253C
+SF060000;252C
+SF070000;2534
+SF080000;251C
+SF090000;2524
+SF100000;2500
+SF110000;2502
+SF190000;2561
+SF200000;2562
+SF210000;2556
+SF220000;2555
+SF230000;2563
+SF240000;2551
+SF250000;2557
+SF260000;255D
+SF270000;255C
+SF280000;255B
+SF360000;255E
+SF370000;255F
+SF380000;255A
+SF390000;2554
+SF400000;2569
+SF410000;2566
+SF420000;2560
+SF430000;2550
+SF440000;256C
+SF450000;2567
+SF460000;2568
+SF470000;2564
+SF480000;2565
+SF490000;2559
+SF500000;2558
+SF510000;2552
+SF520000;2553
+SF530000;256B
+SF540000;256A
+Sacute;015A
+Sacutedotaccent;1E64
+Sampigreek;03E0
+Scaron;0160
+Scarondotaccent;1E66
+Scaronsmall;F6FD
+Scedilla;015E
+Schwa;018F
+Schwacyrillic;04D8
+Schwadieresiscyrillic;04DA
+Scircle;24C8
+Scircumflex;015C
+Scommaaccent;0218
+Sdotaccent;1E60
+Sdotbelow;1E62
+Sdotbelowdotaccent;1E68
+Seharmenian;054D
+Sevenroman;2166
+Shaarmenian;0547
+Shacyrillic;0428
+Shchacyrillic;0429
+Sheicoptic;03E2
+Shhacyrillic;04BA
+Shimacoptic;03EC
+Sigma;03A3
+Sixroman;2165
+Smonospace;FF33
+Softsigncyrillic;042C
+Ssmall;F773
+Stigmagreek;03DA
+T;0054
+Tau;03A4
+Tbar;0166
+Tcaron;0164
+Tcedilla;0162
+Tcircle;24C9
+Tcircumflexbelow;1E70
+Tcommaaccent;0162
+Tdotaccent;1E6A
+Tdotbelow;1E6C
+Tecyrillic;0422
+Tedescendercyrillic;04AC
+Tenroman;2169
+Tetsecyrillic;04B4
+Theta;0398
+Thook;01AC
+Thorn;00DE
+Thornsmall;F7FE
+Threeroman;2162
+Tildesmall;F6FE
+Tiwnarmenian;054F
+Tlinebelow;1E6E
+Tmonospace;FF34
+Toarmenian;0539
+Tonefive;01BC
+Tonesix;0184
+Tonetwo;01A7
+Tretroflexhook;01AE
+Tsecyrillic;0426
+Tshecyrillic;040B
+Tsmall;F774
+Twelveroman;216B
+Tworoman;2161
+U;0055
+Uacute;00DA
+Uacutesmall;F7FA
+Ubreve;016C
+Ucaron;01D3
+Ucircle;24CA
+Ucircumflex;00DB
+Ucircumflexbelow;1E76
+Ucircumflexsmall;F7FB
+Ucyrillic;0423
+Udblacute;0170
+Udblgrave;0214
+Udieresis;00DC
+Udieresisacute;01D7
+Udieresisbelow;1E72
+Udieresiscaron;01D9
+Udieresiscyrillic;04F0
+Udieresisgrave;01DB
+Udieresismacron;01D5
+Udieresissmall;F7FC
+Udotbelow;1EE4
+Ugrave;00D9
+Ugravesmall;F7F9
+Uhookabove;1EE6
+Uhorn;01AF
+Uhornacute;1EE8
+Uhorndotbelow;1EF0
+Uhorngrave;1EEA
+Uhornhookabove;1EEC
+Uhorntilde;1EEE
+Uhungarumlaut;0170
+Uhungarumlautcyrillic;04F2
+Uinvertedbreve;0216
+Ukcyrillic;0478
+Umacron;016A
+Umacroncyrillic;04EE
+Umacrondieresis;1E7A
+Umonospace;FF35
+Uogonek;0172
+Upsilon;03A5
+Upsilon1;03D2
+Upsilonacutehooksymbolgreek;03D3
+Upsilonafrican;01B1
+Upsilondieresis;03AB
+Upsilondieresishooksymbolgreek;03D4
+Upsilonhooksymbol;03D2
+Upsilontonos;038E
+Uring;016E
+Ushortcyrillic;040E
+Usmall;F775
+Ustraightcyrillic;04AE
+Ustraightstrokecyrillic;04B0
+Utilde;0168
+Utildeacute;1E78
+Utildebelow;1E74
+V;0056
+Vcircle;24CB
+Vdotbelow;1E7E
+Vecyrillic;0412
+Vewarmenian;054E
+Vhook;01B2
+Vmonospace;FF36
+Voarmenian;0548
+Vsmall;F776
+Vtilde;1E7C
+W;0057
+Wacute;1E82
+Wcircle;24CC
+Wcircumflex;0174
+Wdieresis;1E84
+Wdotaccent;1E86
+Wdotbelow;1E88
+Wgrave;1E80
+Wmonospace;FF37
+Wsmall;F777
+X;0058
+Xcircle;24CD
+Xdieresis;1E8C
+Xdotaccent;1E8A
+Xeharmenian;053D
+Xi;039E
+Xmonospace;FF38
+Xsmall;F778
+Y;0059
+Yacute;00DD
+Yacutesmall;F7FD
+Yatcyrillic;0462
+Ycircle;24CE
+Ycircumflex;0176
+Ydieresis;0178
+Ydieresissmall;F7FF
+Ydotaccent;1E8E
+Ydotbelow;1EF4
+Yericyrillic;042B
+Yerudieresiscyrillic;04F8
+Ygrave;1EF2
+Yhook;01B3
+Yhookabove;1EF6
+Yiarmenian;0545
+Yicyrillic;0407
+Yiwnarmenian;0552
+Ymonospace;FF39
+Ysmall;F779
+Ytilde;1EF8
+Yusbigcyrillic;046A
+Yusbigiotifiedcyrillic;046C
+Yuslittlecyrillic;0466
+Yuslittleiotifiedcyrillic;0468
+Z;005A
+Zaarmenian;0536
+Zacute;0179
+Zcaron;017D
+Zcaronsmall;F6FF
+Zcircle;24CF
+Zcircumflex;1E90
+Zdot;017B
+Zdotaccent;017B
+Zdotbelow;1E92
+Zecyrillic;0417
+Zedescendercyrillic;0498
+Zedieresiscyrillic;04DE
+Zeta;0396
+Zhearmenian;053A
+Zhebrevecyrillic;04C1
+Zhecyrillic;0416
+Zhedescendercyrillic;0496
+Zhedieresiscyrillic;04DC
+Zlinebelow;1E94
+Zmonospace;FF3A
+Zsmall;F77A
+Zstroke;01B5
+a;0061
+aabengali;0986
+aacute;00E1
+aadeva;0906
+aagujarati;0A86
+aagurmukhi;0A06
+aamatragurmukhi;0A3E
+aarusquare;3303
+aavowelsignbengali;09BE
+aavowelsigndeva;093E
+aavowelsigngujarati;0ABE
+abbreviationmarkarmenian;055F
+abbreviationsigndeva;0970
+abengali;0985
+abopomofo;311A
+abreve;0103
+abreveacute;1EAF
+abrevecyrillic;04D1
+abrevedotbelow;1EB7
+abrevegrave;1EB1
+abrevehookabove;1EB3
+abrevetilde;1EB5
+acaron;01CE
+acircle;24D0
+acircumflex;00E2
+acircumflexacute;1EA5
+acircumflexdotbelow;1EAD
+acircumflexgrave;1EA7
+acircumflexhookabove;1EA9
+acircumflextilde;1EAB
+acute;00B4
+acutebelowcmb;0317
+acutecmb;0301
+acutecomb;0301
+acutedeva;0954
+acutelowmod;02CF
+acutetonecmb;0341
+acyrillic;0430
+adblgrave;0201
+addakgurmukhi;0A71
+adeva;0905
+adieresis;00E4
+adieresiscyrillic;04D3
+adieresismacron;01DF
+adotbelow;1EA1
+adotmacron;01E1
+ae;00E6
+aeacute;01FD
+aekorean;3150
+aemacron;01E3
+afii00208;2015
+afii08941;20A4
+afii10017;0410
+afii10018;0411
+afii10019;0412
+afii10020;0413
+afii10021;0414
+afii10022;0415
+afii10023;0401
+afii10024;0416
+afii10025;0417
+afii10026;0418
+afii10027;0419
+afii10028;041A
+afii10029;041B
+afii10030;041C
+afii10031;041D
+afii10032;041E
+afii10033;041F
+afii10034;0420
+afii10035;0421
+afii10036;0422
+afii10037;0423
+afii10038;0424
+afii10039;0425
+afii10040;0426
+afii10041;0427
+afii10042;0428
+afii10043;0429
+afii10044;042A
+afii10045;042B
+afii10046;042C
+afii10047;042D
+afii10048;042E
+afii10049;042F
+afii10050;0490
+afii10051;0402
+afii10052;0403
+afii10053;0404
+afii10054;0405
+afii10055;0406
+afii10056;0407
+afii10057;0408
+afii10058;0409
+afii10059;040A
+afii10060;040B
+afii10061;040C
+afii10062;040E
+afii10063;F6C4
+afii10064;F6C5
+afii10065;0430
+afii10066;0431
+afii10067;0432
+afii10068;0433
+afii10069;0434
+afii10070;0435
+afii10071;0451
+afii10072;0436
+afii10073;0437
+afii10074;0438
+afii10075;0439
+afii10076;043A
+afii10077;043B
+afii10078;043C
+afii10079;043D
+afii10080;043E
+afii10081;043F
+afii10082;0440
+afii10083;0441
+afii10084;0442
+afii10085;0443
+afii10086;0444
+afii10087;0445
+afii10088;0446
+afii10089;0447
+afii10090;0448
+afii10091;0449
+afii10092;044A
+afii10093;044B
+afii10094;044C
+afii10095;044D
+afii10096;044E
+afii10097;044F
+afii10098;0491
+afii10099;0452
+afii10100;0453
+afii10101;0454
+afii10102;0455
+afii10103;0456
+afii10104;0457
+afii10105;0458
+afii10106;0459
+afii10107;045A
+afii10108;045B
+afii10109;045C
+afii10110;045E
+afii10145;040F
+afii10146;0462
+afii10147;0472
+afii10148;0474
+afii10192;F6C6
+afii10193;045F
+afii10194;0463
+afii10195;0473
+afii10196;0475
+afii10831;F6C7
+afii10832;F6C8
+afii10846;04D9
+afii299;200E
+afii300;200F
+afii301;200D
+afii57381;066A
+afii57388;060C
+afii57392;0660
+afii57393;0661
+afii57394;0662
+afii57395;0663
+afii57396;0664
+afii57397;0665
+afii57398;0666
+afii57399;0667
+afii57400;0668
+afii57401;0669
+afii57403;061B
+afii57407;061F
+afii57409;0621
+afii57410;0622
+afii57411;0623
+afii57412;0624
+afii57413;0625
+afii57414;0626
+afii57415;0627
+afii57416;0628
+afii57417;0629
+afii57418;062A
+afii57419;062B
+afii57420;062C
+afii57421;062D
+afii57422;062E
+afii57423;062F
+afii57424;0630
+afii57425;0631
+afii57426;0632
+afii57427;0633
+afii57428;0634
+afii57429;0635
+afii57430;0636
+afii57431;0637
+afii57432;0638
+afii57433;0639
+afii57434;063A
+afii57440;0640
+afii57441;0641
+afii57442;0642
+afii57443;0643
+afii57444;0644
+afii57445;0645
+afii57446;0646
+afii57448;0648
+afii57449;0649
+afii57450;064A
+afii57451;064B
+afii57452;064C
+afii57453;064D
+afii57454;064E
+afii57455;064F
+afii57456;0650
+afii57457;0651
+afii57458;0652
+afii57470;0647
+afii57505;06A4
+afii57506;067E
+afii57507;0686
+afii57508;0698
+afii57509;06AF
+afii57511;0679
+afii57512;0688
+afii57513;0691
+afii57514;06BA
+afii57519;06D2
+afii57534;06D5
+afii57636;20AA
+afii57645;05BE
+afii57658;05C3
+afii57664;05D0
+afii57665;05D1
+afii57666;05D2
+afii57667;05D3
+afii57668;05D4
+afii57669;05D5
+afii57670;05D6
+afii57671;05D7
+afii57672;05D8
+afii57673;05D9
+afii57674;05DA
+afii57675;05DB
+afii57676;05DC
+afii57677;05DD
+afii57678;05DE
+afii57679;05DF
+afii57680;05E0
+afii57681;05E1
+afii57682;05E2
+afii57683;05E3
+afii57684;05E4
+afii57685;05E5
+afii57686;05E6
+afii57687;05E7
+afii57688;05E8
+afii57689;05E9
+afii57690;05EA
+afii57694;FB2A
+afii57695;FB2B
+afii57700;FB4B
+afii57705;FB1F
+afii57716;05F0
+afii57717;05F1
+afii57718;05F2
+afii57723;FB35
+afii57793;05B4
+afii57794;05B5
+afii57795;05B6
+afii57796;05BB
+afii57797;05B8
+afii57798;05B7
+afii57799;05B0
+afii57800;05B2
+afii57801;05B1
+afii57802;05B3
+afii57803;05C2
+afii57804;05C1
+afii57806;05B9
+afii57807;05BC
+afii57839;05BD
+afii57841;05BF
+afii57842;05C0
+afii57929;02BC
+afii61248;2105
+afii61289;2113
+afii61352;2116
+afii61573;202C
+afii61574;202D
+afii61575;202E
+afii61664;200C
+afii63167;066D
+afii64937;02BD
+agrave;00E0
+agujarati;0A85
+agurmukhi;0A05
+ahiragana;3042
+ahookabove;1EA3
+aibengali;0990
+aibopomofo;311E
+aideva;0910
+aiecyrillic;04D5
+aigujarati;0A90
+aigurmukhi;0A10
+aimatragurmukhi;0A48
+ainarabic;0639
+ainfinalarabic;FECA
+aininitialarabic;FECB
+ainmedialarabic;FECC
+ainvertedbreve;0203
+aivowelsignbengali;09C8
+aivowelsigndeva;0948
+aivowelsigngujarati;0AC8
+akatakana;30A2
+akatakanahalfwidth;FF71
+akorean;314F
+alef;05D0
+alefarabic;0627
+alefdageshhebrew;FB30
+aleffinalarabic;FE8E
+alefhamzaabovearabic;0623
+alefhamzaabovefinalarabic;FE84
+alefhamzabelowarabic;0625
+alefhamzabelowfinalarabic;FE88
+alefhebrew;05D0
+aleflamedhebrew;FB4F
+alefmaddaabovearabic;0622
+alefmaddaabovefinalarabic;FE82
+alefmaksuraarabic;0649
+alefmaksurafinalarabic;FEF0
+alefmaksurainitialarabic;FEF3
+alefmaksuramedialarabic;FEF4
+alefpatahhebrew;FB2E
+alefqamatshebrew;FB2F
+aleph;2135
+allequal;224C
+alpha;03B1
+alphatonos;03AC
+amacron;0101
+amonospace;FF41
+ampersand;0026
+ampersandmonospace;FF06
+ampersandsmall;F726
+amsquare;33C2
+anbopomofo;3122
+angbopomofo;3124
+angkhankhuthai;0E5A
+angle;2220
+anglebracketleft;3008
+anglebracketleftvertical;FE3F
+anglebracketright;3009
+anglebracketrightvertical;FE40
+angleleft;2329
+angleright;232A
+angstrom;212B
+anoteleia;0387
+anudattadeva;0952
+anusvarabengali;0982
+anusvaradeva;0902
+anusvaragujarati;0A82
+aogonek;0105
+apaatosquare;3300
+aparen;249C
+apostrophearmenian;055A
+apostrophemod;02BC
+apple;F8FF
+approaches;2250
+approxequal;2248
+approxequalorimage;2252
+approximatelyequal;2245
+araeaekorean;318E
+araeakorean;318D
+arc;2312
+arighthalfring;1E9A
+aring;00E5
+aringacute;01FB
+aringbelow;1E01
+arrowboth;2194
+arrowdashdown;21E3
+arrowdashleft;21E0
+arrowdashright;21E2
+arrowdashup;21E1
+arrowdblboth;21D4
+arrowdbldown;21D3
+arrowdblleft;21D0
+arrowdblright;21D2
+arrowdblup;21D1
+arrowdown;2193
+arrowdownleft;2199
+arrowdownright;2198
+arrowdownwhite;21E9
+arrowheaddownmod;02C5
+arrowheadleftmod;02C2
+arrowheadrightmod;02C3
+arrowheadupmod;02C4
+arrowhorizex;F8E7
+arrowleft;2190
+arrowleftdbl;21D0
+arrowleftdblstroke;21CD
+arrowleftoverright;21C6
+arrowleftwhite;21E6
+arrowright;2192
+arrowrightdblstroke;21CF
+arrowrightheavy;279E
+arrowrightoverleft;21C4
+arrowrightwhite;21E8
+arrowtableft;21E4
+arrowtabright;21E5
+arrowup;2191
+arrowupdn;2195
+arrowupdnbse;21A8
+arrowupdownbase;21A8
+arrowupleft;2196
+arrowupleftofdown;21C5
+arrowupright;2197
+arrowupwhite;21E7
+arrowvertex;F8E6
+asciicircum;005E
+asciicircummonospace;FF3E
+asciitilde;007E
+asciitildemonospace;FF5E
+ascript;0251
+ascriptturned;0252
+asmallhiragana;3041
+asmallkatakana;30A1
+asmallkatakanahalfwidth;FF67
+asterisk;002A
+asteriskaltonearabic;066D
+asteriskarabic;066D
+asteriskmath;2217
+asteriskmonospace;FF0A
+asterisksmall;FE61
+asterism;2042
+asuperior;F6E9
+asymptoticallyequal;2243
+at;0040
+atilde;00E3
+atmonospace;FF20
+atsmall;FE6B
+aturned;0250
+aubengali;0994
+aubopomofo;3120
+audeva;0914
+augujarati;0A94
+augurmukhi;0A14
+aulengthmarkbengali;09D7
+aumatragurmukhi;0A4C
+auvowelsignbengali;09CC
+auvowelsigndeva;094C
+auvowelsigngujarati;0ACC
+avagrahadeva;093D
+aybarmenian;0561
+ayin;05E2
+ayinaltonehebrew;FB20
+ayinhebrew;05E2
+b;0062
+babengali;09AC
+backslash;005C
+backslashmonospace;FF3C
+badeva;092C
+bagujarati;0AAC
+bagurmukhi;0A2C
+bahiragana;3070
+bahtthai;0E3F
+bakatakana;30D0
+bar;007C
+barmonospace;FF5C
+bbopomofo;3105
+bcircle;24D1
+bdotaccent;1E03
+bdotbelow;1E05
+beamedsixteenthnotes;266C
+because;2235
+becyrillic;0431
+beharabic;0628
+behfinalarabic;FE90
+behinitialarabic;FE91
+behiragana;3079
+behmedialarabic;FE92
+behmeeminitialarabic;FC9F
+behmeemisolatedarabic;FC08
+behnoonfinalarabic;FC6D
+bekatakana;30D9
+benarmenian;0562
+bet;05D1
+beta;03B2
+betasymbolgreek;03D0
+betdagesh;FB31
+betdageshhebrew;FB31
+bethebrew;05D1
+betrafehebrew;FB4C
+bhabengali;09AD
+bhadeva;092D
+bhagujarati;0AAD
+bhagurmukhi;0A2D
+bhook;0253
+bihiragana;3073
+bikatakana;30D3
+bilabialclick;0298
+bindigurmukhi;0A02
+birusquare;3331
+blackcircle;25CF
+blackdiamond;25C6
+blackdownpointingtriangle;25BC
+blackleftpointingpointer;25C4
+blackleftpointingtriangle;25C0
+blacklenticularbracketleft;3010
+blacklenticularbracketleftvertical;FE3B
+blacklenticularbracketright;3011
+blacklenticularbracketrightvertical;FE3C
+blacklowerlefttriangle;25E3
+blacklowerrighttriangle;25E2
+blackrectangle;25AC
+blackrightpointingpointer;25BA
+blackrightpointingtriangle;25B6
+blacksmallsquare;25AA
+blacksmilingface;263B
+blacksquare;25A0
+blackstar;2605
+blackupperlefttriangle;25E4
+blackupperrighttriangle;25E5
+blackuppointingsmalltriangle;25B4
+blackuppointingtriangle;25B2
+blank;2423
+blinebelow;1E07
+block;2588
+bmonospace;FF42
+bobaimaithai;0E1A
+bohiragana;307C
+bokatakana;30DC
+bparen;249D
+bqsquare;33C3
+braceex;F8F4
+braceleft;007B
+braceleftbt;F8F3
+braceleftmid;F8F2
+braceleftmonospace;FF5B
+braceleftsmall;FE5B
+bracelefttp;F8F1
+braceleftvertical;FE37
+braceright;007D
+bracerightbt;F8FE
+bracerightmid;F8FD
+bracerightmonospace;FF5D
+bracerightsmall;FE5C
+bracerighttp;F8FC
+bracerightvertical;FE38
+bracketleft;005B
+bracketleftbt;F8F0
+bracketleftex;F8EF
+bracketleftmonospace;FF3B
+bracketlefttp;F8EE
+bracketright;005D
+bracketrightbt;F8FB
+bracketrightex;F8FA
+bracketrightmonospace;FF3D
+bracketrighttp;F8F9
+breve;02D8
+brevebelowcmb;032E
+brevecmb;0306
+breveinvertedbelowcmb;032F
+breveinvertedcmb;0311
+breveinverteddoublecmb;0361
+bridgebelowcmb;032A
+bridgeinvertedbelowcmb;033A
+brokenbar;00A6
+bstroke;0180
+bsuperior;F6EA
+btopbar;0183
+buhiragana;3076
+bukatakana;30D6
+bullet;2022
+bulletinverse;25D8
+bulletoperator;2219
+bullseye;25CE
+c;0063
+caarmenian;056E
+cabengali;099A
+cacute;0107
+cadeva;091A
+cagujarati;0A9A
+cagurmukhi;0A1A
+calsquare;3388
+candrabindubengali;0981
+candrabinducmb;0310
+candrabindudeva;0901
+candrabindugujarati;0A81
+capslock;21EA
+careof;2105
+caron;02C7
+caronbelowcmb;032C
+caroncmb;030C
+carriagereturn;21B5
+cbopomofo;3118
+ccaron;010D
+ccedilla;00E7
+ccedillaacute;1E09
+ccircle;24D2
+ccircumflex;0109
+ccurl;0255
+cdot;010B
+cdotaccent;010B
+cdsquare;33C5
+cedilla;00B8
+cedillacmb;0327
+cent;00A2
+centigrade;2103
+centinferior;F6DF
+centmonospace;FFE0
+centoldstyle;F7A2
+centsuperior;F6E0
+chaarmenian;0579
+chabengali;099B
+chadeva;091B
+chagujarati;0A9B
+chagurmukhi;0A1B
+chbopomofo;3114
+cheabkhasiancyrillic;04BD
+checkmark;2713
+checyrillic;0447
+chedescenderabkhasiancyrillic;04BF
+chedescendercyrillic;04B7
+chedieresiscyrillic;04F5
+cheharmenian;0573
+chekhakassiancyrillic;04CC
+cheverticalstrokecyrillic;04B9
+chi;03C7
+chieuchacirclekorean;3277
+chieuchaparenkorean;3217
+chieuchcirclekorean;3269
+chieuchkorean;314A
+chieuchparenkorean;3209
+chochangthai;0E0A
+chochanthai;0E08
+chochingthai;0E09
+chochoethai;0E0C
+chook;0188
+cieucacirclekorean;3276
+cieucaparenkorean;3216
+cieuccirclekorean;3268
+cieuckorean;3148
+cieucparenkorean;3208
+cieucuparenkorean;321C
+circle;25CB
+circlemultiply;2297
+circleot;2299
+circleplus;2295
+circlepostalmark;3036
+circlewithlefthalfblack;25D0
+circlewithrighthalfblack;25D1
+circumflex;02C6
+circumflexbelowcmb;032D
+circumflexcmb;0302
+clear;2327
+clickalveolar;01C2
+clickdental;01C0
+clicklateral;01C1
+clickretroflex;01C3
+club;2663
+clubsuitblack;2663
+clubsuitwhite;2667
+cmcubedsquare;33A4
+cmonospace;FF43
+cmsquaredsquare;33A0
+coarmenian;0581
+colon;003A
+colonmonetary;20A1
+colonmonospace;FF1A
+colonsign;20A1
+colonsmall;FE55
+colontriangularhalfmod;02D1
+colontriangularmod;02D0
+comma;002C
+commaabovecmb;0313
+commaaboverightcmb;0315
+commaaccent;F6C3
+commaarabic;060C
+commaarmenian;055D
+commainferior;F6E1
+commamonospace;FF0C
+commareversedabovecmb;0314
+commareversedmod;02BD
+commasmall;FE50
+commasuperior;F6E2
+commaturnedabovecmb;0312
+commaturnedmod;02BB
+compass;263C
+congruent;2245
+contourintegral;222E
+control;2303
+controlACK;0006
+controlBEL;0007
+controlBS;0008
+controlCAN;0018
+controlCR;000D
+controlDC1;0011
+controlDC2;0012
+controlDC3;0013
+controlDC4;0014
+controlDEL;007F
+controlDLE;0010
+controlEM;0019
+controlENQ;0005
+controlEOT;0004
+controlESC;001B
+controlETB;0017
+controlETX;0003
+controlFF;000C
+controlFS;001C
+controlGS;001D
+controlHT;0009
+controlLF;000A
+controlNAK;0015
+controlRS;001E
+controlSI;000F
+controlSO;000E
+controlSOT;0002
+controlSTX;0001
+controlSUB;001A
+controlSYN;0016
+controlUS;001F
+controlVT;000B
+copyright;00A9
+copyrightsans;F8E9
+copyrightserif;F6D9
+cornerbracketleft;300C
+cornerbracketlefthalfwidth;FF62
+cornerbracketleftvertical;FE41
+cornerbracketright;300D
+cornerbracketrighthalfwidth;FF63
+cornerbracketrightvertical;FE42
+corporationsquare;337F
+cosquare;33C7
+coverkgsquare;33C6
+cparen;249E
+cruzeiro;20A2
+cstretched;0297
+curlyand;22CF
+curlyor;22CE
+currency;00A4
+cyrBreve;F6D1
+cyrFlex;F6D2
+cyrbreve;F6D4
+cyrflex;F6D5
+d;0064
+daarmenian;0564
+dabengali;09A6
+dadarabic;0636
+dadeva;0926
+dadfinalarabic;FEBE
+dadinitialarabic;FEBF
+dadmedialarabic;FEC0
+dagesh;05BC
+dageshhebrew;05BC
+dagger;2020
+daggerdbl;2021
+dagujarati;0AA6
+dagurmukhi;0A26
+dahiragana;3060
+dakatakana;30C0
+dalarabic;062F
+dalet;05D3
+daletdagesh;FB33
+daletdageshhebrew;FB33
+dalethatafpatah;05D3 05B2
+dalethatafpatahhebrew;05D3 05B2
+dalethatafsegol;05D3 05B1
+dalethatafsegolhebrew;05D3 05B1
+dalethebrew;05D3
+dalethiriq;05D3 05B4
+dalethiriqhebrew;05D3 05B4
+daletholam;05D3 05B9
+daletholamhebrew;05D3 05B9
+daletpatah;05D3 05B7
+daletpatahhebrew;05D3 05B7
+daletqamats;05D3 05B8
+daletqamatshebrew;05D3 05B8
+daletqubuts;05D3 05BB
+daletqubutshebrew;05D3 05BB
+daletsegol;05D3 05B6
+daletsegolhebrew;05D3 05B6
+daletsheva;05D3 05B0
+daletshevahebrew;05D3 05B0
+dalettsere;05D3 05B5
+dalettserehebrew;05D3 05B5
+dalfinalarabic;FEAA
+dammaarabic;064F
+dammalowarabic;064F
+dammatanaltonearabic;064C
+dammatanarabic;064C
+danda;0964
+dargahebrew;05A7
+dargalefthebrew;05A7
+dasiapneumatacyrilliccmb;0485
+dblGrave;F6D3
+dblanglebracketleft;300A
+dblanglebracketleftvertical;FE3D
+dblanglebracketright;300B
+dblanglebracketrightvertical;FE3E
+dblarchinvertedbelowcmb;032B
+dblarrowleft;21D4
+dblarrowright;21D2
+dbldanda;0965
+dblgrave;F6D6
+dblgravecmb;030F
+dblintegral;222C
+dbllowline;2017
+dbllowlinecmb;0333
+dbloverlinecmb;033F
+dblprimemod;02BA
+dblverticalbar;2016
+dblverticallineabovecmb;030E
+dbopomofo;3109
+dbsquare;33C8
+dcaron;010F
+dcedilla;1E11
+dcircle;24D3
+dcircumflexbelow;1E13
+dcroat;0111
+ddabengali;09A1
+ddadeva;0921
+ddagujarati;0AA1
+ddagurmukhi;0A21
+ddalarabic;0688
+ddalfinalarabic;FB89
+dddhadeva;095C
+ddhabengali;09A2
+ddhadeva;0922
+ddhagujarati;0AA2
+ddhagurmukhi;0A22
+ddotaccent;1E0B
+ddotbelow;1E0D
+decimalseparatorarabic;066B
+decimalseparatorpersian;066B
+decyrillic;0434
+degree;00B0
+dehihebrew;05AD
+dehiragana;3067
+deicoptic;03EF
+dekatakana;30C7
+deleteleft;232B
+deleteright;2326
+delta;03B4
+deltaturned;018D
+denominatorminusonenumeratorbengali;09F8
+dezh;02A4
+dhabengali;09A7
+dhadeva;0927
+dhagujarati;0AA7
+dhagurmukhi;0A27
+dhook;0257
+dialytikatonos;0385
+dialytikatonoscmb;0344
+diamond;2666
+diamondsuitwhite;2662
+dieresis;00A8
+dieresisacute;F6D7
+dieresisbelowcmb;0324
+dieresiscmb;0308
+dieresisgrave;F6D8
+dieresistonos;0385
+dihiragana;3062
+dikatakana;30C2
+dittomark;3003
+divide;00F7
+divides;2223
+divisionslash;2215
+djecyrillic;0452
+dkshade;2593
+dlinebelow;1E0F
+dlsquare;3397
+dmacron;0111
+dmonospace;FF44
+dnblock;2584
+dochadathai;0E0E
+dodekthai;0E14
+dohiragana;3069
+dokatakana;30C9
+dollar;0024
+dollarinferior;F6E3
+dollarmonospace;FF04
+dollaroldstyle;F724
+dollarsmall;FE69
+dollarsuperior;F6E4
+dong;20AB
+dorusquare;3326
+dotaccent;02D9
+dotaccentcmb;0307
+dotbelowcmb;0323
+dotbelowcomb;0323
+dotkatakana;30FB
+dotlessi;0131
+dotlessj;F6BE
+dotlessjstrokehook;0284
+dotmath;22C5
+dottedcircle;25CC
+doubleyodpatah;FB1F
+doubleyodpatahhebrew;FB1F
+downtackbelowcmb;031E
+downtackmod;02D5
+dparen;249F
+dsuperior;F6EB
+dtail;0256
+dtopbar;018C
+duhiragana;3065
+dukatakana;30C5
+dz;01F3
+dzaltone;02A3
+dzcaron;01C6
+dzcurl;02A5
+dzeabkhasiancyrillic;04E1
+dzecyrillic;0455
+dzhecyrillic;045F
+e;0065
+eacute;00E9
+earth;2641
+ebengali;098F
+ebopomofo;311C
+ebreve;0115
+ecandradeva;090D
+ecandragujarati;0A8D
+ecandravowelsigndeva;0945
+ecandravowelsigngujarati;0AC5
+ecaron;011B
+ecedillabreve;1E1D
+echarmenian;0565
+echyiwnarmenian;0587
+ecircle;24D4
+ecircumflex;00EA
+ecircumflexacute;1EBF
+ecircumflexbelow;1E19
+ecircumflexdotbelow;1EC7
+ecircumflexgrave;1EC1
+ecircumflexhookabove;1EC3
+ecircumflextilde;1EC5
+ecyrillic;0454
+edblgrave;0205
+edeva;090F
+edieresis;00EB
+edot;0117
+edotaccent;0117
+edotbelow;1EB9
+eegurmukhi;0A0F
+eematragurmukhi;0A47
+efcyrillic;0444
+egrave;00E8
+egujarati;0A8F
+eharmenian;0567
+ehbopomofo;311D
+ehiragana;3048
+ehookabove;1EBB
+eibopomofo;311F
+eight;0038
+eightarabic;0668
+eightbengali;09EE
+eightcircle;2467
+eightcircleinversesansserif;2791
+eightdeva;096E
+eighteencircle;2471
+eighteenparen;2485
+eighteenperiod;2499
+eightgujarati;0AEE
+eightgurmukhi;0A6E
+eighthackarabic;0668
+eighthangzhou;3028
+eighthnotebeamed;266B
+eightideographicparen;3227
+eightinferior;2088
+eightmonospace;FF18
+eightoldstyle;F738
+eightparen;247B
+eightperiod;248F
+eightpersian;06F8
+eightroman;2177
+eightsuperior;2078
+eightthai;0E58
+einvertedbreve;0207
+eiotifiedcyrillic;0465
+ekatakana;30A8
+ekatakanahalfwidth;FF74
+ekonkargurmukhi;0A74
+ekorean;3154
+elcyrillic;043B
+element;2208
+elevencircle;246A
+elevenparen;247E
+elevenperiod;2492
+elevenroman;217A
+ellipsis;2026
+ellipsisvertical;22EE
+emacron;0113
+emacronacute;1E17
+emacrongrave;1E15
+emcyrillic;043C
+emdash;2014
+emdashvertical;FE31
+emonospace;FF45
+emphasismarkarmenian;055B
+emptyset;2205
+enbopomofo;3123
+encyrillic;043D
+endash;2013
+endashvertical;FE32
+endescendercyrillic;04A3
+eng;014B
+engbopomofo;3125
+enghecyrillic;04A5
+enhookcyrillic;04C8
+enspace;2002
+eogonek;0119
+eokorean;3153
+eopen;025B
+eopenclosed;029A
+eopenreversed;025C
+eopenreversedclosed;025E
+eopenreversedhook;025D
+eparen;24A0
+epsilon;03B5
+epsilontonos;03AD
+equal;003D
+equalmonospace;FF1D
+equalsmall;FE66
+equalsuperior;207C
+equivalence;2261
+erbopomofo;3126
+ercyrillic;0440
+ereversed;0258
+ereversedcyrillic;044D
+escyrillic;0441
+esdescendercyrillic;04AB
+esh;0283
+eshcurl;0286
+eshortdeva;090E
+eshortvowelsigndeva;0946
+eshreversedloop;01AA
+eshsquatreversed;0285
+esmallhiragana;3047
+esmallkatakana;30A7
+esmallkatakanahalfwidth;FF6A
+estimated;212E
+esuperior;F6EC
+eta;03B7
+etarmenian;0568
+etatonos;03AE
+eth;00F0
+etilde;1EBD
+etildebelow;1E1B
+etnahtafoukhhebrew;0591
+etnahtafoukhlefthebrew;0591
+etnahtahebrew;0591
+etnahtalefthebrew;0591
+eturned;01DD
+eukorean;3161
+euro;20AC
+evowelsignbengali;09C7
+evowelsigndeva;0947
+evowelsigngujarati;0AC7
+exclam;0021
+exclamarmenian;055C
+exclamdbl;203C
+exclamdown;00A1
+exclamdownsmall;F7A1
+exclammonospace;FF01
+exclamsmall;F721
+existential;2203
+ezh;0292
+ezhcaron;01EF
+ezhcurl;0293
+ezhreversed;01B9
+ezhtail;01BA
+f;0066
+fadeva;095E
+fagurmukhi;0A5E
+fahrenheit;2109
+fathaarabic;064E
+fathalowarabic;064E
+fathatanarabic;064B
+fbopomofo;3108
+fcircle;24D5
+fdotaccent;1E1F
+feharabic;0641
+feharmenian;0586
+fehfinalarabic;FED2
+fehinitialarabic;FED3
+fehmedialarabic;FED4
+feicoptic;03E5
+female;2640
+ff;FB00
+ffi;FB03
+ffl;FB04
+fi;FB01
+fifteencircle;246E
+fifteenparen;2482
+fifteenperiod;2496
+figuredash;2012
+filledbox;25A0
+filledrect;25AC
+finalkaf;05DA
+finalkafdagesh;FB3A
+finalkafdageshhebrew;FB3A
+finalkafhebrew;05DA
+finalkafqamats;05DA 05B8
+finalkafqamatshebrew;05DA 05B8
+finalkafsheva;05DA 05B0
+finalkafshevahebrew;05DA 05B0
+finalmem;05DD
+finalmemhebrew;05DD
+finalnun;05DF
+finalnunhebrew;05DF
+finalpe;05E3
+finalpehebrew;05E3
+finaltsadi;05E5
+finaltsadihebrew;05E5
+firsttonechinese;02C9
+fisheye;25C9
+fitacyrillic;0473
+five;0035
+fivearabic;0665
+fivebengali;09EB
+fivecircle;2464
+fivecircleinversesansserif;278E
+fivedeva;096B
+fiveeighths;215D
+fivegujarati;0AEB
+fivegurmukhi;0A6B
+fivehackarabic;0665
+fivehangzhou;3025
+fiveideographicparen;3224
+fiveinferior;2085
+fivemonospace;FF15
+fiveoldstyle;F735
+fiveparen;2478
+fiveperiod;248C
+fivepersian;06F5
+fiveroman;2174
+fivesuperior;2075
+fivethai;0E55
+fl;FB02
+florin;0192
+fmonospace;FF46
+fmsquare;3399
+fofanthai;0E1F
+fofathai;0E1D
+fongmanthai;0E4F
+forall;2200
+four;0034
+fourarabic;0664
+fourbengali;09EA
+fourcircle;2463
+fourcircleinversesansserif;278D
+fourdeva;096A
+fourgujarati;0AEA
+fourgurmukhi;0A6A
+fourhackarabic;0664
+fourhangzhou;3024
+fourideographicparen;3223
+fourinferior;2084
+fourmonospace;FF14
+fournumeratorbengali;09F7
+fouroldstyle;F734
+fourparen;2477
+fourperiod;248B
+fourpersian;06F4
+fourroman;2173
+foursuperior;2074
+fourteencircle;246D
+fourteenparen;2481
+fourteenperiod;2495
+fourthai;0E54
+fourthtonechinese;02CB
+fparen;24A1
+fraction;2044
+franc;20A3
+g;0067
+gabengali;0997
+gacute;01F5
+gadeva;0917
+gafarabic;06AF
+gaffinalarabic;FB93
+gafinitialarabic;FB94
+gafmedialarabic;FB95
+gagujarati;0A97
+gagurmukhi;0A17
+gahiragana;304C
+gakatakana;30AC
+gamma;03B3
+gammalatinsmall;0263
+gammasuperior;02E0
+gangiacoptic;03EB
+gbopomofo;310D
+gbreve;011F
+gcaron;01E7
+gcedilla;0123
+gcircle;24D6
+gcircumflex;011D
+gcommaaccent;0123
+gdot;0121
+gdotaccent;0121
+gecyrillic;0433
+gehiragana;3052
+gekatakana;30B2
+geometricallyequal;2251
+gereshaccenthebrew;059C
+gereshhebrew;05F3
+gereshmuqdamhebrew;059D
+germandbls;00DF
+gershayimaccenthebrew;059E
+gershayimhebrew;05F4
+getamark;3013
+ghabengali;0998
+ghadarmenian;0572
+ghadeva;0918
+ghagujarati;0A98
+ghagurmukhi;0A18
+ghainarabic;063A
+ghainfinalarabic;FECE
+ghaininitialarabic;FECF
+ghainmedialarabic;FED0
+ghemiddlehookcyrillic;0495
+ghestrokecyrillic;0493
+gheupturncyrillic;0491
+ghhadeva;095A
+ghhagurmukhi;0A5A
+ghook;0260
+ghzsquare;3393
+gihiragana;304E
+gikatakana;30AE
+gimarmenian;0563
+gimel;05D2
+gimeldagesh;FB32
+gimeldageshhebrew;FB32
+gimelhebrew;05D2
+gjecyrillic;0453
+glottalinvertedstroke;01BE
+glottalstop;0294
+glottalstopinverted;0296
+glottalstopmod;02C0
+glottalstopreversed;0295
+glottalstopreversedmod;02C1
+glottalstopreversedsuperior;02E4
+glottalstopstroke;02A1
+glottalstopstrokereversed;02A2
+gmacron;1E21
+gmonospace;FF47
+gohiragana;3054
+gokatakana;30B4
+gparen;24A2
+gpasquare;33AC
+gradient;2207
+grave;0060
+gravebelowcmb;0316
+gravecmb;0300
+gravecomb;0300
+gravedeva;0953
+gravelowmod;02CE
+gravemonospace;FF40
+gravetonecmb;0340
+greater;003E
+greaterequal;2265
+greaterequalorless;22DB
+greatermonospace;FF1E
+greaterorequivalent;2273
+greaterorless;2277
+greateroverequal;2267
+greatersmall;FE65
+gscript;0261
+gstroke;01E5
+guhiragana;3050
+guillemotleft;00AB
+guillemotright;00BB
+guilsinglleft;2039
+guilsinglright;203A
+gukatakana;30B0
+guramusquare;3318
+gysquare;33C9
+h;0068
+haabkhasiancyrillic;04A9
+haaltonearabic;06C1
+habengali;09B9
+hadescendercyrillic;04B3
+hadeva;0939
+hagujarati;0AB9
+hagurmukhi;0A39
+haharabic;062D
+hahfinalarabic;FEA2
+hahinitialarabic;FEA3
+hahiragana;306F
+hahmedialarabic;FEA4
+haitusquare;332A
+hakatakana;30CF
+hakatakanahalfwidth;FF8A
+halantgurmukhi;0A4D
+hamzaarabic;0621
+hamzadammaarabic;0621 064F
+hamzadammatanarabic;0621 064C
+hamzafathaarabic;0621 064E
+hamzafathatanarabic;0621 064B
+hamzalowarabic;0621
+hamzalowkasraarabic;0621 0650
+hamzalowkasratanarabic;0621 064D
+hamzasukunarabic;0621 0652
+hangulfiller;3164
+hardsigncyrillic;044A
+harpoonleftbarbup;21BC
+harpoonrightbarbup;21C0
+hasquare;33CA
+hatafpatah;05B2
+hatafpatah16;05B2
+hatafpatah23;05B2
+hatafpatah2f;05B2
+hatafpatahhebrew;05B2
+hatafpatahnarrowhebrew;05B2
+hatafpatahquarterhebrew;05B2
+hatafpatahwidehebrew;05B2
+hatafqamats;05B3
+hatafqamats1b;05B3
+hatafqamats28;05B3
+hatafqamats34;05B3
+hatafqamatshebrew;05B3
+hatafqamatsnarrowhebrew;05B3
+hatafqamatsquarterhebrew;05B3
+hatafqamatswidehebrew;05B3
+hatafsegol;05B1
+hatafsegol17;05B1
+hatafsegol24;05B1
+hatafsegol30;05B1
+hatafsegolhebrew;05B1
+hatafsegolnarrowhebrew;05B1
+hatafsegolquarterhebrew;05B1
+hatafsegolwidehebrew;05B1
+hbar;0127
+hbopomofo;310F
+hbrevebelow;1E2B
+hcedilla;1E29
+hcircle;24D7
+hcircumflex;0125
+hdieresis;1E27
+hdotaccent;1E23
+hdotbelow;1E25
+he;05D4
+heart;2665
+heartsuitblack;2665
+heartsuitwhite;2661
+hedagesh;FB34
+hedageshhebrew;FB34
+hehaltonearabic;06C1
+heharabic;0647
+hehebrew;05D4
+hehfinalaltonearabic;FBA7
+hehfinalalttwoarabic;FEEA
+hehfinalarabic;FEEA
+hehhamzaabovefinalarabic;FBA5
+hehhamzaaboveisolatedarabic;FBA4
+hehinitialaltonearabic;FBA8
+hehinitialarabic;FEEB
+hehiragana;3078
+hehmedialaltonearabic;FBA9
+hehmedialarabic;FEEC
+heiseierasquare;337B
+hekatakana;30D8
+hekatakanahalfwidth;FF8D
+hekutaarusquare;3336
+henghook;0267
+herutusquare;3339
+het;05D7
+hethebrew;05D7
+hhook;0266
+hhooksuperior;02B1
+hieuhacirclekorean;327B
+hieuhaparenkorean;321B
+hieuhcirclekorean;326D
+hieuhkorean;314E
+hieuhparenkorean;320D
+hihiragana;3072
+hikatakana;30D2
+hikatakanahalfwidth;FF8B
+hiriq;05B4
+hiriq14;05B4
+hiriq21;05B4
+hiriq2d;05B4
+hiriqhebrew;05B4
+hiriqnarrowhebrew;05B4
+hiriqquarterhebrew;05B4
+hiriqwidehebrew;05B4
+hlinebelow;1E96
+hmonospace;FF48
+hoarmenian;0570
+hohipthai;0E2B
+hohiragana;307B
+hokatakana;30DB
+hokatakanahalfwidth;FF8E
+holam;05B9
+holam19;05B9
+holam26;05B9
+holam32;05B9
+holamhebrew;05B9
+holamnarrowhebrew;05B9
+holamquarterhebrew;05B9
+holamwidehebrew;05B9
+honokhukthai;0E2E
+hookabovecomb;0309
+hookcmb;0309
+hookpalatalizedbelowcmb;0321
+hookretroflexbelowcmb;0322
+hoonsquare;3342
+horicoptic;03E9
+horizontalbar;2015
+horncmb;031B
+hotsprings;2668
+house;2302
+hparen;24A3
+hsuperior;02B0
+hturned;0265
+huhiragana;3075
+huiitosquare;3333
+hukatakana;30D5
+hukatakanahalfwidth;FF8C
+hungarumlaut;02DD
+hungarumlautcmb;030B
+hv;0195
+hyphen;002D
+hypheninferior;F6E5
+hyphenmonospace;FF0D
+hyphensmall;FE63
+hyphensuperior;F6E6
+hyphentwo;2010
+i;0069
+iacute;00ED
+iacyrillic;044F
+ibengali;0987
+ibopomofo;3127
+ibreve;012D
+icaron;01D0
+icircle;24D8
+icircumflex;00EE
+icyrillic;0456
+idblgrave;0209
+ideographearthcircle;328F
+ideographfirecircle;328B
+ideographicallianceparen;323F
+ideographiccallparen;323A
+ideographiccentrecircle;32A5
+ideographicclose;3006
+ideographiccomma;3001
+ideographiccommaleft;FF64
+ideographiccongratulationparen;3237
+ideographiccorrectcircle;32A3
+ideographicearthparen;322F
+ideographicenterpriseparen;323D
+ideographicexcellentcircle;329D
+ideographicfestivalparen;3240
+ideographicfinancialcircle;3296
+ideographicfinancialparen;3236
+ideographicfireparen;322B
+ideographichaveparen;3232
+ideographichighcircle;32A4
+ideographiciterationmark;3005
+ideographiclaborcircle;3298
+ideographiclaborparen;3238
+ideographicleftcircle;32A7
+ideographiclowcircle;32A6
+ideographicmedicinecircle;32A9
+ideographicmetalparen;322E
+ideographicmoonparen;322A
+ideographicnameparen;3234
+ideographicperiod;3002
+ideographicprintcircle;329E
+ideographicreachparen;3243
+ideographicrepresentparen;3239
+ideographicresourceparen;323E
+ideographicrightcircle;32A8
+ideographicsecretcircle;3299
+ideographicselfparen;3242
+ideographicsocietyparen;3233
+ideographicspace;3000
+ideographicspecialparen;3235
+ideographicstockparen;3231
+ideographicstudyparen;323B
+ideographicsunparen;3230
+ideographicsuperviseparen;323C
+ideographicwaterparen;322C
+ideographicwoodparen;322D
+ideographiczero;3007
+ideographmetalcircle;328E
+ideographmooncircle;328A
+ideographnamecircle;3294
+ideographsuncircle;3290
+ideographwatercircle;328C
+ideographwoodcircle;328D
+ideva;0907
+idieresis;00EF
+idieresisacute;1E2F
+idieresiscyrillic;04E5
+idotbelow;1ECB
+iebrevecyrillic;04D7
+iecyrillic;0435
+ieungacirclekorean;3275
+ieungaparenkorean;3215
+ieungcirclekorean;3267
+ieungkorean;3147
+ieungparenkorean;3207
+igrave;00EC
+igujarati;0A87
+igurmukhi;0A07
+ihiragana;3044
+ihookabove;1EC9
+iibengali;0988
+iicyrillic;0438
+iideva;0908
+iigujarati;0A88
+iigurmukhi;0A08
+iimatragurmukhi;0A40
+iinvertedbreve;020B
+iishortcyrillic;0439
+iivowelsignbengali;09C0
+iivowelsigndeva;0940
+iivowelsigngujarati;0AC0
+ij;0133
+ikatakana;30A4
+ikatakanahalfwidth;FF72
+ikorean;3163
+ilde;02DC
+iluyhebrew;05AC
+imacron;012B
+imacroncyrillic;04E3
+imageorapproximatelyequal;2253
+imatragurmukhi;0A3F
+imonospace;FF49
+increment;2206
+infinity;221E
+iniarmenian;056B
+integral;222B
+integralbottom;2321
+integralbt;2321
+integralex;F8F5
+integraltop;2320
+integraltp;2320
+intersection;2229
+intisquare;3305
+invbullet;25D8
+invcircle;25D9
+invsmileface;263B
+iocyrillic;0451
+iogonek;012F
+iota;03B9
+iotadieresis;03CA
+iotadieresistonos;0390
+iotalatin;0269
+iotatonos;03AF
+iparen;24A4
+irigurmukhi;0A72
+ismallhiragana;3043
+ismallkatakana;30A3
+ismallkatakanahalfwidth;FF68
+issharbengali;09FA
+istroke;0268
+isuperior;F6ED
+iterationhiragana;309D
+iterationkatakana;30FD
+itilde;0129
+itildebelow;1E2D
+iubopomofo;3129
+iucyrillic;044E
+ivowelsignbengali;09BF
+ivowelsigndeva;093F
+ivowelsigngujarati;0ABF
+izhitsacyrillic;0475
+izhitsadblgravecyrillic;0477
+j;006A
+jaarmenian;0571
+jabengali;099C
+jadeva;091C
+jagujarati;0A9C
+jagurmukhi;0A1C
+jbopomofo;3110
+jcaron;01F0
+jcircle;24D9
+jcircumflex;0135
+jcrossedtail;029D
+jdotlessstroke;025F
+jecyrillic;0458
+jeemarabic;062C
+jeemfinalarabic;FE9E
+jeeminitialarabic;FE9F
+jeemmedialarabic;FEA0
+jeharabic;0698
+jehfinalarabic;FB8B
+jhabengali;099D
+jhadeva;091D
+jhagujarati;0A9D
+jhagurmukhi;0A1D
+jheharmenian;057B
+jis;3004
+jmonospace;FF4A
+jparen;24A5
+jsuperior;02B2
+k;006B
+kabashkircyrillic;04A1
+kabengali;0995
+kacute;1E31
+kacyrillic;043A
+kadescendercyrillic;049B
+kadeva;0915
+kaf;05DB
+kafarabic;0643
+kafdagesh;FB3B
+kafdageshhebrew;FB3B
+kaffinalarabic;FEDA
+kafhebrew;05DB
+kafinitialarabic;FEDB
+kafmedialarabic;FEDC
+kafrafehebrew;FB4D
+kagujarati;0A95
+kagurmukhi;0A15
+kahiragana;304B
+kahookcyrillic;04C4
+kakatakana;30AB
+kakatakanahalfwidth;FF76
+kappa;03BA
+kappasymbolgreek;03F0
+kapyeounmieumkorean;3171
+kapyeounphieuphkorean;3184
+kapyeounpieupkorean;3178
+kapyeounssangpieupkorean;3179
+karoriisquare;330D
+kashidaautoarabic;0640
+kashidaautonosidebearingarabic;0640
+kasmallkatakana;30F5
+kasquare;3384
+kasraarabic;0650
+kasratanarabic;064D
+kastrokecyrillic;049F
+katahiraprolongmarkhalfwidth;FF70
+kaverticalstrokecyrillic;049D
+kbopomofo;310E
+kcalsquare;3389
+kcaron;01E9
+kcedilla;0137
+kcircle;24DA
+kcommaaccent;0137
+kdotbelow;1E33
+keharmenian;0584
+kehiragana;3051
+kekatakana;30B1
+kekatakanahalfwidth;FF79
+kenarmenian;056F
+kesmallkatakana;30F6
+kgreenlandic;0138
+khabengali;0996
+khacyrillic;0445
+khadeva;0916
+khagujarati;0A96
+khagurmukhi;0A16
+khaharabic;062E
+khahfinalarabic;FEA6
+khahinitialarabic;FEA7
+khahmedialarabic;FEA8
+kheicoptic;03E7
+khhadeva;0959
+khhagurmukhi;0A59
+khieukhacirclekorean;3278
+khieukhaparenkorean;3218
+khieukhcirclekorean;326A
+khieukhkorean;314B
+khieukhparenkorean;320A
+khokhaithai;0E02
+khokhonthai;0E05
+khokhuatthai;0E03
+khokhwaithai;0E04
+khomutthai;0E5B
+khook;0199
+khorakhangthai;0E06
+khzsquare;3391
+kihiragana;304D
+kikatakana;30AD
+kikatakanahalfwidth;FF77
+kiroguramusquare;3315
+kiromeetorusquare;3316
+kirosquare;3314
+kiyeokacirclekorean;326E
+kiyeokaparenkorean;320E
+kiyeokcirclekorean;3260
+kiyeokkorean;3131
+kiyeokparenkorean;3200
+kiyeoksioskorean;3133
+kjecyrillic;045C
+klinebelow;1E35
+klsquare;3398
+kmcubedsquare;33A6
+kmonospace;FF4B
+kmsquaredsquare;33A2
+kohiragana;3053
+kohmsquare;33C0
+kokaithai;0E01
+kokatakana;30B3
+kokatakanahalfwidth;FF7A
+kooposquare;331E
+koppacyrillic;0481
+koreanstandardsymbol;327F
+koroniscmb;0343
+kparen;24A6
+kpasquare;33AA
+ksicyrillic;046F
+ktsquare;33CF
+kturned;029E
+kuhiragana;304F
+kukatakana;30AF
+kukatakanahalfwidth;FF78
+kvsquare;33B8
+kwsquare;33BE
+l;006C
+labengali;09B2
+lacute;013A
+ladeva;0932
+lagujarati;0AB2
+lagurmukhi;0A32
+lakkhangyaothai;0E45
+lamaleffinalarabic;FEFC
+lamalefhamzaabovefinalarabic;FEF8
+lamalefhamzaaboveisolatedarabic;FEF7
+lamalefhamzabelowfinalarabic;FEFA
+lamalefhamzabelowisolatedarabic;FEF9
+lamalefisolatedarabic;FEFB
+lamalefmaddaabovefinalarabic;FEF6
+lamalefmaddaaboveisolatedarabic;FEF5
+lamarabic;0644
+lambda;03BB
+lambdastroke;019B
+lamed;05DC
+lameddagesh;FB3C
+lameddageshhebrew;FB3C
+lamedhebrew;05DC
+lamedholam;05DC 05B9
+lamedholamdagesh;05DC 05B9 05BC
+lamedholamdageshhebrew;05DC 05B9 05BC
+lamedholamhebrew;05DC 05B9
+lamfinalarabic;FEDE
+lamhahinitialarabic;FCCA
+laminitialarabic;FEDF
+lamjeeminitialarabic;FCC9
+lamkhahinitialarabic;FCCB
+lamlamhehisolatedarabic;FDF2
+lammedialarabic;FEE0
+lammeemhahinitialarabic;FD88
+lammeeminitialarabic;FCCC
+lammeemjeeminitialarabic;FEDF FEE4 FEA0
+lammeemkhahinitialarabic;FEDF FEE4 FEA8
+largecircle;25EF
+lbar;019A
+lbelt;026C
+lbopomofo;310C
+lcaron;013E
+lcedilla;013C
+lcircle;24DB
+lcircumflexbelow;1E3D
+lcommaaccent;013C
+ldot;0140
+ldotaccent;0140
+ldotbelow;1E37
+ldotbelowmacron;1E39
+leftangleabovecmb;031A
+lefttackbelowcmb;0318
+less;003C
+lessequal;2264
+lessequalorgreater;22DA
+lessmonospace;FF1C
+lessorequivalent;2272
+lessorgreater;2276
+lessoverequal;2266
+lesssmall;FE64
+lezh;026E
+lfblock;258C
+lhookretroflex;026D
+lira;20A4
+liwnarmenian;056C
+lj;01C9
+ljecyrillic;0459
+ll;F6C0
+lladeva;0933
+llagujarati;0AB3
+llinebelow;1E3B
+llladeva;0934
+llvocalicbengali;09E1
+llvocalicdeva;0961
+llvocalicvowelsignbengali;09E3
+llvocalicvowelsigndeva;0963
+lmiddletilde;026B
+lmonospace;FF4C
+lmsquare;33D0
+lochulathai;0E2C
+logicaland;2227
+logicalnot;00AC
+logicalnotreversed;2310
+logicalor;2228
+lolingthai;0E25
+longs;017F
+lowlinecenterline;FE4E
+lowlinecmb;0332
+lowlinedashed;FE4D
+lozenge;25CA
+lparen;24A7
+lslash;0142
+lsquare;2113
+lsuperior;F6EE
+ltshade;2591
+luthai;0E26
+lvocalicbengali;098C
+lvocalicdeva;090C
+lvocalicvowelsignbengali;09E2
+lvocalicvowelsigndeva;0962
+lxsquare;33D3
+m;006D
+mabengali;09AE
+macron;00AF
+macronbelowcmb;0331
+macroncmb;0304
+macronlowmod;02CD
+macronmonospace;FFE3
+macute;1E3F
+madeva;092E
+magujarati;0AAE
+magurmukhi;0A2E
+mahapakhhebrew;05A4
+mahapakhlefthebrew;05A4
+mahiragana;307E
+maichattawalowleftthai;F895
+maichattawalowrightthai;F894
+maichattawathai;0E4B
+maichattawaupperleftthai;F893
+maieklowleftthai;F88C
+maieklowrightthai;F88B
+maiekthai;0E48
+maiekupperleftthai;F88A
+maihanakatleftthai;F884
+maihanakatthai;0E31
+maitaikhuleftthai;F889
+maitaikhuthai;0E47
+maitholowleftthai;F88F
+maitholowrightthai;F88E
+maithothai;0E49
+maithoupperleftthai;F88D
+maitrilowleftthai;F892
+maitrilowrightthai;F891
+maitrithai;0E4A
+maitriupperleftthai;F890
+maiyamokthai;0E46
+makatakana;30DE
+makatakanahalfwidth;FF8F
+male;2642
+mansyonsquare;3347
+maqafhebrew;05BE
+mars;2642
+masoracirclehebrew;05AF
+masquare;3383
+mbopomofo;3107
+mbsquare;33D4
+mcircle;24DC
+mcubedsquare;33A5
+mdotaccent;1E41
+mdotbelow;1E43
+meemarabic;0645
+meemfinalarabic;FEE2
+meeminitialarabic;FEE3
+meemmedialarabic;FEE4
+meemmeeminitialarabic;FCD1
+meemmeemisolatedarabic;FC48
+meetorusquare;334D
+mehiragana;3081
+meizierasquare;337E
+mekatakana;30E1
+mekatakanahalfwidth;FF92
+mem;05DE
+memdagesh;FB3E
+memdageshhebrew;FB3E
+memhebrew;05DE
+menarmenian;0574
+merkhahebrew;05A5
+merkhakefulahebrew;05A6
+merkhakefulalefthebrew;05A6
+merkhalefthebrew;05A5
+mhook;0271
+mhzsquare;3392
+middledotkatakanahalfwidth;FF65
+middot;00B7
+mieumacirclekorean;3272
+mieumaparenkorean;3212
+mieumcirclekorean;3264
+mieumkorean;3141
+mieumpansioskorean;3170
+mieumparenkorean;3204
+mieumpieupkorean;316E
+mieumsioskorean;316F
+mihiragana;307F
+mikatakana;30DF
+mikatakanahalfwidth;FF90
+minus;2212
+minusbelowcmb;0320
+minuscircle;2296
+minusmod;02D7
+minusplus;2213
+minute;2032
+miribaarusquare;334A
+mirisquare;3349
+mlonglegturned;0270
+mlsquare;3396
+mmcubedsquare;33A3
+mmonospace;FF4D
+mmsquaredsquare;339F
+mohiragana;3082
+mohmsquare;33C1
+mokatakana;30E2
+mokatakanahalfwidth;FF93
+molsquare;33D6
+momathai;0E21
+moverssquare;33A7
+moverssquaredsquare;33A8
+mparen;24A8
+mpasquare;33AB
+mssquare;33B3
+msuperior;F6EF
+mturned;026F
+mu;00B5
+mu1;00B5
+muasquare;3382
+muchgreater;226B
+muchless;226A
+mufsquare;338C
+mugreek;03BC
+mugsquare;338D
+muhiragana;3080
+mukatakana;30E0
+mukatakanahalfwidth;FF91
+mulsquare;3395
+multiply;00D7
+mumsquare;339B
+munahhebrew;05A3
+munahlefthebrew;05A3
+musicalnote;266A
+musicalnotedbl;266B
+musicflatsign;266D
+musicsharpsign;266F
+mussquare;33B2
+muvsquare;33B6
+muwsquare;33BC
+mvmegasquare;33B9
+mvsquare;33B7
+mwmegasquare;33BF
+mwsquare;33BD
+n;006E
+nabengali;09A8
+nabla;2207
+nacute;0144
+nadeva;0928
+nagujarati;0AA8
+nagurmukhi;0A28
+nahiragana;306A
+nakatakana;30CA
+nakatakanahalfwidth;FF85
+napostrophe;0149
+nasquare;3381
+nbopomofo;310B
+nbspace;00A0
+ncaron;0148
+ncedilla;0146
+ncircle;24DD
+ncircumflexbelow;1E4B
+ncommaaccent;0146
+ndotaccent;1E45
+ndotbelow;1E47
+nehiragana;306D
+nekatakana;30CD
+nekatakanahalfwidth;FF88
+newsheqelsign;20AA
+nfsquare;338B
+ngabengali;0999
+ngadeva;0919
+ngagujarati;0A99
+ngagurmukhi;0A19
+ngonguthai;0E07
+nhiragana;3093
+nhookleft;0272
+nhookretroflex;0273
+nieunacirclekorean;326F
+nieunaparenkorean;320F
+nieuncieuckorean;3135
+nieuncirclekorean;3261
+nieunhieuhkorean;3136
+nieunkorean;3134
+nieunpansioskorean;3168
+nieunparenkorean;3201
+nieunsioskorean;3167
+nieuntikeutkorean;3166
+nihiragana;306B
+nikatakana;30CB
+nikatakanahalfwidth;FF86
+nikhahitleftthai;F899
+nikhahitthai;0E4D
+nine;0039
+ninearabic;0669
+ninebengali;09EF
+ninecircle;2468
+ninecircleinversesansserif;2792
+ninedeva;096F
+ninegujarati;0AEF
+ninegurmukhi;0A6F
+ninehackarabic;0669
+ninehangzhou;3029
+nineideographicparen;3228
+nineinferior;2089
+ninemonospace;FF19
+nineoldstyle;F739
+nineparen;247C
+nineperiod;2490
+ninepersian;06F9
+nineroman;2178
+ninesuperior;2079
+nineteencircle;2472
+nineteenparen;2486
+nineteenperiod;249A
+ninethai;0E59
+nj;01CC
+njecyrillic;045A
+nkatakana;30F3
+nkatakanahalfwidth;FF9D
+nlegrightlong;019E
+nlinebelow;1E49
+nmonospace;FF4E
+nmsquare;339A
+nnabengali;09A3
+nnadeva;0923
+nnagujarati;0AA3
+nnagurmukhi;0A23
+nnnadeva;0929
+nohiragana;306E
+nokatakana;30CE
+nokatakanahalfwidth;FF89
+nonbreakingspace;00A0
+nonenthai;0E13
+nonuthai;0E19
+noonarabic;0646
+noonfinalarabic;FEE6
+noonghunnaarabic;06BA
+noonghunnafinalarabic;FB9F
+noonhehinitialarabic;FEE7 FEEC
+nooninitialarabic;FEE7
+noonjeeminitialarabic;FCD2
+noonjeemisolatedarabic;FC4B
+noonmedialarabic;FEE8
+noonmeeminitialarabic;FCD5
+noonmeemisolatedarabic;FC4E
+noonnoonfinalarabic;FC8D
+notcontains;220C
+notelement;2209
+notelementof;2209
+notequal;2260
+notgreater;226F
+notgreaternorequal;2271
+notgreaternorless;2279
+notidentical;2262
+notless;226E
+notlessnorequal;2270
+notparallel;2226
+notprecedes;2280
+notsubset;2284
+notsucceeds;2281
+notsuperset;2285
+nowarmenian;0576
+nparen;24A9
+nssquare;33B1
+nsuperior;207F
+ntilde;00F1
+nu;03BD
+nuhiragana;306C
+nukatakana;30CC
+nukatakanahalfwidth;FF87
+nuktabengali;09BC
+nuktadeva;093C
+nuktagujarati;0ABC
+nuktagurmukhi;0A3C
+numbersign;0023
+numbersignmonospace;FF03
+numbersignsmall;FE5F
+numeralsigngreek;0374
+numeralsignlowergreek;0375
+numero;2116
+nun;05E0
+nundagesh;FB40
+nundageshhebrew;FB40
+nunhebrew;05E0
+nvsquare;33B5
+nwsquare;33BB
+nyabengali;099E
+nyadeva;091E
+nyagujarati;0A9E
+nyagurmukhi;0A1E
+o;006F
+oacute;00F3
+oangthai;0E2D
+obarred;0275
+obarredcyrillic;04E9
+obarreddieresiscyrillic;04EB
+obengali;0993
+obopomofo;311B
+obreve;014F
+ocandradeva;0911
+ocandragujarati;0A91
+ocandravowelsigndeva;0949
+ocandravowelsigngujarati;0AC9
+ocaron;01D2
+ocircle;24DE
+ocircumflex;00F4
+ocircumflexacute;1ED1
+ocircumflexdotbelow;1ED9
+ocircumflexgrave;1ED3
+ocircumflexhookabove;1ED5
+ocircumflextilde;1ED7
+ocyrillic;043E
+odblacute;0151
+odblgrave;020D
+odeva;0913
+odieresis;00F6
+odieresiscyrillic;04E7
+odotbelow;1ECD
+oe;0153
+oekorean;315A
+ogonek;02DB
+ogonekcmb;0328
+ograve;00F2
+ogujarati;0A93
+oharmenian;0585
+ohiragana;304A
+ohookabove;1ECF
+ohorn;01A1
+ohornacute;1EDB
+ohorndotbelow;1EE3
+ohorngrave;1EDD
+ohornhookabove;1EDF
+ohorntilde;1EE1
+ohungarumlaut;0151
+oi;01A3
+oinvertedbreve;020F
+okatakana;30AA
+okatakanahalfwidth;FF75
+okorean;3157
+olehebrew;05AB
+omacron;014D
+omacronacute;1E53
+omacrongrave;1E51
+omdeva;0950
+omega;03C9
+omega1;03D6
+omegacyrillic;0461
+omegalatinclosed;0277
+omegaroundcyrillic;047B
+omegatitlocyrillic;047D
+omegatonos;03CE
+omgujarati;0AD0
+omicron;03BF
+omicrontonos;03CC
+omonospace;FF4F
+one;0031
+onearabic;0661
+onebengali;09E7
+onecircle;2460
+onecircleinversesansserif;278A
+onedeva;0967
+onedotenleader;2024
+oneeighth;215B
+onefitted;F6DC
+onegujarati;0AE7
+onegurmukhi;0A67
+onehackarabic;0661
+onehalf;00BD
+onehangzhou;3021
+oneideographicparen;3220
+oneinferior;2081
+onemonospace;FF11
+onenumeratorbengali;09F4
+oneoldstyle;F731
+oneparen;2474
+oneperiod;2488
+onepersian;06F1
+onequarter;00BC
+oneroman;2170
+onesuperior;00B9
+onethai;0E51
+onethird;2153
+oogonek;01EB
+oogonekmacron;01ED
+oogurmukhi;0A13
+oomatragurmukhi;0A4B
+oopen;0254
+oparen;24AA
+openbullet;25E6
+option;2325
+ordfeminine;00AA
+ordmasculine;00BA
+orthogonal;221F
+oshortdeva;0912
+oshortvowelsigndeva;094A
+oslash;00F8
+oslashacute;01FF
+osmallhiragana;3049
+osmallkatakana;30A9
+osmallkatakanahalfwidth;FF6B
+ostrokeacute;01FF
+osuperior;F6F0
+otcyrillic;047F
+otilde;00F5
+otildeacute;1E4D
+otildedieresis;1E4F
+oubopomofo;3121
+overline;203E
+overlinecenterline;FE4A
+overlinecmb;0305
+overlinedashed;FE49
+overlinedblwavy;FE4C
+overlinewavy;FE4B
+overscore;00AF
+ovowelsignbengali;09CB
+ovowelsigndeva;094B
+ovowelsigngujarati;0ACB
+p;0070
+paampssquare;3380
+paasentosquare;332B
+pabengali;09AA
+pacute;1E55
+padeva;092A
+pagedown;21DF
+pageup;21DE
+pagujarati;0AAA
+pagurmukhi;0A2A
+pahiragana;3071
+paiyannoithai;0E2F
+pakatakana;30D1
+palatalizationcyrilliccmb;0484
+palochkacyrillic;04C0
+pansioskorean;317F
+paragraph;00B6
+parallel;2225
+parenleft;0028
+parenleftaltonearabic;FD3E
+parenleftbt;F8ED
+parenleftex;F8EC
+parenleftinferior;208D
+parenleftmonospace;FF08
+parenleftsmall;FE59
+parenleftsuperior;207D
+parenlefttp;F8EB
+parenleftvertical;FE35
+parenright;0029
+parenrightaltonearabic;FD3F
+parenrightbt;F8F8
+parenrightex;F8F7
+parenrightinferior;208E
+parenrightmonospace;FF09
+parenrightsmall;FE5A
+parenrightsuperior;207E
+parenrighttp;F8F6
+parenrightvertical;FE36
+partialdiff;2202
+paseqhebrew;05C0
+pashtahebrew;0599
+pasquare;33A9
+patah;05B7
+patah11;05B7
+patah1d;05B7
+patah2a;05B7
+patahhebrew;05B7
+patahnarrowhebrew;05B7
+patahquarterhebrew;05B7
+patahwidehebrew;05B7
+pazerhebrew;05A1
+pbopomofo;3106
+pcircle;24DF
+pdotaccent;1E57
+pe;05E4
+pecyrillic;043F
+pedagesh;FB44
+pedageshhebrew;FB44
+peezisquare;333B
+pefinaldageshhebrew;FB43
+peharabic;067E
+peharmenian;057A
+pehebrew;05E4
+pehfinalarabic;FB57
+pehinitialarabic;FB58
+pehiragana;307A
+pehmedialarabic;FB59
+pekatakana;30DA
+pemiddlehookcyrillic;04A7
+perafehebrew;FB4E
+percent;0025
+percentarabic;066A
+percentmonospace;FF05
+percentsmall;FE6A
+period;002E
+periodarmenian;0589
+periodcentered;00B7
+periodhalfwidth;FF61
+periodinferior;F6E7
+periodmonospace;FF0E
+periodsmall;FE52
+periodsuperior;F6E8
+perispomenigreekcmb;0342
+perpendicular;22A5
+perthousand;2030
+peseta;20A7
+pfsquare;338A
+phabengali;09AB
+phadeva;092B
+phagujarati;0AAB
+phagurmukhi;0A2B
+phi;03C6
+phi1;03D5
+phieuphacirclekorean;327A
+phieuphaparenkorean;321A
+phieuphcirclekorean;326C
+phieuphkorean;314D
+phieuphparenkorean;320C
+philatin;0278
+phinthuthai;0E3A
+phisymbolgreek;03D5
+phook;01A5
+phophanthai;0E1E
+phophungthai;0E1C
+phosamphaothai;0E20
+pi;03C0
+pieupacirclekorean;3273
+pieupaparenkorean;3213
+pieupcieuckorean;3176
+pieupcirclekorean;3265
+pieupkiyeokkorean;3172
+pieupkorean;3142
+pieupparenkorean;3205
+pieupsioskiyeokkorean;3174
+pieupsioskorean;3144
+pieupsiostikeutkorean;3175
+pieupthieuthkorean;3177
+pieuptikeutkorean;3173
+pihiragana;3074
+pikatakana;30D4
+pisymbolgreek;03D6
+piwrarmenian;0583
+plus;002B
+plusbelowcmb;031F
+pluscircle;2295
+plusminus;00B1
+plusmod;02D6
+plusmonospace;FF0B
+plussmall;FE62
+plussuperior;207A
+pmonospace;FF50
+pmsquare;33D8
+pohiragana;307D
+pointingindexdownwhite;261F
+pointingindexleftwhite;261C
+pointingindexrightwhite;261E
+pointingindexupwhite;261D
+pokatakana;30DD
+poplathai;0E1B
+postalmark;3012
+postalmarkface;3020
+pparen;24AB
+precedes;227A
+prescription;211E
+primemod;02B9
+primereversed;2035
+product;220F
+projective;2305
+prolongedkana;30FC
+propellor;2318
+propersubset;2282
+propersuperset;2283
+proportion;2237
+proportional;221D
+psi;03C8
+psicyrillic;0471
+psilipneumatacyrilliccmb;0486
+pssquare;33B0
+puhiragana;3077
+pukatakana;30D7
+pvsquare;33B4
+pwsquare;33BA
+q;0071
+qadeva;0958
+qadmahebrew;05A8
+qafarabic;0642
+qaffinalarabic;FED6
+qafinitialarabic;FED7
+qafmedialarabic;FED8
+qamats;05B8
+qamats10;05B8
+qamats1a;05B8
+qamats1c;05B8
+qamats27;05B8
+qamats29;05B8
+qamats33;05B8
+qamatsde;05B8
+qamatshebrew;05B8
+qamatsnarrowhebrew;05B8
+qamatsqatanhebrew;05B8
+qamatsqatannarrowhebrew;05B8
+qamatsqatanquarterhebrew;05B8
+qamatsqatanwidehebrew;05B8
+qamatsquarterhebrew;05B8
+qamatswidehebrew;05B8
+qarneyparahebrew;059F
+qbopomofo;3111
+qcircle;24E0
+qhook;02A0
+qmonospace;FF51
+qof;05E7
+qofdagesh;FB47
+qofdageshhebrew;FB47
+qofhatafpatah;05E7 05B2
+qofhatafpatahhebrew;05E7 05B2
+qofhatafsegol;05E7 05B1
+qofhatafsegolhebrew;05E7 05B1
+qofhebrew;05E7
+qofhiriq;05E7 05B4
+qofhiriqhebrew;05E7 05B4
+qofholam;05E7 05B9
+qofholamhebrew;05E7 05B9
+qofpatah;05E7 05B7
+qofpatahhebrew;05E7 05B7
+qofqamats;05E7 05B8
+qofqamatshebrew;05E7 05B8
+qofqubuts;05E7 05BB
+qofqubutshebrew;05E7 05BB
+qofsegol;05E7 05B6
+qofsegolhebrew;05E7 05B6
+qofsheva;05E7 05B0
+qofshevahebrew;05E7 05B0
+qoftsere;05E7 05B5
+qoftserehebrew;05E7 05B5
+qparen;24AC
+quarternote;2669
+qubuts;05BB
+qubuts18;05BB
+qubuts25;05BB
+qubuts31;05BB
+qubutshebrew;05BB
+qubutsnarrowhebrew;05BB
+qubutsquarterhebrew;05BB
+qubutswidehebrew;05BB
+question;003F
+questionarabic;061F
+questionarmenian;055E
+questiondown;00BF
+questiondownsmall;F7BF
+questiongreek;037E
+questionmonospace;FF1F
+questionsmall;F73F
+quotedbl;0022
+quotedblbase;201E
+quotedblleft;201C
+quotedblmonospace;FF02
+quotedblprime;301E
+quotedblprimereversed;301D
+quotedblright;201D
+quoteleft;2018
+quoteleftreversed;201B
+quotereversed;201B
+quoteright;2019
+quoterightn;0149
+quotesinglbase;201A
+quotesingle;0027
+quotesinglemonospace;FF07
+r;0072
+raarmenian;057C
+rabengali;09B0
+racute;0155
+radeva;0930
+radical;221A
+radicalex;F8E5
+radoverssquare;33AE
+radoverssquaredsquare;33AF
+radsquare;33AD
+rafe;05BF
+rafehebrew;05BF
+ragujarati;0AB0
+ragurmukhi;0A30
+rahiragana;3089
+rakatakana;30E9
+rakatakanahalfwidth;FF97
+ralowerdiagonalbengali;09F1
+ramiddlediagonalbengali;09F0
+ramshorn;0264
+ratio;2236
+rbopomofo;3116
+rcaron;0159
+rcedilla;0157
+rcircle;24E1
+rcommaaccent;0157
+rdblgrave;0211
+rdotaccent;1E59
+rdotbelow;1E5B
+rdotbelowmacron;1E5D
+referencemark;203B
+reflexsubset;2286
+reflexsuperset;2287
+registered;00AE
+registersans;F8E8
+registerserif;F6DA
+reharabic;0631
+reharmenian;0580
+rehfinalarabic;FEAE
+rehiragana;308C
+rehyehaleflamarabic;0631 FEF3 FE8E 0644
+rekatakana;30EC
+rekatakanahalfwidth;FF9A
+resh;05E8
+reshdageshhebrew;FB48
+reshhatafpatah;05E8 05B2
+reshhatafpatahhebrew;05E8 05B2
+reshhatafsegol;05E8 05B1
+reshhatafsegolhebrew;05E8 05B1
+reshhebrew;05E8
+reshhiriq;05E8 05B4
+reshhiriqhebrew;05E8 05B4
+reshholam;05E8 05B9
+reshholamhebrew;05E8 05B9
+reshpatah;05E8 05B7
+reshpatahhebrew;05E8 05B7
+reshqamats;05E8 05B8
+reshqamatshebrew;05E8 05B8
+reshqubuts;05E8 05BB
+reshqubutshebrew;05E8 05BB
+reshsegol;05E8 05B6
+reshsegolhebrew;05E8 05B6
+reshsheva;05E8 05B0
+reshshevahebrew;05E8 05B0
+reshtsere;05E8 05B5
+reshtserehebrew;05E8 05B5
+reversedtilde;223D
+reviahebrew;0597
+reviamugrashhebrew;0597
+revlogicalnot;2310
+rfishhook;027E
+rfishhookreversed;027F
+rhabengali;09DD
+rhadeva;095D
+rho;03C1
+rhook;027D
+rhookturned;027B
+rhookturnedsuperior;02B5
+rhosymbolgreek;03F1
+rhotichookmod;02DE
+rieulacirclekorean;3271
+rieulaparenkorean;3211
+rieulcirclekorean;3263
+rieulhieuhkorean;3140
+rieulkiyeokkorean;313A
+rieulkiyeoksioskorean;3169
+rieulkorean;3139
+rieulmieumkorean;313B
+rieulpansioskorean;316C
+rieulparenkorean;3203
+rieulphieuphkorean;313F
+rieulpieupkorean;313C
+rieulpieupsioskorean;316B
+rieulsioskorean;313D
+rieulthieuthkorean;313E
+rieultikeutkorean;316A
+rieulyeorinhieuhkorean;316D
+rightangle;221F
+righttackbelowcmb;0319
+righttriangle;22BF
+rihiragana;308A
+rikatakana;30EA
+rikatakanahalfwidth;FF98
+ring;02DA
+ringbelowcmb;0325
+ringcmb;030A
+ringhalfleft;02BF
+ringhalfleftarmenian;0559
+ringhalfleftbelowcmb;031C
+ringhalfleftcentered;02D3
+ringhalfright;02BE
+ringhalfrightbelowcmb;0339
+ringhalfrightcentered;02D2
+rinvertedbreve;0213
+rittorusquare;3351
+rlinebelow;1E5F
+rlongleg;027C
+rlonglegturned;027A
+rmonospace;FF52
+rohiragana;308D
+rokatakana;30ED
+rokatakanahalfwidth;FF9B
+roruathai;0E23
+rparen;24AD
+rrabengali;09DC
+rradeva;0931
+rragurmukhi;0A5C
+rreharabic;0691
+rrehfinalarabic;FB8D
+rrvocalicbengali;09E0
+rrvocalicdeva;0960
+rrvocalicgujarati;0AE0
+rrvocalicvowelsignbengali;09C4
+rrvocalicvowelsigndeva;0944
+rrvocalicvowelsigngujarati;0AC4
+rsuperior;F6F1
+rtblock;2590
+rturned;0279
+rturnedsuperior;02B4
+ruhiragana;308B
+rukatakana;30EB
+rukatakanahalfwidth;FF99
+rupeemarkbengali;09F2
+rupeesignbengali;09F3
+rupiah;F6DD
+ruthai;0E24
+rvocalicbengali;098B
+rvocalicdeva;090B
+rvocalicgujarati;0A8B
+rvocalicvowelsignbengali;09C3
+rvocalicvowelsigndeva;0943
+rvocalicvowelsigngujarati;0AC3
+s;0073
+sabengali;09B8
+sacute;015B
+sacutedotaccent;1E65
+sadarabic;0635
+sadeva;0938
+sadfinalarabic;FEBA
+sadinitialarabic;FEBB
+sadmedialarabic;FEBC
+sagujarati;0AB8
+sagurmukhi;0A38
+sahiragana;3055
+sakatakana;30B5
+sakatakanahalfwidth;FF7B
+sallallahoualayhewasallamarabic;FDFA
+samekh;05E1
+samekhdagesh;FB41
+samekhdageshhebrew;FB41
+samekhhebrew;05E1
+saraaathai;0E32
+saraaethai;0E41
+saraaimaimalaithai;0E44
+saraaimaimuanthai;0E43
+saraamthai;0E33
+saraathai;0E30
+saraethai;0E40
+saraiileftthai;F886
+saraiithai;0E35
+saraileftthai;F885
+saraithai;0E34
+saraothai;0E42
+saraueeleftthai;F888
+saraueethai;0E37
+saraueleftthai;F887
+sarauethai;0E36
+sarauthai;0E38
+sarauuthai;0E39
+sbopomofo;3119
+scaron;0161
+scarondotaccent;1E67
+scedilla;015F
+schwa;0259
+schwacyrillic;04D9
+schwadieresiscyrillic;04DB
+schwahook;025A
+scircle;24E2
+scircumflex;015D
+scommaaccent;0219
+sdotaccent;1E61
+sdotbelow;1E63
+sdotbelowdotaccent;1E69
+seagullbelowcmb;033C
+second;2033
+secondtonechinese;02CA
+section;00A7
+seenarabic;0633
+seenfinalarabic;FEB2
+seeninitialarabic;FEB3
+seenmedialarabic;FEB4
+segol;05B6
+segol13;05B6
+segol1f;05B6
+segol2c;05B6
+segolhebrew;05B6
+segolnarrowhebrew;05B6
+segolquarterhebrew;05B6
+segoltahebrew;0592
+segolwidehebrew;05B6
+seharmenian;057D
+sehiragana;305B
+sekatakana;30BB
+sekatakanahalfwidth;FF7E
+semicolon;003B
+semicolonarabic;061B
+semicolonmonospace;FF1B
+semicolonsmall;FE54
+semivoicedmarkkana;309C
+semivoicedmarkkanahalfwidth;FF9F
+sentisquare;3322
+sentosquare;3323
+seven;0037
+sevenarabic;0667
+sevenbengali;09ED
+sevencircle;2466
+sevencircleinversesansserif;2790
+sevendeva;096D
+seveneighths;215E
+sevengujarati;0AED
+sevengurmukhi;0A6D
+sevenhackarabic;0667
+sevenhangzhou;3027
+sevenideographicparen;3226
+seveninferior;2087
+sevenmonospace;FF17
+sevenoldstyle;F737
+sevenparen;247A
+sevenperiod;248E
+sevenpersian;06F7
+sevenroman;2176
+sevensuperior;2077
+seventeencircle;2470
+seventeenparen;2484
+seventeenperiod;2498
+seventhai;0E57
+sfthyphen;00AD
+shaarmenian;0577
+shabengali;09B6
+shacyrillic;0448
+shaddaarabic;0651
+shaddadammaarabic;FC61
+shaddadammatanarabic;FC5E
+shaddafathaarabic;FC60
+shaddafathatanarabic;0651 064B
+shaddakasraarabic;FC62
+shaddakasratanarabic;FC5F
+shade;2592
+shadedark;2593
+shadelight;2591
+shademedium;2592
+shadeva;0936
+shagujarati;0AB6
+shagurmukhi;0A36
+shalshelethebrew;0593
+shbopomofo;3115
+shchacyrillic;0449
+sheenarabic;0634
+sheenfinalarabic;FEB6
+sheeninitialarabic;FEB7
+sheenmedialarabic;FEB8
+sheicoptic;03E3
+sheqel;20AA
+sheqelhebrew;20AA
+sheva;05B0
+sheva115;05B0
+sheva15;05B0
+sheva22;05B0
+sheva2e;05B0
+shevahebrew;05B0
+shevanarrowhebrew;05B0
+shevaquarterhebrew;05B0
+shevawidehebrew;05B0
+shhacyrillic;04BB
+shimacoptic;03ED
+shin;05E9
+shindagesh;FB49
+shindageshhebrew;FB49
+shindageshshindot;FB2C
+shindageshshindothebrew;FB2C
+shindageshsindot;FB2D
+shindageshsindothebrew;FB2D
+shindothebrew;05C1
+shinhebrew;05E9
+shinshindot;FB2A
+shinshindothebrew;FB2A
+shinsindot;FB2B
+shinsindothebrew;FB2B
+shook;0282
+sigma;03C3
+sigma1;03C2
+sigmafinal;03C2
+sigmalunatesymbolgreek;03F2
+sihiragana;3057
+sikatakana;30B7
+sikatakanahalfwidth;FF7C
+siluqhebrew;05BD
+siluqlefthebrew;05BD
+similar;223C
+sindothebrew;05C2
+siosacirclekorean;3274
+siosaparenkorean;3214
+sioscieuckorean;317E
+sioscirclekorean;3266
+sioskiyeokkorean;317A
+sioskorean;3145
+siosnieunkorean;317B
+siosparenkorean;3206
+siospieupkorean;317D
+siostikeutkorean;317C
+six;0036
+sixarabic;0666
+sixbengali;09EC
+sixcircle;2465
+sixcircleinversesansserif;278F
+sixdeva;096C
+sixgujarati;0AEC
+sixgurmukhi;0A6C
+sixhackarabic;0666
+sixhangzhou;3026
+sixideographicparen;3225
+sixinferior;2086
+sixmonospace;FF16
+sixoldstyle;F736
+sixparen;2479
+sixperiod;248D
+sixpersian;06F6
+sixroman;2175
+sixsuperior;2076
+sixteencircle;246F
+sixteencurrencydenominatorbengali;09F9
+sixteenparen;2483
+sixteenperiod;2497
+sixthai;0E56
+slash;002F
+slashmonospace;FF0F
+slong;017F
+slongdotaccent;1E9B
+smileface;263A
+smonospace;FF53
+sofpasuqhebrew;05C3
+softhyphen;00AD
+softsigncyrillic;044C
+sohiragana;305D
+sokatakana;30BD
+sokatakanahalfwidth;FF7F
+soliduslongoverlaycmb;0338
+solidusshortoverlaycmb;0337
+sorusithai;0E29
+sosalathai;0E28
+sosothai;0E0B
+sosuathai;0E2A
+space;0020
+spacehackarabic;0020
+spade;2660
+spadesuitblack;2660
+spadesuitwhite;2664
+sparen;24AE
+squarebelowcmb;033B
+squarecc;33C4
+squarecm;339D
+squarediagonalcrosshatchfill;25A9
+squarehorizontalfill;25A4
+squarekg;338F
+squarekm;339E
+squarekmcapital;33CE
+squareln;33D1
+squarelog;33D2
+squaremg;338E
+squaremil;33D5
+squaremm;339C
+squaremsquared;33A1
+squareorthogonalcrosshatchfill;25A6
+squareupperlefttolowerrightfill;25A7
+squareupperrighttolowerleftfill;25A8
+squareverticalfill;25A5
+squarewhitewithsmallblack;25A3
+srsquare;33DB
+ssabengali;09B7
+ssadeva;0937
+ssagujarati;0AB7
+ssangcieuckorean;3149
+ssanghieuhkorean;3185
+ssangieungkorean;3180
+ssangkiyeokkorean;3132
+ssangnieunkorean;3165
+ssangpieupkorean;3143
+ssangsioskorean;3146
+ssangtikeutkorean;3138
+ssuperior;F6F2
+sterling;00A3
+sterlingmonospace;FFE1
+strokelongoverlaycmb;0336
+strokeshortoverlaycmb;0335
+subset;2282
+subsetnotequal;228A
+subsetorequal;2286
+succeeds;227B
+suchthat;220B
+suhiragana;3059
+sukatakana;30B9
+sukatakanahalfwidth;FF7D
+sukunarabic;0652
+summation;2211
+sun;263C
+superset;2283
+supersetnotequal;228B
+supersetorequal;2287
+svsquare;33DC
+syouwaerasquare;337C
+t;0074
+tabengali;09A4
+tackdown;22A4
+tackleft;22A3
+tadeva;0924
+tagujarati;0AA4
+tagurmukhi;0A24
+taharabic;0637
+tahfinalarabic;FEC2
+tahinitialarabic;FEC3
+tahiragana;305F
+tahmedialarabic;FEC4
+taisyouerasquare;337D
+takatakana;30BF
+takatakanahalfwidth;FF80
+tatweelarabic;0640
+tau;03C4
+tav;05EA
+tavdages;FB4A
+tavdagesh;FB4A
+tavdageshhebrew;FB4A
+tavhebrew;05EA
+tbar;0167
+tbopomofo;310A
+tcaron;0165
+tccurl;02A8
+tcedilla;0163
+tcheharabic;0686
+tchehfinalarabic;FB7B
+tchehinitialarabic;FB7C
+tchehmedialarabic;FB7D
+tchehmeeminitialarabic;FB7C FEE4
+tcircle;24E3
+tcircumflexbelow;1E71
+tcommaaccent;0163
+tdieresis;1E97
+tdotaccent;1E6B
+tdotbelow;1E6D
+tecyrillic;0442
+tedescendercyrillic;04AD
+teharabic;062A
+tehfinalarabic;FE96
+tehhahinitialarabic;FCA2
+tehhahisolatedarabic;FC0C
+tehinitialarabic;FE97
+tehiragana;3066
+tehjeeminitialarabic;FCA1
+tehjeemisolatedarabic;FC0B
+tehmarbutaarabic;0629
+tehmarbutafinalarabic;FE94
+tehmedialarabic;FE98
+tehmeeminitialarabic;FCA4
+tehmeemisolatedarabic;FC0E
+tehnoonfinalarabic;FC73
+tekatakana;30C6
+tekatakanahalfwidth;FF83
+telephone;2121
+telephoneblack;260E
+telishagedolahebrew;05A0
+telishaqetanahebrew;05A9
+tencircle;2469
+tenideographicparen;3229
+tenparen;247D
+tenperiod;2491
+tenroman;2179
+tesh;02A7
+tet;05D8
+tetdagesh;FB38
+tetdageshhebrew;FB38
+tethebrew;05D8
+tetsecyrillic;04B5
+tevirhebrew;059B
+tevirlefthebrew;059B
+thabengali;09A5
+thadeva;0925
+thagujarati;0AA5
+thagurmukhi;0A25
+thalarabic;0630
+thalfinalarabic;FEAC
+thanthakhatlowleftthai;F898
+thanthakhatlowrightthai;F897
+thanthakhatthai;0E4C
+thanthakhatupperleftthai;F896
+theharabic;062B
+thehfinalarabic;FE9A
+thehinitialarabic;FE9B
+thehmedialarabic;FE9C
+thereexists;2203
+therefore;2234
+theta;03B8
+theta1;03D1
+thetasymbolgreek;03D1
+thieuthacirclekorean;3279
+thieuthaparenkorean;3219
+thieuthcirclekorean;326B
+thieuthkorean;314C
+thieuthparenkorean;320B
+thirteencircle;246C
+thirteenparen;2480
+thirteenperiod;2494
+thonangmonthothai;0E11
+thook;01AD
+thophuthaothai;0E12
+thorn;00FE
+thothahanthai;0E17
+thothanthai;0E10
+thothongthai;0E18
+thothungthai;0E16
+thousandcyrillic;0482
+thousandsseparatorarabic;066C
+thousandsseparatorpersian;066C
+three;0033
+threearabic;0663
+threebengali;09E9
+threecircle;2462
+threecircleinversesansserif;278C
+threedeva;0969
+threeeighths;215C
+threegujarati;0AE9
+threegurmukhi;0A69
+threehackarabic;0663
+threehangzhou;3023
+threeideographicparen;3222
+threeinferior;2083
+threemonospace;FF13
+threenumeratorbengali;09F6
+threeoldstyle;F733
+threeparen;2476
+threeperiod;248A
+threepersian;06F3
+threequarters;00BE
+threequartersemdash;F6DE
+threeroman;2172
+threesuperior;00B3
+threethai;0E53
+thzsquare;3394
+tihiragana;3061
+tikatakana;30C1
+tikatakanahalfwidth;FF81
+tikeutacirclekorean;3270
+tikeutaparenkorean;3210
+tikeutcirclekorean;3262
+tikeutkorean;3137
+tikeutparenkorean;3202
+tilde;02DC
+tildebelowcmb;0330
+tildecmb;0303
+tildecomb;0303
+tildedoublecmb;0360
+tildeoperator;223C
+tildeoverlaycmb;0334
+tildeverticalcmb;033E
+timescircle;2297
+tipehahebrew;0596
+tipehalefthebrew;0596
+tippigurmukhi;0A70
+titlocyrilliccmb;0483
+tiwnarmenian;057F
+tlinebelow;1E6F
+tmonospace;FF54
+toarmenian;0569
+tohiragana;3068
+tokatakana;30C8
+tokatakanahalfwidth;FF84
+tonebarextrahighmod;02E5
+tonebarextralowmod;02E9
+tonebarhighmod;02E6
+tonebarlowmod;02E8
+tonebarmidmod;02E7
+tonefive;01BD
+tonesix;0185
+tonetwo;01A8
+tonos;0384
+tonsquare;3327
+topatakthai;0E0F
+tortoiseshellbracketleft;3014
+tortoiseshellbracketleftsmall;FE5D
+tortoiseshellbracketleftvertical;FE39
+tortoiseshellbracketright;3015
+tortoiseshellbracketrightsmall;FE5E
+tortoiseshellbracketrightvertical;FE3A
+totaothai;0E15
+tpalatalhook;01AB
+tparen;24AF
+trademark;2122
+trademarksans;F8EA
+trademarkserif;F6DB
+tretroflexhook;0288
+triagdn;25BC
+triaglf;25C4
+triagrt;25BA
+triagup;25B2
+ts;02A6
+tsadi;05E6
+tsadidagesh;FB46
+tsadidageshhebrew;FB46
+tsadihebrew;05E6
+tsecyrillic;0446
+tsere;05B5
+tsere12;05B5
+tsere1e;05B5
+tsere2b;05B5
+tserehebrew;05B5
+tserenarrowhebrew;05B5
+tserequarterhebrew;05B5
+tserewidehebrew;05B5
+tshecyrillic;045B
+tsuperior;F6F3
+ttabengali;099F
+ttadeva;091F
+ttagujarati;0A9F
+ttagurmukhi;0A1F
+tteharabic;0679
+ttehfinalarabic;FB67
+ttehinitialarabic;FB68
+ttehmedialarabic;FB69
+tthabengali;09A0
+tthadeva;0920
+tthagujarati;0AA0
+tthagurmukhi;0A20
+tturned;0287
+tuhiragana;3064
+tukatakana;30C4
+tukatakanahalfwidth;FF82
+tusmallhiragana;3063
+tusmallkatakana;30C3
+tusmallkatakanahalfwidth;FF6F
+twelvecircle;246B
+twelveparen;247F
+twelveperiod;2493
+twelveroman;217B
+twentycircle;2473
+twentyhangzhou;5344
+twentyparen;2487
+twentyperiod;249B
+two;0032
+twoarabic;0662
+twobengali;09E8
+twocircle;2461
+twocircleinversesansserif;278B
+twodeva;0968
+twodotenleader;2025
+twodotleader;2025
+twodotleadervertical;FE30
+twogujarati;0AE8
+twogurmukhi;0A68
+twohackarabic;0662
+twohangzhou;3022
+twoideographicparen;3221
+twoinferior;2082
+twomonospace;FF12
+twonumeratorbengali;09F5
+twooldstyle;F732
+twoparen;2475
+twoperiod;2489
+twopersian;06F2
+tworoman;2171
+twostroke;01BB
+twosuperior;00B2
+twothai;0E52
+twothirds;2154
+u;0075
+uacute;00FA
+ubar;0289
+ubengali;0989
+ubopomofo;3128
+ubreve;016D
+ucaron;01D4
+ucircle;24E4
+ucircumflex;00FB
+ucircumflexbelow;1E77
+ucyrillic;0443
+udattadeva;0951
+udblacute;0171
+udblgrave;0215
+udeva;0909
+udieresis;00FC
+udieresisacute;01D8
+udieresisbelow;1E73
+udieresiscaron;01DA
+udieresiscyrillic;04F1
+udieresisgrave;01DC
+udieresismacron;01D6
+udotbelow;1EE5
+ugrave;00F9
+ugujarati;0A89
+ugurmukhi;0A09
+uhiragana;3046
+uhookabove;1EE7
+uhorn;01B0
+uhornacute;1EE9
+uhorndotbelow;1EF1
+uhorngrave;1EEB
+uhornhookabove;1EED
+uhorntilde;1EEF
+uhungarumlaut;0171
+uhungarumlautcyrillic;04F3
+uinvertedbreve;0217
+ukatakana;30A6
+ukatakanahalfwidth;FF73
+ukcyrillic;0479
+ukorean;315C
+umacron;016B
+umacroncyrillic;04EF
+umacrondieresis;1E7B
+umatragurmukhi;0A41
+umonospace;FF55
+underscore;005F
+underscoredbl;2017
+underscoremonospace;FF3F
+underscorevertical;FE33
+underscorewavy;FE4F
+union;222A
+universal;2200
+uogonek;0173
+uparen;24B0
+upblock;2580
+upperdothebrew;05C4
+upsilon;03C5
+upsilondieresis;03CB
+upsilondieresistonos;03B0
+upsilonlatin;028A
+upsilontonos;03CD
+uptackbelowcmb;031D
+uptackmod;02D4
+uragurmukhi;0A73
+uring;016F
+ushortcyrillic;045E
+usmallhiragana;3045
+usmallkatakana;30A5
+usmallkatakanahalfwidth;FF69
+ustraightcyrillic;04AF
+ustraightstrokecyrillic;04B1
+utilde;0169
+utildeacute;1E79
+utildebelow;1E75
+uubengali;098A
+uudeva;090A
+uugujarati;0A8A
+uugurmukhi;0A0A
+uumatragurmukhi;0A42
+uuvowelsignbengali;09C2
+uuvowelsigndeva;0942
+uuvowelsigngujarati;0AC2
+uvowelsignbengali;09C1
+uvowelsigndeva;0941
+uvowelsigngujarati;0AC1
+v;0076
+vadeva;0935
+vagujarati;0AB5
+vagurmukhi;0A35
+vakatakana;30F7
+vav;05D5
+vavdagesh;FB35
+vavdagesh65;FB35
+vavdageshhebrew;FB35
+vavhebrew;05D5
+vavholam;FB4B
+vavholamhebrew;FB4B
+vavvavhebrew;05F0
+vavyodhebrew;05F1
+vcircle;24E5
+vdotbelow;1E7F
+vecyrillic;0432
+veharabic;06A4
+vehfinalarabic;FB6B
+vehinitialarabic;FB6C
+vehmedialarabic;FB6D
+vekatakana;30F9
+venus;2640
+verticalbar;007C
+verticallineabovecmb;030D
+verticallinebelowcmb;0329
+verticallinelowmod;02CC
+verticallinemod;02C8
+vewarmenian;057E
+vhook;028B
+vikatakana;30F8
+viramabengali;09CD
+viramadeva;094D
+viramagujarati;0ACD
+visargabengali;0983
+visargadeva;0903
+visargagujarati;0A83
+vmonospace;FF56
+voarmenian;0578
+voicediterationhiragana;309E
+voicediterationkatakana;30FE
+voicedmarkkana;309B
+voicedmarkkanahalfwidth;FF9E
+vokatakana;30FA
+vparen;24B1
+vtilde;1E7D
+vturned;028C
+vuhiragana;3094
+vukatakana;30F4
+w;0077
+wacute;1E83
+waekorean;3159
+wahiragana;308F
+wakatakana;30EF
+wakatakanahalfwidth;FF9C
+wakorean;3158
+wasmallhiragana;308E
+wasmallkatakana;30EE
+wattosquare;3357
+wavedash;301C
+wavyunderscorevertical;FE34
+wawarabic;0648
+wawfinalarabic;FEEE
+wawhamzaabovearabic;0624
+wawhamzaabovefinalarabic;FE86
+wbsquare;33DD
+wcircle;24E6
+wcircumflex;0175
+wdieresis;1E85
+wdotaccent;1E87
+wdotbelow;1E89
+wehiragana;3091
+weierstrass;2118
+wekatakana;30F1
+wekorean;315E
+weokorean;315D
+wgrave;1E81
+whitebullet;25E6
+whitecircle;25CB
+whitecircleinverse;25D9
+whitecornerbracketleft;300E
+whitecornerbracketleftvertical;FE43
+whitecornerbracketright;300F
+whitecornerbracketrightvertical;FE44
+whitediamond;25C7
+whitediamondcontainingblacksmalldiamond;25C8
+whitedownpointingsmalltriangle;25BF
+whitedownpointingtriangle;25BD
+whiteleftpointingsmalltriangle;25C3
+whiteleftpointingtriangle;25C1
+whitelenticularbracketleft;3016
+whitelenticularbracketright;3017
+whiterightpointingsmalltriangle;25B9
+whiterightpointingtriangle;25B7
+whitesmallsquare;25AB
+whitesmilingface;263A
+whitesquare;25A1
+whitestar;2606
+whitetelephone;260F
+whitetortoiseshellbracketleft;3018
+whitetortoiseshellbracketright;3019
+whiteuppointingsmalltriangle;25B5
+whiteuppointingtriangle;25B3
+wihiragana;3090
+wikatakana;30F0
+wikorean;315F
+wmonospace;FF57
+wohiragana;3092
+wokatakana;30F2
+wokatakanahalfwidth;FF66
+won;20A9
+wonmonospace;FFE6
+wowaenthai;0E27
+wparen;24B2
+wring;1E98
+wsuperior;02B7
+wturned;028D
+wynn;01BF
+x;0078
+xabovecmb;033D
+xbopomofo;3112
+xcircle;24E7
+xdieresis;1E8D
+xdotaccent;1E8B
+xeharmenian;056D
+xi;03BE
+xmonospace;FF58
+xparen;24B3
+xsuperior;02E3
+y;0079
+yaadosquare;334E
+yabengali;09AF
+yacute;00FD
+yadeva;092F
+yaekorean;3152
+yagujarati;0AAF
+yagurmukhi;0A2F
+yahiragana;3084
+yakatakana;30E4
+yakatakanahalfwidth;FF94
+yakorean;3151
+yamakkanthai;0E4E
+yasmallhiragana;3083
+yasmallkatakana;30E3
+yasmallkatakanahalfwidth;FF6C
+yatcyrillic;0463
+ycircle;24E8
+ycircumflex;0177
+ydieresis;00FF
+ydotaccent;1E8F
+ydotbelow;1EF5
+yeharabic;064A
+yehbarreearabic;06D2
+yehbarreefinalarabic;FBAF
+yehfinalarabic;FEF2
+yehhamzaabovearabic;0626
+yehhamzaabovefinalarabic;FE8A
+yehhamzaaboveinitialarabic;FE8B
+yehhamzaabovemedialarabic;FE8C
+yehinitialarabic;FEF3
+yehmedialarabic;FEF4
+yehmeeminitialarabic;FCDD
+yehmeemisolatedarabic;FC58
+yehnoonfinalarabic;FC94
+yehthreedotsbelowarabic;06D1
+yekorean;3156
+yen;00A5
+yenmonospace;FFE5
+yeokorean;3155
+yeorinhieuhkorean;3186
+yerahbenyomohebrew;05AA
+yerahbenyomolefthebrew;05AA
+yericyrillic;044B
+yerudieresiscyrillic;04F9
+yesieungkorean;3181
+yesieungpansioskorean;3183
+yesieungsioskorean;3182
+yetivhebrew;059A
+ygrave;1EF3
+yhook;01B4
+yhookabove;1EF7
+yiarmenian;0575
+yicyrillic;0457
+yikorean;3162
+yinyang;262F
+yiwnarmenian;0582
+ymonospace;FF59
+yod;05D9
+yoddagesh;FB39
+yoddageshhebrew;FB39
+yodhebrew;05D9
+yodyodhebrew;05F2
+yodyodpatahhebrew;FB1F
+yohiragana;3088
+yoikorean;3189
+yokatakana;30E8
+yokatakanahalfwidth;FF96
+yokorean;315B
+yosmallhiragana;3087
+yosmallkatakana;30E7
+yosmallkatakanahalfwidth;FF6E
+yotgreek;03F3
+yoyaekorean;3188
+yoyakorean;3187
+yoyakthai;0E22
+yoyingthai;0E0D
+yparen;24B4
+ypogegrammeni;037A
+ypogegrammenigreekcmb;0345
+yr;01A6
+yring;1E99
+ysuperior;02B8
+ytilde;1EF9
+yturned;028E
+yuhiragana;3086
+yuikorean;318C
+yukatakana;30E6
+yukatakanahalfwidth;FF95
+yukorean;3160
+yusbigcyrillic;046B
+yusbigiotifiedcyrillic;046D
+yuslittlecyrillic;0467
+yuslittleiotifiedcyrillic;0469
+yusmallhiragana;3085
+yusmallkatakana;30E5
+yusmallkatakanahalfwidth;FF6D
+yuyekorean;318B
+yuyeokorean;318A
+yyabengali;09DF
+yyadeva;095F
+z;007A
+zaarmenian;0566
+zacute;017A
+zadeva;095B
+zagurmukhi;0A5B
+zaharabic;0638
+zahfinalarabic;FEC6
+zahinitialarabic;FEC7
+zahiragana;3056
+zahmedialarabic;FEC8
+zainarabic;0632
+zainfinalarabic;FEB0
+zakatakana;30B6
+zaqefgadolhebrew;0595
+zaqefqatanhebrew;0594
+zarqahebrew;0598
+zayin;05D6
+zayindagesh;FB36
+zayindageshhebrew;FB36
+zayinhebrew;05D6
+zbopomofo;3117
+zcaron;017E
+zcircle;24E9
+zcircumflex;1E91
+zcurl;0291
+zdot;017C
+zdotaccent;017C
+zdotbelow;1E93
+zecyrillic;0437
+zedescendercyrillic;0499
+zedieresiscyrillic;04DF
+zehiragana;305C
+zekatakana;30BC
+zero;0030
+zeroarabic;0660
+zerobengali;09E6
+zerodeva;0966
+zerogujarati;0AE6
+zerogurmukhi;0A66
+zerohackarabic;0660
+zeroinferior;2080
+zeromonospace;FF10
+zerooldstyle;F730
+zeropersian;06F0
+zerosuperior;2070
+zerothai;0E50
+zerowidthjoiner;FEFF
+zerowidthnonjoiner;200C
+zerowidthspace;200B
+zeta;03B6
+zhbopomofo;3113
+zhearmenian;056A
+zhebrevecyrillic;04C2
+zhecyrillic;0436
+zhedescendercyrillic;0497
+zhedieresiscyrillic;04DD
+zihiragana;3058
+zikatakana;30B8
+zinorhebrew;05AE
+zlinebelow;1E95
+zmonospace;FF5A
+zohiragana;305E
+zokatakana;30BE
+zparen;24B5
+zretroflexhook;0290
+zstroke;01B6
+zuhiragana;305A
+zukatakana;30BA
+"""
+
+
+t1_bias    = 0
+glyph_list = []
+
+
+def adobe_glyph_names():
+  """return the list of glyph names from the adobe list"""
+
+  lines  = string.split( adobe_glyph_list, '\n' )
+  glyphs = []
+
+  for line in lines:
+    if line:
+      fields = string.split( line, ';' )
+#     print fields[1] + ' - ' + fields[0]
+      glyphs.append( fields[0] )
+
+  return glyphs
+
+
+def adobe_glyph_values():
+  """return the list of glyph names and their unicode values"""
+
+  lines  = string.split( adobe_glyph_list, '\n' )
+  glyphs = []
+  values = []
+
+  for line in lines:
+    if line:
+      fields = string.split( line, ';' )
+#     print fields[1] + ' - ' + fields[0]
+      subfields = string.split( fields[1], ' ' )
+      if len( subfields ) == 1:
+        glyphs.append( fields[0] )
+        values.append( fields[1] )
+
+  return glyphs, values
+
+
+def filter_glyph_names( alist, filter ):
+  """filter 'alist' by taking _out_ all glyph names that are in 'filter'"""
+
+  count  = 0
+  extras = []
+
+  for name in alist:
+    try:
+      filtered_index = filter.index( name )
+    except:
+      extras.append( name )
+
+  return extras
+
+
+def dump_mac_indices( file, all_glyphs ):
+  write = file.write
+
+  write( "  static const unsigned short  mac_standard_names[" + \
+         repr( len( mac_standard_names ) + 1 ) + "] =\n" )
+  write( "  {\n" )
+
+  for name in mac_standard_names:
+    write( "    " + repr( all_glyphs.index( name ) ) + ",\n" )
+
+  write( "    0\n" )
+  write( "  };\n" )
+  write( "\n" )
+  write( "\n" )
+
+
+def dump_glyph_list( file, base_list, adobe_list ):
+  write = file.write
+
+  name_list = []
+
+  write( "  static const char* const  ps_glyph_names[] =\n" )
+  write( "  {\n" )
+
+  for name in base_list:
+    write( '    "' + name + '",\n' )
+    name_list.append( name )
+
+  write( "\n" )
+  write( "#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST\n" )
+  write( "\n" )
+
+  for name in adobe_list:
+    write( '    "' + name + '",\n' )
+    name_list.append( name )
+
+  write( "\n" )
+  write( "#endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */\n" )
+  write( "\n" )
+  write( "    NULL\n" )
+  write( "  };\n" )
+  write( "\n" )
+  write( "\n" )
+
+  return name_list
+
+
+def dump_unicode_values( file, sid_list, adobe_list ):
+  """build the glyph names to unicode values table"""
+
+  write = file.write
+
+  agl_names, agl_unicodes = adobe_glyph_values()
+
+  write( "\n" )
+  write( "  static const unsigned short  ps_names_to_unicode[" + \
+          repr( len( sid_list ) + len( adobe_list ) + 1 ) + "] =\n" )
+  write( "  {\n" )
+
+  for name in sid_list:
+    try:
+      index = agl_names.index( name )
+      write( "    0x" + agl_unicodes[index] + "U,\n" )
+    except:
+      write( "    0,\n" )
+
+  write( "\n" )
+  write( "#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST\n" )
+  write( "\n" )
+
+  for name in adobe_list:
+    try:
+      index = agl_names.index( name )
+      write( "    0x" + agl_unicodes[index] + "U,\n" )
+    except:
+      write( "    0,\n" )
+
+  write( "\n" )
+  write( "#endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */\n" )
+  write( "    0\n" )
+  write( "  };\n" )
+  write( "\n" )
+  write( "\n" )
+  write( "\n" )
+
+
+def dump_encoding( file, encoding_name, encoding_list ):
+  """dumps a given encoding"""
+
+  write = file.write
+
+  write( "  static const unsigned short  " + encoding_name + "[" + \
+          repr( len( encoding_list ) + 1 ) + "] =\n" )
+  write( "  {\n" )
+
+  for value in encoding_list:
+    write( "    " + repr( value ) + ",\n" )
+  write( "    0\n" )
+  write( "  };\n" )
+  write( "\n" )
+  write( "\n" )
+
+
+def main():
+  """main program body"""
+
+  if len( sys.argv ) != 2:
+    print __doc__ % sys.argv[0]
+    sys.exit( 1 )
+
+  file  = open( sys.argv[1], "w\n" )
+  write = file.write
+
+  count_sid = len( sid_standard_names )
+
+  # 'mac_extras' contains the list of glyph names in the Macintosh standard
+  # encoding which are not in either the Adobe Glyph List or the SID
+  # Standard Names.
+  #
+  mac_extras = filter_glyph_names( mac_standard_names, adobe_glyph_names() )
+  mac_extras = filter_glyph_names( mac_extras, sid_standard_names )
+
+  # 'base_list' contains the first names of our final glyph names table.
+  # It consists of the 'mac_extras' glyph names, followed by the SID
+  # Standard names.
+  #
+  mac_extras_count = len( mac_extras )
+  t1_bias          = mac_extras_count
+  base_list        = mac_extras + sid_standard_names
+
+  # 'adobe_list' contains the glyph names that are in the AGL, but not in
+  # the base_list; they will be placed after base_list glyph names in
+  # our final table.
+  #
+  adobe_list  = filter_glyph_names( adobe_glyph_names(), base_list )
+  adobe_count = len( adobe_list )
+
+  write( "/***************************************************************************/\n" )
+  write( "/*                                                                         */\n" )
+
+  write( "/*  %-71s*/\n" % sys.argv[1] )
+
+  write( "/*                                                                         */\n" )
+  write( "/*    PostScript glyph names (specification only).                         */\n" )
+  write( "/*                                                                         */\n" )
+  write( "/*  Copyright 2000-2001, 2003 by                                           */\n" )
+  write( "/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */\n" )
+  write( "/*                                                                         */\n" )
+  write( "/*  This file is part of the FreeType project, and may only be used,       */\n" )
+  write( "/*  modified, and distributed under the terms of the FreeType project      */\n" )
+  write( "/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */\n" )
+  write( "/*  this file you indicate that you have read the license and              */\n" )
+  write( "/*  understand and accept it fully.                                        */\n" )
+  write( "/*                                                                         */\n" )
+  write( "/***************************************************************************/\n" )
+  write( "\n" )
+  write( "\n" )
+  write( "  /* this file has been generated automatically -- do not edit! */\n" )
+  write( "\n" )
+  write( "\n" )
+
+  # dump final glyph list (mac extras + sid standard names + AGL glyph names)
+  #
+  name_list = dump_glyph_list( file, base_list, adobe_list )
+
+  # dump t1_standard_list
+  write( "  static const char* const * const  sid_standard_names = " \
+          + "ps_glyph_names + " + repr( t1_bias ) + ";\n" )
+  write( "\n" )
+  write( "\n" )
+
+  write( "#define NUM_SID_GLYPHS " + repr( len( sid_standard_names ) ) + "\n" )
+  write( "\n" )
+  write( "#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST\n" )
+  write( "#define NUM_ADOBE_GLYPHS " + \
+          repr( len( base_list ) + len( adobe_list ) - t1_bias ) + "\n" )
+  write( "#else\n" )
+  write( "#define NUM_ADOBE_GLYPHS " + \
+          repr( len( base_list ) - t1_bias )  + "\n" )
+  write( "#endif\n" )
+  write( "\n" )
+  write( "\n" )
+
+  # dump mac indices table
+  dump_mac_indices( file, name_list )
+
+  # dump unicode values table
+  dump_unicode_values( file, sid_standard_names, adobe_list )
+
+  dump_encoding( file, "t1_standard_encoding", t1_standard_encoding )
+  dump_encoding( file, "t1_expert_encoding", t1_expert_encoding )
+
+  write( "/* END */\n" )
+
+
+# Now run the main routine
+#
+main()
+
+
+# END
diff --git a/nx-X11/extras/freetype2/src/tools/test_bbox.c b/nx-X11/extras/freetype2/src/tools/test_bbox.c
new file mode 100644
index 000000000..e085c5b3d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/test_bbox.c
@@ -0,0 +1,160 @@
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_BBOX_H
+
+
+#include <time.h>    /* for clock() */
+
+/* SunOS 4.1.* does not define CLOCKS_PER_SEC, so include <sys/param.h> */
+/* to get the HZ macro which is the equivalent.                         */
+#if defined(__sun__) && !defined(SVR4) && !defined(__SVR4)
+#include <sys/param.h>
+#define CLOCKS_PER_SEC HZ
+#endif
+
+  static long
+  get_time( void )
+  {
+    return clock() * 10000L / CLOCKS_PER_SEC;
+  }
+
+
+
+
+  /* test bbox computations */
+
+#define  XSCALE    65536
+#define  XX(x)     ((FT_Pos)(x*XSCALE))
+#define  XVEC(x,y)  { XX(x), XX(y) }
+#define  XVAL(x)   ((x)/(1.0*XSCALE))
+
+  /* dummy outline #1 */
+  static FT_Vector  dummy_vec_1[4] =
+  {
+#if 1
+    XVEC( 408.9111, 535.3164 ),
+    XVEC( 455.8887, 634.396  ),
+    XVEC( -37.8765, 786.2207 ),
+    XVEC( 164.6074, 535.3164 )
+#else
+    { (FT_Int32)0x0198E93DL , (FT_Int32)0x021750FFL },  /* 408.9111, 535.3164 */
+    { (FT_Int32)0x01C7E312L , (FT_Int32)0x027A6560L },  /* 455.8887, 634.3960 */
+    { (FT_Int32)0xFFDA1F9EL , (FT_Int32)0x0312387FL },  /* -37.8765, 786.2207 */
+    { (FT_Int32)0x00A49B7EL , (FT_Int32)0x021750FFL }   /* 164.6074, 535.3164 */
+#endif
+   };
+
+  static char  dummy_tag_1[4] =
+  {
+    FT_CURVE_TAG_ON,
+    FT_CURVE_TAG_CUBIC,
+    FT_CURVE_TAG_CUBIC,
+    FT_CURVE_TAG_ON
+  };
+
+  static short  dummy_contour_1[1] =
+  {
+    3
+  };
+
+  static FT_Outline  dummy_outline_1 =
+  {
+    1,
+    4,
+    dummy_vec_1,
+    dummy_tag_1,
+    dummy_contour_1,
+    0
+  };
+
+
+  /* dummy outline #2 */
+  static FT_Vector  dummy_vec_2[4] =
+  {
+    XVEC( 100.0, 100.0 ),
+    XVEC( 100.0, 200.0 ),
+    XVEC( 200.0, 200.0 ),
+    XVEC( 200.0, 133.0 )
+  };
+
+  static FT_Outline  dummy_outline_2 =
+  {
+    1,
+    4,
+    dummy_vec_2,
+    dummy_tag_1,
+    dummy_contour_1,
+    0
+  };
+
+
+  static void
+  dump_outline( FT_Outline*  outline )
+  {
+    FT_BBox  bbox;
+
+    /* compute and display cbox */
+    FT_Outline_Get_CBox( outline, &bbox );
+    printf( "cbox = [%.2f %.2f %.2f %.2f]\n",
+             XVAL( bbox.xMin ),
+             XVAL( bbox.yMin ),
+             XVAL( bbox.xMax ),
+             XVAL( bbox.yMax ) );
+
+    /* compute and display bbox */
+    FT_Outline_Get_BBox( outline, &bbox );
+    printf( "bbox = [%.2f %.2f %.2f %.2f]\n",
+             XVAL( bbox.xMin ),
+             XVAL( bbox.yMin ),
+             XVAL( bbox.xMax ),
+             XVAL( bbox.yMax ) );
+  }
+
+
+
+  static void
+  profile_outline( FT_Outline*   outline,
+                   long          repeat )
+  {
+    FT_BBox  bbox;
+    long     count;
+    long     time0;
+
+    time0 = get_time();
+    for ( count = repeat; count > 0; count-- )
+      FT_Outline_Get_CBox( outline, &bbox );
+
+    time0 = get_time() - time0;
+    printf( "time = %5.2f cbox = [%.2f %.2f %.2f %.2f]\n",
+             ((double)time0/10000.0),
+             XVAL( bbox.xMin ),
+             XVAL( bbox.yMin ),
+             XVAL( bbox.xMax ),
+             XVAL( bbox.yMax ) );
+
+
+    time0 = get_time();
+    for ( count = repeat; count > 0; count-- )
+      FT_Outline_Get_BBox( outline, &bbox );
+
+    time0 = get_time() - time0;
+    printf( "time = %5.2f bbox = [%.2f %.2f %.2f %.2f]\n",
+             ((double)time0/10000.0),
+             XVAL( bbox.xMin ),
+             XVAL( bbox.yMin ),
+             XVAL( bbox.xMax ),
+             XVAL( bbox.yMax ) );
+  }
+
+#define REPEAT  100000L
+
+  int  main( int  argc, char**  argv )
+  {
+    printf( "outline #1\n" );
+    profile_outline( &dummy_outline_1, REPEAT );
+
+    printf( "outline #2\n" );
+    profile_outline( &dummy_outline_2, REPEAT );
+    return 0;
+  }
+
diff --git a/nx-X11/extras/freetype2/src/tools/test_trig.c b/nx-X11/extras/freetype2/src/tools/test_trig.c
new file mode 100644
index 000000000..8c8a544aa
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/tools/test_trig.c
@@ -0,0 +1,236 @@
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TRIGONOMETRY_H
+
+#include <math.h>
+#include <stdio.h>
+
+#define  PI   3.14159265358979323846
+#define  SPI  (PI/FT_ANGLE_PI)
+
+/* the precision in 16.16 fixed float points of the checks. Expect */
+/* between 2 and 5 noise LSB bits during operations, due to        */
+/* rounding errors..                                               */
+#define  THRESHOLD  64
+
+  static  error = 0;
+
+  static void
+  test_cos( void )
+  {
+    FT_Fixed  f1, f2;
+    double    d1, d2;
+    int       i;
+
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      f1 = FT_Cos(i);
+      d1 = f1/65536.0;
+      d2 = cos( i*SPI );
+      f2 = (FT_Fixed)(d2*65536.0);
+
+      if ( abs( f2-f1 ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Cos[%3d] = %.7f  cos[%3d] = %.7f\n",
+                (i >> 16), f1/65536.0, (i >> 16), d2 );
+      }
+    }
+  }
+
+
+
+  static void
+  test_sin( void )
+  {
+    FT_Fixed  f1, f2;
+    double    d1, d2;
+    int       i;
+
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      f1 = FT_Sin(i);
+      d1 = f1/65536.0;
+      d2 = sin( i*SPI );
+      f2 = (FT_Fixed)(d2*65536.0);
+
+      if ( abs( f2-f1 ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Sin[%3d] = %.7f  sin[%3d] = %.7f\n",
+                (i >> 16), f1/65536.0, (i >> 16), d2 );
+      }
+    }
+  }
+
+
+  static void
+  test_tan( void )
+  {
+    FT_Fixed  f1, f2;
+    double    d1, d2;
+    int       i;
+
+    for ( i = 0; i < FT_ANGLE_PI2-0x2000000; i += 0x10000 )
+    {
+      f1 = FT_Tan(i);
+      d1 = f1/65536.0;
+      d2 = tan( i*SPI );
+      f2 = (FT_Fixed)(d2*65536.0);
+
+      if ( abs( f2-f1 ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Tan[%3d] = %.7f  tan[%3d] = %.7f\n",
+                (i >> 16), f1/65536.0, (i >> 16), d2 );
+      }
+    }
+  }
+
+
+  static void
+  test_atan2( void )
+  {
+    FT_Fixed  c2, s2;
+    double    l, a, c1, s1;
+    int       i, j;
+
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      l  = 5.0;
+      a  = i*SPI;
+
+      c1 = l * cos(a);
+      s1 = l * sin(a);
+
+      c2 = (FT_Fixed)(c1*65536.0);
+      s2 = (FT_Fixed)(s1*65536.0);
+
+      j  = FT_Atan2( c2, s2 );
+      if ( j < 0 )
+        j += FT_ANGLE_2PI;
+
+      if ( abs( i - j ) > 1 )
+      {
+        printf( "FT_Atan2( %.7f, %.7f ) = %.5f, atan = %.5f\n",
+                c2/65536.0, s2/65536.0, j/65536.0, i/65536.0 );
+      }
+    }
+  }
+
+  static void
+  test_unit( void )
+  {
+    FT_Vector  v;
+    double     a, c1, s1;
+    FT_Fixed   c2, s2;
+    int        i;
+
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      FT_Vector_Unit( &v, i );
+      a  = ( i*SPI );
+      c1 = cos(a);
+      s1 = sin(a);
+      c2 = (FT_Fixed)(c1*65536.0);
+      s2 = (FT_Fixed)(s1*65536.0);
+
+      if ( abs( v.x-c2 ) > THRESHOLD ||
+           abs( v.y-s2 ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Vector_Unit[%3d] = ( %.7f, %.7f )  vec = ( %.7f, %.7f )\n",
+                (i >> 16),
+                v.x/65536.0, v.y/65536.0,
+                c1, s1 );
+      }
+    }
+  }
+
+
+  static void
+  test_length( void )
+  {
+    FT_Vector  v;
+    FT_Fixed   l, l2;
+    int        i;
+
+    for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+    {
+      l   = (FT_Fixed)(500.0*65536.0);
+      v.x = (FT_Fixed)( l * cos( i*SPI ) );
+      v.y = (FT_Fixed)( l * sin( i*SPI ) );
+      l2  = FT_Vector_Length( &v );
+
+      if ( abs( l2-l ) > THRESHOLD )
+      {
+        error = 1;
+        printf( "FT_Length( %.7f, %.7f ) = %.5f, length = %.5f\n",
+                v.x/65536.0, v.y/65536.0, l2/65536.0, l/65536.0 );
+      }
+    }
+  }
+
+
+  static void
+  test_rotate( void )
+  {
+    FT_Fixed  c2, s2, c4, s4;
+    FT_Vector v;
+    double    l, ra, a, c1, s1, cra, sra, c3, s3;
+    int       i, j, rotate;
+
+    for ( rotate = 0; rotate < FT_ANGLE_2PI; rotate += 0x10000 )
+    {
+      ra  = rotate*SPI;
+      cra = cos( ra );
+      sra = sin( ra );
+
+      for ( i = 0; i < FT_ANGLE_2PI; i += 0x10000 )
+      {
+        l  = 500.0;
+        a  = i*SPI;
+
+        c1 = l * cos(a);
+        s1 = l * sin(a);
+
+        v.x = c2 = (FT_Fixed)(c1*65536.0);
+        v.y = s2 = (FT_Fixed)(s1*65536.0);
+
+        FT_Vector_Rotate( &v, rotate );
+
+        c3 = c1 * cra - s1 * sra;
+        s3 = c1 * sra + s1 * cra;
+
+        c4 = (FT_Fixed)(c3*65536.0);
+        s4 = (FT_Fixed)(s3*65536.0);
+
+        if ( abs( c4 - v.x ) > THRESHOLD ||
+             abs( s4 - v.y ) > THRESHOLD )
+        {
+          error = 1;
+          printf( "FT_Rotate( (%.7f,%.7f), %.5f ) = ( %.7f, %.7f ), rot = ( %.7f, %.7f )\n",
+                  c1, s1, ra,
+                  c2/65536.0, s2/65536.0,
+                  c4/65536.0, s4/65536.0 );
+        }
+      }
+    }
+  }
+
+
+  int main( void )
+  {
+    test_cos();
+    test_sin();
+    test_tan();
+    test_atan2();
+    test_unit();
+    test_length();
+    test_rotate();
+
+    if (!error)
+      printf( "trigonometry test ok !\n" );
+
+    return !error;
+  }
diff --git a/nx-X11/extras/freetype2/src/truetype/Jamfile b/nx-X11/extras/freetype2/src/truetype/Jamfile
new file mode 100644
index 000000000..bb7e05e6e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/truetype Jamfile (c) 2001, 2004 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) truetype ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = ttdriver ttobjs ttpload ttgload ttinterp ttgxvar ;
+  }
+  else
+  {
+    _sources = truetype ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/truetype Jamfile
diff --git a/nx-X11/extras/freetype2/src/truetype/descrip.mms b/nx-X11/extras/freetype2/src/truetype/descrip.mms
new file mode 100644
index 000000000..e30ee1b3f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 TrueType driver compilation rules for VMS
+#
+
+
+# Copyright 2001, 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.truetype])
+
+OBJS=truetype.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/truetype/module.mk b/nx-X11/extras/freetype2/src/truetype/module.mk
new file mode 100644
index 000000000..bb042beae
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 TrueType module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_truetype_driver
+
+add_truetype_driver:
+	$(OPEN_DRIVER)tt_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)truetype  $(ECHO_DRIVER_DESC)Windows/Mac font files with extension *.ttf or *.ttc$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/truetype/rules.mk b/nx-X11/extras/freetype2/src/truetype/rules.mk
new file mode 100644
index 000000000..74684260e
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/rules.mk
@@ -0,0 +1,72 @@
+#
+# FreeType 2 TrueType driver configuration rules
+#
+
+
+# Copyright 1996-2000, 2001, 2003, 2004 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.
+
+
+# TrueType driver directory
+#
+TT_DIR := $(SRC_DIR)/truetype
+
+
+# compilation flags for the driver
+#
+TT_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(TT_DIR))
+
+
+# TrueType driver sources (i.e., C files)
+#
+TT_DRV_SRC := $(TT_DIR)/ttobjs.c   \
+              $(TT_DIR)/ttpload.c  \
+              $(TT_DIR)/ttgload.c  \
+              $(TT_DIR)/ttinterp.c \
+              $(TT_DIR)/ttgxvar.c \
+              $(TT_DIR)/ttdriver.c
+
+# TrueType driver headers
+#
+TT_DRV_H := $(TT_DRV_SRC:%.c=%.h) \
+            $(TT_DIR)/tterrors.h
+
+
+# TrueType driver object(s)
+#
+#   TT_DRV_OBJ_M is used during `multi' builds
+#   TT_DRV_OBJ_S is used during `single' builds
+#
+TT_DRV_OBJ_M := $(TT_DRV_SRC:$(TT_DIR)/%.c=$(OBJ_DIR)/%.$O)
+TT_DRV_OBJ_S := $(OBJ_DIR)/truetype.$O
+
+# TrueType driver source file for single build
+#
+TT_DRV_SRC_S := $(TT_DIR)/truetype.c
+
+
+# TrueType driver - single object
+#
+$(TT_DRV_OBJ_S): $(TT_DRV_SRC_S) $(TT_DRV_SRC) $(FREETYPE_H) $(TT_DRV_H)
+	$(TT_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(TT_DRV_SRC_S))
+
+
+# driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(TT_DIR)/%.c $(FREETYPE_H) $(TT_DRV_H)
+	$(TT_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(TT_DRV_OBJ_S)
+DRV_OBJS_M += $(TT_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/truetype/truetype.c b/nx-X11/extras/freetype2/src/truetype/truetype.c
new file mode 100644
index 000000000..4abb01ec5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/truetype.c
@@ -0,0 +1,36 @@
+/***************************************************************************/
+/*                                                                         */
+/*  truetype.c                                                             */
+/*                                                                         */
+/*    FreeType TrueType driver component (body only).                      */
+/*                                                                         */
+/*  Copyright 1996-2001, 2004 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 "ttdriver.c"   /* driver interface    */
+#include "ttpload.c"    /* tables loader       */
+#include "ttgload.c"    /* glyph loader        */
+#include "ttobjs.c"     /* object manager      */
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+#include "ttinterp.c"
+#endif
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+#include "ttgxvar.c"    /* gx distortable font */
+#endif
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttdriver.c b/nx-X11/extras/freetype2/src/truetype/ttdriver.c
new file mode 100644
index 000000000..25948839d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttdriver.c
@@ -0,0 +1,465 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttdriver.c                                                             */
+/*                                                                         */
+/*    TrueType font driver implementation (body).                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_SFNT_H
+#include FT_TRUETYPE_IDS_H
+#include FT_SERVICE_XFREE86_NAME_H
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+#include FT_MULTIPLE_MASTERS_H
+#include FT_SERVICE_MULTIPLE_MASTERS_H
+#endif
+
+#include "ttdriver.h"
+#include "ttgload.h"
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+#include "ttgxvar.h"
+#endif
+
+#include "tterrors.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_ttdriver
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                          F A C E S                              ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#undef  PAIR_TAG
+#define PAIR_TAG( left, right )  ( ( (FT_ULong)left << 16 ) | \
+                                     (FT_ULong)right        )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Kerning                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to return the kerning vector between two      */
+  /*    glyphs of the same face.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to the source face object.                 */
+  /*                                                                       */
+  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
+  /*                                                                       */
+  /*    right_glyph :: The index of the right glyph in the kern pair.      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    kerning     :: The kerning vector.  This is in font units for      */
+  /*                   scalable formats, and in pixels for fixed-sizes     */
+  /*                   formats.                                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
+  /*    supported by this function.  Other layouts, or more sophisticated  */
+  /*    kernings, are out of scope of this method (the basic driver        */
+  /*    interface is meant to be simple).                                  */
+  /*                                                                       */
+  /*    They can be implemented by format-specific interfaces.             */
+  /*                                                                       */
+  static FT_Error
+  Get_Kerning( FT_Face     ttface,          /* TT_Face */
+               FT_UInt     left_glyph,
+               FT_UInt     right_glyph,
+               FT_Vector*  kerning )
+  {
+    TT_Face        face = (TT_Face)ttface;
+    TT_Kern0_Pair  pair;
+
+
+    if ( !face )
+      return TT_Err_Invalid_Face_Handle;
+
+    kerning->x = 0;
+    kerning->y = 0;
+
+    if ( face->kern_pairs )
+    {
+      /* there are some kerning pairs in this font file! */
+      FT_ULong  search_tag = PAIR_TAG( left_glyph, right_glyph );
+      FT_Long   left, right;
+
+
+      left  = 0;
+      right = face->num_kern_pairs - 1;
+
+      while ( left <= right )
+      {
+        FT_Long   middle = left + ( ( right - left ) >> 1 );
+        FT_ULong  cur_pair;
+
+
+        pair     = face->kern_pairs + middle;
+        cur_pair = PAIR_TAG( pair->left, pair->right );
+
+        if ( cur_pair == search_tag )
+          goto Found;
+
+        if ( cur_pair < search_tag )
+          left = middle + 1;
+        else
+          right = middle - 1;
+      }
+    }
+
+  Exit:
+    return TT_Err_Ok;
+
+  Found:
+    kerning->x = pair->value;
+    goto Exit;
+  }
+
+
+#undef PAIR_TAG
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                           S I Z E S                             ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Set_Char_Sizes                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to reset a size's character sizes (horizontal */
+  /*    and vertical) expressed in fractional points.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    char_width      :: The character width expressed in 26.6           */
+  /*                       fractional points.                              */
+  /*                                                                       */
+  /*    char_height     :: The character height expressed in 26.6          */
+  /*                       fractional points.                              */
+  /*                                                                       */
+  /*    horz_resolution :: The horizontal resolution of the output device. */
+  /*                                                                       */
+  /*    vert_resolution :: The vertical resolution of the output device.   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    size            :: A handle to the target size object.             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Set_Char_Sizes( FT_Size     ttsize,       /* TT_Size */
+                  FT_F26Dot6  char_width,
+                  FT_F26Dot6  char_height,
+                  FT_UInt     horz_resolution,
+                  FT_UInt     vert_resolution )
+  {
+    TT_Size           size     = (TT_Size)ttsize;
+    FT_Size_Metrics*  metrics  = &size->root.metrics;
+    FT_Size_Metrics*  metrics2 = &size->metrics;
+    TT_Face           face     = (TT_Face)size->root.face;
+    FT_Long           dim_x, dim_y;
+
+
+    *metrics2 = *metrics;
+
+    /* This bit flag, when set, indicates that the pixel size must be */
+    /* truncated to an integer.  Nearly all TrueType fonts have this  */
+    /* bit set, as hinting won't work really well otherwise.          */
+    /*                                                                */
+    if ( ( face->header.Flags & 8 ) != 0 )
+    {
+     /* we need to use rounding in the following computations. Otherwise,
+      * the resulting hinted outlines will be very slightly distorted
+      */
+      dim_x = ( ( char_width  * horz_resolution + (36+32*72) ) / 72 ) & ~63;
+      dim_y = ( ( char_height * vert_resolution + (36+32*72) ) / 72 ) & ~63;
+    }
+    else
+    {
+      dim_x = ( ( char_width  * horz_resolution + 36 ) / 72 );
+      dim_y = ( ( char_height * vert_resolution + 36 ) / 72 );
+    }
+
+    /* we only modify "metrics2", not "metrics", so these changes have */
+    /* no effect on the result of the auto-hinter when it is used      */
+    /*                                                                 */
+    metrics2->x_ppem  = (FT_UShort)( dim_x >> 6 );
+    metrics2->y_ppem  = (FT_UShort)( dim_y >> 6 );
+    metrics2->x_scale = FT_DivFix( dim_x, face->root.units_per_EM );
+    metrics2->y_scale = FT_DivFix( dim_y, face->root.units_per_EM );
+
+    size->ttmetrics.valid = FALSE;
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+    size->strike_index    = 0xFFFFU;
+#endif
+
+    return tt_size_reset( size );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Set_Pixel_Sizes                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to reset a size's character sizes (horizontal */
+  /*    and vertical) expressed in integer pixels.                         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    size         :: A handle to the target size object.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Set_Pixel_Sizes( FT_Size  ttsize,         /* TT_Size */
+                   FT_UInt  pixel_width,
+                   FT_UInt  pixel_height )
+  {
+    TT_Size  size = (TT_Size)ttsize;
+
+    FT_UNUSED( pixel_width );
+    FT_UNUSED( pixel_height );
+
+
+    /* many things have been pre-computed by the base layer */
+
+    size->metrics         = size->root.metrics;
+    size->ttmetrics.valid = FALSE;
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+    size->strike_index    = 0xFFFFU;
+#endif
+
+    return tt_size_reset( size );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Load_Glyph                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to load a glyph within a given glyph slot.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    slot        :: A handle to the target slot object where the glyph  */
+  /*                   will be loaded.                                     */
+  /*                                                                       */
+  /*    size        :: A handle to the source face size at which the glyph */
+  /*                   must be scaled, loaded, etc.                        */
+  /*                                                                       */
+  /*    glyph_index :: The index of the glyph in the font file.            */
+  /*                                                                       */
+  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
+  /*                   FTLOAD_??? constants can be used to control the     */
+  /*                   glyph loading process (e.g., whether the outline    */
+  /*                   should be scaled, whether to load bitmaps or not,   */
+  /*                   whether to hint the outline, etc).                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Load_Glyph( FT_GlyphSlot  ttslot,         /* TT_GlyphSlot */
+              FT_Size       ttsize,         /* TT_Size      */
+              FT_UInt       glyph_index,
+              FT_Int32      load_flags )
+  {
+    TT_GlyphSlot  slot = (TT_GlyphSlot)ttslot;
+    TT_Size       size = (TT_Size)ttsize;
+    FT_Error      error;
+
+
+    if ( !slot )
+      return TT_Err_Invalid_Slot_Handle;
+
+    /* check whether we want a scaled outline or bitmap */
+    if ( !size )
+      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
+
+    if ( load_flags & FT_LOAD_NO_SCALE )
+      size = NULL;
+
+    /* reset the size object if necessary */
+    if ( size )
+    {
+      /* these two object must have the same parent */
+      if ( size->root.face != slot->face )
+        return TT_Err_Invalid_Face_Handle;
+
+      if ( !size->ttmetrics.valid )
+      {
+        if ( FT_SET_ERROR( tt_size_reset( size ) ) )
+          return error;
+      }
+    }
+
+    /* now load the glyph outline if necessary */
+    error = TT_Load_Glyph( size, slot, glyph_index, load_flags );
+
+    /* force drop-out mode to 2 - irrelevant now */
+    /* slot->outline.dropout_mode = 2; */
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                D R I V E R  I N T E R F A C E                   ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+  static const FT_Service_MultiMastersRec  tt_service_gx_multi_masters =
+  {
+    (FT_Get_MM_Func)        NULL,
+    (FT_Set_MM_Design_Func) NULL,
+    (FT_Set_MM_Blend_Func)  TT_Set_MM_Blend,
+    (FT_Get_MM_Var_Func)    TT_Get_MM_Var,
+    (FT_Set_Var_Design_Func)TT_Set_Var_Design
+  };
+#endif
+
+
+  static const FT_ServiceDescRec  tt_services[] =
+  {
+    { FT_SERVICE_ID_XF86_NAME,     FT_XF86_FORMAT_TRUETYPE },
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+    { FT_SERVICE_ID_MULTI_MASTERS, &tt_service_gx_multi_masters },
+#endif
+    { NULL, NULL }
+  };
+
+
+  FT_CALLBACK_DEF( FT_Module_Interface )
+  tt_get_interface( FT_Module    driver,    /* TT_Driver */
+                    const char*  tt_interface )
+  {
+    FT_Module_Interface  result;
+    FT_Module            sfntd;
+    SFNT_Service         sfnt;
+
+
+    result = ft_service_list_lookup( tt_services, tt_interface );
+    if ( result != NULL )
+      return result;
+
+    /* only return the default interface from the SFNT module */
+    sfntd = FT_Get_Module( driver->library, "sfnt" );
+    if ( sfntd )
+    {
+      sfnt = (SFNT_Service)( sfntd->clazz->module_interface );
+      if ( sfnt )
+        return sfnt->get_interface( driver, tt_interface );
+    }
+
+    return 0;
+  }
+
+
+  /* The FT_DriverInterface structure is defined in ftdriver.h. */
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  tt_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER        |
+      FT_MODULE_DRIVER_SCALABLE    |
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+      FT_MODULE_DRIVER_HAS_HINTER,
+#else
+      0,
+#endif
+
+      sizeof ( TT_DriverRec ),
+
+      "truetype",      /* driver name                           */
+      0x10000L,        /* driver version == 1.0                 */
+      0x20000L,        /* driver requires FreeType 2.0 or above */
+
+      (void*)0,        /* driver specific interface */
+
+      tt_driver_init,
+      tt_driver_done,
+      tt_get_interface,
+    },
+
+    sizeof ( TT_FaceRec ),
+    sizeof ( TT_SizeRec ),
+    sizeof ( FT_GlyphSlotRec ),
+
+    tt_face_init,
+    tt_face_done,
+    tt_size_init,
+    tt_size_done,
+    0,                      /* FT_Slot_InitFunc        */
+    0,                      /* FT_Slot_DoneFunc        */
+
+    Set_Char_Sizes,
+    Set_Pixel_Sizes,
+    Load_Glyph,
+
+    Get_Kerning,
+    0,                      /* FT_Face_AttachFunc      */
+    0                       /* FT_Face_GetAdvancesFunc */
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttdriver.h b/nx-X11/extras/freetype2/src/truetype/ttdriver.h
new file mode 100644
index 000000000..f6f26e4b5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttdriver.h
@@ -0,0 +1,38 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttdriver.h                                                             */
+/*                                                                         */
+/*    High-level TrueType driver interface (specification).                */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __TTDRIVER_H__
+#define __TTDRIVER_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  tt_driver_class;
+
+
+FT_END_HEADER
+
+#endif /* __TTDRIVER_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/tterrors.h b/nx-X11/extras/freetype2/src/truetype/tterrors.h
new file mode 100644
index 000000000..d317c70e0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/tterrors.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  tterrors.h                                                             */
+/*                                                                         */
+/*    TrueType error codes (specification only).                           */
+/*                                                                         */
+/*  Copyright 2001 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 TrueType error enumeration            */
+  /* constants.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __TTERRORS_H__
+#define __TTERRORS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  TT_Err_
+#define FT_ERR_BASE    FT_Mod_Err_TrueType
+
+#include FT_ERRORS_H
+
+#endif /* __TTERRORS_H__ */
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttgload.c b/nx-X11/extras/freetype2/src/truetype/ttgload.c
new file mode 100644
index 000000000..9fc2d0380
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttgload.c
@@ -0,0 +1,2039 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttgload.c                                                              */
+/*                                                                         */
+/*    TrueType Glyph Loader (body).                                        */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_CALC_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_SFNT_H
+#include FT_TRUETYPE_TAGS_H
+#include FT_OUTLINE_H
+
+#include "ttgload.h"
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+#include "ttgxvar.h"
+#endif
+
+#include "tterrors.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_ttgload
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Composite font flags.                                                 */
+  /*                                                                       */
+#define ARGS_ARE_WORDS             0x0001
+#define ARGS_ARE_XY_VALUES         0x0002
+#define ROUND_XY_TO_GRID           0x0004
+#define WE_HAVE_A_SCALE            0x0008
+/* reserved                        0x0010 */
+#define MORE_COMPONENTS            0x0020
+#define WE_HAVE_AN_XY_SCALE        0x0040
+#define WE_HAVE_A_2X2              0x0080
+#define WE_HAVE_INSTR              0x0100
+#define USE_MY_METRICS             0x0200
+#define OVERLAP_COMPOUND           0x0400
+#define SCALED_COMPONENT_OFFSET    0x0800
+#define UNSCALED_COMPONENT_OFFSET  0x1000
+
+
+/* Maximum recursion depth we allow for composite glyphs.
+ * The TrueType spec doesn't say anything about recursion,
+ * so it isn't clear that recursion is allowed at all. But
+ * we'll be generous.
+ */
+#define TT_MAX_COMPOSITE_RECURSE 5
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Get_Metrics                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns the horizontal or vertical metrics in font units for a     */
+  /*    given glyph.  The metrics are the left side bearing (resp. top     */
+  /*    side bearing) and advance width (resp. advance height).            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    header  :: A pointer to either the horizontal or vertical metrics  */
+  /*               structure.                                              */
+  /*                                                                       */
+  /*    idx     :: The glyph index.                                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    bearing :: The bearing, either left side or top side.              */
+  /*                                                                       */
+  /*    advance :: The advance width resp. advance height.                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function will much probably move to another component in the  */
+  /*    near future, but I haven't decided which yet.                      */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  TT_Get_Metrics( TT_HoriHeader*  header,
+                  FT_UInt         idx,
+                  FT_Short*       bearing,
+                  FT_UShort*      advance )
+  {
+    TT_LongMetrics  longs_m;
+    FT_UShort       k = header->number_Of_HMetrics;
+
+
+    if ( k == 0 )
+    {
+      *bearing = *advance = 0;
+      return;
+    }
+
+    if ( idx < (FT_UInt)k )
+    {
+      longs_m  = (TT_LongMetrics )header->long_metrics + idx;
+      *bearing = longs_m->bearing;
+      *advance = longs_m->advance;
+    }
+    else
+    {
+      *bearing = ((TT_ShortMetrics*)header->short_metrics)[idx - k];
+      *advance = ((TT_LongMetrics )header->long_metrics)[k - 1].advance;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Returns the horizontal metrics in font units for a given glyph.  If   */
+  /* `check' is true, take care of monospaced fonts by returning the       */
+  /* advance width maximum.                                                */
+  /*                                                                       */
+  static void
+  Get_HMetrics( TT_Face     face,
+                FT_UInt     idx,
+                FT_Bool     check,
+                FT_Short*   lsb,
+                FT_UShort*  aw )
+  {
+    TT_Get_Metrics( &face->horizontal, idx, lsb, aw );
+
+    if ( check && face->postscript.isFixedPitch )
+      *aw = face->horizontal.advance_Width_Max;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Returns the advance width table for a given pixel size if it is found */
+  /* in the font's `hdmx' table (if any).                                  */
+  /*                                                                       */
+  static FT_Byte*
+  Get_Advance_Widths( TT_Face    face,
+                      FT_UShort  ppem )
+  {
+    FT_UShort  n;
+
+
+    for ( n = 0; n < face->hdmx.num_records; n++ )
+      if ( face->hdmx.records[n].ppem == ppem )
+        return face->hdmx.records[n].widths;
+
+    return NULL;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Returns the vertical metrics in font units for a given glyph.         */
+  /* Greg Hitchcock from Microsoft told us that if there were no `vmtx'    */
+  /* table, typoAscender/Descender from the `OS/2' table would be used     */
+  /* instead, and if there were no `OS/2' table, use ascender/descender    */
+  /* from the `hhea' table.  But that is not what Microsoft's rasterizer   */
+  /* apparently does: It uses the ppem value as the advance height, and    */
+  /* sets the top side bearing to be zero.                                 */
+  /*                                                                       */
+  /* The monospace `check' is probably not meaningful here, but we leave   */
+  /* it in for a consistent interface.                                     */
+  /*                                                                       */
+  static void
+  Get_VMetrics( TT_Face     face,
+                FT_UInt     idx,
+                FT_Bool     check,
+                FT_Short*   tsb,
+                FT_UShort*  ah )
+  {
+    FT_UNUSED( check );
+
+    if ( face->vertical_info )
+      TT_Get_Metrics( (TT_HoriHeader *)&face->vertical, idx, tsb, ah );
+
+#if 1             /* Emperically determined, at variance with what MS said */
+
+    else
+    {
+      *tsb = 0;
+      *ah  = face->root.units_per_EM;
+    }
+
+#else      /* This is what MS said to do.  It isn't what they do, however. */
+
+    else if ( face->os2.version != 0xFFFFU )
+    {
+      *tsb = face->os2.sTypoAscender;
+      *ah  = face->os2.sTypoAscender - face->os2.sTypoDescender;
+    }
+    else
+    {
+      *tsb = face->horizontal.Ascender;
+      *ah  = face->horizontal.Ascender - face->horizontal.Descender;
+    }
+
+#endif
+
+  }
+
+
+#define cur_to_org( n, zone ) \
+          FT_ARRAY_COPY( (zone)->org, (zone)->cur, (n) )
+
+#define org_to_cur( n, zone ) \
+          FT_ARRAY_COPY( (zone)->cur, (zone)->org, (n) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Translates an array of coordinates.                                   */
+  /*                                                                       */
+  static void
+  translate_array( FT_UInt     n,
+                   FT_Vector*  coords,
+                   FT_Pos      delta_x,
+                   FT_Pos      delta_y )
+  {
+    FT_UInt  k;
+
+
+    if ( delta_x )
+      for ( k = 0; k < n; k++ )
+        coords[k].x += delta_x;
+
+    if ( delta_y )
+      for ( k = 0; k < n; k++ )
+        coords[k].y += delta_y;
+  }
+
+
+  static void
+  tt_prepare_zone( TT_GlyphZone  zone,
+                   FT_GlyphLoad  load,
+                   FT_UInt       start_point,
+                   FT_UInt       start_contour )
+  {
+    zone->n_points   = (FT_UShort)( load->outline.n_points - start_point );
+    zone->n_contours = (FT_Short) ( load->outline.n_contours - start_contour );
+    zone->org        = load->extra_points + start_point;
+    zone->cur        = load->outline.points + start_point;
+    zone->tags       = (FT_Byte*)load->outline.tags + start_point;
+    zone->contours   = (FT_UShort*)load->outline.contours + start_contour;
+  }
+
+
+#undef  IS_HINTED
+#define IS_HINTED( flags )  ( ( flags & FT_LOAD_NO_HINTING ) == 0 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The following functions are used by default with TrueType fonts.      */
+  /* However, they can be replaced by alternatives if we need to support   */
+  /* TrueType-compressed formats (like MicroType) in the future.           */
+  /*                                                                       */
+  /*************************************************************************/
+
+  FT_CALLBACK_DEF( FT_Error )
+  TT_Access_Glyph_Frame( TT_Loader  loader,
+                         FT_UInt    glyph_index,
+                         FT_ULong   offset,
+                         FT_UInt    byte_count )
+  {
+    FT_Error   error;
+    FT_Stream  stream = loader->stream;
+
+    /* for non-debug mode */
+    FT_UNUSED( glyph_index );
+
+
+    FT_TRACE5(( "Glyph %ld\n", glyph_index ));
+
+    /* the following line sets the `error' variable through macros! */
+    if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( byte_count ) )
+      return error;
+
+    return TT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  TT_Forget_Glyph_Frame( TT_Loader  loader )
+  {
+    FT_Stream  stream = loader->stream;
+
+
+    FT_FRAME_EXIT();
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  TT_Load_Glyph_Header( TT_Loader  loader )
+  {
+    FT_Stream  stream   = loader->stream;
+    FT_Int     byte_len = loader->byte_len - 10;
+
+
+    if ( byte_len < 0 )
+      return TT_Err_Invalid_Outline;
+
+    loader->n_contours = FT_GET_SHORT();
+
+    loader->bbox.xMin = FT_GET_SHORT();
+    loader->bbox.yMin = FT_GET_SHORT();
+    loader->bbox.xMax = FT_GET_SHORT();
+    loader->bbox.yMax = FT_GET_SHORT();
+
+    FT_TRACE5(( "  # of contours: %d\n", loader->n_contours ));
+    FT_TRACE5(( "  xMin: %4d  xMax: %4d\n", loader->bbox.xMin,
+                                            loader->bbox.xMax ));
+    FT_TRACE5(( "  yMin: %4d  yMax: %4d\n", loader->bbox.yMin,
+                                            loader->bbox.yMax ));
+    loader->byte_len = byte_len;
+
+    return TT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  TT_Load_Simple_Glyph( TT_Loader  load )
+  {
+    FT_Error        error;
+    FT_Stream       stream     = load->stream;
+    FT_GlyphLoader  gloader    = load->gloader;
+    FT_Int          n_contours = load->n_contours;
+    FT_Outline*     outline;
+    TT_Face         face       = (TT_Face)load->face;
+    TT_GlyphSlot    slot       = (TT_GlyphSlot)load->glyph;
+    FT_UShort       n_ins;
+    FT_Int          n, n_points;
+    FT_Int          byte_len   = load->byte_len;
+
+    FT_Byte         *flag, *flag_limit;
+    FT_Byte         c, count;
+    FT_Vector       *vec, *vec_limit;
+    FT_Pos          x;
+    FT_Short        *cont, *cont_limit;
+
+
+    /* reading the contours' endpoints & number of points */
+    cont       = gloader->current.outline.contours;
+    cont_limit = cont + n_contours;
+
+    /* check space for contours array + instructions count */
+    byte_len -= 2 * ( n_contours + 1 );
+    if ( byte_len < 0 )
+      goto Invalid_Outline;
+
+    for ( ; cont < cont_limit; cont++ )
+      cont[0] = FT_GET_USHORT();
+
+    n_points = 0;
+    if ( n_contours > 0 )
+      n_points = cont[-1] + 1;
+
+    error = FT_GlyphLoader_CheckPoints( gloader, n_points + 4, 0 );
+    if ( error )
+      goto Fail;
+
+    /* we'd better check the contours table right now */
+    outline = &gloader->current.outline;
+
+    for ( cont = outline->contours + 1; cont < cont_limit; cont++ )
+      if ( cont[-1] >= cont[0] )
+        goto Invalid_Outline;
+
+    /* reading the bytecode instructions */
+    slot->control_len  = 0;
+    slot->control_data = 0;
+
+    n_ins = FT_GET_USHORT();
+
+    FT_TRACE5(( "  Instructions size: %u\n", n_ins ));
+
+    if ( n_ins > face->max_profile.maxSizeOfInstructions )
+    {
+      FT_TRACE0(( "TT_Load_Simple_Glyph: Too many instructions!\n" ));
+      error = TT_Err_Too_Many_Hints;
+      goto Fail;
+    }
+
+    byte_len -= (FT_Int)n_ins;
+    if ( byte_len < 0 )
+    {
+      FT_TRACE0(( "TT_Load_Simple_Glyph: Instruction count mismatch!\n" ));
+      error = TT_Err_Too_Many_Hints;
+      goto Fail;
+    }
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+    if ( ( load->load_flags                        &
+         ( FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING ) ) == 0 &&
+           load->instructions )
+    {
+      slot->control_len  = n_ins;
+      slot->control_data = load->instructions;
+
+      FT_MEM_COPY( load->instructions, stream->cursor, (FT_Long)n_ins );
+    }
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+    stream->cursor += (FT_Int)n_ins;
+
+    /* reading the point tags */
+    flag       = (FT_Byte*)outline->tags;
+    flag_limit = flag + n_points;
+
+    while ( flag < flag_limit )
+    {
+      if ( --byte_len < 0 )
+        goto Invalid_Outline;
+
+      *flag++ = c = FT_GET_BYTE();
+      if ( c & 8 )
+      {
+        if ( --byte_len < 0 )
+          goto Invalid_Outline;
+
+        count = FT_GET_BYTE();
+        if ( flag + (FT_Int)count > flag_limit )
+          goto Invalid_Outline;
+
+        for ( ; count > 0; count-- )
+          *flag++ = c;
+      }
+    }
+
+    /* check that there is enough room to load the coordinates */
+    for ( flag = (FT_Byte*)outline->tags; flag < flag_limit; flag++ )
+    {
+      if ( *flag & 2 )
+        byte_len -= 1;
+      else if ( ( *flag & 16 ) == 0 )
+        byte_len -= 2;
+
+      if ( *flag & 4 )
+        byte_len -= 1;
+      else if ( ( *flag & 32 ) == 0 )
+        byte_len -= 2;
+    }
+
+    if ( byte_len < 0 )
+      goto Invalid_Outline;
+
+    /* reading the X coordinates */
+
+    vec       = outline->points;
+    vec_limit = vec + n_points;
+    flag      = (FT_Byte*)outline->tags;
+    x         = 0;
+
+    for ( ; vec < vec_limit; vec++, flag++ )
+    {
+      FT_Pos  y = 0;
+
+
+      if ( *flag & 2 )
+      {
+        y = (FT_Pos)FT_GET_BYTE();
+        if ( ( *flag & 16 ) == 0 )
+          y = -y;
+      }
+      else if ( ( *flag & 16 ) == 0 )
+        y = (FT_Pos)FT_GET_SHORT();
+
+      x     += y;
+      vec->x = x;
+    }
+
+    /* reading the Y coordinates */
+
+    vec       = gloader->current.outline.points;
+    vec_limit = vec + n_points;
+    flag      = (FT_Byte*)outline->tags;
+    x         = 0;
+
+    for ( ; vec < vec_limit; vec++, flag++ )
+    {
+      FT_Pos  y = 0;
+
+
+      if ( *flag & 4 )
+      {
+        y = (FT_Pos)FT_GET_BYTE();
+        if ( ( *flag & 32 ) == 0 )
+          y = -y;
+      }
+      else if ( ( *flag & 32 ) == 0 )
+        y = (FT_Pos)FT_GET_SHORT();
+
+      x     += y;
+      vec->y = x;
+    }
+
+    /* clear the touch tags */
+    for ( n = 0; n < n_points; n++ )
+      outline->tags[n] &= FT_CURVE_TAG_ON;
+
+    outline->n_points   = (FT_UShort)n_points;
+    outline->n_contours = (FT_Short) n_contours;
+
+    load->byte_len = byte_len;
+
+  Fail:
+    return error;
+
+  Invalid_Outline:
+    error = TT_Err_Invalid_Outline;
+    goto Fail;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  TT_Load_Composite_Glyph( TT_Loader  loader )
+  {
+    FT_Error        error;
+    FT_Stream       stream  = loader->stream;
+    FT_GlyphLoader  gloader = loader->gloader;
+    FT_SubGlyph     subglyph;
+    FT_UInt         num_subglyphs;
+    FT_Int          byte_len = loader->byte_len;
+
+
+    num_subglyphs = 0;
+
+    do
+    {
+      FT_Fixed  xx, xy, yy, yx;
+
+
+      /* check that we can load a new subglyph */
+      error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs + 1 );
+      if ( error )
+        goto Fail;
+
+      /* check space */
+      byte_len -= 4;
+      if ( byte_len < 0 )
+        goto Invalid_Composite;
+
+      subglyph = gloader->current.subglyphs + num_subglyphs;
+
+      subglyph->arg1 = subglyph->arg2 = 0;
+
+      subglyph->flags = FT_GET_USHORT();
+      subglyph->index = FT_GET_USHORT();
+
+      /* check space */
+      byte_len -= 2;
+      if ( subglyph->flags & ARGS_ARE_WORDS )
+        byte_len -= 2;
+      if ( subglyph->flags & WE_HAVE_A_SCALE )
+        byte_len -= 2;
+      else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
+        byte_len -= 4;
+      else if ( subglyph->flags & WE_HAVE_A_2X2 )
+        byte_len -= 8;
+
+      if ( byte_len < 0 )
+        goto Invalid_Composite;
+
+      /* read arguments */
+      if ( subglyph->flags & ARGS_ARE_WORDS )
+      {
+        subglyph->arg1 = FT_GET_SHORT();
+        subglyph->arg2 = FT_GET_SHORT();
+      }
+      else
+      {
+        subglyph->arg1 = FT_GET_CHAR();
+        subglyph->arg2 = FT_GET_CHAR();
+      }
+
+      /* read transform */
+      xx = yy = 0x10000L;
+      xy = yx = 0;
+
+      if ( subglyph->flags & WE_HAVE_A_SCALE )
+      {
+        xx = (FT_Fixed)FT_GET_SHORT() << 2;
+        yy = xx;
+      }
+      else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
+      {
+        xx = (FT_Fixed)FT_GET_SHORT() << 2;
+        yy = (FT_Fixed)FT_GET_SHORT() << 2;
+      }
+      else if ( subglyph->flags & WE_HAVE_A_2X2 )
+      {
+        xx = (FT_Fixed)FT_GET_SHORT() << 2;
+        yx = (FT_Fixed)FT_GET_SHORT() << 2;
+        xy = (FT_Fixed)FT_GET_SHORT() << 2;
+        yy = (FT_Fixed)FT_GET_SHORT() << 2;
+      }
+
+      subglyph->transform.xx = xx;
+      subglyph->transform.xy = xy;
+      subglyph->transform.yx = yx;
+      subglyph->transform.yy = yy;
+
+      num_subglyphs++;
+
+    } while ( subglyph->flags & MORE_COMPONENTS );
+
+    gloader->current.num_subglyphs = num_subglyphs;
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+    {
+      /* we must undo the FT_FRAME_ENTER in order to point to the */
+      /* composite instructions, if we find some.               */
+      /* we will process them later...                          */
+      /*                                                        */
+      loader->ins_pos = (FT_ULong)( FT_STREAM_POS() +
+                                    stream->cursor - stream->limit );
+    }
+#endif
+
+    loader->byte_len = byte_len;
+
+  Fail:
+    return error;
+
+  Invalid_Composite:
+    error = TT_Err_Invalid_Composite;
+    goto Fail;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  TT_Init_Glyph_Loading( TT_Face  face )
+  {
+    face->access_glyph_frame   = TT_Access_Glyph_Frame;
+    face->read_glyph_header    = TT_Load_Glyph_Header;
+    face->read_simple_glyph    = TT_Load_Simple_Glyph;
+    face->read_composite_glyph = TT_Load_Composite_Glyph;
+    face->forget_glyph_frame   = TT_Forget_Glyph_Frame;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Process_Simple_Glyph                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Once a simple glyph has been loaded, it needs to be processed.     */
+  /*    Usually, this means scaling and hinting through bytecode           */
+  /*    interpretation.                                                    */
+  /*                                                                       */
+  static FT_Error
+  TT_Process_Simple_Glyph( TT_Loader  load,
+                           FT_Bool    debug )
+  {
+    FT_GlyphLoader  gloader  = load->gloader;
+    FT_Outline*     outline  = &gloader->current.outline;
+    FT_UInt         n_points = outline->n_points;
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+    FT_UInt         n_ins;
+#endif
+    TT_GlyphZone    zone     = &load->zone;
+    FT_Error        error    = TT_Err_Ok;
+
+    FT_UNUSED( debug );  /* used by truetype interpreter only */
+
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+    n_ins = load->glyph->control_len;
+#endif
+
+    /* add shadow points */
+
+    /* Add two horizontal shadow points at n and n+1.   */
+    /* We need the left side bearing and advance width. */
+    /* Add two vertical shadow points at n+2 and n+3.   */
+    /* We need the top side bearing and advance height. */
+
+    {
+      FT_Vector*  pp1;
+      FT_Vector*  pp2;
+      FT_Vector*  pp3;
+      FT_Vector*  pp4;
+
+
+      /* pp1 = xMin - lsb */
+      pp1    = outline->points + n_points;
+      pp1->x = load->bbox.xMin - load->left_bearing;
+      pp1->y = 0;
+
+      /* pp2 = pp1 + aw */
+      pp2    = pp1 + 1;
+      pp2->x = pp1->x + load->advance;
+      pp2->y = 0;
+
+      /* pp3 = top side bearing */
+      pp3    = pp1 + 2;
+      pp3->x = 0;
+      pp3->y = load->top_bearing + load->bbox.yMax;
+
+      /* pp4 = pp3 - ah */
+      pp4    = pp1 + 3;
+      pp4->x = 0;
+      pp4->y = pp3->y - load->vadvance;
+
+      outline->tags[n_points    ] = 0;
+      outline->tags[n_points + 1] = 0;
+      outline->tags[n_points + 2] = 0;
+      outline->tags[n_points + 3] = 0;
+    }
+
+    /* Note that we return four more points that are not */
+    /* part of the glyph outline.                        */
+
+    n_points += 4;
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+
+    if ( ((TT_Face)load->face)->doblend )
+    {
+      /* Deltas apply to the unscaled data. */
+      FT_Vector*    deltas;
+      FT_Memory     memory       = load->face->memory;
+      FT_StreamRec  saved_stream = *(load->stream);
+      FT_UInt       i;
+
+
+      /* TT_Vary_Get_Glyph_Deltas uses a frame, thus we have to save */
+      /* (and restore) the current one                               */
+      load->stream->cursor = 0;
+      load->stream->limit  = 0;
+
+      error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(load->face),
+                                        load->glyph_index,
+                                        &deltas,
+                                        n_points );
+
+      *(load->stream) = saved_stream;
+
+      if ( error )
+        goto Exit;
+
+      for ( i = 0; i < n_points; ++i )
+      {
+        outline->points[i].x += deltas[i].x;
+        outline->points[i].y += deltas[i].y;
+      }
+
+      FT_FREE( deltas );
+    }
+
+#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
+
+    /* set up zone for hinting */
+    tt_prepare_zone( zone, &gloader->current, 0, 0 );
+
+    /* eventually scale the glyph */
+    if ( !( load->load_flags & FT_LOAD_NO_SCALE ) )
+    {
+      FT_Vector*  vec     = zone->cur;
+      FT_Vector*  limit   = vec + n_points;
+      FT_Fixed    x_scale = ((TT_Size)load->size)->metrics.x_scale;
+      FT_Fixed    y_scale = ((TT_Size)load->size)->metrics.y_scale;
+
+      /* first scale the glyph points */
+      for ( ; vec < limit; vec++ )
+      {
+        vec->x = FT_MulFix( vec->x, x_scale );
+        vec->y = FT_MulFix( vec->y, y_scale );
+      }
+    }
+
+    cur_to_org( n_points, zone );
+
+    /* eventually hint the glyph */
+    if ( IS_HINTED( load->load_flags ) )
+    {
+      FT_Pos  x = zone->org[n_points-4].x;
+      FT_Pos  y = zone->org[n_points-2].y;
+
+
+      x = FT_PIX_ROUND( x ) - x;
+      y = FT_PIX_ROUND( y ) - y;
+      translate_array( n_points, zone->org, x, y );
+
+      org_to_cur( n_points, zone );
+
+      zone->cur[n_points - 3].x = FT_PIX_ROUND( zone->cur[n_points - 3].x );
+      zone->cur[n_points - 1].y = FT_PIX_ROUND( zone->cur[n_points - 1].y );
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+      /* now consider hinting */
+      if ( n_ins > 0 )
+      {
+        error = TT_Set_CodeRange( load->exec, tt_coderange_glyph,
+                                  load->exec->glyphIns, n_ins );
+        if ( error )
+          goto Exit;
+
+        load->exec->is_composite     = FALSE;
+        load->exec->pedantic_hinting = (FT_Bool)( load->load_flags &
+                                                  FT_LOAD_PEDANTIC );
+        load->exec->pts              = *zone;
+        load->exec->pts.n_points    += 4;
+
+        error = TT_Run_Context( load->exec, debug );
+        if ( error && load->exec->pedantic_hinting )
+          goto Exit;
+
+        error = TT_Err_Ok;  /* ignore bytecode errors in non-pedantic mode */
+      }
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+    }
+
+    /* save glyph phantom points */
+    if ( !load->preserve_pps )
+    {
+      load->pp1 = zone->cur[n_points - 4];
+      load->pp2 = zone->cur[n_points - 3];
+      load->pp3 = zone->cur[n_points - 2];
+      load->pp4 = zone->cur[n_points - 1];
+    }
+
+#if defined( TT_CONFIG_OPTION_BYTECODE_INTERPRETER ) || \
+    defined( TT_CONFIG_OPTION_GX_VAR_SUPPORT )
+  Exit:
+#endif
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    load_truetype_glyph                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads a given truetype glyph.  Handles composites and uses a       */
+  /*    TT_Loader object.                                                  */
+  /*                                                                       */
+  static FT_Error
+  load_truetype_glyph( TT_Loader  loader,
+                       FT_UInt    glyph_index,
+                       FT_UInt    recurse_count )
+  {
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+    FT_Stream       stream = loader->stream;
+#endif
+
+    FT_Error        error;
+    TT_Face         face = (TT_Face)loader->face;
+    FT_ULong        offset;
+    FT_Int          contours_count;
+    FT_UInt         num_points, count;
+    FT_Fixed        x_scale, y_scale;
+    FT_GlyphLoader  gloader = loader->gloader;
+    FT_Bool         opened_frame = 0;
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    FT_StreamRec    inc_stream;
+    FT_Data         glyph_data;
+    FT_Bool         glyph_data_loaded = 0;
+#endif
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+    FT_Vector      *deltas;
+#endif
+
+
+    if ( recurse_count >= TT_MAX_COMPOSITE_RECURSE )
+    {
+      error = TT_Err_Invalid_Composite;
+      goto Exit;
+    }
+
+    /* check glyph index */
+    if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
+    {
+      error = TT_Err_Invalid_Glyph_Index;
+      goto Exit;
+    }
+
+    loader->glyph_index = glyph_index;
+    num_points          = 0;
+
+    x_scale = 0x10000L;
+    y_scale = 0x10000L;
+    if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
+    {
+      x_scale = ((TT_Size)loader->size)->metrics.x_scale;
+      y_scale = ((TT_Size)loader->size)->metrics.y_scale;
+    }
+
+    /* get metrics, horizontal and vertical */
+    {
+      FT_Short   left_bearing = 0, top_bearing = 0;
+      FT_UShort  advance_width = 0, advance_height = 0;
+
+
+      Get_HMetrics( face, glyph_index,
+                    (FT_Bool)!( loader->load_flags &
+                                FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ),
+                    &left_bearing,
+                    &advance_width );
+      Get_VMetrics( face, glyph_index,
+                    (FT_Bool)!( loader->load_flags &
+                                FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ),
+                    &top_bearing,
+                    &advance_height );
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+      /* If this is an incrementally loaded font see if there are */
+      /* overriding metrics for this glyph.                       */
+      if ( face->root.internal->incremental_interface &&
+           face->root.internal->incremental_interface->funcs->get_glyph_metrics )
+      {
+        FT_Incremental_MetricsRec  metrics;
+
+
+        metrics.bearing_x = left_bearing;
+        metrics.bearing_y = 0;
+        metrics.advance = advance_width;
+        error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
+                  face->root.internal->incremental_interface->object,
+                  glyph_index, FALSE, &metrics );
+        if ( error )
+          goto Exit;
+        left_bearing  = (FT_Short)metrics.bearing_x;
+        advance_width = (FT_UShort)metrics.advance;
+      }
+
+# if 0
+      /* GWW: Do I do the same for vertical metrics ??? */
+      if ( face->root.internal->incremental_interface &&
+           face->root.internal->incremental_interface->funcs->get_glyph_metrics )
+      {
+        FT_Incremental_MetricsRec  metrics;
+
+
+        metrics.bearing_x = 0;
+        metrics.bearing_y = top_bearing;
+        metrics.advance = advance_height;
+        error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
+                  face->root.internal->incremental_interface->object,
+                  glyph_index, TRUE, &metrics );
+        if ( error )
+          goto Exit;
+        top_bearing  = (FT_Short)metrics.bearing_y;
+        advance_height = (FT_UShort)metrics.advance;
+      }
+# endif
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+      loader->left_bearing = left_bearing;
+      loader->advance      = advance_width;
+      loader->top_bearing  = top_bearing;
+      loader->vadvance     = advance_height;
+
+      if ( !loader->linear_def )
+      {
+        loader->linear_def = 1;
+        loader->linear     = advance_width;
+      }
+    }
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    /* Set `offset' to the start of the glyph program relative to the  */
+    /* start of the 'glyf' table, and `count' to the length of the     */
+    /* glyph program in bytes.                                         */
+    /*                                                                 */
+    /* If we are loading glyph data via the incremental interface, set */
+    /* the loader stream to a memory stream reading the data returned  */
+    /* by the interface.                                               */
+
+    if ( face->root.internal->incremental_interface )
+    {
+      error = face->root.internal->incremental_interface->funcs->get_glyph_data(
+                face->root.internal->incremental_interface->object,
+                glyph_index, &glyph_data );
+      if ( error )
+        goto Exit;
+
+      glyph_data_loaded = 1;
+      offset            = 0;
+      count             = glyph_data.length;
+
+      FT_MEM_ZERO( &inc_stream, sizeof ( inc_stream ) );
+      FT_Stream_OpenMemory( &inc_stream,
+                            glyph_data.pointer, glyph_data.length );
+
+      loader->stream = &inc_stream;
+    }
+    else
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+    {
+      offset = face->glyph_locations[glyph_index];
+      count  = 0;
+
+      if ( glyph_index < (FT_UInt)face->num_locations - 1 )
+        count = (FT_UInt)( face->glyph_locations[glyph_index + 1] - offset );
+    }
+
+    if ( count == 0 )
+    {
+      /* as described by Frederic Loyer, these are spaces, and */
+      /* not the unknown glyph.                                */
+      loader->bbox.xMin = 0;
+      loader->bbox.xMax = 0;
+      loader->bbox.yMin = 0;
+      loader->bbox.yMax = 0;
+
+      loader->pp1.x = 0;
+      loader->pp2.x = loader->advance;
+      loader->pp3.y = 0;
+      loader->pp4.y = loader->pp3.y-loader->vadvance;
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+      if ( ((TT_Face)(loader->face))->doblend )
+      {
+        /* this must be done before scaling */
+        FT_Memory  memory = loader->face->memory;
+
+
+        if ( (error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face),
+                                                glyph_index,
+                                                &deltas,
+                                                4 ) ) )
+          goto Exit;
+
+        loader->pp1.x += deltas[0].x; loader->pp1.y += deltas[0].y;
+        loader->pp2.x += deltas[1].x; loader->pp2.y += deltas[1].y;
+        loader->pp3.x += deltas[2].x; loader->pp3.y += deltas[2].y;
+        loader->pp4.x += deltas[3].x; loader->pp4.y += deltas[3].y;
+
+        FT_FREE( deltas );
+      }
+#endif
+
+      if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
+      {
+        loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
+        loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
+      }
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+      if ( loader->exec )
+        loader->exec->glyphSize = 0;
+
+#endif
+
+      error = TT_Err_Ok;
+      goto Exit;
+    }
+
+    loader->byte_len = (FT_Int)count;
+
+    offset = loader->glyf_offset + offset;
+
+    /* access glyph frame */
+    error = face->access_glyph_frame( loader, glyph_index, offset, count );
+    if ( error )
+      goto Exit;
+
+    opened_frame = 1;
+
+    /* read first glyph header */
+    error = face->read_glyph_header( loader );
+    if ( error )
+      goto Fail;
+
+    contours_count = loader->n_contours;
+
+    count -= 10;
+
+    loader->pp1.x = loader->bbox.xMin - loader->left_bearing;
+    loader->pp1.y = 0;
+    loader->pp2.x = loader->pp1.x + loader->advance;
+    loader->pp2.y = 0;
+
+    loader->pp3.x = 0;
+    loader->pp3.y = loader->top_bearing + loader->bbox.yMax;
+    loader->pp4.x = 0;
+    loader->pp4.y = loader->pp3.y - loader->vadvance;
+
+    /***********************************************************************/
+    /***********************************************************************/
+    /***********************************************************************/
+
+    /* if it is a simple glyph, load it */
+
+    if ( contours_count >= 0 )
+    {
+      /* check that we can add the contours to the glyph */
+      error = FT_GlyphLoader_CheckPoints( gloader, 0, contours_count );
+      if ( error )
+        goto Fail;
+
+      error = face->read_simple_glyph( loader );
+      if ( error )
+        goto Fail;
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+      {
+        TT_Size  size = (TT_Size)loader->size;
+
+
+        error = TT_Process_Simple_Glyph( loader,
+                                         (FT_Bool)( size && size->debug ) );
+      }
+
+#else
+
+      error = TT_Process_Simple_Glyph( loader, 0 );
+
+#endif
+
+      if ( error )
+        goto Fail;
+
+      FT_GlyphLoader_Add( gloader );
+
+      /* Note: We could have put the simple loader source there */
+      /*       but the code is fat enough already :-)           */
+    }
+
+    /***********************************************************************/
+    /***********************************************************************/
+    /***********************************************************************/
+
+    /* otherwise, load a composite! */
+    else if ( contours_count == -1 )
+    {
+      TT_GlyphSlot  glyph = (TT_GlyphSlot)loader->glyph;
+      FT_UInt       start_point;
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+      FT_UInt       start_contour;
+      FT_ULong      ins_pos;  /* position of composite instructions, if any */
+#endif
+
+
+      /* for each subglyph, read composite header */
+      start_point   = gloader->base.outline.n_points;
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+      start_contour = gloader->base.outline.n_contours;
+#endif
+
+      error = face->read_composite_glyph( loader );
+      if ( error )
+        goto Fail;
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+      ins_pos = loader->ins_pos;
+#endif
+      face->forget_glyph_frame( loader );
+      opened_frame = 0;
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+
+      if ( face->doblend )
+      {
+        FT_Int       i, limit;
+        FT_SubGlyph  subglyph;
+        FT_Memory    memory = face->root.memory;
+
+
+        /* this provides additional offsets */
+        /* for each component's translation */
+
+        if ( (error = TT_Vary_Get_Glyph_Deltas(
+                        face,
+                        glyph_index,
+                        &deltas,
+                        gloader->current.num_subglyphs + 4 ) ) )
+          goto Exit;
+
+        /* Note: No subglyph reallocation here, our pointers are stable. */
+        subglyph = gloader->current.subglyphs + gloader->base.num_subglyphs;
+        limit    = gloader->current.num_subglyphs;
+
+        for ( i = 0; i < limit; ++i, ++subglyph )
+        {
+          if ( subglyph->flags & ARGS_ARE_XY_VALUES )
+          {
+            subglyph->arg1 += deltas[i].x;
+            subglyph->arg2 += deltas[i].y;
+          }
+        }
+
+        loader->pp1.x += deltas[i + 0].x; loader->pp1.y += deltas[i + 0].y;
+        loader->pp2.x += deltas[i + 1].x; loader->pp2.y += deltas[i + 1].y;
+        loader->pp3.x += deltas[i + 2].x; loader->pp3.y += deltas[i + 2].y;
+        loader->pp4.x += deltas[i + 3].x; loader->pp4.y += deltas[i + 3].y;
+
+        FT_FREE( deltas );
+      }
+
+#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
+
+      if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
+      {
+        loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale );
+        loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
+        loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale );
+        loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
+      }
+
+      /* if the flag FT_LOAD_NO_RECURSE is set, we return the subglyph */
+      /* `as is' in the glyph slot (the client application will be     */
+      /* responsible for interpreting these data)...                   */
+      /*                                                               */
+      if ( loader->load_flags & FT_LOAD_NO_RECURSE )
+      {
+        /* set up remaining glyph fields */
+        FT_GlyphLoader_Add( gloader );
+
+        glyph->num_subglyphs = gloader->base.num_subglyphs;
+        glyph->format        = FT_GLYPH_FORMAT_COMPOSITE;
+        glyph->subglyphs     = gloader->base.subglyphs;
+
+        goto Exit;
+      }
+
+      /*********************************************************************/
+      /*********************************************************************/
+      /*********************************************************************/
+
+      /* Now, read each subglyph independently. */
+      {
+        FT_Int       n, num_base_points, num_new_points;
+        FT_SubGlyph  subglyph       = 0;
+
+        FT_UInt      num_subglyphs  = gloader->current.num_subglyphs;
+        FT_UInt      num_base_subgs = gloader->base.num_subglyphs;
+
+
+        FT_GlyphLoader_Add( gloader );
+
+        for ( n = 0; n < (FT_Int)num_subglyphs; n++ )
+        {
+          FT_Vector  pp1, pp2, pp3, pp4;
+          FT_Pos     x, y;
+
+
+          /* Each time we call load_truetype_glyph in this loop, the   */
+          /* value of `gloader.base.subglyphs' can change due to table */
+          /* reallocations.  We thus need to recompute the subglyph    */
+          /* pointer on each iteration.                                */
+          subglyph = gloader->base.subglyphs + num_base_subgs + n;
+
+          pp1 = loader->pp1;
+          pp2 = loader->pp2;
+          pp3 = loader->pp3;
+          pp4 = loader->pp4;
+
+          num_base_points = gloader->base.outline.n_points;
+
+          error = load_truetype_glyph( loader, subglyph->index,
+                                       recurse_count + 1 );
+          if ( error )
+            goto Fail;
+
+          /* restore subglyph pointer */
+          subglyph = gloader->base.subglyphs + num_base_subgs + n;
+
+          if ( subglyph->flags & USE_MY_METRICS )
+          {
+            pp1 = loader->pp1;
+            pp2 = loader->pp2;
+            pp3 = loader->pp3;
+            pp4 = loader->pp4;
+          }
+          else
+          {
+            loader->pp1 = pp1;
+            loader->pp2 = pp2;
+            loader->pp3 = pp3;
+            loader->pp4 = pp4;
+          }
+
+          num_points = gloader->base.outline.n_points;
+
+          num_new_points = num_points - num_base_points;
+
+          /* now perform the transform required for this subglyph */
+
+          if ( subglyph->flags & ( WE_HAVE_A_SCALE     |
+                                   WE_HAVE_AN_XY_SCALE |
+                                   WE_HAVE_A_2X2       ) )
+          {
+            FT_Vector*  cur   = gloader->base.outline.points +
+                                  num_base_points;
+            FT_Vector*  org   = gloader->base.extra_points +
+                                  num_base_points;
+            FT_Vector*  limit = cur + num_new_points;
+
+
+            for ( ; cur < limit; cur++, org++ )
+            {
+              FT_Vector_Transform( cur, &subglyph->transform );
+              FT_Vector_Transform( org, &subglyph->transform );
+            }
+          }
+
+          /* apply offset */
+
+          if ( !( subglyph->flags & ARGS_ARE_XY_VALUES ) )
+          {
+            FT_UInt     k = subglyph->arg1;
+            FT_UInt     l = subglyph->arg2;
+            FT_Vector*  p1;
+            FT_Vector*  p2;
+
+
+            if ( start_point + k >= (FT_UInt)num_base_points ||
+                               l >= (FT_UInt)num_new_points  )
+            {
+              error = TT_Err_Invalid_Composite;
+              goto Fail;
+            }
+
+            l += num_base_points;
+
+            p1 = gloader->base.outline.points + start_point + k;
+            p2 = gloader->base.outline.points + start_point + l;
+
+            x = p1->x - p2->x;
+            y = p1->y - p2->y;
+          }
+          else
+          {
+            x = subglyph->arg1;
+            y = subglyph->arg2;
+
+  /* Use a default value dependent on                                     */
+  /* TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED.  This is useful for old TT */
+  /* fonts which don't set the xxx_COMPONENT_OFFSET bit.                  */
+
+#ifdef TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED
+            if ( !( subglyph->flags & UNSCALED_COMPONENT_OFFSET ) &&
+#else
+            if (  ( subglyph->flags & SCALED_COMPONENT_OFFSET ) &&
+#endif
+                  ( subglyph->flags & ( WE_HAVE_A_SCALE     |
+                                        WE_HAVE_AN_XY_SCALE |
+                                        WE_HAVE_A_2X2       )) )
+            {
+#if 0
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This algorithm is what Apple documents.  But it doesn't work.         */
+  /*                                                                       */
+              int  a = subglyph->transform.xx > 0 ?  subglyph->transform.xx
+                                                  : -subglyph->transform.xx;
+              int  b = subglyph->transform.yx > 0 ?  subglyph->transform.yx
+                                                  : -subglyph->transform.yx;
+              int  c = subglyph->transform.xy > 0 ?  subglyph->transform.xy
+                                                  : -subglyph->transform.xy;
+              int  d = subglyph->transform.yy > 0 ? subglyph->transform.yy
+                                                  : -subglyph->transform.yy;
+              int  m = a > b ? a : b;
+              int  n = c > d ? c : d;
+
+
+              if ( a - b <= 33 && a - b >= -33 )
+                m *= 2;
+              if ( c - d <= 33 && c - d >= -33 )
+                n *= 2;
+              x = FT_MulFix( x, m );
+              y = FT_MulFix( y, n );
+
+#else /* 0 */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This algorithm is a guess and works much better than the above.       */
+  /*                                                                       */
+              FT_Fixed  mac_xscale = FT_SqrtFixed(
+                                       FT_MulFix( subglyph->transform.xx,
+                                                  subglyph->transform.xx ) +
+                                       FT_MulFix( subglyph->transform.xy,
+                                                  subglyph->transform.xy) );
+              FT_Fixed  mac_yscale = FT_SqrtFixed(
+                                       FT_MulFix( subglyph->transform.yy,
+                                                  subglyph->transform.yy ) +
+                                       FT_MulFix( subglyph->transform.yx,
+                                                  subglyph->transform.yx ) );
+
+
+              x = FT_MulFix( x, mac_xscale );
+              y = FT_MulFix( y, mac_yscale );
+#endif /* 0 */
+
+            }
+
+            if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) )
+            {
+              x = FT_MulFix( x, x_scale );
+              y = FT_MulFix( y, y_scale );
+
+              if ( subglyph->flags & ROUND_XY_TO_GRID )
+              {
+                x = FT_PIX_ROUND( x );
+                y = FT_PIX_ROUND( y );
+              }
+            }
+          }
+
+          if ( x || y )
+          {
+            translate_array( num_new_points,
+                             gloader->base.outline.points + num_base_points,
+                             x, y );
+
+            translate_array( num_new_points,
+                             gloader->base.extra_points + num_base_points,
+                             x, y );
+          }
+        }
+
+        /*******************************************************************/
+        /*******************************************************************/
+        /*******************************************************************/
+
+        /* we have finished loading all sub-glyphs; now, look for */
+        /* instructions for this composite!                       */
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+        if ( num_subglyphs > 0               &&
+             loader->exec                    &&
+             ins_pos > 0                     &&
+             subglyph->flags & WE_HAVE_INSTR )
+        {
+          FT_UShort       n_ins;
+          TT_ExecContext  exec = loader->exec;
+          TT_GlyphZone    pts;
+          FT_Vector*      pp1;
+
+
+          /* read size of instructions */
+          if ( FT_STREAM_SEEK( ins_pos ) ||
+               FT_READ_USHORT( n_ins ) )
+            goto Fail;
+          FT_TRACE5(( "  Instructions size = %d\n", n_ins ));
+
+          /* in some fonts? */
+          if ( n_ins == 0xFFFFU )
+            n_ins = 0;
+
+          /* check it */
+          if ( n_ins > face->max_profile.maxSizeOfInstructions )
+          {
+            FT_TRACE0(( "Too many instructions (%d) in composite glyph %ld\n",
+                        n_ins, subglyph->index ));
+            error = TT_Err_Too_Many_Hints;
+            goto Fail;
+          }
+
+          /* read the instructions */
+          if ( FT_STREAM_READ( exec->glyphIns, n_ins ) )
+            goto Fail;
+
+          glyph->control_data = exec->glyphIns;
+          glyph->control_len  = n_ins;
+
+          error = TT_Set_CodeRange( exec,
+                                    tt_coderange_glyph,
+                                    exec->glyphIns,
+                                    n_ins );
+          if ( error )
+            goto Fail;
+
+          error = FT_GlyphLoader_CheckPoints( gloader, num_points + 4, 0 );
+          if ( error )
+            goto Fail;
+
+          /* prepare the execution context */
+          tt_prepare_zone( &exec->pts, &gloader->base,
+                           start_point, start_contour );
+          pts = &exec->pts;
+
+          pts->n_points   = (short)( num_points + 4 );
+          pts->n_contours = gloader->base.outline.n_contours;
+
+          /* add phantom points */
+          pp1    = pts->cur + num_points;
+          pp1[0] = loader->pp1;
+          pp1[1] = loader->pp2;
+          pp1[2] = loader->pp3;
+          pp1[3] = loader->pp4;
+
+          pts->tags[num_points    ] = 0;
+          pts->tags[num_points + 1] = 0;
+          pts->tags[num_points + 2] = 0;
+          pts->tags[num_points + 3] = 0;
+
+          /* if hinting, round the phantom points */
+          if ( IS_HINTED( loader->load_flags ) )
+          {
+            pp1[0].x = FT_PIX_ROUND( loader->pp1.x );
+            pp1[1].x = FT_PIX_ROUND( loader->pp2.x );
+            pp1[2].y = FT_PIX_ROUND( loader->pp3.y );
+            pp1[3].y = FT_PIX_ROUND( loader->pp4.y );
+          }
+
+          {
+            FT_UInt  k;
+
+
+            for ( k = 0; k < num_points; k++ )
+              pts->tags[k] &= FT_CURVE_TAG_ON;
+          }
+
+          cur_to_org( num_points + 4, pts );
+
+          /* now consider hinting */
+          if ( IS_HINTED( loader->load_flags ) && n_ins > 0 )
+          {
+            exec->is_composite     = TRUE;
+            exec->pedantic_hinting =
+              (FT_Bool)( loader->load_flags & FT_LOAD_PEDANTIC );
+            error = TT_Run_Context( exec, ((TT_Size)loader->size)->debug );
+            if ( error && exec->pedantic_hinting )
+              goto Fail;
+          }
+
+          /* save glyph origin and advance points */
+          loader->pp1 = pp1[0];
+          loader->pp2 = pp1[1];
+          loader->pp3 = pp1[2];
+          loader->pp4 = pp1[3];
+        }
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+      }
+      /* end of composite loading */
+    }
+    else
+    {
+      /* invalid composite count ( negative but not -1 ) */
+      error = TT_Err_Invalid_Outline;
+      goto Fail;
+    }
+
+    /***********************************************************************/
+    /***********************************************************************/
+    /***********************************************************************/
+
+  Fail:
+    if ( opened_frame )
+      face->forget_glyph_frame( loader );
+
+  Exit:
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    if ( glyph_data_loaded )
+      face->root.internal->incremental_interface->funcs->free_glyph_data(
+        face->root.internal->incremental_interface->object,
+        &glyph_data );
+#endif
+
+    return error;
+  }
+
+
+  static FT_Error
+  compute_glyph_metrics( TT_Loader   loader,
+                         FT_UInt     glyph_index )
+  {
+    FT_BBox       bbox;
+    TT_Face       face = (TT_Face)loader->face;
+    FT_Fixed      y_scale;
+    TT_GlyphSlot  glyph = loader->glyph;
+    TT_Size       size = (TT_Size)loader->size;
+
+
+    y_scale = 0x10000L;
+    if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
+      y_scale = size->root.metrics.y_scale;
+
+    if ( glyph->format != FT_GLYPH_FORMAT_COMPOSITE )
+    {
+      glyph->outline.flags &= ~FT_OUTLINE_SINGLE_PASS;
+
+      /* copy outline to our glyph slot */
+      FT_GlyphLoader_CopyPoints( glyph->internal->loader, loader->gloader );
+      glyph->outline = glyph->internal->loader->base.outline;
+
+      /* translate array so that (0,0) is the glyph's origin */
+      FT_Outline_Translate( &glyph->outline, -loader->pp1.x, 0 );
+
+      FT_Outline_Get_CBox( &glyph->outline, &bbox );
+
+      if ( IS_HINTED( loader->load_flags ) )
+      {
+        /* grid-fit the bounding box */
+        bbox.xMin = FT_PIX_FLOOR( bbox.xMin );
+        bbox.yMin = FT_PIX_FLOOR( bbox.yMin );
+        bbox.xMax = FT_PIX_CEIL( bbox.xMax );
+        bbox.yMax = FT_PIX_CEIL( bbox.yMax );
+      }
+    }
+    else
+      bbox = loader->bbox;
+
+    /* get the device-independent horizontal advance.  It is scaled later */
+    /* by the base layer.                                                 */
+    {
+      FT_Pos  advance = loader->linear;
+
+
+      /* the flag FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH was introduced to */
+      /* correctly support DynaLab fonts, which have an incorrect       */
+      /* `advance_Width_Max' field!  It is used, to my knowledge,       */
+      /* exclusively in the X-TrueType font server.                     */
+      /*                                                                */
+      if ( face->postscript.isFixedPitch                                     &&
+           ( loader->load_flags & FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ) == 0 )
+        advance = face->horizontal.advance_Width_Max;
+
+      /* we need to return the advance in font units in linearHoriAdvance, */
+      /* it will be scaled later by the base layer.                        */
+      glyph->linearHoriAdvance = advance;
+    }
+
+    glyph->metrics.horiBearingX = bbox.xMin;
+    glyph->metrics.horiBearingY = bbox.yMax;
+    glyph->metrics.horiAdvance  = loader->pp2.x - loader->pp1.x;
+
+    /* don't forget to hint the advance when we need to */
+    if ( IS_HINTED( loader->load_flags ) )
+      glyph->metrics.horiAdvance = FT_PIX_ROUND( glyph->metrics.horiAdvance );
+
+    /* Now take care of vertical metrics.  In the case where there is    */
+    /* no vertical information within the font (relatively common), make */
+    /* up some metrics by `hand'...                                      */
+
+    {
+      FT_Short   top_bearing;    /* vertical top side bearing (EM units) */
+      FT_UShort  advance_height; /* vertical advance height   (EM units) */
+
+      FT_Pos     left;     /* scaled vertical left side bearing */
+      FT_Pos     top;      /* scaled vertical top side bearing  */
+      FT_Pos     advance;  /* scaled vertical advance height    */
+
+
+      /* Get the unscaled top bearing and advance height. */
+      if ( face->vertical_info &&
+           face->vertical.number_Of_VMetrics > 0 )
+      {
+        advance_height = (FT_UShort)( loader->pp4.y - loader->pp3.y );
+        top_bearing    = (FT_Short)( loader->pp3.y - bbox.yMax );
+      }
+      else
+      {
+        /* Make up the distances from the horizontal header.   */
+
+        /* NOTE: The OS/2 values are the only `portable' ones, */
+        /*       which is why we use them, if there is an OS/2 */
+        /*       table in the font.  Otherwise, we use the     */
+        /*       values defined in the horizontal header.      */
+        /*                                                     */
+        /* NOTE2: The sTypoDescender is negative, which is why */
+        /*        we compute the baseline-to-baseline distance */
+        /*        here with:                                   */
+        /*             ascender - descender + linegap          */
+        /*                                                     */
+        /* NOTE3: This is different from what MS's rasterizer  */
+        /*        appears to do when getting default values    */
+        /*        for the vertical phantom points.  We leave   */
+        /*        the old code untouched, but relying on       */
+        /*        phantom points alone might be reasonable     */
+        /*        (i.e., removing the `if' above).             */
+        if ( face->os2.version != 0xFFFFU )
+        {
+          top_bearing    = (FT_Short)( face->os2.sTypoLineGap / 2 );
+          advance_height = (FT_UShort)( face->os2.sTypoAscender -
+                                        face->os2.sTypoDescender +
+                                        face->os2.sTypoLineGap );
+        }
+        else
+        {
+          top_bearing    = (FT_Short)( face->horizontal.Line_Gap / 2 );
+          advance_height = (FT_UShort)( face->horizontal.Ascender  +
+                                        face->horizontal.Descender +
+                                        face->horizontal.Line_Gap );
+        }
+      }
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+      /* If this is an incrementally loaded font see if there are */
+      /* overriding metrics for this glyph.                       */
+      if ( face->root.internal->incremental_interface &&
+           face->root.internal->incremental_interface->funcs->get_glyph_metrics )
+      {
+        FT_Incremental_MetricsRec  metrics;
+        FT_Error                   error = 0;
+
+
+        metrics.bearing_x = 0;
+        metrics.bearing_y = top_bearing;
+        metrics.advance = advance_height;
+        error =
+          face->root.internal->incremental_interface->funcs->get_glyph_metrics(
+            face->root.internal->incremental_interface->object,
+            glyph_index, TRUE, &metrics );
+
+        if ( error )
+          return error;
+
+        top_bearing    = (FT_Short)metrics.bearing_y;
+        advance_height = (FT_UShort)metrics.advance;
+      }
+
+      /* GWW: Do vertical metrics get loaded incrementally too? */
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+      /* We must adjust the top_bearing value from the bounding box given */
+      /* in the glyph header to the bounding box calculated with          */
+      /* FT_Get_Outline_CBox().                                           */
+
+      /* scale the metrics */
+      if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) )
+      {
+        top     = FT_MulFix( top_bearing + loader->bbox.yMax, y_scale )
+                    - bbox.yMax;
+        advance = FT_MulFix( advance_height, y_scale );
+      }
+      else
+      {
+        top     = top_bearing + loader->bbox.yMax - bbox.yMax;
+        advance = advance_height;
+      }
+
+      /* set the advance height in design units.  It is scaled later by */
+      /* the base layer.                                                */
+      glyph->linearVertAdvance = advance_height;
+
+      /* XXX: for now, we have no better algorithm for the lsb, but it */
+      /*      should work fine.                                        */
+      /*                                                               */
+      left = ( bbox.xMin - bbox.xMax ) / 2;
+
+      /* grid-fit them if necessary */
+      if ( IS_HINTED( loader->load_flags ) )
+      {
+        left    = FT_PIX_FLOOR( left );
+        top     = FT_PIX_CEIL( top );
+        advance = FT_PIX_ROUND( advance );
+      }
+
+      glyph->metrics.vertBearingX = left;
+      glyph->metrics.vertBearingY = top;
+      glyph->metrics.vertAdvance  = advance;
+    }
+
+    /* adjust advance width to the value contained in the hdmx table */
+    if ( !face->postscript.isFixedPitch && size &&
+         IS_HINTED( loader->load_flags )        )
+    {
+      FT_Byte*  widths = Get_Advance_Widths( face,
+                                             size->root.metrics.x_ppem );
+
+
+      if ( widths )
+        glyph->metrics.horiAdvance = widths[glyph_index] << 6;
+    }
+
+    /* set glyph dimensions */
+    glyph->metrics.width  = bbox.xMax - bbox.xMin;
+    glyph->metrics.height = bbox.yMax - bbox.yMin;
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Load_Glyph                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to load a single glyph within a given glyph slot,  */
+  /*    for a given size.                                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph       :: A handle to a target slot object where the glyph    */
+  /*                   will be loaded.                                     */
+  /*                                                                       */
+  /*    size        :: A handle to the source face size at which the glyph */
+  /*                   must be scaled/loaded.                              */
+  /*                                                                       */
+  /*    glyph_index :: The index of the glyph in the font file.            */
+  /*                                                                       */
+  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
+  /*                   FT_LOAD_XXX constants can be used to control the    */
+  /*                   glyph loading process (e.g., whether the outline    */
+  /*                   should be scaled, whether to load bitmaps or not,   */
+  /*                   whether to hint the outline, etc).                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Load_Glyph( TT_Size       size,
+                 TT_GlyphSlot  glyph,
+                 FT_UInt       glyph_index,
+                 FT_Int32      load_flags )
+  {
+    SFNT_Service  sfnt;
+    TT_Face       face;
+    FT_Stream     stream;
+    FT_Error      error;
+    TT_LoaderRec  loader;
+
+
+    face   = (TT_Face)glyph->face;
+    sfnt   = (SFNT_Service)face->sfnt;
+    stream = face->root.stream;
+    error  = 0;
+
+    if ( !size || ( load_flags & FT_LOAD_NO_SCALE )   ||
+                  ( load_flags & FT_LOAD_NO_RECURSE ) )
+    {
+      size        = NULL;
+      load_flags |= FT_LOAD_NO_SCALE   |
+                    FT_LOAD_NO_HINTING |
+                    FT_LOAD_NO_BITMAP;
+    }
+
+    glyph->num_subglyphs = 0;
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    /* try to load embedded bitmap if any              */
+    /*                                                 */
+    /* XXX: The convention should be emphasized in     */
+    /*      the documents because it can be confusing. */
+    if ( size                                    &&
+         size->strike_index != 0xFFFFU           &&
+         sfnt->load_sbits                        &&
+         ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
+
+    {
+      TT_SBit_MetricsRec  metrics;
+
+
+      error = sfnt->load_sbit_image( face,
+                                     (FT_ULong)size->strike_index,
+                                     glyph_index,
+                                     (FT_Int)load_flags,
+                                     stream,
+                                     &glyph->bitmap,
+                                     &metrics );
+      if ( !error )
+      {
+        glyph->outline.n_points   = 0;
+        glyph->outline.n_contours = 0;
+
+        glyph->metrics.width  = (FT_Pos)metrics.width  << 6;
+        glyph->metrics.height = (FT_Pos)metrics.height << 6;
+
+        glyph->metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6;
+        glyph->metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6;
+        glyph->metrics.horiAdvance  = (FT_Pos)metrics.horiAdvance  << 6;
+
+        glyph->metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6;
+        glyph->metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6;
+        glyph->metrics.vertAdvance  = (FT_Pos)metrics.vertAdvance  << 6;
+
+        glyph->format = FT_GLYPH_FORMAT_BITMAP;
+        if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
+        {
+          glyph->bitmap_left = metrics.vertBearingX;
+          glyph->bitmap_top  = metrics.vertBearingY;
+        }
+        else
+        {
+          glyph->bitmap_left = metrics.horiBearingX;
+          glyph->bitmap_top  = metrics.horiBearingY;
+        }
+        return error;
+      }
+    }
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+    /* return immediately if we only want the embedded bitmaps */
+    if ( load_flags & FT_LOAD_SBITS_ONLY )
+      return TT_Err_Invalid_Argument;
+
+    /* seek to the beginning of the glyph table.  For Type 42 fonts      */
+    /* the table might be accessed from a Postscript stream or something */
+    /* else...                                                           */
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    /* Don't look for the glyph table if this is an incremental font. */
+    if ( !face->root.internal->incremental_interface )
+
+#endif
+
+    {
+      error = face->goto_table( face, TTAG_glyf, stream, 0 );
+      if ( error )
+      {
+        FT_ERROR(( "TT_Load_Glyph: could not access glyph table\n" ));
+        goto Exit;
+      }
+    }
+
+    FT_MEM_ZERO( &loader, sizeof ( loader ) );
+
+    /* update the glyph zone bounds */
+    {
+      FT_GlyphLoader  gloader = FT_FACE_DRIVER(face)->glyph_loader;
+
+
+      loader.gloader = gloader;
+
+      FT_GlyphLoader_Rewind( gloader );
+
+      tt_prepare_zone( &loader.zone, &gloader->base, 0, 0 );
+      tt_prepare_zone( &loader.base, &gloader->base, 0, 0 );
+    }
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+    if ( size )
+    {
+      /* query new execution context */
+      loader.exec = size->debug ? size->context : TT_New_Context( face );
+      if ( !loader.exec )
+        return TT_Err_Could_Not_Find_Context;
+
+      TT_Load_Context( loader.exec, face, size );
+      loader.instructions = loader.exec->glyphIns;
+
+      /* load default graphics state - if needed */
+      if ( size->GS.instruct_control & 2 )
+        loader.exec->GS = tt_default_graphics_state;
+    }
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+    /* clear all outline flags, except the `owner' one */
+    glyph->outline.flags = 0;
+
+    /* let's initialize the rest of our loader now */
+
+    loader.load_flags    = load_flags;
+
+    loader.face   = (FT_Face)face;
+    loader.size   = (FT_Size)size;
+    loader.glyph  = (FT_GlyphSlot)glyph;
+    loader.stream = stream;
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    if ( face->root.internal->incremental_interface )
+      loader.glyf_offset = 0;
+    else
+
+#endif
+
+      loader.glyf_offset = FT_STREAM_POS();
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+    /* if the cvt program has disabled hinting, the argument */
+    /* is ignored.                                           */
+    if ( size && ( size->GS.instruct_control & 1 ) )
+      loader.load_flags |= FT_LOAD_NO_HINTING;
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+    /* Main loading loop */
+    glyph->format        = FT_GLYPH_FORMAT_OUTLINE;
+    glyph->num_subglyphs = 0;
+
+    error = load_truetype_glyph( &loader, glyph_index, 0 );
+    if ( !error )
+      compute_glyph_metrics( &loader, glyph_index );
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+    if ( !size || !size->debug )
+      TT_Done_Context( loader.exec );
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+    /* Set the `high precision' bit flag.                           */
+    /* This is _critical_ to get correct output for monochrome      */
+    /* TrueType glyphs at all sizes using the bytecode interpreter. */
+    /*                                                              */
+    if ( size && size->root.metrics.y_ppem < 24 )
+      glyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;
+
+  Exit:
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttgload.h b/nx-X11/extras/freetype2/src/truetype/ttgload.h
new file mode 100644
index 000000000..dfa2a60a5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttgload.h
@@ -0,0 +1,55 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttgload.h                                                              */
+/*                                                                         */
+/*    TrueType Glyph Loader (specification).                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 __TTGLOAD_H__
+#define __TTGLOAD_H__
+
+
+#include <ft2build.h>
+#include "ttobjs.h"
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+#include "ttinterp.h"
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( void )
+  TT_Get_Metrics( TT_HoriHeader*  header,
+                  FT_UInt         idx,
+                  FT_Short*       bearing,
+                  FT_UShort*      advance );
+
+  FT_LOCAL( void )
+  TT_Init_Glyph_Loading( TT_Face  face );
+
+  FT_LOCAL( FT_Error )
+  TT_Load_Glyph( TT_Size       size,
+                 TT_GlyphSlot  glyph,
+                 FT_UInt       glyph_index,
+                 FT_Int32      load_flags );
+
+
+FT_END_HEADER
+
+#endif /* __TTGLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttgxvar.c b/nx-X11/extras/freetype2/src/truetype/ttgxvar.c
new file mode 100644
index 000000000..e48bb5054
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttgxvar.c
@@ -0,0 +1,1520 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttgxvar.c                                                              */
+/*                                                                         */
+/*    TrueType GX Font Variation loader                                    */
+/*                                                                         */
+/*  Copyright 2004 by                                                      */
+/*  David Turner, Robert Wilhelm, Werner Lemberg, and George Williams.     */
+/*                                                                         */
+/*  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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* Apple documents the `fvar', `gvar', `cvar', and `avar' tables at        */
+/*                                                                         */
+/*   http://developer.apple.com/fonts/TTRefMan/RM06/Chap6[fgca]var.html    */
+/*                                                                         */
+/* The documentation for `fvar' is inconsistant.  At one point it says     */
+/* that `countSizePairs' should be 3, at another point 2.  It should be 2. */
+/*                                                                         */
+/* The documentation for `gvar' is not intelligible; `cvar' refers you to  */
+/* `gvar' and is thus also incomprehensible.                               */
+/*                                                                         */
+/* The documentation for `avar' appears correct, but Apple has no fonts    */
+/* with an `avar' table, so it is hard to test.                            */
+/*                                                                         */
+/* Many thanks to John Jenkins (at Apple) in figuring this out.            */
+/*                                                                         */
+/*                                                                         */
+/* Apple's `kern' table has some references to tuple indices, but as there */
+/* is no indication where these indices are defined, nor how to            */
+/* interpolate the kerning values (different tuples have different         */
+/* classes) this issue is ignored.                                         */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_CONFIG_CONFIG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_SFNT_H
+#include FT_TRUETYPE_IDS_H
+#include FT_TRUETYPE_TAGS_H
+#include FT_MULTIPLE_MASTERS_H
+
+#include "ttdriver.h"
+#include "ttpload.h"
+#include "ttgxvar.h"
+
+#include "tterrors.h"
+
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+
+
+#define FT_Stream_FTell( stream )  \
+          ( (stream)->cursor - (stream)->base )
+#define FT_Stream_SeekSet( stream, off ) \
+              ( (stream)->cursor = (stream)->base+(off) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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_ttgxvar
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       Internal Routines                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro ALL_POINTS is used in `ft_var_readpackedpoints'.  It        */
+  /* indicates that there is a delta for every point without needing to    */
+  /* enumerate all of them.                                                */
+  /*                                                                       */
+#define ALL_POINTS  (FT_UShort*)(-1)
+
+
+  enum
+  {
+    GX_PT_POINTS_ARE_WORDS     = 0x80,
+    GX_PT_POINT_RUN_COUNT_MASK = 0x7F
+  };
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_var_readpackedpoints                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Read a set of points to which the following deltas will apply.     */
+  /*    Points are packed with a run length encoding.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream    :: The data stream.                                      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    point_cnt :: The number of points read.  A zero value means that   */
+  /*                 all points in the glyph will be affected, without     */
+  /*                 enumerating them individually.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    An array of FT_UShort containing the affected points or the        */
+  /*    special value ALL_POINTS.                                          */
+  /*                                                                       */
+  static FT_UShort*
+  ft_var_readpackedpoints( FT_Stream  stream,
+                           FT_UInt   *point_cnt )
+  {
+    FT_UShort *points;
+    FT_Int     n;
+    FT_Int     runcnt;
+    FT_Int     i;
+    FT_Int     j;
+    FT_Int     first;
+    FT_Memory  memory = stream->memory;
+    FT_Error   error;
+
+
+    *point_cnt = n = FT_GET_BYTE();
+    if ( n == 0 )
+      return ALL_POINTS;
+
+    if ( n & GX_PT_POINTS_ARE_WORDS )
+      n = FT_GET_BYTE() | ( ( n & GX_PT_POINT_RUN_COUNT_MASK ) << 8 );
+
+    if ( FT_NEW_ARRAY( points, n ) )
+      return NULL;
+
+    i = 0;
+    while ( i < n )
+    {
+      runcnt = FT_GET_BYTE();
+      if ( runcnt & GX_PT_POINTS_ARE_WORDS )
+      {
+        runcnt = runcnt & GX_PT_POINT_RUN_COUNT_MASK;
+        points[i++] = first = FT_GET_USHORT();
+
+        /* first point not included in runcount */
+        for ( j = 0; j < runcnt; ++j )
+          points[i++] = ( first += FT_GET_USHORT() );
+      }
+      else
+      {
+        points[i++] = first = FT_GET_BYTE();
+
+        for ( j = 0; j < runcnt; ++j )
+          points[i++] = ( first += FT_GET_BYTE() );
+      }
+    }
+
+    return points;
+  }
+
+
+  enum
+  {
+    GX_DT_DELTAS_ARE_ZERO      = 0x80,
+    GX_DT_DELTAS_ARE_WORDS     = 0x40,
+    GX_DT_DELTA_RUN_COUNT_MASK = 0x3F
+  };
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_var_readpackeddeltas                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Read a set of deltas.  These are packed slightly differently than  */
+  /*    points.  In particular there is no overall count.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream    :: The data stream.                                      */
+  /*                                                                       */
+  /*    delta_cnt :: The number of to be read.                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    An array of FT_Short containing the deltas for the affected        */
+  /*    points.  (This only gets the deltas for one dimension.  It will    */
+  /*    generally be called twice, once for x, once for y.  When used in   */
+  /*    cvt table, it will only be called once.)                           */
+  /*                                                                       */
+  static FT_Short*
+  ft_var_readpackeddeltas( FT_Stream  stream,
+                           FT_Int     delta_cnt )
+  {
+    FT_Short  *deltas;
+    FT_Int     runcnt;
+    FT_Int     i;
+    FT_Int     j;
+    FT_Memory  memory = stream->memory;
+    FT_Error   error;
+
+
+    if ( FT_NEW_ARRAY( deltas, delta_cnt ) )
+      return NULL;
+
+    i = 0;
+    while ( i < delta_cnt )
+    {
+      runcnt = FT_GET_BYTE();
+      if ( runcnt & GX_DT_DELTAS_ARE_ZERO )
+      {
+        /* runcnt zeroes get added */
+        for ( j = 0;
+              j <= ( runcnt & GX_DT_DELTA_RUN_COUNT_MASK ) && i < delta_cnt;
+              ++j )
+          deltas[i++] = 0;
+      }
+      else if ( runcnt & GX_DT_DELTAS_ARE_WORDS )
+      {
+        /* runcnt shorts from the stack */
+        for ( j = 0;
+              j <= ( runcnt & GX_DT_DELTA_RUN_COUNT_MASK ) && i < delta_cnt;
+              ++j )
+          deltas[i++] = FT_GET_SHORT();
+      }
+      else
+      {
+        /* runcnt signed bytes from the stack */
+        for ( j = 0;
+              j <= ( runcnt & GX_DT_DELTA_RUN_COUNT_MASK ) && i < delta_cnt;
+              ++j )
+          deltas[i++] = FT_GET_CHAR();
+      }
+
+      if ( j <= ( runcnt & GX_DT_DELTA_RUN_COUNT_MASK ) )
+      {
+        /* Bad format */
+        FT_FREE( deltas );
+        return NULL;
+      }
+    }
+
+    return deltas;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_var_load_avar                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Parse the `avar' table if present.  It need not be, so we return   */
+  /*    nothing.                                                           */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face :: The font face.                                             */
+  /*                                                                       */
+  static void
+  ft_var_load_avar( TT_Face  face )
+  {
+    FT_Stream       stream = FT_FACE_STREAM(face);
+    FT_Memory       memory = stream->memory;
+    GX_Blend        blend  = face->blend;
+    GX_AVarSegment  segment;
+    FT_Error        error;
+    FT_ULong        version;
+    FT_Long         axisCount;
+    FT_Int          i, j;
+    FT_ULong        table_len;
+
+
+    blend->avar_checked = TRUE;
+    if ( ( error = face->goto_table( face, TTAG_avar, stream, &table_len ) ) )
+      return;
+    if ( FT_FRAME_ENTER( table_len ) )
+      return;
+
+    version   = FT_GET_LONG();
+    axisCount = FT_GET_LONG();
+
+    if ( version != 0x00010000L                       ||
+         axisCount != (FT_Long)blend->mmvar->num_axis )
+      goto Exit;
+
+    if ( FT_NEW_ARRAY( blend->avar_segment, axisCount ) )
+      goto Exit;
+
+    segment = &blend->avar_segment[0];
+    for ( i = 0; i < axisCount; ++i, ++segment )
+    {
+      segment->pairCount = FT_GET_USHORT();
+      if ( FT_NEW_ARRAY( segment->correspondence, segment->pairCount ) )
+      {
+        /* Failure.  Free everything we have done so far.  We must do */
+        /* it right now since loading the `avar' table is optional.   */
+
+        for ( j = i - 1; j >= 0; --j )
+          FT_FREE( blend->avar_segment[j].correspondence );
+
+        FT_FREE( blend->avar_segment );
+        blend->avar_segment = NULL;
+        goto Exit;
+      }
+
+      for ( j = 0; j < segment->pairCount; ++j )
+      {
+        segment->correspondence[j].fromCoord =
+          FT_GET_SHORT() << 2;    /* convert to Fixed */
+        segment->correspondence[j].toCoord =
+          FT_GET_SHORT()<<2;    /* convert to Fixed */
+      }
+    }
+
+  Exit:
+    FT_FRAME_EXIT();
+  }
+
+
+  typedef struct  GX_GVar_Head_ {
+    FT_Long    version;
+    FT_UShort  axisCount;
+    FT_UShort  globalCoordCount;
+    FT_ULong   offsetToCoord;
+    FT_UShort  glyphCount;
+    FT_UShort  flags;
+    FT_ULong   offsetToData;
+
+  } GX_GVar_Head;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_var_load_gvar                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Parses the `gvar' table if present.  If `fvar' is there, `gvar'    */
+  /*    had better be there too.                                           */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face :: The font face.                                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  ft_var_load_gvar( TT_Face  face )
+  {
+    FT_Stream     stream = FT_FACE_STREAM(face);
+    FT_Memory     memory = stream->memory;
+    GX_Blend      blend  = face->blend;
+    FT_Error      error;
+    FT_UInt       i, j;
+    FT_ULong      table_len;
+    FT_ULong      gvar_start;
+    FT_ULong      offsetToData;
+    GX_GVar_Head  gvar_head;
+
+    static const FT_Frame_Field  gvar_fields[] =
+    {
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  GX_GVar_Head
+
+      FT_FRAME_START( 20 ),
+        FT_FRAME_LONG  ( version ),
+        FT_FRAME_USHORT( axisCount ),
+        FT_FRAME_USHORT( globalCoordCount ),
+        FT_FRAME_ULONG ( offsetToCoord ),
+        FT_FRAME_USHORT( glyphCount ),
+        FT_FRAME_USHORT( flags ),
+        FT_FRAME_ULONG ( offsetToData ),
+      FT_FRAME_END
+    };
+
+    if ( ( error = face->goto_table( face, TTAG_gvar, stream, &table_len ) ) )
+      goto Exit;
+
+    gvar_start = FT_STREAM_POS( );
+    if ( FT_STREAM_READ_FIELDS( gvar_fields, &gvar_head ) )
+      goto Exit;
+
+    blend->tuplecount  = gvar_head.globalCoordCount;
+    blend->gv_glyphcnt = gvar_head.glyphCount;
+    offsetToData       = gvar_start + gvar_head.offsetToData;
+
+    if ( gvar_head.version != 0x00010000L              ||
+         gvar_head.axisCount != blend->mmvar->num_axis )
+    {
+      error = TT_Err_Invalid_Table;
+      goto Exit;
+    }
+
+    if ( FT_NEW_ARRAY( blend->glyphoffsets, blend->gv_glyphcnt + 1 ) )
+      goto Exit;
+
+    if ( gvar_head.flags & 1 )
+    {
+      /* long offsets (one more offset than glyphs, to mark size of last) */
+      if ( FT_FRAME_ENTER( ( blend->gv_glyphcnt + 1 ) * 4L ) )
+        goto Exit;
+
+      for ( i = 0; i <= blend->gv_glyphcnt; ++i )
+        blend->glyphoffsets[i] = offsetToData + FT_GET_LONG();
+
+      FT_FRAME_EXIT();
+    }
+    else
+    {
+      /* short offsets (one more offset than glyphs, to mark size of last) */
+      if ( FT_FRAME_ENTER( ( blend->gv_glyphcnt + 1 ) * 2L ) )
+        goto Exit;
+
+      for ( i = 0; i <= blend->gv_glyphcnt; ++i )
+        blend->glyphoffsets[i] = offsetToData + FT_GET_USHORT() * 2;
+                                              /* XXX: Undocumented: `*2'! */
+
+      FT_FRAME_EXIT();
+    }
+
+    if ( blend->tuplecount != 0 )
+    {
+      if ( FT_NEW_ARRAY( blend->tuplecoords,
+                         gvar_head.axisCount * blend->tuplecount ) )
+        goto Exit;
+
+      if ( FT_STREAM_SEEK( gvar_start + gvar_head.offsetToCoord )       ||
+           FT_FRAME_ENTER( blend->tuplecount * gvar_head.axisCount * 2L )                   )
+        goto Exit;
+
+      for ( i = 0; i < blend->tuplecount; ++i )
+        for ( j = 0 ; j < gvar_head.axisCount; ++j )
+          blend->tuplecoords[i * gvar_head.axisCount + j] =
+            FT_GET_SHORT() << 2;                /* convert to FT_Fixed */
+
+      FT_FRAME_EXIT();
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    ft_var_apply_tuple                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Figure out whether a given tuple (design) applies to the current   */
+  /*    blend, and if so, what is the scaling factor.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    blend           :: The current blend of the font.                  */
+  /*                                                                       */
+  /*    tupleIndex      :: A flag saying whether this is an intermediate   */
+  /*                       tuple or not.                                   */
+  /*                                                                       */
+  /*    tuple_coords    :: The coordinates of the tuple in normalized axis */
+  /*                       units.                                          */
+  /*                                                                       */
+  /*    im_start_coords :: The initial coordinates where this tuple starts */
+  /*                       to apply (for intermediate coordinates).        */
+  /*                                                                       */
+  /*    im_end_coords   :: The final coordinates after which this tuple no */
+  /*                       longer applies (for intermediate coordinates).  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    An FT_Fixed value containing the scaling factor.                   */
+  /*                                                                       */
+  static FT_Fixed
+  ft_var_apply_tuple( GX_Blend   blend,
+                      FT_UShort  tupleIndex,
+                      FT_Fixed*  tuple_coords,
+                      FT_Fixed*  im_start_coords,
+                      FT_Fixed*  im_end_coords )
+  {
+    FT_UInt   i;
+    FT_Fixed  apply;
+    FT_Fixed  temp;
+
+
+    apply = 0x10000L;
+    for ( i = 0; i < blend->num_axis; ++i )
+    {
+      if ( tuple_coords[i] == 0 )
+        /* It's not clear why (for intermediate tuples) we don't need     */
+        /* to check against start/end -- the documentation says we don't. */
+        /* Similarly, it's unclear why we don't need to scale along the   */
+        /* axis.                                                          */
+        continue;
+
+      else if ( blend->normalizedcoords[i] == 0                           ||
+                ( blend->normalizedcoords[i] < 0 && tuple_coords[i] > 0 ) ||
+                ( blend->normalizedcoords[i] > 0 && tuple_coords[i] < 0 ) )
+      {
+        apply = 0;
+        break;
+      }
+
+      else if ( !( tupleIndex & GX_TI_INTERMEDIATE_TUPLE ) )
+        /* not an intermediate tuple */
+        apply = FT_MulDiv( apply,
+                           blend->normalizedcoords[i] > 0
+                             ? blend->normalizedcoords[i]
+                             : -blend->normalizedcoords[i],
+                           0x10000L );
+
+      else if ( blend->normalizedcoords[i] <= im_start_coords[i] ||
+                blend->normalizedcoords[i] >= im_end_coords[i]   )
+      {
+        apply = 0;
+        break;
+      }
+
+      else if ( blend->normalizedcoords[i] < tuple_coords[i] )
+      {
+        temp = FT_MulDiv( blend->normalizedcoords[i] - im_start_coords[i],
+                          0x10000L,
+                          tuple_coords[i] - im_start_coords[i]);
+        apply = FT_MulDiv( apply, temp, 0x10000L );
+      }
+
+      else
+      {
+        temp = FT_MulDiv( im_end_coords[i] - blend->normalizedcoords[i],
+                          0x10000L,
+                          im_end_coords[i] - tuple_coords[i] );
+        apply = FT_MulDiv( apply, temp, 0x10000L );
+      }
+    }
+
+    return apply;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****               MULTIPLE MASTERS SERVICE FUNCTIONS              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  typedef struct  GX_FVar_Head_ {
+    FT_Long    version;
+    FT_UShort  offsetToData;
+    FT_UShort  countSizePairs;
+    FT_UShort  axisCount;
+    FT_UShort  axisSize;
+    FT_UShort  instanceCount;
+    FT_UShort  instanceSize;
+
+  } GX_FVar_Head;
+
+
+  typedef struct  fvar_axis {
+    FT_ULong   axisTag;
+    FT_ULong   minValue;
+    FT_ULong   defaultValue;
+    FT_ULong   maxValue;
+    FT_UShort  flags;
+    FT_UShort  nameID;
+
+  } GX_FVar_Axis;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Get_MM_Var                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Check that the font's `fvar' table is valid, parse it, and return  */
+  /*    those data.                                                        */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face   :: The font face.                                           */
+  /*              TT_Get_MM_Var initializes the blend structure.           */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    master :: The `fvar' data (must be freed by caller).               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Get_MM_Var( TT_Face      face,
+                 FT_MM_Var*  *master )
+  {
+    FT_Stream            stream = face->root.stream;
+    FT_Memory            memory = face->root.memory;
+    FT_ULong             table_len;
+    FT_Error             error  = TT_Err_Ok;
+    FT_ULong             fvar_start;
+    FT_Int               i, j;
+    FT_MM_Var*           mmvar;
+    FT_Fixed*            next_coords;
+    FT_String*           next_name;
+    FT_Var_Axis*         a;
+    FT_Var_Named_Style*  ns;
+    GX_FVar_Head         fvar_head;
+
+    static const FT_Frame_Field  fvar_fields[] =
+    {
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  GX_FVar_Head
+
+      FT_FRAME_START( 16 ),
+        FT_FRAME_LONG  ( version ),
+        FT_FRAME_USHORT( offsetToData ),
+        FT_FRAME_USHORT( countSizePairs ),
+        FT_FRAME_USHORT( axisCount ),
+        FT_FRAME_USHORT( axisSize ),
+        FT_FRAME_USHORT( instanceCount ),
+        FT_FRAME_USHORT( instanceSize ),
+      FT_FRAME_END
+    };
+
+    static const FT_Frame_Field  fvaraxis_fields[] =
+    {
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  GX_FVar_Axis
+
+      FT_FRAME_START( 20 ),
+        FT_FRAME_ULONG ( axisTag ),
+        FT_FRAME_ULONG ( minValue ),
+        FT_FRAME_ULONG ( defaultValue ),
+        FT_FRAME_ULONG ( maxValue ),
+        FT_FRAME_USHORT( flags ),
+        FT_FRAME_USHORT( nameID ),
+      FT_FRAME_END
+    };
+
+
+    if ( face->blend == NULL )
+    {
+      /* both `fvar' and `gvar' must be present */
+      if ( ( error = face->goto_table( face, TTAG_gvar,
+                                       stream, &table_len ) ) )
+        goto Exit;
+      if ( ( error = face->goto_table( face, TTAG_fvar,
+                                       stream, &table_len ) ) )
+        goto Exit;
+
+      fvar_start = FT_STREAM_POS( );
+
+      if ( FT_STREAM_READ_FIELDS( fvar_fields, &fvar_head ) )
+        goto Exit;
+
+      if ( fvar_head.version != 0x00010000UL                              ||
+           fvar_head.countSizePairs != 2                                  ||
+           fvar_head.axisSize != 20                                       ||
+           fvar_head.instanceSize != 4 + 4 * fvar_head.axisCount          ||
+           fvar_head.offsetToData + fvar_head.axisCount * 20U +
+             fvar_head.instanceCount * fvar_head.instanceSize > table_len )
+      {
+        error = TT_Err_Invalid_Table;
+        goto Exit;
+      }
+
+      if ( FT_ALLOC( face->blend, sizeof ( GX_BlendRec ) ) )
+        goto Exit;
+
+      face->blend->mmvar_len =
+        sizeof ( FT_MM_Var ) +
+        fvar_head.axisCount * sizeof ( FT_Var_Axis ) +
+        fvar_head.instanceCount * sizeof ( FT_Var_Named_Style ) +
+        fvar_head.instanceCount * fvar_head.axisCount * sizeof ( FT_Fixed ) +
+        5 * fvar_head.axisCount;
+      if ( FT_ALLOC( mmvar, face->blend->mmvar_len ) )
+        goto Exit;
+      face->blend->mmvar = mmvar;
+
+      mmvar->num_axis =
+        fvar_head.axisCount;
+      mmvar->num_designs =
+        (FT_UInt)-1;           /* meaningless in this context; each glyph */
+                               /* may have a different number of designs  */
+                               /* (or tuples, as called by Apple)         */
+      mmvar->num_namedstyles =
+        fvar_head.instanceCount;
+      mmvar->axis =
+        (FT_Var_Axis*)&(mmvar[1]);
+      mmvar->namedstyle =
+        (FT_Var_Named_Style*)&(mmvar->axis[fvar_head.axisCount]);
+
+      next_coords =
+        (FT_Fixed*)&(mmvar->namedstyle[fvar_head.instanceCount]);
+      for ( i = 0; i < fvar_head.instanceCount; ++i )
+      {
+        mmvar->namedstyle[i].coords  = next_coords;
+        next_coords                 += fvar_head.axisCount;
+      }
+
+      next_name = (FT_String*)next_coords;
+      for ( i = 0; i < fvar_head.axisCount; ++i )
+      {
+        mmvar->axis[i].name  = next_name;
+        next_name           += 5;
+      }
+
+      if ( FT_STREAM_SEEK( fvar_start + fvar_head.offsetToData ) )
+        goto Exit;
+
+      a = mmvar->axis;
+      for ( i = 0; i < fvar_head.axisCount; ++i )
+      {
+        GX_FVar_Axis  axis_rec;
+
+
+        if ( FT_STREAM_READ_FIELDS( fvaraxis_fields, &axis_rec ) )
+          goto Exit;
+        a->tag     = axis_rec.axisTag;
+        a->minimum = axis_rec.minValue;     /* A Fixed */
+        a->def     = axis_rec.defaultValue; /* A Fixed */
+        a->maximum = axis_rec.maxValue;     /* A Fixed */
+        a->strid   = axis_rec.nameID;
+
+        a->name[0] =   a->tag >> 24;
+        a->name[1] = ( a->tag >> 16 ) & 0xFF;
+        a->name[2] = ( a->tag >>  8 ) & 0xFF;
+        a->name[3] = ( a->tag       ) & 0xFF;
+        a->name[4] = 0;
+
+        ++a;
+      }
+
+      ns = mmvar->namedstyle;
+      for ( i = 0; i < fvar_head.instanceCount; ++i )
+      {
+        if ( FT_FRAME_ENTER( 4L + 4L * fvar_head.axisCount ) )
+          goto Exit;
+
+        ns->strid       =    FT_GET_USHORT();
+        (void) /* flags = */ FT_GET_USHORT();
+
+        for ( j = 0; j < fvar_head.axisCount; ++j )
+          ns->coords[j] = FT_GET_ULONG();     /* A Fixed */
+
+        FT_FRAME_EXIT();
+      }
+    }
+
+    if ( master != NULL )
+    {
+      FT_UInt  n;
+
+
+      if ( FT_ALLOC( mmvar, face->blend->mmvar_len ) )
+        goto Exit;
+      FT_MEM_COPY( mmvar, face->blend->mmvar, face->blend->mmvar_len );
+
+      mmvar->axis =
+        (FT_Var_Axis*)&(mmvar[1]);
+      mmvar->namedstyle =
+        (FT_Var_Named_Style*)&(mmvar->axis[mmvar->num_axis]);
+      next_coords =
+        (FT_Fixed*)&(mmvar->namedstyle[mmvar->num_namedstyles]);
+
+      for ( n = 0; n < mmvar->num_namedstyles; ++n )
+      {
+        mmvar->namedstyle[n].coords  = next_coords;
+        next_coords                 += mmvar->num_axis;
+      }
+
+      a = mmvar->axis;
+      next_name = (FT_String*)next_coords;
+      for ( n = 0; n < mmvar->num_axis; ++n )
+      {
+        a->name = next_name;
+
+        /* standard PostScript names for some standard apple tags */
+        if ( a->tag == TTAG_wght )
+          a->name = (char *)"Weight";
+        else if ( a->tag == TTAG_wdth )
+          a->name = (char *)"Width";
+        else if ( a->tag == TTAG_opsz )
+          a->name = (char *)"OpticalSize";
+        else if ( a->tag == TTAG_slnt )
+          a->name = (char *)"Slant";
+
+        next_name += 5;
+        ++a;
+      }
+
+      *master = mmvar;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Set_MM_Blend                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Set the blend (normalized) coordinates for this instance of the    */
+  /*    font.  Check that the `gvar' table is reasonable and does some     */
+  /*    initial preparation.                                               */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: The font.                                            */
+  /*                  Initialize the blend structure with `gvar' data.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_coords :: Must be the axis count of the font.                  */
+  /*                                                                       */
+  /*    coords     :: An array of num_coords, each between [-1,1].         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Set_MM_Blend( TT_Face    face,
+                   FT_UInt    num_coords,
+                   FT_Fixed*  coords )
+  {
+    FT_Error    error = TT_Err_Ok;
+    GX_Blend    blend;
+    FT_MM_Var*  mmvar;
+    FT_UInt     i;
+    FT_Memory   memory = face->root.memory;
+
+    enum
+    {
+      mcvt_retain,
+      mcvt_modify,
+      mcvt_load
+
+    } manageCvt;
+
+
+    face->doblend = FALSE;
+
+    if ( face->blend == NULL )
+    {
+      if ( ( error = TT_Get_MM_Var( face, NULL) ) )
+        goto Exit;
+    }
+
+    blend = face->blend;
+    mmvar = blend->mmvar;
+
+    if ( num_coords != mmvar->num_axis )
+    {
+      error = TT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    for ( i = 0; i < num_coords; ++i )
+      if ( coords[i] < -0x00010000L || coords[i] > 0x00010000L )
+      {
+        error = TT_Err_Invalid_Argument;
+        goto Exit;
+      }
+
+    if ( blend->glyphoffsets == NULL )
+      if ( ( error = ft_var_load_gvar( face ) ) )
+        goto Exit;
+
+    if ( blend->normalizedcoords == NULL )
+    {
+      if ( FT_NEW_ARRAY( blend->normalizedcoords, num_coords ) )
+        goto Exit;
+
+      manageCvt = mcvt_modify;
+
+      /* If we have not set the blend coordinates before this, then the  */
+      /* cvt table will still be what we read from the `cvt ' table and  */
+      /* we don't need to reload it.  We may need to change it though... */
+    }
+    else
+    {
+      for ( i = 0;
+            i < num_coords && blend->normalizedcoords[i] == coords[i];
+            ++i );
+        if ( i == num_coords )
+          manageCvt = mcvt_retain;
+        else
+          manageCvt = mcvt_load;
+
+      /* If we don't change the blend coords then we don't need to do  */
+      /* anything to the cvt table.  It will be correct.  Otherwise we */
+      /* no longer have the original cvt (it was modified when we set  */
+      /* the blend last time), so we must reload and then modify it.   */
+    }
+
+    blend->num_axis = num_coords;
+    FT_MEM_COPY( blend->normalizedcoords,
+                 coords,
+                 num_coords * sizeof ( FT_Fixed ) );
+
+    face->doblend = TRUE;
+
+    if ( face->cvt != NULL )
+    {
+      switch ( manageCvt )
+      {
+      case mcvt_load:
+        /* The cvt table has been loaded already; every time we change the */
+        /* blend we may need to reload and remodify the cvt table.         */
+        FT_FREE( face->cvt );
+        face->cvt = NULL;
+
+        tt_face_load_cvt( face, face->root.stream );
+        break;
+
+      case mcvt_modify:
+        /* The original cvt table is in memory.  All we need to do is */
+        /* apply the `cvar' table (if any).                           */
+        tt_face_vary_cvt( face, face->root.stream );
+        break;
+
+      case mcvt_retain:
+        /* The cvt table is correct for this set of coordinates. */
+        break;
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Set_Var_Design                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Set the coordinates for the instance, measured in the user         */
+  /*    coordinate system.  Parse the `avar' table (if present) to convert */
+  /*    from user to normalized coordinates.                               */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: The font face.                                       */
+  /*                  Initialize the blend struct with `gvar' data.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_coords :: This must be the axis count of the font.             */
+  /*                                                                       */
+  /*    coords     :: A coordinate array with `num_coords' elements.       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Set_Var_Design( TT_Face    face,
+                     FT_UInt    num_coords,
+                     FT_Fixed*  coords )
+  {
+    FT_Error        error      = TT_Err_Ok;
+    FT_Fixed*       normalized = NULL;
+    GX_Blend        blend;
+    FT_MM_Var*      mmvar;
+    FT_UInt         i, j;
+    FT_Var_Axis*    a;
+    GX_AVarSegment  av;
+    FT_Memory       memory = face->root.memory;
+
+
+    if ( face->blend == NULL )
+    {
+      if ( ( error = TT_Get_MM_Var( face, NULL ) ) )
+        goto Exit;
+    }
+
+    blend = face->blend;
+    mmvar = blend->mmvar;
+
+    if ( num_coords != mmvar->num_axis )
+    {
+      error = TT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* Axis normalization is a two stage process.  First we normalize */
+    /* based on the [min,def,max] values for the axis to be [-1,0,1]. */
+    /* Then, if there's an `avar' table, we renormalize this range.   */
+
+    if ( FT_NEW_ARRAY( normalized, mmvar->num_axis ) )
+      goto Exit;
+
+    a = mmvar->axis;
+    for ( i = 0; i < mmvar->num_axis; ++i, ++a )
+    {
+      if ( coords[i] > a->maximum || coords[i] < a->minimum )
+      {
+        error = TT_Err_Invalid_Argument;
+        goto Exit;
+      }
+
+      if ( coords[i] < a->def )
+      {
+        normalized[i] = -FT_MulDiv( coords[i] - a->def,
+                                    0x10000L,
+                                    a->minimum - a->def );
+      }
+      else if ( a->maximum == a->def )
+        normalized[i] = 0;
+      else
+      {
+        normalized[i] = FT_MulDiv( coords[i] - a->def,
+                                   0x10000L,
+                                   a->maximum - a->def );
+      }
+    }
+
+    if ( !blend->avar_checked )
+      ft_var_load_avar( face );
+
+    if ( blend->avar_segment != NULL )
+    {
+      av = blend->avar_segment;
+      for ( i = 0; i < mmvar->num_axis; ++i, ++av )
+      {
+        for ( j = 1; j < av->pairCount; ++j )
+          if ( normalized[i] < av->correspondence[j].fromCoord )
+          {
+            normalized[i] =
+              FT_MulDiv(
+                FT_MulDiv(
+                  normalized[i] - av->correspondence[j - 1].fromCoord,
+                  0x10000L,
+                  av->correspondence[j].fromCoord -
+                    av->correspondence[j - 1].fromCoord ),
+                av->correspondence[j].toCoord -
+                  av->correspondence[j - 1].toCoord,
+                0x10000L ) +
+              av->correspondence[j - 1].toCoord;
+            break;
+          }
+      }
+    }
+
+    error = TT_Set_MM_Blend( face, num_coords, normalized );
+
+  Exit:
+    FT_FREE( normalized );
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                     GX VAR PARSING ROUTINES                   *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_vary_cvt                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Modify the loaded cvt table according to the `cvar' table and the  */
+  /*    font's blend.                                                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream :: A handle to the input stream.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /*    Most errors are ignored.  It is perfectly valid not to have a      */
+  /*    `cvar' table even if there is a `gvar' and `fvar' table.           */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_vary_cvt( TT_Face    face,
+                    FT_Stream  stream )
+  {
+    FT_Error    error;
+    FT_Memory   memory = stream->memory;
+    FT_ULong    table_start;
+    FT_ULong    table_len;
+    FT_UInt     tupleCount;
+    FT_ULong    offsetToData;
+    FT_ULong    here;
+    FT_UInt     i, j;
+    FT_Fixed*   tuple_coords    = NULL;
+    FT_Fixed*   im_start_coords = NULL;
+    FT_Fixed*   im_end_coords   = NULL;
+    GX_Blend    blend           = face->blend;
+    FT_UInt     point_count;
+    FT_UShort*  localpoints;
+    FT_Short*   deltas;
+
+
+    FT_TRACE2(( "CVAR " ));
+
+    if ( blend == NULL )
+    {
+      FT_TRACE2(( "no blend specified!\n" ));
+
+      error = TT_Err_Ok;
+      goto Exit;
+    }
+
+    if ( face->cvt == NULL )
+    {
+      FT_TRACE2(( "no `cvt ' table!\n" ));
+
+      error = TT_Err_Ok;
+      goto Exit;
+    }
+
+    error = face->goto_table( face, TTAG_cvar, stream, &table_len );
+    if ( error )
+    {
+      FT_TRACE2(( "is missing!\n" ));
+
+      error = TT_Err_Ok;
+      goto Exit;
+    }
+
+    if ( FT_FRAME_ENTER( table_len ) )
+    {
+      error = TT_Err_Ok;
+      goto Exit;
+    }
+
+    table_start = FT_Stream_FTell( stream );
+    if ( FT_GET_LONG() != 0x00010000L )
+    {
+      FT_TRACE2(( "bad table version!\n" ));
+
+      error = TT_Err_Ok;
+      goto FExit;
+    }
+
+    if ( FT_NEW_ARRAY( tuple_coords, blend->num_axis )    ||
+         FT_NEW_ARRAY( im_start_coords, blend->num_axis ) ||
+         FT_NEW_ARRAY( im_end_coords, blend->num_axis )   )
+      goto FExit;
+
+    tupleCount   = FT_GET_USHORT();
+    offsetToData = table_start + FT_GET_USHORT();
+
+    /* The documentation implies there are flags packed into the        */
+    /* tuplecount, but John Jenkins says that shared points don't apply */
+    /* to `cvar', and no other flags are defined.                       */
+
+    for ( i = 0; i < ( tupleCount & 0xFFF ); ++i )
+    {
+      FT_UInt   tupleDataSize;
+      FT_UInt   tupleIndex;
+      FT_Fixed  apply;
+
+
+      tupleDataSize = FT_GET_USHORT();
+      tupleIndex    = FT_GET_USHORT();
+
+      /* There is no provision here for a global tuple coordinate section, */
+      /* so John says.  There are no tuple indices, just embedded tuples.  */
+
+      if ( tupleIndex & GX_TI_EMBEDDED_TUPLE_COORD )
+      {
+        for ( j = 0; j < blend->num_axis; ++j )
+          tuple_coords[j] = FT_GET_SHORT() << 2; /* convert from        */
+                                                 /* short frac to fixed */
+      }
+      else
+      {
+        /* skip this tuple; it makes no sense */
+
+        if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE )
+          for ( j = 0; j < 2 * blend->num_axis; ++j )
+            (void)FT_GET_SHORT();
+
+        offsetToData += tupleDataSize;
+        continue;
+      }
+
+      if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE )
+      {
+        for ( j = 0; j < blend->num_axis; ++j )
+          im_start_coords[j] = FT_GET_SHORT() << 2;
+        for ( j = 0; j < blend->num_axis; ++j )
+          im_end_coords[j] = FT_GET_SHORT() << 2;
+      }
+
+      apply = ft_var_apply_tuple( blend,
+                                  tupleIndex,
+                                  tuple_coords,
+                                  im_start_coords,
+                                  im_end_coords );
+      if ( /* tuple isn't active for our blend */
+           apply == 0                                    ||
+           /* global points not allowed,           */
+           /* if they aren't local, makes no sense */
+           !( tupleIndex & GX_TI_PRIVATE_POINT_NUMBERS ) )
+      {
+        offsetToData += tupleDataSize;
+        continue;
+      }
+
+      here = FT_Stream_FTell( stream );
+
+      FT_Stream_SeekSet( stream, offsetToData );
+
+      localpoints = ft_var_readpackedpoints( stream, &point_count );
+      deltas      = ft_var_readpackeddeltas( stream,
+                                             point_count == 0 ? face->cvt_size
+                                                              : point_count );
+      if ( localpoints == NULL || deltas == NULL )
+        /* failure, ignore it */;
+
+      else if ( localpoints == ALL_POINTS )
+      {
+        /* this means that there are deltas for every entry in cvt */
+        for ( j = 0; j < face->cvt_size; ++j )
+          face->cvt[j] += FT_MulFix( deltas[j], apply );
+      }
+
+      else
+      {
+        for ( j = 0; j < point_count; ++j )
+          face->cvt[localpoints[j]] += FT_MulFix( deltas[j], apply );
+      }
+
+      if ( localpoints != ALL_POINTS )
+        FT_FREE( localpoints );
+      FT_FREE( deltas );
+
+      offsetToData += tupleDataSize;
+
+      FT_Stream_SeekSet( stream, here );
+    }
+
+  FExit:
+    FT_FRAME_EXIT();
+
+  Exit:
+    FT_FREE( tuple_coords );
+    FT_FREE( im_start_coords );
+    FT_FREE( im_end_coords );
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Vary_Get_Glyph_Deltas                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Load the appropriate deltas for the current glyph.                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to the target face object.                 */
+  /*                                                                       */
+  /*    glyph_index :: The index of the glyph being modified.              */
+  /*                                                                       */
+  /*    n_points    :: The number of the points in the glyph, including    */
+  /*                   phantom points.                                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    deltas      :: The array of points to change.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Vary_Get_Glyph_Deltas( TT_Face      face,
+                            FT_UInt      glyph_index,
+                            FT_Vector*  *deltas,
+                            FT_UInt      n_points )
+  {
+    FT_Stream   stream = face->root.stream;
+    FT_Memory   memory = stream->memory;
+    GX_Blend    blend  = face->blend;
+    FT_Vector*  delta_xy;
+
+    FT_Error    error;
+    FT_ULong    glyph_start;
+    FT_UInt     tupleCount;
+    FT_ULong    offsetToData;
+    FT_ULong    here;
+    FT_UInt     i, j;
+    FT_Fixed*   tuple_coords    = NULL;
+    FT_Fixed*   im_start_coords = NULL;
+    FT_Fixed*   im_end_coords   = NULL;
+    FT_UInt     point_count, spoint_count = 0;
+    FT_UShort*  sharedpoints = NULL;
+    FT_UShort*  localpoints;
+    FT_UShort*  points;
+    FT_Short    *deltas_x, *deltas_y;
+
+
+    if ( !face->doblend || blend == NULL )
+      return TT_Err_Invalid_Argument;
+
+    /* to be freed by the caller */
+    if ( ( error = FT_NEW_ARRAY( delta_xy, n_points ) ) )
+      goto Exit;
+    *deltas = delta_xy;
+
+    if ( glyph_index >= blend->gv_glyphcnt      ||
+         blend->glyphoffsets[glyph_index] ==
+           blend->glyphoffsets[glyph_index + 1] )
+      return TT_Err_Ok;               /* no variation data for this glyph */
+
+    if ( FT_STREAM_SEEK( blend->glyphoffsets[glyph_index] )   ||
+         FT_FRAME_ENTER( blend->glyphoffsets[glyph_index + 1] -
+                           blend->glyphoffsets[glyph_index] ) )
+      goto Fail1;
+
+    glyph_start = FT_Stream_FTell( stream );
+
+    /* each set of glyph variation data is formatted similarly to `cvar' */
+    /* (except we get shared points and global tuples)                   */
+
+    if ( FT_NEW_ARRAY( tuple_coords, blend->num_axis )    ||
+         FT_NEW_ARRAY( im_start_coords, blend->num_axis ) ||
+         FT_NEW_ARRAY( im_end_coords, blend->num_axis )   )
+      goto Fail2;
+
+    tupleCount   = FT_GET_USHORT();
+    offsetToData = glyph_start + FT_GET_USHORT();
+
+    if ( tupleCount & GX_TC_TUPLES_SHARE_POINT_NUMBERS )
+    {
+      here = FT_Stream_FTell( stream );
+
+      FT_Stream_SeekSet( stream, offsetToData );
+
+      sharedpoints = ft_var_readpackedpoints( stream, &spoint_count );
+      offsetToData = FT_Stream_FTell( stream );
+
+      FT_Stream_SeekSet( stream, here );
+    }
+
+    for ( i = 0; i < ( tupleCount & GX_TC_TUPLE_COUNT_MASK ); ++i )
+    {
+      FT_UInt   tupleDataSize;
+      FT_UInt   tupleIndex;
+      FT_Fixed  apply;
+
+
+      tupleDataSize = FT_GET_USHORT();
+      tupleIndex    = FT_GET_USHORT();
+
+      if ( tupleIndex & GX_TI_EMBEDDED_TUPLE_COORD )
+      {
+        for ( j = 0; j < blend->num_axis; ++j )
+          tuple_coords[j] = FT_GET_SHORT() << 2;  /* convert from        */
+                                                  /* short frac to fixed */
+      }
+      else if ( ( tupleIndex & GX_TI_TUPLE_INDEX_MASK ) >= blend->tuplecount )
+      {
+        error = TT_Err_Invalid_Table;
+        goto Fail3;
+      }
+      else
+      {
+        FT_MEM_COPY(
+          tuple_coords,
+          &blend->tuplecoords[(tupleIndex & 0xFFF) * blend->num_axis],
+          blend->num_axis * sizeof ( FT_Fixed ) );
+      }
+
+      if ( tupleIndex & GX_TI_INTERMEDIATE_TUPLE )
+      {
+        for ( j = 0; j < blend->num_axis; ++j )
+          im_start_coords[j] = FT_GET_SHORT() << 2;
+        for ( j = 0; j < blend->num_axis; ++j )
+          im_end_coords[j] = FT_GET_SHORT() << 2;
+      }
+
+      apply = ft_var_apply_tuple( blend,
+                                  tupleIndex,
+                                  tuple_coords,
+                                  im_start_coords,
+                                  im_end_coords );
+
+      if ( apply == 0 )              /* tuple isn't active for our blend */
+      {
+        offsetToData += tupleDataSize;
+        continue;
+      }
+
+      here = FT_Stream_FTell( stream );
+
+      if ( tupleIndex & GX_TI_PRIVATE_POINT_NUMBERS )
+      {
+        FT_Stream_SeekSet( stream, offsetToData );
+
+        localpoints = ft_var_readpackedpoints( stream, &point_count );
+        points      = localpoints;
+      }
+      else
+      {
+        points      = sharedpoints;
+        point_count = spoint_count;
+      }
+
+      deltas_x = ft_var_readpackeddeltas( stream,
+                                          point_count == 0 ? n_points
+                                                           : point_count );
+      deltas_y = ft_var_readpackeddeltas( stream,
+                                          point_count == 0 ? n_points
+                                                           : point_count );
+
+      if ( points == NULL || deltas_y == NULL || deltas_x == NULL )
+        ; /* failure, ignore it */
+
+      else if ( points == ALL_POINTS )
+      {
+        /* this means that there are deltas for every point in the glyph */
+        for ( j = 0; j < n_points; ++j )
+        {
+          delta_xy[j].x += FT_MulFix( deltas_x[j], apply );
+          delta_xy[j].y += FT_MulFix( deltas_y[j], apply );
+        }
+      }
+
+      else
+      {
+        for ( j = 0; j < point_count; ++j )
+        {
+          delta_xy[localpoints[j]].x += FT_MulFix( deltas_x[j], apply );
+          delta_xy[localpoints[j]].y += FT_MulFix( deltas_y[j], apply );
+        }
+      }
+
+      if ( localpoints != ALL_POINTS )
+        FT_FREE( localpoints );
+      FT_FREE( deltas_x );
+      FT_FREE( deltas_y );
+
+      offsetToData += tupleDataSize;
+
+      FT_Stream_SeekSet( stream, here );
+    }
+
+  Fail3:
+    FT_FREE( tuple_coords );
+    FT_FREE( im_start_coords );
+    FT_FREE( im_end_coords );
+
+  Fail2:
+    FT_FRAME_EXIT();
+
+  Fail1:
+    if ( error )
+    {
+      FT_FREE( delta_xy );
+      *deltas = NULL;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_done_blend                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Frees the blend internal data structure.                           */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  tt_done_blend( FT_Memory  memory,
+                 GX_Blend   blend )
+  {
+    if ( blend != NULL )
+    {
+      FT_UInt  i;
+
+
+      FT_FREE( blend->normalizedcoords );
+      FT_FREE( blend->mmvar );
+
+      if ( blend->avar_segment != NULL )
+      {
+        for ( i = 0; i < blend->num_axis; ++i )
+          FT_FREE( blend->avar_segment[i].correspondence );
+        FT_FREE( blend->avar_segment );
+      }
+
+      FT_FREE( blend->tuplecoords );
+      FT_FREE( blend->glyphoffsets );
+      FT_FREE( blend );
+    }
+  }
+
+#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttgxvar.h b/nx-X11/extras/freetype2/src/truetype/ttgxvar.h
new file mode 100644
index 000000000..e86c7eecc
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttgxvar.h
@@ -0,0 +1,182 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttgxvar.h                                                              */
+/*                                                                         */
+/*    TrueType GX Font Variation loader (specification)                    */
+/*                                                                         */
+/*  Copyright 2004 by                                                      */
+/*  David Turner, Robert Wilhelm, Werner Lemberg and George Williams.      */
+/*                                                                         */
+/*  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 __TTGXVAR_H__
+#define __TTGXVAR_H__
+
+
+#include <ft2build.h>
+#include "ttobjs.h"
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    GX_AVarCorrespondenceRec                                           */
+  /*                                                                       */
+  /* <Description>                                                         */  
+  /*    A data structure representing `shortFracCorrespondence' in `avar'  */
+  /*    table according to the specifications from Apple.                  */
+  /*                                                                       */
+  typedef struct  GX_AVarCorrespondenceRec_
+  {
+    FT_Fixed  fromCoord;
+    FT_Fixed  toCoord;
+
+  } GX_AVarCorrespondenceRec_, *GX_AVarCorrespondence;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    GX_AVarRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Data from the segment field of `avar' table.                       */
+  /*    There is one of these for each axis.                               */
+  /*                                                                       */
+  typedef struct  GX_AVarSegmentRec_
+  {
+    FT_UShort              pairCount;
+    GX_AVarCorrespondence  correspondence; /* array with pairCount entries */
+
+  } GX_AVarSegmentRec, *GX_AVarSegment;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    GX_BlendRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Data for interpolating a font from a distortable font specified    */
+  /*    by the GX *var tables ([fgca]var).                                 */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_axis         :: The number of axes along which interpolation   */
+  /*                         may happen                                    */
+  /*                                                                       */
+  /*    normalizedcoords :: A normalized value (between [-1,1]) indicating */
+  /*                        the contribution along each axis to the final  */
+  /*                        interpolated font.                             */
+  /*                                                                       */
+  typedef struct  GX_BlendRec_
+  {
+    FT_UInt         num_axis;
+    FT_Fixed*       normalizedcoords;
+
+    FT_MM_Var*      mmvar;
+    FT_Int          mmvar_len;
+
+    FT_Bool         avar_checked;
+    GX_AVarSegment  avar_segment;
+
+    FT_UInt         tuplecount;      /* shared tuples in `gvar'           */
+    FT_Fixed*       tuplecoords;     /* tuplecoords[tuplecount][num_axis] */
+
+    FT_UInt         gv_glyphcnt;
+    FT_ULong*       glyphoffsets;
+    
+  } GX_BlendRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <enum>                                                                */
+  /*    GX_TupleCountFlags                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Flags used within the `TupleCount' field of the `gvar' table.      */
+  /*                                                                       */
+  typedef enum  GX_TupleCountFlags_
+  {
+    GX_TC_TUPLES_SHARE_POINT_NUMBERS = 0x8000,
+    GX_TC_RESERVED_TUPLE_FLAGS       = 0x7000,
+    GX_TC_TUPLE_COUNT_MASK           = 0x0FFF
+
+  } GX_TupleCountFlags;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <enum>                                                                */
+  /*    GX_TupleIndexFlags                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Flags used within the `TupleIndex' field of the `gvar' and `cvar'  */
+  /*    tables.                                                            */
+  /*                                                                       */
+  typedef enum  GX_TupleIndexFlags_
+  {
+    GX_TI_EMBEDDED_TUPLE_COORD  = 0x8000,
+    GX_TI_INTERMEDIATE_TUPLE    = 0x4000,
+    GX_TI_PRIVATE_POINT_NUMBERS = 0x2000,
+    GX_TI_RESERVED_TUPLE_FLAG   = 0x1000,
+    GX_TI_TUPLE_INDEX_MASK      = 0x0FFF
+
+  } GX_TupleIndexFlags;
+
+
+#define TTAG_wght  FT_MAKE_TAG( 'w', 'g', 'h', 't' )
+#define TTAG_wdth  FT_MAKE_TAG( 'w', 'd', 't', 'h' )
+#define TTAG_opsz  FT_MAKE_TAG( 'o', 'p', 's', 'z' )
+#define TTAG_slnt  FT_MAKE_TAG( 's', 'l', 'n', 't' )
+
+
+  FT_LOCAL( FT_Error )
+  TT_Set_MM_Blend( TT_Face    face,
+                   FT_UInt    num_coords,
+                   FT_Fixed*  coords );
+
+  FT_LOCAL( FT_Error )
+  TT_Set_Var_Design( TT_Face    face,
+                     FT_UInt    num_coords,
+                     FT_Fixed*  coords );
+
+  FT_LOCAL( FT_Error )
+  TT_Get_MM_Var( TT_Face      face,
+                 FT_MM_Var*  *master );
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_vary_cvt( TT_Face    face,
+                    FT_Stream  stream );
+
+
+  FT_LOCAL( FT_Error )
+  TT_Vary_Get_Glyph_Deltas( TT_Face      face,
+                            FT_UInt      glyph_index,
+                            FT_Vector*  *deltas,
+                            FT_UInt      n_points );
+
+
+  FT_LOCAL( void )
+  tt_done_blend( FT_Memory  memory,
+                 GX_Blend   blend );
+
+
+FT_END_HEADER
+
+
+#endif /* __TTGXVAR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttinterp.c b/nx-X11/extras/freetype2/src/truetype/ttinterp.c
new file mode 100644
index 000000000..889ebbf4f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttinterp.c
@@ -0,0 +1,7742 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttinterp.c                                                             */
+/*                                                                         */
+/*    TrueType bytecode interpreter (body).                                */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_CALC_H
+#include FT_TRIGONOMETRY_H
+#include FT_SYSTEM_H
+
+#include "ttinterp.h"
+
+#include "tterrors.h"
+
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+
+#define TT_MULFIX           FT_MulFix
+#define TT_MULDIV           FT_MulDiv
+#define TT_MULDIV_NO_ROUND  FT_MulDiv_No_Round
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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_ttinterp
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* In order to detect infinite loops in the code, we set up a counter    */
+  /* within the run loop.  A single stroke of interpretation is now        */
+  /* limitet to a maximal number of opcodes defined below.                 */
+  /*                                                                       */
+#define MAX_RUNNABLE_OPCODES  1000000L
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* There are two kinds of implementations:                               */
+  /*                                                                       */
+  /* a. static implementation                                              */
+  /*                                                                       */
+  /*    The current execution context is a static variable, which fields   */
+  /*    are accessed directly by the interpreter during execution.  The    */
+  /*    context is named `cur'.                                            */
+  /*                                                                       */
+  /*    This version is non-reentrant, of course.                          */
+  /*                                                                       */
+  /* b. indirect implementation                                            */
+  /*                                                                       */
+  /*    The current execution context is passed to _each_ function as its  */
+  /*    first argument, and each field is thus accessed indirectly.        */
+  /*                                                                       */
+  /*    This version is fully re-entrant.                                  */
+  /*                                                                       */
+  /* The idea is that an indirect implementation may be slower to execute  */
+  /* on low-end processors that are used in some systems (like 386s or     */
+  /* even 486s).                                                           */
+  /*                                                                       */
+  /* As a consequence, the indirect implementation is now the default, as  */
+  /* its performance costs can be considered negligible in our context.    */
+  /* Note, however, that we kept the same source with macros because:      */
+  /*                                                                       */
+  /* - The code is kept very close in design to the Pascal code used for   */
+  /*   development.                                                        */
+  /*                                                                       */
+  /* - It's much more readable that way!                                   */
+  /*                                                                       */
+  /* - It's still open to experimentation and tuning.                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef TT_CONFIG_OPTION_STATIC_INTERPRETER     /* indirect implementation */
+
+#define CUR  (*exc)                             /* see ttobjs.h */
+
+#else                                           /* static implementation */
+
+#define CUR  cur
+
+  static
+  TT_ExecContextRec  cur;   /* static exec. context variable */
+
+  /* apparently, we have a _lot_ of direct indexing when accessing  */
+  /* the static `cur', which makes the code bigger (due to all the  */
+  /* four bytes addresses).                                         */
+
+#endif /* TT_CONFIG_OPTION_STATIC_INTERPRETER */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The instruction argument stack.                                       */
+  /*                                                                       */
+#define INS_ARG  EXEC_OP_ FT_Long*  args    /* see ttobjs.h for EXEC_OP_ */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This macro is used whenever `exec' is unused in a function, to avoid  */
+  /* stupid warnings from pedantic compilers.                              */
+  /*                                                                       */
+#define FT_UNUSED_EXEC  FT_UNUSED( CUR )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This macro is used whenever `args' is unused in a function, to avoid  */
+  /* stupid warnings from pedantic compilers.                              */
+  /*                                                                       */
+#define FT_UNUSED_ARG  FT_UNUSED_EXEC; FT_UNUSED( args )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The following macros hide the use of EXEC_ARG and EXEC_ARG_ to        */
+  /* increase readabilty of the code.                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define SKIP_Code() \
+          SkipCode( EXEC_ARG )
+
+#define GET_ShortIns() \
+          GetShortIns( EXEC_ARG )
+
+#define NORMalize( x, y, v ) \
+          Normalize( EXEC_ARG_ x, y, v )
+
+#define SET_SuperRound( scale, flags ) \
+          SetSuperRound( EXEC_ARG_ scale, flags )
+
+#define ROUND_None( d, c ) \
+          Round_None( EXEC_ARG_ d, c )
+
+#define INS_Goto_CodeRange( range, ip ) \
+          Ins_Goto_CodeRange( EXEC_ARG_ range, ip )
+
+#define CUR_Func_project( x, y ) \
+          CUR.func_project( EXEC_ARG_ x, y )
+
+#define CUR_Func_move( z, p, d ) \
+          CUR.func_move( EXEC_ARG_ z, p, d )
+
+#define CUR_Func_move_orig( z, p, d ) \
+          CUR.func_move_orig( EXEC_ARG_ z, p, d )
+
+#define CUR_Func_dualproj( x, y ) \
+          CUR.func_dualproj( EXEC_ARG_ x, y )
+
+#define CUR_Func_round( d, c ) \
+          CUR.func_round( EXEC_ARG_ d, c )
+
+#define CUR_Func_read_cvt( index ) \
+          CUR.func_read_cvt( EXEC_ARG_ index )
+
+#define CUR_Func_write_cvt( index, val ) \
+          CUR.func_write_cvt( EXEC_ARG_ index, val )
+
+#define CUR_Func_move_cvt( index, val ) \
+          CUR.func_move_cvt( EXEC_ARG_ index, val )
+
+#define CURRENT_Ratio() \
+          Current_Ratio( EXEC_ARG )
+
+#define CURRENT_Ppem() \
+          Current_Ppem( EXEC_ARG )
+
+#define CUR_Ppem() \
+          Cur_PPEM( EXEC_ARG )
+
+#define INS_SxVTL( a, b, c, d ) \
+          Ins_SxVTL( EXEC_ARG_ a, b, c, d )
+
+#define COMPUTE_Funcs() \
+          Compute_Funcs( EXEC_ARG )
+
+#define COMPUTE_Round( a ) \
+          Compute_Round( EXEC_ARG_ a )
+
+#define COMPUTE_Point_Displacement( a, b, c, d ) \
+          Compute_Point_Displacement( EXEC_ARG_ a, b, c, d )
+
+#define MOVE_Zp2_Point( a, b, c, t ) \
+          Move_Zp2_Point( EXEC_ARG_ a, b, c, t )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Instruction dispatch function, as used by the interpreter.            */
+  /*                                                                       */
+  typedef void  (*TInstruction_Function)( INS_ARG );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A simple bounds-checking macro.                                       */
+  /*                                                                       */
+#define BOUNDS( x, n )  ( (FT_UInt)(x) >= (FT_UInt)(n) )
+
+#undef  SUCCESS
+#define SUCCESS  0
+
+#undef  FAILURE
+#define FAILURE  1
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+#define GUESS_VECTOR( V )                                         \
+  if ( CUR.face->unpatented_hinting )                             \
+  {                                                               \
+    CUR.GS.V.x = (FT_F2Dot14)( CUR.GS.both_x_axis ? 0x4000 : 0 ); \
+    CUR.GS.V.y = (FT_F2Dot14)( CUR.GS.both_x_axis ? 0 : 0x4000 ); \
+  }
+#else
+#define GUESS_VECTOR( V )
+#endif
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                        CODERANGE FUNCTIONS                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Goto_CodeRange                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Switches to a new code range (updates the code related elements in */
+  /*    `exec', and `IP').                                                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    range :: The new execution code range.                             */
+  /*                                                                       */
+  /*    IP    :: The new IP in the new code range.                         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    exec  :: The target execution context.                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Goto_CodeRange( TT_ExecContext  exec,
+                     FT_Int          range,
+                     FT_Long         IP )
+  {
+    TT_CodeRange*  coderange;
+
+
+    FT_ASSERT( range >= 1 && range <= 3 );
+
+    coderange = &exec->codeRangeTable[range - 1];
+
+    FT_ASSERT( coderange->base != NULL );
+
+    /* NOTE: Because the last instruction of a program may be a CALL */
+    /*       which will return to the first byte *after* the code    */
+    /*       range, we test for IP <= Size instead of IP < Size.     */
+    /*                                                               */
+    FT_ASSERT( (FT_ULong)IP <= coderange->size );
+
+    exec->code     = coderange->base;
+    exec->codeSize = coderange->size;
+    exec->IP       = IP;
+    exec->curRange = range;
+
+    return TT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Set_CodeRange                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Sets a code range.                                                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    range  :: The code range index.                                    */
+  /*                                                                       */
+  /*    base   :: The new code base.                                       */
+  /*                                                                       */
+  /*    length :: The range size in bytes.                                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    exec   :: The target execution context.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Set_CodeRange( TT_ExecContext  exec,
+                    FT_Int          range,
+                    void*           base,
+                    FT_Long         length )
+  {
+    FT_ASSERT( range >= 1 && range <= 3 );
+
+    exec->codeRangeTable[range - 1].base = (FT_Byte*)base;
+    exec->codeRangeTable[range - 1].size = length;
+
+    return TT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Clear_CodeRange                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Clears a code range.                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    range :: The code range index.                                     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    exec  :: The target execution context.                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Does not set the Error variable.                                   */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Clear_CodeRange( TT_ExecContext  exec,
+                      FT_Int          range )
+  {
+    FT_ASSERT( range >= 1 && range <= 3 );
+
+    exec->codeRangeTable[range - 1].base = NULL;
+    exec->codeRangeTable[range - 1].size = 0;
+
+    return TT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                   EXECUTION CONTEXT ROUTINES                          */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Destroy_Context                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a given context.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    exec   :: A handle to the target execution context.                */
+  /*                                                                       */
+  /*    memory :: A handle to the parent memory object.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only the glyph loader and debugger should call this function.      */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Destroy_Context( TT_ExecContext  exec,
+                      FT_Memory       memory )
+  {
+    /* free composite load stack */
+    FT_FREE( exec->loadStack );
+    exec->loadSize = 0;
+
+    /* points zone */
+    exec->maxPoints   = 0;
+    exec->maxContours = 0;
+
+    /* free stack */
+    FT_FREE( exec->stack );
+    exec->stackSize = 0;
+
+    /* free call stack */
+    FT_FREE( exec->callStack );
+    exec->callSize = 0;
+    exec->callTop  = 0;
+
+    /* free glyph code range */
+    FT_FREE( exec->glyphIns );
+    exec->glyphSize = 0;
+
+    exec->size = NULL;
+    exec->face = NULL;
+
+    FT_FREE( exec );
+    return TT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Init_Context                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a context object.                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory :: A handle to the parent memory object.                    */
+  /*                                                                       */
+  /*    face   :: A handle to the source TrueType face object.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    exec   :: A handle to the target execution context.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Init_Context( TT_ExecContext  exec,
+                TT_Face         face,
+                FT_Memory       memory )
+  {
+    FT_Error  error;
+
+
+    FT_TRACE1(( "Init_Context: new object at 0x%08p, parent = 0x%08p\n",
+                exec, face ));
+
+    exec->memory   = memory;
+    exec->callSize = 32;
+
+    if ( FT_NEW_ARRAY( exec->callStack, exec->callSize ) )
+      goto Fail_Memory;
+
+    /* all values in the context are set to 0 already, but this is */
+    /* here as a remainder                                         */
+    exec->maxPoints   = 0;
+    exec->maxContours = 0;
+
+    exec->stackSize = 0;
+    exec->loadSize  = 0;
+    exec->glyphSize = 0;
+
+    exec->stack     = NULL;
+    exec->loadStack = NULL;
+    exec->glyphIns  = NULL;
+
+    exec->face = face;
+    exec->size = NULL;
+
+    return TT_Err_Ok;
+
+  Fail_Memory:
+    FT_ERROR(( "Init_Context: not enough memory for 0x%08lx\n",
+               (FT_Long)exec ));
+    TT_Destroy_Context( exec, memory );
+
+    return error;
+ }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Update_Max                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Checks the size of a buffer and reallocates it if necessary.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory     :: A handle to the parent memory object.                */
+  /*                                                                       */
+  /*    multiplier :: The size in bytes of each element in the buffer.     */
+  /*                                                                       */
+  /*    new_max    :: The new capacity (size) of the buffer.               */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    size       :: The address of the buffer's current size expressed   */
+  /*                  in elements.                                         */
+  /*                                                                       */
+  /*    buff       :: The address of the buffer base pointer.              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Update_Max( FT_Memory  memory,
+              FT_ULong*  size,
+              FT_Long    multiplier,
+              void**     buff,
+              FT_ULong   new_max )
+  {
+    FT_Error  error;
+
+
+    if ( *size < new_max )
+    {
+      if ( FT_REALLOC( *buff, *size, new_max * multiplier ) )
+        return error;
+      *size = new_max;
+    }
+
+    return TT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Load_Context                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Prepare an execution context for glyph hinting.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source face object.                        */
+  /*                                                                       */
+  /*    size :: A handle to the source size object.                        */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    exec :: A handle to the target execution context.                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only the glyph loader and debugger should call this function.      */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Load_Context( TT_ExecContext  exec,
+                   TT_Face         face,
+                   TT_Size         size )
+  {
+    FT_Int          i;
+    FT_ULong        tmp;
+    TT_MaxProfile*  maxp;
+    FT_Error        error;
+
+
+    exec->face = face;
+    maxp       = &face->max_profile;
+    exec->size = size;
+
+    if ( size )
+    {
+      exec->numFDefs   = size->num_function_defs;
+      exec->maxFDefs   = size->max_function_defs;
+      exec->numIDefs   = size->num_instruction_defs;
+      exec->maxIDefs   = size->max_instruction_defs;
+      exec->FDefs      = size->function_defs;
+      exec->IDefs      = size->instruction_defs;
+      exec->tt_metrics = size->ttmetrics;
+      exec->metrics    = size->metrics;
+
+      exec->maxFunc    = size->max_func;
+      exec->maxIns     = size->max_ins;
+
+      for ( i = 0; i < TT_MAX_CODE_RANGES; i++ )
+        exec->codeRangeTable[i] = size->codeRangeTable[i];
+
+      /* set graphics state */
+      exec->GS = size->GS;
+
+      exec->cvtSize = size->cvt_size;
+      exec->cvt     = size->cvt;
+
+      exec->storeSize = size->storage_size;
+      exec->storage   = size->storage;
+
+      exec->twilight  = size->twilight;
+    }
+
+    error = Update_Max( exec->memory,
+                        &exec->loadSize,
+                        sizeof ( TT_SubGlyphRec ),
+                        (void**)&exec->loadStack,
+                        exec->face->max_components + 1 );
+    if ( error )
+      return error;
+
+    /* XXX: We reserve a little more elements on the stack to deal safely */
+    /*      with broken fonts like arialbs, courbs, timesbs, etc.         */
+    tmp = exec->stackSize;
+    error = Update_Max( exec->memory,
+                        &tmp,
+                        sizeof ( FT_F26Dot6 ),
+                        (void**)&exec->stack,
+                        maxp->maxStackElements + 32 );
+    exec->stackSize = (FT_UInt)tmp;
+    if ( error )
+      return error;
+
+    tmp = exec->glyphSize;
+    error = Update_Max( exec->memory,
+                        &tmp,
+                        sizeof ( FT_Byte ),
+                        (void**)&exec->glyphIns,
+                        maxp->maxSizeOfInstructions );
+    exec->glyphSize = (FT_UShort)tmp;
+    if ( error )
+      return error;
+
+    exec->pts.n_points   = 0;
+    exec->pts.n_contours = 0;
+
+    exec->instruction_trap = FALSE;
+
+    return TT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Save_Context                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Saves the code ranges in a `size' object.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    exec :: A handle to the source execution context.                  */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    size :: A handle to the target size object.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only the glyph loader and debugger should call this function.      */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Save_Context( TT_ExecContext  exec,
+                   TT_Size         size )
+  {
+    FT_Int  i;
+
+
+    /* XXXX: Will probably disappear soon with all the code range */
+    /*       management, which is now rather obsolete.            */
+    /*                                                            */
+    size->num_function_defs    = exec->numFDefs;
+    size->num_instruction_defs = exec->numIDefs;
+
+    size->max_func = exec->maxFunc;
+    size->max_ins  = exec->maxIns;
+
+    for ( i = 0; i < TT_MAX_CODE_RANGES; i++ )
+      size->codeRangeTable[i] = exec->codeRangeTable[i];
+
+    return TT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Run_Context                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Executes one or more instructions in the execution context.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    debug :: A Boolean flag.  If set, the function sets some internal  */
+  /*             variables and returns immediately, otherwise TT_RunIns()  */
+  /*             is called.                                                */
+  /*                                                                       */
+  /*             This is commented out currently.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    exec  :: A handle to the target execution context.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    TrueTyoe error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only the glyph loader and debugger should call this function.      */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Run_Context( TT_ExecContext  exec,
+                  FT_Bool         debug )
+  {
+    FT_Error  error;
+
+
+    if ( ( error = TT_Goto_CodeRange( exec, tt_coderange_glyph, 0  ) )
+           != TT_Err_Ok )
+      return error;
+
+    exec->zp0 = exec->pts;
+    exec->zp1 = exec->pts;
+    exec->zp2 = exec->pts;
+
+    exec->GS.gep0 = 1;
+    exec->GS.gep1 = 1;
+    exec->GS.gep2 = 1;
+
+    exec->GS.projVector.x = 0x4000;
+    exec->GS.projVector.y = 0x0000;
+
+    exec->GS.freeVector = exec->GS.projVector;
+    exec->GS.dualVector = exec->GS.projVector;
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    exec->GS.both_x_axis = TRUE;
+#endif
+
+    exec->GS.round_state = 1;
+    exec->GS.loop        = 1;
+
+    /* some glyphs leave something on the stack. so we clean it */
+    /* before a new execution.                                  */
+    exec->top     = 0;
+    exec->callTop = 0;
+
+#if 1
+    FT_UNUSED( debug );
+
+    return exec->face->interpreter( exec );
+#else
+    if ( !debug )
+      return TT_RunIns( exec );
+    else
+      return TT_Err_Ok;
+#endif
+  }
+
+
+  const TT_GraphicsState  tt_default_graphics_state =
+  {
+    0, 0, 0,
+    { 0x4000, 0 },
+    { 0x4000, 0 },
+    { 0x4000, 0 },
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    TRUE,
+#endif
+
+    1, 64, 1,
+    TRUE, 68, 0, 0, 9, 3,
+    0, FALSE, 2, 1, 1, 1
+  };
+
+
+  /* documentation is in ttinterp.h */
+
+  FT_EXPORT_DEF( TT_ExecContext )
+  TT_New_Context( TT_Face  face )
+  {
+    TT_Driver       driver;
+    TT_ExecContext  exec;
+    FT_Memory       memory;
+
+
+    if ( !face )
+      return 0;
+
+    driver = (TT_Driver)face->root.driver;
+
+    memory = driver->root.root.memory;
+    exec   = driver->context;
+
+    if ( !driver->context )
+    {
+      FT_Error  error;
+
+
+      /* allocate object */
+      if ( FT_NEW( exec ) )
+        goto Exit;
+
+      /* initialize it */
+      error = Init_Context( exec, face, memory );
+      if ( error )
+        goto Fail;
+
+      /* store it into the driver */
+      driver->context = exec;
+    }
+
+  Exit:
+    return driver->context;
+
+  Fail:
+    FT_FREE( exec );
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_Done_Context                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discards an execution context.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    exec :: A handle to the target execution context.                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only the glyph loader and debugger should call this function.      */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Done_Context( TT_ExecContext  exec )
+  {
+    /* Nothing at all for now */
+    FT_UNUSED( exec );
+
+    return TT_Err_Ok;
+  }
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Before an opcode is executed, the interpreter verifies that there are */
+  /* enough arguments on the stack, with the help of the Pop_Push_Count    */
+  /* table.                                                                */
+  /*                                                                       */
+  /* For each opcode, the first column gives the number of arguments that  */
+  /* are popped from the stack; the second one gives the number of those   */
+  /* that are pushed in result.                                            */
+  /*                                                                       */
+  /* Note that for opcodes with a varying number of parameters, either 0   */
+  /* or 1 arg is verified before execution, depending on the nature of the */
+  /* instruction:                                                          */
+  /*                                                                       */
+  /* - if the number of arguments is given by the bytecode stream or the   */
+  /*   loop variable, 0 is chosen.                                         */
+  /*                                                                       */
+  /* - if the first argument is a count n that is followed by arguments    */
+  /*   a1 .. an, then 1 is chosen.                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#undef  PACK
+#define PACK( x, y )  ( ( x << 4 ) | y )
+
+
+  static
+  const FT_Byte  Pop_Push_Count[256] =
+  {
+    /* opcodes are gathered in groups of 16 */
+    /* please keep the spaces as they are   */
+
+    /*  SVTCA  y  */  PACK( 0, 0 ),
+    /*  SVTCA  x  */  PACK( 0, 0 ),
+    /*  SPvTCA y  */  PACK( 0, 0 ),
+    /*  SPvTCA x  */  PACK( 0, 0 ),
+    /*  SFvTCA y  */  PACK( 0, 0 ),
+    /*  SFvTCA x  */  PACK( 0, 0 ),
+    /*  SPvTL //  */  PACK( 2, 0 ),
+    /*  SPvTL +   */  PACK( 2, 0 ),
+    /*  SFvTL //  */  PACK( 2, 0 ),
+    /*  SFvTL +   */  PACK( 2, 0 ),
+    /*  SPvFS     */  PACK( 2, 0 ),
+    /*  SFvFS     */  PACK( 2, 0 ),
+    /*  GPV       */  PACK( 0, 2 ),
+    /*  GFV       */  PACK( 0, 2 ),
+    /*  SFvTPv    */  PACK( 0, 0 ),
+    /*  ISECT     */  PACK( 5, 0 ),
+
+    /*  SRP0      */  PACK( 1, 0 ),
+    /*  SRP1      */  PACK( 1, 0 ),
+    /*  SRP2      */  PACK( 1, 0 ),
+    /*  SZP0      */  PACK( 1, 0 ),
+    /*  SZP1      */  PACK( 1, 0 ),
+    /*  SZP2      */  PACK( 1, 0 ),
+    /*  SZPS      */  PACK( 1, 0 ),
+    /*  SLOOP     */  PACK( 1, 0 ),
+    /*  RTG       */  PACK( 0, 0 ),
+    /*  RTHG      */  PACK( 0, 0 ),
+    /*  SMD       */  PACK( 1, 0 ),
+    /*  ELSE      */  PACK( 0, 0 ),
+    /*  JMPR      */  PACK( 1, 0 ),
+    /*  SCvTCi    */  PACK( 1, 0 ),
+    /*  SSwCi     */  PACK( 1, 0 ),
+    /*  SSW       */  PACK( 1, 0 ),
+
+    /*  DUP       */  PACK( 1, 2 ),
+    /*  POP       */  PACK( 1, 0 ),
+    /*  CLEAR     */  PACK( 0, 0 ),
+    /*  SWAP      */  PACK( 2, 2 ),
+    /*  DEPTH     */  PACK( 0, 1 ),
+    /*  CINDEX    */  PACK( 1, 1 ),
+    /*  MINDEX    */  PACK( 1, 0 ),
+    /*  AlignPTS  */  PACK( 2, 0 ),
+    /*  INS_$28   */  PACK( 0, 0 ),
+    /*  UTP       */  PACK( 1, 0 ),
+    /*  LOOPCALL  */  PACK( 2, 0 ),
+    /*  CALL      */  PACK( 1, 0 ),
+    /*  FDEF      */  PACK( 1, 0 ),
+    /*  ENDF      */  PACK( 0, 0 ),
+    /*  MDAP[0]   */  PACK( 1, 0 ),
+    /*  MDAP[1]   */  PACK( 1, 0 ),
+
+    /*  IUP[0]    */  PACK( 0, 0 ),
+    /*  IUP[1]    */  PACK( 0, 0 ),
+    /*  SHP[0]    */  PACK( 0, 0 ),
+    /*  SHP[1]    */  PACK( 0, 0 ),
+    /*  SHC[0]    */  PACK( 1, 0 ),
+    /*  SHC[1]    */  PACK( 1, 0 ),
+    /*  SHZ[0]    */  PACK( 1, 0 ),
+    /*  SHZ[1]    */  PACK( 1, 0 ),
+    /*  SHPIX     */  PACK( 1, 0 ),
+    /*  IP        */  PACK( 0, 0 ),
+    /*  MSIRP[0]  */  PACK( 2, 0 ),
+    /*  MSIRP[1]  */  PACK( 2, 0 ),
+    /*  AlignRP   */  PACK( 0, 0 ),
+    /*  RTDG      */  PACK( 0, 0 ),
+    /*  MIAP[0]   */  PACK( 2, 0 ),
+    /*  MIAP[1]   */  PACK( 2, 0 ),
+
+    /*  NPushB    */  PACK( 0, 0 ),
+    /*  NPushW    */  PACK( 0, 0 ),
+    /*  WS        */  PACK( 2, 0 ),
+    /*  RS        */  PACK( 1, 1 ),
+    /*  WCvtP     */  PACK( 2, 0 ),
+    /*  RCvt      */  PACK( 1, 1 ),
+    /*  GC[0]     */  PACK( 1, 1 ),
+    /*  GC[1]     */  PACK( 1, 1 ),
+    /*  SCFS      */  PACK( 2, 0 ),
+    /*  MD[0]     */  PACK( 2, 1 ),
+    /*  MD[1]     */  PACK( 2, 1 ),
+    /*  MPPEM     */  PACK( 0, 1 ),
+    /*  MPS       */  PACK( 0, 1 ),
+    /*  FlipON    */  PACK( 0, 0 ),
+    /*  FlipOFF   */  PACK( 0, 0 ),
+    /*  DEBUG     */  PACK( 1, 0 ),
+
+    /*  LT        */  PACK( 2, 1 ),
+    /*  LTEQ      */  PACK( 2, 1 ),
+    /*  GT        */  PACK( 2, 1 ),
+    /*  GTEQ      */  PACK( 2, 1 ),
+    /*  EQ        */  PACK( 2, 1 ),
+    /*  NEQ       */  PACK( 2, 1 ),
+    /*  ODD       */  PACK( 1, 1 ),
+    /*  EVEN      */  PACK( 1, 1 ),
+    /*  IF        */  PACK( 1, 0 ),
+    /*  EIF       */  PACK( 0, 0 ),
+    /*  AND       */  PACK( 2, 1 ),
+    /*  OR        */  PACK( 2, 1 ),
+    /*  NOT       */  PACK( 1, 1 ),
+    /*  DeltaP1   */  PACK( 1, 0 ),
+    /*  SDB       */  PACK( 1, 0 ),
+    /*  SDS       */  PACK( 1, 0 ),
+
+    /*  ADD       */  PACK( 2, 1 ),
+    /*  SUB       */  PACK( 2, 1 ),
+    /*  DIV       */  PACK( 2, 1 ),
+    /*  MUL       */  PACK( 2, 1 ),
+    /*  ABS       */  PACK( 1, 1 ),
+    /*  NEG       */  PACK( 1, 1 ),
+    /*  FLOOR     */  PACK( 1, 1 ),
+    /*  CEILING   */  PACK( 1, 1 ),
+    /*  ROUND[0]  */  PACK( 1, 1 ),
+    /*  ROUND[1]  */  PACK( 1, 1 ),
+    /*  ROUND[2]  */  PACK( 1, 1 ),
+    /*  ROUND[3]  */  PACK( 1, 1 ),
+    /*  NROUND[0] */  PACK( 1, 1 ),
+    /*  NROUND[1] */  PACK( 1, 1 ),
+    /*  NROUND[2] */  PACK( 1, 1 ),
+    /*  NROUND[3] */  PACK( 1, 1 ),
+
+    /*  WCvtF     */  PACK( 2, 0 ),
+    /*  DeltaP2   */  PACK( 1, 0 ),
+    /*  DeltaP3   */  PACK( 1, 0 ),
+    /*  DeltaCn[0] */ PACK( 1, 0 ),
+    /*  DeltaCn[1] */ PACK( 1, 0 ),
+    /*  DeltaCn[2] */ PACK( 1, 0 ),
+    /*  SROUND    */  PACK( 1, 0 ),
+    /*  S45Round  */  PACK( 1, 0 ),
+    /*  JROT      */  PACK( 2, 0 ),
+    /*  JROF      */  PACK( 2, 0 ),
+    /*  ROFF      */  PACK( 0, 0 ),
+    /*  INS_$7B   */  PACK( 0, 0 ),
+    /*  RUTG      */  PACK( 0, 0 ),
+    /*  RDTG      */  PACK( 0, 0 ),
+    /*  SANGW     */  PACK( 1, 0 ),
+    /*  AA        */  PACK( 1, 0 ),
+
+    /*  FlipPT    */  PACK( 0, 0 ),
+    /*  FlipRgON  */  PACK( 2, 0 ),
+    /*  FlipRgOFF */  PACK( 2, 0 ),
+    /*  INS_$83   */  PACK( 0, 0 ),
+    /*  INS_$84   */  PACK( 0, 0 ),
+    /*  ScanCTRL  */  PACK( 1, 0 ),
+    /*  SDVPTL[0] */  PACK( 2, 0 ),
+    /*  SDVPTL[1] */  PACK( 2, 0 ),
+    /*  GetINFO   */  PACK( 1, 1 ),
+    /*  IDEF      */  PACK( 1, 0 ),
+    /*  ROLL      */  PACK( 3, 3 ),
+    /*  MAX       */  PACK( 2, 1 ),
+    /*  MIN       */  PACK( 2, 1 ),
+    /*  ScanTYPE  */  PACK( 1, 0 ),
+    /*  InstCTRL  */  PACK( 2, 0 ),
+    /*  INS_$8F   */  PACK( 0, 0 ),
+
+    /*  INS_$90  */   PACK( 0, 0 ),
+    /*  INS_$91  */   PACK( 0, 0 ),
+    /*  INS_$92  */   PACK( 0, 0 ),
+    /*  INS_$93  */   PACK( 0, 0 ),
+    /*  INS_$94  */   PACK( 0, 0 ),
+    /*  INS_$95  */   PACK( 0, 0 ),
+    /*  INS_$96  */   PACK( 0, 0 ),
+    /*  INS_$97  */   PACK( 0, 0 ),
+    /*  INS_$98  */   PACK( 0, 0 ),
+    /*  INS_$99  */   PACK( 0, 0 ),
+    /*  INS_$9A  */   PACK( 0, 0 ),
+    /*  INS_$9B  */   PACK( 0, 0 ),
+    /*  INS_$9C  */   PACK( 0, 0 ),
+    /*  INS_$9D  */   PACK( 0, 0 ),
+    /*  INS_$9E  */   PACK( 0, 0 ),
+    /*  INS_$9F  */   PACK( 0, 0 ),
+
+    /*  INS_$A0  */   PACK( 0, 0 ),
+    /*  INS_$A1  */   PACK( 0, 0 ),
+    /*  INS_$A2  */   PACK( 0, 0 ),
+    /*  INS_$A3  */   PACK( 0, 0 ),
+    /*  INS_$A4  */   PACK( 0, 0 ),
+    /*  INS_$A5  */   PACK( 0, 0 ),
+    /*  INS_$A6  */   PACK( 0, 0 ),
+    /*  INS_$A7  */   PACK( 0, 0 ),
+    /*  INS_$A8  */   PACK( 0, 0 ),
+    /*  INS_$A9  */   PACK( 0, 0 ),
+    /*  INS_$AA  */   PACK( 0, 0 ),
+    /*  INS_$AB  */   PACK( 0, 0 ),
+    /*  INS_$AC  */   PACK( 0, 0 ),
+    /*  INS_$AD  */   PACK( 0, 0 ),
+    /*  INS_$AE  */   PACK( 0, 0 ),
+    /*  INS_$AF  */   PACK( 0, 0 ),
+
+    /*  PushB[0]  */  PACK( 0, 1 ),
+    /*  PushB[1]  */  PACK( 0, 2 ),
+    /*  PushB[2]  */  PACK( 0, 3 ),
+    /*  PushB[3]  */  PACK( 0, 4 ),
+    /*  PushB[4]  */  PACK( 0, 5 ),
+    /*  PushB[5]  */  PACK( 0, 6 ),
+    /*  PushB[6]  */  PACK( 0, 7 ),
+    /*  PushB[7]  */  PACK( 0, 8 ),
+    /*  PushW[0]  */  PACK( 0, 1 ),
+    /*  PushW[1]  */  PACK( 0, 2 ),
+    /*  PushW[2]  */  PACK( 0, 3 ),
+    /*  PushW[3]  */  PACK( 0, 4 ),
+    /*  PushW[4]  */  PACK( 0, 5 ),
+    /*  PushW[5]  */  PACK( 0, 6 ),
+    /*  PushW[6]  */  PACK( 0, 7 ),
+    /*  PushW[7]  */  PACK( 0, 8 ),
+
+    /*  MDRP[00]  */  PACK( 1, 0 ),
+    /*  MDRP[01]  */  PACK( 1, 0 ),
+    /*  MDRP[02]  */  PACK( 1, 0 ),
+    /*  MDRP[03]  */  PACK( 1, 0 ),
+    /*  MDRP[04]  */  PACK( 1, 0 ),
+    /*  MDRP[05]  */  PACK( 1, 0 ),
+    /*  MDRP[06]  */  PACK( 1, 0 ),
+    /*  MDRP[07]  */  PACK( 1, 0 ),
+    /*  MDRP[08]  */  PACK( 1, 0 ),
+    /*  MDRP[09]  */  PACK( 1, 0 ),
+    /*  MDRP[10]  */  PACK( 1, 0 ),
+    /*  MDRP[11]  */  PACK( 1, 0 ),
+    /*  MDRP[12]  */  PACK( 1, 0 ),
+    /*  MDRP[13]  */  PACK( 1, 0 ),
+    /*  MDRP[14]  */  PACK( 1, 0 ),
+    /*  MDRP[15]  */  PACK( 1, 0 ),
+
+    /*  MDRP[16]  */  PACK( 1, 0 ),
+    /*  MDRP[17]  */  PACK( 1, 0 ),
+    /*  MDRP[18]  */  PACK( 1, 0 ),
+    /*  MDRP[19]  */  PACK( 1, 0 ),
+    /*  MDRP[20]  */  PACK( 1, 0 ),
+    /*  MDRP[21]  */  PACK( 1, 0 ),
+    /*  MDRP[22]  */  PACK( 1, 0 ),
+    /*  MDRP[23]  */  PACK( 1, 0 ),
+    /*  MDRP[24]  */  PACK( 1, 0 ),
+    /*  MDRP[25]  */  PACK( 1, 0 ),
+    /*  MDRP[26]  */  PACK( 1, 0 ),
+    /*  MDRP[27]  */  PACK( 1, 0 ),
+    /*  MDRP[28]  */  PACK( 1, 0 ),
+    /*  MDRP[29]  */  PACK( 1, 0 ),
+    /*  MDRP[30]  */  PACK( 1, 0 ),
+    /*  MDRP[31]  */  PACK( 1, 0 ),
+
+    /*  MIRP[00]  */  PACK( 2, 0 ),
+    /*  MIRP[01]  */  PACK( 2, 0 ),
+    /*  MIRP[02]  */  PACK( 2, 0 ),
+    /*  MIRP[03]  */  PACK( 2, 0 ),
+    /*  MIRP[04]  */  PACK( 2, 0 ),
+    /*  MIRP[05]  */  PACK( 2, 0 ),
+    /*  MIRP[06]  */  PACK( 2, 0 ),
+    /*  MIRP[07]  */  PACK( 2, 0 ),
+    /*  MIRP[08]  */  PACK( 2, 0 ),
+    /*  MIRP[09]  */  PACK( 2, 0 ),
+    /*  MIRP[10]  */  PACK( 2, 0 ),
+    /*  MIRP[11]  */  PACK( 2, 0 ),
+    /*  MIRP[12]  */  PACK( 2, 0 ),
+    /*  MIRP[13]  */  PACK( 2, 0 ),
+    /*  MIRP[14]  */  PACK( 2, 0 ),
+    /*  MIRP[15]  */  PACK( 2, 0 ),
+
+    /*  MIRP[16]  */  PACK( 2, 0 ),
+    /*  MIRP[17]  */  PACK( 2, 0 ),
+    /*  MIRP[18]  */  PACK( 2, 0 ),
+    /*  MIRP[19]  */  PACK( 2, 0 ),
+    /*  MIRP[20]  */  PACK( 2, 0 ),
+    /*  MIRP[21]  */  PACK( 2, 0 ),
+    /*  MIRP[22]  */  PACK( 2, 0 ),
+    /*  MIRP[23]  */  PACK( 2, 0 ),
+    /*  MIRP[24]  */  PACK( 2, 0 ),
+    /*  MIRP[25]  */  PACK( 2, 0 ),
+    /*  MIRP[26]  */  PACK( 2, 0 ),
+    /*  MIRP[27]  */  PACK( 2, 0 ),
+    /*  MIRP[28]  */  PACK( 2, 0 ),
+    /*  MIRP[29]  */  PACK( 2, 0 ),
+    /*  MIRP[30]  */  PACK( 2, 0 ),
+    /*  MIRP[31]  */  PACK( 2, 0 )
+  };
+
+
+  static
+  const FT_Char  opcode_length[256] =
+  {
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+
+   -1,-1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    2, 3, 4, 5,  6, 7, 8, 9,  3, 5, 7, 9, 11,13,15,17,
+
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,
+    1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1
+  };
+
+  static
+  const FT_Vector  Null_Vector = {0,0};
+
+
+#undef PACK
+
+
+#undef  NULL_Vector
+#define NULL_Vector  (FT_Vector*)&Null_Vector
+
+
+  /* compute (a*b)/2^14 with maximal accuracy and rounding */
+  static FT_Int32
+  TT_MulFix14( FT_Int32  a,
+               FT_Int    b )
+  {
+    FT_Int32   m, s, hi;
+    FT_UInt32  l, lo;
+
+
+    /* compute ax*bx as 64-bit value */
+    l  = (FT_UInt32)( ( a & 0xFFFFU ) * b );
+    m  = ( a >> 16 ) * b;
+
+    lo = l + (FT_UInt32)( m << 16 );
+    hi = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo < l );
+
+    /* divide the result by 2^14 with rounding */
+    s   = hi >> 31;
+    l   = lo + (FT_UInt32)s;
+    hi += s + ( l < lo );
+    lo  = l;
+
+    l   = lo + 0x2000U;
+    hi += (l < lo);
+
+    return ( hi << 18 ) | ( l >> 14 );
+  }
+
+
+  /* compute (ax*bx+ay*by)/2^14 with maximal accuracy and rounding */
+  static FT_Int32
+  TT_DotFix14( FT_Int32  ax,
+               FT_Int32  ay,
+               FT_Int    bx,
+               FT_Int    by )
+  {
+    FT_Int32   m, s, hi1, hi2, hi;
+    FT_UInt32  l, lo1, lo2, lo;
+
+
+    /* compute ax*bx as 64-bit value */
+    l = (FT_UInt32)( ( ax & 0xFFFFU ) * bx );
+    m = ( ax >> 16 ) * bx;
+
+    lo1 = l + (FT_UInt32)( m << 16 );
+    hi1 = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo1 < l );
+
+    /* compute ay*by as 64-bit value */
+    l = (FT_UInt32)( ( ay & 0xFFFFU ) * by );
+    m = ( ay >> 16 ) * by;
+
+    lo2 = l + (FT_UInt32)( m << 16 );
+    hi2 = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo2 < l );
+
+    /* add them */
+    lo = lo1 + lo2;
+    hi = hi1 + hi2 + ( lo < lo1 );
+
+    /* divide the result by 2^14 with rounding */
+    s   = hi >> 31;
+    l   = lo + (FT_UInt32)s;
+    hi += s + ( l < lo );
+    lo  = l;
+
+    l   = lo + 0x2000U;
+    hi += ( l < lo );
+
+    return ( hi << 18 ) | ( l >> 14 );
+  }
+
+
+  /* return length of given vector */
+
+#if 0
+
+  static FT_Int32
+  TT_VecLen( FT_Int32  x,
+             FT_Int32  y )
+  {
+    FT_Int32   m, hi1, hi2, hi;
+    FT_UInt32  l, lo1, lo2, lo;
+
+
+    /* compute x*x as 64-bit value */
+    lo = (FT_UInt32)( x & 0xFFFFU );
+    hi = x >> 16;
+
+    l  = lo * lo;
+    m  = hi * lo;
+    hi = hi * hi;
+
+    lo1 = l + (FT_UInt32)( m << 17 );
+    hi1 = hi + ( m >> 15 ) + ( lo1 < l );
+
+    /* compute y*y as 64-bit value */
+    lo = (FT_UInt32)( y & 0xFFFFU );
+    hi = y >> 16;
+
+    l  = lo * lo;
+    m  = hi * lo;
+    hi = hi * hi;
+
+    lo2 = l + (FT_UInt32)( m << 17 );
+    hi2 = hi + ( m >> 15 ) + ( lo2 < l );
+
+    /* add them to get 'x*x+y*y' as 64-bit value */
+    lo = lo1 + lo2;
+    hi = hi1 + hi2 + ( lo < lo1 );
+
+    /* compute the square root of this value */
+    {
+      FT_UInt32  root, rem, test_div;
+      FT_Int     count;
+
+
+      root = 0;
+
+      {
+        rem   = 0;
+        count = 32;
+        do
+        {
+          rem      = ( rem << 2 ) | ( (FT_UInt32)hi >> 30 );
+          hi       = (  hi << 2 ) | (            lo >> 30 );
+          lo     <<= 2;
+          root   <<= 1;
+          test_div = ( root << 1 ) + 1;
+
+          if ( rem >= test_div )
+          {
+            rem  -= test_div;
+            root += 1;
+          }
+        } while ( --count );
+      }
+
+      return (FT_Int32)root;
+    }
+  }
+
+#else
+
+  /* this version uses FT_Vector_Length which computes the same value */
+  /* much, much faster..                                              */
+  /*                                                                  */
+  static FT_F26Dot6
+  TT_VecLen( FT_F26Dot6  X,
+             FT_F26Dot6  Y )
+  {
+    FT_Vector  v;
+
+
+    v.x = X;
+    v.y = Y;
+
+    return FT_Vector_Length( &v );
+  }
+
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Current_Ratio                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns the current aspect ratio scaling factor depending on the   */
+  /*    projection vector's state and device resolutions.                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The aspect ratio in 16.16 format, always <= 1.0 .                  */
+  /*                                                                       */
+  static FT_Long
+  Current_Ratio( EXEC_OP )
+  {
+    if ( !CUR.tt_metrics.ratio )
+    {
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+      if ( CUR.face->unpatented_hinting )
+      {
+        if ( CUR.GS.both_x_axis )
+          CUR.tt_metrics.ratio = CUR.tt_metrics.x_ratio;
+        else
+          CUR.tt_metrics.ratio = CUR.tt_metrics.y_ratio;
+      }
+      else
+#endif
+      {
+        if ( CUR.GS.projVector.y == 0 )
+          CUR.tt_metrics.ratio = CUR.tt_metrics.x_ratio;
+
+        else if ( CUR.GS.projVector.x == 0 )
+          CUR.tt_metrics.ratio = CUR.tt_metrics.y_ratio;
+
+        else
+        {
+          FT_Long  x, y;
+
+
+          x = TT_MULDIV( CUR.GS.projVector.x,
+                         CUR.tt_metrics.x_ratio, 0x4000 );
+          y = TT_MULDIV( CUR.GS.projVector.y,
+                         CUR.tt_metrics.y_ratio, 0x4000 );
+          CUR.tt_metrics.ratio = TT_VecLen( x, y );
+        }
+      }
+    }
+    return CUR.tt_metrics.ratio;
+  }
+
+
+  static FT_Long
+  Current_Ppem( EXEC_OP )
+  {
+    return TT_MULFIX( CUR.tt_metrics.ppem, CURRENT_Ratio() );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Functions related to the control value table (CVT).                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  FT_CALLBACK_DEF( FT_F26Dot6 )
+  Read_CVT( EXEC_OP_ FT_ULong  idx )
+  {
+    return CUR.cvt[idx];
+  }
+
+
+  FT_CALLBACK_DEF( FT_F26Dot6 )
+  Read_CVT_Stretched( EXEC_OP_ FT_ULong  idx )
+  {
+    return TT_MULFIX( CUR.cvt[idx], CURRENT_Ratio() );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  Write_CVT( EXEC_OP_ FT_ULong    idx,
+                      FT_F26Dot6  value )
+  {
+    CUR.cvt[idx] = value;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  Write_CVT_Stretched( EXEC_OP_ FT_ULong    idx,
+                                FT_F26Dot6  value )
+  {
+    CUR.cvt[idx] = FT_DivFix( value, CURRENT_Ratio() );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  Move_CVT( EXEC_OP_ FT_ULong    idx,
+                     FT_F26Dot6  value )
+  {
+    CUR.cvt[idx] += value;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  Move_CVT_Stretched( EXEC_OP_ FT_ULong    idx,
+                               FT_F26Dot6  value )
+  {
+    CUR.cvt[idx] += FT_DivFix( value, CURRENT_Ratio() );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    GetShortIns                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns a short integer taken from the instruction stream at       */
+  /*    address IP.                                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Short read at code[IP].                                            */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This one could become a macro.                                     */
+  /*                                                                       */
+  static FT_Short
+  GetShortIns( EXEC_OP )
+  {
+    /* Reading a byte stream so there is no endianess (DaveP) */
+    CUR.IP += 2;
+    return (FT_Short)( ( CUR.code[CUR.IP - 2] << 8 ) +
+                         CUR.code[CUR.IP - 1]      );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Ins_Goto_CodeRange                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Goes to a certain code range in the instruction stream.            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    aRange :: The index of the code range.                             */
+  /*                                                                       */
+  /*    aIP    :: The new IP address in the code range.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    SUCCESS or FAILURE.                                                */
+  /*                                                                       */
+  static FT_Bool
+  Ins_Goto_CodeRange( EXEC_OP_ FT_Int    aRange,
+                               FT_ULong  aIP )
+  {
+    TT_CodeRange*  range;
+
+
+    if ( aRange < 1 || aRange > 3 )
+    {
+      CUR.error = TT_Err_Bad_Argument;
+      return FAILURE;
+    }
+
+    range = &CUR.codeRangeTable[aRange - 1];
+
+    if ( range->base == NULL )     /* invalid coderange */
+    {
+      CUR.error = TT_Err_Invalid_CodeRange;
+      return FAILURE;
+    }
+
+    /* NOTE: Because the last instruction of a program may be a CALL */
+    /*       which will return to the first byte *after* the code    */
+    /*       range, we test for AIP <= Size, instead of AIP < Size.  */
+
+    if ( aIP > range->size )
+    {
+      CUR.error = TT_Err_Code_Overflow;
+      return FAILURE;
+    }
+
+    CUR.code     = range->base;
+    CUR.codeSize = range->size;
+    CUR.IP       = aIP;
+    CUR.curRange = aRange;
+
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Direct_Move                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Moves a point by a given distance along the freedom vector.  The   */
+  /*    point will be `touched'.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    point    :: The index of the point to move.                        */
+  /*                                                                       */
+  /*    distance :: The distance to apply.                                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    zone     :: The affected glyph zone.                               */
+  /*                                                                       */
+  static void
+  Direct_Move( EXEC_OP_ TT_GlyphZone  zone,
+                        FT_UShort     point,
+                        FT_F26Dot6    distance )
+  {
+    FT_F26Dot6  v;
+
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    FT_ASSERT( !CUR.face->unpatented_hinting );
+#endif
+
+    v = CUR.GS.freeVector.x;
+
+    if ( v != 0 )
+    {
+      zone->cur[point].x += TT_MULDIV( distance,
+                                       v * 0x10000L,
+                                       CUR.F_dot_P );
+
+      zone->tags[point] |= FT_CURVE_TAG_TOUCH_X;
+    }
+
+    v = CUR.GS.freeVector.y;
+
+    if ( v != 0 )
+    {
+      zone->cur[point].y += TT_MULDIV( distance,
+                                       v * 0x10000L,
+                                       CUR.F_dot_P );
+
+      zone->tags[point] |= FT_CURVE_TAG_TOUCH_Y;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Direct_Move_Orig                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Moves the *original* position of a point by a given distance along */
+  /*    the freedom vector.  Obviously, the point will not be `touched'.   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    point    :: The index of the point to move.                        */
+  /*                                                                       */
+  /*    distance :: The distance to apply.                                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    zone     :: The affected glyph zone.                               */
+  /*                                                                       */
+  static void
+  Direct_Move_Orig( EXEC_OP_ TT_GlyphZone  zone,
+                             FT_UShort     point,
+                             FT_F26Dot6    distance )
+  {
+    FT_F26Dot6  v;
+
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    FT_ASSERT( !CUR.face->unpatented_hinting );
+#endif
+
+    v = CUR.GS.freeVector.x;
+
+    if ( v != 0 )
+      zone->org[point].x += TT_MULDIV( distance,
+                                       v * 0x10000L,
+                                       CUR.F_dot_P );
+
+    v = CUR.GS.freeVector.y;
+
+    if ( v != 0 )
+      zone->org[point].y += TT_MULDIV( distance,
+                                       v * 0x10000L,
+                                       CUR.F_dot_P );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Special versions of Direct_Move()                                     */
+  /*                                                                       */
+  /*   The following versions are used whenever both vectors are both      */
+  /*   along one of the coordinate unit vectors, i.e. in 90% of the cases. */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static void
+  Direct_Move_X( EXEC_OP_ TT_GlyphZone  zone,
+                          FT_UShort     point,
+                          FT_F26Dot6    distance )
+  {
+    FT_UNUSED_EXEC;
+
+    zone->cur[point].x += distance;
+    zone->tags[point]  |= FT_CURVE_TAG_TOUCH_X;
+  }
+
+
+  static void
+  Direct_Move_Y( EXEC_OP_ TT_GlyphZone  zone,
+                          FT_UShort     point,
+                          FT_F26Dot6    distance )
+  {
+    FT_UNUSED_EXEC;
+
+    zone->cur[point].y += distance;
+    zone->tags[point]  |= FT_CURVE_TAG_TOUCH_Y;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Special versions of Direct_Move_Orig()                                */
+  /*                                                                       */
+  /*   The following versions are used whenever both vectors are both      */
+  /*   along one of the coordinate unit vectors, i.e. in 90% of the cases. */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static void
+  Direct_Move_Orig_X( EXEC_OP_ TT_GlyphZone  zone,
+                               FT_UShort     point,
+                               FT_F26Dot6    distance )
+  {
+    FT_UNUSED_EXEC;
+
+    zone->org[point].x += distance;
+  }
+
+
+  static void
+  Direct_Move_Orig_Y( EXEC_OP_ TT_GlyphZone  zone,
+                               FT_UShort     point,
+                               FT_F26Dot6    distance )
+  {
+    FT_UNUSED_EXEC;
+
+    zone->org[point].y += distance;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Round_None                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Does not round, but adds engine compensation.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    distance     :: The distance (not) to round.                       */
+  /*                                                                       */
+  /*    compensation :: The engine compensation.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The compensated distance.                                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The TrueType specification says very few about the relationship    */
+  /*    between rounding and engine compensation.  However, it seems from  */
+  /*    the description of super round that we should add the compensation */
+  /*    before rounding.                                                   */
+  /*                                                                       */
+  static FT_F26Dot6
+  Round_None( EXEC_OP_ FT_F26Dot6  distance,
+                       FT_F26Dot6  compensation )
+  {
+    FT_F26Dot6  val;
+
+    FT_UNUSED_EXEC;
+
+
+    if ( distance >= 0 )
+    {
+      val = distance + compensation;
+      if ( distance && val < 0 )
+        val = 0;
+    }
+    else {
+      val = distance - compensation;
+      if ( val > 0 )
+        val = 0;
+    }
+    return val;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Round_To_Grid                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Rounds value to grid after adding engine compensation.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    distance     :: The distance to round.                             */
+  /*                                                                       */
+  /*    compensation :: The engine compensation.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Rounded distance.                                                  */
+  /*                                                                       */
+  static FT_F26Dot6
+  Round_To_Grid( EXEC_OP_ FT_F26Dot6  distance,
+                          FT_F26Dot6  compensation )
+  {
+    FT_F26Dot6  val;
+
+    FT_UNUSED_EXEC;
+
+
+    if ( distance >= 0 )
+    {
+      val = distance + compensation + 32;
+      if ( distance && val > 0 )
+        val &= ~63;
+      else
+        val = 0;
+    }
+    else
+    {
+      val = -FT_PIX_ROUND( compensation - distance );
+      if ( val > 0 )
+        val = 0;
+    }
+
+    return  val;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Round_To_Half_Grid                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Rounds value to half grid after adding engine compensation.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    distance     :: The distance to round.                             */
+  /*                                                                       */
+  /*    compensation :: The engine compensation.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Rounded distance.                                                  */
+  /*                                                                       */
+  static FT_F26Dot6
+  Round_To_Half_Grid( EXEC_OP_ FT_F26Dot6  distance,
+                               FT_F26Dot6  compensation )
+  {
+    FT_F26Dot6  val;
+
+    FT_UNUSED_EXEC;
+
+
+    if ( distance >= 0 )
+    {
+      val = FT_PIX_FLOOR( distance + compensation ) + 32;
+      if ( distance && val < 0 )
+        val = 0;
+    }
+    else
+    {
+      val = -( FT_PIX_FLOOR( compensation - distance ) + 32 );
+      if ( val > 0 )
+        val = 0;
+    }
+
+    return val;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Round_Down_To_Grid                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Rounds value down to grid after adding engine compensation.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    distance     :: The distance to round.                             */
+  /*                                                                       */
+  /*    compensation :: The engine compensation.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Rounded distance.                                                  */
+  /*                                                                       */
+  static FT_F26Dot6
+  Round_Down_To_Grid( EXEC_OP_ FT_F26Dot6  distance,
+                               FT_F26Dot6  compensation )
+  {
+    FT_F26Dot6  val;
+
+    FT_UNUSED_EXEC;
+
+
+    if ( distance >= 0 )
+    {
+      val = distance + compensation;
+      if ( distance && val > 0 )
+        val &= ~63;
+      else
+        val = 0;
+    }
+    else
+    {
+      val = -( ( compensation - distance ) & -64 );
+      if ( val > 0 )
+        val = 0;
+    }
+
+    return val;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Round_Up_To_Grid                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Rounds value up to grid after adding engine compensation.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    distance     :: The distance to round.                             */
+  /*                                                                       */
+  /*    compensation :: The engine compensation.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Rounded distance.                                                  */
+  /*                                                                       */
+  static FT_F26Dot6
+  Round_Up_To_Grid( EXEC_OP_ FT_F26Dot6  distance,
+                             FT_F26Dot6  compensation )
+  {
+    FT_F26Dot6  val;
+
+
+    FT_UNUSED_EXEC;
+
+    if ( distance >= 0 )
+    {
+      val = distance + compensation + 63;
+      if ( distance && val > 0 )
+        val &= ~63;
+      else
+        val = 0;
+    }
+    else
+    {
+      val = - FT_PIX_CEIL( compensation - distance );
+      if ( val > 0 )
+        val = 0;
+    }
+
+    return val;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Round_To_Double_Grid                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Rounds value to double grid after adding engine compensation.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    distance     :: The distance to round.                             */
+  /*                                                                       */
+  /*    compensation :: The engine compensation.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Rounded distance.                                                  */
+  /*                                                                       */
+  static FT_F26Dot6
+  Round_To_Double_Grid( EXEC_OP_ FT_F26Dot6  distance,
+                                 FT_F26Dot6  compensation )
+  {
+    FT_F26Dot6 val;
+
+    FT_UNUSED_EXEC;
+
+
+    if ( distance >= 0 )
+    {
+      val = distance + compensation + 16;
+      if ( distance && val > 0 )
+        val &= ~31;
+      else
+        val = 0;
+    }
+    else
+    {
+      val = -FT_PAD_ROUND( compensation - distance, 32 );
+      if ( val > 0 )
+        val = 0;
+    }
+
+    return val;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Round_Super                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Super-rounds value to grid after adding engine compensation.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    distance     :: The distance to round.                             */
+  /*                                                                       */
+  /*    compensation :: The engine compensation.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Rounded distance.                                                  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The TrueType specification says very few about the relationship    */
+  /*    between rounding and engine compensation.  However, it seems from  */
+  /*    the description of super round that we should add the compensation */
+  /*    before rounding.                                                   */
+  /*                                                                       */
+  static FT_F26Dot6
+  Round_Super( EXEC_OP_ FT_F26Dot6  distance,
+                        FT_F26Dot6  compensation )
+  {
+    FT_F26Dot6  val;
+
+
+    if ( distance >= 0 )
+    {
+      val = ( distance - CUR.phase + CUR.threshold + compensation ) &
+              -CUR.period;
+      if ( distance && val < 0 )
+        val = 0;
+      val += CUR.phase;
+    }
+    else
+    {
+      val = -( ( CUR.threshold - CUR.phase - distance + compensation ) &
+               -CUR.period );
+      if ( val > 0 )
+        val = 0;
+      val -= CUR.phase;
+    }
+
+    return val;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Round_Super_45                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Super-rounds value to grid after adding engine compensation.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    distance     :: The distance to round.                             */
+  /*                                                                       */
+  /*    compensation :: The engine compensation.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Rounded distance.                                                  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    There is a separate function for Round_Super_45() as we may need   */
+  /*    greater precision.                                                 */
+  /*                                                                       */
+  static FT_F26Dot6
+  Round_Super_45( EXEC_OP_ FT_F26Dot6  distance,
+                           FT_F26Dot6  compensation )
+  {
+    FT_F26Dot6  val;
+
+
+    if ( distance >= 0 )
+    {
+      val = ( ( distance - CUR.phase + CUR.threshold + compensation ) /
+                CUR.period ) * CUR.period;
+      if ( distance && val < 0 )
+        val = 0;
+      val += CUR.phase;
+    }
+    else
+    {
+      val = -( ( ( CUR.threshold - CUR.phase - distance + compensation ) /
+                   CUR.period ) * CUR.period );
+      if ( val > 0 )
+        val = 0;
+      val -= CUR.phase;
+    }
+
+    return val;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Compute_Round                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Sets the rounding mode.                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    round_mode :: The rounding mode to be used.                        */
+  /*                                                                       */
+  static void
+  Compute_Round( EXEC_OP_ FT_Byte  round_mode )
+  {
+    switch ( round_mode )
+    {
+    case TT_Round_Off:
+      CUR.func_round = (TT_Round_Func)Round_None;
+      break;
+
+    case TT_Round_To_Grid:
+      CUR.func_round = (TT_Round_Func)Round_To_Grid;
+      break;
+
+    case TT_Round_Up_To_Grid:
+      CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
+      break;
+
+    case TT_Round_Down_To_Grid:
+      CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
+      break;
+
+    case TT_Round_To_Half_Grid:
+      CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
+      break;
+
+    case TT_Round_To_Double_Grid:
+      CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
+      break;
+
+    case TT_Round_Super:
+      CUR.func_round = (TT_Round_Func)Round_Super;
+      break;
+
+    case TT_Round_Super_45:
+      CUR.func_round = (TT_Round_Func)Round_Super_45;
+      break;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    SetSuperRound                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Sets Super Round parameters.                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    GridPeriod :: Grid period                                          */
+  /*    selector   :: SROUND opcode                                        */
+  /*                                                                       */
+  static void
+  SetSuperRound( EXEC_OP_ FT_F26Dot6  GridPeriod,
+                          FT_Long     selector )
+  {
+    switch ( (FT_Int)( selector & 0xC0 ) )
+    {
+      case 0:
+        CUR.period = GridPeriod / 2;
+        break;
+
+      case 0x40:
+        CUR.period = GridPeriod;
+        break;
+
+      case 0x80:
+        CUR.period = GridPeriod * 2;
+        break;
+
+      /* This opcode is reserved, but... */
+
+      case 0xC0:
+        CUR.period = GridPeriod;
+        break;
+    }
+
+    switch ( (FT_Int)( selector & 0x30 ) )
+    {
+    case 0:
+      CUR.phase = 0;
+      break;
+
+    case 0x10:
+      CUR.phase = CUR.period / 4;
+      break;
+
+    case 0x20:
+      CUR.phase = CUR.period / 2;
+      break;
+
+    case 0x30:
+      CUR.phase = CUR.period * 3 / 4;
+      break;
+    }
+
+    if ( (selector & 0x0F) == 0 )
+      CUR.threshold = CUR.period - 1;
+    else
+      CUR.threshold = ( (FT_Int)( selector & 0x0F ) - 4 ) * CUR.period / 8;
+
+    CUR.period    /= 256;
+    CUR.phase     /= 256;
+    CUR.threshold /= 256;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Project                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the projection of vector given by (v2-v1) along the       */
+  /*    current projection vector.                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    v1 :: First input vector.                                          */
+  /*    v2 :: Second input vector.                                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The distance in F26dot6 format.                                    */
+  /*                                                                       */
+  static FT_F26Dot6
+  Project( EXEC_OP_ FT_Vector*  v1,
+                    FT_Vector*  v2 )
+  {
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    FT_ASSERT( !CUR.face->unpatented_hinting );
+#endif
+
+    return TT_DotFix14( v1->x - v2->x,
+                        v1->y - v2->y,
+                        CUR.GS.projVector.x,
+                        CUR.GS.projVector.y );
+  }
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Dual_Project                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the projection of the vector given by (v2-v1) along the   */
+  /*    current dual vector.                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    v1 :: First input vector.                                          */
+  /*    v2 :: Second input vector.                                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The distance in F26dot6 format.                                    */
+  /*                                                                       */
+  static FT_F26Dot6
+  Dual_Project( EXEC_OP_ FT_Vector*  v1,
+                         FT_Vector*  v2 )
+  {
+    return TT_DotFix14( v1->x - v2->x,
+                        v1->y - v2->y,
+                        CUR.GS.dualVector.x,
+                        CUR.GS.dualVector.y );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Project_x                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the projection of the vector given by (v2-v1) along the   */
+  /*    horizontal axis.                                                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    v1 :: First input vector.                                          */
+  /*    v2 :: Second input vector.                                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The distance in F26dot6 format.                                    */
+  /*                                                                       */
+  static FT_F26Dot6
+  Project_x( EXEC_OP_ FT_Vector*  v1,
+                      FT_Vector*  v2 )
+  {
+    FT_UNUSED_EXEC;
+
+    return ( v1->x - v2->x );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Project_y                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the projection of the vector given by (v2-v1) along the   */
+  /*    vertical axis.                                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    v1 :: First input vector.                                          */
+  /*    v2 :: Second input vector.                                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The distance in F26dot6 format.                                    */
+  /*                                                                       */
+  static FT_F26Dot6
+  Project_y( EXEC_OP_ FT_Vector*  v1,
+                      FT_Vector*  v2 )
+  {
+    FT_UNUSED_EXEC;
+
+   return ( v1->y - v2->y );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Compute_Funcs                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the projection and movement function pointers according   */
+  /*    to the current graphics state.                                     */
+  /*                                                                       */
+  static void
+  Compute_Funcs( EXEC_OP )
+  {
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    if ( CUR.face->unpatented_hinting )
+    {
+      /* If both vectors point rightwards along the x axis, set             */
+      /* `both-x-axis' true, otherwise set it false.  The x values only     */
+      /* need be tested because the vector has been normalised to a unit    */
+      /* vector of length 0x4000 = unity.                                   */
+      CUR.GS.both_x_axis = (FT_Bool)( CUR.GS.projVector.x == 0x4000 &&
+                                      CUR.GS.freeVector.x == 0x4000 );
+
+      /* Throw away projection and freedom vector information */
+      /* because the patents don't allow them to be stored.   */
+      /* The relevant US Patents are 5155805 and 5325479.     */
+      CUR.GS.projVector.x = 0;
+      CUR.GS.projVector.y = 0;
+      CUR.GS.freeVector.x = 0;
+      CUR.GS.freeVector.y = 0;
+
+      if ( CUR.GS.both_x_axis )
+      {
+        CUR.func_project   = Project_x;
+        CUR.func_move      = Direct_Move_X;
+        CUR.func_move_orig = Direct_Move_Orig_X;
+      }
+      else
+      {
+        CUR.func_project   = Project_y;
+        CUR.func_move      = Direct_Move_Y;
+        CUR.func_move_orig = Direct_Move_Orig_Y;
+      }
+
+      if ( CUR.GS.dualVector.x == 0x4000 )
+        CUR.func_dualproj = Project_x;
+      else
+      {
+        if ( CUR.GS.dualVector.y == 0x4000 )
+          CUR.func_dualproj = Project_y;
+        else
+          CUR.func_dualproj = Dual_Project;
+      }
+
+      /* Force recalculation of cached aspect ratio */
+      CUR.tt_metrics.ratio = 0;
+
+      return;
+    }
+#endif /* TT_CONFIG_OPTION_UNPATENTED_HINTING */
+
+    if ( CUR.GS.freeVector.x == 0x4000 )
+      CUR.F_dot_P       = CUR.GS.projVector.x * 0x10000L;
+    else
+    {
+      if ( CUR.GS.freeVector.y == 0x4000 )
+        CUR.F_dot_P       = CUR.GS.projVector.y * 0x10000L;
+      else
+        CUR.F_dot_P = (FT_Long)CUR.GS.projVector.x * CUR.GS.freeVector.x * 4 +
+                      (FT_Long)CUR.GS.projVector.y * CUR.GS.freeVector.y * 4;
+    }
+
+    if ( CUR.GS.projVector.x == 0x4000 )
+      CUR.func_project = (TT_Project_Func)Project_x;
+    else
+    {
+      if ( CUR.GS.projVector.y == 0x4000 )
+        CUR.func_project = (TT_Project_Func)Project_y;
+      else
+        CUR.func_project = (TT_Project_Func)Project;
+    }
+
+    if ( CUR.GS.dualVector.x == 0x4000 )
+      CUR.func_dualproj = (TT_Project_Func)Project_x;
+    else
+    {
+      if ( CUR.GS.dualVector.y == 0x4000 )
+        CUR.func_dualproj = (TT_Project_Func)Project_y;
+      else
+        CUR.func_dualproj = (TT_Project_Func)Dual_Project;
+    }
+
+    CUR.func_move      = (TT_Move_Func)Direct_Move;
+    CUR.func_move_orig = (TT_Move_Func)Direct_Move_Orig;
+
+    if ( CUR.F_dot_P == 0x40000000L )
+    {
+      if ( CUR.GS.freeVector.x == 0x4000 )
+      {
+        CUR.func_move      = (TT_Move_Func)Direct_Move_X;
+        CUR.func_move_orig = (TT_Move_Func)Direct_Move_Orig_X;
+      }
+      else
+      {
+        if ( CUR.GS.freeVector.y == 0x4000 )
+        {
+          CUR.func_move      = (TT_Move_Func)Direct_Move_Y;
+          CUR.func_move_orig = (TT_Move_Func)Direct_Move_Orig_Y;
+        }
+      }
+    }
+
+    /* at small sizes, F_dot_P can become too small, resulting   */
+    /* in overflows and `spikes' in a number of glyphs like `w'. */
+
+    if ( FT_ABS( CUR.F_dot_P ) < 0x4000000L )
+      CUR.F_dot_P = 0x40000000L;
+
+    /* Disable cached aspect ratio */
+    CUR.tt_metrics.ratio = 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Normalize                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Norms a vector.                                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    Vx :: The horizontal input vector coordinate.                      */
+  /*    Vy :: The vertical input vector coordinate.                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    R  :: The normed unit vector.                                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Returns FAILURE if a vector parameter is zero.                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    In case Vx and Vy are both zero, Normalize() returns SUCCESS, and  */
+  /*    R is undefined.                                                    */
+  /*                                                                       */
+
+
+  static FT_Bool
+  Normalize( EXEC_OP_ FT_F26Dot6      Vx,
+                      FT_F26Dot6      Vy,
+                      FT_UnitVector*  R )
+  {
+    FT_F26Dot6  W;
+    FT_Bool     S1, S2;
+
+    FT_UNUSED_EXEC;
+
+
+    if ( FT_ABS( Vx ) < 0x10000L && FT_ABS( Vy ) < 0x10000L )
+    {
+      Vx *= 0x100;
+      Vy *= 0x100;
+
+      W = TT_VecLen( Vx, Vy );
+
+      if ( W == 0 )
+      {
+        /* XXX: UNDOCUMENTED! It seems that it is possible to try   */
+        /*      to normalize the vector (0,0).  Return immediately. */
+        return SUCCESS;
+      }
+
+      R->x = (FT_F2Dot14)FT_MulDiv( Vx, 0x4000L, W );
+      R->y = (FT_F2Dot14)FT_MulDiv( Vy, 0x4000L, W );
+
+      return SUCCESS;
+    }
+
+    W = TT_VecLen( Vx, Vy );
+
+    Vx = FT_MulDiv( Vx, 0x4000L, W );
+    Vy = FT_MulDiv( Vy, 0x4000L, W );
+
+    W = Vx * Vx + Vy * Vy;
+
+    /* Now, we want that Sqrt( W ) = 0x4000 */
+    /* Or 0x1000000 <= W < 0x1004000        */
+
+    if ( Vx < 0 )
+    {
+      Vx = -Vx;
+      S1 = TRUE;
+    }
+    else
+      S1 = FALSE;
+
+    if ( Vy < 0 )
+    {
+      Vy = -Vy;
+      S2 = TRUE;
+    }
+    else
+      S2 = FALSE;
+
+    while ( W < 0x1000000L )
+    {
+      /* We need to increase W by a minimal amount */
+      if ( Vx < Vy )
+        Vx++;
+      else
+        Vy++;
+
+      W = Vx * Vx + Vy * Vy;
+    }
+
+    while ( W >= 0x1004000L )
+    {
+      /* We need to decrease W by a minimal amount */
+      if ( Vx < Vy )
+        Vx--;
+      else
+        Vy--;
+
+      W = Vx * Vx + Vy * Vy;
+    }
+
+    /* Note that in various cases, we can only  */
+    /* compute a Sqrt(W) of 0x3FFF, eg. Vx = Vy */
+
+    if ( S1 )
+      Vx = -Vx;
+
+    if ( S2 )
+      Vy = -Vy;
+
+    R->x = (FT_F2Dot14)Vx;   /* Type conversion */
+    R->y = (FT_F2Dot14)Vy;   /* Type conversion */
+
+    return SUCCESS;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Here we start with the implementation of the various opcodes.         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static FT_Bool
+  Ins_SxVTL( EXEC_OP_ FT_UShort       aIdx1,
+                      FT_UShort       aIdx2,
+                      FT_Int          aOpc,
+                      FT_UnitVector*  Vec )
+  {
+    FT_Long     A, B, C;
+    FT_Vector*  p1;
+    FT_Vector*  p2;
+
+
+    if ( BOUNDS( aIdx1, CUR.zp2.n_points ) ||
+         BOUNDS( aIdx2, CUR.zp1.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return FAILURE;
+    }
+
+    p1 = CUR.zp1.cur + aIdx2;
+    p2 = CUR.zp2.cur + aIdx1;
+
+    A = p1->x - p2->x;
+    B = p1->y - p2->y;
+
+    if ( ( aOpc & 1 ) != 0 )
+    {
+      C =  B;   /* counter clockwise rotation */
+      B =  A;
+      A = -C;
+    }
+
+    NORMalize( A, B, Vec );
+
+    return SUCCESS;
+  }
+
+
+  /* When not using the big switch statements, the interpreter uses a */
+  /* call table defined later below in this source.  Each opcode must */
+  /* thus have a corresponding function, even trivial ones.           */
+  /*                                                                  */
+  /* They are all defined there.                                      */
+
+#define DO_SVTCA                            \
+  {                                         \
+    FT_Short  A, B;                         \
+                                            \
+                                            \
+    A = (FT_Short)( CUR.opcode & 1 ) << 14; \
+    B = A ^ (FT_Short)0x4000;               \
+                                            \
+    CUR.GS.freeVector.x = A;                \
+    CUR.GS.projVector.x = A;                \
+    CUR.GS.dualVector.x = A;                \
+                                            \
+    CUR.GS.freeVector.y = B;                \
+    CUR.GS.projVector.y = B;                \
+    CUR.GS.dualVector.y = B;                \
+                                            \
+    COMPUTE_Funcs();                        \
+  }
+
+
+#define DO_SPVTCA                           \
+  {                                         \
+    FT_Short  A, B;                         \
+                                            \
+                                            \
+    A = (FT_Short)( CUR.opcode & 1 ) << 14; \
+    B = A ^ (FT_Short)0x4000;               \
+                                            \
+    CUR.GS.projVector.x = A;                \
+    CUR.GS.dualVector.x = A;                \
+                                            \
+    CUR.GS.projVector.y = B;                \
+    CUR.GS.dualVector.y = B;                \
+                                            \
+    GUESS_VECTOR( freeVector );             \
+                                            \
+    COMPUTE_Funcs();                        \
+  }
+
+
+#define DO_SFVTCA                           \
+  {                                         \
+    FT_Short  A, B;                         \
+                                            \
+                                            \
+    A = (FT_Short)( CUR.opcode & 1 ) << 14; \
+    B = A ^ (FT_Short)0x4000;               \
+                                            \
+    CUR.GS.freeVector.x = A;                \
+    CUR.GS.freeVector.y = B;                \
+                                            \
+    GUESS_VECTOR( projVector );             \
+                                            \
+    COMPUTE_Funcs();                        \
+  }
+
+
+#define DO_SPVTL                                      \
+    if ( INS_SxVTL( (FT_UShort)args[1],               \
+                    (FT_UShort)args[0],               \
+                    CUR.opcode,                       \
+                    &CUR.GS.projVector ) == SUCCESS ) \
+    {                                                 \
+      CUR.GS.dualVector = CUR.GS.projVector;          \
+      GUESS_VECTOR( freeVector );                     \
+      COMPUTE_Funcs();                                \
+    }
+
+
+#define DO_SFVTL                                      \
+    if ( INS_SxVTL( (FT_UShort)args[1],               \
+                    (FT_UShort)args[0],               \
+                    CUR.opcode,                       \
+                    &CUR.GS.freeVector ) == SUCCESS ) \
+    {                                                 \
+      GUESS_VECTOR( projVector );                     \
+      COMPUTE_Funcs();                                \
+    }
+
+
+#define DO_SFVTPV                          \
+    GUESS_VECTOR( projVector );            \
+    CUR.GS.freeVector = CUR.GS.projVector; \
+    COMPUTE_Funcs();
+
+
+#define DO_SPVFS                                \
+  {                                             \
+    FT_Short  S;                                \
+    FT_Long   X, Y;                             \
+                                                \
+                                                \
+    /* Only use low 16bits, then sign extend */ \
+    S = (FT_Short)args[1];                      \
+    Y = (FT_Long)S;                             \
+    S = (FT_Short)args[0];                      \
+    X = (FT_Long)S;                             \
+                                                \
+    NORMalize( X, Y, &CUR.GS.projVector );      \
+                                                \
+    CUR.GS.dualVector = CUR.GS.projVector;      \
+    GUESS_VECTOR( freeVector );                 \
+    COMPUTE_Funcs();                            \
+  }
+
+
+#define DO_SFVFS                                \
+  {                                             \
+    FT_Short  S;                                \
+    FT_Long   X, Y;                             \
+                                                \
+                                                \
+    /* Only use low 16bits, then sign extend */ \
+    S = (FT_Short)args[1];                      \
+    Y = (FT_Long)S;                             \
+    S = (FT_Short)args[0];                      \
+    X = S;                                      \
+                                                \
+    NORMalize( X, Y, &CUR.GS.freeVector );      \
+    GUESS_VECTOR( projVector );                 \
+    COMPUTE_Funcs();                            \
+  }
+
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+#define DO_GPV                                   \
+    if ( CUR.face->unpatented_hinting )          \
+    {                                            \
+      args[0] = CUR.GS.both_x_axis ? 0x4000 : 0; \
+      args[1] = CUR.GS.both_x_axis ? 0 : 0x4000; \
+    }                                            \
+    else                                         \
+    {                                            \
+      args[0] = CUR.GS.projVector.x;             \
+      args[1] = CUR.GS.projVector.y;             \
+    }
+#else
+#define DO_GPV                                   \
+    args[0] = CUR.GS.projVector.x;               \
+    args[1] = CUR.GS.projVector.y;
+#endif
+
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+#define DO_GFV                                   \
+    if ( CUR.face->unpatented_hinting )          \
+    {                                            \
+      args[0] = CUR.GS.both_x_axis ? 0x4000 : 0; \
+      args[1] = CUR.GS.both_x_axis ? 0 : 0x4000; \
+    }                                            \
+    else                                         \
+    {                                            \
+      args[0] = CUR.GS.freeVector.x;             \
+      args[1] = CUR.GS.freeVector.y;             \
+    }
+#else
+#define DO_GFV                                   \
+    args[0] = CUR.GS.freeVector.x;               \
+    args[1] = CUR.GS.freeVector.y;
+#endif
+
+
+#define DO_SRP0                      \
+    CUR.GS.rp0 = (FT_UShort)args[0];
+
+
+#define DO_SRP1                      \
+    CUR.GS.rp1 = (FT_UShort)args[0];
+
+
+#define DO_SRP2                      \
+    CUR.GS.rp2 = (FT_UShort)args[0];
+
+
+#define DO_RTHG                                         \
+    CUR.GS.round_state = TT_Round_To_Half_Grid;         \
+    CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
+
+
+#define DO_RTG                                     \
+    CUR.GS.round_state = TT_Round_To_Grid;         \
+    CUR.func_round = (TT_Round_Func)Round_To_Grid;
+
+
+#define DO_RTDG                                           \
+    CUR.GS.round_state = TT_Round_To_Double_Grid;         \
+    CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
+
+
+#define DO_RUTG                                       \
+    CUR.GS.round_state = TT_Round_Up_To_Grid;         \
+    CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
+
+
+#define DO_RDTG                                         \
+    CUR.GS.round_state = TT_Round_Down_To_Grid;         \
+    CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
+
+
+#define DO_ROFF                                 \
+    CUR.GS.round_state = TT_Round_Off;          \
+    CUR.func_round = (TT_Round_Func)Round_None;
+
+
+#define DO_SROUND                                \
+    SET_SuperRound( 0x4000, args[0] );           \
+    CUR.GS.round_state = TT_Round_Super;         \
+    CUR.func_round = (TT_Round_Func)Round_Super;
+
+
+#define DO_S45ROUND                                 \
+    SET_SuperRound( 0x2D41, args[0] );              \
+    CUR.GS.round_state = TT_Round_Super_45;         \
+    CUR.func_round = (TT_Round_Func)Round_Super_45;
+
+
+#define DO_SLOOP                       \
+    if ( args[0] < 0 )                 \
+      CUR.error = TT_Err_Bad_Argument; \
+    else                               \
+      CUR.GS.loop = args[0];
+
+
+#define DO_SMD                         \
+    CUR.GS.minimum_distance = args[0];
+
+
+#define DO_SCVTCI                                     \
+    CUR.GS.control_value_cutin = (FT_F26Dot6)args[0];
+
+
+#define DO_SSWCI                                     \
+    CUR.GS.single_width_cutin = (FT_F26Dot6)args[0];
+
+
+    /* XXX: UNDOCUMENTED! or bug in the Windows engine? */
+    /*                                                  */
+    /* It seems that the value that is read here is     */
+    /* expressed in 16.16 format rather than in font    */
+    /* units.                                           */
+    /*                                                  */
+#define DO_SSW                                                 \
+    CUR.GS.single_width_value = (FT_F26Dot6)( args[0] >> 10 );
+
+
+#define DO_FLIPON            \
+    CUR.GS.auto_flip = TRUE;
+
+
+#define DO_FLIPOFF            \
+    CUR.GS.auto_flip = FALSE;
+
+
+#define DO_SDB                             \
+    CUR.GS.delta_base = (FT_Short)args[0];
+
+
+#define DO_SDS                              \
+    CUR.GS.delta_shift = (FT_Short)args[0];
+
+
+#define DO_MD  /* nothing */
+
+
+#define DO_MPPEM              \
+    args[0] = CURRENT_Ppem();
+
+
+  /* Note: The pointSize should be irrelevant in a given font program; */
+  /*       we thus decide to return only the ppem.                     */
+#if 0
+
+#define DO_MPS                       \
+    args[0] = CUR.metrics.pointSize;
+
+#else
+
+#define DO_MPS                \
+    args[0] = CURRENT_Ppem();
+
+#endif /* 0 */
+
+
+#define DO_DUP         \
+    args[1] = args[0];
+
+
+#define DO_CLEAR     \
+    CUR.new_top = 0;
+
+
+#define DO_SWAP        \
+  {                    \
+    FT_Long  L;        \
+                       \
+                       \
+    L       = args[0]; \
+    args[0] = args[1]; \
+    args[1] = L;       \
+  }
+
+
+#define DO_DEPTH       \
+    args[0] = CUR.top;
+
+
+#define DO_CINDEX                           \
+  {                                         \
+    FT_Long  L;                             \
+                                            \
+                                            \
+    L = args[0];                            \
+                                            \
+    if ( L <= 0 || L > CUR.args )           \
+      CUR.error = TT_Err_Invalid_Reference; \
+    else                                    \
+      args[0] = CUR.stack[CUR.args - L];    \
+  }
+
+
+#define DO_JROT               \
+    if ( args[1] != 0 )       \
+    {                         \
+      CUR.IP      += args[0]; \
+      CUR.step_ins = FALSE;   \
+    }
+
+
+#define DO_JMPR             \
+    CUR.IP      += args[0]; \
+    CUR.step_ins = FALSE;
+
+
+#define DO_JROF               \
+    if ( args[1] == 0 )       \
+    {                         \
+      CUR.IP      += args[0]; \
+      CUR.step_ins = FALSE;   \
+    }
+
+
+#define DO_LT                        \
+    args[0] = ( args[0] < args[1] );
+
+
+#define DO_LTEQ                       \
+    args[0] = ( args[0] <= args[1] );
+
+
+#define DO_GT                        \
+    args[0] = ( args[0] > args[1] );
+
+
+#define DO_GTEQ                       \
+    args[0] = ( args[0] >= args[1] );
+
+
+#define DO_EQ                         \
+    args[0] = ( args[0] == args[1] );
+
+
+#define DO_NEQ                        \
+    args[0] = ( args[0] != args[1] );
+
+
+#define DO_ODD                                                  \
+    args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 64 );
+
+
+#define DO_EVEN                                                \
+    args[0] = ( ( CUR_Func_round( args[0], 0 ) & 127 ) == 0 );
+
+
+#define DO_AND                        \
+    args[0] = ( args[0] && args[1] );
+
+
+#define DO_OR                         \
+    args[0] = ( args[0] || args[1] );
+
+
+#define DO_NOT          \
+    args[0] = !args[0];
+
+
+#define DO_ADD          \
+    args[0] += args[1];
+
+
+#define DO_SUB          \
+    args[0] -= args[1];
+
+
+#define DO_DIV                                               \
+    if ( args[1] == 0 )                                      \
+      CUR.error = TT_Err_Divide_By_Zero;                     \
+    else                                                     \
+      args[0] = TT_MULDIV_NO_ROUND( args[0], 64L, args[1] );
+
+
+#define DO_MUL                                    \
+    args[0] = TT_MULDIV( args[0], args[1], 64L );
+
+
+#define DO_ABS                   \
+    args[0] = FT_ABS( args[0] );
+
+
+#define DO_NEG          \
+    args[0] = -args[0];
+
+
+#define DO_FLOOR    \
+    args[0] = FT_PIX_FLOOR( args[0] );
+
+
+#define DO_CEILING                    \
+    args[0] = FT_PIX_CEIL( args[0] );
+
+
+#define DO_RS                          \
+   {                                   \
+     FT_ULong  I = (FT_ULong)args[0];  \
+                                       \
+                                       \
+     if ( BOUNDS( I, CUR.storeSize ) ) \
+     {                                 \
+       if ( CUR.pedantic_hinting )     \
+       {                               \
+         ARRAY_BOUND_ERROR;            \
+       }                               \
+       else                            \
+         args[0] = 0;                  \
+     }                                 \
+     else                              \
+       args[0] = CUR.storage[I];       \
+   }
+
+
+#define DO_WS                          \
+   {                                   \
+     FT_ULong  I = (FT_ULong)args[0];  \
+                                       \
+                                       \
+     if ( BOUNDS( I, CUR.storeSize ) ) \
+     {                                 \
+       if ( CUR.pedantic_hinting )     \
+       {                               \
+         ARRAY_BOUND_ERROR;            \
+       }                               \
+     }                                 \
+     else                              \
+       CUR.storage[I] = args[1];       \
+   }
+
+
+#define DO_RCVT                          \
+   {                                     \
+     FT_ULong  I = (FT_ULong)args[0];    \
+                                         \
+                                         \
+     if ( BOUNDS( I, CUR.cvtSize ) )     \
+     {                                   \
+       if ( CUR.pedantic_hinting )       \
+       {                                 \
+         ARRAY_BOUND_ERROR;              \
+       }                                 \
+       else                              \
+         args[0] = 0;                    \
+     }                                   \
+     else                                \
+       args[0] = CUR_Func_read_cvt( I ); \
+   }
+
+
+#define DO_WCVTP                         \
+   {                                     \
+     FT_ULong  I = (FT_ULong)args[0];    \
+                                         \
+                                         \
+     if ( BOUNDS( I, CUR.cvtSize ) )     \
+     {                                   \
+       if ( CUR.pedantic_hinting )       \
+       {                                 \
+         ARRAY_BOUND_ERROR;              \
+       }                                 \
+     }                                   \
+     else                                \
+       CUR_Func_write_cvt( I, args[1] ); \
+   }
+
+
+#define DO_WCVTF                                                \
+   {                                                            \
+     FT_ULong  I = (FT_ULong)args[0];                           \
+                                                                \
+                                                                \
+     if ( BOUNDS( I, CUR.cvtSize ) )                            \
+     {                                                          \
+       if ( CUR.pedantic_hinting )                              \
+       {                                                        \
+         ARRAY_BOUND_ERROR;                                     \
+       }                                                        \
+     }                                                          \
+     else                                                       \
+       CUR.cvt[I] = TT_MULFIX( args[1], CUR.tt_metrics.scale ); \
+   }
+
+
+#define DO_DEBUG                     \
+    CUR.error = TT_Err_Debug_OpCode;
+
+
+#define DO_ROUND                                                   \
+    args[0] = CUR_Func_round(                                      \
+                args[0],                                           \
+                CUR.tt_metrics.compensations[CUR.opcode - 0x68] );
+
+
+#define DO_NROUND                                                            \
+    args[0] = ROUND_None( args[0],                                           \
+                          CUR.tt_metrics.compensations[CUR.opcode - 0x6C] );
+
+
+#define DO_MAX               \
+    if ( args[1] > args[0] ) \
+      args[0] = args[1];
+
+
+#define DO_MIN               \
+    if ( args[1] < args[0] ) \
+      args[0] = args[1];
+
+
+#ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
+
+
+#undef  ARRAY_BOUND_ERROR
+#define ARRAY_BOUND_ERROR                   \
+    {                                       \
+      CUR.error = TT_Err_Invalid_Reference; \
+      return;                               \
+    }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SVTCA[a]:     Set (F and P) Vectors to Coordinate Axis                */
+  /* Opcode range: 0x00-0x01                                               */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_SVTCA( INS_ARG )
+  {
+    DO_SVTCA
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SPVTCA[a]:    Set PVector to Coordinate Axis                          */
+  /* Opcode range: 0x02-0x03                                               */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_SPVTCA( INS_ARG )
+  {
+    DO_SPVTCA
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SFVTCA[a]:    Set FVector to Coordinate Axis                          */
+  /* Opcode range: 0x04-0x05                                               */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_SFVTCA( INS_ARG )
+  {
+    DO_SFVTCA
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SPVTL[a]:     Set PVector To Line                                     */
+  /* Opcode range: 0x06-0x07                                               */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_SPVTL( INS_ARG )
+  {
+    DO_SPVTL
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SFVTL[a]:     Set FVector To Line                                     */
+  /* Opcode range: 0x08-0x09                                               */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_SFVTL( INS_ARG )
+  {
+    DO_SFVTL
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SFVTPV[]:     Set FVector To PVector                                  */
+  /* Opcode range: 0x0E                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_SFVTPV( INS_ARG )
+  {
+    DO_SFVTPV
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SPVFS[]:      Set PVector From Stack                                  */
+  /* Opcode range: 0x0A                                                    */
+  /* Stack:        f2.14 f2.14 -->                                         */
+  /*                                                                       */
+  static void
+  Ins_SPVFS( INS_ARG )
+  {
+    DO_SPVFS
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SFVFS[]:      Set FVector From Stack                                  */
+  /* Opcode range: 0x0B                                                    */
+  /* Stack:        f2.14 f2.14 -->                                         */
+  /*                                                                       */
+  static void
+  Ins_SFVFS( INS_ARG )
+  {
+    DO_SFVFS
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* GPV[]:        Get Projection Vector                                   */
+  /* Opcode range: 0x0C                                                    */
+  /* Stack:        ef2.14 --> ef2.14                                       */
+  /*                                                                       */
+  static void
+  Ins_GPV( INS_ARG )
+  {
+    DO_GPV
+  }
+
+
+  /*************************************************************************/
+  /* GFV[]:        Get Freedom Vector                                      */
+  /* Opcode range: 0x0D                                                    */
+  /* Stack:        ef2.14 --> ef2.14                                       */
+  /*                                                                       */
+  static void
+  Ins_GFV( INS_ARG )
+  {
+    DO_GFV
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SRP0[]:       Set Reference Point 0                                   */
+  /* Opcode range: 0x10                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SRP0( INS_ARG )
+  {
+    DO_SRP0
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SRP1[]:       Set Reference Point 1                                   */
+  /* Opcode range: 0x11                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SRP1( INS_ARG )
+  {
+    DO_SRP1
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SRP2[]:       Set Reference Point 2                                   */
+  /* Opcode range: 0x12                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SRP2( INS_ARG )
+  {
+    DO_SRP2
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* RTHG[]:       Round To Half Grid                                      */
+  /* Opcode range: 0x19                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_RTHG( INS_ARG )
+  {
+    DO_RTHG
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* RTG[]:        Round To Grid                                           */
+  /* Opcode range: 0x18                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_RTG( INS_ARG )
+  {
+    DO_RTG
+  }
+
+
+  /*************************************************************************/
+  /* RTDG[]:       Round To Double Grid                                    */
+  /* Opcode range: 0x3D                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_RTDG( INS_ARG )
+  {
+    DO_RTDG
+  }
+
+
+  /*************************************************************************/
+  /* RUTG[]:       Round Up To Grid                                        */
+  /* Opcode range: 0x7C                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_RUTG( INS_ARG )
+  {
+    DO_RUTG
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* RDTG[]:       Round Down To Grid                                      */
+  /* Opcode range: 0x7D                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_RDTG( INS_ARG )
+  {
+    DO_RDTG
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ROFF[]:       Round OFF                                               */
+  /* Opcode range: 0x7A                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_ROFF( INS_ARG )
+  {
+    DO_ROFF
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SROUND[]:     Super ROUND                                             */
+  /* Opcode range: 0x76                                                    */
+  /* Stack:        Eint8 -->                                               */
+  /*                                                                       */
+  static void
+  Ins_SROUND( INS_ARG )
+  {
+    DO_SROUND
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* S45ROUND[]:   Super ROUND 45 degrees                                  */
+  /* Opcode range: 0x77                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_S45ROUND( INS_ARG )
+  {
+    DO_S45ROUND
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SLOOP[]:      Set LOOP variable                                       */
+  /* Opcode range: 0x17                                                    */
+  /* Stack:        int32? -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SLOOP( INS_ARG )
+  {
+    DO_SLOOP
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SMD[]:        Set Minimum Distance                                    */
+  /* Opcode range: 0x1A                                                    */
+  /* Stack:        f26.6 -->                                               */
+  /*                                                                       */
+  static void
+  Ins_SMD( INS_ARG )
+  {
+    DO_SMD
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SCVTCI[]:     Set Control Value Table Cut In                          */
+  /* Opcode range: 0x1D                                                    */
+  /* Stack:        f26.6 -->                                               */
+  /*                                                                       */
+  static void
+  Ins_SCVTCI( INS_ARG )
+  {
+    DO_SCVTCI
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SSWCI[]:      Set Single Width Cut In                                 */
+  /* Opcode range: 0x1E                                                    */
+  /* Stack:        f26.6 -->                                               */
+  /*                                                                       */
+  static void
+  Ins_SSWCI( INS_ARG )
+  {
+    DO_SSWCI
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SSW[]:        Set Single Width                                        */
+  /* Opcode range: 0x1F                                                    */
+  /* Stack:        int32? -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SSW( INS_ARG )
+  {
+    DO_SSW
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FLIPON[]:     Set auto-FLIP to ON                                     */
+  /* Opcode range: 0x4D                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_FLIPON( INS_ARG )
+  {
+    DO_FLIPON
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FLIPOFF[]:    Set auto-FLIP to OFF                                    */
+  /* Opcode range: 0x4E                                                    */
+  /* Stack: -->                                                            */
+  /*                                                                       */
+  static void
+  Ins_FLIPOFF( INS_ARG )
+  {
+    DO_FLIPOFF
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SANGW[]:      Set ANGle Weight                                        */
+  /* Opcode range: 0x7E                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SANGW( INS_ARG )
+  {
+    /* instruction not supported anymore */
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SDB[]:        Set Delta Base                                          */
+  /* Opcode range: 0x5E                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SDB( INS_ARG )
+  {
+    DO_SDB
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SDS[]:        Set Delta Shift                                         */
+  /* Opcode range: 0x5F                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SDS( INS_ARG )
+  {
+    DO_SDS
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MPPEM[]:      Measure Pixel Per EM                                    */
+  /* Opcode range: 0x4B                                                    */
+  /* Stack:        --> Euint16                                             */
+  /*                                                                       */
+  static void
+  Ins_MPPEM( INS_ARG )
+  {
+    DO_MPPEM
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MPS[]:        Measure Point Size                                      */
+  /* Opcode range: 0x4C                                                    */
+  /* Stack:        --> Euint16                                             */
+  /*                                                                       */
+  static void
+  Ins_MPS( INS_ARG )
+  {
+    DO_MPS
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DUP[]:        DUPlicate the top stack's element                       */
+  /* Opcode range: 0x20                                                    */
+  /* Stack:        StkElt --> StkElt StkElt                                */
+  /*                                                                       */
+  static void
+  Ins_DUP( INS_ARG )
+  {
+    DO_DUP
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* POP[]:        POP the stack's top element                             */
+  /* Opcode range: 0x21                                                    */
+  /* Stack:        StkElt -->                                              */
+  /*                                                                       */
+  static void
+  Ins_POP( INS_ARG )
+  {
+    /* nothing to do */
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* CLEAR[]:      CLEAR the entire stack                                  */
+  /* Opcode range: 0x22                                                    */
+  /* Stack:        StkElt... -->                                           */
+  /*                                                                       */
+  static void
+  Ins_CLEAR( INS_ARG )
+  {
+    DO_CLEAR
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SWAP[]:       SWAP the stack's top two elements                       */
+  /* Opcode range: 0x23                                                    */
+  /* Stack:        2 * StkElt --> 2 * StkElt                               */
+  /*                                                                       */
+  static void
+  Ins_SWAP( INS_ARG )
+  {
+    DO_SWAP
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DEPTH[]:      return the stack DEPTH                                  */
+  /* Opcode range: 0x24                                                    */
+  /* Stack:        --> uint32                                              */
+  /*                                                                       */
+  static void
+  Ins_DEPTH( INS_ARG )
+  {
+    DO_DEPTH
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* CINDEX[]:     Copy INDEXed element                                    */
+  /* Opcode range: 0x25                                                    */
+  /* Stack:        int32 --> StkElt                                        */
+  /*                                                                       */
+  static void
+  Ins_CINDEX( INS_ARG )
+  {
+    DO_CINDEX
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* EIF[]:        End IF                                                  */
+  /* Opcode range: 0x59                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_EIF( INS_ARG )
+  {
+    /* nothing to do */
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* JROT[]:       Jump Relative On True                                   */
+  /* Opcode range: 0x78                                                    */
+  /* Stack:        StkElt int32 -->                                        */
+  /*                                                                       */
+  static void
+  Ins_JROT( INS_ARG )
+  {
+    DO_JROT
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* JMPR[]:       JuMP Relative                                           */
+  /* Opcode range: 0x1C                                                    */
+  /* Stack:        int32 -->                                               */
+  /*                                                                       */
+  static void
+  Ins_JMPR( INS_ARG )
+  {
+    DO_JMPR
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* JROF[]:       Jump Relative On False                                  */
+  /* Opcode range: 0x79                                                    */
+  /* Stack:        StkElt int32 -->                                        */
+  /*                                                                       */
+  static void
+  Ins_JROF( INS_ARG )
+  {
+    DO_JROF
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* LT[]:         Less Than                                               */
+  /* Opcode range: 0x50                                                    */
+  /* Stack:        int32? int32? --> bool                                  */
+  /*                                                                       */
+  static void
+  Ins_LT( INS_ARG )
+  {
+    DO_LT
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* LTEQ[]:       Less Than or EQual                                      */
+  /* Opcode range: 0x51                                                    */
+  /* Stack:        int32? int32? --> bool                                  */
+  /*                                                                       */
+  static void
+  Ins_LTEQ( INS_ARG )
+  {
+    DO_LTEQ
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* GT[]:         Greater Than                                            */
+  /* Opcode range: 0x52                                                    */
+  /* Stack:        int32? int32? --> bool                                  */
+  /*                                                                       */
+  static void
+  Ins_GT( INS_ARG )
+  {
+    DO_GT
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* GTEQ[]:       Greater Than or EQual                                   */
+  /* Opcode range: 0x53                                                    */
+  /* Stack:        int32? int32? --> bool                                  */
+  /*                                                                       */
+  static void
+  Ins_GTEQ( INS_ARG )
+  {
+    DO_GTEQ
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* EQ[]:         EQual                                                   */
+  /* Opcode range: 0x54                                                    */
+  /* Stack:        StkElt StkElt --> bool                                  */
+  /*                                                                       */
+  static void
+  Ins_EQ( INS_ARG )
+  {
+    DO_EQ
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* NEQ[]:        Not EQual                                               */
+  /* Opcode range: 0x55                                                    */
+  /* Stack:        StkElt StkElt --> bool                                  */
+  /*                                                                       */
+  static void
+  Ins_NEQ( INS_ARG )
+  {
+    DO_NEQ
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ODD[]:        Is ODD                                                  */
+  /* Opcode range: 0x56                                                    */
+  /* Stack:        f26.6 --> bool                                          */
+  /*                                                                       */
+  static void
+  Ins_ODD( INS_ARG )
+  {
+    DO_ODD
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* EVEN[]:       Is EVEN                                                 */
+  /* Opcode range: 0x57                                                    */
+  /* Stack:        f26.6 --> bool                                          */
+  /*                                                                       */
+  static void
+  Ins_EVEN( INS_ARG )
+  {
+    DO_EVEN
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* AND[]:        logical AND                                             */
+  /* Opcode range: 0x5A                                                    */
+  /* Stack:        uint32 uint32 --> uint32                                */
+  /*                                                                       */
+  static void
+  Ins_AND( INS_ARG )
+  {
+    DO_AND
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* OR[]:         logical OR                                              */
+  /* Opcode range: 0x5B                                                    */
+  /* Stack:        uint32 uint32 --> uint32                                */
+  /*                                                                       */
+  static void
+  Ins_OR( INS_ARG )
+  {
+    DO_OR
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* NOT[]:        logical NOT                                             */
+  /* Opcode range: 0x5C                                                    */
+  /* Stack:        StkElt --> uint32                                       */
+  /*                                                                       */
+  static void
+  Ins_NOT( INS_ARG )
+  {
+    DO_NOT
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ADD[]:        ADD                                                     */
+  /* Opcode range: 0x60                                                    */
+  /* Stack:        f26.6 f26.6 --> f26.6                                   */
+  /*                                                                       */
+  static void
+  Ins_ADD( INS_ARG )
+  {
+    DO_ADD
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SUB[]:        SUBtract                                                */
+  /* Opcode range: 0x61                                                    */
+  /* Stack:        f26.6 f26.6 --> f26.6                                   */
+  /*                                                                       */
+  static void
+  Ins_SUB( INS_ARG )
+  {
+    DO_SUB
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DIV[]:        DIVide                                                  */
+  /* Opcode range: 0x62                                                    */
+  /* Stack:        f26.6 f26.6 --> f26.6                                   */
+  /*                                                                       */
+  static void
+  Ins_DIV( INS_ARG )
+  {
+    DO_DIV
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MUL[]:        MULtiply                                                */
+  /* Opcode range: 0x63                                                    */
+  /* Stack:        f26.6 f26.6 --> f26.6                                   */
+  /*                                                                       */
+  static void
+  Ins_MUL( INS_ARG )
+  {
+    DO_MUL
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ABS[]:        ABSolute value                                          */
+  /* Opcode range: 0x64                                                    */
+  /* Stack:        f26.6 --> f26.6                                         */
+  /*                                                                       */
+  static void
+  Ins_ABS( INS_ARG )
+  {
+    DO_ABS
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* NEG[]:        NEGate                                                  */
+  /* Opcode range: 0x65                                                    */
+  /* Stack: f26.6 --> f26.6                                                */
+  /*                                                                       */
+  static void
+  Ins_NEG( INS_ARG )
+  {
+    DO_NEG
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FLOOR[]:      FLOOR                                                   */
+  /* Opcode range: 0x66                                                    */
+  /* Stack:        f26.6 --> f26.6                                         */
+  /*                                                                       */
+  static void
+  Ins_FLOOR( INS_ARG )
+  {
+    DO_FLOOR
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* CEILING[]:    CEILING                                                 */
+  /* Opcode range: 0x67                                                    */
+  /* Stack:        f26.6 --> f26.6                                         */
+  /*                                                                       */
+  static void
+  Ins_CEILING( INS_ARG )
+  {
+    DO_CEILING
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* RS[]:         Read Store                                              */
+  /* Opcode range: 0x43                                                    */
+  /* Stack:        uint32 --> uint32                                       */
+  /*                                                                       */
+  static void
+  Ins_RS( INS_ARG )
+  {
+    DO_RS
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* WS[]:         Write Store                                             */
+  /* Opcode range: 0x42                                                    */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_WS( INS_ARG )
+  {
+    DO_WS
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* WCVTP[]:      Write CVT in Pixel units                                */
+  /* Opcode range: 0x44                                                    */
+  /* Stack:        f26.6 uint32 -->                                        */
+  /*                                                                       */
+  static void
+  Ins_WCVTP( INS_ARG )
+  {
+    DO_WCVTP
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* WCVTF[]:      Write CVT in Funits                                     */
+  /* Opcode range: 0x70                                                    */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_WCVTF( INS_ARG )
+  {
+    DO_WCVTF
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* RCVT[]:       Read CVT                                                */
+  /* Opcode range: 0x45                                                    */
+  /* Stack:        uint32 --> f26.6                                        */
+  /*                                                                       */
+  static void
+  Ins_RCVT( INS_ARG )
+  {
+    DO_RCVT
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* AA[]:         Adjust Angle                                            */
+  /* Opcode range: 0x7F                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_AA( INS_ARG )
+  {
+    /* intentionally no longer supported */
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DEBUG[]:      DEBUG.  Unsupported.                                    */
+  /* Opcode range: 0x4F                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  /* Note: The original instruction pops a value from the stack.           */
+  /*                                                                       */
+  static void
+  Ins_DEBUG( INS_ARG )
+  {
+    DO_DEBUG
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ROUND[ab]:    ROUND value                                             */
+  /* Opcode range: 0x68-0x6B                                               */
+  /* Stack:        f26.6 --> f26.6                                         */
+  /*                                                                       */
+  static void
+  Ins_ROUND( INS_ARG )
+  {
+    DO_ROUND
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* NROUND[ab]:   No ROUNDing of value                                    */
+  /* Opcode range: 0x6C-0x6F                                               */
+  /* Stack:        f26.6 --> f26.6                                         */
+  /*                                                                       */
+  static void
+  Ins_NROUND( INS_ARG )
+  {
+    DO_NROUND
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MAX[]:        MAXimum                                                 */
+  /* Opcode range: 0x68                                                    */
+  /* Stack:        int32? int32? --> int32                                 */
+  /*                                                                       */
+  static void
+  Ins_MAX( INS_ARG )
+  {
+    DO_MAX
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MIN[]:        MINimum                                                 */
+  /* Opcode range: 0x69                                                    */
+  /* Stack:        int32? int32? --> int32                                 */
+  /*                                                                       */
+  static void
+  Ins_MIN( INS_ARG )
+  {
+    DO_MIN
+  }
+
+
+#endif  /* !TT_CONFIG_OPTION_INTERPRETER_SWITCH */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The following functions are called as is within the switch statement. */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MINDEX[]:     Move INDEXed element                                    */
+  /* Opcode range: 0x26                                                    */
+  /* Stack:        int32? --> StkElt                                       */
+  /*                                                                       */
+  static void
+  Ins_MINDEX( INS_ARG )
+  {
+    FT_Long  L, K;
+
+
+    L = args[0];
+
+    if ( L <= 0 || L > CUR.args )
+    {
+      CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    K = CUR.stack[CUR.args - L];
+
+    FT_ARRAY_MOVE( &CUR.stack[CUR.args - L    ],
+                   &CUR.stack[CUR.args - L + 1],
+                   ( L - 1 ) );
+
+    CUR.stack[CUR.args - 1] = K;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ROLL[]:       ROLL top three elements                                 */
+  /* Opcode range: 0x8A                                                    */
+  /* Stack:        3 * StkElt --> 3 * StkElt                               */
+  /*                                                                       */
+  static void
+  Ins_ROLL( INS_ARG )
+  {
+    FT_Long  A, B, C;
+
+    FT_UNUSED_EXEC;
+
+
+    A = args[2];
+    B = args[1];
+    C = args[0];
+
+    args[2] = C;
+    args[1] = A;
+    args[0] = B;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MANAGING THE FLOW OF CONTROL                                          */
+  /*                                                                       */
+  /*   Instructions appear in the specification's order.                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static FT_Bool
+  SkipCode( EXEC_OP )
+  {
+    CUR.IP += CUR.length;
+
+    if ( CUR.IP < CUR.codeSize )
+    {
+      CUR.opcode = CUR.code[CUR.IP];
+
+      CUR.length = opcode_length[CUR.opcode];
+      if ( CUR.length < 0 )
+      {
+        if ( CUR.IP + 1 > CUR.codeSize )
+          goto Fail_Overflow;
+        CUR.length = CUR.code[CUR.IP + 1] + 2;
+      }
+
+      if ( CUR.IP + CUR.length <= CUR.codeSize )
+        return SUCCESS;
+    }
+
+  Fail_Overflow:
+    CUR.error = TT_Err_Code_Overflow;
+    return FAILURE;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* IF[]:         IF test                                                 */
+  /* Opcode range: 0x58                                                    */
+  /* Stack:        StkElt -->                                              */
+  /*                                                                       */
+  static void
+  Ins_IF( INS_ARG )
+  {
+    FT_Int   nIfs;
+    FT_Bool  Out;
+
+
+    if ( args[0] != 0 )
+      return;
+
+    nIfs = 1;
+    Out = 0;
+
+    do
+    {
+      if ( SKIP_Code() == FAILURE )
+        return;
+
+      switch ( CUR.opcode )
+      {
+      case 0x58:      /* IF */
+        nIfs++;
+        break;
+
+      case 0x1B:      /* ELSE */
+        Out = FT_BOOL( nIfs == 1 );
+        break;
+
+      case 0x59:      /* EIF */
+        nIfs--;
+        Out = FT_BOOL( nIfs == 0 );
+        break;
+      }
+    } while ( Out == 0 );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ELSE[]:       ELSE                                                    */
+  /* Opcode range: 0x1B                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_ELSE( INS_ARG )
+  {
+    FT_Int  nIfs;
+
+    FT_UNUSED_ARG;
+
+
+    nIfs = 1;
+
+    do
+    {
+      if ( SKIP_Code() == FAILURE )
+        return;
+
+      switch ( CUR.opcode )
+      {
+      case 0x58:    /* IF */
+        nIfs++;
+        break;
+
+      case 0x59:    /* EIF */
+        nIfs--;
+        break;
+      }
+    } while ( nIfs != 0 );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DEFINING AND USING FUNCTIONS AND INSTRUCTIONS                         */
+  /*                                                                       */
+  /*   Instructions appear in the specification's order.                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FDEF[]:       Function DEFinition                                     */
+  /* Opcode range: 0x2C                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_FDEF( INS_ARG )
+  {
+    FT_ULong       n;
+    TT_DefRecord*  rec;
+    TT_DefRecord*  limit;
+
+
+    /* some font programs are broken enough to redefine functions! */
+    /* We will then parse the current table.                       */
+
+    rec   = CUR.FDefs;
+    limit = rec + CUR.numFDefs;
+    n     = args[0];
+
+    for ( ; rec < limit; rec++ )
+    {
+      if ( rec->opc == n )
+        break;
+    }
+
+    if ( rec == limit )
+    {
+      /* check that there is enough room for new functions */
+      if ( CUR.numFDefs >= CUR.maxFDefs )
+      {
+        CUR.error = TT_Err_Too_Many_Function_Defs;
+        return;
+      }
+      CUR.numFDefs++;
+    }
+
+    rec->range  = CUR.curRange;
+    rec->opc    = n;
+    rec->start  = CUR.IP + 1;
+    rec->active = TRUE;
+
+    if ( n > CUR.maxFunc )
+      CUR.maxFunc = n;
+
+    /* Now skip the whole function definition. */
+    /* We don't allow nested IDEFS & FDEFs.    */
+
+    while ( SKIP_Code() == SUCCESS )
+    {
+      switch ( CUR.opcode )
+      {
+      case 0x89:    /* IDEF */
+      case 0x2C:    /* FDEF */
+        CUR.error = TT_Err_Nested_DEFS;
+        return;
+
+      case 0x2D:   /* ENDF */
+        return;
+      }
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ENDF[]:       END Function definition                                 */
+  /* Opcode range: 0x2D                                                    */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_ENDF( INS_ARG )
+  {
+    TT_CallRec*  pRec;
+
+    FT_UNUSED_ARG;
+
+
+    if ( CUR.callTop <= 0 )     /* We encountered an ENDF without a call */
+    {
+      CUR.error = TT_Err_ENDF_In_Exec_Stream;
+      return;
+    }
+
+    CUR.callTop--;
+
+    pRec = &CUR.callStack[CUR.callTop];
+
+    pRec->Cur_Count--;
+
+    CUR.step_ins = FALSE;
+
+    if ( pRec->Cur_Count > 0 )
+    {
+      CUR.callTop++;
+      CUR.IP = pRec->Cur_Restart;
+    }
+    else
+      /* Loop through the current function */
+      INS_Goto_CodeRange( pRec->Caller_Range,
+                          pRec->Caller_IP );
+
+    /* Exit the current call frame.                      */
+
+    /* NOTE: If the last intruction of a program is a    */
+    /*       CALL or LOOPCALL, the return address is     */
+    /*       always out of the code range.  This is a    */
+    /*       valid address, and it is why we do not test */
+    /*       the result of Ins_Goto_CodeRange() here!    */
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* CALL[]:       CALL function                                           */
+  /* Opcode range: 0x2B                                                    */
+  /* Stack:        uint32? -->                                             */
+  /*                                                                       */
+  static void
+  Ins_CALL( INS_ARG )
+  {
+    FT_ULong       F;
+    TT_CallRec*    pCrec;
+    TT_DefRecord*  def;
+
+
+    /* first of all, check the index */
+
+    F = args[0];
+    if ( BOUNDS( F, CUR.maxFunc + 1 ) )
+      goto Fail;
+
+    /* Except for some old Apple fonts, all functions in a TrueType */
+    /* font are defined in increasing order, starting from 0.  This */
+    /* means that we normally have                                  */
+    /*                                                              */
+    /*    CUR.maxFunc+1 == CUR.numFDefs                             */
+    /*    CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc             */
+    /*                                                              */
+    /* If this isn't true, we need to look up the function table.   */
+
+    def = CUR.FDefs + F;
+    if ( CUR.maxFunc + 1 != CUR.numFDefs || def->opc != F )
+    {
+      /* look up the FDefs table */
+      TT_DefRecord*  limit;
+
+
+      def   = CUR.FDefs;
+      limit = def + CUR.numFDefs;
+
+      while ( def < limit && def->opc != F )
+        def++;
+
+      if ( def == limit )
+        goto Fail;
+    }
+
+    /* check that the function is active */
+    if ( !def->active )
+      goto Fail;
+
+    /* check the call stack */
+    if ( CUR.callTop >= CUR.callSize )
+    {
+      CUR.error = TT_Err_Stack_Overflow;
+      return;
+    }
+
+    pCrec = CUR.callStack + CUR.callTop;
+
+    pCrec->Caller_Range = CUR.curRange;
+    pCrec->Caller_IP    = CUR.IP + 1;
+    pCrec->Cur_Count    = 1;
+    pCrec->Cur_Restart  = def->start;
+
+    CUR.callTop++;
+
+    INS_Goto_CodeRange( def->range,
+                        def->start );
+
+    CUR.step_ins = FALSE;
+    return;
+
+  Fail:
+    CUR.error = TT_Err_Invalid_Reference;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* LOOPCALL[]:   LOOP and CALL function                                  */
+  /* Opcode range: 0x2A                                                    */
+  /* Stack:        uint32? Eint16? -->                                     */
+  /*                                                                       */
+  static void
+  Ins_LOOPCALL( INS_ARG )
+  {
+    FT_ULong       F;
+    TT_CallRec*    pCrec;
+    TT_DefRecord*  def;
+
+
+    /* first of all, check the index */
+    F = args[1];
+    if ( BOUNDS( F, CUR.maxFunc + 1 ) )
+      goto Fail;
+
+    /* Except for some old Apple fonts, all functions in a TrueType */
+    /* font are defined in increasing order, starting from 0.  This */
+    /* means that we normally have                                  */
+    /*                                                              */
+    /*    CUR.maxFunc+1 == CUR.numFDefs                             */
+    /*    CUR.FDefs[n].opc == n for n in 0..CUR.maxFunc             */
+    /*                                                              */
+    /* If this isn't true, we need to look up the function table.   */
+
+    def = CUR.FDefs + F;
+    if ( CUR.maxFunc + 1 != CUR.numFDefs || def->opc != F )
+    {
+      /* look up the FDefs table */
+      TT_DefRecord*  limit;
+
+
+      def   = CUR.FDefs;
+      limit = def + CUR.numFDefs;
+
+      while ( def < limit && def->opc != F )
+        def++;
+
+      if ( def == limit )
+        goto Fail;
+    }
+
+    /* check that the function is active */
+    if ( !def->active )
+      goto Fail;
+
+    /* check stack */
+    if ( CUR.callTop >= CUR.callSize )
+    {
+      CUR.error = TT_Err_Stack_Overflow;
+      return;
+    }
+
+    if ( args[0] > 0 )
+    {
+      pCrec = CUR.callStack + CUR.callTop;
+
+      pCrec->Caller_Range = CUR.curRange;
+      pCrec->Caller_IP    = CUR.IP + 1;
+      pCrec->Cur_Count    = (FT_Int)args[0];
+      pCrec->Cur_Restart  = def->start;
+
+      CUR.callTop++;
+
+      INS_Goto_CodeRange( def->range, def->start );
+
+      CUR.step_ins = FALSE;
+    }
+    return;
+
+  Fail:
+    CUR.error = TT_Err_Invalid_Reference;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* IDEF[]:       Instruction DEFinition                                  */
+  /* Opcode range: 0x89                                                    */
+  /* Stack:        Eint8 -->                                               */
+  /*                                                                       */
+  static void
+  Ins_IDEF( INS_ARG )
+  {
+    TT_DefRecord*  def;
+    TT_DefRecord*  limit;
+
+
+    /*  First of all, look for the same function in our table */
+
+    def   = CUR.IDefs;
+    limit = def + CUR.numIDefs;
+
+    for ( ; def < limit; def++ )
+      if ( def->opc == (FT_ULong)args[0] )
+        break;
+
+    if ( def == limit )
+    {
+      /* check that there is enough room for a new instruction */
+      if ( CUR.numIDefs >= CUR.maxIDefs )
+      {
+        CUR.error = TT_Err_Too_Many_Instruction_Defs;
+        return;
+      }
+      CUR.numIDefs++;
+    }
+
+    def->opc    = args[0];
+    def->start  = CUR.IP+1;
+    def->range  = CUR.curRange;
+    def->active = TRUE;
+
+    if ( (FT_ULong)args[0] > CUR.maxIns )
+      CUR.maxIns = args[0];
+
+    /* Now skip the whole function definition. */
+    /* We don't allow nested IDEFs & FDEFs.    */
+
+    while ( SKIP_Code() == SUCCESS )
+    {
+      switch ( CUR.opcode )
+      {
+      case 0x89:   /* IDEF */
+      case 0x2C:   /* FDEF */
+        CUR.error = TT_Err_Nested_DEFS;
+        return;
+      case 0x2D:   /* ENDF */
+        return;
+      }
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* PUSHING DATA ONTO THE INTERPRETER STACK                               */
+  /*                                                                       */
+  /*   Instructions appear in the specification's order.                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* NPUSHB[]:     PUSH N Bytes                                            */
+  /* Opcode range: 0x40                                                    */
+  /* Stack:        --> uint32...                                           */
+  /*                                                                       */
+  static void
+  Ins_NPUSHB( INS_ARG )
+  {
+    FT_UShort  L, K;
+
+
+    L = (FT_UShort)CUR.code[CUR.IP + 1];
+
+    if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
+    {
+      CUR.error = TT_Err_Stack_Overflow;
+      return;
+    }
+
+    for ( K = 1; K <= L; K++ )
+      args[K - 1] = CUR.code[CUR.IP + K + 1];
+
+    CUR.new_top += L;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* NPUSHW[]:     PUSH N Words                                            */
+  /* Opcode range: 0x41                                                    */
+  /* Stack:        --> int32...                                            */
+  /*                                                                       */
+  static void
+  Ins_NPUSHW( INS_ARG )
+  {
+    FT_UShort  L, K;
+
+
+    L = (FT_UShort)CUR.code[CUR.IP + 1];
+
+    if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
+    {
+      CUR.error = TT_Err_Stack_Overflow;
+      return;
+    }
+
+    CUR.IP += 2;
+
+    for ( K = 0; K < L; K++ )
+      args[K] = GET_ShortIns();
+
+    CUR.step_ins = FALSE;
+    CUR.new_top += L;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* PUSHB[abc]:   PUSH Bytes                                              */
+  /* Opcode range: 0xB0-0xB7                                               */
+  /* Stack:        --> uint32...                                           */
+  /*                                                                       */
+  static void
+  Ins_PUSHB( INS_ARG )
+  {
+    FT_UShort  L, K;
+
+
+    L = (FT_UShort)(CUR.opcode - 0xB0 + 1);
+
+    if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
+    {
+      CUR.error = TT_Err_Stack_Overflow;
+      return;
+    }
+
+    for ( K = 1; K <= L; K++ )
+      args[K - 1] = CUR.code[CUR.IP + K];
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* PUSHW[abc]:   PUSH Words                                              */
+  /* Opcode range: 0xB8-0xBF                                               */
+  /* Stack:        --> int32...                                            */
+  /*                                                                       */
+  static void
+  Ins_PUSHW( INS_ARG )
+  {
+    FT_UShort  L, K;
+
+
+    L = (FT_UShort)(CUR.opcode - 0xB8 + 1);
+
+    if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
+    {
+      CUR.error = TT_Err_Stack_Overflow;
+      return;
+    }
+
+    CUR.IP++;
+
+    for ( K = 0; K < L; K++ )
+      args[K] = GET_ShortIns();
+
+    CUR.step_ins = FALSE;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MANAGING THE GRAPHICS STATE                                           */
+  /*                                                                       */
+  /*  Instructions appear in the specs' order.                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* GC[a]:        Get Coordinate projected onto                           */
+  /* Opcode range: 0x46-0x47                                               */
+  /* Stack:        uint32 --> f26.6                                        */
+  /*                                                                       */
+  /* BULLSHIT: Measures from the original glyph must be taken along the    */
+  /*           dual projection vector!                                     */
+  /*                                                                       */
+  static void
+  Ins_GC( INS_ARG )
+  {
+    FT_ULong    L;
+    FT_F26Dot6  R;
+
+
+    L = (FT_ULong)args[0];
+
+    if ( BOUNDS( L, CUR.zp2.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+      {
+        CUR.error = TT_Err_Invalid_Reference;
+        return;
+      }
+      else
+        R = 0;
+    }
+    else
+    {
+      if ( CUR.opcode & 1 )
+        R = CUR_Func_dualproj( CUR.zp2.org + L, NULL_Vector );
+      else
+        R = CUR_Func_project( CUR.zp2.cur + L, NULL_Vector );
+    }
+
+    args[0] = R;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SCFS[]:       Set Coordinate From Stack                               */
+  /* Opcode range: 0x48                                                    */
+  /* Stack:        f26.6 uint32 -->                                        */
+  /*                                                                       */
+  /* Formula:                                                              */
+  /*                                                                       */
+  /*   OA := OA + ( value - OA.p )/( f.p ) * f                             */
+  /*                                                                       */
+  static void
+  Ins_SCFS( INS_ARG )
+  {
+    FT_Long    K;
+    FT_UShort  L;
+
+
+    L = (FT_UShort)args[0];
+
+    if ( BOUNDS( L, CUR.zp2.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    K = CUR_Func_project( CUR.zp2.cur + L, NULL_Vector );
+
+    CUR_Func_move( &CUR.zp2, L, args[1] - K );
+
+    /* not part of the specs, but here for safety */
+
+    if ( CUR.GS.gep2 == 0 )
+      CUR.zp2.org[L] = CUR.zp2.cur[L];
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MD[a]:        Measure Distance                                        */
+  /* Opcode range: 0x49-0x4A                                               */
+  /* Stack:        uint32 uint32 --> f26.6                                 */
+  /*                                                                       */
+  /* BULLSHIT: Measure taken in the original glyph must be along the dual  */
+  /*           projection vector.                                          */
+  /*                                                                       */
+  /* Second BULLSHIT: Flag attributes are inverted!                        */
+  /*                  0 => measure distance in original outline            */
+  /*                  1 => measure distance in grid-fitted outline         */
+  /*                                                                       */
+  /* Third one: `zp0 - zp1', and not `zp2 - zp1!                           */
+  /*                                                                       */
+  static void
+  Ins_MD( INS_ARG )
+  {
+    FT_UShort   K, L;
+    FT_F26Dot6  D;
+
+
+    K = (FT_UShort)args[1];
+    L = (FT_UShort)args[0];
+
+    if( BOUNDS( L, CUR.zp0.n_points ) ||
+        BOUNDS( K, CUR.zp1.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+      {
+        CUR.error = TT_Err_Invalid_Reference;
+        return;
+      }
+      D = 0;
+    }
+    else
+    {
+      if ( CUR.opcode & 1 )
+        D = CUR_Func_project( CUR.zp0.cur + L, CUR.zp1.cur + K );
+      else
+        D = CUR_Func_dualproj( CUR.zp0.org + L, CUR.zp1.org + K );
+    }
+
+    args[0] = D;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SDPVTL[a]:    Set Dual PVector to Line                                */
+  /* Opcode range: 0x86-0x87                                               */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_SDPVTL( INS_ARG )
+  {
+    FT_Long    A, B, C;
+    FT_UShort  p1, p2;   /* was FT_Int in pas type ERROR */
+
+
+    p1 = (FT_UShort)args[1];
+    p2 = (FT_UShort)args[0];
+
+    if ( BOUNDS( p2, CUR.zp1.n_points ) ||
+         BOUNDS( p1, CUR.zp2.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    {
+      FT_Vector* v1 = CUR.zp1.org + p2;
+      FT_Vector* v2 = CUR.zp2.org + p1;
+
+
+      A = v1->x - v2->x;
+      B = v1->y - v2->y;
+    }
+
+    if ( ( CUR.opcode & 1 ) != 0 )
+    {
+      C =  B;   /* counter clockwise rotation */
+      B =  A;
+      A = -C;
+    }
+
+    NORMalize( A, B, &CUR.GS.dualVector );
+
+    {
+      FT_Vector*  v1 = CUR.zp1.cur + p2;
+      FT_Vector*  v2 = CUR.zp2.cur + p1;
+
+
+      A = v1->x - v2->x;
+      B = v1->y - v2->y;
+    }
+
+    if ( ( CUR.opcode & 1 ) != 0 )
+    {
+      C =  B;   /* counter clockwise rotation */
+      B =  A;
+      A = -C;
+    }
+
+    NORMalize( A, B, &CUR.GS.projVector );
+
+    GUESS_VECTOR( freeVector );
+
+    COMPUTE_Funcs();
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SZP0[]:       Set Zone Pointer 0                                      */
+  /* Opcode range: 0x13                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SZP0( INS_ARG )
+  {
+    switch ( (FT_Int)args[0] )
+    {
+    case 0:
+      CUR.zp0 = CUR.twilight;
+      break;
+
+    case 1:
+      CUR.zp0 = CUR.pts;
+      break;
+
+    default:
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    CUR.GS.gep0 = (FT_UShort)args[0];
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SZP1[]:       Set Zone Pointer 1                                      */
+  /* Opcode range: 0x14                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SZP1( INS_ARG )
+  {
+    switch ( (FT_Int)args[0] )
+    {
+    case 0:
+      CUR.zp1 = CUR.twilight;
+      break;
+
+    case 1:
+      CUR.zp1 = CUR.pts;
+      break;
+
+    default:
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    CUR.GS.gep1 = (FT_UShort)args[0];
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SZP2[]:       Set Zone Pointer 2                                      */
+  /* Opcode range: 0x15                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SZP2( INS_ARG )
+  {
+    switch ( (FT_Int)args[0] )
+    {
+    case 0:
+      CUR.zp2 = CUR.twilight;
+      break;
+
+    case 1:
+      CUR.zp2 = CUR.pts;
+      break;
+
+    default:
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    CUR.GS.gep2 = (FT_UShort)args[0];
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SZPS[]:       Set Zone PointerS                                       */
+  /* Opcode range: 0x16                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SZPS( INS_ARG )
+  {
+    switch ( (FT_Int)args[0] )
+    {
+    case 0:
+      CUR.zp0 = CUR.twilight;
+      break;
+
+    case 1:
+      CUR.zp0 = CUR.pts;
+      break;
+
+    default:
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    CUR.zp1 = CUR.zp0;
+    CUR.zp2 = CUR.zp0;
+
+    CUR.GS.gep0 = (FT_UShort)args[0];
+    CUR.GS.gep1 = (FT_UShort)args[0];
+    CUR.GS.gep2 = (FT_UShort)args[0];
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* INSTCTRL[]:   INSTruction ConTRoL                                     */
+  /* Opcode range: 0x8e                                                    */
+  /* Stack:        int32 int32 -->                                         */
+  /*                                                                       */
+  static void
+  Ins_INSTCTRL( INS_ARG )
+  {
+    FT_Long  K, L;
+
+
+    K = args[1];
+    L = args[0];
+
+    if ( K < 1 || K > 2 )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    if ( L != 0 )
+        L = K;
+
+    CUR.GS.instruct_control = FT_BOOL(
+      ( (FT_Byte)CUR.GS.instruct_control & ~(FT_Byte)K ) | (FT_Byte)L );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SCANCTRL[]:   SCAN ConTRoL                                            */
+  /* Opcode range: 0x85                                                    */
+  /* Stack:        uint32? -->                                             */
+  /*                                                                       */
+  static void
+  Ins_SCANCTRL( INS_ARG )
+  {
+    FT_Int  A;
+
+
+    /* Get Threshold */
+    A = (FT_Int)( args[0] & 0xFF );
+
+    if ( A == 0xFF )
+    {
+      CUR.GS.scan_control = TRUE;
+      return;
+    }
+    else if ( A == 0 )
+    {
+      CUR.GS.scan_control = FALSE;
+      return;
+    }
+
+    A *= 64;
+
+#if 0
+    if ( (args[0] & 0x100) != 0 && CUR.metrics.pointSize <= A )
+      CUR.GS.scan_control = TRUE;
+#endif
+
+    if ( (args[0] & 0x200) != 0 && CUR.tt_metrics.rotated )
+      CUR.GS.scan_control = TRUE;
+
+    if ( (args[0] & 0x400) != 0 && CUR.tt_metrics.stretched )
+      CUR.GS.scan_control = TRUE;
+
+#if 0
+    if ( (args[0] & 0x800) != 0 && CUR.metrics.pointSize > A )
+      CUR.GS.scan_control = FALSE;
+#endif
+
+    if ( (args[0] & 0x1000) != 0 && CUR.tt_metrics.rotated )
+      CUR.GS.scan_control = FALSE;
+
+    if ( (args[0] & 0x2000) != 0 && CUR.tt_metrics.stretched )
+      CUR.GS.scan_control = FALSE;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SCANTYPE[]:   SCAN TYPE                                               */
+  /* Opcode range: 0x8D                                                    */
+  /* Stack:        uint32? -->                                             */
+  /*                                                                       */
+  static void
+  Ins_SCANTYPE( INS_ARG )
+  {
+    /* for compatibility with future enhancements, */
+    /* we must ignore new modes                    */
+
+    if ( args[0] >= 0 && args[0] <= 5 )
+    {
+      if ( args[0] == 3 )
+        args[0] = 2;
+
+      CUR.GS.scan_type = (FT_Int)args[0];
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MANAGING OUTLINES                                                     */
+  /*                                                                       */
+  /*   Instructions appear in the specification's order.                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FLIPPT[]:     FLIP PoinT                                              */
+  /* Opcode range: 0x80                                                    */
+  /* Stack:        uint32... -->                                           */
+  /*                                                                       */
+  static void
+  Ins_FLIPPT( INS_ARG )
+  {
+    FT_UShort  point;
+
+    FT_UNUSED_ARG;
+
+
+    if ( CUR.top < CUR.GS.loop )
+    {
+      CUR.error = TT_Err_Too_Few_Arguments;
+      return;
+    }
+
+    while ( CUR.GS.loop > 0 )
+    {
+      CUR.args--;
+
+      point = (FT_UShort)CUR.stack[CUR.args];
+
+      if ( BOUNDS( point, CUR.pts.n_points ) )
+      {
+        if ( CUR.pedantic_hinting )
+        {
+          CUR.error = TT_Err_Invalid_Reference;
+          return;
+        }
+      }
+      else
+        CUR.pts.tags[point] ^= FT_CURVE_TAG_ON;
+
+      CUR.GS.loop--;
+    }
+
+    CUR.GS.loop = 1;
+    CUR.new_top = CUR.args;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FLIPRGON[]:   FLIP RanGe ON                                           */
+  /* Opcode range: 0x81                                                    */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_FLIPRGON( INS_ARG )
+  {
+    FT_UShort  I, K, L;
+
+
+    K = (FT_UShort)args[1];
+    L = (FT_UShort)args[0];
+
+    if ( BOUNDS( K, CUR.pts.n_points ) ||
+         BOUNDS( L, CUR.pts.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    for ( I = L; I <= K; I++ )
+      CUR.pts.tags[I] |= FT_CURVE_TAG_ON;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FLIPRGOFF:    FLIP RanGe OFF                                          */
+  /* Opcode range: 0x82                                                    */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_FLIPRGOFF( INS_ARG )
+  {
+    FT_UShort  I, K, L;
+
+
+    K = (FT_UShort)args[1];
+    L = (FT_UShort)args[0];
+
+    if ( BOUNDS( K, CUR.pts.n_points ) ||
+         BOUNDS( L, CUR.pts.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    for ( I = L; I <= K; I++ )
+      CUR.pts.tags[I] &= ~FT_CURVE_TAG_ON;
+  }
+
+
+  static FT_Bool
+  Compute_Point_Displacement( EXEC_OP_ FT_F26Dot6*   x,
+                                       FT_F26Dot6*   y,
+                                       TT_GlyphZone  zone,
+                                       FT_UShort*    refp )
+  {
+    TT_GlyphZoneRec  zp;
+    FT_UShort        p;
+    FT_F26Dot6       d;
+
+
+    if ( CUR.opcode & 1 )
+    {
+      zp = CUR.zp0;
+      p  = CUR.GS.rp1;
+    }
+    else
+    {
+      zp = CUR.zp1;
+      p  = CUR.GS.rp2;
+    }
+
+    if ( BOUNDS( p, zp.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return FAILURE;
+    }
+
+    *zone = zp;
+    *refp = p;
+
+    d = CUR_Func_project( zp.cur + p, zp.org + p );
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    if ( CUR.face->unpatented_hinting )
+    {
+      if ( CUR.GS.both_x_axis )
+      {
+        *x = d;
+        *y = 0;
+      }
+      else
+      {
+        *x = 0;
+        *y = d;
+      }
+    }
+    else
+#endif
+    {
+      *x = TT_MULDIV( d,
+                      (FT_Long)CUR.GS.freeVector.x * 0x10000L,
+                      CUR.F_dot_P );
+      *y = TT_MULDIV( d,
+                      (FT_Long)CUR.GS.freeVector.y * 0x10000L,
+                      CUR.F_dot_P );
+    }
+
+    return SUCCESS;
+  }
+
+
+  static void
+  Move_Zp2_Point( EXEC_OP_ FT_UShort   point,
+                           FT_F26Dot6  dx,
+                           FT_F26Dot6  dy,
+                           FT_Bool     touch )
+  {
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    if ( CUR.face->unpatented_hinting )
+    {
+      if ( CUR.GS.both_x_axis )
+      {
+        CUR.zp2.cur[point].x += dx;
+        if ( touch )
+          CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X;
+      }
+      else
+      {
+        CUR.zp2.cur[point].y += dy;
+        if ( touch )
+          CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_Y;
+      }
+      return;
+    }
+#endif
+
+    if ( CUR.GS.freeVector.x != 0 )
+    {
+      CUR.zp2.cur[point].x += dx;
+      if ( touch )
+        CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X;
+    }
+
+    if ( CUR.GS.freeVector.y != 0 )
+    {
+      CUR.zp2.cur[point].y += dy;
+      if ( touch )
+        CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_Y;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SHP[a]:       SHift Point by the last point                           */
+  /* Opcode range: 0x32-0x33                                               */
+  /* Stack:        uint32... -->                                           */
+  /*                                                                       */
+  static void
+  Ins_SHP( INS_ARG )
+  {
+    TT_GlyphZoneRec  zp;
+    FT_UShort        refp;
+
+    FT_F26Dot6       dx,
+                     dy;
+    FT_UShort        point;
+
+    FT_UNUSED_ARG;
+
+
+    if ( CUR.top < CUR.GS.loop )
+    {
+      CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    if ( COMPUTE_Point_Displacement( &dx, &dy, &zp, &refp ) )
+      return;
+
+    while ( CUR.GS.loop > 0 )
+    {
+      CUR.args--;
+      point = (FT_UShort)CUR.stack[CUR.args];
+
+      if ( BOUNDS( point, CUR.zp2.n_points ) )
+      {
+        if ( CUR.pedantic_hinting )
+        {
+          CUR.error = TT_Err_Invalid_Reference;
+          return;
+        }
+      }
+      else
+        /* XXX: UNDOCUMENTED! SHP touches the points */
+        MOVE_Zp2_Point( point, dx, dy, TRUE );
+
+      CUR.GS.loop--;
+    }
+
+    CUR.GS.loop = 1;
+    CUR.new_top = CUR.args;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SHC[a]:       SHift Contour                                           */
+  /* Opcode range: 0x34-35                                                 */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SHC( INS_ARG )
+  {
+    TT_GlyphZoneRec zp;
+    FT_UShort       refp;
+    FT_F26Dot6      dx,
+                    dy;
+
+    FT_Short        contour;
+    FT_UShort       first_point, last_point, i;
+
+
+    contour = (FT_UShort)args[0];
+
+    if ( BOUNDS( contour, CUR.pts.n_contours ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    if ( COMPUTE_Point_Displacement( &dx, &dy, &zp, &refp ) )
+      return;
+
+    if ( contour == 0 )
+      first_point = 0;
+    else
+      first_point = (FT_UShort)(CUR.pts.contours[contour - 1] + 1);
+
+    last_point = CUR.pts.contours[contour];
+
+    /* XXX: this is probably wrong... at least it prevents memory */
+    /*      corruption when zp2 is the twilight zone              */
+    if ( last_point > CUR.zp2.n_points )
+    {
+      if ( CUR.zp2.n_points > 0 )
+        last_point = (FT_UShort)(CUR.zp2.n_points - 1);
+      else
+        last_point = 0;
+    }
+
+    /* XXX: UNDOCUMENTED! SHC does touch the points */
+    for ( i = first_point; i <= last_point; i++ )
+    {
+      if ( zp.cur != CUR.zp2.cur || refp != i )
+        MOVE_Zp2_Point( i, dx, dy, TRUE );
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SHZ[a]:       SHift Zone                                              */
+  /* Opcode range: 0x36-37                                                 */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_SHZ( INS_ARG )
+  {
+    TT_GlyphZoneRec zp;
+    FT_UShort       refp;
+    FT_F26Dot6      dx,
+                    dy;
+
+    FT_UShort       last_point, i;
+
+
+    if ( BOUNDS( args[0], 2 ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    if ( COMPUTE_Point_Displacement( &dx, &dy, &zp, &refp ) )
+      return;
+
+    if ( CUR.zp2.n_points > 0 )
+      last_point = (FT_UShort)(CUR.zp2.n_points - 1);
+    else
+      last_point = 0;
+
+    /* XXX: UNDOCUMENTED! SHZ doesn't touch the points */
+    for ( i = 0; i <= last_point; i++ )
+    {
+      if ( zp.cur != CUR.zp2.cur || refp != i )
+        MOVE_Zp2_Point( i, dx, dy, FALSE );
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* SHPIX[]:      SHift points by a PIXel amount                          */
+  /* Opcode range: 0x38                                                    */
+  /* Stack:        f26.6 uint32... -->                                     */
+  /*                                                                       */
+  static void
+  Ins_SHPIX( INS_ARG )
+  {
+    FT_F26Dot6  dx, dy;
+    FT_UShort   point;
+
+
+    if ( CUR.top < CUR.GS.loop + 1 )
+    {
+      CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    if ( CUR.face->unpatented_hinting )
+    {
+      if ( CUR.GS.both_x_axis )
+      {
+        dx = TT_MulFix14( args[0], 0x4000 );
+        dy = 0;
+      }
+      else
+      {
+        dx = 0;
+        dy = TT_MulFix14( args[0], 0x4000 );
+      }
+    }
+    else
+#endif
+    {
+      dx = TT_MulFix14( args[0], CUR.GS.freeVector.x );
+      dy = TT_MulFix14( args[0], CUR.GS.freeVector.y );
+    }
+
+    while ( CUR.GS.loop > 0 )
+    {
+      CUR.args--;
+
+      point = (FT_UShort)CUR.stack[CUR.args];
+
+      if ( BOUNDS( point, CUR.zp2.n_points ) )
+      {
+        if ( CUR.pedantic_hinting )
+        {
+          CUR.error = TT_Err_Invalid_Reference;
+          return;
+        }
+      }
+      else
+        MOVE_Zp2_Point( point, dx, dy, TRUE );
+
+      CUR.GS.loop--;
+    }
+
+    CUR.GS.loop = 1;
+    CUR.new_top = CUR.args;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MSIRP[a]:     Move Stack Indirect Relative Position                   */
+  /* Opcode range: 0x3A-0x3B                                               */
+  /* Stack:        f26.6 uint32 -->                                        */
+  /*                                                                       */
+  static void
+  Ins_MSIRP( INS_ARG )
+  {
+    FT_UShort   point;
+    FT_F26Dot6  distance;
+
+
+    point = (FT_UShort)args[0];
+
+    if ( BOUNDS( point,      CUR.zp1.n_points ) ||
+         BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    /* XXX: UNDOCUMENTED! behaviour */
+    if ( CUR.GS.gep1 == 0 )   /* if the point that is to be moved */
+                              /* is in twilight zone              */
+    {
+      CUR.zp1.org[point] = CUR.zp0.org[CUR.GS.rp0];
+      CUR_Func_move_orig( &CUR.zp1, point, args[1] );
+      CUR.zp1.cur[point] = CUR.zp1.org[point];
+    }
+
+    distance = CUR_Func_project( CUR.zp1.cur + point,
+                                 CUR.zp0.cur + CUR.GS.rp0 );
+
+    CUR_Func_move( &CUR.zp1, point, args[1] - distance );
+
+    CUR.GS.rp1 = CUR.GS.rp0;
+    CUR.GS.rp2 = point;
+
+    if ( (CUR.opcode & 1) != 0 )
+      CUR.GS.rp0 = point;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MDAP[a]:      Move Direct Absolute Point                              */
+  /* Opcode range: 0x2E-0x2F                                               */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_MDAP( INS_ARG )
+  {
+    FT_UShort   point;
+    FT_F26Dot6  cur_dist,
+                distance;
+
+
+    point = (FT_UShort)args[0];
+
+    if ( BOUNDS( point, CUR.zp0.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    /* XXX: Is there some undocumented feature while in the */
+    /*      twilight zone? ?                                */
+    if ( ( CUR.opcode & 1 ) != 0 )
+    {
+      cur_dist = CUR_Func_project( CUR.zp0.cur + point, NULL_Vector );
+      distance = CUR_Func_round( cur_dist,
+                                 CUR.tt_metrics.compensations[0] ) - cur_dist;
+    }
+    else
+      distance = 0;
+
+    CUR_Func_move( &CUR.zp0, point, distance );
+
+    CUR.GS.rp0 = point;
+    CUR.GS.rp1 = point;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MIAP[a]:      Move Indirect Absolute Point                            */
+  /* Opcode range: 0x3E-0x3F                                               */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_MIAP( INS_ARG )
+  {
+    FT_ULong    cvtEntry;
+    FT_UShort   point;
+    FT_F26Dot6  distance,
+                org_dist;
+
+
+    cvtEntry = (FT_ULong)args[1];
+    point    = (FT_UShort)args[0];
+
+    if ( BOUNDS( point,    CUR.zp0.n_points ) ||
+         BOUNDS( cvtEntry, CUR.cvtSize )      )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    /* UNDOCUMENTED!                                     */
+    /*                                                   */
+    /* The behaviour of an MIAP instruction is quite     */
+    /* different when used in the twilight zone.         */
+    /*                                                   */
+    /* First, no control value cutin test is performed   */
+    /* as it would fail anyway.  Second, the original    */
+    /* point, i.e. (org_x,org_y) of zp0.point, is set    */
+    /* to the absolute, unrounded distance found in      */
+    /* the CVT.                                          */
+    /*                                                   */
+    /* This is used in the CVT programs of the Microsoft */
+    /* fonts Arial, Times, etc., in order to re-adjust   */
+    /* some key font heights.  It allows the use of the  */
+    /* IP instruction in the twilight zone, which        */
+    /* otherwise would be `illegal' according to the     */
+    /* specification.                                    */
+    /*                                                   */
+    /* We implement it with a special sequence for the   */
+    /* twilight zone.  This is a bad hack, but it seems  */
+    /* to work.                                          */
+
+    distance = CUR_Func_read_cvt( cvtEntry );
+
+    if ( CUR.GS.gep0 == 0 )   /* If in twilight zone */
+    {
+      CUR.zp0.org[point].x = TT_MulFix14( distance, CUR.GS.freeVector.x );
+      CUR.zp0.org[point].y = TT_MulFix14( distance, CUR.GS.freeVector.y ),
+      CUR.zp0.cur[point]   = CUR.zp0.org[point];
+    }
+
+    org_dist = CUR_Func_project( CUR.zp0.cur + point, NULL_Vector );
+
+    if ( ( CUR.opcode & 1 ) != 0 )   /* rounding and control cutin flag */
+    {
+      if ( FT_ABS( distance - org_dist ) > CUR.GS.control_value_cutin )
+        distance = org_dist;
+
+      distance = CUR_Func_round( distance, CUR.tt_metrics.compensations[0] );
+    }
+
+    CUR_Func_move( &CUR.zp0, point, distance - org_dist );
+
+    CUR.GS.rp0 = point;
+    CUR.GS.rp1 = point;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MDRP[abcde]:  Move Direct Relative Point                              */
+  /* Opcode range: 0xC0-0xDF                                               */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_MDRP( INS_ARG )
+  {
+    FT_UShort   point;
+    FT_F26Dot6  org_dist, distance;
+
+
+    point = (FT_UShort)args[0];
+
+    if ( BOUNDS( point,      CUR.zp1.n_points ) ||
+         BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    /* XXX: Is there some undocumented feature while in the */
+    /*      twilight zone?                                  */
+
+    org_dist = CUR_Func_dualproj( CUR.zp1.org + point,
+                                  CUR.zp0.org + CUR.GS.rp0 );
+
+    /* single width cutin test */
+
+    if ( FT_ABS( org_dist - CUR.GS.single_width_value ) <
+         CUR.GS.single_width_cutin )
+    {
+      if ( org_dist >= 0 )
+        org_dist = CUR.GS.single_width_value;
+      else
+        org_dist = -CUR.GS.single_width_value;
+    }
+
+    /* round flag */
+
+    if ( ( CUR.opcode & 4 ) != 0 )
+      distance = CUR_Func_round(
+                   org_dist,
+                   CUR.tt_metrics.compensations[CUR.opcode & 3] );
+    else
+      distance = ROUND_None(
+                   org_dist,
+                   CUR.tt_metrics.compensations[CUR.opcode & 3] );
+
+    /* minimum distance flag */
+
+    if ( ( CUR.opcode & 8 ) != 0 )
+    {
+      if ( org_dist >= 0 )
+      {
+        if ( distance < CUR.GS.minimum_distance )
+          distance = CUR.GS.minimum_distance;
+      }
+      else
+      {
+        if ( distance > -CUR.GS.minimum_distance )
+          distance = -CUR.GS.minimum_distance;
+      }
+    }
+
+    /* now move the point */
+
+    org_dist = CUR_Func_project( CUR.zp1.cur + point,
+                                 CUR.zp0.cur + CUR.GS.rp0 );
+
+    CUR_Func_move( &CUR.zp1, point, distance - org_dist );
+
+    CUR.GS.rp1 = CUR.GS.rp0;
+    CUR.GS.rp2 = point;
+
+    if ( ( CUR.opcode & 16 ) != 0 )
+      CUR.GS.rp0 = point;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MIRP[abcde]:  Move Indirect Relative Point                            */
+  /* Opcode range: 0xE0-0xFF                                               */
+  /* Stack:        int32? uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_MIRP( INS_ARG )
+  {
+    FT_UShort   point;
+    FT_ULong    cvtEntry;
+
+    FT_F26Dot6  cvt_dist,
+                distance,
+                cur_dist,
+                org_dist;
+
+
+    point    = (FT_UShort)args[0];
+    cvtEntry = (FT_ULong)( args[1] + 1 );
+
+    /* XXX: UNDOCUMENTED! cvt[-1] = 0 always */
+
+    if ( BOUNDS( point,      CUR.zp1.n_points ) ||
+         BOUNDS( cvtEntry,   CUR.cvtSize + 1 )  ||
+         BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    if ( !cvtEntry )
+      cvt_dist = 0;
+    else
+      cvt_dist = CUR_Func_read_cvt( cvtEntry - 1 );
+
+    /* single width test */
+
+    if ( FT_ABS( cvt_dist - CUR.GS.single_width_value ) <
+         CUR.GS.single_width_cutin )
+    {
+      if ( cvt_dist >= 0 )
+        cvt_dist =  CUR.GS.single_width_value;
+      else
+        cvt_dist = -CUR.GS.single_width_value;
+    }
+
+    /* XXX: UNDOCUMENTED! -- twilight zone */
+
+    if ( CUR.GS.gep1 == 0 )
+    {
+      CUR.zp1.org[point].x = CUR.zp0.org[CUR.GS.rp0].x +
+                             TT_MulFix14( cvt_dist, CUR.GS.freeVector.x );
+
+      CUR.zp1.org[point].y = CUR.zp0.org[CUR.GS.rp0].y +
+                             TT_MulFix14( cvt_dist, CUR.GS.freeVector.y );
+
+      CUR.zp1.cur[point] = CUR.zp1.org[point];
+    }
+
+    org_dist = CUR_Func_dualproj( CUR.zp1.org + point,
+                                  CUR.zp0.org + CUR.GS.rp0 );
+
+    cur_dist = CUR_Func_project( CUR.zp1.cur + point,
+                                 CUR.zp0.cur + CUR.GS.rp0 );
+
+    /* auto-flip test */
+
+    if ( CUR.GS.auto_flip )
+    {
+      if ( ( org_dist ^ cvt_dist ) < 0 )
+        cvt_dist = -cvt_dist;
+    }
+
+    /* control value cutin and round */
+
+    if ( ( CUR.opcode & 4 ) != 0 )
+    {
+      /* XXX: UNDOCUMENTED!  Only perform cut-in test when both points */
+      /*      refer to the same zone.                                  */
+
+      if ( CUR.GS.gep0 == CUR.GS.gep1 )
+        if ( FT_ABS( cvt_dist - org_dist ) >= CUR.GS.control_value_cutin )
+          cvt_dist = org_dist;
+
+      distance = CUR_Func_round(
+                   cvt_dist,
+                   CUR.tt_metrics.compensations[CUR.opcode & 3] );
+    }
+    else
+      distance = ROUND_None(
+                   cvt_dist,
+                   CUR.tt_metrics.compensations[CUR.opcode & 3] );
+
+    /* minimum distance test */
+
+    if ( ( CUR.opcode & 8 ) != 0 )
+    {
+      if ( org_dist >= 0 )
+      {
+        if ( distance < CUR.GS.minimum_distance )
+          distance = CUR.GS.minimum_distance;
+      }
+      else
+      {
+        if ( distance > -CUR.GS.minimum_distance )
+          distance = -CUR.GS.minimum_distance;
+      }
+    }
+
+    CUR_Func_move( &CUR.zp1, point, distance - cur_dist );
+
+    CUR.GS.rp1 = CUR.GS.rp0;
+
+    if ( ( CUR.opcode & 16 ) != 0 )
+      CUR.GS.rp0 = point;
+
+    /* XXX: UNDOCUMENTED! */
+
+    CUR.GS.rp2 = point;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ALIGNRP[]:    ALIGN Relative Point                                    */
+  /* Opcode range: 0x3C                                                    */
+  /* Stack:        uint32 uint32... -->                                    */
+  /*                                                                       */
+  static void
+  Ins_ALIGNRP( INS_ARG )
+  {
+    FT_UShort   point;
+    FT_F26Dot6  distance;
+
+    FT_UNUSED_ARG;
+
+
+    if ( CUR.top < CUR.GS.loop ||
+         BOUNDS( CUR.GS.rp0, CUR.zp0.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    while ( CUR.GS.loop > 0 )
+    {
+      CUR.args--;
+
+      point = (FT_UShort)CUR.stack[CUR.args];
+
+      if ( BOUNDS( point, CUR.zp1.n_points ) )
+      {
+        if ( CUR.pedantic_hinting )
+        {
+          CUR.error = TT_Err_Invalid_Reference;
+          return;
+        }
+      }
+      else
+      {
+        distance = CUR_Func_project( CUR.zp1.cur + point,
+                                     CUR.zp0.cur + CUR.GS.rp0 );
+
+        CUR_Func_move( &CUR.zp1, point, -distance );
+      }
+
+      CUR.GS.loop--;
+    }
+
+    CUR.GS.loop = 1;
+    CUR.new_top = CUR.args;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ISECT[]:      moves point to InterSECTion                             */
+  /* Opcode range: 0x0F                                                    */
+  /* Stack:        5 * uint32 -->                                          */
+  /*                                                                       */
+  static void
+  Ins_ISECT( INS_ARG )
+  {
+    FT_UShort   point,
+                a0, a1,
+                b0, b1;
+
+    FT_F26Dot6  discriminant;
+
+    FT_F26Dot6  dx,  dy,
+                dax, day,
+                dbx, dby;
+
+    FT_F26Dot6  val;
+
+    FT_Vector   R;
+
+
+    point = (FT_UShort)args[0];
+
+    a0 = (FT_UShort)args[1];
+    a1 = (FT_UShort)args[2];
+    b0 = (FT_UShort)args[3];
+    b1 = (FT_UShort)args[4];
+
+    if ( BOUNDS( b0, CUR.zp0.n_points )  ||
+         BOUNDS( b1, CUR.zp0.n_points )  ||
+         BOUNDS( a0, CUR.zp1.n_points )  ||
+         BOUNDS( a1, CUR.zp1.n_points )  ||
+         BOUNDS( point, CUR.zp2.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    dbx = CUR.zp0.cur[b1].x - CUR.zp0.cur[b0].x;
+    dby = CUR.zp0.cur[b1].y - CUR.zp0.cur[b0].y;
+
+    dax = CUR.zp1.cur[a1].x - CUR.zp1.cur[a0].x;
+    day = CUR.zp1.cur[a1].y - CUR.zp1.cur[a0].y;
+
+    dx = CUR.zp0.cur[b0].x - CUR.zp1.cur[a0].x;
+    dy = CUR.zp0.cur[b0].y - CUR.zp1.cur[a0].y;
+
+    CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_BOTH;
+
+    discriminant = TT_MULDIV( dax, -dby, 0x40 ) +
+                   TT_MULDIV( day, dbx, 0x40 );
+
+    if ( FT_ABS( discriminant ) >= 0x40 )
+    {
+      val = TT_MULDIV( dx, -dby, 0x40 ) + TT_MULDIV( dy, dbx, 0x40 );
+
+      R.x = TT_MULDIV( val, dax, discriminant );
+      R.y = TT_MULDIV( val, day, discriminant );
+
+      CUR.zp2.cur[point].x = CUR.zp1.cur[a0].x + R.x;
+      CUR.zp2.cur[point].y = CUR.zp1.cur[a0].y + R.y;
+    }
+    else
+    {
+      /* else, take the middle of the middles of A and B */
+
+      CUR.zp2.cur[point].x = ( CUR.zp1.cur[a0].x +
+                               CUR.zp1.cur[a1].x +
+                               CUR.zp0.cur[b0].x +
+                               CUR.zp0.cur[b1].x ) / 4;
+      CUR.zp2.cur[point].y = ( CUR.zp1.cur[a0].y +
+                               CUR.zp1.cur[a1].y +
+                               CUR.zp0.cur[b0].y +
+                               CUR.zp0.cur[b1].y ) / 4;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ALIGNPTS[]:   ALIGN PoinTS                                            */
+  /* Opcode range: 0x27                                                    */
+  /* Stack:        uint32 uint32 -->                                       */
+  /*                                                                       */
+  static void
+  Ins_ALIGNPTS( INS_ARG )
+  {
+    FT_UShort   p1, p2;
+    FT_F26Dot6  distance;
+
+
+    p1 = (FT_UShort)args[0];
+    p2 = (FT_UShort)args[1];
+
+    if ( BOUNDS( args[0], CUR.zp1.n_points ) ||
+         BOUNDS( args[1], CUR.zp0.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    distance = CUR_Func_project( CUR.zp0.cur + p2,
+                                 CUR.zp1.cur + p1 ) / 2;
+
+    CUR_Func_move( &CUR.zp1, p1, distance );
+    CUR_Func_move( &CUR.zp0, p2, -distance );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* IP[]:         Interpolate Point                                       */
+  /* Opcode range: 0x39                                                    */
+  /* Stack:        uint32... -->                                           */
+  /*                                                                       */
+  static void
+  Ins_IP( INS_ARG )
+  {
+    FT_F26Dot6  org_a, org_b, org_x,
+                cur_a, cur_b, cur_x,
+                distance;
+    FT_UShort   point;
+
+    FT_UNUSED_ARG;
+
+
+    if ( CUR.top < CUR.GS.loop )
+    {
+      CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    /* XXX: There are some glyphs in some braindead but popular  */
+    /*      fonts out there (e.g. [aeu]grave in monotype.ttf)    */
+    /*      calling IP[] with bad values of rp[12].              */
+    /*      Do something sane when this odd thing happens.       */
+
+    if ( BOUNDS( CUR.GS.rp1, CUR.zp0.n_points ) ||
+         BOUNDS( CUR.GS.rp2, CUR.zp1.n_points ) )
+    {
+      org_a = cur_a = 0;
+      org_b = cur_b = 0;
+    }
+    else
+    {
+      org_a = CUR_Func_dualproj( CUR.zp0.org + CUR.GS.rp1, NULL_Vector );
+      org_b = CUR_Func_dualproj( CUR.zp1.org + CUR.GS.rp2, NULL_Vector );
+
+      cur_a = CUR_Func_project( CUR.zp0.cur + CUR.GS.rp1, NULL_Vector );
+      cur_b = CUR_Func_project( CUR.zp1.cur + CUR.GS.rp2, NULL_Vector );
+    }
+
+    while ( CUR.GS.loop > 0 )
+    {
+      CUR.args--;
+
+      point = (FT_UShort)CUR.stack[CUR.args];
+      if ( BOUNDS( point, CUR.zp2.n_points ) )
+      {
+        if ( CUR.pedantic_hinting )
+        {
+          CUR.error = TT_Err_Invalid_Reference;
+          return;
+        }
+      }
+      else
+      {
+        org_x = CUR_Func_dualproj( CUR.zp2.org + point, NULL_Vector );
+        cur_x = CUR_Func_project ( CUR.zp2.cur + point, NULL_Vector );
+
+        if ( ( org_a <= org_b && org_x <= org_a ) ||
+             ( org_a >  org_b && org_x >= org_a ) )
+
+          distance = ( cur_a - org_a ) + ( org_x - cur_x );
+
+        else if ( ( org_a <= org_b  &&  org_x >= org_b ) ||
+                  ( org_a >  org_b  &&  org_x <  org_b ) )
+
+          distance = ( cur_b - org_b ) + ( org_x - cur_x );
+
+        else
+           /* note: it seems that rounding this value isn't a good */
+           /*       idea (cf. width of capital `S' in Times)       */
+
+           distance = TT_MULDIV( cur_b - cur_a,
+                                 org_x - org_a,
+                                 org_b - org_a ) + ( cur_a - cur_x );
+
+        CUR_Func_move( &CUR.zp2, point, distance );
+      }
+
+      CUR.GS.loop--;
+    }
+
+    CUR.GS.loop = 1;
+    CUR.new_top = CUR.args;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* UTP[a]:       UnTouch Point                                           */
+  /* Opcode range: 0x29                                                    */
+  /* Stack:        uint32 -->                                              */
+  /*                                                                       */
+  static void
+  Ins_UTP( INS_ARG )
+  {
+    FT_UShort  point;
+    FT_Byte    mask;
+
+
+    point = (FT_UShort)args[0];
+
+    if ( BOUNDS( point, CUR.zp0.n_points ) )
+    {
+      if ( CUR.pedantic_hinting )
+        CUR.error = TT_Err_Invalid_Reference;
+      return;
+    }
+
+    mask = 0xFF;
+
+    if ( CUR.GS.freeVector.x != 0 )
+      mask &= ~FT_CURVE_TAG_TOUCH_X;
+
+    if ( CUR.GS.freeVector.y != 0 )
+      mask &= ~FT_CURVE_TAG_TOUCH_Y;
+
+    CUR.zp0.tags[point] &= mask;
+  }
+
+
+  /* Local variables for Ins_IUP: */
+  struct  LOC_Ins_IUP
+  {
+    FT_Vector*  orgs;   /* original and current coordinate */
+    FT_Vector*  curs;   /* arrays                          */
+  };
+
+
+  static void
+  Shift( FT_UInt              p1,
+         FT_UInt              p2,
+         FT_UInt              p,
+         struct LOC_Ins_IUP*  LINK )
+  {
+    FT_UInt     i;
+    FT_F26Dot6  x;
+
+
+    x = LINK->curs[p].x - LINK->orgs[p].x;
+
+    for ( i = p1; i < p; i++ )
+      LINK->curs[i].x += x;
+
+    for ( i = p + 1; i <= p2; i++ )
+      LINK->curs[i].x += x;
+  }
+
+
+  static void
+  Interp( FT_UInt              p1,
+          FT_UInt              p2,
+          FT_UInt              ref1,
+          FT_UInt              ref2,
+          struct LOC_Ins_IUP*  LINK )
+  {
+    FT_UInt     i;
+    FT_F26Dot6  x, x1, x2, d1, d2;
+
+
+    if ( p1 > p2 )
+      return;
+
+    x1 = LINK->orgs[ref1].x;
+    d1 = LINK->curs[ref1].x - LINK->orgs[ref1].x;
+    x2 = LINK->orgs[ref2].x;
+    d2 = LINK->curs[ref2].x - LINK->orgs[ref2].x;
+
+    if ( x1 == x2 )
+    {
+      for ( i = p1; i <= p2; i++ )
+      {
+        x = LINK->orgs[i].x;
+
+        if ( x <= x1 )
+          x += d1;
+        else
+          x += d2;
+
+        LINK->curs[i].x = x;
+      }
+      return;
+    }
+
+    if ( x1 < x2 )
+    {
+      for ( i = p1; i <= p2; i++ )
+      {
+        x = LINK->orgs[i].x;
+
+        if ( x <= x1 )
+          x += d1;
+        else
+        {
+          if ( x >= x2 )
+            x += d2;
+          else
+            x = LINK->curs[ref1].x +
+                  TT_MULDIV( x - x1,
+                             LINK->curs[ref2].x - LINK->curs[ref1].x,
+                             x2 - x1 );
+        }
+        LINK->curs[i].x = x;
+      }
+      return;
+    }
+
+    /* x2 < x1 */
+
+    for ( i = p1; i <= p2; i++ )
+    {
+      x = LINK->orgs[i].x;
+      if ( x <= x2 )
+        x += d2;
+      else
+      {
+        if ( x >= x1 )
+          x += d1;
+        else
+          x = LINK->curs[ref1].x +
+              TT_MULDIV( x - x1,
+                         LINK->curs[ref2].x - LINK->curs[ref1].x,
+                         x2 - x1 );
+      }
+      LINK->curs[i].x = x;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* IUP[a]:       Interpolate Untouched Points                            */
+  /* Opcode range: 0x30-0x31                                               */
+  /* Stack:        -->                                                     */
+  /*                                                                       */
+  static void
+  Ins_IUP( INS_ARG )
+  {
+    struct LOC_Ins_IUP  V;
+    FT_Byte             mask;
+
+    FT_UInt   first_point;   /* first point of contour        */
+    FT_UInt   end_point;     /* end point (last+1) of contour */
+
+    FT_UInt   first_touched; /* first touched point in contour   */
+    FT_UInt   cur_touched;   /* current touched point in contour */
+
+    FT_UInt   point;         /* current point   */
+    FT_Short  contour;       /* current contour */
+
+    FT_UNUSED_ARG;
+
+
+    if ( CUR.opcode & 1 )
+    {
+      mask   = FT_CURVE_TAG_TOUCH_X;
+      V.orgs = CUR.pts.org;
+      V.curs = CUR.pts.cur;
+    }
+    else
+    {
+      mask   = FT_CURVE_TAG_TOUCH_Y;
+      V.orgs = (FT_Vector*)( (FT_Pos*)CUR.pts.org + 1 );
+      V.curs = (FT_Vector*)( (FT_Pos*)CUR.pts.cur + 1 );
+    }
+
+    contour = 0;
+    point   = 0;
+
+    do
+    {
+      end_point   = CUR.pts.contours[contour];
+      first_point = point;
+
+      while ( point <= end_point && (CUR.pts.tags[point] & mask) == 0 )
+        point++;
+
+      if ( point <= end_point )
+      {
+        first_touched = point;
+        cur_touched   = point;
+
+        point++;
+
+        while ( point <= end_point )
+        {
+          if ( ( CUR.pts.tags[point] & mask ) != 0 )
+          {
+            if ( point > 0 )
+              Interp( cur_touched + 1,
+                      point - 1,
+                      cur_touched,
+                      point,
+                      &V );
+            cur_touched = point;
+          }
+
+          point++;
+        }
+
+        if ( cur_touched == first_touched )
+          Shift( first_point, end_point, cur_touched, &V );
+        else
+        {
+          Interp( (FT_UShort)( cur_touched + 1 ),
+                  end_point,
+                  cur_touched,
+                  first_touched,
+                  &V );
+
+          if ( first_touched > 0 )
+            Interp( first_point,
+                    first_touched - 1,
+                    cur_touched,
+                    first_touched,
+                    &V );
+        }
+      }
+      contour++;
+    } while ( contour < CUR.pts.n_contours );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DELTAPn[]:    DELTA exceptions P1, P2, P3                             */
+  /* Opcode range: 0x5D,0x71,0x72                                          */
+  /* Stack:        uint32 (2 * uint32)... -->                              */
+  /*                                                                       */
+  static void
+  Ins_DELTAP( INS_ARG )
+  {
+    FT_ULong   k, nump;
+    FT_UShort  A;
+    FT_ULong   C;
+    FT_Long    B;
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    /* Delta hinting is covered by US Patent 5159668. */
+    if ( CUR.face->unpatented_hinting )
+      {
+      FT_Long n = args[0] * 2;
+      if ( CUR.args < n )
+      {
+        CUR.error = TT_Err_Too_Few_Arguments;
+        return;
+      }
+
+      CUR.args -= n;
+      CUR.new_top = CUR.args;
+      return;
+    }
+#endif
+
+    nump = (FT_ULong)args[0];   /* some points theoretically may occur more
+                                   than once, thus UShort isn't enough */
+
+    for ( k = 1; k <= nump; k++ )
+    {
+      if ( CUR.args < 2 )
+      {
+        CUR.error = TT_Err_Too_Few_Arguments;
+        return;
+      }
+
+      CUR.args -= 2;
+
+      A = (FT_UShort)CUR.stack[CUR.args + 1];
+      B = CUR.stack[CUR.args];
+
+      /* XXX: Because some popular fonts contain some invalid DeltaP */
+      /*      instructions, we simply ignore them when the stacked   */
+      /*      point reference is off limit, rather than returning an */
+      /*      error.  As a delta instruction doesn't change a glyph  */
+      /*      in great ways, this shouldn't be a problem.            */
+
+      if ( !BOUNDS( A, CUR.zp0.n_points ) )
+      {
+        C = ( (FT_ULong)B & 0xF0 ) >> 4;
+
+        switch ( CUR.opcode )
+        {
+        case 0x5D:
+          break;
+
+        case 0x71:
+          C += 16;
+          break;
+
+        case 0x72:
+          C += 32;
+          break;
+        }
+
+        C += CUR.GS.delta_base;
+
+        if ( CURRENT_Ppem() == (FT_Long)C )
+        {
+          B = ( (FT_ULong)B & 0xF ) - 8;
+          if ( B >= 0 )
+            B++;
+          B = B * 64 / ( 1L << CUR.GS.delta_shift );
+
+          CUR_Func_move( &CUR.zp0, A, B );
+        }
+      }
+      else
+        if ( CUR.pedantic_hinting )
+          CUR.error = TT_Err_Invalid_Reference;
+    }
+
+    CUR.new_top = CUR.args;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DELTACn[]:    DELTA exceptions C1, C2, C3                             */
+  /* Opcode range: 0x73,0x74,0x75                                          */
+  /* Stack:        uint32 (2 * uint32)... -->                              */
+  /*                                                                       */
+  static void
+  Ins_DELTAC( INS_ARG )
+  {
+    FT_ULong  nump, k;
+    FT_ULong  A, C;
+    FT_Long   B;
+
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    /* Delta hinting is covered by US Patent 5159668. */
+    if ( CUR.face->unpatented_hinting )
+    {
+      FT_Long  n = args[0] * 2;
+
+
+      if ( CUR.args < n )
+      {
+        CUR.error = TT_Err_Too_Few_Arguments;
+        return;
+      }
+
+      CUR.args -= n;
+      CUR.new_top = CUR.args;
+      return;
+    }
+#endif
+
+    nump = (FT_ULong)args[0];
+
+    for ( k = 1; k <= nump; k++ )
+    {
+      if ( CUR.args < 2 )
+      {
+        CUR.error = TT_Err_Too_Few_Arguments;
+        return;
+      }
+
+      CUR.args -= 2;
+
+      A = (FT_ULong)CUR.stack[CUR.args + 1];
+      B = CUR.stack[CUR.args];
+
+      if ( BOUNDS( A, CUR.cvtSize ) )
+      {
+        if ( CUR.pedantic_hinting )
+        {
+          CUR.error = TT_Err_Invalid_Reference;
+          return;
+        }
+      }
+      else
+      {
+        C = ( (FT_ULong)B & 0xF0 ) >> 4;
+
+        switch ( CUR.opcode )
+        {
+        case 0x73:
+          break;
+
+        case 0x74:
+          C += 16;
+          break;
+
+        case 0x75:
+          C += 32;
+          break;
+        }
+
+        C += CUR.GS.delta_base;
+
+        if ( CURRENT_Ppem() == (FT_Long)C )
+        {
+          B = ( (FT_ULong)B & 0xF ) - 8;
+          if ( B >= 0 )
+            B++;
+          B = B * 64 / ( 1L << CUR.GS.delta_shift );
+
+          CUR_Func_move_cvt( A, B );
+        }
+      }
+    }
+
+    CUR.new_top = CUR.args;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* MISC. INSTRUCTIONS                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* GETINFO[]:    GET INFOrmation                                         */
+  /* Opcode range: 0x88                                                    */
+  /* Stack:        uint32 --> uint32                                       */
+  /*                                                                       */
+  /* XXX: According to Apple specs, bits 1 & 2 of the argument ought to be */
+  /*      consulted before rotated/stretched info is returned.             */
+  static void
+  Ins_GETINFO( INS_ARG )
+  {
+    FT_Long  K;
+
+
+    K = 0;
+
+    /* We return then Windows 3.1 version number */
+    /* for the font scaler                       */
+    if ( ( args[0] & 1 ) != 0 )
+      K = 3;
+
+    /* Has the glyph been rotated ? */
+    if ( CUR.tt_metrics.rotated )
+      K |= 0x80;
+
+    /* Has the glyph been stretched ? */
+    if ( CUR.tt_metrics.stretched )
+      K |= 0x100;
+
+    args[0] = K;
+  }
+
+
+  static void
+  Ins_UNKNOWN( INS_ARG )
+  {
+    TT_DefRecord*  def   = CUR.IDefs;
+    TT_DefRecord*  limit = def + CUR.numIDefs;
+
+    FT_UNUSED_ARG;
+
+
+    for ( ; def < limit; def++ )
+    {
+      if ( (FT_Byte)def->opc == CUR.opcode && def->active )
+      {
+        TT_CallRec*  call;
+
+
+        if ( CUR.callTop >= CUR.callSize )
+        {
+          CUR.error = TT_Err_Stack_Overflow;
+          return;
+        }
+
+        call = CUR.callStack + CUR.callTop++;
+
+        call->Caller_Range = CUR.curRange;
+        call->Caller_IP    = CUR.IP+1;
+        call->Cur_Count    = 1;
+        call->Cur_Restart  = def->start;
+
+        INS_Goto_CodeRange( def->range, def->start );
+
+        CUR.step_ins = FALSE;
+        return;
+      }
+    }
+
+    CUR.error = TT_Err_Invalid_Opcode;
+  }
+
+
+#ifndef TT_CONFIG_OPTION_INTERPRETER_SWITCH
+
+
+  static
+  TInstruction_Function  Instruct_Dispatch[256] =
+  {
+    /* Opcodes are gathered in groups of 16. */
+    /* Please keep the spaces as they are.   */
+
+    /*  SVTCA  y  */  Ins_SVTCA,
+    /*  SVTCA  x  */  Ins_SVTCA,
+    /*  SPvTCA y  */  Ins_SPVTCA,
+    /*  SPvTCA x  */  Ins_SPVTCA,
+    /*  SFvTCA y  */  Ins_SFVTCA,
+    /*  SFvTCA x  */  Ins_SFVTCA,
+    /*  SPvTL //  */  Ins_SPVTL,
+    /*  SPvTL +   */  Ins_SPVTL,
+    /*  SFvTL //  */  Ins_SFVTL,
+    /*  SFvTL +   */  Ins_SFVTL,
+    /*  SPvFS     */  Ins_SPVFS,
+    /*  SFvFS     */  Ins_SFVFS,
+    /*  GPV       */  Ins_GPV,
+    /*  GFV       */  Ins_GFV,
+    /*  SFvTPv    */  Ins_SFVTPV,
+    /*  ISECT     */  Ins_ISECT,
+
+    /*  SRP0      */  Ins_SRP0,
+    /*  SRP1      */  Ins_SRP1,
+    /*  SRP2      */  Ins_SRP2,
+    /*  SZP0      */  Ins_SZP0,
+    /*  SZP1      */  Ins_SZP1,
+    /*  SZP2      */  Ins_SZP2,
+    /*  SZPS      */  Ins_SZPS,
+    /*  SLOOP     */  Ins_SLOOP,
+    /*  RTG       */  Ins_RTG,
+    /*  RTHG      */  Ins_RTHG,
+    /*  SMD       */  Ins_SMD,
+    /*  ELSE      */  Ins_ELSE,
+    /*  JMPR      */  Ins_JMPR,
+    /*  SCvTCi    */  Ins_SCVTCI,
+    /*  SSwCi     */  Ins_SSWCI,
+    /*  SSW       */  Ins_SSW,
+
+    /*  DUP       */  Ins_DUP,
+    /*  POP       */  Ins_POP,
+    /*  CLEAR     */  Ins_CLEAR,
+    /*  SWAP      */  Ins_SWAP,
+    /*  DEPTH     */  Ins_DEPTH,
+    /*  CINDEX    */  Ins_CINDEX,
+    /*  MINDEX    */  Ins_MINDEX,
+    /*  AlignPTS  */  Ins_ALIGNPTS,
+    /*  INS_0x28  */  Ins_UNKNOWN,
+    /*  UTP       */  Ins_UTP,
+    /*  LOOPCALL  */  Ins_LOOPCALL,
+    /*  CALL      */  Ins_CALL,
+    /*  FDEF      */  Ins_FDEF,
+    /*  ENDF      */  Ins_ENDF,
+    /*  MDAP[0]   */  Ins_MDAP,
+    /*  MDAP[1]   */  Ins_MDAP,
+
+    /*  IUP[0]    */  Ins_IUP,
+    /*  IUP[1]    */  Ins_IUP,
+    /*  SHP[0]    */  Ins_SHP,
+    /*  SHP[1]    */  Ins_SHP,
+    /*  SHC[0]    */  Ins_SHC,
+    /*  SHC[1]    */  Ins_SHC,
+    /*  SHZ[0]    */  Ins_SHZ,
+    /*  SHZ[1]    */  Ins_SHZ,
+    /*  SHPIX     */  Ins_SHPIX,
+    /*  IP        */  Ins_IP,
+    /*  MSIRP[0]  */  Ins_MSIRP,
+    /*  MSIRP[1]  */  Ins_MSIRP,
+    /*  AlignRP   */  Ins_ALIGNRP,
+    /*  RTDG      */  Ins_RTDG,
+    /*  MIAP[0]   */  Ins_MIAP,
+    /*  MIAP[1]   */  Ins_MIAP,
+
+    /*  NPushB    */  Ins_NPUSHB,
+    /*  NPushW    */  Ins_NPUSHW,
+    /*  WS        */  Ins_WS,
+    /*  RS        */  Ins_RS,
+    /*  WCvtP     */  Ins_WCVTP,
+    /*  RCvt      */  Ins_RCVT,
+    /*  GC[0]     */  Ins_GC,
+    /*  GC[1]     */  Ins_GC,
+    /*  SCFS      */  Ins_SCFS,
+    /*  MD[0]     */  Ins_MD,
+    /*  MD[1]     */  Ins_MD,
+    /*  MPPEM     */  Ins_MPPEM,
+    /*  MPS       */  Ins_MPS,
+    /*  FlipON    */  Ins_FLIPON,
+    /*  FlipOFF   */  Ins_FLIPOFF,
+    /*  DEBUG     */  Ins_DEBUG,
+
+    /*  LT        */  Ins_LT,
+    /*  LTEQ      */  Ins_LTEQ,
+    /*  GT        */  Ins_GT,
+    /*  GTEQ      */  Ins_GTEQ,
+    /*  EQ        */  Ins_EQ,
+    /*  NEQ       */  Ins_NEQ,
+    /*  ODD       */  Ins_ODD,
+    /*  EVEN      */  Ins_EVEN,
+    /*  IF        */  Ins_IF,
+    /*  EIF       */  Ins_EIF,
+    /*  AND       */  Ins_AND,
+    /*  OR        */  Ins_OR,
+    /*  NOT       */  Ins_NOT,
+    /*  DeltaP1   */  Ins_DELTAP,
+    /*  SDB       */  Ins_SDB,
+    /*  SDS       */  Ins_SDS,
+
+    /*  ADD       */  Ins_ADD,
+    /*  SUB       */  Ins_SUB,
+    /*  DIV       */  Ins_DIV,
+    /*  MUL       */  Ins_MUL,
+    /*  ABS       */  Ins_ABS,
+    /*  NEG       */  Ins_NEG,
+    /*  FLOOR     */  Ins_FLOOR,
+    /*  CEILING   */  Ins_CEILING,
+    /*  ROUND[0]  */  Ins_ROUND,
+    /*  ROUND[1]  */  Ins_ROUND,
+    /*  ROUND[2]  */  Ins_ROUND,
+    /*  ROUND[3]  */  Ins_ROUND,
+    /*  NROUND[0] */  Ins_NROUND,
+    /*  NROUND[1] */  Ins_NROUND,
+    /*  NROUND[2] */  Ins_NROUND,
+    /*  NROUND[3] */  Ins_NROUND,
+
+    /*  WCvtF     */  Ins_WCVTF,
+    /*  DeltaP2   */  Ins_DELTAP,
+    /*  DeltaP3   */  Ins_DELTAP,
+    /*  DeltaCn[0] */ Ins_DELTAC,
+    /*  DeltaCn[1] */ Ins_DELTAC,
+    /*  DeltaCn[2] */ Ins_DELTAC,
+    /*  SROUND    */  Ins_SROUND,
+    /*  S45Round  */  Ins_S45ROUND,
+    /*  JROT      */  Ins_JROT,
+    /*  JROF      */  Ins_JROF,
+    /*  ROFF      */  Ins_ROFF,
+    /*  INS_0x7B  */  Ins_UNKNOWN,
+    /*  RUTG      */  Ins_RUTG,
+    /*  RDTG      */  Ins_RDTG,
+    /*  SANGW     */  Ins_SANGW,
+    /*  AA        */  Ins_AA,
+
+    /*  FlipPT    */  Ins_FLIPPT,
+    /*  FlipRgON  */  Ins_FLIPRGON,
+    /*  FlipRgOFF */  Ins_FLIPRGOFF,
+    /*  INS_0x83  */  Ins_UNKNOWN,
+    /*  INS_0x84  */  Ins_UNKNOWN,
+    /*  ScanCTRL  */  Ins_SCANCTRL,
+    /*  SDPVTL[0] */  Ins_SDPVTL,
+    /*  SDPVTL[1] */  Ins_SDPVTL,
+    /*  GetINFO   */  Ins_GETINFO,
+    /*  IDEF      */  Ins_IDEF,
+    /*  ROLL      */  Ins_ROLL,
+    /*  MAX       */  Ins_MAX,
+    /*  MIN       */  Ins_MIN,
+    /*  ScanTYPE  */  Ins_SCANTYPE,
+    /*  InstCTRL  */  Ins_INSTCTRL,
+    /*  INS_0x8F  */  Ins_UNKNOWN,
+
+    /*  INS_0x90  */   Ins_UNKNOWN,
+    /*  INS_0x91  */   Ins_UNKNOWN,
+    /*  INS_0x92  */   Ins_UNKNOWN,
+    /*  INS_0x93  */   Ins_UNKNOWN,
+    /*  INS_0x94  */   Ins_UNKNOWN,
+    /*  INS_0x95  */   Ins_UNKNOWN,
+    /*  INS_0x96  */   Ins_UNKNOWN,
+    /*  INS_0x97  */   Ins_UNKNOWN,
+    /*  INS_0x98  */   Ins_UNKNOWN,
+    /*  INS_0x99  */   Ins_UNKNOWN,
+    /*  INS_0x9A  */   Ins_UNKNOWN,
+    /*  INS_0x9B  */   Ins_UNKNOWN,
+    /*  INS_0x9C  */   Ins_UNKNOWN,
+    /*  INS_0x9D  */   Ins_UNKNOWN,
+    /*  INS_0x9E  */   Ins_UNKNOWN,
+    /*  INS_0x9F  */   Ins_UNKNOWN,
+
+    /*  INS_0xA0  */   Ins_UNKNOWN,
+    /*  INS_0xA1  */   Ins_UNKNOWN,
+    /*  INS_0xA2  */   Ins_UNKNOWN,
+    /*  INS_0xA3  */   Ins_UNKNOWN,
+    /*  INS_0xA4  */   Ins_UNKNOWN,
+    /*  INS_0xA5  */   Ins_UNKNOWN,
+    /*  INS_0xA6  */   Ins_UNKNOWN,
+    /*  INS_0xA7  */   Ins_UNKNOWN,
+    /*  INS_0xA8  */   Ins_UNKNOWN,
+    /*  INS_0xA9  */   Ins_UNKNOWN,
+    /*  INS_0xAA  */   Ins_UNKNOWN,
+    /*  INS_0xAB  */   Ins_UNKNOWN,
+    /*  INS_0xAC  */   Ins_UNKNOWN,
+    /*  INS_0xAD  */   Ins_UNKNOWN,
+    /*  INS_0xAE  */   Ins_UNKNOWN,
+    /*  INS_0xAF  */   Ins_UNKNOWN,
+
+    /*  PushB[0]  */  Ins_PUSHB,
+    /*  PushB[1]  */  Ins_PUSHB,
+    /*  PushB[2]  */  Ins_PUSHB,
+    /*  PushB[3]  */  Ins_PUSHB,
+    /*  PushB[4]  */  Ins_PUSHB,
+    /*  PushB[5]  */  Ins_PUSHB,
+    /*  PushB[6]  */  Ins_PUSHB,
+    /*  PushB[7]  */  Ins_PUSHB,
+    /*  PushW[0]  */  Ins_PUSHW,
+    /*  PushW[1]  */  Ins_PUSHW,
+    /*  PushW[2]  */  Ins_PUSHW,
+    /*  PushW[3]  */  Ins_PUSHW,
+    /*  PushW[4]  */  Ins_PUSHW,
+    /*  PushW[5]  */  Ins_PUSHW,
+    /*  PushW[6]  */  Ins_PUSHW,
+    /*  PushW[7]  */  Ins_PUSHW,
+
+    /*  MDRP[00]  */  Ins_MDRP,
+    /*  MDRP[01]  */  Ins_MDRP,
+    /*  MDRP[02]  */  Ins_MDRP,
+    /*  MDRP[03]  */  Ins_MDRP,
+    /*  MDRP[04]  */  Ins_MDRP,
+    /*  MDRP[05]  */  Ins_MDRP,
+    /*  MDRP[06]  */  Ins_MDRP,
+    /*  MDRP[07]  */  Ins_MDRP,
+    /*  MDRP[08]  */  Ins_MDRP,
+    /*  MDRP[09]  */  Ins_MDRP,
+    /*  MDRP[10]  */  Ins_MDRP,
+    /*  MDRP[11]  */  Ins_MDRP,
+    /*  MDRP[12]  */  Ins_MDRP,
+    /*  MDRP[13]  */  Ins_MDRP,
+    /*  MDRP[14]  */  Ins_MDRP,
+    /*  MDRP[15]  */  Ins_MDRP,
+
+    /*  MDRP[16]  */  Ins_MDRP,
+    /*  MDRP[17]  */  Ins_MDRP,
+    /*  MDRP[18]  */  Ins_MDRP,
+    /*  MDRP[19]  */  Ins_MDRP,
+    /*  MDRP[20]  */  Ins_MDRP,
+    /*  MDRP[21]  */  Ins_MDRP,
+    /*  MDRP[22]  */  Ins_MDRP,
+    /*  MDRP[23]  */  Ins_MDRP,
+    /*  MDRP[24]  */  Ins_MDRP,
+    /*  MDRP[25]  */  Ins_MDRP,
+    /*  MDRP[26]  */  Ins_MDRP,
+    /*  MDRP[27]  */  Ins_MDRP,
+    /*  MDRP[28]  */  Ins_MDRP,
+    /*  MDRP[29]  */  Ins_MDRP,
+    /*  MDRP[30]  */  Ins_MDRP,
+    /*  MDRP[31]  */  Ins_MDRP,
+
+    /*  MIRP[00]  */  Ins_MIRP,
+    /*  MIRP[01]  */  Ins_MIRP,
+    /*  MIRP[02]  */  Ins_MIRP,
+    /*  MIRP[03]  */  Ins_MIRP,
+    /*  MIRP[04]  */  Ins_MIRP,
+    /*  MIRP[05]  */  Ins_MIRP,
+    /*  MIRP[06]  */  Ins_MIRP,
+    /*  MIRP[07]  */  Ins_MIRP,
+    /*  MIRP[08]  */  Ins_MIRP,
+    /*  MIRP[09]  */  Ins_MIRP,
+    /*  MIRP[10]  */  Ins_MIRP,
+    /*  MIRP[11]  */  Ins_MIRP,
+    /*  MIRP[12]  */  Ins_MIRP,
+    /*  MIRP[13]  */  Ins_MIRP,
+    /*  MIRP[14]  */  Ins_MIRP,
+    /*  MIRP[15]  */  Ins_MIRP,
+
+    /*  MIRP[16]  */  Ins_MIRP,
+    /*  MIRP[17]  */  Ins_MIRP,
+    /*  MIRP[18]  */  Ins_MIRP,
+    /*  MIRP[19]  */  Ins_MIRP,
+    /*  MIRP[20]  */  Ins_MIRP,
+    /*  MIRP[21]  */  Ins_MIRP,
+    /*  MIRP[22]  */  Ins_MIRP,
+    /*  MIRP[23]  */  Ins_MIRP,
+    /*  MIRP[24]  */  Ins_MIRP,
+    /*  MIRP[25]  */  Ins_MIRP,
+    /*  MIRP[26]  */  Ins_MIRP,
+    /*  MIRP[27]  */  Ins_MIRP,
+    /*  MIRP[28]  */  Ins_MIRP,
+    /*  MIRP[29]  */  Ins_MIRP,
+    /*  MIRP[30]  */  Ins_MIRP,
+    /*  MIRP[31]  */  Ins_MIRP
+  };
+
+
+#endif /* !TT_CONFIG_OPTION_INTERPRETER_SWITCH */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* RUN                                                                   */
+  /*                                                                       */
+  /*  This function executes a run of opcodes.  It will exit in the        */
+  /*  following cases:                                                     */
+  /*                                                                       */
+  /*  - Errors (in which case it returns FALSE).                           */
+  /*                                                                       */
+  /*  - Reaching the end of the main code range (returns TRUE).            */
+  /*    Reaching the end of a code range within a function call is an      */
+  /*    error.                                                             */
+  /*                                                                       */
+  /*  - After executing one single opcode, if the flag `Instruction_Trap'  */
+  /*    is set to TRUE (returns TRUE).                                     */
+  /*                                                                       */
+  /*  On exit whith TRUE, test IP < CodeSize to know wether it comes from  */
+  /*  an instruction trap or a normal termination.                         */
+  /*                                                                       */
+  /*                                                                       */
+  /*  Note: The documented DEBUG opcode pops a value from the stack.  This */
+  /*        behaviour is unsupported; here a DEBUG opcode is always an     */
+  /*        error.                                                         */
+  /*                                                                       */
+  /*                                                                       */
+  /* THIS IS THE INTERPRETER'S MAIN LOOP.                                  */
+  /*                                                                       */
+  /*  Instructions appear in the specification's order.                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* documentation is in ttinterp.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  TT_RunIns( TT_ExecContext  exc )
+  {
+    FT_Long  ins_counter = 0;  /* executed instructions counter */
+
+
+#ifdef TT_CONFIG_OPTION_STATIC_RASTER
+    cur = *exc;
+#endif
+
+    /* set CVT functions */
+    CUR.tt_metrics.ratio = 0;
+    if ( CUR.metrics.x_ppem != CUR.metrics.y_ppem )
+    {
+      /* non-square pixels, use the stretched routines */
+      CUR.func_read_cvt  = Read_CVT_Stretched;
+      CUR.func_write_cvt = Write_CVT_Stretched;
+      CUR.func_move_cvt  = Move_CVT_Stretched;
+    }
+    else
+    {
+      /* square pixels, use normal routines */
+      CUR.func_read_cvt  = Read_CVT;
+      CUR.func_write_cvt = Write_CVT;
+      CUR.func_move_cvt  = Move_CVT;
+    }
+
+    COMPUTE_Funcs();
+    COMPUTE_Round( (FT_Byte)exc->GS.round_state );
+
+    do
+    {
+      CUR.opcode = CUR.code[CUR.IP];
+
+      if ( ( CUR.length = opcode_length[CUR.opcode] ) < 0 )
+      {
+        if ( CUR.IP + 1 > CUR.codeSize )
+          goto LErrorCodeOverflow_;
+
+        CUR.length = CUR.code[CUR.IP + 1] + 2;
+      }
+
+      if ( CUR.IP + CUR.length > CUR.codeSize )
+        goto LErrorCodeOverflow_;
+
+      /* First, let's check for empty stack and overflow */
+      CUR.args = CUR.top - ( Pop_Push_Count[CUR.opcode] >> 4 );
+
+      /* `args' is the top of the stack once arguments have been popped. */
+      /* One can also interpret it as the index of the last argument.    */
+      if ( CUR.args < 0 )
+      {
+        CUR.error = TT_Err_Too_Few_Arguments;
+        goto LErrorLabel_;
+      }
+
+      CUR.new_top = CUR.args + ( Pop_Push_Count[CUR.opcode] & 15 );
+
+      /* `new_top' is the new top of the stack, after the instruction's */
+      /* execution.  `top' will be set to `new_top' after the `switch'  */
+      /* statement.                                                     */
+      if ( CUR.new_top > CUR.stackSize )
+      {
+        CUR.error = TT_Err_Stack_Overflow;
+        goto LErrorLabel_;
+      }
+
+      CUR.step_ins = TRUE;
+      CUR.error    = TT_Err_Ok;
+
+#ifdef TT_CONFIG_OPTION_INTERPRETER_SWITCH
+
+      {
+        FT_Long*  args   = CUR.stack + CUR.args;
+        FT_Byte   opcode = CUR.opcode;
+
+
+#undef  ARRAY_BOUND_ERROR
+#define ARRAY_BOUND_ERROR  goto Set_Invalid_Ref
+
+
+        switch ( opcode )
+        {
+        case 0x00:  /* SVTCA y  */
+        case 0x01:  /* SVTCA x  */
+        case 0x02:  /* SPvTCA y */
+        case 0x03:  /* SPvTCA x */
+        case 0x04:  /* SFvTCA y */
+        case 0x05:  /* SFvTCA x */
+          {
+            FT_Short AA, BB;
+
+
+            AA = (FT_Short)( ( opcode & 1 ) << 14 );
+            BB = (FT_Short)( AA ^ 0x4000 );
+
+            if ( opcode < 4 )
+            {
+              CUR.GS.projVector.x = AA;
+              CUR.GS.projVector.y = BB;
+
+              CUR.GS.dualVector.x = AA;
+              CUR.GS.dualVector.y = BB;
+            }
+            else
+            {
+              GUESS_VECTOR( projVector );
+            }
+
+            if ( ( opcode & 2 ) == 0 )
+            {
+              CUR.GS.freeVector.x = AA;
+              CUR.GS.freeVector.y = BB;
+            }
+            else
+            {
+              GUESS_VECTOR( freeVector );
+            }
+
+            COMPUTE_Funcs();
+          }
+          break;
+
+        case 0x06:  /* SPvTL // */
+        case 0x07:  /* SPvTL +  */
+          DO_SPVTL
+          break;
+
+        case 0x08:  /* SFvTL // */
+        case 0x09:  /* SFvTL +  */
+          DO_SFVTL
+          break;
+
+        case 0x0A:  /* SPvFS */
+          DO_SPVFS
+          break;
+
+        case 0x0B:  /* SFvFS */
+          DO_SFVFS
+          break;
+
+        case 0x0C:  /* GPV */
+          DO_GPV
+          break;
+
+        case 0x0D:  /* GFV */
+          DO_GFV
+          break;
+
+        case 0x0E:  /* SFvTPv */
+          DO_SFVTPV
+          break;
+
+        case 0x0F:  /* ISECT  */
+          Ins_ISECT( EXEC_ARG_ args );
+          break;
+
+        case 0x10:  /* SRP0 */
+          DO_SRP0
+          break;
+
+        case 0x11:  /* SRP1 */
+          DO_SRP1
+          break;
+
+        case 0x12:  /* SRP2 */
+          DO_SRP2
+          break;
+
+        case 0x13:  /* SZP0 */
+          Ins_SZP0( EXEC_ARG_ args );
+          break;
+
+        case 0x14:  /* SZP1 */
+          Ins_SZP1( EXEC_ARG_ args );
+          break;
+
+        case 0x15:  /* SZP2 */
+          Ins_SZP2( EXEC_ARG_ args );
+          break;
+
+        case 0x16:  /* SZPS */
+          Ins_SZPS( EXEC_ARG_ args );
+          break;
+
+        case 0x17:  /* SLOOP */
+          DO_SLOOP
+          break;
+
+        case 0x18:  /* RTG */
+          DO_RTG
+          break;
+
+        case 0x19:  /* RTHG */
+          DO_RTHG
+          break;
+
+        case 0x1A:  /* SMD */
+          DO_SMD
+          break;
+
+        case 0x1B:  /* ELSE */
+          Ins_ELSE( EXEC_ARG_ args );
+          break;
+
+        case 0x1C:  /* JMPR */
+          DO_JMPR
+          break;
+
+        case 0x1D:  /* SCVTCI */
+          DO_SCVTCI
+          break;
+
+        case 0x1E:  /* SSWCI */
+          DO_SSWCI
+          break;
+
+        case 0x1F:  /* SSW */
+          DO_SSW
+          break;
+
+        case 0x20:  /* DUP */
+          DO_DUP
+          break;
+
+        case 0x21:  /* POP */
+          /* nothing :-) */
+          break;
+
+        case 0x22:  /* CLEAR */
+          DO_CLEAR
+          break;
+
+        case 0x23:  /* SWAP */
+          DO_SWAP
+          break;
+
+        case 0x24:  /* DEPTH */
+          DO_DEPTH
+          break;
+
+        case 0x25:  /* CINDEX */
+          DO_CINDEX
+          break;
+
+        case 0x26:  /* MINDEX */
+          Ins_MINDEX( EXEC_ARG_ args );
+          break;
+
+        case 0x27:  /* ALIGNPTS */
+          Ins_ALIGNPTS( EXEC_ARG_ args );
+          break;
+
+        case 0x28:  /* ???? */
+          Ins_UNKNOWN( EXEC_ARG_ args );
+          break;
+
+        case 0x29:  /* UTP */
+          Ins_UTP( EXEC_ARG_ args );
+          break;
+
+        case 0x2A:  /* LOOPCALL */
+          Ins_LOOPCALL( EXEC_ARG_ args );
+          break;
+
+        case 0x2B:  /* CALL */
+          Ins_CALL( EXEC_ARG_ args );
+          break;
+
+        case 0x2C:  /* FDEF */
+          Ins_FDEF( EXEC_ARG_ args );
+          break;
+
+        case 0x2D:  /* ENDF */
+          Ins_ENDF( EXEC_ARG_ args );
+          break;
+
+        case 0x2E:  /* MDAP */
+        case 0x2F:  /* MDAP */
+          Ins_MDAP( EXEC_ARG_ args );
+          break;
+
+
+        case 0x30:  /* IUP */
+        case 0x31:  /* IUP */
+          Ins_IUP( EXEC_ARG_ args );
+          break;
+
+        case 0x32:  /* SHP */
+        case 0x33:  /* SHP */
+          Ins_SHP( EXEC_ARG_ args );
+          break;
+
+        case 0x34:  /* SHC */
+        case 0x35:  /* SHC */
+          Ins_SHC( EXEC_ARG_ args );
+          break;
+
+        case 0x36:  /* SHZ */
+        case 0x37:  /* SHZ */
+          Ins_SHZ( EXEC_ARG_ args );
+          break;
+
+        case 0x38:  /* SHPIX */
+          Ins_SHPIX( EXEC_ARG_ args );
+          break;
+
+        case 0x39:  /* IP    */
+          Ins_IP( EXEC_ARG_ args );
+          break;
+
+        case 0x3A:  /* MSIRP */
+        case 0x3B:  /* MSIRP */
+          Ins_MSIRP( EXEC_ARG_ args );
+          break;
+
+        case 0x3C:  /* AlignRP */
+          Ins_ALIGNRP( EXEC_ARG_ args );
+          break;
+
+        case 0x3D:  /* RTDG */
+          DO_RTDG
+          break;
+
+        case 0x3E:  /* MIAP */
+        case 0x3F:  /* MIAP */
+          Ins_MIAP( EXEC_ARG_ args );
+          break;
+
+        case 0x40:  /* NPUSHB */
+          Ins_NPUSHB( EXEC_ARG_ args );
+          break;
+
+        case 0x41:  /* NPUSHW */
+          Ins_NPUSHW( EXEC_ARG_ args );
+          break;
+
+        case 0x42:  /* WS */
+          DO_WS
+          break;
+
+      Set_Invalid_Ref:
+            CUR.error = TT_Err_Invalid_Reference;
+          break;
+
+        case 0x43:  /* RS */
+          DO_RS
+          break;
+
+        case 0x44:  /* WCVTP */
+          DO_WCVTP
+          break;
+
+        case 0x45:  /* RCVT */
+          DO_RCVT
+          break;
+
+        case 0x46:  /* GC */
+        case 0x47:  /* GC */
+          Ins_GC( EXEC_ARG_ args );
+          break;
+
+        case 0x48:  /* SCFS */
+          Ins_SCFS( EXEC_ARG_ args );
+          break;
+
+        case 0x49:  /* MD */
+        case 0x4A:  /* MD */
+          Ins_MD( EXEC_ARG_ args );
+          break;
+
+        case 0x4B:  /* MPPEM */
+          DO_MPPEM
+          break;
+
+        case 0x4C:  /* MPS */
+          DO_MPS
+          break;
+
+        case 0x4D:  /* FLIPON */
+          DO_FLIPON
+          break;
+
+        case 0x4E:  /* FLIPOFF */
+          DO_FLIPOFF
+          break;
+
+        case 0x4F:  /* DEBUG */
+          DO_DEBUG
+          break;
+
+        case 0x50:  /* LT */
+          DO_LT
+          break;
+
+        case 0x51:  /* LTEQ */
+          DO_LTEQ
+          break;
+
+        case 0x52:  /* GT */
+          DO_GT
+          break;
+
+        case 0x53:  /* GTEQ */
+          DO_GTEQ
+          break;
+
+        case 0x54:  /* EQ */
+          DO_EQ
+          break;
+
+        case 0x55:  /* NEQ */
+          DO_NEQ
+          break;
+
+        case 0x56:  /* ODD */
+          DO_ODD
+          break;
+
+        case 0x57:  /* EVEN */
+          DO_EVEN
+          break;
+
+        case 0x58:  /* IF */
+          Ins_IF( EXEC_ARG_ args );
+          break;
+
+        case 0x59:  /* EIF */
+          /* do nothing */
+          break;
+
+        case 0x5A:  /* AND */
+          DO_AND
+          break;
+
+        case 0x5B:  /* OR */
+          DO_OR
+          break;
+
+        case 0x5C:  /* NOT */
+          DO_NOT
+          break;
+
+        case 0x5D:  /* DELTAP1 */
+          Ins_DELTAP( EXEC_ARG_ args );
+          break;
+
+        case 0x5E:  /* SDB */
+          DO_SDB
+          break;
+
+        case 0x5F:  /* SDS */
+          DO_SDS
+          break;
+
+        case 0x60:  /* ADD */
+          DO_ADD
+          break;
+
+        case 0x61:  /* SUB */
+          DO_SUB
+          break;
+
+        case 0x62:  /* DIV */
+          DO_DIV
+          break;
+
+        case 0x63:  /* MUL */
+          DO_MUL
+          break;
+
+        case 0x64:  /* ABS */
+          DO_ABS
+          break;
+
+        case 0x65:  /* NEG */
+          DO_NEG
+          break;
+
+        case 0x66:  /* FLOOR */
+          DO_FLOOR
+          break;
+
+        case 0x67:  /* CEILING */
+          DO_CEILING
+          break;
+
+        case 0x68:  /* ROUND */
+        case 0x69:  /* ROUND */
+        case 0x6A:  /* ROUND */
+        case 0x6B:  /* ROUND */
+          DO_ROUND
+          break;
+
+        case 0x6C:  /* NROUND */
+        case 0x6D:  /* NROUND */
+        case 0x6E:  /* NRRUND */
+        case 0x6F:  /* NROUND */
+          DO_NROUND
+          break;
+
+        case 0x70:  /* WCVTF */
+          DO_WCVTF
+          break;
+
+        case 0x71:  /* DELTAP2 */
+        case 0x72:  /* DELTAP3 */
+          Ins_DELTAP( EXEC_ARG_ args );
+          break;
+
+        case 0x73:  /* DELTAC0 */
+        case 0x74:  /* DELTAC1 */
+        case 0x75:  /* DELTAC2 */
+          Ins_DELTAC( EXEC_ARG_ args );
+          break;
+
+        case 0x76:  /* SROUND */
+          DO_SROUND
+          break;
+
+        case 0x77:  /* S45Round */
+          DO_S45ROUND
+          break;
+
+        case 0x78:  /* JROT */
+          DO_JROT
+          break;
+
+        case 0x79:  /* JROF */
+          DO_JROF
+          break;
+
+        case 0x7A:  /* ROFF */
+          DO_ROFF
+          break;
+
+        case 0x7B:  /* ???? */
+          Ins_UNKNOWN( EXEC_ARG_ args );
+          break;
+
+        case 0x7C:  /* RUTG */
+          DO_RUTG
+          break;
+
+        case 0x7D:  /* RDTG */
+          DO_RDTG
+          break;
+
+        case 0x7E:  /* SANGW */
+        case 0x7F:  /* AA    */
+          /* nothing - obsolete */
+          break;
+
+        case 0x80:  /* FLIPPT */
+          Ins_FLIPPT( EXEC_ARG_ args );
+          break;
+
+        case 0x81:  /* FLIPRGON */
+          Ins_FLIPRGON( EXEC_ARG_ args );
+          break;
+
+        case 0x82:  /* FLIPRGOFF */
+          Ins_FLIPRGOFF( EXEC_ARG_ args );
+          break;
+
+        case 0x83:  /* UNKNOWN */
+        case 0x84:  /* UNKNOWN */
+          Ins_UNKNOWN( EXEC_ARG_ args );
+          break;
+
+        case 0x85:  /* SCANCTRL */
+          Ins_SCANCTRL( EXEC_ARG_ args );
+          break;
+
+        case 0x86:  /* SDPVTL */
+        case 0x87:  /* SDPVTL */
+          Ins_SDPVTL( EXEC_ARG_ args );
+          break;
+
+        case 0x88:  /* GETINFO */
+          Ins_GETINFO( EXEC_ARG_ args );
+          break;
+
+        case 0x89:  /* IDEF */
+          Ins_IDEF( EXEC_ARG_ args );
+          break;
+
+        case 0x8A:  /* ROLL */
+          Ins_ROLL( EXEC_ARG_ args );
+          break;
+
+        case 0x8B:  /* MAX */
+          DO_MAX
+          break;
+
+        case 0x8C:  /* MIN */
+          DO_MIN
+          break;
+
+        case 0x8D:  /* SCANTYPE */
+          Ins_SCANTYPE( EXEC_ARG_ args );
+          break;
+
+        case 0x8E:  /* INSTCTRL */
+          Ins_INSTCTRL( EXEC_ARG_ args );
+          break;
+
+        case 0x8F:
+          Ins_UNKNOWN( EXEC_ARG_ args );
+          break;
+
+        default:
+          if ( opcode >= 0xE0 )
+            Ins_MIRP( EXEC_ARG_ args );
+          else if ( opcode >= 0xC0 )
+            Ins_MDRP( EXEC_ARG_ args );
+          else if ( opcode >= 0xB8 )
+            Ins_PUSHW( EXEC_ARG_ args );
+          else if ( opcode >= 0xB0 )
+            Ins_PUSHB( EXEC_ARG_ args );
+          else
+            Ins_UNKNOWN( EXEC_ARG_ args );
+        }
+
+      }
+
+#else
+
+      Instruct_Dispatch[CUR.opcode]( EXEC_ARG_ &CUR.stack[CUR.args] );
+
+#endif /* TT_CONFIG_OPTION_INTERPRETER_SWITCH */
+
+      if ( CUR.error != TT_Err_Ok )
+      {
+        switch ( CUR.error )
+        {
+        case TT_Err_Invalid_Opcode: /* looking for redefined instructions */
+          {
+            TT_DefRecord*  def   = CUR.IDefs;
+            TT_DefRecord*  limit = def + CUR.numIDefs;
+
+
+            for ( ; def < limit; def++ )
+            {
+              if ( def->active && CUR.opcode == (FT_Byte)def->opc )
+              {
+                TT_CallRec*  callrec;
+
+
+                if ( CUR.callTop >= CUR.callSize )
+                {
+                  CUR.error = TT_Err_Invalid_Reference;
+                  goto LErrorLabel_;
+                }
+
+                callrec = &CUR.callStack[CUR.callTop];
+
+                callrec->Caller_Range = CUR.curRange;
+                callrec->Caller_IP    = CUR.IP + 1;
+                callrec->Cur_Count    = 1;
+                callrec->Cur_Restart  = def->start;
+
+                if ( INS_Goto_CodeRange( def->range, def->start ) == FAILURE )
+                  goto LErrorLabel_;
+
+                goto LSuiteLabel_;
+              }
+            }
+          }
+
+          CUR.error = TT_Err_Invalid_Opcode;
+          goto LErrorLabel_;
+
+#if 0
+          break;   /* Unreachable code warning suppression.             */
+                   /* Leave to remind in case a later change the editor */
+                   /* to consider break;                                */
+#endif
+
+        default:
+          goto LErrorLabel_;
+
+#if 0
+        break;
+#endif
+        }
+      }
+
+      CUR.top = CUR.new_top;
+
+      if ( CUR.step_ins )
+        CUR.IP += CUR.length;
+
+      /* increment instruction counter and check if we didn't */
+      /* run this program for too long (e.g. infinite loops). */
+      if ( ++ins_counter > MAX_RUNNABLE_OPCODES )
+        return TT_Err_Execution_Too_Long;
+
+    LSuiteLabel_:
+      if ( CUR.IP >= CUR.codeSize )
+      {
+        if ( CUR.callTop > 0 )
+        {
+          CUR.error = TT_Err_Code_Overflow;
+          goto LErrorLabel_;
+        }
+        else
+          goto LNo_Error_;
+      }
+    } while ( !CUR.instruction_trap );
+
+  LNo_Error_:
+
+#ifdef TT_CONFIG_OPTION_STATIC_RASTER
+    *exc = cur;
+#endif
+
+    return TT_Err_Ok;
+
+  LErrorCodeOverflow_:
+    CUR.error = TT_Err_Code_Overflow;
+
+  LErrorLabel_:
+
+#ifdef TT_CONFIG_OPTION_STATIC_RASTER
+    *exc = cur;
+#endif
+
+    return CUR.error;
+  }
+
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttinterp.h b/nx-X11/extras/freetype2/src/truetype/ttinterp.h
new file mode 100644
index 000000000..eb0bb0bb6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttinterp.h
@@ -0,0 +1,318 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttinterp.h                                                             */
+/*                                                                         */
+/*    TrueType bytecode interpreter (specification).                       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 __TTINTERP_H__
+#define __TTINTERP_H__
+
+
+#include <ft2build.h>
+#include "ttobjs.h"
+
+
+FT_BEGIN_HEADER
+
+
+#ifndef TT_CONFIG_OPTION_STATIC_INTEPRETER  /* indirect implementation */
+
+#define EXEC_OP_   TT_ExecContext  exc,
+#define EXEC_OP    TT_ExecContext  exc
+#define EXEC_ARG_  exc,
+#define EXEC_ARG   exc
+
+#else                                       /* static implementation */
+
+#define EXEC_OP_   /* void */
+#define EXEC_OP    /* void */
+#define EXEC_ARG_  /* void */
+#define EXEC_ARG   /* void */
+
+#endif /* TT_CONFIG_OPTION_STATIC_INTERPRETER */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Rounding mode constants.                                              */
+  /*                                                                       */
+#define TT_Round_Off             5
+#define TT_Round_To_Half_Grid    0
+#define TT_Round_To_Grid         1
+#define TT_Round_To_Double_Grid  2
+#define TT_Round_Up_To_Grid      4
+#define TT_Round_Down_To_Grid    3
+#define TT_Round_Super           6
+#define TT_Round_Super_45        7
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Function types used by the interpreter, depending on various modes    */
+  /* (e.g. the rounding mode, whether to render a vertical or horizontal   */
+  /* line etc).                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* Rounding function */
+  typedef FT_F26Dot6
+  (*TT_Round_Func)( EXEC_OP_ FT_F26Dot6  distance,
+                             FT_F26Dot6  compensation );
+
+  /* Point displacement along the freedom vector routine */
+  typedef void
+  (*TT_Move_Func)( EXEC_OP_ TT_GlyphZone  zone,
+                            FT_UShort     point,
+                            FT_F26Dot6    distance );
+
+  /* Distance projection along one of the projection vectors */
+  typedef FT_F26Dot6
+  (*TT_Project_Func)( EXEC_OP_ FT_Vector*  v1,
+                               FT_Vector*  v2 );
+
+  /* reading a cvt value.  Take care of non-square pixels if necessary */
+  typedef FT_F26Dot6
+  (*TT_Get_CVT_Func)( EXEC_OP_ FT_ULong  idx );
+
+  /* setting or moving a cvt value.  Take care of non-square pixels  */
+  /* if necessary                                                    */
+  typedef void
+  (*TT_Set_CVT_Func)( EXEC_OP_ FT_ULong    idx,
+                               FT_F26Dot6  value );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This structure defines a call record, used to manage function calls.  */
+  /*                                                                       */
+  typedef struct  TT_CallRec_
+  {
+    FT_Int   Caller_Range;
+    FT_Long  Caller_IP;
+    FT_Long  Cur_Count;
+    FT_Long  Cur_Restart;
+
+  } TT_CallRec, *TT_CallStack;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The main structure for the interpreter which collects all necessary   */
+  /* variables and states.                                                 */
+  /*                                                                       */
+  typedef struct  TT_ExecContextRec_
+  {
+    TT_Face            face;
+    TT_Size            size;
+    FT_Memory          memory;
+
+    /* instructions state */
+
+    FT_Error           error;      /* last execution error */
+
+    FT_Long            top;        /* top of exec. stack   */
+
+    FT_UInt            stackSize;  /* size of exec. stack  */
+    FT_Long*           stack;      /* current exec. stack  */
+
+    FT_Long            args;
+    FT_UInt            new_top;    /* new top after exec.  */
+
+    TT_GlyphZoneRec    zp0,        /* zone records */
+                       zp1,
+                       zp2,
+                       pts,
+                       twilight;
+
+    FT_Size_Metrics    metrics;
+    TT_Size_Metrics    tt_metrics; /* size metrics */
+
+    TT_GraphicsState   GS;         /* current graphics state */
+
+    FT_Int             curRange;  /* current code range number   */
+    FT_Byte*           code;      /* current code range          */
+    FT_Long            IP;        /* current instruction pointer */
+    FT_Long            codeSize;  /* size of current range       */
+
+    FT_Byte            opcode;    /* current opcode              */
+    FT_Int             length;    /* length of current opcode    */
+
+    FT_Bool            step_ins;  /* true if the interpreter must */
+                                  /* increment IP after ins. exec */
+    FT_Long            cvtSize;
+    FT_Long*           cvt;
+
+    FT_UInt            glyphSize; /* glyph instructions buffer size */
+    FT_Byte*           glyphIns;  /* glyph instructions buffer */
+
+    FT_UInt            numFDefs;  /* number of function defs         */
+    FT_UInt            maxFDefs;  /* maximum number of function defs */
+    TT_DefArray        FDefs;     /* table of FDefs entries          */
+
+    FT_UInt            numIDefs;  /* number of instruction defs */
+    FT_UInt            maxIDefs;  /* maximum number of ins defs */
+    TT_DefArray        IDefs;     /* table of IDefs entries     */
+
+    FT_UInt            maxFunc;   /* maximum function index     */
+    FT_UInt            maxIns;    /* maximum instruction index  */
+
+    FT_Int             callTop,    /* top of call stack during execution */
+                       callSize;   /* size of call stack */
+    TT_CallStack       callStack;  /* call stack */
+
+    FT_UShort          maxPoints;    /* capacity of this context's `pts' */
+    FT_Short           maxContours;  /* record, expressed in points and  */
+                                     /* contours.                        */
+
+    TT_CodeRangeTable  codeRangeTable;  /* table of valid code ranges */
+                                        /* useful for the debugger   */
+
+    FT_UShort          storeSize;  /* size of current storage */
+    FT_Long*           storage;    /* storage area            */
+
+    FT_F26Dot6         period;     /* values used for the */
+    FT_F26Dot6         phase;      /* `SuperRounding'     */
+    FT_F26Dot6         threshold;
+
+#if 0
+    /* this seems to be unused */
+    FT_Int             cur_ppem;   /* ppem along the current proj vector */
+#endif
+
+    FT_Bool            instruction_trap; /* If `True', the interpreter will */
+                                         /* exit after each instruction     */
+
+    TT_GraphicsState   default_GS;       /* graphics state resulting from   */
+                                         /* the prep program                */
+    FT_Bool            is_composite;     /* true if the glyph is composite  */
+    FT_Bool            pedantic_hinting; /* true if pedantic interpretation */
+
+    /* latest interpreter additions */
+
+    FT_Long            F_dot_P;    /* dot product of freedom and projection */
+                                   /* vectors                               */
+    TT_Round_Func      func_round; /* current rounding function             */
+
+    TT_Project_Func    func_project,   /* current projection function */
+                       func_dualproj,  /* current dual proj. function */
+                       func_freeProj;  /* current freedom proj. func  */
+
+    TT_Move_Func       func_move;      /* current point move function */
+    TT_Move_Func       func_move_orig; /* move original position function */
+
+    TT_Get_CVT_Func    func_read_cvt;  /* read a cvt entry              */
+    TT_Set_CVT_Func    func_write_cvt; /* write a cvt entry (in pixels) */
+    TT_Set_CVT_Func    func_move_cvt;  /* incr a cvt entry (in pixels)  */
+
+    FT_ULong           loadSize;
+    TT_SubGlyph_Stack  loadStack;      /* loading subglyph stack */
+
+  } TT_ExecContextRec;
+
+
+  extern const TT_GraphicsState  tt_default_graphics_state;
+
+
+  FT_LOCAL( FT_Error )
+  TT_Goto_CodeRange( TT_ExecContext  exec,
+                     FT_Int          range,
+                     FT_Long         IP );
+
+  FT_LOCAL( FT_Error )
+  TT_Set_CodeRange( TT_ExecContext  exec,
+                    FT_Int          range,
+                    void*           base,
+                    FT_Long         length );
+
+  FT_LOCAL( FT_Error )
+  TT_Clear_CodeRange( TT_ExecContext  exec,
+                      FT_Int          range );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_New_Context                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Queries the face context for a given font.  Note that there is     */
+  /*    now a _single_ execution context in the TrueType driver which is   */
+  /*    shared among faces.                                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source face object.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A handle to the execution context.  Initialized for `face'.        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only the glyph loader and debugger should call this function.      */
+  /*                                                                       */
+  FT_EXPORT( TT_ExecContext )
+  TT_New_Context( TT_Face  face );
+
+
+  FT_LOCAL( FT_Error )
+  TT_Done_Context( TT_ExecContext  exec );
+
+  FT_LOCAL( FT_Error )
+  TT_Destroy_Context( TT_ExecContext  exec,
+                      FT_Memory       memory );
+
+  FT_LOCAL( FT_Error )
+  TT_Load_Context( TT_ExecContext  exec,
+                   TT_Face         face,
+                   TT_Size         size );
+
+  FT_LOCAL( FT_Error )
+  TT_Save_Context( TT_ExecContext  exec,
+                   TT_Size         ins );
+
+  FT_LOCAL( FT_Error )
+  TT_Run_Context( TT_ExecContext  exec,
+                  FT_Bool         debug );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_RunIns                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Executes one or more instruction in the execution context.  This   */
+  /*    is the main function of the TrueType opcode interpreter.           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    exec :: A handle to the target execution context.                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only the object manager and debugger should call this function.    */
+  /*                                                                       */
+  /*    This function is publicly exported because it is directly          */
+  /*    invoked by the TrueType debugger.                                  */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  TT_RunIns( TT_ExecContext  exec );
+
+
+FT_END_HEADER
+
+#endif /* __TTINTERP_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttobjs.c b/nx-X11/extras/freetype2/src/truetype/ttobjs.c
new file mode 100644
index 000000000..3914ba5da
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttobjs.c
@@ -0,0 +1,901 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttobjs.c                                                               */
+/*                                                                         */
+/*    Objects manager (body).                                              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_CALC_H
+#include FT_INTERNAL_STREAM_H
+#include FT_TRUETYPE_IDS_H
+#include FT_TRUETYPE_TAGS_H
+#include FT_INTERNAL_SFNT_H
+
+#include "ttgload.h"
+#include "ttpload.h"
+
+#include "tterrors.h"
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+#include "ttinterp.h"
+#endif
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+#include FT_TRUETYPE_UNPATENTED_H
+#endif
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+#include "ttgxvar.h"
+#endif
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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_ttobjs
+
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                       GLYPH ZONE FUNCTIONS                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_glyphzone_done                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Deallocates a glyph zone.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    zone :: A pointer to the target glyph zone.                        */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  tt_glyphzone_done( TT_GlyphZone  zone )
+  {
+    FT_Memory  memory = zone->memory;
+
+
+    if ( memory )
+    {
+      FT_FREE( zone->contours );
+      FT_FREE( zone->tags );
+      FT_FREE( zone->cur );
+      FT_FREE( zone->org );
+
+      zone->max_points   = zone->n_points   = 0;
+      zone->max_contours = zone->n_contours = 0;
+      zone->memory       = NULL;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_glyphzone_new                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Allocates a new glyph zone.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory      :: A handle to the current memory object.              */
+  /*                                                                       */
+  /*    maxPoints   :: The capacity of glyph zone in points.               */
+  /*                                                                       */
+  /*    maxContours :: The capacity of glyph zone in contours.             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    zone        :: A pointer to the target glyph zone record.          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_glyphzone_new( FT_Memory     memory,
+                    FT_UShort     maxPoints,
+                    FT_Short      maxContours,
+                    TT_GlyphZone  zone )
+  {
+    FT_Error  error;
+
+
+    if ( maxPoints > 0 )
+      maxPoints += 2;
+
+    FT_MEM_ZERO( zone, sizeof ( *zone ) );
+    zone->memory = memory;
+
+    if ( FT_NEW_ARRAY( zone->org,      maxPoints * 2 ) ||
+         FT_NEW_ARRAY( zone->cur,      maxPoints * 2 ) ||
+         FT_NEW_ARRAY( zone->tags,     maxPoints     ) ||
+         FT_NEW_ARRAY( zone->contours, maxContours   ) )
+    {
+      tt_glyphzone_done( zone );
+    }
+
+    return error;
+  }
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_init                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given TrueType face object.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream     :: The source font stream.                              */
+  /*                                                                       */
+  /*    face_index :: The index of the font face in the resource.          */
+  /*                                                                       */
+  /*    num_params :: Number of additional generic parameters.  Ignored.   */
+  /*                                                                       */
+  /*    params     :: Additional generic parameters.  Ignored.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: The newly built face object.                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_init( FT_Stream      stream,
+                FT_Face        ttface,      /* TT_Face */
+                FT_Int         face_index,
+                FT_Int         num_params,
+                FT_Parameter*  params )
+  {
+    FT_Error      error;
+    FT_Library    library;
+    SFNT_Service  sfnt;
+    TT_Face       face = (TT_Face)ttface;
+
+
+    library = face->root.driver->root.library;
+    sfnt    = (SFNT_Service)FT_Get_Module_Interface( library, "sfnt" );
+    if ( !sfnt )
+      goto Bad_Format;
+
+    /* create input stream from resource */
+    if ( FT_STREAM_SEEK( 0 ) )
+      goto Exit;
+
+    /* check that we have a valid TrueType file */
+    error = sfnt->init_face( stream, face, face_index, num_params, params );
+    if ( error )
+      goto Exit;
+
+    /* We must also be able to accept Mac/GX fonts, as well as OT ones */
+    if ( face->format_tag != 0x00010000L &&    /* MS fonts  */
+         face->format_tag != TTAG_true   )     /* Mac fonts */
+    {
+      FT_TRACE2(( "[not a valid TTF font]\n" ));
+      goto Bad_Format;
+    }
+
+    /* If we are performing a simple font format check, exit immediately */
+    if ( face_index < 0 )
+      return TT_Err_Ok;
+
+    /* Load font directory */
+    error = sfnt->load_face( stream, face, face_index, num_params, params );
+    if ( error )
+      goto Exit;
+
+    if ( face->root.face_flags & FT_FACE_FLAG_SCALABLE )
+    {
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+      if ( !face->root.internal->incremental_interface )
+        error = tt_face_load_loca( face, stream );
+      if ( !error )
+        error = tt_face_load_cvt( face, stream ) ||
+                tt_face_load_fpgm( face, stream );
+
+#else
+
+      if ( !error )
+        error = tt_face_load_loca( face, stream ) ||
+                tt_face_load_cvt( face, stream )  ||
+                tt_face_load_fpgm( face, stream );
+
+#endif
+
+    }
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+
+    /* Determine whether unpatented hinting is to be used for this face. */
+    face->unpatented_hinting = FT_BOOL
+       ( library->debug_hooks[ FT_DEBUG_HOOK_UNPATENTED_HINTING ] != NULL );
+
+    {
+      int  i;
+
+
+      for ( i = 0; i < num_params && !face->unpatented_hinting; i++ )
+        if ( params[i].tag == FT_PARAM_TAG_UNPATENTED_HINTING )
+          face->unpatented_hinting = TRUE;
+    }
+
+#endif /* TT_CONFIG_OPTION_UNPATENTED_HINTING */
+
+    /* initialize standard glyph loading routines */
+    TT_Init_Glyph_Loading( face );
+
+  Exit:
+    return error;
+
+  Bad_Format:
+    error = TT_Err_Unknown_File_Format;
+    goto Exit;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_done                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes a given face object.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A pointer to the face object to destroy.                   */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  tt_face_done( FT_Face  ttface )           /* TT_Face */
+  {
+    TT_Face       face   = (TT_Face)ttface;
+    FT_Memory     memory = face->root.memory;
+    FT_Stream     stream = face->root.stream;
+
+    SFNT_Service  sfnt   = (SFNT_Service)face->sfnt;
+
+
+    /* for `extended TrueType formats' (i.e. compressed versions) */
+    if ( face->extra.finalizer )
+      face->extra.finalizer( face->extra.data );
+
+    if ( sfnt )
+      sfnt->done_face( face );
+
+    /* freeing the locations table */
+    FT_FREE( face->glyph_locations );
+    face->num_locations = 0;
+
+    /* freeing the CVT */
+    FT_FREE( face->cvt );
+    face->cvt_size = 0;
+
+    /* freeing the programs */
+    FT_FRAME_RELEASE( face->font_program );
+    FT_FRAME_RELEASE( face->cvt_program );
+    face->font_program_size = 0;
+    face->cvt_program_size  = 0;
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+    tt_done_blend( memory, face->blend );
+    face->blend = NULL;
+#endif
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                           SIZE  FUNCTIONS                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_size_init                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a new TrueType size object.                            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    size :: A handle to the size object.                               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_size_init( FT_Size  ttsize )           /* TT_Size */
+  {
+    TT_Size   size  = (TT_Size)ttsize;
+    FT_Error  error = TT_Err_Ok;
+
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+    TT_Face    face   = (TT_Face)size->root.face;
+    FT_Memory  memory = face->root.memory;
+    FT_Int     i;
+
+    TT_ExecContext  exec;
+    FT_UShort       n_twilight;
+    TT_MaxProfile*  maxp = &face->max_profile;
+
+
+    size->ttmetrics.valid = FALSE;
+
+    size->max_function_defs    = maxp->maxFunctionDefs;
+    size->max_instruction_defs = maxp->maxInstructionDefs;
+
+    size->num_function_defs    = 0;
+    size->num_instruction_defs = 0;
+
+    size->max_func = 0;
+    size->max_ins  = 0;
+
+    size->cvt_size     = face->cvt_size;
+    size->storage_size = maxp->maxStorage;
+
+    /* Set default metrics */
+    {
+      FT_Size_Metrics*  metrics  = &size->root.metrics;
+      TT_Size_Metrics*  metrics2 = &size->ttmetrics;
+
+
+      metrics->x_ppem = 0;
+      metrics->y_ppem = 0;
+
+      metrics2->rotated   = FALSE;
+      metrics2->stretched = FALSE;
+
+      /* set default compensation (all 0) */
+      for ( i = 0; i < 4; i++ )
+        metrics2->compensations[i] = 0;
+    }
+
+    /* allocate function defs, instruction defs, cvt, and storage area */
+    if ( FT_NEW_ARRAY( size->function_defs,    size->max_function_defs    ) ||
+         FT_NEW_ARRAY( size->instruction_defs, size->max_instruction_defs ) ||
+         FT_NEW_ARRAY( size->cvt,              size->cvt_size             ) ||
+         FT_NEW_ARRAY( size->storage,          size->storage_size         ) )
+
+      goto Fail_Memory;
+
+    /* reserve twilight zone */
+    n_twilight = maxp->maxTwilightPoints;
+    error = tt_glyphzone_new( memory, n_twilight, 0, &size->twilight );
+    if ( error )
+      goto Fail_Memory;
+
+    size->twilight.n_points = n_twilight;
+
+    /* set `face->interpreter' according to the debug hook present */
+    {
+      FT_Library  library = face->root.driver->root.library;
+
+
+      face->interpreter = (TT_Interpreter)
+                            library->debug_hooks[FT_DEBUG_HOOK_TRUETYPE];
+      if ( !face->interpreter )
+        face->interpreter = (TT_Interpreter)TT_RunIns;
+    }
+
+    /* Fine, now execute the font program! */
+    exec = size->context;
+    /* size objects used during debugging have their own context */
+    if ( !size->debug )
+      exec = TT_New_Context( face );
+
+    if ( !exec )
+    {
+      error = TT_Err_Could_Not_Find_Context;
+      goto Fail_Memory;
+    }
+
+    size->GS = tt_default_graphics_state;
+    TT_Load_Context( exec, face, size );
+
+    exec->callTop   = 0;
+    exec->top       = 0;
+
+    exec->period    = 64;
+    exec->phase     = 0;
+    exec->threshold = 0;
+
+    {
+      FT_Size_Metrics*  metrics    = &exec->metrics;
+      TT_Size_Metrics*  tt_metrics = &exec->tt_metrics;
+
+
+      metrics->x_ppem   = 0;
+      metrics->y_ppem   = 0;
+      metrics->x_scale  = 0;
+      metrics->y_scale  = 0;
+
+      tt_metrics->ppem  = 0;
+      tt_metrics->scale = 0;
+      tt_metrics->ratio = 0x10000L;
+    }
+
+    exec->instruction_trap = FALSE;
+
+    exec->cvtSize = size->cvt_size;
+    exec->cvt     = size->cvt;
+
+    exec->F_dot_P = 0x10000L;
+
+    /* allow font program execution */
+    TT_Set_CodeRange( exec,
+                      tt_coderange_font,
+                      face->font_program,
+                      face->font_program_size );
+
+    /* disable CVT and glyph programs coderange */
+    TT_Clear_CodeRange( exec, tt_coderange_cvt );
+    TT_Clear_CodeRange( exec, tt_coderange_glyph );
+
+    if ( face->font_program_size > 0 )
+    {
+      error = TT_Goto_CodeRange( exec, tt_coderange_font, 0 );
+      if ( !error )
+        error = face->interpreter( exec );
+
+      if ( error )
+        goto Fail_Exec;
+    }
+    else
+      error = TT_Err_Ok;
+
+    TT_Save_Context( exec, size );
+
+    if ( !size->debug )
+      TT_Done_Context( exec );
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+    size->ttmetrics.valid = FALSE;
+    return error;
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+  Fail_Exec:
+    if ( !size->debug )
+      TT_Done_Context( exec );
+
+  Fail_Memory:
+
+    tt_size_done( ttsize );
+    return error;
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_size_done                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The TrueType size object finalizer.                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    size :: A handle to the target size object.                        */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  tt_size_done( FT_Size  ttsize )           /* TT_Size */
+  {
+    TT_Size    size = (TT_Size)ttsize;
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+    FT_Memory  memory = size->root.face->memory;
+
+
+    if ( size->debug )
+    {
+      /* the debug context must be deleted by the debugger itself */
+      size->context = NULL;
+      size->debug   = FALSE;
+    }
+
+    FT_FREE( size->cvt );
+    size->cvt_size = 0;
+
+    /* free storage area */
+    FT_FREE( size->storage );
+    size->storage_size = 0;
+
+    /* twilight zone */
+    tt_glyphzone_done( &size->twilight );
+
+    FT_FREE( size->function_defs );
+    FT_FREE( size->instruction_defs );
+
+    size->num_function_defs    = 0;
+    size->max_function_defs    = 0;
+    size->num_instruction_defs = 0;
+    size->max_instruction_defs = 0;
+
+    size->max_func = 0;
+    size->max_ins  = 0;
+
+#endif
+
+    size->ttmetrics.valid = FALSE;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Reset_Outline_Size                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Resets a TrueType outline size when resolutions and character      */
+  /*    dimensions have been changed.                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    size :: A handle to the target size object.                        */
+  /*                                                                       */
+  static FT_Error
+  Reset_Outline_Size( TT_Size  size )
+  {
+    TT_Face           face;
+    FT_Error          error = TT_Err_Ok;
+
+    FT_Size_Metrics*  metrics;
+
+
+    if ( size->ttmetrics.valid )
+      return TT_Err_Ok;
+
+    face = (TT_Face)size->root.face;
+
+    metrics = &size->metrics;
+
+    if ( metrics->x_ppem < 1 || metrics->y_ppem < 1 )
+      return TT_Err_Invalid_PPem;
+
+    /* compute new transformation */
+    if ( metrics->x_ppem >= metrics->y_ppem )
+    {
+      size->ttmetrics.scale   = metrics->x_scale;
+      size->ttmetrics.ppem    = metrics->x_ppem;
+      size->ttmetrics.x_ratio = 0x10000L;
+      size->ttmetrics.y_ratio = FT_MulDiv( metrics->y_ppem,
+                                           0x10000L,
+                                           metrics->x_ppem );
+    }
+    else
+    {
+      size->ttmetrics.scale   = metrics->y_scale;
+      size->ttmetrics.ppem    = metrics->y_ppem;
+      size->ttmetrics.x_ratio = FT_MulDiv( metrics->x_ppem,
+                                           0x10000L,
+                                           metrics->y_ppem );
+      size->ttmetrics.y_ratio = 0x10000L;
+    }
+
+    /* Compute root ascender, descender, text height, and max_advance */
+    metrics->ascender =
+      FT_PIX_ROUND( FT_MulFix( face->root.ascender, metrics->y_scale ) );
+    metrics->descender =
+      FT_PIX_ROUND( FT_MulFix( face->root.descender, metrics->y_scale ) );
+    metrics->height =
+      FT_PIX_ROUND( FT_MulFix( face->root.height, metrics->y_scale ) );
+    metrics->max_advance =
+      FT_PIX_ROUND( FT_MulFix( face->root.max_advance_width,
+                               metrics->x_scale ) );
+
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+    /* set to `invalid' by default */
+    size->strike_index = 0xFFFFU;
+#endif
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+    {
+      TT_ExecContext  exec;
+      FT_UInt         i, j;
+
+
+      /* Scale the cvt values to the new ppem.          */
+      /* We use by default the y ppem to scale the CVT. */
+      for ( i = 0; i < size->cvt_size; i++ )
+        size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
+
+      /* All twilight points are originally zero */
+      for ( j = 0; j < (FT_UInt)size->twilight.n_points; j++ )
+      {
+        size->twilight.org[j].x = 0;
+        size->twilight.org[j].y = 0;
+        size->twilight.cur[j].x = 0;
+        size->twilight.cur[j].y = 0;
+      }
+
+      /* clear storage area */
+      for ( i = 0; i < (FT_UInt)size->storage_size; i++ )
+        size->storage[i] = 0;
+
+      size->GS = tt_default_graphics_state;
+
+      /* get execution context and run prep program */
+      if ( size->debug )
+        exec = size->context;
+      else
+        exec = TT_New_Context( face );
+      /* debugging instances have their own context */
+
+      if ( !exec )
+        return TT_Err_Could_Not_Find_Context;
+
+      TT_Load_Context( exec, face, size );
+
+      TT_Set_CodeRange( exec,
+                        tt_coderange_cvt,
+                        face->cvt_program,
+                        face->cvt_program_size );
+
+      TT_Clear_CodeRange( exec, tt_coderange_glyph );
+
+      exec->instruction_trap = FALSE;
+
+      exec->top     = 0;
+      exec->callTop = 0;
+
+      if ( face->cvt_program_size > 0 )
+      {
+        error = TT_Goto_CodeRange( exec, tt_coderange_cvt, 0 );
+        if ( error )
+          goto End;
+
+        if ( !size->debug )
+          error = face->interpreter( exec );
+      }
+      else
+        error = TT_Err_Ok;
+
+      size->GS = exec->GS;
+      /* save default graphics state */
+
+    End:
+      TT_Save_Context( exec, size );
+
+      if ( !size->debug )
+        TT_Done_Context( exec );
+      /* debugging instances keep their context */
+    }
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+    if ( !error )
+      size->ttmetrics.valid = TRUE;
+
+    return error;
+  }
+
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Reset_SBit_Size                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Resets a TrueType sbit size when resolutions and character         */
+  /*    dimensions have been changed.                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    size :: A handle to the target size object.                        */
+  /*                                                                       */
+  static FT_Error
+  Reset_SBit_Size( TT_Size  size )
+  {
+    TT_Face           face;
+    FT_Error          error = TT_Err_Ok;
+
+    FT_ULong          strike_index;
+    FT_Size_Metrics*  metrics;
+    FT_Size_Metrics*  sbit_metrics;
+    SFNT_Service      sfnt;
+
+
+    metrics = &size->metrics;
+
+    if ( size->strike_index != 0xFFFFU )
+      return TT_Err_Ok;
+
+    face = (TT_Face)size->root.face;
+    sfnt = (SFNT_Service)face->sfnt;
+
+    sbit_metrics = &size->strike_metrics;
+
+    error = sfnt->set_sbit_strike( face,
+                                   metrics->x_ppem, metrics->y_ppem,
+                                   &strike_index );
+
+    if ( !error )
+    {
+      TT_SBit_Strike  strike = face->sbit_strikes + strike_index;
+
+
+      sbit_metrics->x_ppem = metrics->x_ppem;
+      sbit_metrics->y_ppem = metrics->y_ppem;
+#if 0
+      /*
+       * sbit_metrics->?_scale
+       * are not used now.
+       */
+      sbit_metrics->x_scale = 1 << 16;
+      sbit_metrics->y_scale = 1 << 16;
+#endif
+
+      sbit_metrics->ascender  = strike->hori.ascender << 6;
+      sbit_metrics->descender = strike->hori.descender << 6;
+
+      /* XXX: Is this correct? */
+      sbit_metrics->height = sbit_metrics->ascender -
+                             sbit_metrics->descender;
+
+      /* XXX: Is this correct? */
+      sbit_metrics->max_advance = ( strike->hori.min_origin_SB  +
+                                    strike->hori.max_width      +
+                                    strike->hori.min_advance_SB ) << 6;
+
+      size->strike_index = (FT_UInt)strike_index;
+    }
+    else
+    {
+      size->strike_index = 0xFFFFU;
+
+      sbit_metrics->x_ppem      = 0;
+      sbit_metrics->y_ppem      = 0;
+      sbit_metrics->ascender    = 0;
+      sbit_metrics->descender   = 0;
+      sbit_metrics->height      = 0;
+      sbit_metrics->max_advance = 0;
+    }
+
+    return error;
+  }
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_size_reset                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Resets a TrueType size when resolutions and character dimensions   */
+  /*    have been changed.                                                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    size :: A handle to the target size object.                        */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_size_reset( TT_Size  size )
+  {
+    FT_Face   face;
+    FT_Error  error = TT_Err_Ok;
+
+
+    face = size->root.face;
+
+    if ( face->face_flags & FT_FACE_FLAG_SCALABLE )
+    {
+      if ( !size->ttmetrics.valid )
+        error = Reset_Outline_Size( size );
+
+      if ( error )
+        return error;
+    }
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    if ( face->face_flags & FT_FACE_FLAG_FIXED_SIZES )
+    {
+      if ( size->strike_index == 0xFFFFU )
+        error = Reset_SBit_Size( size );
+
+      if ( !error && !( face->face_flags & FT_FACE_FLAG_SCALABLE ) )
+        size->root.metrics = size->strike_metrics;
+    }
+
+#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
+
+    if ( face->face_flags & FT_FACE_FLAG_SCALABLE )
+      return TT_Err_Ok;
+    else
+      return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_driver_init                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given TrueType driver object.                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    driver :: A handle to the target driver object.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_driver_init( FT_Module  driver )       /* TT_Driver */
+  {
+    FT_Error  error;
+
+
+    /* set `extra' in glyph loader */
+    error = FT_GlyphLoader_CreateExtra( FT_DRIVER( driver )->glyph_loader );
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_driver_done                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes a given TrueType driver.                                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    driver :: A handle to the target TrueType driver.                  */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  tt_driver_done( FT_Module  ttdriver )     /* TT_Driver */
+  {
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+    TT_Driver  driver = (TT_Driver)ttdriver;
+
+
+    /* destroy the execution context */
+    if ( driver->context )
+    {
+      TT_Destroy_Context( driver->context, driver->root.root.memory );
+      driver->context = NULL;
+    }
+#else
+    FT_UNUSED( ttdriver );
+#endif
+
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttobjs.h b/nx-X11/extras/freetype2/src/truetype/ttobjs.h
new file mode 100644
index 000000000..423d3f005
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttobjs.h
@@ -0,0 +1,437 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttobjs.h                                                               */
+/*                                                                         */
+/*    Objects manager (specification).                                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 __TTOBJS_H__
+#define __TTOBJS_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    TT_Driver                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a TrueType driver object.                              */
+  /*                                                                       */
+  typedef struct TT_DriverRec_*  TT_Driver;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    TT_Instance                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a TrueType size object.                                */
+  /*                                                                       */
+  typedef struct TT_SizeRec_*  TT_Size;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    TT_GlyphSlot                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a TrueType glyph slot object.                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This is a direct typedef of FT_GlyphSlot, as there is nothing      */
+  /*    specific about the TrueType glyph slot.                            */
+  /*                                                                       */
+  typedef FT_GlyphSlot  TT_GlyphSlot;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_GraphicsState                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The TrueType graphics state used during bytecode interpretation.   */
+  /*                                                                       */
+  typedef struct  TT_GraphicsState_
+  {
+    FT_UShort      rp0;
+    FT_UShort      rp1;
+    FT_UShort      rp2;
+
+    FT_UnitVector  dualVector;
+    FT_UnitVector  projVector;
+    FT_UnitVector  freeVector;
+
+#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
+    FT_Bool        both_x_axis;
+#endif
+
+    FT_Long        loop;
+    FT_F26Dot6     minimum_distance;
+    FT_Int         round_state;
+
+    FT_Bool        auto_flip;
+    FT_F26Dot6     control_value_cutin;
+    FT_F26Dot6     single_width_cutin;
+    FT_F26Dot6     single_width_value;
+    FT_Short       delta_base;
+    FT_Short       delta_shift;
+
+    FT_Byte        instruct_control;
+    FT_Bool        scan_control;
+    FT_Int         scan_type;
+
+    FT_UShort      gep0;
+    FT_UShort      gep1;
+    FT_UShort      gep2;
+
+  } TT_GraphicsState;
+
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+  FT_LOCAL( void )
+  tt_glyphzone_done( TT_GlyphZone  zone );
+
+  FT_LOCAL( FT_Error )
+  tt_glyphzone_new( FT_Memory     memory,
+                    FT_UShort     maxPoints,
+                    FT_Short      maxContours,
+                    TT_GlyphZone  zone );
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  EXECUTION SUBTABLES                                                  */
+  /*                                                                       */
+  /*  These sub-tables relate to instruction execution.                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define TT_MAX_CODE_RANGES  3
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* There can only be 3 active code ranges at once:                       */
+  /*   - the Font Program                                                  */
+  /*   - the CVT Program                                                   */
+  /*   - a glyph's instructions set                                        */
+  /*                                                                       */
+  typedef enum  TT_CodeRange_Tag_
+  {
+    tt_coderange_none = 0,
+    tt_coderange_font,
+    tt_coderange_cvt,
+    tt_coderange_glyph
+
+  } TT_CodeRange_Tag;
+
+
+  typedef struct  TT_CodeRange_
+  {
+    FT_Byte*  base;
+    FT_ULong  size;
+
+  } TT_CodeRange;
+
+  typedef TT_CodeRange  TT_CodeRangeTable[TT_MAX_CODE_RANGES];
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Defines a function/instruction definition record.                     */
+  /*                                                                       */
+  typedef struct  TT_DefRecord_
+  {
+    FT_Int   range;      /* in which code range is it located? */
+    FT_Long  start;      /* where does it start?               */
+    FT_UInt  opc;        /* function #, or instruction code    */
+    FT_Bool  active;     /* is it active?                      */
+
+  } TT_DefRecord, *TT_DefArray;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Subglyph transformation record.                                       */
+  /*                                                                       */
+  typedef struct  TT_Transform_
+  {
+    FT_Fixed    xx, xy;     /* transformation matrix coefficients */
+    FT_Fixed    yx, yy;
+    FT_F26Dot6  ox, oy;     /* offsets        */
+
+  } TT_Transform;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Subglyph loading record.  Used to load composite components.          */
+  /*                                                                       */
+  typedef struct  TT_SubglyphRec_
+  {
+    FT_Long          index;        /* subglyph index; initialized with -1 */
+    FT_Bool          is_scaled;    /* is the subglyph scaled?             */
+    FT_Bool          is_hinted;    /* should it be hinted?                */
+    FT_Bool          preserve_pps; /* preserve phantom points?            */
+
+    FT_Long          file_offset;
+
+    FT_BBox          bbox;
+    FT_Pos           left_bearing;
+    FT_Pos           advance;
+
+    TT_GlyphZoneRec  zone;
+
+    FT_Long          arg1;         /* first argument                      */
+    FT_Long          arg2;         /* second argument                     */
+
+    FT_UShort        element_flag; /* current load element flag           */
+
+    TT_Transform     transform;    /* transformation matrix               */
+
+    FT_Vector        pp1, pp2;     /* phantom points (horizontal)         */
+    FT_Vector        pp3, pp4;     /* phantom points (vertical)           */
+
+  } TT_SubGlyphRec, *TT_SubGlyph_Stack;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A note regarding non-squared pixels:                                  */
+  /*                                                                       */
+  /* (This text will probably go into some docs at some time; for now, it  */
+  /*  is kept here to explain some definitions in the TIns_Metrics         */
+  /*  record).                                                             */
+  /*                                                                       */
+  /* The CVT is a one-dimensional array containing values that control     */
+  /* certain important characteristics in a font, like the height of all   */
+  /* capitals, all lowercase letter, default spacing or stem width/height. */
+  /*                                                                       */
+  /* These values are found in FUnits in the font file, and must be scaled */
+  /* to pixel coordinates before being used by the CVT and glyph programs. */
+  /* Unfortunately, when using distinct x and y resolutions (or distinct x */
+  /* and y pointsizes), there are two possible scalings.                   */
+  /*                                                                       */
+  /* A first try was to implement a `lazy' scheme where all values were    */
+  /* scaled when first used.  However, while some values are always used   */
+  /* in the same direction, some others are used under many different      */
+  /* circumstances and orientations.                                       */
+  /*                                                                       */
+  /* I have found a simpler way to do the same, and it even seems to work  */
+  /* in most of the cases:                                                 */
+  /*                                                                       */
+  /* - All CVT values are scaled to the maximum ppem size.                 */
+  /*                                                                       */
+  /* - When performing a read or write in the CVT, a ratio factor is used  */
+  /*   to perform adequate scaling.  Example:                              */
+  /*                                                                       */
+  /*     x_ppem = 14                                                       */
+  /*     y_ppem = 10                                                       */
+  /*                                                                       */
+  /*   We choose ppem = x_ppem = 14 as the CVT scaling size.  All cvt      */
+  /*   entries are scaled to it.                                           */
+  /*                                                                       */
+  /*     x_ratio = 1.0                                                     */
+  /*     y_ratio = y_ppem/ppem (< 1.0)                                     */
+  /*                                                                       */
+  /*   We compute the current ratio like:                                  */
+  /*                                                                       */
+  /*   - If projVector is horizontal,                                      */
+  /*       ratio = x_ratio = 1.0                                           */
+  /*                                                                       */
+  /*   - if projVector is vertical,                                        */
+  /*       ratio = y_ratio                                                 */
+  /*                                                                       */
+  /*   - else,                                                             */
+  /*       ratio = sqrt( (proj.x * x_ratio) ^ 2 + (proj.y * y_ratio) ^ 2 ) */
+  /*                                                                       */
+  /*   Reading a cvt value returns                                         */
+  /*     ratio * cvt[index]                                                */
+  /*                                                                       */
+  /*   Writing a cvt value in pixels:                                      */
+  /*     cvt[index] / ratio                                                */
+  /*                                                                       */
+  /*   The current ppem is simply                                          */
+  /*     ratio * ppem                                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Metrics used by the TrueType size and context objects.                */
+  /*                                                                       */
+  typedef struct  TT_Size_Metrics_
+  {
+    /* for non-square pixels */
+    FT_Long     x_ratio;
+    FT_Long     y_ratio;
+
+    FT_UShort   ppem;               /* maximum ppem size              */
+    FT_Long     ratio;              /* current ratio                  */
+    FT_Fixed    scale;
+
+    FT_F26Dot6  compensations[4];   /* device-specific compensations  */
+
+    FT_Bool     valid;
+
+    FT_Bool     rotated;            /* `is the glyph rotated?'-flag   */
+    FT_Bool     stretched;          /* `is the glyph stretched?'-flag */
+
+  } TT_Size_Metrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TrueType size class.                                                  */
+  /*                                                                       */
+  typedef struct  TT_SizeRec_
+  {
+    FT_SizeRec         root;
+
+    FT_Size_Metrics    metrics; /* slightly different from the root metrics */
+    TT_Size_Metrics    ttmetrics;
+
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+    FT_UInt            strike_index;    /* 0xFFFF to indicate invalid */
+    FT_Size_Metrics    strike_metrics;  /* current strike's metrics   */
+
+#endif
+
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+
+    FT_UInt            num_function_defs; /* number of function definitions */
+    FT_UInt            max_function_defs;
+    TT_DefArray        function_defs;     /* table of function definitions  */
+
+    FT_UInt            num_instruction_defs;  /* number of ins. definitions */
+    FT_UInt            max_instruction_defs;
+    TT_DefArray        instruction_defs;      /* table of ins. definitions  */
+
+    FT_UInt            max_func;
+    FT_UInt            max_ins;
+
+    TT_CodeRangeTable  codeRangeTable;
+
+    TT_GraphicsState   GS;
+
+    FT_ULong           cvt_size;      /* the scaled control value table */
+    FT_Long*           cvt;
+
+    FT_UShort          storage_size; /* The storage area is now part of */
+    FT_Long*           storage;      /* the instance                    */
+
+    TT_GlyphZoneRec    twilight;     /* The instance's twilight zone    */
+
+    /* debugging variables */
+
+    /* When using the debugger, we must keep the */
+    /* execution context tied to the instance    */
+    /* object rather than asking it on demand.   */
+
+    FT_Bool            debug;
+    TT_ExecContext     context;
+
+#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+  } TT_SizeRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TrueType driver class.                                                */
+  /*                                                                       */
+  typedef struct  TT_DriverRec_
+  {
+    FT_DriverRec     root;
+    TT_ExecContext   context;  /* execution context        */
+    TT_GlyphZoneRec  zone;     /* glyph loader points zone */
+
+    void*            extension_component;
+
+  } TT_DriverRec;
+
+
+  /* Note: All of the functions below (except tt_size_reset()) are used    */
+  /* as function pointers in a FT_Driver_ClassRec.  Therefore their        */
+  /* parameters are of types FT_Face, FT_Size, etc., rather than TT_Face,  */
+  /* TT_Size, etc., so that the compiler can confirm that the types and    */
+  /* number of parameters are correct.  In all cases the FT_xxx types are  */
+  /* cast to their TT_xxx counterparts inside the functions since FreeType */
+  /* will always use the TT driver to create them.                         */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Face functions                                                        */
+  /*                                                                       */
+  FT_LOCAL( FT_Error )
+  tt_face_init( FT_Stream      stream,
+                FT_Face        ttface,      /* TT_Face */
+                FT_Int         face_index,
+                FT_Int         num_params,
+                FT_Parameter*  params );
+
+  FT_LOCAL( void )
+  tt_face_done( FT_Face  ttface );          /* TT_Face */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Size functions                                                        */
+  /*                                                                       */
+  FT_LOCAL( FT_Error )
+  tt_size_init( FT_Size  ttsize );          /* TT_Size */
+
+  FT_LOCAL( void )
+  tt_size_done( FT_Size  ttsize );          /* TT_Size */
+
+  FT_LOCAL( FT_Error )
+  tt_size_reset( TT_Size  size );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Driver functions                                                      */
+  /*                                                                       */
+  FT_LOCAL( FT_Error )
+  tt_driver_init( FT_Module  ttdriver );    /* TT_Driver */
+
+  FT_LOCAL( void )
+  tt_driver_done( FT_Module  ttdriver );    /* TT_Driver */
+
+
+FT_END_HEADER
+
+#endif /* __TTOBJS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttpload.c b/nx-X11/extras/freetype2/src/truetype/ttpload.c
new file mode 100644
index 000000000..9cae477c5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttpload.c
@@ -0,0 +1,273 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttpload.c                                                              */
+/*                                                                         */
+/*    TrueType glyph data/program tables loader (body).                    */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2004 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_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+#include FT_TRUETYPE_TAGS_H
+
+#include "ttpload.h"
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+#include "ttgxvar.h"
+#endif
+
+#include "tterrors.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_ttpload
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_loca                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the locations table.                                         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_loca( TT_Face    face,
+                     FT_Stream  stream )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+    FT_Short   LongOffsets;
+    FT_ULong   table_len;
+
+
+    FT_TRACE2(( "Locations " ));
+    LongOffsets = face->header.Index_To_Loc_Format;
+
+    error = face->goto_table( face, TTAG_loca, stream, &table_len );
+    if ( error )
+    {
+      error = TT_Err_Locations_Missing;
+      goto Exit;
+    }
+
+    if ( LongOffsets != 0 )
+    {
+      face->num_locations = (FT_UShort)( table_len >> 2 );
+
+      FT_TRACE2(( "(32bit offsets): %12d ", face->num_locations ));
+
+      if ( FT_NEW_ARRAY( face->glyph_locations, face->num_locations ) )
+        goto Exit;
+
+      if ( FT_FRAME_ENTER( face->num_locations * 4L ) )
+        goto Exit;
+
+      {
+        FT_Long*  loc   = face->glyph_locations;
+        FT_Long*  limit = loc + face->num_locations;
+
+
+        for ( ; loc < limit; loc++ )
+          *loc = FT_GET_LONG();
+      }
+
+      FT_FRAME_EXIT();
+    }
+    else
+    {
+      face->num_locations = (FT_UShort)( table_len >> 1 );
+
+      FT_TRACE2(( "(16bit offsets): %12d ", face->num_locations ));
+
+      if ( FT_NEW_ARRAY( face->glyph_locations, face->num_locations ) )
+        goto Exit;
+
+      if ( FT_FRAME_ENTER( face->num_locations * 2L ) )
+        goto Exit;
+      {
+        FT_Long*  loc   = face->glyph_locations;
+        FT_Long*  limit = loc + face->num_locations;
+
+
+        for ( ; loc < limit; loc++ )
+          *loc = (FT_Long)( (FT_ULong)FT_GET_USHORT() * 2 );
+      }
+      FT_FRAME_EXIT();
+    }
+
+    FT_TRACE2(( "loaded\n" ));
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_cvt                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the control value table into a face object.                  */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream :: A handle to the input stream.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_cvt( TT_Face    face,
+                    FT_Stream  stream )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+    FT_ULong   table_len;
+
+
+    FT_TRACE2(( "CVT " ));
+
+    error = face->goto_table( face, TTAG_cvt, stream, &table_len );
+    if ( error )
+    {
+      FT_TRACE2(( "is missing!\n" ));
+
+      face->cvt_size = 0;
+      face->cvt      = NULL;
+      error          = TT_Err_Ok;
+
+      goto Exit;
+    }
+
+    face->cvt_size = table_len / 2;
+
+    if ( FT_NEW_ARRAY( face->cvt, face->cvt_size ) )
+      goto Exit;
+
+    if ( FT_FRAME_ENTER( face->cvt_size * 2L ) )
+      goto Exit;
+
+    {
+      FT_Short*  cur   = face->cvt;
+      FT_Short*  limit = cur + face->cvt_size;
+
+
+      for ( ; cur <  limit; cur++ )
+        *cur = FT_GET_SHORT();
+    }
+
+    FT_FRAME_EXIT();
+    FT_TRACE2(( "loaded\n" ));
+
+#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
+    if ( face->doblend )
+      error = tt_face_vary_cvt( face, stream );
+#endif
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_load_fpgm                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the font program and the cvt program.                        */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream :: A handle to the input stream.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  tt_face_load_fpgm( TT_Face    face,
+                     FT_Stream  stream )
+  {
+    FT_Error   error;
+    FT_ULong   table_len;
+
+
+    FT_TRACE2(( "Font program " ));
+
+    /* The font program is optional */
+    error = face->goto_table( face, TTAG_fpgm, stream, &table_len );
+    if ( error )
+    {
+      face->font_program      = NULL;
+      face->font_program_size = 0;
+
+      FT_TRACE2(( "is missing!\n" ));
+    }
+    else
+    {
+      face->font_program_size = table_len;
+      if ( FT_FRAME_EXTRACT( table_len, face->font_program ) )
+        goto Exit;
+
+      FT_TRACE2(( "loaded, %12d bytes\n", face->font_program_size ));
+    }
+
+    FT_TRACE2(( "Prep program " ));
+
+    error = face->goto_table( face, TTAG_prep, stream, &table_len );
+    if ( error )
+    {
+      face->cvt_program      = NULL;
+      face->cvt_program_size = 0;
+      error                  = TT_Err_Ok;
+
+      FT_TRACE2(( "is missing!\n" ));
+    }
+    else
+    {
+      face->cvt_program_size = table_len;
+      if ( FT_FRAME_EXTRACT( table_len, face->cvt_program ) )
+        goto Exit;
+
+      FT_TRACE2(( "loaded, %12d bytes\n", face->cvt_program_size ));
+    }
+
+  Exit:
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/truetype/ttpload.h b/nx-X11/extras/freetype2/src/truetype/ttpload.h
new file mode 100644
index 000000000..3f8cd64ff
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/truetype/ttpload.h
@@ -0,0 +1,48 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttpload.h                                                              */
+/*                                                                         */
+/*    TrueType glyph data/program tables loader (specification).           */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __TTPLOAD_H__
+#define __TTPLOAD_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_loca( TT_Face    face,
+                     FT_Stream  stream );
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_cvt( TT_Face    face,
+                    FT_Stream  stream );
+
+  FT_LOCAL( FT_Error )
+  tt_face_load_fpgm( TT_Face    face,
+                     FT_Stream  stream );
+
+
+FT_END_HEADER
+
+#endif /* __TTPLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/Jamfile b/nx-X11/extras/freetype2/src/type1/Jamfile
new file mode 100644
index 000000000..4d966f3d6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/type1 Jamfile (c) 2001 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) type1 ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = t1afm t1driver t1objs t1load t1gload t1parse ;
+  }
+  else
+  {
+    _sources = type1 ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/type1 Jamfile
diff --git a/nx-X11/extras/freetype2/src/type1/module.mk b/nx-X11/extras/freetype2/src/type1/module.mk
new file mode 100644
index 000000000..82d9355ba
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 Type1 module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_type1_driver
+
+add_type1_driver:
+	$(OPEN_DRIVER)t1_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)type1     $(ECHO_DRIVER_DESC)Postscript font files with extension *.pfa or *.pfb$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/type1/rules.mk b/nx-X11/extras/freetype2/src/type1/rules.mk
new file mode 100644
index 000000000..15087b030
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/rules.mk
@@ -0,0 +1,73 @@
+#
+# FreeType 2 Type1 driver configuration rules
+#
+
+
+# Copyright 1996-2000, 2001, 2003 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.
+
+
+# Type1 driver directory
+#
+T1_DIR := $(SRC_DIR)/type1
+
+
+# compilation flags for the driver
+#
+T1_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(T1_DIR))
+
+
+# Type1 driver sources (i.e., C files)
+#
+T1_DRV_SRC := $(T1_DIR)/t1parse.c  \
+              $(T1_DIR)/t1load.c   \
+              $(T1_DIR)/t1driver.c \
+              $(T1_DIR)/t1afm.c    \
+              $(T1_DIR)/t1gload.c  \
+              $(T1_DIR)/t1objs.c
+
+# Type1 driver headers
+#
+T1_DRV_H := $(T1_DRV_SRC:%.c=%.h) \
+            $(T1_DIR)/t1tokens.h  \
+            $(T1_DIR)/t1errors.h
+
+
+# Type1 driver object(s)
+#
+#   T1_DRV_OBJ_M is used during `multi' builds
+#   T1_DRV_OBJ_S is used during `single' builds
+#
+T1_DRV_OBJ_M := $(T1_DRV_SRC:$(T1_DIR)/%.c=$(OBJ_DIR)/%.$O)
+T1_DRV_OBJ_S := $(OBJ_DIR)/type1.$O
+
+# Type1 driver source file for single build
+#
+T1_DRV_SRC_S := $(T1_DIR)/type1.c
+
+
+# Type1 driver - single object
+#
+$(T1_DRV_OBJ_S): $(T1_DRV_SRC_S) $(T1_DRV_SRC) $(FREETYPE_H) $(T1_DRV_H)
+	$(T1_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(T1_DRV_SRC_S))
+
+
+# Type1 driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(T1_DIR)/%.c $(FREETYPE_H) $(T1_DRV_H)
+	$(T1_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(T1_DRV_OBJ_S)
+DRV_OBJS_M += $(T1_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/type1/t1afm.c b/nx-X11/extras/freetype2/src/type1/t1afm.c
new file mode 100644
index 000000000..9945ebdf6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1afm.c
@@ -0,0 +1,282 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1afm.c                                                                */
+/*                                                                         */
+/*    AFM support for Type 1 fonts (body).                                 */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 "t1afm.h"
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_TYPE1_TYPES_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_t1afm
+
+
+  FT_LOCAL_DEF( void )
+  T1_Done_AFM( FT_Memory  memory,
+               T1_AFM*    afm )
+  {
+    FT_FREE( afm->kern_pairs );
+    afm->num_pairs = 0;
+    FT_FREE( afm );
+  }
+
+
+#undef  IS_KERN_PAIR
+#define IS_KERN_PAIR( p )  ( p[0] == 'K' && p[1] == 'P' )
+
+#define IS_ALPHANUM( c )  ( ft_isalnum( c ) || \
+                            c == '_'        || \
+                            c == '.'        )
+
+
+  /* read a glyph name and return the equivalent glyph index */
+  static FT_UInt
+  afm_atoindex( FT_Byte**  start,
+                FT_Byte*   limit,
+                T1_Font    type1 )
+  {
+    FT_Byte*    p = *start;
+    FT_PtrDist  len;
+    FT_UInt     result = 0;
+    char        temp[64];
+
+
+    /* skip whitespace */
+    while ( ( *p == ' ' || *p == '\t' || *p == ':' || *p == ';' ) &&
+            p < limit                                             )
+      p++;
+    *start = p;
+
+    /* now, read glyph name */
+    while ( IS_ALPHANUM( *p ) && p < limit )
+      p++;
+
+    len = p - *start;
+
+    if ( len > 0 && len < 64 )
+    {
+      FT_Int  n;
+
+
+      /* copy glyph name to intermediate array */
+      FT_MEM_COPY( temp, *start, len );
+      temp[len] = 0;
+
+      /* lookup glyph name in face array */
+      for ( n = 0; n < type1->num_glyphs; n++ )
+      {
+        char*  gname = (char*)type1->glyph_names[n];
+
+
+        if ( gname && gname[0] == temp[0] && ft_strcmp( gname, temp ) == 0 )
+        {
+          result = n;
+          break;
+        }
+      }
+    }
+    *start = p;
+    return result;
+  }
+
+
+  /* read an integer */
+  static int
+  afm_atoi( FT_Byte**  start,
+            FT_Byte*   limit )
+  {
+    FT_Byte*  p    = *start;
+    int       sum  = 0;
+    int       sign = 1;
+
+
+    /* skip everything that is not a number */
+    while ( p < limit && !isdigit( *p ) )
+    {
+      sign = 1;
+      if ( *p == '-' )
+        sign = -1;
+
+      p++;
+    }
+
+    while ( p < limit && isdigit( *p ) )
+    {
+      sum = sum * 10 + ( *p - '0' );
+      p++;
+    }
+    *start = p;
+
+    return sum * sign;
+  }
+
+
+#undef  KERN_INDEX
+#define KERN_INDEX( g1, g2 )  ( ( (FT_ULong)g1 << 16 ) | g2 )
+
+
+  /* compare two kerning pairs */
+  FT_CALLBACK_DEF( int )
+  compare_kern_pairs( const void*  a,
+                      const void*  b )
+  {
+    T1_Kern_Pair*  pair1 = (T1_Kern_Pair*)a;
+    T1_Kern_Pair*  pair2 = (T1_Kern_Pair*)b;
+
+    FT_ULong  index1 = KERN_INDEX( pair1->glyph1, pair1->glyph2 );
+    FT_ULong  index2 = KERN_INDEX( pair2->glyph1, pair2->glyph2 );
+
+
+    return (int)( index1 - index2 );
+  }
+
+
+  /* parse an AFM file -- for now, only read the kerning pairs */
+  FT_LOCAL_DEF( FT_Error )
+  T1_Read_AFM( FT_Face    t1_face,
+               FT_Stream  stream )
+  {
+    FT_Error       error;
+    FT_Memory      memory = stream->memory;
+    FT_Byte*       start;
+    FT_Byte*       limit;
+    FT_Byte*       p;
+    FT_Int         count = 0;
+    T1_Kern_Pair*  pair;
+    T1_Font        type1 = &((T1_Face)t1_face)->type1;
+    T1_AFM*        afm   = 0;
+
+
+    if ( FT_FRAME_ENTER( stream->size ) )
+      return error;
+
+    start = (FT_Byte*)stream->cursor;
+    limit = (FT_Byte*)stream->limit;
+    p     = start;
+
+    /* we are now going to count the occurences of `KP' or `KPX' in */
+    /* the AFM file                                                 */
+    count = 0;
+    for ( p = start; p < limit - 3; p++ )
+    {
+      if ( IS_KERN_PAIR( p ) )
+        count++;
+    }
+
+    /* Actually, kerning pairs are simply optional! */
+    if ( count == 0 )
+      goto Exit;
+
+    /* allocate the pairs */
+    if ( FT_NEW( afm ) || FT_NEW_ARRAY( afm->kern_pairs, count ) )
+      goto Exit;
+
+    /* now, read each kern pair */
+    pair           = afm->kern_pairs;
+    afm->num_pairs = count;
+
+    /* save in face object */
+    ((T1_Face)t1_face)->afm_data = afm;
+
+    t1_face->face_flags |= FT_FACE_FLAG_KERNING;
+
+    for ( p = start; p < limit - 3; p++ )
+    {
+      if ( IS_KERN_PAIR( p ) )
+      {
+        FT_Byte*  q;
+
+
+        /* skip keyword (KP or KPX) */
+        q = p + 2;
+        if ( *q == 'X' )
+          q++;
+
+        pair->glyph1    = afm_atoindex( &q, limit, type1 );
+        pair->glyph2    = afm_atoindex( &q, limit, type1 );
+        pair->kerning.x = afm_atoi( &q, limit );
+
+        pair->kerning.y = 0;
+        if ( p[2] != 'X' )
+          pair->kerning.y = afm_atoi( &q, limit );
+
+        pair++;
+      }
+    }
+
+    /* now, sort the kern pairs according to their glyph indices */
+    ft_qsort( afm->kern_pairs, count, sizeof ( T1_Kern_Pair ),
+              compare_kern_pairs );
+
+  Exit:
+    if ( error )
+      FT_FREE( afm );
+
+    FT_FRAME_EXIT();
+
+    return error;
+  }
+
+
+  /* find the kerning for a given glyph pair */
+  FT_LOCAL_DEF( void )
+  T1_Get_Kerning( T1_AFM*     afm,
+                  FT_UInt     glyph1,
+                  FT_UInt     glyph2,
+                  FT_Vector*  kerning )
+  {
+    T1_Kern_Pair  *min, *mid, *max;
+    FT_ULong      idx = KERN_INDEX( glyph1, glyph2 );
+
+
+    /* simple binary search */
+    min = afm->kern_pairs;
+    max = min + afm->num_pairs - 1;
+
+    while ( min <= max )
+    {
+      FT_ULong  midi;
+
+
+      mid  = min + ( max - min ) / 2;
+      midi = KERN_INDEX( mid->glyph1, mid->glyph2 );
+
+      if ( midi == idx )
+      {
+        *kerning = mid->kerning;
+        return;
+      }
+
+      if ( midi < idx )
+        min = mid + 1;
+      else
+        max = mid - 1;
+    }
+
+    kerning->x = 0;
+    kerning->y = 0;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1afm.h b/nx-X11/extras/freetype2/src/type1/t1afm.h
new file mode 100644
index 000000000..77cc6a6e9
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1afm.h
@@ -0,0 +1,66 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1afm.h                                                                */
+/*                                                                         */
+/*    AFM support for Type 1 fonts (specification).                        */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __T1AFM_H__
+#define __T1AFM_H__
+
+#include <ft2build.h>
+#include "t1objs.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  T1_Kern_Pair_
+  {
+    FT_UInt    glyph1;
+    FT_UInt    glyph2;
+    FT_Vector  kerning;
+
+  } T1_Kern_Pair;
+
+
+  typedef struct  T1_AFM_
+  {
+    FT_Int         num_pairs;
+    T1_Kern_Pair*  kern_pairs;
+
+  } T1_AFM;
+
+
+  FT_LOCAL( FT_Error )
+  T1_Read_AFM( FT_Face    face,
+               FT_Stream  stream );
+
+  FT_LOCAL( void )
+  T1_Done_AFM( FT_Memory  memory,
+               T1_AFM*    afm );
+
+  FT_LOCAL( void )
+  T1_Get_Kerning( T1_AFM*     afm,
+                  FT_UInt     glyph1,
+                  FT_UInt     glyph2,
+                  FT_Vector*  kerning );
+
+
+FT_END_HEADER
+
+#endif /* __T1AFM_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1driver.c b/nx-X11/extras/freetype2/src/type1/t1driver.c
new file mode 100644
index 000000000..b37ae77c5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1driver.c
@@ -0,0 +1,303 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1driver.c                                                             */
+/*                                                                         */
+/*    Type 1 driver interface (body).                                      */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 "t1driver.h"
+#include "t1gload.h"
+#include "t1load.h"
+
+#include "t1errors.h"
+
+#ifndef T1_CONFIG_OPTION_NO_AFM
+#include "t1afm.h"
+#endif
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+
+#include FT_SERVICE_MULTIPLE_MASTERS_H
+#include FT_SERVICE_GLYPH_DICT_H
+#include FT_SERVICE_XFREE86_NAME_H
+#include FT_SERVICE_POSTSCRIPT_NAME_H
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+#include FT_SERVICE_POSTSCRIPT_INFO_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_t1driver
+
+ /*
+  *  GLYPH DICT SERVICE
+  *
+  */
+
+  static FT_Error
+  t1_get_glyph_name( T1_Face     face,
+                     FT_UInt     glyph_index,
+                     FT_Pointer  buffer,
+                     FT_UInt     buffer_max )
+  {
+    FT_String*  gname;
+
+
+    gname = face->type1.glyph_names[glyph_index];
+
+    if ( buffer_max > 0 )
+    {
+      FT_UInt  len = (FT_UInt)( ft_strlen( gname ) );
+
+
+      if (len >= buffer_max)
+        len = buffer_max - 1;
+
+      FT_MEM_COPY( buffer, gname, len );
+      ((FT_Byte*)buffer)[len] = 0;
+    }
+
+    return T1_Err_Ok;
+  }
+
+
+  static FT_UInt
+  t1_get_name_index( T1_Face     face,
+                     FT_String*  glyph_name )
+  {
+    FT_Int      i;
+    FT_String*  gname;
+
+
+    for ( i = 0; i < face->type1.num_glyphs; i++ )
+    {
+      gname = face->type1.glyph_names[i];
+
+      if ( !ft_strcmp( glyph_name, gname ) )
+        return (FT_UInt)i;
+    }
+
+    return 0;
+  }
+
+  static const FT_Service_GlyphDictRec  t1_service_glyph_dict =
+  {
+    (FT_GlyphDict_GetNameFunc)  t1_get_glyph_name,
+    (FT_GlyphDict_NameIndexFunc)t1_get_name_index
+  };
+
+
+ /*
+  *  POSTSCRIPT NAME SERVICE
+  *
+  */
+
+  static const char*
+  t1_get_ps_name( T1_Face  face )
+  {
+    return (const char*) face->type1.font_name;
+  }
+
+  static const FT_Service_PsFontNameRec  t1_service_ps_name =
+  {
+    (FT_PsName_GetFunc)t1_get_ps_name
+  };
+
+
+ /*
+  *  MULTIPLE MASTERS SERVICE
+  *
+  */
+
+#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
+  static const FT_Service_MultiMastersRec  t1_service_multi_masters =
+  {
+    (FT_Get_MM_Func)        T1_Get_Multi_Master,
+    (FT_Set_MM_Design_Func) T1_Set_MM_Design,
+    (FT_Set_MM_Blend_Func)  T1_Set_MM_Blend,
+    (FT_Get_MM_Var_Func)    T1_Get_MM_Var,
+    (FT_Set_Var_Design_Func)T1_Set_Var_Design
+  };
+#endif
+
+
+ /*
+  *  POSTSCRIPT INFO SERVICE
+  *
+  */
+
+  static FT_Error
+  t1_ps_get_font_info( FT_Face          face,
+                       PS_FontInfoRec*  afont_info )
+  {
+    *afont_info = ((T1_Face)face)->type1.font_info;
+    return 0;
+  }
+
+
+  static FT_Int
+  t1_ps_has_glyph_names( FT_Face  face )
+  {
+    FT_UNUSED( face );
+    return 1;
+  }
+
+
+  static const FT_Service_PsInfoRec  t1_service_ps_info =
+  {
+    (PS_GetFontInfoFunc)  t1_ps_get_font_info,
+    (PS_HasGlyphNamesFunc)t1_ps_has_glyph_names
+  };
+
+
+ /*
+  *  SERVICE LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  t1_services[] =
+  {
+    { FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &t1_service_ps_name },
+    { FT_SERVICE_ID_GLYPH_DICT,           &t1_service_glyph_dict },
+    { FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_TYPE_1 },
+    { FT_SERVICE_ID_POSTSCRIPT_INFO,      &t1_service_ps_info },
+
+#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
+    { FT_SERVICE_ID_MULTI_MASTERS,        &t1_service_multi_masters },
+#endif
+    { NULL, NULL }
+  };
+
+
+  static FT_Module_Interface
+  Get_Interface( FT_Driver         driver,
+                 const FT_String*  t1_interface )
+  {
+    FT_UNUSED( driver );
+
+    return ft_service_list_lookup( t1_services, t1_interface );
+  }
+
+
+#ifndef T1_CONFIG_OPTION_NO_AFM
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Kerning                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to return the kerning vector between two      */
+  /*    glyphs of the same face.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to the source face object.                 */
+  /*                                                                       */
+  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
+  /*                                                                       */
+  /*    right_glyph :: The index of the right glyph in the kern pair.      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    kerning     :: The kerning vector.  This is in font units for      */
+  /*                   scalable formats, and in pixels for fixed-sizes     */
+  /*                   formats.                                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
+  /*    supported by this function.  Other layouts, or more sophisticated  */
+  /*    kernings are out of scope of this method (the basic driver         */
+  /*    interface is meant to be simple).                                  */
+  /*                                                                       */
+  /*    They can be implemented by format-specific interfaces.             */
+  /*                                                                       */
+  static FT_Error
+  Get_Kerning( T1_Face     face,
+               FT_UInt     left_glyph,
+               FT_UInt     right_glyph,
+               FT_Vector*  kerning )
+  {
+    T1_AFM*  afm;
+
+
+    kerning->x = 0;
+    kerning->y = 0;
+
+    afm = (T1_AFM*)face->afm_data;
+    if ( afm )
+      T1_Get_Kerning( afm, left_glyph, right_glyph, kerning );
+
+    return T1_Err_Ok;
+  }
+
+
+#endif /* T1_CONFIG_OPTION_NO_AFM */
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  t1_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER       |
+      FT_MODULE_DRIVER_SCALABLE   |
+      FT_MODULE_DRIVER_HAS_HINTER,
+
+      sizeof( FT_DriverRec ),
+
+      "type1",
+      0x10000L,
+      0x20000L,
+
+      0,   /* format interface */
+
+      (FT_Module_Constructor)T1_Driver_Init,
+      (FT_Module_Destructor) T1_Driver_Done,
+      (FT_Module_Requester)  Get_Interface,
+    },
+
+    sizeof( T1_FaceRec ),
+    sizeof( T1_SizeRec ),
+    sizeof( T1_GlyphSlotRec ),
+
+    (FT_Face_InitFunc)        T1_Face_Init,
+    (FT_Face_DoneFunc)        T1_Face_Done,
+    (FT_Size_InitFunc)        T1_Size_Init,
+    (FT_Size_DoneFunc)        T1_Size_Done,
+    (FT_Slot_InitFunc)        T1_GlyphSlot_Init,
+    (FT_Slot_DoneFunc)        T1_GlyphSlot_Done,
+
+    (FT_Size_ResetPointsFunc) T1_Size_Reset,
+    (FT_Size_ResetPixelsFunc) T1_Size_Reset,
+    (FT_Slot_LoadFunc)        T1_Load_Glyph,
+
+#ifdef T1_CONFIG_OPTION_NO_AFM
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+#else
+    (FT_Face_GetKerningFunc)  Get_Kerning,
+    (FT_Face_AttachFunc)      T1_Read_AFM,
+#endif
+    (FT_Face_GetAdvancesFunc) 0
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1driver.h b/nx-X11/extras/freetype2/src/type1/t1driver.h
new file mode 100644
index 000000000..ad429440d
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1driver.h
@@ -0,0 +1,38 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1driver.h                                                             */
+/*                                                                         */
+/*    High-level Type 1 driver interface (specification).                  */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __T1DRIVER_H__
+#define __T1DRIVER_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  t1_driver_class;
+
+
+FT_END_HEADER
+
+#endif /* __T1DRIVER_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1errors.h b/nx-X11/extras/freetype2/src/type1/t1errors.h
new file mode 100644
index 000000000..81221c343
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1errors.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1errors.h                                                             */
+/*                                                                         */
+/*    Type 1 error codes (specification only).                             */
+/*                                                                         */
+/*  Copyright 2001 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 Type 1 error enumeration constants.   */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __T1ERRORS_H__
+#define __T1ERRORS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  T1_Err_
+#define FT_ERR_BASE    FT_Mod_Err_Type1
+
+#include FT_ERRORS_H
+
+#endif /* __T1ERRORS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1gload.c b/nx-X11/extras/freetype2/src/type1/t1gload.c
new file mode 100644
index 000000000..f45a83b40
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1gload.c
@@ -0,0 +1,431 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1gload.c                                                              */
+/*                                                                         */
+/*    Type 1 Glyph Loader (body).                                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 "t1gload.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+
+#include "t1errors.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_t1gload
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /**********                                                      *********/
+  /**********            COMPUTE THE MAXIMUM ADVANCE WIDTH         *********/
+  /**********                                                      *********/
+  /**********    The following code is in charge of computing      *********/
+  /**********    the maximum advance width of the font.  It        *********/
+  /**********    quickly processes each glyph charstring to        *********/
+  /**********    extract the value from either a `sbw' or `seac'   *********/
+  /**********    operator.                                         *********/
+  /**********                                                      *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Parse_Glyph_And_Get_Char_String( T1_Decoder  decoder,
+                                      FT_UInt     glyph_index,
+                                      FT_Data*    char_string )
+  {
+    T1_Face   face  = (T1_Face)decoder->builder.face;
+    T1_Font   type1 = &face->type1;
+    FT_Error  error = T1_Err_Ok;
+
+
+    decoder->font_matrix = type1->font_matrix;
+    decoder->font_offset = type1->font_offset;
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    /* For incremental fonts get the character data using the */
+    /* callback function.                                     */
+    if ( face->root.internal->incremental_interface )
+      error = face->root.internal->incremental_interface->funcs->get_glyph_data(
+                face->root.internal->incremental_interface->object,
+                glyph_index, char_string );
+    else
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+    /* For ordinary fonts get the character data stored in the face record. */
+    {
+      char_string->pointer = type1->charstrings[glyph_index];
+      char_string->length  = (FT_Int)type1->charstrings_len[glyph_index];
+    }
+
+    if ( !error )
+      error = decoder->funcs.parse_charstrings(
+                decoder, (FT_Byte*)char_string->pointer,
+                char_string->length );
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    /* Incremental fonts can optionally override the metrics. */
+    if ( !error && face->root.internal->incremental_interface                 &&
+         face->root.internal->incremental_interface->funcs->get_glyph_metrics )
+    {
+      FT_Incremental_MetricsRec  metrics;
+
+
+      metrics.bearing_x = decoder->builder.left_bearing.x;
+      metrics.bearing_y = decoder->builder.left_bearing.y;
+      metrics.advance   = decoder->builder.advance.x;
+      error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
+                face->root.internal->incremental_interface->object,
+                glyph_index, FALSE, &metrics );
+      decoder->builder.left_bearing.x = metrics.bearing_x;
+      decoder->builder.left_bearing.y = metrics.bearing_y;
+      decoder->builder.advance.x      = metrics.advance;
+      decoder->builder.advance.y      = 0;
+    }
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  T1_Parse_Glyph( T1_Decoder  decoder,
+                  FT_UInt     glyph_index )
+  {
+    FT_Data   glyph_data;
+    FT_Error  error = T1_Parse_Glyph_And_Get_Char_String(
+                        decoder, glyph_index, &glyph_data );
+
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+
+    if ( !error )
+    {
+      T1_Face  face = (T1_Face)decoder->builder.face;
+
+
+      if ( face->root.internal->incremental_interface )
+        face->root.internal->incremental_interface->funcs->free_glyph_data(
+          face->root.internal->incremental_interface->object,
+          &glyph_data );
+    }
+
+#endif /* FT_CONFIG_OPTION_INCREMENTAL */
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Compute_Max_Advance( T1_Face  face,
+                          FT_Pos*  max_advance )
+  {
+    FT_Error       error;
+    T1_DecoderRec  decoder;
+    FT_Int         glyph_index;
+    T1_Font        type1 = &face->type1;
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
+
+
+    *max_advance = 0;
+
+    /* initialize load decoder */
+    error = psaux->t1_decoder_funcs->init( &decoder,
+                                           (FT_Face)face,
+                                           0, /* size       */
+                                           0, /* glyph slot */
+                                           (FT_Byte**)type1->glyph_names,
+                                           face->blend,
+                                           0,
+                                           FT_RENDER_MODE_NORMAL,
+                                           T1_Parse_Glyph );
+    if ( error )
+      return error;
+
+    decoder.builder.metrics_only = 1;
+    decoder.builder.load_points  = 0;
+
+    decoder.num_subrs = type1->num_subrs;
+    decoder.subrs     = type1->subrs;
+    decoder.subrs_len = type1->subrs_len;
+
+    *max_advance = 0;
+
+    /* for each glyph, parse the glyph charstring and extract */
+    /* the advance width                                      */
+    for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ )
+    {
+      /* now get load the unscaled outline */
+      error = T1_Parse_Glyph( &decoder, glyph_index );
+      if ( glyph_index == 0 || decoder.builder.advance.x > *max_advance )
+        *max_advance = decoder.builder.advance.x;
+
+      /* ignore the error if one occurred - skip to next glyph */
+    }
+
+    return T1_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /**********                                                      *********/
+  /**********               UNHINTED GLYPH LOADER                  *********/
+  /**********                                                      *********/
+  /**********    The following code is in charge of loading a      *********/
+  /**********    single outline.  It completely ignores hinting    *********/
+  /**********    and is used when FT_LOAD_NO_HINTING is set.       *********/
+  /**********                                                      *********/
+  /**********      The Type 1 hinter is located in `t1hint.c'      *********/
+  /**********                                                      *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Load_Glyph( T1_GlyphSlot  glyph,
+                 T1_Size       size,
+                 FT_UInt       glyph_index,
+                 FT_Int32      load_flags )
+  {
+    FT_Error                error;
+    T1_DecoderRec           decoder;
+    T1_Face                 face = (T1_Face)glyph->root.face;
+    FT_Bool                 hinting;
+    T1_Font                 type1         = &face->type1;
+    PSAux_Service           psaux         = (PSAux_Service)face->psaux;
+    const T1_Decoder_Funcs  decoder_funcs = psaux->t1_decoder_funcs;
+
+    FT_Matrix               font_matrix;
+    FT_Vector               font_offset;
+    FT_Data                 glyph_data;
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    FT_Bool                 glyph_data_loaded = 0;
+#endif
+
+
+    if ( load_flags & FT_LOAD_NO_RECURSE )
+      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
+
+    glyph->x_scale = size->root.metrics.x_scale;
+    glyph->y_scale = size->root.metrics.y_scale;
+
+    glyph->root.outline.n_points   = 0;
+    glyph->root.outline.n_contours = 0;
+
+    hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE   ) == 0 &&
+                       ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
+
+    glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;
+
+    error = decoder_funcs->init( &decoder,
+                                 (FT_Face)face,
+                                 (FT_Size)size,
+                                 (FT_GlyphSlot)glyph,
+                                 (FT_Byte**)type1->glyph_names,
+                                 face->blend,
+                                 FT_BOOL( hinting ),
+                                 FT_LOAD_TARGET_MODE( load_flags ),
+                                 T1_Parse_Glyph );
+    if ( error )
+      goto Exit;
+
+    decoder.builder.no_recurse = FT_BOOL(
+                                   ( load_flags & FT_LOAD_NO_RECURSE ) != 0 );
+
+    decoder.num_subrs = type1->num_subrs;
+    decoder.subrs     = type1->subrs;
+    decoder.subrs_len = type1->subrs_len;
+
+    /* now load the unscaled outline */
+    error = T1_Parse_Glyph_And_Get_Char_String( &decoder, glyph_index,
+                                                &glyph_data );
+    if ( error )
+      goto Exit;
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    glyph_data_loaded = 1;
+#endif
+
+    font_matrix = decoder.font_matrix;
+    font_offset = decoder.font_offset;
+
+    /* save new glyph tables */
+    decoder_funcs->done( &decoder );
+
+    /* now, set the metrics -- this is rather simple, as   */
+    /* the left side bearing is the xMin, and the top side */
+    /* bearing the yMax                                    */
+    if ( !error )
+    {
+      glyph->root.outline.flags &= FT_OUTLINE_OWNER;
+      glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;
+
+      /* for composite glyphs, return only left side bearing and */
+      /* advance width                                           */
+      if ( load_flags & FT_LOAD_NO_RECURSE )
+      {
+        FT_Slot_Internal  internal = glyph->root.internal;
+
+
+        glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
+        glyph->root.metrics.horiAdvance  = decoder.builder.advance.x;
+        internal->glyph_matrix           = font_matrix;
+        internal->glyph_delta            = font_offset;
+        internal->glyph_transformed      = 1;
+      }
+      else
+      {
+        FT_BBox            cbox;
+        FT_Glyph_Metrics*  metrics = &glyph->root.metrics;
+        FT_Vector          advance;
+
+
+        /* copy the _unscaled_ advance width */
+        metrics->horiAdvance                    = decoder.builder.advance.x;
+        glyph->root.linearHoriAdvance           = decoder.builder.advance.x;
+        glyph->root.internal->glyph_transformed = 0;
+
+        /* make up vertical metrics */
+        metrics->vertBearingX = 0;
+        metrics->vertBearingY = 0;
+        metrics->vertAdvance  = 0;
+
+        glyph->root.linearVertAdvance = 0;
+
+        glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;
+
+        if ( size && size->root.metrics.y_ppem < 24 )
+          glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;
+
+#if 1
+        /* apply the font matrix, if any */
+        FT_Outline_Transform( &glyph->root.outline, &font_matrix );
+
+        FT_Outline_Translate( &glyph->root.outline,
+                              font_offset.x,
+                              font_offset.y );
+
+        advance.x = metrics->horiAdvance;
+        advance.y = 0;
+        FT_Vector_Transform( &advance, &font_matrix );
+        metrics->horiAdvance = advance.x + font_offset.x;
+        advance.x = 0;
+        advance.y = metrics->vertAdvance;
+        FT_Vector_Transform( &advance, &font_matrix );
+        metrics->vertAdvance = advance.y + font_offset.y;
+#endif
+
+        if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )
+        {
+          /* scale the outline and the metrics */
+          FT_Int       n;
+          FT_Outline*  cur = decoder.builder.base;
+          FT_Vector*   vec = cur->points;
+          FT_Fixed     x_scale = glyph->x_scale;
+          FT_Fixed     y_scale = glyph->y_scale;
+
+
+          /* First of all, scale the points, if we are not hinting */
+          if ( !hinting )
+            for ( n = cur->n_points; n > 0; n--, vec++ )
+            {
+              vec->x = FT_MulFix( vec->x, x_scale );
+              vec->y = FT_MulFix( vec->y, y_scale );
+            }
+
+          FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
+
+          /* Then scale the metrics */
+          metrics->horiAdvance  = FT_MulFix( metrics->horiAdvance,  x_scale );
+          metrics->vertAdvance  = FT_MulFix( metrics->vertAdvance,  y_scale );
+
+          metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );
+          metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );
+
+          if ( hinting )
+          {
+            metrics->horiAdvance = FT_PIX_ROUND( metrics->horiAdvance );
+            metrics->vertAdvance = FT_PIX_ROUND( metrics->vertAdvance );
+
+            metrics->vertBearingX = FT_PIX_ROUND( metrics->vertBearingX );
+            metrics->vertBearingY = FT_PIX_ROUND( metrics->vertBearingY );
+          }
+        }
+
+        /* compute the other metrics */
+        FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
+
+        /* grid fit the bounding box if necessary */
+        if ( hinting )
+        {
+          cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
+          cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
+          cbox.xMax = FT_PIX_CEIL( cbox.xMax );
+          cbox.yMax = FT_PIX_CEIL( cbox.yMax );
+        }
+
+        metrics->width  = cbox.xMax - cbox.xMin;
+        metrics->height = cbox.yMax - cbox.yMin;
+
+        metrics->horiBearingX = cbox.xMin;
+        metrics->horiBearingY = cbox.yMax;
+      }
+
+      /* Set control data to the glyph charstrings.  Note that this is */
+      /* _not_ zero-terminated.                                        */
+      glyph->root.control_data = (FT_Byte*)glyph_data.pointer;
+      glyph->root.control_len  = glyph_data.length;
+    }
+
+
+  Exit:
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    if ( glyph_data_loaded && face->root.internal->incremental_interface )
+    {
+      face->root.internal->incremental_interface->funcs->free_glyph_data(
+        face->root.internal->incremental_interface->object,
+        &glyph_data );
+
+      /* Set the control data to null - it is no longer available if   */
+      /* loaded incrementally.                                         */
+      glyph->root.control_data = 0;
+      glyph->root.control_len  = 0;
+    }
+#endif
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1gload.h b/nx-X11/extras/freetype2/src/type1/t1gload.h
new file mode 100644
index 000000000..de87896dc
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1gload.h
@@ -0,0 +1,46 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1gload.h                                                              */
+/*                                                                         */
+/*    Type 1 Glyph Loader (specification).                                 */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 __T1GLOAD_H__
+#define __T1GLOAD_H__
+
+
+#include <ft2build.h>
+#include "t1objs.h"
+
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( FT_Error )
+  T1_Compute_Max_Advance( T1_Face  face,
+                          FT_Pos*  max_advance );
+
+  FT_LOCAL( FT_Error )
+  T1_Load_Glyph( T1_GlyphSlot  glyph,
+                 T1_Size       size,
+                 FT_UInt       glyph_index,
+                 FT_Int32      load_flags );
+
+
+FT_END_HEADER
+
+#endif /* __T1GLOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1load.c b/nx-X11/extras/freetype2/src/type1/t1load.c
new file mode 100644
index 000000000..7ec163ad5
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1load.c
@@ -0,0 +1,2094 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1load.c                                                               */
+/*                                                                         */
+/*    Type 1 font loader (body).                                           */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 is the new and improved Type 1 data loader for FreeType 2.  The  */
+  /* old loader has several problems: it is slow, complex, difficult to    */
+  /* maintain, and contains incredible hacks to make it accept some        */
+  /* ill-formed Type 1 fonts without hiccup-ing.  Moreover, about 5% of    */
+  /* the Type 1 fonts on my machine still aren't loaded correctly by it.   */
+  /*                                                                       */
+  /* This version is much simpler, much faster and also easier to read and */
+  /* maintain by a great order of magnitude.  The idea behind it is to     */
+  /* _not_ try to read the Type 1 token stream with a state machine (i.e.  */
+  /* a Postscript-like interpreter) but rather to perform simple pattern   */
+  /* matching.                                                             */
+  /*                                                                       */
+  /* Indeed, nearly all data definitions follow a simple pattern like      */
+  /*                                                                       */
+  /*  ... /Field <data> ...                                                */
+  /*                                                                       */
+  /* where <data> can be a number, a boolean, a string, or an array of     */
+  /* numbers.  There are a few exceptions, namely the encoding, font name, */
+  /* charstrings, and subrs; they are handled with a special pattern       */
+  /* matching routine.                                                     */
+  /*                                                                       */
+  /* All other common cases are handled very simply.  The matching rules   */
+  /* are defined in the file `t1tokens.h' through the use of several       */
+  /* macros calls PARSE_XXX.  This file is included twice here; the first  */
+  /* time to generate parsing callback functions, the second time to       */
+  /* generate a table of keywords (with pointers to the associated         */
+  /* callback functions).                                                  */
+  /*                                                                       */
+  /* The function `parse_dict' simply scans *linearly* a given dictionary  */
+  /* (either the top-level or private one) and calls the appropriate       */
+  /* callback when it encounters an immediate keyword.                     */
+  /*                                                                       */
+  /* This is by far the fastest way one can find to parse and read all     */
+  /* data.                                                                 */
+  /*                                                                       */
+  /* This led to tremendous code size reduction.  Note that later, the     */
+  /* glyph loader will also be _greatly_ simplified, and the automatic     */
+  /* hinter will replace the clumsy `t1hinter'.                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_CONFIG_CONFIG_H
+#include FT_MULTIPLE_MASTERS_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+
+#include "t1load.h"
+#include "t1errors.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_t1load
+
+
+#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    MULTIPLE MASTERS SUPPORT                   *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static FT_Error
+  t1_allocate_blend( T1_Face  face,
+                     FT_UInt  num_designs,
+                     FT_UInt  num_axis )
+  {
+    PS_Blend   blend;
+    FT_Memory  memory = face->root.memory;
+    FT_Error   error  = T1_Err_Ok;
+
+
+    blend = face->blend;
+    if ( !blend )
+    {
+      if ( FT_NEW( blend ) )
+        goto Exit;
+
+      face->blend = blend;
+    }
+
+    /* allocate design data if needed */
+    if ( num_designs > 0 )
+    {
+      if ( blend->num_designs == 0 )
+      {
+        FT_UInt  nn;
+
+
+        /* allocate the blend `private' and `font_info' dictionaries */
+        if ( FT_NEW_ARRAY( blend->font_infos[1], num_designs     ) ||
+             FT_NEW_ARRAY( blend->privates[1], num_designs       ) ||
+             FT_NEW_ARRAY( blend->bboxes[1], num_designs         ) ||
+             FT_NEW_ARRAY( blend->weight_vector, num_designs * 2 ) )
+          goto Exit;
+
+        blend->default_weight_vector = blend->weight_vector + num_designs;
+
+        blend->font_infos[0] = &face->type1.font_info;
+        blend->privates  [0] = &face->type1.private_dict;
+        blend->bboxes    [0] = &face->type1.font_bbox;
+
+        for ( nn = 2; nn <= num_designs; nn++ )
+        {
+          blend->privates[nn]   = blend->privates  [nn - 1] + 1;
+          blend->font_infos[nn] = blend->font_infos[nn - 1] + 1;
+          blend->bboxes[nn]     = blend->bboxes    [nn - 1] + 1;
+        }
+
+        blend->num_designs   = num_designs;
+      }
+      else if ( blend->num_designs != num_designs )
+        goto Fail;
+    }
+
+    /* allocate axis data if needed */
+    if ( num_axis > 0 )
+    {
+      if ( blend->num_axis != 0 && blend->num_axis != num_axis )
+        goto Fail;
+
+      blend->num_axis = num_axis;
+    }
+
+    /* allocate the blend design pos table if needed */
+    num_designs = blend->num_designs;
+    num_axis    = blend->num_axis;
+    if ( num_designs && num_axis && blend->design_pos[0] == 0 )
+    {
+      FT_UInt  n;
+
+
+      if ( FT_NEW_ARRAY( blend->design_pos[0], num_designs * num_axis ) )
+        goto Exit;
+
+      for ( n = 1; n < num_designs; n++ )
+        blend->design_pos[n] = blend->design_pos[0] + num_axis * n;
+    }
+
+  Exit:
+    return error;
+
+  Fail:
+    error = T1_Err_Invalid_File_Format;
+    goto Exit;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Get_Multi_Master( T1_Face           face,
+                       FT_Multi_Master*  master )
+  {
+    PS_Blend  blend = face->blend;
+    FT_UInt   n;
+    FT_Error  error;
+
+
+    error = T1_Err_Invalid_Argument;
+
+    if ( blend )
+    {
+      master->num_axis    = blend->num_axis;
+      master->num_designs = blend->num_designs;
+
+      for ( n = 0; n < blend->num_axis; n++ )
+      {
+        FT_MM_Axis*   axis = master->axis + n;
+        PS_DesignMap  map = blend->design_map + n;
+
+
+        axis->name    = blend->axis_names[n];
+        axis->minimum = map->design_points[0];
+        axis->maximum = map->design_points[map->num_points - 1];
+      }
+
+      error = T1_Err_Ok;
+    }
+
+    return error;
+  }
+
+
+#define FT_INT_TO_FIXED( a )  ( (a) << 16 )
+#define FT_FIXED_TO_INT( a )  ( FT_RoundFix( a ) >> 16 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Given a normalized (blend) coordinate, figure out the design          */
+  /* coordinate appropriate for that value.                                */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Fixed )
+  mm_axis_unmap( PS_DesignMap  axismap,
+                 FT_Fixed      ncv )
+  {
+    int  j;
+
+
+    if ( ncv <= axismap->blend_points[0] )
+      return axismap->design_points[0];
+
+    for ( j = 1; j < axismap->num_points; ++j )
+    {
+      if ( ncv <= axismap->blend_points[j] )
+      {
+        FT_Fixed  t = FT_MulDiv( ncv - axismap->blend_points[j - 1],
+                                 0x10000L,
+                                 axismap->blend_points[j] -
+                                   axismap->blend_points[j - 1] );
+
+
+        return axismap->design_points[j - 1] +
+                 FT_MulDiv( t,
+                            axismap->design_points[j] - 
+                              axismap->design_points[j - 1],
+                            1L );
+      }
+    }
+
+    return axismap->design_points[axismap->num_points - 1];
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Given a vector of weights, one for each design, figure out the        */
+  /* normalized axis coordinates which gave rise to those weights.         */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  mm_weights_unmap( FT_Fixed*  weights,
+                    FT_Fixed*  axiscoords,
+                    FT_UInt    axis_count )
+  {
+    FT_ASSERT( axis_count <= T1_MAX_MM_AXIS );
+
+    if ( axis_count == 1 )
+      axiscoords[0] = weights[1];
+
+    else if ( axis_count == 2 )
+    {
+      axiscoords[0] = weights[3] + weights[1];
+      axiscoords[1] = weights[3] + weights[2];
+    }
+
+    else if ( axis_count == 3 )
+    {
+      axiscoords[0] = weights[7] + weights[5] + weights[3] + weights[1];
+      axiscoords[1] = weights[7] + weights[6] + weights[3] + weights[2];
+      axiscoords[2] = weights[7] + weights[6] + weights[5] + weights[4];
+    }
+
+    else
+    {
+      axiscoords[0] = weights[15] + weights[13] + weights[11] + weights[9] +
+                        weights[7] + weights[5] + weights[3] + weights[1];
+      axiscoords[1] = weights[15] + weights[14] + weights[11] + weights[10] +
+                        weights[7] + weights[6] + weights[3] + weights[2];
+      axiscoords[2] = weights[15] + weights[14] + weights[13] + weights[12] +
+                        weights[7] + weights[6] + weights[5] + weights[4];
+      axiscoords[3] = weights[15] + weights[14] + weights[13] + weights[12] +
+                        weights[11] + weights[10] + weights[9] + weights[8];
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Just a wrapper around T1_Get_Multi_Master to support the different    */
+  /*  arguments needed by the GX var distortable fonts.                    */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  T1_Get_MM_Var( T1_Face      face,
+                 FT_MM_Var*  *master )
+  {
+    FT_Memory        memory = face->root.memory;
+    FT_MM_Var       *mmvar;
+    FT_Multi_Master  mmaster;
+    FT_Error         error;
+    FT_UInt          i;
+    FT_Fixed         axiscoords[T1_MAX_MM_AXIS];
+    PS_Blend         blend = face->blend;
+
+
+    error = T1_Get_Multi_Master( face, &mmaster );
+    if ( error )
+      goto Exit;
+    if ( FT_ALLOC( mmvar,
+                   sizeof ( FT_MM_Var ) +
+                     mmaster.num_axis * sizeof ( FT_Var_Axis ) ) )
+      goto Exit;
+
+    mmvar->num_axis        = mmaster.num_axis;
+    mmvar->num_designs     = mmaster.num_designs;
+    mmvar->num_namedstyles = (FT_UInt)-1;                /* Does not apply */
+    mmvar->axis            = (FT_Var_Axis*)&mmvar[1];
+                                      /* Point to axes after MM_Var struct */
+    mmvar->namedstyle      = NULL;
+
+    for ( i = 0 ; i < mmaster.num_axis; ++i )
+    {
+      mmvar->axis[i].name    = mmaster.axis[i].name;
+      mmvar->axis[i].minimum = FT_INT_TO_FIXED( mmaster.axis[i].minimum);
+      mmvar->axis[i].maximum = FT_INT_TO_FIXED( mmaster.axis[i].maximum);
+      mmvar->axis[i].def     = ( mmvar->axis[i].minimum +
+                                   mmvar->axis[i].maximum ) / 2;
+                            /* Does not apply.  But this value is in range */
+      mmvar->axis[i].strid   = 0xFFFFFFFFLU;   /* Does not apply */
+      mmvar->axis[i].tag     = 0xFFFFFFFFLU;   /* Does not apply */
+
+      if ( ft_strcmp( mmvar->axis[i].name, "Weight" ) == 0 )
+        mmvar->axis[i].tag = FT_MAKE_TAG( 'w', 'g', 'h', 't' );
+      else if ( ft_strcmp( mmvar->axis[i].name, "Width" ) == 0 )
+        mmvar->axis[i].tag = FT_MAKE_TAG( 'w', 'd', 't', 'h' );
+      else if ( ft_strcmp( mmvar->axis[i].name, "OpticalSize" ) == 0 )
+        mmvar->axis[i].tag = FT_MAKE_TAG( 'o', 'p', 's', 'z' );
+    }
+
+    if ( blend->num_designs == 1U << blend->num_axis )
+    {
+      mm_weights_unmap( blend->default_weight_vector,
+                        axiscoords,
+                        blend->num_axis );
+
+      for ( i = 0; i < mmaster.num_axis; ++i )
+        mmvar->axis[i].def = mm_axis_unmap( &blend->design_map[i],
+                                            axiscoords[i] );
+    }
+
+    *master = mmvar;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Set_MM_Blend( T1_Face    face,
+                   FT_UInt    num_coords,
+                   FT_Fixed*  coords )
+  {
+    PS_Blend  blend = face->blend;
+    FT_Error  error;
+    FT_UInt   n, m;
+
+
+    error = T1_Err_Invalid_Argument;
+
+    if ( blend && blend->num_axis == num_coords )
+    {
+      /* recompute the weight vector from the blend coordinates */
+      error = T1_Err_Ok;
+
+      for ( n = 0; n < blend->num_designs; n++ )
+      {
+        FT_Fixed  result = 0x10000L;  /* 1.0 fixed */
+
+
+        for ( m = 0; m < blend->num_axis; m++ )
+        {
+          FT_Fixed  factor;
+
+
+          /* get current blend axis position */
+          factor = coords[m];
+          if ( factor < 0 )        factor = 0;
+          if ( factor > 0x10000L ) factor = 0x10000L;
+
+          if ( ( n & ( 1 << m ) ) == 0 )
+            factor = 0x10000L - factor;
+
+          result = FT_MulFix( result, factor );
+        }
+        blend->weight_vector[n] = result;
+      }
+
+      error = T1_Err_Ok;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Set_MM_Design( T1_Face   face,
+                    FT_UInt   num_coords,
+                    FT_Long*  coords )
+  {
+    PS_Blend  blend = face->blend;
+    FT_Error  error;
+    FT_UInt   n, p;
+
+
+    error = T1_Err_Invalid_Argument;
+    if ( blend && blend->num_axis == num_coords )
+    {
+      /* compute the blend coordinates through the blend design map */
+      FT_Fixed  final_blends[T1_MAX_MM_DESIGNS];
+
+
+      for ( n = 0; n < blend->num_axis; n++ )
+      {
+        FT_Long       design  = coords[n];
+        FT_Fixed      the_blend;
+        PS_DesignMap  map     = blend->design_map + n;
+        FT_Long*      designs = map->design_points;
+        FT_Fixed*     blends  = map->blend_points;
+        FT_Int        before  = -1, after = -1;
+
+
+        for ( p = 0; p < (FT_UInt)map->num_points; p++ )
+        {
+          FT_Long  p_design = designs[p];
+
+
+          /* exact match? */
+          if ( design == p_design )
+          {
+            the_blend = blends[p];
+            goto Found;
+          }
+
+          if ( design < p_design )
+          {
+            after = p;
+            break;
+          }
+
+          before = p;
+        }
+
+        /* now interpolate if necessary */
+        if ( before < 0 )
+          the_blend = blends[0];
+
+        else if ( after < 0 )
+          the_blend = blends[map->num_points - 1];
+
+        else
+          the_blend = FT_MulDiv( design         - designs[before],
+                                 blends [after] - blends [before],
+                                 designs[after] - designs[before] );
+
+      Found:
+        final_blends[n] = the_blend;
+      }
+
+      error = T1_Set_MM_Blend( face, num_coords, final_blends );
+    }
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Just a wrapper around T1_Set_MM_Design to support the different       */
+  /* arguments needed by the GX var distortable fonts.                     */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  T1_Set_Var_Design( T1_Face    face,
+                     FT_UInt    num_coords,
+                     FT_Fixed*  coords )
+  {
+     FT_Long   lcoords[4];          /* maximum axis count is 4 */
+     FT_UInt   i;
+     FT_Error  error;
+
+
+     error = T1_Err_Invalid_Argument;
+     if ( num_coords <= 4 && num_coords > 0 )
+     {
+       for ( i = 0; i < num_coords; ++i )
+         lcoords[i] = FT_FIXED_TO_INT( coords[i] );
+       error = T1_Set_MM_Design( face, num_coords, lcoords );
+     }
+
+     return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T1_Done_Blend( T1_Face  face )
+  {
+    FT_Memory  memory = face->root.memory;
+    PS_Blend   blend  = face->blend;
+
+
+    if ( blend )
+    {
+      FT_UInt  num_designs = blend->num_designs;
+      FT_UInt  num_axis    = blend->num_axis;
+      FT_UInt  n;
+
+
+      /* release design pos table */
+      FT_FREE( blend->design_pos[0] );
+      for ( n = 1; n < num_designs; n++ )
+        blend->design_pos[n] = 0;
+
+      /* release blend `private' and `font info' dictionaries */
+      FT_FREE( blend->privates[1] );
+      FT_FREE( blend->font_infos[1] );
+      FT_FREE( blend->bboxes[1] );
+
+      for ( n = 0; n < num_designs; n++ )
+      {
+        blend->privates  [n] = 0;
+        blend->font_infos[n] = 0;
+        blend->bboxes    [n] = 0;
+      }
+
+      /* release weight vectors */
+      FT_FREE( blend->weight_vector );
+      blend->default_weight_vector = 0;
+
+      /* release axis names */
+      for ( n = 0; n < num_axis; n++ )
+        FT_FREE( blend->axis_names[n] );
+
+      /* release design map */
+      for ( n = 0; n < num_axis; n++ )
+      {
+        PS_DesignMap  dmap = blend->design_map + n;
+
+
+        FT_FREE( dmap->design_points );
+        dmap->num_points = 0;
+      }
+
+      FT_FREE( face->blend );
+    }
+  }
+
+
+  static void
+  parse_blend_axis_types( T1_Face    face,
+                          T1_Loader  loader )
+  {
+    T1_TokenRec  axis_tokens[T1_MAX_MM_AXIS];
+    FT_Int       n, num_axis;
+    FT_Error     error = T1_Err_Ok;
+    PS_Blend     blend;
+    FT_Memory    memory;
+
+
+    /* take an array of objects */
+    T1_ToTokenArray( &loader->parser, axis_tokens,
+                     T1_MAX_MM_AXIS, &num_axis );
+    if ( num_axis < 0 )
+    {
+      error = T1_Err_Ignore;
+      goto Exit;
+    }
+    if ( num_axis == 0 || num_axis > T1_MAX_MM_AXIS )
+    {
+      FT_ERROR(( "parse_blend_axis_types: incorrect number of axes: %d\n",
+                 num_axis ));
+      error = T1_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    /* allocate blend if necessary */
+    error = t1_allocate_blend( face, 0, (FT_UInt)num_axis );
+    if ( error )
+      goto Exit;
+
+    blend  = face->blend;
+    memory = face->root.memory;
+
+    /* each token is an immediate containing the name of the axis */
+    for ( n = 0; n < num_axis; n++ )
+    {
+      T1_Token    token = axis_tokens + n;
+      FT_Byte*    name;
+      FT_PtrDist  len;
+
+
+      /* skip first slash, if any */
+      if ( token->start[0] == '/' )
+        token->start++;
+
+      len = token->limit - token->start;
+      if ( len == 0 )
+      {
+        error = T1_Err_Invalid_File_Format;
+        goto Exit;
+      }
+
+      if ( FT_ALLOC( blend->axis_names[n], len + 1 ) )
+        goto Exit;
+
+      name = (FT_Byte*)blend->axis_names[n];
+      FT_MEM_COPY( name, token->start, len );
+      name[len] = 0;
+    }
+
+  Exit:
+    loader->parser.root.error = error;
+  }
+
+
+  static void
+  parse_blend_design_positions( T1_Face    face,
+                                T1_Loader  loader )
+  {
+    T1_TokenRec  design_tokens[T1_MAX_MM_DESIGNS];
+    FT_Int       num_designs;
+    FT_Int       num_axis;
+    T1_Parser    parser = &loader->parser;
+
+    FT_Error     error = T1_Err_Ok;
+    PS_Blend     blend;
+
+
+    /* get the array of design tokens -- compute number of designs */
+    T1_ToTokenArray( parser, design_tokens,
+                     T1_MAX_MM_DESIGNS, &num_designs );
+    if ( num_designs < 0 )
+    {
+      error = T1_Err_Ignore;
+      goto Exit;
+    }
+    if ( num_designs == 0 || num_designs > T1_MAX_MM_DESIGNS )
+    {
+      FT_ERROR(( "parse_blend_design_positions:" ));
+      FT_ERROR(( " incorrect number of designs: %d\n",
+                 num_designs ));
+      error = T1_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    {
+      FT_Byte*  old_cursor = parser->root.cursor;
+      FT_Byte*  old_limit  = parser->root.limit;
+      FT_Int    n;
+
+
+      blend    = face->blend;
+      num_axis = 0;  /* make compiler happy */
+
+      for ( n = 0; n < num_designs; n++ )
+      {
+        T1_TokenRec  axis_tokens[T1_MAX_MM_DESIGNS];
+        T1_Token     token;
+        FT_Int       axis, n_axis;
+
+
+        /* read axis/coordinates tokens */
+        token = design_tokens + n;
+        parser->root.cursor = token->start;
+        parser->root.limit  = token->limit;
+        T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &n_axis );
+
+        if ( n == 0 )
+        {
+          num_axis = n_axis;
+          error = t1_allocate_blend( face, num_designs, num_axis );
+          if ( error )
+            goto Exit;
+          blend = face->blend;
+        }
+        else if ( n_axis != num_axis )
+        {
+          FT_ERROR(( "parse_blend_design_positions: incorrect table\n" ));
+          error = T1_Err_Invalid_File_Format;
+          goto Exit;
+        }
+
+        /* now read each axis token into the design position */
+        for ( axis = 0; axis < n_axis; axis++ )
+        {
+          T1_Token  token2 = axis_tokens + axis;
+
+
+          parser->root.cursor = token2->start;
+          parser->root.limit  = token2->limit;
+          blend->design_pos[n][axis] = T1_ToFixed( parser, 0 );
+        }
+      }
+
+      loader->parser.root.cursor = old_cursor;
+      loader->parser.root.limit  = old_limit;
+    }
+
+  Exit:
+    loader->parser.root.error = error;
+  }
+
+
+  static void
+  parse_blend_design_map( T1_Face    face,
+                          T1_Loader  loader )
+  {
+    FT_Error     error  = T1_Err_Ok;
+    T1_Parser    parser = &loader->parser;
+    PS_Blend     blend;
+    T1_TokenRec  axis_tokens[T1_MAX_MM_AXIS];
+    FT_Int       n, num_axis;
+    FT_Byte*     old_cursor;
+    FT_Byte*     old_limit;
+    FT_Memory    memory = face->root.memory;
+
+
+    T1_ToTokenArray( parser, axis_tokens, 
+                     T1_MAX_MM_AXIS, &num_axis );
+    if ( num_axis < 0 )
+    {
+      error = T1_Err_Ignore;
+      goto Exit;
+    }
+    if ( num_axis == 0 || num_axis > T1_MAX_MM_AXIS )
+    {
+      FT_ERROR(( "parse_blend_design_map: incorrect number of axes: %d\n",
+                 num_axis ));
+      error = T1_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    old_cursor = parser->root.cursor;
+    old_limit  = parser->root.limit;
+
+    error = t1_allocate_blend( face, 0, num_axis );
+    if ( error )
+      goto Exit;
+    blend = face->blend;
+
+    /* now read each axis design map */
+    for ( n = 0; n < num_axis; n++ )
+    {
+      PS_DesignMap  map = blend->design_map + n;
+      T1_Token      axis_token;
+      T1_TokenRec   point_tokens[T1_MAX_MM_MAP_POINTS];
+      FT_Int        p, num_points;
+
+
+      axis_token = axis_tokens + n;
+
+      parser->root.cursor = axis_token->start;
+      parser->root.limit  = axis_token->limit;
+      T1_ToTokenArray( parser, point_tokens,
+                       T1_MAX_MM_MAP_POINTS, &num_points );
+
+      if ( num_points <= 0 || num_points > T1_MAX_MM_MAP_POINTS )
+      {
+        FT_ERROR(( "parse_blend_design_map: incorrect table\n" ));
+        error = T1_Err_Invalid_File_Format;
+        goto Exit;
+      }
+
+      /* allocate design map data */
+      if ( FT_NEW_ARRAY( map->design_points, num_points * 2 ) )
+        goto Exit;
+      map->blend_points = map->design_points + num_points;
+      map->num_points   = (FT_Byte)num_points;
+
+      for ( p = 0; p < num_points; p++ )
+      {
+        T1_Token  point_token;
+
+
+        point_token = point_tokens + p;
+
+        /* don't include delimiting brackets */
+        parser->root.cursor = point_token->start + 1;
+        parser->root.limit  = point_token->limit - 1;
+
+        map->design_points[p] = T1_ToInt( parser );
+        map->blend_points [p] = T1_ToFixed( parser, 0 );
+      }
+    }
+
+    parser->root.cursor = old_cursor;
+    parser->root.limit  = old_limit;
+
+  Exit:
+    parser->root.error = error;
+  }
+
+
+  static void
+  parse_weight_vector( T1_Face    face,
+                       T1_Loader  loader )
+  {
+    T1_TokenRec  design_tokens[T1_MAX_MM_DESIGNS];
+    FT_Int       num_designs;
+    FT_Error     error  = T1_Err_Ok;
+    T1_Parser    parser = &loader->parser;
+    PS_Blend     blend  = face->blend;
+    T1_Token     token;
+    FT_Int       n;
+    FT_Byte*     old_cursor;
+    FT_Byte*     old_limit;
+
+
+    T1_ToTokenArray( parser, design_tokens,
+                     T1_MAX_MM_DESIGNS, &num_designs );
+    if ( num_designs < 0 )
+    {
+      error = T1_Err_Ignore;
+      goto Exit;
+    }
+    if ( num_designs == 0 || num_designs > T1_MAX_MM_DESIGNS )
+    {
+      FT_ERROR(( "parse_weight_vector:" ));
+      FT_ERROR(( " incorrect number of designs: %d\n",
+                 num_designs ));
+      error = T1_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    if ( !blend || !blend->num_designs )
+    {
+      error = t1_allocate_blend( face, num_designs, 0 );
+      if ( error )
+        goto Exit;
+      blend = face->blend;
+    }
+    else if ( blend->num_designs != (FT_UInt)num_designs )
+    {
+      FT_ERROR(( "parse_weight_vector:"
+                 " /BlendDesignPosition and /WeightVector have\n" ));
+      FT_ERROR(( "                    "
+                 " different number of elements!\n" ));
+      error = T1_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    old_cursor = parser->root.cursor;
+    old_limit  = parser->root.limit;
+
+    for ( n = 0; n < num_designs; n++ )
+    {
+      token = design_tokens + n;
+      parser->root.cursor = token->start;
+      parser->root.limit  = token->limit;
+
+      blend->default_weight_vector[n] =
+      blend->weight_vector[n]         = T1_ToFixed( parser, 0 );
+    }
+
+    parser->root.cursor = old_cursor;
+    parser->root.limit  = old_limit;
+
+  Exit:
+    parser->root.error = error;
+  }
+
+
+#endif /* T1_CONFIG_OPTION_NO_MM_SUPPORT */
+
+
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      TYPE 1 SYMBOL PARSING                    *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static FT_Error
+  t1_load_keyword( T1_Face         face,
+                   T1_Loader       loader,
+                   const T1_Field  field )
+  {
+    FT_Error  error;
+    void*     dummy_object;
+    void**    objects;
+    FT_UInt   max_objects;
+    PS_Blend  blend = face->blend;
+
+
+    /* if the keyword has a dedicated callback, call it */
+    if ( field->type == T1_FIELD_TYPE_CALLBACK )
+    {
+      field->reader( (FT_Face)face, loader );
+      error = loader->parser.root.error;
+      goto Exit;
+    }
+
+    /* now, the keyword is either a simple field, or a table of fields; */
+    /* we are now going to take care of it                              */
+    switch ( field->location )
+    {
+    case T1_FIELD_LOCATION_FONT_INFO:
+      dummy_object = &face->type1.font_info;
+      objects      = &dummy_object;
+      max_objects  = 0;
+
+      if ( blend )
+      {
+        objects     = (void**)blend->font_infos;
+        max_objects = blend->num_designs;
+      }
+      break;
+
+    case T1_FIELD_LOCATION_PRIVATE:
+      dummy_object = &face->type1.private_dict;
+      objects      = &dummy_object;
+      max_objects  = 0;
+
+      if ( blend )
+      {
+        objects     = (void**)blend->privates;
+        max_objects = blend->num_designs;
+      }
+      break;
+
+    case T1_FIELD_LOCATION_BBOX:
+      dummy_object = &face->type1.font_bbox;
+      objects      = &dummy_object;
+      max_objects  = 0;
+
+      if ( blend )
+      {
+        objects     = (void**)blend->bboxes;
+        max_objects = blend->num_designs;
+      }
+      break;
+
+    default:
+      dummy_object = &face->type1;
+      objects      = &dummy_object;
+      max_objects  = 0;
+    }
+
+    if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
+         field->type == T1_FIELD_TYPE_FIXED_ARRAY   )
+      error = T1_Load_Field_Table( &loader->parser, field,
+                                   objects, max_objects, 0 );
+    else
+      error = T1_Load_Field( &loader->parser, field,
+                             objects, max_objects, 0 );
+
+  Exit:
+    return error;
+  }
+
+
+  static int
+  is_space( FT_Byte  c )
+  {
+    return ( c == ' '  || c == '\t'              ||
+             c == '\r' || c == '\n' || c == '\f' ||
+             c == '\0'                           );
+  }
+
+
+  static int
+  read_binary_data( T1_Parser  parser,
+                    FT_Long*   size,
+                    FT_Byte**  base )
+  {
+    FT_Byte*  cur;
+    FT_Byte*  limit = parser->root.limit;
+
+
+    /* the binary data has one of the following formats */
+    /*                                                  */
+    /*   `size' [white*] RD white ....... ND            */
+    /*   `size' [white*] -| white ....... |-            */
+    /*                                                  */
+
+    T1_Skip_Spaces( parser );
+
+    cur = parser->root.cursor;
+
+    if ( cur < limit && ft_isdigit( *cur ) )
+    {
+      *size = T1_ToInt( parser );
+
+      T1_Skip_PS_Token( parser );   /* `RD' or `-|' or something else */
+
+      /* there is only one whitespace char after the */
+      /* `RD' or `-|' token                          */
+      *base = parser->root.cursor + 1;
+
+      parser->root.cursor += *size + 1;
+      return 1;
+    }
+
+    FT_ERROR(( "read_binary_data: invalid size field\n" ));
+    parser->root.error = T1_Err_Invalid_File_Format;
+    return 0;
+  }
+
+
+  /* We now define the routines to handle the `/Encoding', `/Subrs', */
+  /* and `/CharStrings' dictionaries.                                */
+
+  static void
+  parse_font_matrix( T1_Face    face,
+                     T1_Loader  loader )
+  {
+    T1_Parser   parser = &loader->parser;
+    FT_Matrix*  matrix = &face->type1.font_matrix;
+    FT_Vector*  offset = &face->type1.font_offset;
+    FT_Face     root   = (FT_Face)&face->root;
+    FT_Fixed    temp[6];
+    FT_Fixed    temp_scale;
+
+
+    (void)T1_ToFixedArray( parser, 6, temp, 3 );
+
+    temp_scale = FT_ABS( temp[3] );
+
+    /* Set Units per EM based on FontMatrix values.  We set the value to */
+    /* 1000 / temp_scale, because temp_scale was already multiplied by   */
+    /* 1000 (in t1_tofixed, from psobjs.c).                              */
+
+    root->units_per_EM = (FT_UShort)( FT_DivFix( 1000 * 0x10000L,
+                                                 temp_scale ) >> 16 );
+
+    /* we need to scale the values by 1.0/temp_scale */
+    if ( temp_scale != 0x10000L )
+    {
+      temp[0] = FT_DivFix( temp[0], temp_scale );
+      temp[1] = FT_DivFix( temp[1], temp_scale );
+      temp[2] = FT_DivFix( temp[2], temp_scale );
+      temp[4] = FT_DivFix( temp[4], temp_scale );
+      temp[5] = FT_DivFix( temp[5], temp_scale );
+      temp[3] = 0x10000L;
+    }
+
+    matrix->xx = temp[0];
+    matrix->yx = temp[1];
+    matrix->xy = temp[2];
+    matrix->yy = temp[3];
+
+    /* note that the offsets must be expressed in integer font units */
+    offset->x = temp[4] >> 16;
+    offset->y = temp[5] >> 16;
+  }
+
+
+  static void
+  parse_encoding( T1_Face    face,
+                  T1_Loader  loader )
+  {
+    T1_Parser  parser = &loader->parser;
+    FT_Byte*   cur;
+    FT_Byte*   limit  = parser->root.limit;
+
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
+
+
+    T1_Skip_Spaces( parser );
+    cur = parser->root.cursor;
+    if ( cur >= limit )
+    {
+      FT_ERROR(( "parse_encoding: out of bounds!\n" ));
+      parser->root.error = T1_Err_Invalid_File_Format;
+      return;
+    }
+
+    /* if we have a number or `[', the encoding is an array, */
+    /* and we must load it now                               */
+    if ( ft_isdigit( *cur ) || *cur == '[' )
+    {
+      T1_Encoding  encode          = &face->type1.encoding;
+      FT_Int       count, n;
+      PS_Table     char_table      = &loader->encoding_table;
+      FT_Memory    memory          = parser->root.memory;
+      FT_Error     error;
+      FT_Bool      only_immediates = 0;
+
+
+      /* read the number of entries in the encoding; should be 256 */
+      if ( *cur == '[' )
+      {
+        count           = 256;
+        only_immediates = 1;
+        parser->root.cursor++;
+      }
+      else
+        count = (FT_Int)T1_ToInt( parser );
+
+      T1_Skip_Spaces( parser );
+      if ( parser->root.cursor >= limit )
+        return;
+
+      /* we use a T1_Table to store our charnames */
+      loader->num_chars = encode->num_chars = count;
+      if ( FT_NEW_ARRAY( encode->char_index, count )     ||
+           FT_NEW_ARRAY( encode->char_name,  count )     ||
+           FT_SET_ERROR( psaux->ps_table_funcs->init(
+                           char_table, count, memory ) ) )
+      {
+        parser->root.error = error;
+        return;
+      }
+
+      /* We need to `zero' out encoding_table.elements */
+      for ( n = 0; n < count; n++ )
+      {
+        char*  notdef = (char *)".notdef";
+
+
+        T1_Add_Table( char_table, n, notdef, 8 );
+      }
+
+      /* Now we need to read records of the form                */
+      /*                                                        */
+      /*   ... charcode /charname ...                           */
+      /*                                                        */
+      /* for each entry in our table.                           */
+      /*                                                        */
+      /* We simply look for a number followed by an immediate   */
+      /* name.  Note that this ignores correctly the sequence   */
+      /* that is often seen in type1 fonts:                     */
+      /*                                                        */
+      /*   0 1 255 { 1 index exch /.notdef put } for dup        */
+      /*                                                        */
+      /* used to clean the encoding array before anything else. */
+      /*                                                        */
+      /* Alternatively, if the array is directly given as       */
+      /*                                                        */
+      /*   /Encoding [ ... ]                                    */
+      /*                                                        */
+      /* we only read immediates.                               */
+
+      n = 0;
+      T1_Skip_Spaces( parser );
+
+      while ( parser->root.cursor < limit )
+      {
+        cur = parser->root.cursor;
+
+        /* we stop when we encounter a `def' or `]' */
+        if ( *cur == 'd' && cur + 3 < limit )
+        {
+          if ( cur[1] == 'e'      &&
+               cur[2] == 'f'      &&
+               is_space( cur[3] ) )
+          {
+            FT_TRACE6(( "encoding end\n" ));
+            cur += 3;
+            break;
+          }
+        }
+        if ( *cur == ']' )
+        {
+          FT_TRACE6(( "encoding end\n" ));
+          cur++;
+          break;
+        }
+
+        /* check whether we've found an entry */
+        if ( ft_isdigit( *cur ) || only_immediates )
+        {
+          FT_Int  charcode;
+
+
+          if ( only_immediates )
+            charcode = n;
+          else
+          {
+            charcode = (FT_Int)T1_ToInt( parser );
+            T1_Skip_Spaces( parser );
+          }
+
+          cur = parser->root.cursor;
+
+          if ( *cur == '/' && cur + 2 < limit && n < count )
+          {
+            FT_PtrDist  len;
+
+
+            cur++;
+
+            parser->root.cursor = cur;
+            T1_Skip_PS_Token( parser );
+
+            len = parser->root.cursor - cur;
+
+            parser->root.error = T1_Add_Table( char_table, charcode,
+                                               cur, len + 1 );
+            if ( parser->root.error )
+              return;
+            char_table->elements[charcode][len] = '\0';
+
+            n++;
+          }
+        }
+        else
+          T1_Skip_PS_Token( parser );
+
+        T1_Skip_Spaces( parser );
+      }
+
+      face->type1.encoding_type = T1_ENCODING_TYPE_ARRAY;
+      parser->root.cursor       = cur;
+    }
+
+    /* Otherwise, we should have either `StandardEncoding', */
+    /* `ExpertEncoding', or `ISOLatin1Encoding'             */
+    else
+    {
+      if ( cur + 17 < limit                                            &&
+           ft_strncmp( (const char*)cur, "StandardEncoding", 16 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_STANDARD;
+
+      else if ( cur + 15 < limit                                          &&
+                ft_strncmp( (const char*)cur, "ExpertEncoding", 14 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_EXPERT;
+
+      else if ( cur + 18 < limit                                             &&
+                ft_strncmp( (const char*)cur, "ISOLatin1Encoding", 17 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_ISOLATIN1;
+
+      else
+        parser->root.error = T1_Err_Ignore;
+    }
+  }
+
+
+  static void
+  parse_subrs( T1_Face    face,
+               T1_Loader  loader )
+  {
+    T1_Parser  parser = &loader->parser;
+    PS_Table   table  = &loader->subrs;
+    FT_Memory  memory = parser->root.memory;
+    FT_Error   error;
+    FT_Int     n, num_subrs;
+
+    PSAux_Service  psaux  = (PSAux_Service)face->psaux;
+
+
+    T1_Skip_Spaces( parser );
+
+    /* test for empty array */
+    if ( parser->root.cursor < parser->root.limit &&
+         *parser->root.cursor == '['              )
+    {
+      T1_Skip_PS_Token( parser );
+      T1_Skip_Spaces  ( parser );
+      if ( parser->root.cursor >= parser->root.limit ||
+           *parser->root.cursor != ']'               )
+        parser->root.error = T1_Err_Invalid_File_Format;
+      return;
+    }
+
+    num_subrs = (FT_Int)T1_ToInt( parser );
+
+    /* position the parser right before the `dup' of the first subr */
+    T1_Skip_PS_Token( parser );         /* `array' */
+    T1_Skip_Spaces  ( parser );
+
+    /* initialize subrs array -- with synthetic fonts it is possible */
+    /* we get here twice                                             */
+    if ( !loader->num_subrs )
+    {
+      error = psaux->ps_table_funcs->init( table, num_subrs, memory );
+      if ( error )
+        goto Fail;
+    }
+
+    /* the format is simple:                                 */
+    /*                                                       */
+    /*   `index' + binary data                               */
+    /*                                                       */
+    for ( n = 0; n < num_subrs; n++ )
+    {
+      FT_Long   idx, size;
+      FT_Byte*  base;
+
+
+      /* If the next token isn't `dup', we are also done.  This */
+      /* happens when there are `holes' in the Subrs array.     */
+      if ( ft_strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 )
+        break;
+
+      T1_Skip_PS_Token( parser );       /* `dup' */
+
+      idx = T1_ToInt( parser );
+
+      if ( !read_binary_data( parser, &size, &base ) )
+        return;
+
+      /* The binary string is followed by one token, e.g. `NP' */
+      /* (bound to `noaccess put') or by two separate tokens:  */
+      /* `noaccess' & `put'.  We position the parser right     */
+      /* before the next `dup', if any.                        */
+      T1_Skip_PS_Token( parser );   /* `NP' or `|' or `noaccess' */
+      T1_Skip_Spaces  ( parser );
+
+      if ( ft_strncmp( (char*)parser->root.cursor, "put", 3 ) == 0 )
+      {
+        T1_Skip_PS_Token( parser ); /* skip `put' */
+        T1_Skip_Spaces  ( parser );
+      }
+
+      /* with synthetic fonts it is possible we get here twice */
+      if ( loader->num_subrs )
+        continue;
+
+      /* some fonts use a value of -1 for lenIV to indicate that */
+      /* the charstrings are unencoded                           */
+      /*                                                         */
+      /* thanks to Tom Kacvinsky for pointing this out           */
+      /*                                                         */
+      if ( face->type1.private_dict.lenIV >= 0 )
+      {
+        FT_Byte*  temp;
+
+
+        /* t1_decrypt() shouldn't write to base -- make temporary copy */
+        if ( FT_ALLOC( temp, size ) )
+          goto Fail;
+        FT_MEM_COPY( temp, base, size );
+        psaux->t1_decrypt( temp, size, 4330 );
+        size -= face->type1.private_dict.lenIV;
+        error = T1_Add_Table( table, (FT_Int)idx,
+                              temp + face->type1.private_dict.lenIV, size );
+        FT_FREE( temp );
+      }
+      else
+        error = T1_Add_Table( table, (FT_Int)idx, base, size );
+      if ( error )
+        goto Fail;
+    }
+
+    if ( !loader->num_subrs )
+      loader->num_subrs = num_subrs;
+
+    return;
+
+  Fail:
+    parser->root.error = error;
+  }
+
+
+#define TABLE_EXTEND  5
+
+
+  static void
+  parse_charstrings( T1_Face    face,
+                     T1_Loader  loader )
+  {
+    T1_Parser      parser       = &loader->parser;
+    PS_Table       code_table   = &loader->charstrings;
+    PS_Table       name_table   = &loader->glyph_names;
+    PS_Table       swap_table   = &loader->swap_table;
+    FT_Memory      memory       = parser->root.memory;
+    FT_Error       error;
+
+    PSAux_Service  psaux        = (PSAux_Service)face->psaux;
+
+    FT_Byte*       cur;
+    FT_Byte*       limit        = parser->root.limit;
+    FT_Int         n, num_glyphs;
+    FT_UInt        notdef_index = 0;
+    FT_Byte        notdef_found = 0;
+
+
+    num_glyphs = (FT_Int)T1_ToInt( parser );
+    /* some fonts like Optima-Oblique not only define the /CharStrings */
+    /* array but access it also                                        */
+    if ( num_glyphs == 0 || parser->root.error )
+      return;
+
+    /* initialize tables, leaving space for addition of .notdef, */
+    /* if necessary, and a few other glyphs to handle buggy      */
+    /* fonts which have more glyphs than specified.              */
+
+    /* for some non-standard fonts like `Optima' which provides  */
+    /* different outlines depending on the resolution it is      */
+    /* possible to get here twice                                */
+    if ( !loader->num_glyphs )
+    {
+      error = psaux->ps_table_funcs->init(
+                code_table, num_glyphs + 1 + TABLE_EXTEND, memory );
+      if ( error )
+        goto Fail;
+
+      error = psaux->ps_table_funcs->init(
+                name_table, num_glyphs + 1 + TABLE_EXTEND, memory );
+      if ( error )
+        goto Fail;
+
+      /* Initialize table for swapping index notdef_index and */
+      /* index 0 names and codes (if necessary).              */
+
+      error = psaux->ps_table_funcs->init( swap_table, 4, memory );
+      if ( error )
+        goto Fail;
+    }
+
+    n = 0;
+
+    for (;;)
+    {
+      FT_Long   size;
+      FT_Byte*  base;
+
+
+      /* the format is simple:        */
+      /*   `/glyphname' + binary data */
+
+      T1_Skip_Spaces( parser );
+
+      cur = parser->root.cursor;
+      if ( cur >= limit )
+        break;
+
+      /* we stop when we find a `def' or `end' keyword */
+      if ( cur + 3 < limit && is_space( cur[3] ) )
+      {
+        if ( cur[0] == 'd' &&
+             cur[1] == 'e' &&
+             cur[2] == 'f' )
+          break;
+
+        if ( cur[0] == 'e' &&
+             cur[1] == 'n' &&
+             cur[2] == 'd' )
+          break;
+      }
+
+      T1_Skip_PS_Token( parser );
+
+      if ( *cur == '/' )
+      {
+        FT_PtrDist  len;
+
+
+        if ( cur + 1 >= limit )
+        {
+          error = T1_Err_Invalid_File_Format;
+          goto Fail;
+        }
+
+        cur++;                              /* skip `/' */
+        len = parser->root.cursor - cur;
+
+        if ( !read_binary_data( parser, &size, &base ) )
+          return;
+
+        /* for some non-standard fonts like `Optima' which provides */
+        /* different outlines depending on the resolution it is     */
+        /* possible to get here twice                               */
+        if ( loader->num_glyphs )
+          continue;
+
+        error = T1_Add_Table( name_table, n, cur, len + 1 );
+        if ( error )
+          goto Fail;
+
+        /* add a trailing zero to the name table */
+        name_table->elements[n][len] = '\0';
+
+        /* record index of /.notdef */
+        if ( *cur == '.'                                              &&
+             ft_strcmp( ".notdef",
+                        (const char*)(name_table->elements[n]) ) == 0 )
+        {
+          notdef_index = n;
+          notdef_found = 1;
+        }
+
+        if ( face->type1.private_dict.lenIV >= 0   &&
+             n < num_glyphs + TABLE_EXTEND )
+        {
+          FT_Byte*  temp;
+
+
+          /* t1_decrypt() shouldn't write to base -- make temporary copy */
+          if ( FT_ALLOC( temp, size ) )
+            goto Fail;
+          FT_MEM_COPY( temp, base, size );
+          psaux->t1_decrypt( temp, size, 4330 );
+          size -= face->type1.private_dict.lenIV;
+          error = T1_Add_Table( code_table, n,
+                                temp + face->type1.private_dict.lenIV, size );
+          FT_FREE( temp );
+        }
+        else
+          error = T1_Add_Table( code_table, n, base, size );
+        if ( error )
+          goto Fail;
+
+        n++;
+      }
+    }
+
+    if ( loader->num_glyphs )
+      return;
+    else
+      loader->num_glyphs = n;
+
+    /* if /.notdef is found but does not occupy index 0, do our magic. */
+    if ( ft_strcmp( (const char*)".notdef",
+                    (const char*)name_table->elements[0] ) &&
+         notdef_found                                      )
+    {
+      /* Swap glyph in index 0 with /.notdef glyph.  First, add index 0  */
+      /* name and code entries to swap_table.  Then place notdef_index   */
+      /* name and code entries into swap_table.  Then swap name and code */
+      /* entries at indices notdef_index and 0 using values stored in    */
+      /* swap_table.                                                     */
+
+      /* Index 0 name */
+      error = T1_Add_Table( swap_table, 0,
+                            name_table->elements[0],
+                            name_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      /* Index 0 code */
+      error = T1_Add_Table( swap_table, 1,
+                            code_table->elements[0],
+                            code_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      /* Index notdef_index name */
+      error = T1_Add_Table( swap_table, 2,
+                            name_table->elements[notdef_index],
+                            name_table->lengths [notdef_index] );
+      if ( error )
+        goto Fail;
+
+      /* Index notdef_index code */
+      error = T1_Add_Table( swap_table, 3,
+                            code_table->elements[notdef_index],
+                            code_table->lengths [notdef_index] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( name_table, notdef_index,
+                            swap_table->elements[0],
+                            swap_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( code_table, notdef_index,
+                            swap_table->elements[1],
+                            swap_table->lengths [1] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( name_table, 0,
+                            swap_table->elements[2],
+                            swap_table->lengths [2] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( code_table, 0,
+                            swap_table->elements[3],
+                            swap_table->lengths [3] );
+      if ( error )
+        goto Fail;
+
+    }
+    else if ( !notdef_found )
+    {
+      /* notdef_index is already 0, or /.notdef is undefined in   */
+      /* charstrings dictionary.  Worry about /.notdef undefined. */
+      /* We take index 0 and add it to the end of the table(s)    */
+      /* and add our own /.notdef glyph to index 0.               */
+
+      /* 0 333 hsbw endchar */
+      FT_Byte  notdef_glyph[] = {0x8B, 0xF7, 0xE1, 0x0D, 0x0E};
+      char*    notdef_name    = (char *)".notdef";
+
+
+      error = T1_Add_Table( swap_table, 0,
+                            name_table->elements[0],
+                            name_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( swap_table, 1,
+                            code_table->elements[0],
+                            code_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( name_table, 0, notdef_name, 8 );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( code_table, 0, notdef_glyph, 5 );
+
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( name_table, n,
+                            swap_table->elements[0],
+                            swap_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( code_table, n,
+                            swap_table->elements[1],
+                            swap_table->lengths [1] );
+      if ( error )
+        goto Fail;
+
+      /* we added a glyph. */
+      loader->num_glyphs = n + 1;
+    }
+
+    return;
+
+  Fail:
+    parser->root.error = error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define the token field static variables.  This is a set of            */
+  /* T1_FieldRec variables.                                                */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static
+  const T1_FieldRec  t1_keywords[] =
+  {
+
+#include "t1tokens.h"
+
+    /* now add the special functions... */
+    T1_FIELD_CALLBACK( "FontMatrix", parse_font_matrix )
+    T1_FIELD_CALLBACK( "Encoding", parse_encoding )
+    T1_FIELD_CALLBACK( "Subrs", parse_subrs )
+    T1_FIELD_CALLBACK( "CharStrings", parse_charstrings )
+
+#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
+    T1_FIELD_CALLBACK( "BlendDesignPositions", parse_blend_design_positions )
+    T1_FIELD_CALLBACK( "BlendDesignMap", parse_blend_design_map )
+    T1_FIELD_CALLBACK( "BlendAxisTypes", parse_blend_axis_types )
+    T1_FIELD_CALLBACK( "WeightVector", parse_weight_vector )
+#endif
+
+    { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0 }
+  };
+
+
+#define T1_FIELD_COUNT                                           \
+          ( sizeof ( t1_keywords ) / sizeof ( t1_keywords[0] ) )
+
+
+  static FT_Error
+  parse_dict( T1_Face    face,
+              T1_Loader  loader,
+              FT_Byte*   base,
+              FT_Long    size,
+              FT_Byte*   keyword_flags )
+  {
+    T1_Parser  parser = &loader->parser;
+    FT_Byte   *limit, *start_binary = NULL;
+    FT_Bool    have_integer = 0;
+
+
+    parser->root.cursor = base;
+    parser->root.limit  = base + size;
+    parser->root.error  = T1_Err_Ok;
+
+    limit = parser->root.limit;
+
+    T1_Skip_Spaces( parser );
+
+    while ( parser->root.cursor < limit )
+    {
+      FT_Byte*  cur;
+
+
+      cur = parser->root.cursor;
+
+      /* look for `FontDirectory' which causes problems for some fonts */
+      if ( *cur == 'F' && cur + 25 < limit                    &&
+           ft_strncmp( (char*)cur, "FontDirectory", 13 ) == 0 )
+      {
+        FT_Byte*  cur2;
+
+
+        /* skip the `FontDirectory' keyword */
+        T1_Skip_PS_Token( parser );
+        T1_Skip_Spaces  ( parser );
+        cur = cur2 = parser->root.cursor;
+
+        /* look up the `known' keyword */
+        while ( cur < limit )
+        {
+          if ( *cur == 'k' && cur + 5 < limit            &&
+               ft_strncmp( (char*)cur, "known", 5 ) == 0 )
+            break;
+
+          T1_Skip_PS_Token( parser );
+          T1_Skip_Spaces  ( parser );
+          cur = parser->root.cursor;
+        }
+
+        if ( cur < limit )
+        {
+          T1_TokenRec  token;
+
+
+          /* skip the `known' keyword and the token following it */
+          T1_Skip_PS_Token( parser );
+          T1_ToToken( parser, &token );
+
+          /* if the last token was an array, skip it! */
+          if ( token.type == T1_TOKEN_TYPE_ARRAY )
+            cur2 = parser->root.cursor;
+        }
+        parser->root.cursor = cur2;
+        have_integer = 0;
+      }
+
+      /* look for `eexec' */
+      else if ( *cur == 'e' && cur + 5 < limit &&
+                ft_strncmp( (char*)cur, "eexec", 5 ) == 0 )
+        break;
+
+      /* look for `closefile' which ends the eexec section */
+      else if ( *cur == 'c' && cur + 9 < limit &&
+                ft_strncmp( (char*)cur, "closefile", 9 ) == 0 )
+        break;
+
+      /* check whether we have an integer */
+      else if ( ft_isdigit( *cur ) )
+      {
+        start_binary = cur;
+        T1_Skip_PS_Token( parser );
+        have_integer = 1;
+      }
+
+      /* in valid Type 1 fonts we don't see `RD' or `-|' directly */
+      /* since those tokens are handled by parse_subrs and        */
+      /* parse_charstrings                                        */
+      else if ( *cur == 'R' && cur + 6 < limit && *(cur + 1) == 'D' &&
+                have_integer )
+      {
+        FT_Long   s;
+        FT_Byte*  b;
+
+
+        parser->root.cursor = start_binary;
+        if ( !read_binary_data( parser, &s, &b ) )
+          return T1_Err_Invalid_File_Format;
+        have_integer = 0;
+      }
+
+      else if ( *cur == '-' && cur + 6 < limit && *(cur + 1) == '|' &&
+                have_integer )
+      {
+        FT_Long   s;
+        FT_Byte*  b;
+
+
+        parser->root.cursor = start_binary;
+        if ( !read_binary_data( parser, &s, &b ) )
+          return T1_Err_Invalid_File_Format;
+        have_integer = 0;
+      }
+
+      /* look for immediates */
+      else if ( *cur == '/' && cur + 2 < limit )
+      {
+        FT_PtrDist  len;
+
+
+        cur++;
+
+        parser->root.cursor = cur;
+        T1_Skip_PS_Token( parser );
+
+        len = parser->root.cursor - cur;
+
+        if ( len > 0 && len < 22 && parser->root.cursor < limit )
+        {
+          /* now compare the immediate name to the keyword table */
+          T1_Field  keyword      = (T1_Field)t1_keywords;
+          FT_Byte*  keyword_flag = keyword_flags;
+
+
+          for (;;)
+          {
+            FT_Byte*  name;
+
+
+            name = (FT_Byte*)keyword->ident;
+            if ( !name )
+              break;
+
+            if ( cur[0] == name[0]                      &&
+                 len == ft_strlen( (const char *)name ) &&
+                 ft_memcmp( cur, name, len ) == 0       )
+            {
+              /* We found it -- run the parsing callback! */
+              /* We only record the first instance of any */
+              /* field to deal adequately with synthetic  */
+              /* fonts; /Subrs and /CharStrings are       */
+              /* handled specially.                       */
+              if ( keyword_flag[0] == 0                              ||
+                   ft_strcmp( (const char*)name, "Subrs" ) == 0      ||
+                   ft_strcmp( (const char*)name, "CharStrings") == 0 )
+              {
+                parser->root.error = t1_load_keyword( face,
+                                                      loader,
+                                                      keyword );
+                if ( parser->root.error == T1_Err_Ok )
+                  keyword_flag[0] = 1;
+                else
+                {
+                  if ( FT_ERROR_BASE( parser->root.error ) == FT_Err_Ignore )
+                    parser->root.error = T1_Err_Ok;
+                  else
+                    return parser->root.error;
+                }
+              }
+              break;
+            }
+
+            keyword++;
+            keyword_flag++;
+          }
+        }
+
+        have_integer = 0;
+      }
+      else
+      {
+        T1_Skip_PS_Token( parser );
+        if ( parser->root.error )
+          goto Exit;
+        have_integer = 0;
+      }
+
+      T1_Skip_Spaces( parser );
+    }
+
+  Exit:
+    return parser->root.error;
+  }
+
+
+  static void
+  t1_init_loader( T1_Loader  loader,
+                  T1_Face    face )
+  {
+    FT_UNUSED( face );
+
+    FT_MEM_ZERO( loader, sizeof ( *loader ) );
+    loader->num_glyphs = 0;
+    loader->num_chars  = 0;
+
+    /* initialize the tables -- simply set their `init' field to 0 */
+    loader->encoding_table.init = 0;
+    loader->charstrings.init    = 0;
+    loader->glyph_names.init    = 0;
+    loader->subrs.init          = 0;
+    loader->swap_table.init     = 0;
+    loader->fontdata            = 0;
+  }
+
+
+  static void
+  t1_done_loader( T1_Loader  loader )
+  {
+    T1_Parser  parser = &loader->parser;
+
+
+    /* finalize tables */
+    T1_Release_Table( &loader->encoding_table );
+    T1_Release_Table( &loader->charstrings );
+    T1_Release_Table( &loader->glyph_names );
+    T1_Release_Table( &loader->swap_table );
+    T1_Release_Table( &loader->subrs );
+
+    /* finalize parser */
+    T1_Finalize_Parser( parser );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Open_Face( T1_Face  face )
+  {
+    T1_LoaderRec   loader;
+    T1_Parser      parser;
+    T1_Font        type1 = &face->type1;
+    PS_Private     priv  = &type1->private_dict;
+    FT_Error       error;
+    FT_Byte        keyword_flags[T1_FIELD_COUNT];
+
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
+
+
+    t1_init_loader( &loader, face );
+
+    /* default values */
+    priv->blue_shift       = 7;
+    priv->blue_fuzz        = 1;
+    priv->lenIV            = 4;
+    priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
+    priv->blue_scale       = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
+
+    parser = &loader.parser;
+    error  = T1_New_Parser( parser,
+                            face->root.stream,
+                            face->root.memory,
+                            psaux );
+    if ( error )
+      goto Exit;
+
+    {
+      FT_UInt  n;
+      
+
+      for ( n = 0; n < T1_FIELD_COUNT; n++ )
+        keyword_flags[n] = 0;
+    }
+
+    error = parse_dict( face, &loader, parser->base_dict, parser->base_len,
+                        keyword_flags );
+    if ( error )
+      goto Exit;
+
+    error = T1_Get_Private_Dict( parser, psaux );
+    if ( error )
+      goto Exit;
+
+    error = parse_dict( face, &loader, parser->private_dict,
+                        parser->private_len,
+                        keyword_flags );
+    if ( error )
+      goto Exit;
+
+#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
+
+    /* the following can happen for MM instances; we then treat the */
+    /* font as a normal PS font                                     */
+    if ( face->blend                                             &&
+         ( !face->blend->num_designs || !face->blend->num_axis ) )
+      T1_Done_Blend( face );
+
+    /* another safety check */
+    if ( face->blend )
+    {
+      FT_UInt  i;
+
+
+      for ( i = 0; i < face->blend->num_axis; i++ )
+        if ( !face->blend->design_map[i].num_points )
+        {
+          T1_Done_Blend( face );
+          break;
+        }
+    }
+
+#endif /* T1_CONFIG_OPTION_NO_MM_SUPPORT */
+
+    /* now, propagate the subrs, charstrings, and glyphnames tables */
+    /* to the Type1 data                                            */
+    type1->num_glyphs = loader.num_glyphs;
+
+    if ( loader.subrs.init )
+    {
+      loader.subrs.init  = 0;
+      type1->num_subrs   = loader.num_subrs;
+      type1->subrs_block = loader.subrs.block;
+      type1->subrs       = loader.subrs.elements;
+      type1->subrs_len   = loader.subrs.lengths;
+    }
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    if ( !face->root.internal->incremental_interface )
+#endif
+      if ( !loader.charstrings.init )
+      {
+        FT_ERROR(( "T1_Open_Face: no `/CharStrings' array in face!\n" ));
+        error = T1_Err_Invalid_File_Format;
+      }
+
+    loader.charstrings.init  = 0;
+    type1->charstrings_block = loader.charstrings.block;
+    type1->charstrings       = loader.charstrings.elements;
+    type1->charstrings_len   = loader.charstrings.lengths;
+
+    /* we copy the glyph names `block' and `elements' fields; */
+    /* the `lengths' field must be released later             */
+    type1->glyph_names_block    = loader.glyph_names.block;
+    type1->glyph_names          = (FT_String**)loader.glyph_names.elements;
+    loader.glyph_names.block    = 0;
+    loader.glyph_names.elements = 0;
+
+    /* we must now build type1.encoding when we have a custom array */
+    if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY )
+    {
+      FT_Int    charcode, idx, min_char, max_char;
+      FT_Byte*  char_name;
+      FT_Byte*  glyph_name;
+
+
+      /* OK, we do the following: for each element in the encoding  */
+      /* table, look up the index of the glyph having the same name */
+      /* the index is then stored in type1.encoding.char_index, and */
+      /* a the name to type1.encoding.char_name                     */
+
+      min_char = +32000;
+      max_char = -32000;
+
+      charcode = 0;
+      for ( ; charcode < loader.encoding_table.max_elems; charcode++ )
+      {
+        type1->encoding.char_index[charcode] = 0;
+        type1->encoding.char_name [charcode] = (char *)".notdef";
+
+        char_name = loader.encoding_table.elements[charcode];
+        if ( char_name )
+          for ( idx = 0; idx < type1->num_glyphs; idx++ )
+          {
+            glyph_name = (FT_Byte*)type1->glyph_names[idx];
+            if ( ft_strcmp( (const char*)char_name,
+                            (const char*)glyph_name ) == 0 )
+            {
+              type1->encoding.char_index[charcode] = (FT_UShort)idx;
+              type1->encoding.char_name [charcode] = (char*)glyph_name;
+
+              /* Change min/max encoded char only if glyph name is */
+              /* not /.notdef                                      */
+              if ( ft_strcmp( (const char*)".notdef",
+                              (const char*)glyph_name ) != 0 )
+              {
+                if ( charcode < min_char )
+                  min_char = charcode;
+                if ( charcode > max_char )
+                  max_char = charcode;
+              }
+              break;
+            }
+          }
+      }
+
+      /*
+       *  Yes, this happens: Certain PDF-embedded fonts have only a
+       *  `.notdef' glyph defined!
+       */
+
+      if ( min_char > max_char )
+      {
+        min_char = 0;
+        max_char = loader.encoding_table.max_elems;
+      }
+
+      type1->encoding.code_first = min_char;
+      type1->encoding.code_last  = max_char;
+      type1->encoding.num_chars  = loader.num_chars;
+    }
+
+  Exit:
+    t1_done_loader( &loader );
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1load.h b/nx-X11/extras/freetype2/src/type1/t1load.h
new file mode 100644
index 000000000..9823f53e0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1load.h
@@ -0,0 +1,93 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1load.h                                                               */
+/*                                                                         */
+/*    Type 1 font loader (specification).                                  */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2004 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 __T1LOAD_H__
+#define __T1LOAD_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+#include FT_MULTIPLE_MASTERS_H
+
+#include "t1parse.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  T1_Loader_
+  {
+    T1_ParserRec  parser;          /* parser used to read the stream */
+
+    FT_Int        num_chars;       /* number of characters in encoding */
+    PS_TableRec   encoding_table;  /* PS_Table used to store the       */
+                                   /* encoding character names         */
+
+    FT_Int        num_glyphs;
+    PS_TableRec   glyph_names;
+    PS_TableRec   charstrings;
+    PS_TableRec   swap_table;      /* For moving .notdef glyph to index 0. */
+
+    FT_Int        num_subrs;
+    PS_TableRec   subrs;
+    FT_Bool       fontdata;
+
+  } T1_LoaderRec, *T1_Loader;
+
+
+  FT_LOCAL( FT_Error )
+  T1_Open_Face( T1_Face  face );
+
+#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
+
+  FT_LOCAL( FT_Error )
+  T1_Get_Multi_Master( T1_Face           face,
+                       FT_Multi_Master*  master );
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Get_MM_Var( T1_Face      face,
+                 FT_MM_Var*  *master );
+
+  FT_LOCAL( FT_Error )
+  T1_Set_MM_Blend( T1_Face    face,
+                   FT_UInt    num_coords,
+                   FT_Fixed*  coords );
+
+  FT_LOCAL( FT_Error )
+  T1_Set_MM_Design( T1_Face   face,
+                    FT_UInt   num_coords,
+                    FT_Long*  coords );
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Set_Var_Design( T1_Face    face,
+                     FT_UInt    num_coords,
+                     FT_Fixed*  coords );
+
+  FT_LOCAL( void )
+  T1_Done_Blend( T1_Face  face );
+
+#endif /* !T1_CONFIG_OPTION_NO_MM_SUPPORT */
+
+
+FT_END_HEADER
+
+#endif /* __T1LOAD_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1objs.c b/nx-X11/extras/freetype2/src/type1/t1objs.c
new file mode 100644
index 000000000..a832ee000
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1objs.c
@@ -0,0 +1,552 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1objs.c                                                               */
+/*                                                                         */
+/*    Type 1 objects manager (body).                                       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_TRUETYPE_IDS_H
+
+#include "t1gload.h"
+#include "t1load.h"
+
+#include "t1errors.h"
+
+#ifndef T1_CONFIG_OPTION_NO_AFM
+#include "t1afm.h"
+#endif
+
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+#include FT_INTERNAL_POSTSCRIPT_AUX_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_t1objs
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                            SIZE FUNCTIONS                             */
+  /*                                                                       */
+  /*  note that we store the global hints in the size's "internal" root    */
+  /*  field                                                                */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static PSH_Globals_Funcs
+  T1_Size_Get_Globals_Funcs( T1_Size  size )
+  {
+    T1_Face           face     = (T1_Face)size->root.face;
+    PSHinter_Service  pshinter = (PSHinter_Service)face->pshinter;
+    FT_Module         module;
+
+
+    module = FT_Get_Module( size->root.face->driver->root.library,
+                            "pshinter" );
+    return ( module && pshinter && pshinter->get_globals_funcs )
+           ? pshinter->get_globals_funcs( module )
+           : 0 ;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T1_Size_Done( T1_Size  size )
+  {
+    if ( size->root.internal )
+    {
+      PSH_Globals_Funcs  funcs;
+
+
+      funcs = T1_Size_Get_Globals_Funcs( size );
+      if ( funcs )
+        funcs->destroy( (PSH_Globals)size->root.internal );
+
+      size->root.internal = 0;
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Size_Init( T1_Size  size )
+  {
+    FT_Error           error = 0;
+    PSH_Globals_Funcs  funcs = T1_Size_Get_Globals_Funcs( size );
+
+
+    if ( funcs )
+    {
+      PSH_Globals  globals;
+      T1_Face      face = (T1_Face)size->root.face;
+
+
+      error = funcs->create( size->root.face->memory,
+                             &face->type1.private_dict, &globals );
+      if ( !error )
+        size->root.internal = (FT_Size_Internal)(void*)globals;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Size_Reset( T1_Size  size )
+  {
+    PSH_Globals_Funcs  funcs = T1_Size_Get_Globals_Funcs( size );
+    FT_Error           error = 0;
+
+
+    if ( funcs )
+      error = funcs->set_scale( (PSH_Globals)size->root.internal,
+                                size->root.metrics.x_scale,
+                                size->root.metrics.y_scale,
+                                0, 0 );
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                            SLOT  FUNCTIONS                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( void )
+  T1_GlyphSlot_Done( T1_GlyphSlot  slot )
+  {
+    slot->root.internal->glyph_hints = 0;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_GlyphSlot_Init( T1_GlyphSlot  slot )
+  {
+    T1_Face           face;
+    PSHinter_Service  pshinter;
+
+
+    face     = (T1_Face)slot->root.face;
+    pshinter = (PSHinter_Service)face->pshinter;
+
+    if ( pshinter )
+    {
+      FT_Module  module;
+
+
+      module = FT_Get_Module( slot->root.face->driver->root.library, "pshinter" );
+      if (module)
+      {
+        T1_Hints_Funcs  funcs;
+
+        funcs = pshinter->get_t1_funcs( module );
+        slot->root.internal->glyph_hints = (void*)funcs;
+      }
+    }
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                            FACE  FUNCTIONS                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    T1_Face_Done                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The face object destructor.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A typeless pointer to the face object to destroy.          */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  T1_Face_Done( T1_Face  face )
+  {
+    FT_Memory  memory;
+    T1_Font    type1 = &face->type1;
+
+
+    if ( face )
+    {
+      memory = face->root.memory;
+
+#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
+      /* release multiple masters information */
+      T1_Done_Blend( face );
+      face->blend = 0;
+#endif
+
+      /* release font info strings */
+      {
+        PS_FontInfo  info = &type1->font_info;
+
+
+        FT_FREE( info->version );
+        FT_FREE( info->notice );
+        FT_FREE( info->full_name );
+        FT_FREE( info->family_name );
+        FT_FREE( info->weight );
+      }
+
+      /* release top dictionary */
+      FT_FREE( type1->charstrings_len );
+      FT_FREE( type1->charstrings );
+      FT_FREE( type1->glyph_names );
+
+      FT_FREE( type1->subrs );
+      FT_FREE( type1->subrs_len );
+
+      FT_FREE( type1->subrs_block );
+      FT_FREE( type1->charstrings_block );
+      FT_FREE( type1->glyph_names_block );
+
+      FT_FREE( type1->encoding.char_index );
+      FT_FREE( type1->encoding.char_name );
+      FT_FREE( type1->font_name );
+
+#ifndef T1_CONFIG_OPTION_NO_AFM
+      /* release afm data if present */
+      if ( face->afm_data )
+        T1_Done_AFM( memory, (T1_AFM*)face->afm_data );
+#endif
+
+      /* release unicode map, if any */
+      FT_FREE( face->unicode_map.maps );
+      face->unicode_map.num_maps = 0;
+
+      face->root.family_name = 0;
+      face->root.style_name  = 0;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    T1_Face_Init                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The face object constructor.                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream     ::  input stream where to load font data.               */
+  /*                                                                       */
+  /*    face_index :: The index of the font face in the resource.          */
+  /*                                                                       */
+  /*    num_params :: Number of additional generic parameters.  Ignored.   */
+  /*                                                                       */
+  /*    params     :: Additional generic parameters.  Ignored.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: The face record to build.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  T1_Face_Init( FT_Stream      stream,
+                T1_Face        face,
+                FT_Int         face_index,
+                FT_Int         num_params,
+                FT_Parameter*  params )
+  {
+    FT_Error            error;
+    FT_Service_PsCMaps  psnames;
+    PSAux_Service       psaux;
+    T1_Font             type1 = &face->type1;
+    PS_FontInfo         info = &type1->font_info;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( face_index );
+    FT_UNUSED( stream );
+
+
+    face->root.num_faces = 1;
+
+    FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
+    face->psnames = psnames;
+
+    face->psaux = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                           "psaux" );
+    psaux = (PSAux_Service)face->psaux;
+
+    face->pshinter = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                              "pshinter" );
+
+    /* open the tokenizer; this will also check the font format */
+    error = T1_Open_Face( face );
+    if ( error )
+      goto Exit;
+
+    /* if we just wanted to check the format, leave successfully now */
+    if ( face_index < 0 )
+      goto Exit;
+
+    /* check the face index */
+    if ( face_index != 0 )
+    {
+      FT_ERROR(( "T1_Face_Init: invalid face index\n" ));
+      error = T1_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* now load the font program into the face object */
+
+    /* initialize the face object fields */
+
+    /* set up root face fields */
+    {
+      FT_Face  root = (FT_Face)&face->root;
+
+
+      root->num_glyphs = type1->num_glyphs;
+      root->face_index = face_index;
+
+      root->face_flags  = FT_FACE_FLAG_SCALABLE;
+      root->face_flags |= FT_FACE_FLAG_HORIZONTAL;
+      root->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;
+
+      if ( info->is_fixed_pitch )
+        root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      if ( face->blend )
+        root->face_flags |= FT_FACE_FLAG_MULTIPLE_MASTERS;
+
+      /* XXX: TODO -- add kerning with .afm support */
+
+      /* get style name -- be careful, some broken fonts only */
+      /* have a `/FontName' dictionary entry!                 */
+      root->family_name = info->family_name;
+      /* assume "Regular" style if we don't know better */
+      root->style_name = (char *)"Regular";
+      if ( root->family_name )
+      {
+        char*  full   = info->full_name;
+        char*  family = root->family_name;
+
+
+        if ( full )
+        {
+          while ( *full )
+          {
+            if ( *full == *family )
+            {
+              family++;
+              full++;
+            }
+            else
+            {
+              if ( *full == ' ' || *full == '-' )
+                full++;
+              else if ( *family == ' ' || *family == '-' )
+                family++;
+              else
+              {
+                if ( !*family )
+                  root->style_name = full;
+                break;
+              }
+            }
+          }
+        }
+      }
+      else
+      {
+        /* do we have a `/FontName'? */
+        if ( type1->font_name )
+          root->family_name = type1->font_name;
+      }
+
+      /* compute style flags */
+      root->style_flags = 0;
+      if ( info->italic_angle )
+        root->style_flags |= FT_STYLE_FLAG_ITALIC;
+      if ( info->weight )
+      {
+        if ( !ft_strcmp( info->weight, "Bold"  ) ||
+             !ft_strcmp( info->weight, "Black" ) )
+          root->style_flags |= FT_STYLE_FLAG_BOLD;
+      }
+
+      /* no embedded bitmap support */
+      root->num_fixed_sizes = 0;
+      root->available_sizes = 0;
+
+      root->bbox.xMin =   type1->font_bbox.xMin             >> 16;
+      root->bbox.yMin =   type1->font_bbox.yMin             >> 16;
+      root->bbox.xMax = ( type1->font_bbox.xMax + 0xFFFFU ) >> 16;
+      root->bbox.yMax = ( type1->font_bbox.yMax + 0xFFFFU ) >> 16;
+
+      /* Set units_per_EM if we didn't set it in parse_font_matrix. */
+      if ( !root->units_per_EM )
+        root->units_per_EM = 1000;
+
+      root->ascender  = (FT_Short)( root->bbox.yMax );
+      root->descender = (FT_Short)( root->bbox.yMin );
+      root->height    = (FT_Short)(
+        ( ( root->ascender - root->descender ) * 12 ) / 10 );
+
+      /* now compute the maximum advance width */
+      root->max_advance_width =
+        (FT_Short)( root->bbox.xMax );
+      {
+        FT_Pos  max_advance;
+
+
+        error = T1_Compute_Max_Advance( face, &max_advance );
+
+        /* in case of error, keep the standard width */
+        if ( !error )
+          root->max_advance_width = (FT_Short)max_advance;
+        else
+          error = 0;   /* clear error */
+      }
+
+      root->max_advance_height = root->height;
+
+      root->underline_position  = (FT_Short)info->underline_position;
+      root->underline_thickness = (FT_Short)info->underline_thickness;
+
+      root->internal->max_points   = 0;
+      root->internal->max_contours = 0;
+    }
+
+    {
+      FT_Face  root = &face->root;
+
+
+      if ( psnames && psaux )
+      {
+        FT_CharMapRec    charmap;
+        T1_CMap_Classes  cmap_classes = psaux->t1_cmap_classes;
+        FT_CMap_Class    clazz;
+
+
+        charmap.face = root;
+
+        /* first of all, try to synthetize a Unicode charmap */
+        charmap.platform_id = 3;
+        charmap.encoding_id = 1;
+        charmap.encoding    = FT_ENCODING_UNICODE;
+
+        FT_CMap_New( cmap_classes->unicode, NULL, &charmap, NULL );
+
+        /* now, generate an Adobe Standard encoding when appropriate */
+        charmap.platform_id = 7;
+        clazz               = NULL;
+
+        switch ( type1->encoding_type )
+        {
+        case T1_ENCODING_TYPE_STANDARD:
+          charmap.encoding    = FT_ENCODING_ADOBE_STANDARD;
+          charmap.encoding_id = TT_ADOBE_ID_STANDARD;
+          clazz               = cmap_classes->standard;
+          break;
+
+        case T1_ENCODING_TYPE_EXPERT:
+          charmap.encoding    = FT_ENCODING_ADOBE_EXPERT;
+          charmap.encoding_id = TT_ADOBE_ID_EXPERT;
+          clazz               = cmap_classes->expert;
+          break;
+
+        case T1_ENCODING_TYPE_ARRAY:
+          charmap.encoding    = FT_ENCODING_ADOBE_CUSTOM;
+          charmap.encoding_id = TT_ADOBE_ID_CUSTOM;
+          clazz               = cmap_classes->custom;
+          break;
+
+        case T1_ENCODING_TYPE_ISOLATIN1:
+          charmap.encoding    = FT_ENCODING_ADOBE_LATIN_1;
+          charmap.encoding_id = TT_ADOBE_ID_LATIN_1;
+          clazz               = cmap_classes->unicode;
+          break;
+
+        default:
+          ;
+        }
+
+        if ( clazz )
+          FT_CMap_New( clazz, NULL, &charmap, NULL );
+
+#if 0
+        /* Select default charmap */
+        if (root->num_charmaps)
+          root->charmap = root->charmaps[0];
+#endif
+      }
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    T1_Driver_Init                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given Type 1 driver object.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    driver :: A handle to the target driver object.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  T1_Driver_Init( T1_Driver  driver )
+  {
+    FT_UNUSED( driver );
+
+    return T1_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    T1_Driver_Done                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finalizes a given Type 1 driver.                                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    driver :: A handle to the target Type 1 driver.                    */
+  /*                                                                       */
+  FT_LOCAL_DEF( void )
+  T1_Driver_Done( T1_Driver  driver )
+  {
+    FT_UNUSED( driver );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1objs.h b/nx-X11/extras/freetype2/src/type1/t1objs.h
new file mode 100644
index 000000000..9aeb10dd2
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1objs.h
@@ -0,0 +1,170 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1objs.h                                                               */
+/*                                                                         */
+/*    Type 1 objects manager (specification).                              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 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 __T1OBJS_H__
+#define __T1OBJS_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_CONFIG_CONFIG_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* The following structures must be defined by the hinter */
+  typedef struct T1_Size_Hints_   T1_Size_Hints;
+  typedef struct T1_Glyph_Hints_  T1_Glyph_Hints;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    T1_Driver                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a Type 1 driver object.                                */
+  /*                                                                       */
+  typedef struct T1_DriverRec_   *T1_Driver;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    T1_Size                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a Type 1 size object.                                  */
+  /*                                                                       */
+  typedef struct T1_SizeRec_*  T1_Size;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    T1_GlyphSlot                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a Type 1 glyph slot object.                            */
+  /*                                                                       */
+  typedef struct T1_GlyphSlotRec_*  T1_GlyphSlot;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    T1_CharMap                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a Type 1 character mapping object.                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The Type 1 format doesn't use a charmap but an encoding table.     */
+  /*    The driver is responsible for making up charmap objects            */
+  /*    corresponding to these tables.                                     */
+  /*                                                                       */
+  typedef struct T1_CharMapRec_*   T1_CharMap;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                  HERE BEGINS THE TYPE1 SPECIFIC STUFF                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    T1_SizeRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Type 1 size record.                                                */
+  /*                                                                       */
+  typedef struct  T1_SizeRec_
+  {
+    FT_SizeRec  root;
+
+  } T1_SizeRec;
+
+
+  FT_LOCAL( void )
+  T1_Size_Done( T1_Size  size );
+
+  FT_LOCAL( FT_Error )
+  T1_Size_Reset( T1_Size  size );
+
+  FT_LOCAL( FT_Error )
+  T1_Size_Init( T1_Size  size );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    T1_GlyphSlotRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Type 1 glyph slot record.                                          */
+  /*                                                                       */
+  typedef struct  T1_GlyphSlotRec_
+  {
+    FT_GlyphSlotRec  root;
+
+    FT_Bool          hint;
+    FT_Bool          scaled;
+
+    FT_Int           max_points;
+    FT_Int           max_contours;
+
+    FT_Fixed         x_scale;
+    FT_Fixed         y_scale;
+
+  } T1_GlyphSlotRec;
+
+
+  FT_LOCAL( FT_Error )
+  T1_Face_Init( FT_Stream      stream,
+                T1_Face        face,
+                FT_Int         face_index,
+                FT_Int         num_params,
+                FT_Parameter*  params );
+
+  FT_LOCAL( void )
+  T1_Face_Done( T1_Face  face );
+
+  FT_LOCAL( FT_Error )
+  T1_GlyphSlot_Init( T1_GlyphSlot  slot );
+  
+  FT_LOCAL( void )
+  T1_GlyphSlot_Done( T1_GlyphSlot  slot );
+
+  FT_LOCAL( FT_Error )
+  T1_Driver_Init( T1_Driver  driver );
+
+  FT_LOCAL( void )
+  T1_Driver_Done( T1_Driver  driver );
+
+
+FT_END_HEADER
+
+#endif /* __T1OBJS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1parse.c b/nx-X11/extras/freetype2/src/type1/t1parse.c
new file mode 100644
index 000000000..544aa093f
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1parse.c
@@ -0,0 +1,443 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1parse.c                                                              */
+/*                                                                         */
+/*    Type 1 parser (body).                                                */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The Type 1 parser is in charge of the following:                      */
+  /*                                                                       */
+  /*  - provide an implementation of a growing sequence of objects called  */
+  /*    a `T1_Table' (used to build various tables needed by the loader).  */
+  /*                                                                       */
+  /*  - opening .pfb and .pfa files to extract their top-level and private */
+  /*    dictionaries.                                                      */
+  /*                                                                       */
+  /*  - read numbers, arrays & strings from any dictionary.                */
+  /*                                                                       */
+  /* See `t1load.c' to see how data is loaded from the font file.          */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_CALC_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+
+#include "t1parse.h"
+
+#include "t1errors.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_t1parse
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                   INPUT STREAM PARSER                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  static FT_Error
+  read_pfb_tag( FT_Stream   stream,
+                FT_UShort  *atag,
+                FT_Long    *asize )
+  {
+    FT_Error   error;
+    FT_UShort  tag;
+    FT_Long    size;
+
+
+    *atag  = 0;
+    *asize = 0;
+
+    if ( !FT_READ_USHORT( tag ) )
+    {
+      if ( tag == 0x8001U || tag == 0x8002U )
+      {
+        if ( !FT_READ_LONG_LE( size ) )
+          *asize = size;
+      }
+
+      *atag = tag;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_New_Parser( T1_Parser      parser,
+                 FT_Stream      stream,
+                 FT_Memory      memory,
+                 PSAux_Service  psaux )
+  {
+    FT_Error   error;
+    FT_UShort  tag;
+    FT_Long    size;
+
+
+    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );
+
+    parser->stream       = stream;
+    parser->base_len     = 0;
+    parser->base_dict    = 0;
+    parser->private_len  = 0;
+    parser->private_dict = 0;
+    parser->in_pfb       = 0;
+    parser->in_memory    = 0;
+    parser->single_block = 0;
+
+    /******************************************************************/
+    /*                                                                */
+    /* Here a short summary of what is going on:                      */
+    /*                                                                */
+    /*   When creating a new Type 1 parser, we try to locate and load */
+    /*   the base dictionary if this is possible (i.e. for PFB        */
+    /*   files).  Otherwise, we load the whole font into memory.      */
+    /*                                                                */
+    /*   When `loading' the base dictionary, we only setup pointers   */
+    /*   in the case of a memory-based stream.  Otherwise, we         */
+    /*   allocate and load the base dictionary in it.                 */
+    /*                                                                */
+    /*   parser->in_pfb is set if we are in a binary (".pfb") font.   */
+    /*   parser->in_memory is set if we have a memory stream.         */
+    /*                                                                */
+
+    /* try to compute the size of the base dictionary;   */
+    /* look for a Postscript binary file tag, i.e 0x8001 */
+    if ( FT_STREAM_SEEK( 0L ) )
+      goto Exit;
+
+    error = read_pfb_tag( stream, &tag, &size );
+    if ( error )
+      goto Exit;
+
+    if ( tag != 0x8001U )
+    {
+      /* assume that this is a PFA file for now; an error will */
+      /* be produced later when more things are checked        */
+      if ( FT_STREAM_SEEK( 0L ) )
+        goto Exit;
+      size = stream->size;
+    }
+    else
+      parser->in_pfb = 1;
+
+    /* now, try to load `size' bytes of the `base' dictionary we */
+    /* found previously                                          */
+
+    /* if it is a memory-based resource, set up pointers */
+    if ( !stream->read )
+    {
+      parser->base_dict = (FT_Byte*)stream->base + stream->pos;
+      parser->base_len  = size;
+      parser->in_memory = 1;
+
+      /* check that the `size' field is valid */
+      if ( FT_STREAM_SKIP( size ) )
+        goto Exit;
+    }
+    else
+    {
+      /* read segment in memory */
+      if ( FT_ALLOC( parser->base_dict, size )     ||
+           FT_STREAM_READ( parser->base_dict, size ) )
+        goto Exit;
+      parser->base_len = size;
+    }
+
+    /* Now check font format; we must see `%!PS-AdobeFont-1' */
+    /* or `%!FontType'                                       */
+    {
+      if ( size <= 16                                       ||
+           ( ft_strncmp( (const char*)parser->base_dict,
+                         "%!PS-AdobeFont-1", 16 )        &&
+             ft_strncmp( (const char*)parser->base_dict,
+                         "%!FontType", 10 )              )  )
+      {
+        FT_TRACE2(( "[not a Type1 font]\n" ));
+        error = T1_Err_Unknown_File_Format;
+      }
+      else
+      {
+        parser->root.base   = parser->base_dict;
+        parser->root.cursor = parser->base_dict;
+        parser->root.limit  = parser->root.cursor + parser->base_len;
+      }
+    }
+
+  Exit:
+    if ( error && !parser->in_memory )
+      FT_FREE( parser->base_dict );
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T1_Finalize_Parser( T1_Parser  parser )
+  {
+    FT_Memory  memory = parser->root.memory;
+
+
+    /* always free the private dictionary */
+    FT_FREE( parser->private_dict );
+
+    /* free the base dictionary only when we have a disk stream */
+    if ( !parser->in_memory )
+      FT_FREE( parser->base_dict );
+
+    parser->root.funcs.done( &parser->root );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T1_Get_Private_Dict( T1_Parser      parser,
+                       PSAux_Service  psaux )
+  {
+    FT_Stream  stream = parser->stream;
+    FT_Memory  memory = parser->root.memory;
+    FT_Error   error  = T1_Err_Ok;
+    FT_Long    size;
+
+
+    if ( parser->in_pfb )
+    {
+      /* in the case of the PFB format, the private dictionary can be  */
+      /* made of several segments.  We thus first read the number of   */
+      /* segments to compute the total size of the private dictionary  */
+      /* then re-read them into memory.                                */
+      FT_Long    start_pos = FT_STREAM_POS();
+      FT_UShort  tag;
+
+
+      parser->private_len = 0;
+      for (;;)
+      {
+        error = read_pfb_tag( stream, &tag, &size );
+        if ( error )
+          goto Fail;
+
+        if ( tag != 0x8002U )
+          break;
+
+        parser->private_len += size;
+
+        if ( FT_STREAM_SKIP( size ) )
+          goto Fail;
+      }
+
+      /* Check that we have a private dictionary there */
+      /* and allocate private dictionary buffer        */
+      if ( parser->private_len == 0 )
+      {
+        FT_ERROR(( "T1_Get_Private_Dict:" ));
+        FT_ERROR(( " invalid private dictionary section\n" ));
+        error = T1_Err_Invalid_File_Format;
+        goto Fail;
+      }
+
+      if ( FT_STREAM_SEEK( start_pos )                             ||
+           FT_ALLOC( parser->private_dict, parser->private_len ) )
+        goto Fail;
+
+      parser->private_len = 0;
+      for (;;)
+      {
+        error = read_pfb_tag( stream, &tag, &size );
+        if ( error || tag != 0x8002U )
+        {
+          error = T1_Err_Ok;
+          break;
+        }
+
+        if ( FT_STREAM_READ( parser->private_dict + parser->private_len,
+                             size ) )
+          goto Fail;
+
+        parser->private_len += size;
+      }
+    }
+    else
+    {
+      /* We have already `loaded' the whole PFA font file into memory; */
+      /* if this is a memory resource, allocate a new block to hold    */
+      /* the private dict.  Otherwise, simply overwrite into the base  */
+      /* dictionary block in the heap.                                 */
+
+      /* first of all, look at the `eexec' keyword */
+      FT_Byte*  cur   = parser->base_dict;
+      FT_Byte*  limit = cur + parser->base_len;
+      FT_Byte   c;
+
+
+    Again:
+      for (;;)
+      {
+        c = cur[0];
+        if ( c == 'e' && cur + 9 < limit )  /* 9 = 5 letters for `eexec' + */
+                                            /* newline + 4 chars           */
+        {
+          if ( cur[1] == 'e' &&
+               cur[2] == 'x' &&
+               cur[3] == 'e' &&
+               cur[4] == 'c' )
+            break;
+        }
+        cur++;
+        if ( cur >= limit )
+        {
+          FT_ERROR(( "T1_Get_Private_Dict:" ));
+          FT_ERROR(( " could not find `eexec' keyword\n" ));
+          error = T1_Err_Invalid_File_Format;
+          goto Exit;
+        }
+      }
+
+      /* check whether `eexec' was real -- it could be in a comment */
+      /* or string (as e.g. in u003043t.gsf from ghostscript)       */
+
+      parser->root.cursor = parser->base_dict;
+      parser->root.limit  = cur + 9;
+
+      cur   = parser->root.cursor;
+      limit = parser->root.limit;
+
+      while ( cur < limit )
+      {
+        if ( *cur == 'e' && ft_strncmp( (char*)cur, "eexec", 5 ) == 0 )
+          goto Found;
+
+        T1_Skip_PS_Token( parser );
+        T1_Skip_Spaces  ( parser );
+        cur = parser->root.cursor;
+      }
+
+      /* we haven't found the correct `eexec'; go back and continue */
+      /* searching                                                  */
+
+      cur   = limit;
+      limit = parser->base_dict + parser->base_len;
+      goto Again;
+
+      /* now determine where to write the _encrypted_ binary private  */
+      /* dictionary.  We overwrite the base dictionary for disk-based */
+      /* resources and allocate a new block otherwise                 */
+
+    Found:
+      parser->root.limit = parser->base_dict + parser->base_len;
+
+      T1_Skip_PS_Token( parser );
+      cur = parser->root.cursor;
+      if ( *cur == '\r' )
+      {
+        cur++;
+        if ( *cur == '\n' )
+          cur++;
+      }
+      else if ( *cur == '\n' )
+        cur++;
+      else
+      {
+        FT_ERROR(( "T1_Get_Private_Dict:" ));
+        FT_ERROR(( " `eexec' not properly terminated\n" ));
+        error = T1_Err_Invalid_File_Format;
+        goto Exit;
+      }
+
+      size = (FT_Long)( parser->base_len - ( cur - parser->base_dict ) );
+
+      if ( parser->in_memory )
+      {
+        /* note that we allocate one more byte to put a terminating `0' */
+        if ( FT_ALLOC( parser->private_dict, size + 1 ) )
+          goto Fail;
+        parser->private_len = size;
+      }
+      else
+      {
+        parser->single_block = 1;
+        parser->private_dict = parser->base_dict;
+        parser->private_len  = size;
+        parser->base_dict    = 0;
+        parser->base_len     = 0;
+      }
+
+      /* now determine whether the private dictionary is encoded in binary */
+      /* or hexadecimal ASCII format -- decode it accordingly              */
+
+      /* we need to access the next 4 bytes (after the final \r following */
+      /* the `eexec' keyword); if they all are hexadecimal digits, then   */
+      /* we have a case of ASCII storage                                  */
+
+      if ( ft_isxdigit( cur[0] ) && ft_isxdigit( cur[1] ) &&
+           ft_isxdigit( cur[2] ) && ft_isxdigit( cur[3] ) )
+      {
+        /* ASCII hexadecimal encoding */
+        FT_Long  len;
+
+
+        parser->root.cursor = cur;
+        (void)psaux->ps_parser_funcs->to_bytes( &parser->root,
+                                                parser->private_dict,
+                                                parser->private_len,
+                                                &len,
+                                                0 );
+        parser->private_len = len;
+
+        /* put a safeguard */
+        parser->private_dict[len] = '\0';
+      }
+      else
+        /* binary encoding -- copy the private dict */
+        FT_MEM_MOVE( parser->private_dict, cur, size );
+    }
+
+    /* we now decrypt the encoded binary private dictionary */
+    psaux->t1_decrypt( parser->private_dict, parser->private_len, 55665U );
+
+    /* replace the four random bytes at the beginning with whitespace */
+    parser->private_dict[0] = ' ';
+    parser->private_dict[1] = ' ';
+    parser->private_dict[2] = ' ';
+    parser->private_dict[3] = ' ';
+
+    parser->root.base   = parser->private_dict;
+    parser->root.cursor = parser->private_dict;
+    parser->root.limit  = parser->root.cursor + parser->private_len;
+
+  Fail:
+  Exit:
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1parse.h b/nx-X11/extras/freetype2/src/type1/t1parse.h
new file mode 100644
index 000000000..6fa4ca624
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1parse.h
@@ -0,0 +1,135 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1parse.h                                                              */
+/*                                                                         */
+/*    Type 1 parser (specification).                                       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003 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 __T1PARSE_H__
+#define __T1PARSE_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_STREAM_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    T1_ParserRec                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A PS_ParserRec is an object used to parse a Type 1 fonts very      */
+  /*    quickly.                                                           */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root         :: The root parser.                                   */
+  /*                                                                       */
+  /*    stream       :: The current input stream.                          */
+  /*                                                                       */
+  /*    base_dict    :: A pointer to the top-level dictionary.             */
+  /*                                                                       */
+  /*    base_len     :: The length in bytes of the top dictionary.         */
+  /*                                                                       */
+  /*    private_dict :: A pointer to the private dictionary.               */
+  /*                                                                       */
+  /*    private_len  :: The length in bytes of the private dictionary.     */
+  /*                                                                       */
+  /*    in_pfb       :: A boolean.  Indicates that we are handling a PFB   */
+  /*                    file.                                              */
+  /*                                                                       */
+  /*    in_memory    :: A boolean.  Indicates a memory-based stream.       */
+  /*                                                                       */
+  /*    single_block :: A boolean.  Indicates that the private dictionary  */
+  /*                    is stored in lieu of the base dictionary.          */
+  /*                                                                       */
+  typedef struct  T1_ParserRec_
+  {
+    PS_ParserRec  root;
+    FT_Stream     stream;
+
+    FT_Byte*      base_dict;
+    FT_Long       base_len;
+
+    FT_Byte*      private_dict;
+    FT_Long       private_len;
+
+    FT_Bool       in_pfb;
+    FT_Bool       in_memory;
+    FT_Bool       single_block;
+
+  } T1_ParserRec, *T1_Parser;
+
+
+#define T1_Add_Table( p, i, o, l )  (p)->funcs.add( (p), i, o, l )
+#define T1_Done_Table( p )          \
+          do                        \
+          {                         \
+            if ( (p)->funcs.done )  \
+              (p)->funcs.done( p ); \
+          } while ( 0 )
+#define T1_Release_Table( p )          \
+          do                           \
+          {                            \
+            if ( (p)->funcs.release )  \
+              (p)->funcs.release( p ); \
+          } while ( 0 )
+
+
+#define T1_Skip_Spaces( p )    (p)->root.funcs.skip_spaces( &(p)->root )
+#define T1_Skip_PS_Token( p )  (p)->root.funcs.skip_PS_token( &(p)->root )
+
+#define T1_ToInt( p )       (p)->root.funcs.to_int( &(p)->root )
+#define T1_ToFixed( p, t )  (p)->root.funcs.to_fixed( &(p)->root, t )
+
+#define T1_ToCoordArray( p, m, c )                           \
+          (p)->root.funcs.to_coord_array( &(p)->root, m, c )
+#define T1_ToFixedArray( p, m, f, t )                           \
+          (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
+#define T1_ToToken( p, t )                          \
+          (p)->root.funcs.to_token( &(p)->root, t )
+#define T1_ToTokenArray( p, t, m, c )                           \
+          (p)->root.funcs.to_token_array( &(p)->root, t, m, c )
+
+#define T1_Load_Field( p, f, o, m, pf )                         \
+          (p)->root.funcs.load_field( &(p)->root, f, o, m, pf )
+
+#define T1_Load_Field_Table( p, f, o, m, pf )                         \
+          (p)->root.funcs.load_field_table( &(p)->root, f, o, m, pf )
+
+
+  FT_LOCAL( FT_Error )
+  T1_New_Parser( T1_Parser      parser,
+                 FT_Stream      stream,
+                 FT_Memory      memory,
+                 PSAux_Service  psaux );
+
+  FT_LOCAL( FT_Error )
+  T1_Get_Private_Dict( T1_Parser      parser,
+                       PSAux_Service  psaux );
+
+  FT_LOCAL( void )
+  T1_Finalize_Parser( T1_Parser  parser );
+
+
+FT_END_HEADER
+
+#endif /* __T1PARSE_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/t1tokens.h b/nx-X11/extras/freetype2/src/type1/t1tokens.h
new file mode 100644
index 000000000..a3cc952e0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/t1tokens.h
@@ -0,0 +1,84 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1tokens.h                                                             */
+/*                                                                         */
+/*    Type 1 tokenizer (specification).                                    */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PS_FontInfoRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_FONT_INFO
+
+  T1_FIELD_STRING( "version", version )
+  T1_FIELD_STRING( "Notice", notice )
+  T1_FIELD_STRING( "FullName", full_name )
+  T1_FIELD_STRING( "FamilyName", family_name )
+  T1_FIELD_STRING( "Weight", weight )
+
+  /* we use pointers to detect modifications made by synthetic fonts */
+  T1_FIELD_NUM   ( "ItalicAngle", italic_angle )
+  T1_FIELD_BOOL  ( "isFixedPitch", is_fixed_pitch )
+  T1_FIELD_NUM   ( "UnderlinePosition", underline_position )
+  T1_FIELD_NUM   ( "UnderlineThickness", underline_thickness )
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PS_PrivateRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_PRIVATE
+
+  T1_FIELD_NUM       ( "UniqueID", unique_id )
+  T1_FIELD_NUM       ( "lenIV", lenIV )
+  T1_FIELD_NUM       ( "LanguageGroup", language_group )
+  T1_FIELD_NUM       ( "password", password )
+
+  T1_FIELD_FIXED_1000( "BlueScale", blue_scale )
+  T1_FIELD_NUM       ( "BlueShift", blue_shift )
+  T1_FIELD_NUM       ( "BlueFuzz",  blue_fuzz )
+
+  T1_FIELD_NUM_TABLE ( "BlueValues", blue_values, 14 )
+  T1_FIELD_NUM_TABLE ( "OtherBlues", other_blues, 10 )
+  T1_FIELD_NUM_TABLE ( "FamilyBlues", family_blues, 14 )
+  T1_FIELD_NUM_TABLE ( "FamilyOtherBlues", family_other_blues, 10 )
+
+  T1_FIELD_NUM_TABLE2( "StdHW", standard_width,  1 )
+  T1_FIELD_NUM_TABLE2( "StdVW", standard_height, 1 )
+  T1_FIELD_NUM_TABLE2( "MinFeature", min_feature, 2 )
+
+  T1_FIELD_NUM_TABLE ( "StemSnapH", snap_widths, 12 )
+  T1_FIELD_NUM_TABLE ( "StemSnapV", snap_heights, 12 )
+
+  T1_FIELD_FIXED     ( "ExpansionFactor", expansion_factor )
+
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  T1_FontRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_FONT_DICT
+
+  T1_FIELD_KEY  ( "FontName", font_name )
+  T1_FIELD_NUM  ( "PaintType", paint_type )
+  T1_FIELD_NUM  ( "FontType", font_type )
+  T1_FIELD_FIXED( "StrokeWidth", stroke_width )
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  FT_BBox
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_BBOX
+
+  T1_FIELD_BBOX("FontBBox", xMin )
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type1/type1.c b/nx-X11/extras/freetype2/src/type1/type1.c
new file mode 100644
index 000000000..ccc12be10
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type1/type1.c
@@ -0,0 +1,33 @@
+/***************************************************************************/
+/*                                                                         */
+/*  type1.c                                                                */
+/*                                                                         */
+/*    FreeType Type 1 driver component (body only).                        */
+/*                                                                         */
+/*  Copyright 1996-2001 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 "t1parse.c"
+#include "t1load.c"
+#include "t1objs.c"
+#include "t1driver.c"
+#include "t1gload.c"
+
+#ifndef T1_CONFIG_OPTION_NO_AFM
+#include "t1afm.c"
+#endif
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/Jamfile b/nx-X11/extras/freetype2/src/type42/Jamfile
new file mode 100644
index 000000000..032ac7179
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/Jamfile
@@ -0,0 +1,21 @@
+# FreeType 2 src/type42 Jamfile (c) 2002 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) type42 ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = t42objs t42parse t42drivr ;
+  }
+  else
+  {
+    _sources = type42 ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/type42 Jamfile
diff --git a/nx-X11/extras/freetype2/src/type42/descrip.mms b/nx-X11/extras/freetype2/src/type42/descrip.mms
new file mode 100644
index 000000000..a52ba06fb
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 Type 42 driver compilation rules for VMS
+#
+
+
+# Copyright 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.type42])
+
+OBJS=type42.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/type42/module.mk b/nx-X11/extras/freetype2/src/type42/module.mk
new file mode 100644
index 000000000..ceaea41b0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/module.mk
@@ -0,0 +1,22 @@
+#
+# FreeType 2 Type42 module definition
+#
+
+
+# Copyright 2002 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.
+
+
+make_module_list: add_type42_driver
+
+add_type42_driver:
+	$(OPEN_DRIVER)t42_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)type42     $(ECHO_DRIVER_DESC)Type 42 font files with no known extension$(ECHO_DRIVER_DONE)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/type42/rules.mk b/nx-X11/extras/freetype2/src/type42/rules.mk
new file mode 100644
index 000000000..556306195
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/rules.mk
@@ -0,0 +1,69 @@
+#
+# FreeType 2 Type42 driver configuration rules
+#
+
+
+# Copyright 2002, 2003 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.
+
+
+# Type42 driver directory
+#
+T42_DIR := $(SRC_DIR)/type42
+
+
+# compilation flags for the driver
+#
+T42_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(T42_DIR))
+
+
+# Type42 driver source
+#
+T42_DRV_SRC := $(T42_DIR)/t42objs.c  \
+               $(T42_DIR)/t42parse.c \
+               $(T42_DIR)/t42drivr.c
+
+# Type42 driver headers
+#
+T42_DRV_H := $(T42_DRV_SRC:%.c=%.h) \
+             $(T42_DIR)/t42error.h
+
+
+# Type42 driver object(s)
+#
+#   T42_DRV_OBJ_M is used during `multi' builds
+#   T42_DRV_OBJ_S is used during `single' builds
+#
+T42_DRV_OBJ_M := $(T42_DRV_SRC:$(T42_DIR)/%.c=$(OBJ_DIR)/%.$O)
+T42_DRV_OBJ_S := $(OBJ_DIR)/type42.$O
+
+# Type42 driver source file for single build
+#
+T42_DRV_SRC_S := $(T42_DIR)/type42.c
+
+
+# Type42 driver - single object
+#
+$(T42_DRV_OBJ_S): $(T42_DRV_SRC_S) $(T42_DRV_SRC) $(FREETYPE_H) $(T42_DRV_H)
+	$(T42_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(T42_DRV_SRC_S))
+
+
+# Type42 driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(T42_DIR)/%.c $(FREETYPE_H) $(T42_DRV_H)
+	$(T42_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(T42_DRV_OBJ_S)
+DRV_OBJS_M += $(T42_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/type42/t42drivr.c b/nx-X11/extras/freetype2/src/type42/t42drivr.c
new file mode 100644
index 000000000..2afe2db84
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/t42drivr.c
@@ -0,0 +1,233 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42drivr.c                                                             */
+/*                                                                         */
+/*    High-level Type 42 driver interface (body).                          */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 by Roberto Alameda.                         */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This driver implements Type42 fonts as described in the               */
+  /* Technical Note #5012 from Adobe, with these limitations:              */
+  /*                                                                       */
+  /* 1) CID Fonts are not currently supported.                             */
+  /* 2) Incremental fonts making use of the GlyphDirectory keyword         */
+  /*    will be loaded, but the rendering will be using the TrueType       */
+  /*    tables.                                                            */
+  /* 3) As for Type1 fonts, CDevProc is not supported.                     */
+  /* 4) The Metrics dictionary is not supported.                           */
+  /* 5) AFM metrics are not supported.                                     */
+  /*                                                                       */
+  /* In other words, this driver supports Type42 fonts derived from        */
+  /* TrueType fonts in a non-CID manner, as done by usual conversion       */
+  /* programs.                                                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include "t42drivr.h"
+#include "t42objs.h"
+#include "t42error.h"
+#include FT_INTERNAL_DEBUG_H
+
+#include FT_SERVICE_XFREE86_NAME_H
+#include FT_SERVICE_GLYPH_DICT_H
+#include FT_SERVICE_POSTSCRIPT_NAME_H
+#include FT_SERVICE_POSTSCRIPT_INFO_H
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_t42
+
+
+ /*
+  *
+  *  GLYPH DICT SERVICE
+  *
+  */
+
+  static FT_Error
+  t42_get_glyph_name( T42_Face    face,
+                      FT_UInt     glyph_index,
+                      FT_Pointer  buffer,
+                      FT_UInt     buffer_max )
+  {
+    FT_String*  gname;
+
+
+    gname = face->type1.glyph_names[glyph_index];
+
+    if ( buffer_max > 0 )
+    {
+      FT_UInt  len = (FT_UInt)( ft_strlen( gname ) );
+
+
+      if ( len >= buffer_max )
+        len = buffer_max - 1;
+
+      FT_MEM_COPY( buffer, gname, len );
+      ((FT_Byte*)buffer)[len] = 0;
+    }
+
+    return T42_Err_Ok;
+  }
+
+
+  static FT_UInt
+  t42_get_name_index( T42_Face    face,
+                      FT_String*  glyph_name )
+  {
+    FT_Int      i;
+    FT_String*  gname;
+
+
+    for ( i = 0; i < face->type1.num_glyphs; i++ )
+    {
+      gname = face->type1.glyph_names[i];
+
+      if ( !ft_strcmp( glyph_name, gname ) )
+        return (FT_UInt)ft_atol( (const char *)face->type1.charstrings[i] );
+    }
+
+    return 0;
+  }
+
+
+  static const FT_Service_GlyphDictRec  t42_service_glyph_dict =
+  {
+    (FT_GlyphDict_GetNameFunc)  t42_get_glyph_name,
+    (FT_GlyphDict_NameIndexFunc)t42_get_name_index
+  };
+
+
+ /*
+  *
+  *  POSTSCRIPT NAME SERVICE
+  *
+  */
+
+  static const char*
+  t42_get_ps_font_name( T42_Face  face )
+  {
+    return (const char*)face->type1.font_name;
+  }
+
+
+  static const FT_Service_PsFontNameRec  t42_service_ps_font_name =
+  {
+    (FT_PsName_GetFunc)t42_get_ps_font_name
+  };
+
+
+ /*
+  *
+  *  POSTSCRIPT INFO SERVICE
+  *
+  */
+
+  static FT_Error
+  t42_ps_get_font_info( FT_Face          face,
+                        PS_FontInfoRec*  afont_info )
+  {
+    *afont_info = ((T42_Face)face)->type1.font_info;
+    return 0;
+  }
+
+
+  static FT_Int
+  t42_ps_has_glyph_names( FT_Face  face )
+  {
+    FT_UNUSED( face );
+    return 1;
+  }
+
+
+  static const FT_Service_PsInfoRec  t42_service_ps_info =
+  {
+    (PS_GetFontInfoFunc)  t42_ps_get_font_info,
+    (PS_HasGlyphNamesFunc)t42_ps_has_glyph_names
+  };
+
+
+ /*
+  *
+  *  SERVICE LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  t42_services[] =
+  {
+    { FT_SERVICE_ID_GLYPH_DICT,           &t42_service_glyph_dict },
+    { FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &t42_service_ps_font_name },
+    { FT_SERVICE_ID_POSTSCRIPT_INFO,      &t42_service_ps_info },
+    { FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_TYPE_42 },
+    { NULL, NULL }
+  };
+
+
+  static FT_Module_Interface
+  T42_Get_Interface( FT_Driver         driver,
+                     const FT_String*  t42_interface )
+  {
+    FT_UNUSED( driver );
+
+    return ft_service_list_lookup( t42_services, t42_interface );
+  }
+
+
+  const FT_Driver_ClassRec  t42_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER       |
+      FT_MODULE_DRIVER_SCALABLE   |
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+      FT_MODULE_DRIVER_HAS_HINTER,
+#else
+      0,
+#endif
+
+      sizeof ( T42_DriverRec ),
+
+      "type42",
+      0x10000L,
+      0x20000L,
+
+      0,    /* format interface */
+
+      (FT_Module_Constructor)T42_Driver_Init,
+      (FT_Module_Destructor) T42_Driver_Done,
+      (FT_Module_Requester)  T42_Get_Interface,
+    },
+
+    sizeof ( T42_FaceRec ),
+    sizeof ( T42_SizeRec ),
+    sizeof ( T42_GlyphSlotRec ),
+
+    (FT_Face_InitFunc)        T42_Face_Init,
+    (FT_Face_DoneFunc)        T42_Face_Done,
+    (FT_Size_InitFunc)        T42_Size_Init,
+    (FT_Size_DoneFunc)        T42_Size_Done,
+    (FT_Slot_InitFunc)        T42_GlyphSlot_Init,
+    (FT_Slot_DoneFunc)        T42_GlyphSlot_Done,
+
+    (FT_Size_ResetPointsFunc) T42_Size_SetChars,
+    (FT_Size_ResetPixelsFunc) T42_Size_SetPixels,
+    (FT_Slot_LoadFunc)        T42_GlyphSlot_Load,
+
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+
+    (FT_Face_GetAdvancesFunc) 0
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/t42drivr.h b/nx-X11/extras/freetype2/src/type42/t42drivr.h
new file mode 100644
index 000000000..98b7410b6
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/t42drivr.h
@@ -0,0 +1,38 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42drivr.h                                                             */
+/*                                                                         */
+/*    High-level Type 42 driver interface (specification).                 */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42DRIVR_H__
+#define __T42DRIVR_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  t42_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __T42DRIVR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/t42error.h b/nx-X11/extras/freetype2/src/type42/t42error.h
new file mode 100644
index 000000000..b23091001
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/t42error.h
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42error.h                                                             */
+/*                                                                         */
+/*    Type 42 error codes (specification only).                            */
+/*                                                                         */
+/*  Copyright 2002, 2003 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 Type 42 error enumeration constants.  */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __T42ERROR_H__
+#define __T42ERROR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  T42_Err_
+#define FT_ERR_BASE    FT_Mod_Err_Type42
+
+#include FT_ERRORS_H
+
+#endif /* __T42ERROR_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/t42objs.c b/nx-X11/extras/freetype2/src/type42/t42objs.c
new file mode 100644
index 000000000..8837136ff
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/t42objs.c
@@ -0,0 +1,643 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42objs.c                                                              */
+/*                                                                         */
+/*    Type 42 objects manager (body).                                      */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 by Roberto Alameda.                         */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "t42objs.h"
+#include "t42parse.h"
+#include "t42error.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_LIST_H
+
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_t42
+
+
+  static FT_Error
+  T42_Open_Face( T42_Face  face )
+  {
+    T42_LoaderRec  loader;
+    T42_Parser     parser;
+    T1_Font        type1 = &face->type1;
+    FT_Memory      memory = face->root.memory;
+    FT_Error       error;
+
+    PSAux_Service  psaux  = (PSAux_Service)face->psaux;
+
+
+    t42_loader_init( &loader, face );
+
+    parser = &loader.parser;
+
+    if ( FT_ALLOC( face->ttf_data, 12 ) )
+      goto Exit;
+
+    error = t42_parser_init( parser,
+                             face->root.stream,
+                             memory,
+                             psaux);
+    if ( error )
+      goto Exit;
+
+    error = t42_parse_dict( face, &loader,
+                            parser->base_dict, parser->base_len );
+
+    if ( type1->font_type != 42 )
+    {
+      error = T42_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* now, propagate the charstrings and glyphnames tables */
+    /* to the Type1 data                                    */
+    type1->num_glyphs = loader.num_glyphs;
+
+    if ( !loader.charstrings.init )
+    {
+      FT_ERROR(( "T42_Open_Face: no charstrings array in face!\n" ));
+      error = T42_Err_Invalid_File_Format;
+    }
+
+    loader.charstrings.init  = 0;
+    type1->charstrings_block = loader.charstrings.block;
+    type1->charstrings       = loader.charstrings.elements;
+    type1->charstrings_len   = loader.charstrings.lengths;
+
+    /* we copy the glyph names `block' and `elements' fields; */
+    /* the `lengths' field must be released later             */
+    type1->glyph_names_block    = loader.glyph_names.block;
+    type1->glyph_names          = (FT_String**)loader.glyph_names.elements;
+    loader.glyph_names.block    = 0;
+    loader.glyph_names.elements = 0;
+
+    /* we must now build type1.encoding when we have a custom array */
+    if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY )
+    {
+      FT_Int    charcode, idx, min_char, max_char;
+      FT_Byte*  char_name;
+      FT_Byte*  glyph_name;
+
+
+      /* OK, we do the following: for each element in the encoding   */
+      /* table, look up the index of the glyph having the same name  */
+      /* as defined in the CharStrings array.                        */
+      /* The index is then stored in type1.encoding.char_index, and  */
+      /* the name in type1.encoding.char_name                        */
+
+      min_char = +32000;
+      max_char = -32000;
+
+      charcode = 0;
+      for ( ; charcode < loader.encoding_table.max_elems; charcode++ )
+      {
+        type1->encoding.char_index[charcode] = 0;
+        type1->encoding.char_name [charcode] = (char *)".notdef";
+
+        char_name = loader.encoding_table.elements[charcode];
+        if ( char_name )
+          for ( idx = 0; idx < type1->num_glyphs; idx++ )
+          {
+            glyph_name = (FT_Byte*)type1->glyph_names[idx];
+            if ( ft_strcmp( (const char*)char_name,
+                            (const char*)glyph_name ) == 0 )
+            {
+              type1->encoding.char_index[charcode] = (FT_UShort)idx;
+              type1->encoding.char_name [charcode] = (char*)glyph_name;
+
+              /* Change min/max encoded char only if glyph name is */
+              /* not /.notdef                                      */
+              if ( ft_strcmp( (const char*)".notdef",
+                              (const char*)glyph_name ) != 0 )
+              {
+                if ( charcode < min_char )
+                  min_char = charcode;
+                if ( charcode > max_char )
+                  max_char = charcode;
+              }
+              break;
+            }
+          }
+      }
+      type1->encoding.code_first = min_char;
+      type1->encoding.code_last  = max_char;
+      type1->encoding.num_chars  = loader.num_chars;
+    }
+
+  Exit:
+    t42_loader_done( &loader );
+    return error;
+  }
+
+
+  /***************** Driver Functions *************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_Face_Init( FT_Stream      stream,
+                 T42_Face       face,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    FT_Error            error;
+    FT_Service_PsCMaps  psnames;
+    PSAux_Service       psaux;
+    FT_Face             root  = (FT_Face)&face->root;
+    T1_Font             type1 = &face->type1;
+    PS_FontInfo         info  = &type1->font_info;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( face_index );
+    FT_UNUSED( stream );
+
+
+    face->ttf_face       = NULL;
+    face->root.num_faces = 1;
+
+    FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
+    face->psnames = psnames;
+
+    face->psaux = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                           "psaux" );
+    psaux = (PSAux_Service)face->psaux;
+
+    /* open the tokenizer, this will also check the font format */
+    error = T42_Open_Face( face );
+    if ( error )
+      goto Exit;
+
+    /* if we just wanted to check the format, leave successfully now */
+    if ( face_index < 0 )
+      goto Exit;
+
+    /* check the face index */
+    if ( face_index != 0 )
+    {
+      FT_ERROR(( "T42_Face_Init: invalid face index\n" ));
+      error = T42_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* Now load the font program into the face object */
+
+    /* Init the face object fields */
+    /* Now set up root face fields */
+
+    root->num_glyphs   = type1->num_glyphs;
+    root->num_charmaps = 0;
+    root->face_index   = face_index;
+
+    root->face_flags  = FT_FACE_FLAG_SCALABLE;
+    root->face_flags |= FT_FACE_FLAG_HORIZONTAL;
+    root->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;
+
+    if ( info->is_fixed_pitch )
+      root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+    /* XXX: TODO -- add kerning with .afm support */
+
+    /* get style name -- be careful, some broken fonts only */
+    /* have a `/FontName' dictionary entry!                 */
+    root->family_name = info->family_name;
+    /* assume "Regular" style if we don't know better */
+    root->style_name = (char *)"Regular";
+    if ( root->family_name )
+    {
+      char*  full   = info->full_name;
+      char*  family = root->family_name;
+
+
+      if ( full )
+      {
+        while ( *full )
+        {
+          if ( *full == *family )
+          {
+            family++;
+            full++;
+          }
+          else
+          {
+            if ( *full == ' ' || *full == '-' )
+              full++;
+            else if ( *family == ' ' || *family == '-' )
+              family++;
+            else
+            {
+              if ( !*family )
+                root->style_name = full;
+              break;
+            }
+          }
+        }
+      }
+    }
+    else
+    {
+      /* do we have a `/FontName'? */
+      if ( type1->font_name )
+        root->family_name = type1->font_name;
+    }
+
+    /* no embedded bitmap support */
+    root->num_fixed_sizes = 0;
+    root->available_sizes = 0;
+
+    /* Load the TTF font embedded in the T42 font */
+    error = FT_New_Memory_Face( FT_FACE_LIBRARY( face ),
+                                face->ttf_data,
+                                face->ttf_size,
+                                0,
+                                &face->ttf_face );
+    if ( error )
+      goto Exit;
+
+    FT_Done_Size( face->ttf_face->size );
+
+    /* Ignore info in FontInfo dictionary and use the info from the  */
+    /* loaded TTF font.  The PostScript interpreter also ignores it. */
+    root->bbox         = face->ttf_face->bbox;
+    root->units_per_EM = face->ttf_face->units_per_EM;
+
+    root->ascender  = face->ttf_face->ascender;
+    root->descender = face->ttf_face->descender;
+    root->height    = face->ttf_face->height;
+
+    root->max_advance_width  = face->ttf_face->max_advance_width;
+    root->max_advance_height = face->ttf_face->max_advance_height;
+
+    root->underline_position  = (FT_Short)info->underline_position;
+    root->underline_thickness = (FT_Short)info->underline_thickness;
+
+    root->internal->max_points   = 0;
+    root->internal->max_contours = 0;
+
+    /* compute style flags */
+    root->style_flags = 0;
+    if ( info->italic_angle )
+      root->style_flags |= FT_STYLE_FLAG_ITALIC;
+
+    if ( face->ttf_face->style_flags & FT_STYLE_FLAG_BOLD )
+      root->style_flags |= FT_STYLE_FLAG_BOLD;
+
+    if ( face->ttf_face->face_flags & FT_FACE_FLAG_VERTICAL )
+      root->face_flags |= FT_FACE_FLAG_VERTICAL;
+
+    {
+      if ( psnames && psaux )
+      {
+        FT_CharMapRec    charmap;
+        T1_CMap_Classes  cmap_classes = psaux->t1_cmap_classes;
+        FT_CMap_Class    clazz;
+
+
+        charmap.face = root;
+
+        /* first of all, try to synthetize a Unicode charmap */
+        charmap.platform_id = 3;
+        charmap.encoding_id = 1;
+        charmap.encoding    = FT_ENCODING_UNICODE;
+
+        FT_CMap_New( cmap_classes->unicode, NULL, &charmap, NULL );
+
+        /* now, generate an Adobe Standard encoding when appropriate */
+        charmap.platform_id = 7;
+        clazz               = NULL;
+
+        switch ( type1->encoding_type )
+        {
+        case T1_ENCODING_TYPE_STANDARD:
+          charmap.encoding    = FT_ENCODING_ADOBE_STANDARD;
+          charmap.encoding_id = 0;
+          clazz               = cmap_classes->standard;
+          break;
+
+        case T1_ENCODING_TYPE_EXPERT:
+          charmap.encoding    = FT_ENCODING_ADOBE_EXPERT;
+          charmap.encoding_id = 1;
+          clazz               = cmap_classes->expert;
+          break;
+
+        case T1_ENCODING_TYPE_ARRAY:
+          charmap.encoding    = FT_ENCODING_ADOBE_CUSTOM;
+          charmap.encoding_id = 2;
+          clazz               = cmap_classes->custom;
+          break;
+
+        case T1_ENCODING_TYPE_ISOLATIN1:
+          charmap.encoding    = FT_ENCODING_ADOBE_LATIN_1;
+          charmap.encoding_id = 3;
+          clazz               = cmap_classes->unicode;
+          break;
+
+        default:
+          ;
+        }
+
+        if ( clazz )
+          FT_CMap_New( clazz, NULL, &charmap, NULL );
+
+#if 0
+        /* Select default charmap */
+        if ( root->num_charmaps )
+          root->charmap = root->charmaps[0];
+#endif
+      }
+    }
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T42_Face_Done( T42_Face  face )
+  {
+    T1_Font      type1;
+    PS_FontInfo  info;
+    FT_Memory    memory;
+
+
+    if ( face )
+    {
+      type1  = &face->type1;
+      info   = &type1->font_info;
+      memory = face->root.memory;
+
+      /* delete internal ttf face prior to freeing face->ttf_data */
+      if ( face->ttf_face )
+        FT_Done_Face( face->ttf_face );
+
+      /* release font info strings */
+      FT_FREE( info->version );
+      FT_FREE( info->notice );
+      FT_FREE( info->full_name );
+      FT_FREE( info->family_name );
+      FT_FREE( info->weight );
+
+      /* release top dictionary */
+      FT_FREE( type1->charstrings_len );
+      FT_FREE( type1->charstrings );
+      FT_FREE( type1->glyph_names );
+
+      FT_FREE( type1->charstrings_block );
+      FT_FREE( type1->glyph_names_block );
+
+      FT_FREE( type1->encoding.char_index );
+      FT_FREE( type1->encoding.char_name );
+      FT_FREE( type1->font_name );
+
+      FT_FREE( face->ttf_data );
+
+#if 0
+      /* release afm data if present */
+      if ( face->afm_data )
+        T1_Done_AFM( memory, (T1_AFM*)face->afm_data );
+#endif
+
+      /* release unicode map, if any */
+      FT_FREE( face->unicode_map.maps );
+      face->unicode_map.num_maps = 0;
+
+      face->root.family_name = 0;
+      face->root.style_name  = 0;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    T42_Driver_Init                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given Type 42 driver object.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    driver :: A handle to the target driver object.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  T42_Driver_Init( T42_Driver  driver )
+  {
+    FT_Module  ttmodule;
+
+
+    ttmodule = FT_Get_Module( FT_MODULE(driver)->library, "truetype" );
+    driver->ttclazz = (FT_Driver_Class)ttmodule->clazz;
+
+    return T42_Err_Ok;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T42_Driver_Done( T42_Driver  driver )
+  {
+    FT_UNUSED( driver );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_Size_Init( T42_Size  size )
+  {
+    FT_Face   face = size->root.face;
+    T42_Face  t42face = (T42_Face)face;
+    FT_Size   ttsize;
+    FT_Error  error   = T42_Err_Ok;
+
+
+    error = FT_New_Size( t42face->ttf_face, &ttsize );
+    size->ttsize = ttsize;
+
+    FT_Activate_Size( ttsize );
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T42_Size_Done( T42_Size  size )
+  {
+    FT_Face      face    = size->root.face;
+    T42_Face     t42face = (T42_Face)face;
+    FT_ListNode  node;
+
+
+    node = FT_List_Find( &t42face->ttf_face->sizes_list, size->ttsize );
+    if ( node )
+    {
+      FT_Done_Size( size->ttsize );
+      size->ttsize = NULL;
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_GlyphSlot_Init( T42_GlyphSlot  slot )
+  {
+    FT_Face       face    = slot->root.face;
+    T42_Face      t42face = (T42_Face)face;
+    FT_GlyphSlot  ttslot;
+    FT_Error      error   = T42_Err_Ok;
+
+
+    if ( face->glyph == NULL )
+    {
+      /* First glyph slot for this face */
+      slot->ttslot = t42face->ttf_face->glyph;
+    }
+    else
+    {
+      error = FT_New_GlyphSlot( t42face->ttf_face, &ttslot );
+      slot->ttslot = ttslot;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T42_GlyphSlot_Done( T42_GlyphSlot slot )
+  {
+    FT_Face       face    = slot->root.face;
+    T42_Face      t42face = (T42_Face)face;
+    FT_GlyphSlot  cur     = t42face->ttf_face->glyph;
+
+
+    while ( cur )
+    {
+      if ( cur == slot->ttslot )
+      {
+        FT_Done_GlyphSlot( slot->ttslot );
+        break;
+      }
+
+      cur = cur->next;
+    }
+  }
+
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_Size_SetChars( T42_Size    size,
+                     FT_F26Dot6  char_width,
+                     FT_F26Dot6  char_height,
+                     FT_UInt     horz_resolution,
+                     FT_UInt     vert_resolution )
+  {
+    FT_Face   face    = size->root.face;
+    T42_Face  t42face = (T42_Face)face;
+
+
+    FT_Activate_Size( size->ttsize );
+
+    return FT_Set_Char_Size( t42face->ttf_face,
+                             char_width,
+                             char_height,
+                             horz_resolution,
+                             vert_resolution );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_Size_SetPixels( T42_Size  size,
+                      FT_UInt   pixel_width,
+                      FT_UInt   pixel_height )
+  {
+    FT_Face   face    = size->root.face;
+    T42_Face  t42face = (T42_Face)face;
+
+
+    FT_Activate_Size( size->ttsize );
+
+    return FT_Set_Pixel_Sizes( t42face->ttf_face,
+                               pixel_width,
+                               pixel_height );
+  }
+
+
+  static void
+  t42_glyphslot_clear( FT_GlyphSlot  slot )
+  {
+    /* free bitmap if needed */
+    ft_glyphslot_free_bitmap( slot );
+
+    /* clear all public fields in the glyph slot */
+    FT_ZERO( &slot->metrics );
+    FT_ZERO( &slot->outline );
+    FT_ZERO( &slot->bitmap );
+
+    slot->bitmap_left   = 0;
+    slot->bitmap_top    = 0;
+    slot->num_subglyphs = 0;
+    slot->subglyphs     = 0;
+    slot->control_data  = 0;
+    slot->control_len   = 0;
+    slot->other         = 0;
+    slot->format        = FT_GLYPH_FORMAT_NONE;
+
+    slot->linearHoriAdvance = 0;
+    slot->linearVertAdvance = 0;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_GlyphSlot_Load( FT_GlyphSlot  glyph,
+                      FT_Size       size,
+                      FT_UInt       glyph_index,
+                      FT_Int32      load_flags )
+  {
+    FT_Error         error;
+    T42_GlyphSlot    t42slot = (T42_GlyphSlot)glyph;
+    T42_Size         t42size = (T42_Size)size;
+    FT_Driver_Class  ttclazz = ((T42_Driver)glyph->face->driver)->ttclazz;
+
+
+    t42_glyphslot_clear( t42slot->ttslot );
+    error = ttclazz->load_glyph( t42slot->ttslot,
+                                 t42size->ttsize,
+                                 glyph_index,
+                                 load_flags | FT_LOAD_NO_BITMAP );
+
+    if ( !error )
+    {
+      glyph->metrics = t42slot->ttslot->metrics;
+
+      glyph->linearHoriAdvance = t42slot->ttslot->linearHoriAdvance;
+      glyph->linearVertAdvance = t42slot->ttslot->linearVertAdvance;
+
+      glyph->format  = t42slot->ttslot->format;
+      glyph->outline = t42slot->ttslot->outline;
+
+      glyph->bitmap      = t42slot->ttslot->bitmap;
+      glyph->bitmap_left = t42slot->ttslot->bitmap_left;
+      glyph->bitmap_top  = t42slot->ttslot->bitmap_top;
+
+      glyph->num_subglyphs = t42slot->ttslot->num_subglyphs;
+      glyph->subglyphs     = t42slot->ttslot->subglyphs;
+
+      glyph->control_data  = t42slot->ttslot->control_data;
+      glyph->control_len   = t42slot->ttslot->control_len;
+    }
+
+    return error;
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/t42objs.h b/nx-X11/extras/freetype2/src/type42/t42objs.h
new file mode 100644
index 000000000..623809573
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/t42objs.h
@@ -0,0 +1,126 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42objs.h                                                              */
+/*                                                                         */
+/*    Type 42 objects manager (specification).                             */
+/*                                                                         */
+/*  Copyright 2002, 2003 by Roberto Alameda.                               */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42OBJS_H__
+#define __T42OBJS_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TYPE1_TABLES_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include "t42types.h"
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DRIVER_H
+#include FT_SERVICE_POSTSCRIPT_CMAPS_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* Type42 size */
+  typedef struct  T42_SizeRec_
+  {
+    FT_SizeRec  root;
+    FT_Size     ttsize;
+
+  } T42_SizeRec, *T42_Size;
+
+
+  /* Type42 slot */
+  typedef struct  T42_GlyphSlotRec_
+  {
+    FT_GlyphSlotRec  root;
+    FT_GlyphSlot     ttslot;
+
+  } T42_GlyphSlotRec, *T42_GlyphSlot;
+
+
+  /* Type 42 driver */
+  typedef struct  T42_DriverRec_
+  {
+    FT_DriverRec     root;
+    FT_Driver_Class  ttclazz;
+    void*            extension_component;
+
+  } T42_DriverRec, *T42_Driver;
+
+
+  /* */
+
+
+  FT_LOCAL( FT_Error )
+  T42_Face_Init( FT_Stream      stream,
+                 T42_Face       face,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params );
+
+
+  FT_LOCAL( void )
+  T42_Face_Done( T42_Face  face );
+
+
+  FT_LOCAL( FT_Error )
+  T42_Size_Init( T42_Size  size );
+
+
+  FT_LOCAL( FT_Error )
+  T42_Size_SetChars( T42_Size    size,
+                     FT_F26Dot6  char_width,
+                     FT_F26Dot6  char_height,
+                     FT_UInt     horz_resolution,
+                     FT_UInt     vert_resolution );
+
+  FT_LOCAL( FT_Error )
+  T42_Size_SetPixels( T42_Size  size,
+                      FT_UInt   pixel_width,
+                      FT_UInt   pixel_height );
+
+  FT_LOCAL( void )
+  T42_Size_Done( T42_Size  size );
+
+
+  FT_LOCAL( FT_Error )
+  T42_GlyphSlot_Init( T42_GlyphSlot  slot );
+
+
+  FT_LOCAL( FT_Error )
+  T42_GlyphSlot_Load( FT_GlyphSlot  glyph,
+                      FT_Size       size,
+                      FT_UInt       glyph_index,
+                      FT_Int32      load_flags );
+
+  FT_LOCAL( void )
+  T42_GlyphSlot_Done( T42_GlyphSlot slot );
+
+
+  FT_LOCAL( FT_Error )
+  T42_Driver_Init( T42_Driver  driver );
+
+  FT_LOCAL( void )
+  T42_Driver_Done( T42_Driver  driver );
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __T42OBJS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/t42parse.c b/nx-X11/extras/freetype2/src/type42/t42parse.c
new file mode 100644
index 000000000..ff53a3eb4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/t42parse.c
@@ -0,0 +1,1115 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42parse.c                                                             */
+/*                                                                         */
+/*    Type 42 font parser (body).                                          */
+/*                                                                         */
+/*  Copyright 2002, 2003, 2004 by Roberto Alameda.                         */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "t42parse.h"
+#include "t42error.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_LIST_H
+#include FT_INTERNAL_POSTSCRIPT_AUX_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_t42
+
+
+  static void
+  t42_parse_font_matrix( T42_Face    face,
+                         T42_Loader  loader );
+  static void
+  t42_parse_encoding( T42_Face    face,
+                      T42_Loader  loader );
+
+  static void
+  t42_parse_charstrings( T42_Face    face,
+                         T42_Loader  loader );
+
+  static void
+  t42_parse_sfnts( T42_Face    face,
+                   T42_Loader  loader );
+
+
+  static const
+  T1_FieldRec  t42_keywords[] = {
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  T1_FontInfo
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_FONT_INFO
+
+    T1_FIELD_STRING( "version",            version )
+    T1_FIELD_STRING( "Notice",             notice )
+    T1_FIELD_STRING( "FullName",           full_name )
+    T1_FIELD_STRING( "FamilyName",         family_name )
+    T1_FIELD_STRING( "Weight",             weight )
+    T1_FIELD_NUM   ( "ItalicAngle",        italic_angle )
+    T1_FIELD_BOOL  ( "isFixedPitch",       is_fixed_pitch )
+    T1_FIELD_NUM   ( "UnderlinePosition",  underline_position )
+    T1_FIELD_NUM   ( "UnderlineThickness", underline_thickness )
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  T1_FontRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_FONT_DICT
+
+    T1_FIELD_KEY  ( "FontName",    font_name )
+    T1_FIELD_NUM  ( "PaintType",   paint_type )
+    T1_FIELD_NUM  ( "FontType",    font_type )
+    T1_FIELD_FIXED( "StrokeWidth", stroke_width )
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  FT_BBox
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_BBOX
+
+    T1_FIELD_BBOX("FontBBox", xMin )
+
+    T1_FIELD_CALLBACK( "FontMatrix",  t42_parse_font_matrix )
+    T1_FIELD_CALLBACK( "Encoding",    t42_parse_encoding )
+    T1_FIELD_CALLBACK( "CharStrings", t42_parse_charstrings )
+    T1_FIELD_CALLBACK( "sfnts",       t42_parse_sfnts )
+
+    { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0 }
+  };
+
+
+#define T1_Add_Table( p, i, o, l )  (p)->funcs.add( (p), i, o, l )
+#define T1_Done_Table( p )          \
+          do                        \
+          {                         \
+            if ( (p)->funcs.done )  \
+              (p)->funcs.done( p ); \
+          } while ( 0 )
+#define T1_Release_Table( p )          \
+          do                           \
+          {                            \
+            if ( (p)->funcs.release )  \
+              (p)->funcs.release( p ); \
+          } while ( 0 )
+
+#define T1_Skip_Spaces( p )    (p)->root.funcs.skip_spaces( &(p)->root )
+#define T1_Skip_PS_Token( p )  (p)->root.funcs.skip_PS_token( &(p)->root )
+
+#define T1_ToInt( p )                          \
+          (p)->root.funcs.to_int( &(p)->root )
+#define T1_ToBytes( p, b, m, n, d )                          \
+          (p)->root.funcs.to_bytes( &(p)->root, b, m, n, d )
+
+#define T1_ToFixedArray( p, m, f, t )                           \
+          (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
+#define T1_ToToken( p, t )                          \
+          (p)->root.funcs.to_token( &(p)->root, t )
+
+#define T1_Load_Field( p, f, o, m, pf )                         \
+          (p)->root.funcs.load_field( &(p)->root, f, o, m, pf )
+#define T1_Load_Field_Table( p, f, o, m, pf )                         \
+          (p)->root.funcs.load_field_table( &(p)->root, f, o, m, pf )
+
+
+  /********************* Parsing Functions ******************/
+
+  FT_LOCAL_DEF( FT_Error )
+  t42_parser_init( T42_Parser     parser,
+                   FT_Stream      stream,
+                   FT_Memory      memory,
+                   PSAux_Service  psaux )
+  {
+    FT_Error  error = T42_Err_Ok;
+    FT_Long   size;
+
+
+    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );
+
+    parser->stream    = stream;
+    parser->base_len  = 0;
+    parser->base_dict = 0;
+    parser->in_memory = 0;
+
+    /*******************************************************************/
+    /*                                                                 */
+    /* Here a short summary of what is going on:                       */
+    /*                                                                 */
+    /*   When creating a new Type 42 parser, we try to locate and load */
+    /*   the base dictionary, loading the whole font into memory.      */
+    /*                                                                 */
+    /*   When `loading' the base dictionary, we only set up pointers   */
+    /*   in the case of a memory-based stream.  Otherwise, we allocate */
+    /*   and load the base dictionary in it.                           */
+    /*                                                                 */
+    /*   parser->in_memory is set if we have a memory stream.          */
+    /*                                                                 */
+
+    if ( FT_STREAM_SEEK( 0L ) )
+      goto Exit;
+
+    size = stream->size;
+
+    /* now, try to load `size' bytes of the `base' dictionary we */
+    /* found previously                                          */
+
+    /* if it is a memory-based resource, set up pointers */
+    if ( !stream->read )
+    {
+      parser->base_dict = (FT_Byte*)stream->base + stream->pos;
+      parser->base_len  = size;
+      parser->in_memory = 1;
+
+      /* check that the `size' field is valid */
+      if ( FT_STREAM_SKIP( size ) )
+        goto Exit;
+    }
+    else
+    {
+      /* read segment in memory */
+      if ( FT_ALLOC( parser->base_dict, size )       ||
+           FT_STREAM_READ( parser->base_dict, size ) )
+        goto Exit;
+
+      parser->base_len = size;
+    }
+
+    /* Now check font format; we must see `%!PS-TrueTypeFont' */
+    if ( size <= 17                                    ||
+         ( ft_strncmp( (const char*)parser->base_dict,
+                       "%!PS-TrueTypeFont", 17 ) )     )
+      error = T42_Err_Unknown_File_Format;
+    else
+    {
+      parser->root.base   = parser->base_dict;
+      parser->root.cursor = parser->base_dict;
+      parser->root.limit  = parser->root.cursor + parser->base_len;
+    }
+
+  Exit:
+    if ( error && !parser->in_memory )
+      FT_FREE( parser->base_dict );
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  t42_parser_done( T42_Parser  parser )
+  {
+    FT_Memory  memory = parser->root.memory;
+
+
+    /* free the base dictionary only when we have a disk stream */
+    if ( !parser->in_memory )
+      FT_FREE( parser->base_dict );
+
+    parser->root.funcs.done( &parser->root );
+  }
+
+
+  static int
+  t42_is_space( FT_Byte  c )
+  {
+    return ( c == ' '  || c == '\t'              ||
+             c == '\r' || c == '\n' || c == '\f' ||
+             c == '\0'                           );
+  }
+
+
+  static void
+  t42_parse_font_matrix( T42_Face    face,
+                         T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+    FT_Matrix*  matrix = &face->type1.font_matrix;
+    FT_Vector*  offset = &face->type1.font_offset;
+    FT_Face     root   = (FT_Face)&face->root;
+    FT_Fixed    temp[6];
+    FT_Fixed    temp_scale;
+
+
+    (void)T1_ToFixedArray( parser, 6, temp, 3 );
+
+    temp_scale = FT_ABS( temp[3] );
+
+    /* Set Units per EM based on FontMatrix values.  We set the value to */
+    /* 1000 / temp_scale, because temp_scale was already multiplied by   */
+    /* 1000 (in t1_tofixed, from psobjs.c).                              */
+
+    root->units_per_EM = (FT_UShort)( FT_DivFix( 1000 * 0x10000L,
+                                                 temp_scale ) >> 16 );
+
+    /* we need to scale the values by 1.0/temp_scale */
+    if ( temp_scale != 0x10000L ) {
+      temp[0] = FT_DivFix( temp[0], temp_scale );
+      temp[1] = FT_DivFix( temp[1], temp_scale );
+      temp[2] = FT_DivFix( temp[2], temp_scale );
+      temp[4] = FT_DivFix( temp[4], temp_scale );
+      temp[5] = FT_DivFix( temp[5], temp_scale );
+      temp[3] = 0x10000L;
+    }
+
+    matrix->xx = temp[0];
+    matrix->yx = temp[1];
+    matrix->xy = temp[2];
+    matrix->yy = temp[3];
+
+    /* note that the offsets must be expressed in integer font units */
+    offset->x = temp[4] >> 16;
+    offset->y = temp[5] >> 16;
+  }
+
+
+  static void
+  t42_parse_encoding( T42_Face    face,
+                      T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+    FT_Byte*    cur;
+    FT_Byte*    limit  = parser->root.limit;
+
+    PSAux_Service  psaux  = (PSAux_Service)face->psaux;
+
+
+    T1_Skip_Spaces( parser );
+    cur = parser->root.cursor;
+    if ( cur >= limit )
+    {
+      FT_ERROR(( "t42_parse_encoding: out of bounds!\n" ));
+      parser->root.error = T42_Err_Invalid_File_Format;
+      return;
+    }
+
+    /* if we have a number or `[', the encoding is an array, */
+    /* and we must load it now                               */
+    if ( ft_isdigit( *cur ) || *cur == '[' )
+    {
+      T1_Encoding  encode          = &face->type1.encoding;
+      FT_UInt      count, n;
+      PS_Table     char_table      = &loader->encoding_table;
+      FT_Memory    memory          = parser->root.memory;
+      FT_Error     error;
+      FT_Bool      only_immediates = 0;
+
+
+      /* read the number of entries in the encoding; should be 256 */
+      if ( *cur == '[' )
+      {
+        count           = 256;
+        only_immediates = 1;
+        parser->root.cursor++;
+      }
+      else
+        count = (FT_UInt)T1_ToInt( parser );
+
+      T1_Skip_Spaces( parser );
+      if ( parser->root.cursor >= limit )
+        return;
+
+      /* we use a T1_Table to store our charnames */
+      loader->num_chars = encode->num_chars = count;
+      if ( FT_NEW_ARRAY( encode->char_index, count )     ||
+           FT_NEW_ARRAY( encode->char_name,  count )     ||
+           FT_SET_ERROR( psaux->ps_table_funcs->init(
+                           char_table, count, memory ) ) )
+      {
+        parser->root.error = error;
+        return;
+      }
+
+      /* We need to `zero' out encoding_table.elements */
+      for ( n = 0; n < count; n++ )
+      {
+        char*  notdef = (char *)".notdef";
+
+
+        T1_Add_Table( char_table, n, notdef, 8 );
+      }
+
+      /* Now we need to read records of the form                */
+      /*                                                        */
+      /*   ... charcode /charname ...                           */
+      /*                                                        */
+      /* for each entry in our table.                           */
+      /*                                                        */
+      /* We simply look for a number followed by an immediate   */
+      /* name.  Note that this ignores correctly the sequence   */
+      /* that is often seen in type42 fonts:                    */
+      /*                                                        */
+      /*   0 1 255 { 1 index exch /.notdef put } for dup        */
+      /*                                                        */
+      /* used to clean the encoding array before anything else. */
+      /*                                                        */
+      /* Alternatively, if the array is directly given as       */
+      /*                                                        */
+      /*   /Encoding [ ... ]                                    */
+      /*                                                        */
+      /* we only read immediates.                               */
+
+      n = 0;
+      T1_Skip_Spaces( parser );
+
+      while ( parser->root.cursor < limit )
+      {
+        cur = parser->root.cursor;
+
+        /* we stop when we encounter `def' or `]' */
+        if ( *cur == 'd' && cur + 3 < limit )
+        {
+          if ( cur[1] == 'e'          &&
+               cur[2] == 'f'          &&
+               t42_is_space( cur[3] ) )
+          {
+            FT_TRACE6(( "encoding end\n" ));
+            cur += 3;
+            break;
+          }
+        }
+        if ( *cur == ']' )
+        {
+          FT_TRACE6(( "encoding end\n" ));
+          cur++;
+          break;
+        }
+
+        /* check whether we've found an entry */
+        if ( ft_isdigit( *cur ) || only_immediates )
+        {
+          FT_Int  charcode;
+
+
+          if ( only_immediates )
+            charcode = n;
+          else
+          {
+            charcode = (FT_Int)T1_ToInt( parser );
+            T1_Skip_Spaces( parser );
+          }
+
+          cur = parser->root.cursor;
+
+          if ( *cur == '/' && cur + 2 < limit && n < count )
+          {
+            FT_PtrDist  len;
+
+
+            cur++;
+
+            parser->root.cursor = cur;
+            T1_Skip_PS_Token( parser );
+
+            len = parser->root.cursor - cur;
+
+            parser->root.error = T1_Add_Table( char_table, charcode,
+                                               cur, len + 1 );
+            char_table->elements[charcode][len] = '\0';
+            if ( parser->root.error )
+              return;
+
+            n++;
+          }
+        }
+        else
+          T1_Skip_PS_Token( parser );
+
+        T1_Skip_Spaces( parser );
+      }
+
+      face->type1.encoding_type  = T1_ENCODING_TYPE_ARRAY;
+      parser->root.cursor        = cur;
+    }
+
+    /* Otherwise, we should have either `StandardEncoding', */
+    /* `ExpertEncoding', or `ISOLatin1Encoding'             */
+    else
+    {
+      if ( cur + 17 < limit                                            &&
+           ft_strncmp( (const char*)cur, "StandardEncoding", 16 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_STANDARD;
+
+      else if ( cur + 15 < limit                                          &&
+                ft_strncmp( (const char*)cur, "ExpertEncoding", 14 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_EXPERT;
+
+      else if ( cur + 18 < limit                                             &&
+                ft_strncmp( (const char*)cur, "ISOLatin1Encoding", 17 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_ISOLATIN1;
+
+      else
+      {
+        FT_ERROR(( "t42_parse_encoding: invalid token!\n" ));
+        parser->root.error = T42_Err_Invalid_File_Format;
+      }
+    }
+  }
+
+
+  typedef enum
+  {
+    BEFORE_START,
+    BEFORE_TABLE_DIR,
+    OTHER_TABLES
+
+  } T42_Load_Status;
+
+
+  static void
+  t42_parse_sfnts( T42_Face    face,
+                   T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+    FT_Memory   memory = parser->root.memory;
+    FT_Byte*    cur;
+    FT_Byte*    limit  = parser->root.limit;
+    FT_Error    error;
+    FT_Int      num_tables = 0;
+    FT_ULong    count, ttf_size = 0;
+
+    FT_Long     n, string_size, old_string_size, real_size;
+    FT_Byte*    string_buf = NULL;
+    FT_Bool     alloc      = 0;
+
+    T42_Load_Status  status;
+
+
+    /* The format is                                */
+    /*                                              */
+    /*   /sfnts [ <hexstring> <hexstring> ... ] def */
+    /*                                              */
+    /* or                                           */
+    /*                                              */
+    /*   /sfnts [                                   */
+    /*      <num_bin_bytes> RD <binary data>        */
+    /*      <num_bin_bytes> RD <binary data>        */
+    /*      ...                                     */
+    /*   ] def                                      */
+    /*                                              */
+    /* with exactly one space after the `RD' token. */
+
+    T1_Skip_Spaces( parser );
+
+    if ( parser->root.cursor >= limit || *parser->root.cursor++ != '[' )
+    {
+      FT_ERROR(( "t42_parse_sfnts: can't find begin of sfnts vector!\n" ));
+      error = T42_Err_Invalid_File_Format;
+      goto Fail;
+    }
+
+    T1_Skip_Spaces( parser );
+    status          = BEFORE_START;
+    string_size     = 0;
+    old_string_size = 0;
+    count           = 0;
+
+    while ( parser->root.cursor < limit )
+    {
+      cur = parser->root.cursor;
+
+      if ( *cur == ']' )
+      {
+        parser->root.cursor++;
+        goto Exit;
+      }
+
+      else if ( *cur == '<' )
+      {
+        T1_Skip_PS_Token( parser );
+        if ( parser->root.error )
+          goto Exit;
+
+        /* don't include delimiters */
+        string_size = (FT_Long)( ( parser->root.cursor - cur - 2 + 1 ) / 2 );
+        if ( FT_REALLOC( string_buf, old_string_size, string_size ) )
+          goto Fail;
+
+        alloc = 1;
+
+        parser->root.cursor = cur;
+        (void)T1_ToBytes( parser, string_buf, string_size, &real_size, 1 );
+        old_string_size = string_size;
+        string_size = real_size;
+      }
+
+      else if ( ft_isdigit( *cur ) )
+      {
+        string_size = T1_ToInt( parser );
+
+        T1_Skip_PS_Token( parser );             /* `RD' */
+
+        string_buf = parser->root.cursor + 1;   /* one space after `RD' */
+
+        parser->root.cursor += string_size + 1;
+        if ( parser->root.cursor >= limit )
+        {
+          FT_ERROR(( "t42_parse_sfnts: too many binary data!\n" ));
+          error = T42_Err_Invalid_File_Format;
+          goto Fail;
+        }
+      }
+
+      /* A string can have a trailing zero byte for padding.  Ignore it. */
+      if ( string_buf[string_size - 1] == 0 && ( string_size % 2 == 1 ) )
+        string_size--;
+
+      for ( n = 0; n < string_size; n++ )
+      {
+        switch ( status )
+        {
+        case BEFORE_START:
+          /* load offset table, 12 bytes */
+          if ( count < 12 )
+          {
+            face->ttf_data[count++] = string_buf[n];
+            continue;
+          }
+          else
+          {
+            num_tables = 16 * face->ttf_data[4] + face->ttf_data[5];
+            status     = BEFORE_TABLE_DIR;
+            ttf_size   = 12 + 16 * num_tables;
+
+            if ( FT_REALLOC( face->ttf_data, 12, ttf_size ) )
+              goto Fail;
+          }
+          /* fall through */
+
+        case BEFORE_TABLE_DIR:
+          /* the offset table is read; read the table directory */
+          if ( count < ttf_size )
+          {
+            face->ttf_data[count++] = string_buf[n];
+            continue;
+          }
+          else
+          {
+            int       i;
+            FT_ULong  len;
+
+
+            for ( i = 0; i < num_tables; i++ )
+            {
+              FT_Byte*  p = face->ttf_data + 12 + 16 * i + 12;
+
+
+              len = FT_PEEK_ULONG( p );
+
+              /* Pad to a 4-byte boundary length */
+              ttf_size += ( len + 3 ) & ~3;
+            }
+
+            status         = OTHER_TABLES;
+            face->ttf_size = ttf_size;
+
+            if ( FT_REALLOC( face->ttf_data, 12 + 16 * num_tables,
+                             ttf_size + 1 ) )
+              goto Fail;
+          }
+          /* fall through */
+
+        case OTHER_TABLES:
+          /* all other tables are just copied */
+          if ( count >= ttf_size )
+          {
+            FT_ERROR(( "t42_parse_sfnts: too many binary data!\n" ));
+            error = T42_Err_Invalid_File_Format;
+            goto Fail;
+          }
+          face->ttf_data[count++] = string_buf[n];
+        }
+      }
+
+      T1_Skip_Spaces( parser );
+    }
+
+    /* if control reaches this point, the format was not valid */
+    error = T42_Err_Invalid_File_Format;
+
+  Fail:
+    parser->root.error = error;
+
+  Exit:
+    if ( alloc )
+      FT_FREE( string_buf );
+  }
+
+
+  static void
+  t42_parse_charstrings( T42_Face    face,
+                         T42_Loader  loader )
+  {
+    T42_Parser     parser       = &loader->parser;
+    PS_Table       code_table   = &loader->charstrings;
+    PS_Table       name_table   = &loader->glyph_names;
+    PS_Table       swap_table   = &loader->swap_table;
+    FT_Memory      memory       = parser->root.memory;
+    FT_Error       error;
+
+    PSAux_Service  psaux        = (PSAux_Service)face->psaux;
+
+    FT_Byte*       cur;
+    FT_Byte*       limit        = parser->root.limit;
+    FT_UInt        n;
+    FT_UInt        notdef_index = 0;
+    FT_Byte        notdef_found = 0;
+
+
+    T1_Skip_Spaces( parser );
+
+    if ( parser->root.cursor >= limit )
+    {
+      FT_ERROR(( "t42_parse_charstrings: out of bounds!\n" ));
+      error = T42_Err_Invalid_File_Format;
+      goto Fail;
+    }
+
+    if ( ft_isdigit( *parser->root.cursor ) )
+    {
+      loader->num_glyphs = (FT_UInt)T1_ToInt( parser );
+      if ( parser->root.error )
+        return;
+    }
+    else if ( *parser->root.cursor == '<' )
+    {
+      /* We have `<< ... >>'.  Count the number of `/' in the dictionary */
+      /* to get its size.                                                */
+      FT_UInt  count = 0;
+
+
+      T1_Skip_PS_Token( parser );
+      T1_Skip_Spaces( parser );
+      cur = parser->root.cursor;
+
+      while ( parser->root.cursor < limit )
+      {
+        if ( *parser->root.cursor == '/' )
+          count++;
+        else if ( *parser->root.cursor == '>' )
+        {
+          loader->num_glyphs  = count;
+          parser->root.cursor = cur;        /* rewind */
+          break;
+        }
+        T1_Skip_PS_Token( parser );
+        T1_Skip_Spaces( parser );
+      }
+    }
+    else
+    {
+      FT_ERROR(( "t42_parse_charstrings: invalid token!\n" ));
+      error = T42_Err_Invalid_File_Format;
+      goto Fail;
+    }
+
+    if ( parser->root.cursor >= limit )
+    {
+      FT_ERROR(( "t42_parse_charstrings: out of bounds!\n" ));
+      error = T42_Err_Invalid_File_Format;
+      goto Fail;
+    }
+
+    /* initialize tables */
+
+    error = psaux->ps_table_funcs->init( code_table,
+                                         loader->num_glyphs,
+                                         memory );
+    if ( error )
+      goto Fail;
+
+    error = psaux->ps_table_funcs->init( name_table,
+                                         loader->num_glyphs,
+                                         memory );
+    if ( error )
+      goto Fail;
+
+    /* Initialize table for swapping index notdef_index and */
+    /* index 0 names and codes (if necessary).              */
+
+    error = psaux->ps_table_funcs->init( swap_table, 4, memory );
+    if ( error )
+      goto Fail;
+
+    n = 0;
+
+    for (;;)
+    {
+      /* The format is simple:                   */
+      /*   `/glyphname' + index [+ def]          */
+
+      T1_Skip_Spaces( parser );
+
+      cur = parser->root.cursor;
+      if ( cur >= limit )
+        break;
+
+      /* We stop when we find an `end' keyword or '>' */
+      if ( *cur   == 'e'          &&
+           cur + 3 < limit        &&
+           cur[1] == 'n'          &&
+           cur[2] == 'd'          &&
+           t42_is_space( cur[3] ) )
+        break;
+      if ( *cur == '>' )
+        break;
+
+      T1_Skip_PS_Token( parser );
+
+      if ( *cur == '/' )
+      {
+        FT_PtrDist  len;
+
+
+        if ( cur + 1 >= limit )
+        {
+          FT_ERROR(( "t42_parse_charstrings: out of bounds!\n" ));
+          error = T42_Err_Invalid_File_Format;
+          goto Fail;
+        }
+
+        cur++;                              /* skip `/' */
+        len = parser->root.cursor - cur;
+
+        error = T1_Add_Table( name_table, n, cur, len + 1 );
+        if ( error )
+          goto Fail;
+
+        /* add a trailing zero to the name table */
+        name_table->elements[n][len] = '\0';
+
+        /* record index of /.notdef */
+        if ( *cur == '.'                                              &&
+             ft_strcmp( ".notdef",
+                        (const char*)(name_table->elements[n]) ) == 0 )
+        {
+          notdef_index = n;
+          notdef_found = 1;
+        }
+
+        T1_Skip_Spaces( parser );
+
+        cur = parser->root.cursor;
+
+        (void)T1_ToInt( parser );
+        if ( parser->root.cursor >= limit )
+        {
+          FT_ERROR(( "t42_parse_charstrings: out of bounds!\n" ));
+          error = T42_Err_Invalid_File_Format;
+          goto Fail;
+        }
+
+        len = parser->root.cursor - cur;
+
+        error = T1_Add_Table( code_table, n, cur, len + 1 );
+        if ( error )
+          goto Fail;
+
+        code_table->elements[n][len] = '\0';
+
+        n++;
+        if ( n >= loader->num_glyphs )
+          break;
+      }
+    }
+
+    loader->num_glyphs = n;
+
+    if ( !notdef_found )
+    {
+      FT_ERROR(( "t42_parse_charstrings: no /.notdef glyph!\n" ));
+      error = T42_Err_Invalid_File_Format;
+      goto Fail;
+    }
+
+    /* if /.notdef does not occupy index 0, do our magic. */
+    if ( ft_strcmp( (const char*)".notdef",
+                    (const char*)name_table->elements[0] ) )
+    {
+      /* Swap glyph in index 0 with /.notdef glyph.  First, add index 0  */
+      /* name and code entries to swap_table.  Then place notdef_index   */
+      /* name and code entries into swap_table.  Then swap name and code */
+      /* entries at indices notdef_index and 0 using values stored in    */
+      /* swap_table.                                                     */
+
+      /* Index 0 name */
+      error = T1_Add_Table( swap_table, 0,
+                            name_table->elements[0],
+                            name_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      /* Index 0 code */
+      error = T1_Add_Table( swap_table, 1,
+                            code_table->elements[0],
+                            code_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      /* Index notdef_index name */
+      error = T1_Add_Table( swap_table, 2,
+                            name_table->elements[notdef_index],
+                            name_table->lengths [notdef_index] );
+      if ( error )
+        goto Fail;
+
+      /* Index notdef_index code */
+      error = T1_Add_Table( swap_table, 3,
+                            code_table->elements[notdef_index],
+                            code_table->lengths [notdef_index] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( name_table, notdef_index,
+                            swap_table->elements[0],
+                            swap_table->lengths [0] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( code_table, notdef_index,
+                            swap_table->elements[1],
+                            swap_table->lengths [1] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( name_table, 0,
+                            swap_table->elements[2],
+                            swap_table->lengths [2] );
+      if ( error )
+        goto Fail;
+
+      error = T1_Add_Table( code_table, 0,
+                            swap_table->elements[3],
+                            swap_table->lengths [3] );
+      if ( error )
+        goto Fail;
+
+    }
+
+    return;
+
+  Fail:
+    parser->root.error = error;
+  }
+
+
+  static FT_Error
+  t42_load_keyword( T42_Face    face,
+                    T42_Loader  loader,
+                    T1_Field    field )
+  {
+    FT_Error  error;
+    void*     dummy_object;
+    void**    objects;
+    FT_UInt   max_objects = 0;
+
+
+    /* if the keyword has a dedicated callback, call it */
+    if ( field->type == T1_FIELD_TYPE_CALLBACK )
+    {
+      field->reader( (FT_Face)face, loader );
+      error = loader->parser.root.error;
+      goto Exit;
+    }
+
+    /* now the keyword is either a simple field or a table of fields; */
+    /* we are now going to take care of it                            */
+
+    switch ( field->location )
+    {
+    case T1_FIELD_LOCATION_FONT_INFO:
+      dummy_object = &face->type1.font_info;
+      break;
+
+    case T1_FIELD_LOCATION_BBOX:
+      dummy_object = &face->type1.font_bbox;
+      break;
+
+    default:
+      dummy_object = &face->type1;
+    }
+
+    objects = &dummy_object;
+
+    if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
+         field->type == T1_FIELD_TYPE_FIXED_ARRAY   )
+      error = T1_Load_Field_Table( &loader->parser, field,
+                                   objects, max_objects, 0 );
+    else
+      error = T1_Load_Field( &loader->parser, field,
+                             objects, max_objects, 0 );
+
+   Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  t42_parse_dict( T42_Face    face,
+                  T42_Loader  loader,
+                  FT_Byte*    base,
+                  FT_Long     size )
+  {
+    T42_Parser  parser     = &loader->parser;
+    FT_Byte*    limit;
+    FT_Int      n_keywords = (FT_Int)( sizeof ( t42_keywords ) /
+                                         sizeof ( t42_keywords[0] ) );
+
+
+    parser->root.cursor = base;
+    parser->root.limit  = base + size;
+    parser->root.error  = T42_Err_Ok;
+
+    limit = parser->root.limit;
+
+    T1_Skip_Spaces( parser );
+
+    while ( parser->root.cursor < limit )
+    {
+      FT_Byte*  cur;
+
+
+      cur = parser->root.cursor;
+
+      /* look for `FontDirectory' which causes problems for some fonts */
+      if ( *cur == 'F' && cur + 25 < limit                    &&
+           ft_strncmp( (char*)cur, "FontDirectory", 13 ) == 0 )
+      {
+        FT_Byte*  cur2;
+
+
+        /* skip the `FontDirectory' keyword */
+        T1_Skip_PS_Token( parser );
+        T1_Skip_Spaces  ( parser );
+        cur = cur2 = parser->root.cursor;
+
+        /* look up the `known' keyword */
+        while ( cur < limit )
+        {
+          if ( *cur == 'k' && cur + 5 < limit             &&
+                ft_strncmp( (char*)cur, "known", 5 ) == 0 )
+            break;
+
+          T1_Skip_PS_Token( parser );
+          T1_Skip_Spaces  ( parser );
+          cur = parser->root.cursor;
+        }
+
+        if ( cur < limit )
+        {
+          T1_TokenRec  token;
+
+
+          /* skip the `known' keyword and the token following it */
+          T1_Skip_PS_Token( parser );
+          T1_ToToken( parser, &token );
+
+          /* if the last token was an array, skip it! */
+          if ( token.type == T1_TOKEN_TYPE_ARRAY )
+            cur2 = parser->root.cursor;
+        }
+        parser->root.cursor = cur2;
+      }
+
+      /* look for immediates */
+      else if ( *cur == '/' && cur + 2 < limit )
+      {
+        FT_PtrDist  len;
+
+
+        cur++;
+
+        parser->root.cursor = cur;
+        T1_Skip_PS_Token( parser );
+
+        len = parser->root.cursor - cur;
+
+        if ( len > 0 && len < 22 && parser->root.cursor < limit )
+        {
+          int  i;
+
+
+          /* now compare the immediate name to the keyword table */
+
+          /* loop through all known keywords */
+          for ( i = 0; i < n_keywords; i++ )
+          {
+            T1_Field  keyword = (T1_Field)&t42_keywords[i];
+            FT_Byte   *name   = (FT_Byte*)keyword->ident;
+
+
+            if ( !name )
+              continue;
+
+            if ( cur[0] == name[0]                      && 
+                 len == ft_strlen( (const char *)name ) &&
+                 ft_memcmp( cur, name, len ) == 0       )
+            {
+              /* we found it -- run the parsing callback! */
+              parser->root.error = t42_load_keyword( face,
+                                                     loader,
+                                                     keyword );
+              if ( parser->root.error )
+                return parser->root.error;
+              break;
+            }
+          }
+        }
+      }
+      else
+        T1_Skip_PS_Token( parser );
+
+      T1_Skip_Spaces( parser );
+    }
+
+    return parser->root.error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  t42_loader_init( T42_Loader  loader,
+                   T42_Face    face )
+  {
+    FT_UNUSED( face );
+
+    FT_MEM_ZERO( loader, sizeof ( *loader ) );
+    loader->num_glyphs = 0;
+    loader->num_chars  = 0;
+
+    /* initialize the tables -- simply set their `init' field to 0 */
+    loader->encoding_table.init = 0;
+    loader->charstrings.init    = 0;
+    loader->glyph_names.init    = 0;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  t42_loader_done( T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+
+
+    /* finalize tables */
+    T1_Release_Table( &loader->encoding_table );
+    T1_Release_Table( &loader->charstrings );
+    T1_Release_Table( &loader->glyph_names );
+    T1_Release_Table( &loader->swap_table );
+
+    /* finalize parser */
+    t42_parser_done( parser );
+  }
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/t42parse.h b/nx-X11/extras/freetype2/src/type42/t42parse.h
new file mode 100644
index 000000000..f77ec4af4
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/t42parse.h
@@ -0,0 +1,90 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42parse.h                                                             */
+/*                                                                         */
+/*    Type 42 font parser (specification).                                 */
+/*                                                                         */
+/*  Copyright 2002, 2003 by Roberto Alameda.                               */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42PARSE_H__
+#define __T42PARSE_H__
+
+
+#include "t42objs.h"
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+
+
+FT_BEGIN_HEADER
+
+  typedef struct  T42_ParserRec_
+  {
+    PS_ParserRec  root;
+    FT_Stream     stream;
+
+    FT_Byte*      base_dict;
+    FT_Long       base_len;
+
+    FT_Bool       in_memory;
+
+  } T42_ParserRec, *T42_Parser;
+
+
+  typedef struct  T42_Loader_
+  {
+    T42_ParserRec  parser;          /* parser used to read the stream */
+
+    FT_UInt        num_chars;       /* number of characters in encoding */
+    PS_TableRec    encoding_table;  /* PS_Table used to store the       */
+                                    /* encoding character names         */
+
+    FT_UInt        num_glyphs;
+    PS_TableRec    glyph_names;
+    PS_TableRec    charstrings;
+    PS_TableRec    swap_table;      /* For moving .notdef glyph to index 0. */
+
+  } T42_LoaderRec, *T42_Loader;
+
+
+  FT_LOCAL( FT_Error )
+  t42_parser_init( T42_Parser     parser,
+                   FT_Stream      stream,
+                   FT_Memory      memory,
+                   PSAux_Service  psaux );
+
+  FT_LOCAL( void )
+  t42_parser_done( T42_Parser  parser );
+
+
+  FT_LOCAL( FT_Error )
+  t42_parse_dict( T42_Face    face,
+                  T42_Loader  loader,
+                  FT_Byte*    base,
+                  FT_Long     size );
+
+
+  FT_LOCAL( void )
+  t42_loader_init( T42_Loader  loader,
+                   T42_Face    face );
+
+  FT_LOCAL( void )
+  t42_loader_done( T42_Loader  loader );
+
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __T42PARSE_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/t42types.h b/nx-X11/extras/freetype2/src/type42/t42types.h
new file mode 100644
index 000000000..d44ac4e67
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/t42types.h
@@ -0,0 +1,54 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42types.h                                                             */
+/*                                                                         */
+/*    Type 42 font data types (specification only).                        */
+/*                                                                         */
+/*  Copyright 2002, 2003 by Roberto Alameda.                               */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42TYPES_H__
+#define __T42TYPES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TYPE1_TABLES_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  T42_FaceRec_
+  {
+    FT_FaceRec     root;
+    T1_FontRec     type1;
+    const void*    psnames;
+    const void*    psaux;
+    const void*    afm_data;
+    FT_Byte*       ttf_data;
+    FT_ULong       ttf_size;
+    FT_Face        ttf_face;
+    FT_CharMapRec  charmaprecs[2];
+    FT_CharMap     charmaps[2];
+    PS_Unicodes    unicode_map;
+
+  } T42_FaceRec, *T42_Face;
+
+
+FT_END_HEADER
+
+#endif /* __T1TYPES_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/type42/type42.c b/nx-X11/extras/freetype2/src/type42/type42.c
new file mode 100644
index 000000000..d13df56b1
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/type42/type42.c
@@ -0,0 +1,25 @@
+/***************************************************************************/
+/*                                                                         */
+/*  type42.c                                                               */
+/*                                                                         */
+/*    FreeType Type 42 driver component.                                   */
+/*                                                                         */
+/*  Copyright 2002 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 "t42objs.c"
+#include "t42parse.c"
+#include "t42drivr.c"
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/winfonts/Jamfile b/nx-X11/extras/freetype2/src/winfonts/Jamfile
new file mode 100644
index 000000000..a903f8938
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/winfonts/Jamfile
@@ -0,0 +1,8 @@
+# FreeType 2 src/winfonts Jamfile (c) 2001 David Turner
+#
+
+SubDir  FT2_TOP $(FT2_SRC_DIR) winfonts ;
+
+Library  $(FT2_LIB) : winfnt.c ;
+
+# end of src/winfonts Jamfile
diff --git a/nx-X11/extras/freetype2/src/winfonts/descrip.mms b/nx-X11/extras/freetype2/src/winfonts/descrip.mms
new file mode 100644
index 000000000..475cdbb6b
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/winfonts/descrip.mms
@@ -0,0 +1,23 @@
+#
+# FreeType 2 Windows FNT/FON driver compilation rules for VMS
+#
+
+
+# Copyright 2001, 2002 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.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.winfonts])
+
+OBJS=winfnt.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/winfonts/fnterrs.h b/nx-X11/extras/freetype2/src/winfonts/fnterrs.h
new file mode 100644
index 000000000..ea8090971
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/winfonts/fnterrs.h
@@ -0,0 +1,41 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fnterrs.h                                                              */
+/*                                                                         */
+/*    Win FNT/FON error codes (specification only).                        */
+/*                                                                         */
+/*  Copyright 2001 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 Windows FNT/FON error enumeration     */
+  /* constants.                                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __FNTERRS_H__
+#define __FNTERRS_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  FNT_Err_
+#define FT_ERR_BASE    FT_Mod_Err_Winfonts
+
+#include FT_ERRORS_H
+
+#endif /* __FNTERRS_H__ */
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/winfonts/module.mk b/nx-X11/extras/freetype2/src/winfonts/module.mk
new file mode 100644
index 000000000..99be845c1
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/winfonts/module.mk
@@ -0,0 +1,21 @@
+#
+# FreeType 2 Windows FNT/FON module definition
+#
+
+
+# Copyright 1996-2000 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_windows_driver
+
+add_windows_driver:
+	$(OPEN_DRIVER)winfnt_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)winfnt    $(ECHO_DRIVER_DESC)Windows bitmap fonts with extension *.fnt or *.fon$(ECHO_DRIVER_DONE)
+
diff --git a/nx-X11/extras/freetype2/src/winfonts/rules.mk b/nx-X11/extras/freetype2/src/winfonts/rules.mk
new file mode 100644
index 000000000..71a7df2d8
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/winfonts/rules.mk
@@ -0,0 +1,65 @@
+#
+# FreeType 2 Windows FNT/FON driver configuration rules
+#
+
+
+# Copyright 1996-2000, 2001, 2003 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.
+
+
+# Windows driver directory
+#
+FNT_DIR := $(SRC_DIR)/winfonts
+
+
+FNT_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(FNT_DIR))
+
+
+# Windows driver sources (i.e., C files)
+#
+FNT_DRV_SRC := $(FNT_DIR)/winfnt.c
+
+# Windows driver headers
+#
+FNT_DRV_H := $(FNT_DRV_SRC:%.c=%.h) \
+             $(FNT_DIR)/fnterrs.h
+
+
+# Windows driver object(s)
+#
+#   FNT_DRV_OBJ_M is used during `multi' builds
+#   FNT_DRV_OBJ_S is used during `single' builds
+#
+FNT_DRV_OBJ_M := $(FNT_DRV_SRC:$(FNT_DIR)/%.c=$(OBJ_DIR)/%.$O)
+FNT_DRV_OBJ_S := $(OBJ_DIR)/winfnt.$O
+
+# Windows driver source file for single build
+#
+FNT_DRV_SRC_S := $(FNT_DIR)/winfnt.c
+
+
+# Windows driver - single object
+#
+$(FNT_DRV_OBJ_S): $(FNT_DRV_SRC_S) $(FNT_DRV_SRC) $(FREETYPE_H) $(FNT_DRV_H)
+	$(FNT_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(FNT_DRV_SRC_S))
+
+
+# Windows driver - multiple objects
+#
+$(OBJ_DIR)/%.$O: $(FNT_DIR)/%.c $(FREETYPE_H) $(FNT_DRV_H)
+	$(FNT_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(FNT_DRV_OBJ_S)
+DRV_OBJS_M += $(FNT_DRV_OBJ_M)
+
+
+# EOF
diff --git a/nx-X11/extras/freetype2/src/winfonts/winfnt.c b/nx-X11/extras/freetype2/src/winfonts/winfnt.c
new file mode 100644
index 000000000..92174aedb
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/winfonts/winfnt.c
@@ -0,0 +1,754 @@
+/***************************************************************************/
+/*                                                                         */
+/*  winfnt.c                                                               */
+/*                                                                         */
+/*    FreeType font driver for Windows FNT/FON files                       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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_WINFONTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+
+#include "winfnt.h"
+#include "fnterrs.h"
+#include FT_SERVICE_WINFNT_H
+#include FT_SERVICE_XFREE86_NAME_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_winfnt
+
+
+  static const FT_Frame_Field  winmz_header_fields[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  WinMZ_HeaderRec
+
+    FT_FRAME_START( 64 ),
+      FT_FRAME_USHORT_LE ( magic ),
+      FT_FRAME_SKIP_BYTES( 29 * 2 ),
+      FT_FRAME_ULONG_LE  ( lfanew ),
+    FT_FRAME_END
+  };
+
+  static const FT_Frame_Field  winne_header_fields[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  WinNE_HeaderRec
+
+    FT_FRAME_START( 40 ),
+      FT_FRAME_USHORT_LE ( magic ),
+      FT_FRAME_SKIP_BYTES( 34 ),
+      FT_FRAME_USHORT_LE ( resource_tab_offset ),
+      FT_FRAME_USHORT_LE ( rname_tab_offset ),
+    FT_FRAME_END
+  };
+
+  static const FT_Frame_Field  winfnt_header_fields[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  FT_WinFNT_HeaderRec
+
+    FT_FRAME_START( 148 ),
+      FT_FRAME_USHORT_LE( version ),
+      FT_FRAME_ULONG_LE ( file_size ),
+      FT_FRAME_BYTES    ( copyright, 60 ),
+      FT_FRAME_USHORT_LE( file_type ),
+      FT_FRAME_USHORT_LE( nominal_point_size ),
+      FT_FRAME_USHORT_LE( vertical_resolution ),
+      FT_FRAME_USHORT_LE( horizontal_resolution ),
+      FT_FRAME_USHORT_LE( ascent ),
+      FT_FRAME_USHORT_LE( internal_leading ),
+      FT_FRAME_USHORT_LE( external_leading ),
+      FT_FRAME_BYTE     ( italic ),
+      FT_FRAME_BYTE     ( underline ),
+      FT_FRAME_BYTE     ( strike_out ),
+      FT_FRAME_USHORT_LE( weight ),
+      FT_FRAME_BYTE     ( charset ),
+      FT_FRAME_USHORT_LE( pixel_width ),
+      FT_FRAME_USHORT_LE( pixel_height ),
+      FT_FRAME_BYTE     ( pitch_and_family ),
+      FT_FRAME_USHORT_LE( avg_width ),
+      FT_FRAME_USHORT_LE( max_width ),
+      FT_FRAME_BYTE     ( first_char ),
+      FT_FRAME_BYTE     ( last_char ),
+      FT_FRAME_BYTE     ( default_char ),
+      FT_FRAME_BYTE     ( break_char ),
+      FT_FRAME_USHORT_LE( bytes_per_row ),
+      FT_FRAME_ULONG_LE ( device_offset ),
+      FT_FRAME_ULONG_LE ( face_name_offset ),
+      FT_FRAME_ULONG_LE ( bits_pointer ),
+      FT_FRAME_ULONG_LE ( bits_offset ),
+      FT_FRAME_BYTE     ( reserved ),
+      FT_FRAME_ULONG_LE ( flags ),
+      FT_FRAME_USHORT_LE( A_space ),
+      FT_FRAME_USHORT_LE( B_space ),
+      FT_FRAME_USHORT_LE( C_space ),
+      FT_FRAME_ULONG_LE ( color_table_offset ),
+      FT_FRAME_BYTES    ( reserved1, 16 ),
+    FT_FRAME_END
+  };
+
+
+  static void
+  fnt_font_done( FNT_Face face )
+  {
+    FT_Memory  memory = FT_FACE( face )->memory;
+    FT_Stream  stream = FT_FACE( face )->stream;
+    FNT_Font   font   = face->font;
+
+
+    if ( !font )
+      return;
+
+    if ( font->fnt_frame )
+      FT_FRAME_RELEASE( font->fnt_frame );
+    FT_FREE( font->family_name );
+
+    FT_FREE( font );
+    face->font = 0;
+  }
+
+
+  static FT_Error
+  fnt_font_load( FNT_Font   font,
+                 FT_Stream  stream )
+  {
+    FT_Error          error;
+    FT_WinFNT_Header  header = &font->header;
+    FT_Bool           new_format;
+    FT_UInt           size;
+
+
+    /* first of all, read the FNT header */
+    if ( FT_STREAM_SEEK( font->offset )                        ||
+         FT_STREAM_READ_FIELDS( winfnt_header_fields, header ) )
+      goto Exit;
+
+    /* check header */
+    if ( header->version != 0x200 &&
+         header->version != 0x300 )
+    {
+      FT_TRACE2(( "[not a valid FNT file]\n" ));
+      error = FNT_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    new_format = FT_BOOL( font->header.version == 0x300 );
+    size       = new_format ? 148 : 118;
+
+    if ( header->file_size < size )
+    {
+      FT_TRACE2(( "[not a valid FNT file]\n" ));
+      error = FNT_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* Version 2 doesn't have these fields */
+    if ( header->version == 0x200 )
+    {
+      header->flags   = 0;
+      header->A_space = 0;
+      header->B_space = 0;
+      header->C_space = 0;
+
+      header->color_table_offset = 0;
+    }
+
+    if ( header->file_type & 1 )
+    {
+      FT_TRACE2(( "[can't handle vector FNT fonts]\n" ));
+      error = FNT_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* this is a FNT file/table; extract its frame */
+    if ( FT_STREAM_SEEK( font->offset )                         ||
+         FT_FRAME_EXTRACT( header->file_size, font->fnt_frame ) )
+      goto Exit;
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  fnt_face_get_dll_font( FNT_Face  face,
+                         FT_Int    face_index )
+  {
+    FT_Error         error;
+    FT_Stream        stream = FT_FACE( face )->stream;
+    FT_Memory        memory = FT_FACE( face )->memory;
+    WinMZ_HeaderRec  mz_header;
+
+
+    face->font = 0;
+
+    /* does it begin with an MZ header? */
+    if ( FT_STREAM_SEEK( 0 )                                      ||
+         FT_STREAM_READ_FIELDS( winmz_header_fields, &mz_header ) )
+      goto Exit;
+
+    error = FNT_Err_Unknown_File_Format;
+    if ( mz_header.magic == WINFNT_MZ_MAGIC )
+    {
+      /* yes, now look for an NE header in the file */
+      WinNE_HeaderRec  ne_header;
+
+
+      if ( FT_STREAM_SEEK( mz_header.lfanew )                       ||
+           FT_STREAM_READ_FIELDS( winne_header_fields, &ne_header ) )
+        goto Exit;
+
+      error = FNT_Err_Unknown_File_Format;
+      if ( ne_header.magic == WINFNT_NE_MAGIC )
+      {
+        /* good, now look into the resource table for each FNT resource */
+        FT_ULong   res_offset  = mz_header.lfanew +
+                                   ne_header.resource_tab_offset;
+        FT_UShort  size_shift;
+        FT_UShort  font_count  = 0;
+        FT_ULong   font_offset = 0;
+
+
+        if ( FT_STREAM_SEEK( res_offset )                    ||
+             FT_FRAME_ENTER( ne_header.rname_tab_offset -
+                             ne_header.resource_tab_offset ) )
+          goto Exit;
+
+        size_shift = FT_GET_USHORT_LE();
+
+        for (;;)
+        {
+          FT_UShort  type_id, count;
+
+
+          type_id = FT_GET_USHORT_LE();
+          if ( !type_id )
+            break;
+
+          count = FT_GET_USHORT_LE();
+
+          if ( type_id == 0x8008U )
+          {
+            font_count  = count;
+            font_offset = (FT_ULong)( FT_STREAM_POS() + 4 +
+                                      ( stream->cursor - stream->limit ) );
+            break;
+          }
+
+          stream->cursor += 4 + count * 12;
+        }
+
+        FT_FRAME_EXIT();
+
+        if ( !font_count || !font_offset )
+        {
+          FT_TRACE2(( "this file doesn't contain any FNT resources!\n" ));
+          error = FNT_Err_Unknown_File_Format;
+          goto Exit;
+        }
+
+        face->root.num_faces = font_count;
+
+        if ( face_index >= font_count )
+        {
+          error = FNT_Err_Bad_Argument;
+          goto Exit;
+        }
+
+        if ( FT_NEW( face->font ) )
+          goto Exit;
+
+        if ( FT_STREAM_SEEK( font_offset + face_index * 12 ) ||
+             FT_FRAME_ENTER( 12 )                            )
+          goto Fail;
+
+        face->font->offset     = (FT_ULong)FT_GET_USHORT_LE() << size_shift;
+        face->font->fnt_size   = (FT_ULong)FT_GET_USHORT_LE() << size_shift;
+        face->font->size_shift = size_shift;
+
+        stream->cursor += 8;
+
+        FT_FRAME_EXIT();
+
+        error = fnt_font_load( face->font, stream );
+      }
+    }
+
+  Fail:
+    if ( error )
+      fnt_font_done( face );
+
+  Exit:
+    return error;
+  }
+
+
+  typedef struct  FNT_CMapRec_
+  {
+    FT_CMapRec  cmap;
+    FT_UInt32   first;
+    FT_UInt32   count;
+
+  } FNT_CMapRec, *FNT_CMap;
+
+
+  static FT_Error
+  fnt_cmap_init( FNT_CMap  cmap )
+  {
+    FNT_Face  face = (FNT_Face)FT_CMAP_FACE( cmap );
+    FNT_Font  font = face->font;
+
+
+    cmap->first = (FT_UInt32)  font->header.first_char;
+    cmap->count = (FT_UInt32)( font->header.last_char - cmap->first + 1 );
+
+    return 0;
+  }
+
+
+  static FT_UInt
+  fnt_cmap_char_index( FNT_CMap   cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_UInt  gindex = 0;
+
+
+    char_code -= cmap->first;
+    if ( char_code < cmap->count )
+      gindex = char_code + 1; /* we artificially increase the glyph index; */
+                              /* FNT_Load_Glyph reverts to the right one   */
+    return gindex;
+  }
+
+
+  static FT_UInt
+  fnt_cmap_char_next( FNT_CMap    cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_UInt    gindex = 0;
+    FT_UInt32  result = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+    if ( char_code <= cmap->first )
+    {
+      result = cmap->first;
+      gindex = 1;
+    }
+    else
+    {
+      char_code -= cmap->first;
+      if ( char_code < cmap->count )
+      {
+        result = cmap->first + char_code;
+        gindex = char_code + 1;
+      }
+    }
+
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  static const FT_CMap_ClassRec  fnt_cmap_class_rec =
+  {
+    sizeof ( FNT_CMapRec ),
+
+    (FT_CMap_InitFunc)     fnt_cmap_init,
+    (FT_CMap_DoneFunc)     NULL,
+    (FT_CMap_CharIndexFunc)fnt_cmap_char_index,
+    (FT_CMap_CharNextFunc) fnt_cmap_char_next
+  };
+
+  static FT_CMap_Class const  fnt_cmap_class = &fnt_cmap_class_rec;
+
+
+  static void
+  FNT_Face_Done( FNT_Face  face )
+  {
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+
+    fnt_font_done( face );
+
+    FT_FREE( face->root.available_sizes );
+    face->root.num_fixed_sizes = 0;
+  }
+
+
+  static FT_Error
+  FNT_Face_Init( FT_Stream      stream,
+                 FNT_Face       face,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    FT_Error   error;
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+
+
+    /* try to load font from a DLL */
+    error = fnt_face_get_dll_font( face, face_index );
+    if ( error )
+    {
+      /* this didn't work; try to load a single FNT font */
+      FNT_Font  font;
+
+
+      if ( FT_NEW( face->font ) )
+        goto Exit;
+
+      face->root.num_faces = 1;
+
+      font           = face->font;
+      font->offset   = 0;
+      font->fnt_size = stream->size;
+
+      error = fnt_font_load( font, stream );
+      if ( error )
+        goto Fail;
+    }
+
+    /* we now need to fill the root FT_Face fields */
+    /* with relevant information                   */
+    {
+      FT_Face     root = FT_FACE( face );
+      FNT_Font    font = face->font;
+      FT_PtrDist  family_size;
+
+
+      root->face_flags = FT_FACE_FLAG_FIXED_SIZES |
+                         FT_FACE_FLAG_HORIZONTAL;
+
+      if ( font->header.avg_width == font->header.max_width )
+        root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      if ( font->header.italic )
+        root->style_flags |= FT_STYLE_FLAG_ITALIC;
+
+      if ( font->header.weight >= 800 )
+        root->style_flags |= FT_STYLE_FLAG_BOLD;
+
+      /* set up the `fixed_sizes' array */
+      if ( FT_NEW_ARRAY( root->available_sizes, 1 ) )
+        goto Fail;
+
+      root->num_fixed_sizes = 1;
+
+      {
+        FT_Bitmap_Size*  bsize = root->available_sizes;
+
+
+        bsize->width  = font->header.avg_width;
+        bsize->height = (FT_Short)(
+          font->header.pixel_height + font->header.external_leading );
+        bsize->size   = font->header.nominal_point_size << 6;
+        bsize->x_ppem = font->header.pixel_width << 6;
+        bsize->y_ppem = font->header.pixel_height << 6;
+      }
+
+      {
+        FT_CharMapRec  charmap;
+
+
+        charmap.encoding    = FT_ENCODING_NONE;
+        charmap.platform_id = 0;
+        charmap.encoding_id = 0;
+        charmap.face        = root;
+
+        if ( font->header.charset == FT_WinFNT_ID_MAC )
+        {
+          charmap.encoding    = FT_ENCODING_APPLE_ROMAN;
+          charmap.platform_id = 1;
+/*        charmap.encoding_id = 0; */
+        }
+
+        error = FT_CMap_New( fnt_cmap_class,
+                             NULL,
+                             &charmap,
+                             NULL );
+        if ( error )
+          goto Fail;
+
+        /* Select default charmap */
+        if ( root->num_charmaps )
+          root->charmap = root->charmaps[0];
+      }
+
+      /* setup remaining flags */
+
+      /* reserve one slot for the .notdef glyph at index 0 */
+      root->num_glyphs = font->header.last_char -
+                           font->header.first_char + 1 + 1;
+
+      /* Some broken fonts don't delimit the face name with a final */
+      /* NULL byte -- the frame is erroneously one byte too small.  */
+      /* We thus allocate one more byte, setting it explicitly to   */
+      /* zero.                                                      */
+      family_size = font->header.file_size - font->header.face_name_offset;
+      if ( FT_ALLOC( font->family_name, family_size + 1 ) )
+        goto Fail;
+      FT_MEM_COPY( font->family_name,
+                   font->fnt_frame + font->header.face_name_offset,
+                   family_size );
+      font->family_name[family_size] = '\0';
+      if ( FT_REALLOC( font->family_name,
+                       family_size,
+                       ft_strlen( font->family_name ) + 1 ) )
+        goto Fail;
+      root->family_name = font->family_name;
+      root->style_name  = (char *)"Regular";
+
+      if ( root->style_flags & FT_STYLE_FLAG_BOLD )
+      {
+        if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
+          root->style_name = (char *)"Bold Italic";
+        else
+          root->style_name = (char *)"Bold";
+      }
+      else if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
+        root->style_name = (char *)"Italic";
+    }
+    goto Exit;
+
+  Fail:
+    FNT_Face_Done( face );
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  FNT_Size_Set_Pixels( FT_Size  size )
+  {
+    FNT_Face  face = (FNT_Face)FT_SIZE_FACE( size );
+    FT_Face   root = FT_FACE( face );
+
+
+    if ( size->metrics.y_ppem == root->available_sizes->y_ppem >> 6 )
+    {
+      FNT_Font  font = face->font;
+
+
+      size->metrics.ascender    = font->header.ascent * 64;
+      size->metrics.descender   = -( font->header.pixel_height -
+                                       font->header.ascent ) * 64;
+      size->metrics.height      = font->header.pixel_height * 64;
+      size->metrics.max_advance = font->header.max_width * 64;
+
+      return FNT_Err_Ok;
+    }
+    else
+      return FNT_Err_Invalid_Pixel_Size;
+  }
+
+
+  static FT_Error
+  FNT_Load_Glyph( FT_GlyphSlot  slot,
+                  FT_Size       size,
+                  FT_UInt       glyph_index,
+                  FT_Int32      load_flags )
+  {
+    FNT_Face    face   = (FNT_Face)FT_SIZE_FACE( size );
+    FNT_Font    font   = face->font;
+    FT_Error    error  = FNT_Err_Ok;
+    FT_Byte*    p;
+    FT_Int      len;
+    FT_Bitmap*  bitmap = &slot->bitmap;
+    FT_ULong    offset;
+    FT_Bool     new_format;
+
+    FT_UNUSED( load_flags );
+
+
+    if ( !face || !font )
+    {
+      error = FNT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    if ( glyph_index > 0 )
+      glyph_index--;                           /* revert to real index */
+    else
+      glyph_index = font->header.default_char; /* the .notdef glyph */
+
+    new_format = FT_BOOL( font->header.version == 0x300 );
+    len        = new_format ? 6 : 4;
+
+    /* jump to glyph entry */
+    p = font->fnt_frame + ( new_format ? 148 : 118 ) + len * glyph_index;
+
+    bitmap->width = FT_NEXT_SHORT_LE( p );
+
+    if ( new_format )
+      offset = FT_NEXT_ULONG_LE( p );
+    else
+      offset = FT_NEXT_USHORT_LE( p );
+
+    if ( offset >= font->header.file_size )
+    {
+      FT_TRACE2(( "invalid FNT offset!\n" ));
+      error = FNT_Err_Invalid_File_Format;
+      goto Exit;
+    }
+
+    /* jump to glyph data */
+    p = font->fnt_frame + /* font->header.bits_offset */ + offset;
+
+    /* allocate and build bitmap */
+    {
+      FT_Memory  memory = FT_FACE_MEMORY( slot->face );
+      FT_Int     pitch  = ( bitmap->width + 7 ) >> 3;
+      FT_Byte*   column;
+      FT_Byte*   write;
+
+
+      bitmap->pitch      = pitch;
+      bitmap->rows       = font->header.pixel_height;
+      bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
+
+      /* note: since glyphs are stored in columns and not in rows we */
+      /*       can't use ft_glyphslot_set_bitmap                     */
+      if ( FT_ALLOC( bitmap->buffer, pitch * bitmap->rows ) )
+        goto Exit;
+
+      column = (FT_Byte*)bitmap->buffer;
+
+      for ( ; pitch > 0; pitch--, column++ )
+      {
+        FT_Byte*  limit = p + bitmap->rows;
+
+
+        for ( write = column; p < limit; p++, write += bitmap->pitch )
+          *write = *p;
+      }
+    }
+
+    slot->internal->flags = FT_GLYPH_OWN_BITMAP;
+    slot->bitmap_left     = 0;
+    slot->bitmap_top      = font->header.ascent;
+    slot->format          = FT_GLYPH_FORMAT_BITMAP;
+
+    /* now set up metrics */
+    slot->metrics.width        = bitmap->width << 6;
+    slot->metrics.height       = bitmap->rows << 6;
+    slot->metrics.horiAdvance  = bitmap->width << 6;
+    slot->metrics.horiBearingX = 0;
+    slot->metrics.horiBearingY = slot->bitmap_top << 6;
+
+    slot->linearHoriAdvance    = (FT_Fixed)bitmap->width << 16;
+    slot->format               = FT_GLYPH_FORMAT_BITMAP;
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  winfnt_get_header( FT_Face               face,
+                     FT_WinFNT_HeaderRec  *aheader )
+  {
+    FNT_Font  font = ((FNT_Face)face)->font;
+
+
+    *aheader = font->header;
+
+    return 0;
+  }
+
+
+  static const FT_Service_WinFntRec  winfnt_service_rec =
+  {
+    winfnt_get_header
+  };
+
+ /*
+  *  SERVICE LIST
+  *
+  */
+
+  static const FT_ServiceDescRec  winfnt_services[] =
+  {
+    { FT_SERVICE_ID_XF86_NAME, FT_XF86_FORMAT_WINFNT },
+    { FT_SERVICE_ID_WINFNT,    &winfnt_service_rec },
+    { NULL, NULL }
+  };
+
+
+  static FT_Module_Interface
+  winfnt_get_service( FT_Driver         driver,
+                      const FT_String*  service_id )
+  {
+    FT_UNUSED( driver );
+
+    return ft_service_list_lookup( winfnt_services, service_id );
+  }
+
+
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  winfnt_driver_class =
+  {
+    {
+      FT_MODULE_FONT_DRIVER        |
+      FT_MODULE_DRIVER_NO_OUTLINES,
+      sizeof ( FT_DriverRec ),
+
+      "winfonts",
+      0x10000L,
+      0x20000L,
+
+      0,
+
+      (FT_Module_Constructor)0,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  winfnt_get_service
+    },
+
+    sizeof( FNT_FaceRec ),
+    sizeof( FT_SizeRec ),
+    sizeof( FT_GlyphSlotRec ),
+
+    (FT_Face_InitFunc)        FNT_Face_Init,
+    (FT_Face_DoneFunc)        FNT_Face_Done,
+    (FT_Size_InitFunc)        0,
+    (FT_Size_DoneFunc)        0,
+    (FT_Slot_InitFunc)        0,
+    (FT_Slot_DoneFunc)        0,
+
+    (FT_Size_ResetPointsFunc) FNT_Size_Set_Pixels,
+    (FT_Size_ResetPixelsFunc) FNT_Size_Set_Pixels,
+    (FT_Slot_LoadFunc)        FNT_Load_Glyph,
+
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+    (FT_Face_GetAdvancesFunc) 0
+  };
+
+
+/* END */
diff --git a/nx-X11/extras/freetype2/src/winfonts/winfnt.h b/nx-X11/extras/freetype2/src/winfonts/winfnt.h
new file mode 100644
index 000000000..32ab6daf0
--- /dev/null
+++ b/nx-X11/extras/freetype2/src/winfonts/winfnt.h
@@ -0,0 +1,107 @@
+/***************************************************************************/
+/*                                                                         */
+/*  winfnt.h                                                               */
+/*                                                                         */
+/*    FreeType font driver for Windows FNT/FON files                       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002, 2003, 2004 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 __WINFNT_H__
+#define __WINFNT_H__
+
+
+#include <ft2build.h>
+#include FT_WINFONTS_H
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+  typedef struct  WinMZ_HeaderRec_
+  {
+    FT_UShort  magic;
+    /* skipped content */
+    FT_UShort  lfanew;
+
+  } WinMZ_HeaderRec;
+
+
+  typedef struct  WinNE_HeaderRec_
+  {
+    FT_UShort  magic;
+    /* skipped content */
+    FT_UShort  resource_tab_offset;
+    FT_UShort  rname_tab_offset;
+
+  } WinNE_HeaderRec;
+
+
+  typedef struct  WinNameInfoRec_
+  {
+    FT_UShort  offset;
+    FT_UShort  length;
+    FT_UShort  flags;
+    FT_UShort  id;
+    FT_UShort  handle;
+    FT_UShort  usage;
+
+  } WinNameInfoRec;
+
+
+  typedef struct  WinResourceInfoRec_
+  {
+    FT_UShort  type_id;
+    FT_UShort  count;
+
+  } WinResourceInfoRec;
+
+
+#define WINFNT_MZ_MAGIC  0x5A4D
+#define WINFNT_NE_MAGIC  0x454E
+
+
+  typedef struct  FNT_FontRec_
+  {
+    FT_ULong             offset;
+    FT_Int               size_shift;
+
+    FT_WinFNT_HeaderRec  header;
+
+    FT_Byte*             fnt_frame;
+    FT_ULong             fnt_size;
+    FT_String*           family_name;
+
+  } FNT_FontRec, *FNT_Font;
+
+
+  typedef struct  FNT_FaceRec_
+  {
+    FT_FaceRec     root;
+    FNT_Font       font;
+
+    FT_CharMap     charmap_handle;
+    FT_CharMapRec  charmap;  /* a single charmap per face */
+
+  } FNT_FaceRec, *FNT_Face;
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  winfnt_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __WINFNT_H__ */
+
+
+/* END */