diff --git a/Jamfile b/Jamfile
index fa774b3..8fc419b 100644
--- a/Jamfile
+++ b/Jamfile
@@ -15,6 +15,13 @@
 
 FT2_LIB     = $(LIBPREFIX)freetype ;
 
+if $(DEBUG_HINTER)
+{
+  CCFLAGS += -DDEBUG_HINTER ;
+}
+
+
+
 # We need "freetype2/include" in the current include path in order to
 # compile any part of FreeType 2.
 #
@@ -38,8 +45,11 @@
 SubInclude  FT2_TOP src ;
 
 
-# tests files
+# tests files (hinter debugging)
 #
-SubInclude FT2_TOP tests ;
+if $(DEBUG_HINTER)
+{
+  SubInclude FT2_TOP tests ;
+}
 
 # end of top Jamfile
diff --git a/src/psaux/t1decode.c b/src/psaux/t1decode.c
index d3af416..2ceaccc 100644
--- a/src/psaux/t1decode.c
+++ b/src/psaux/t1decode.c
@@ -141,7 +141,7 @@
       FT_String*  name = (FT_String*)decoder->glyph_names[n];
 
 
-      if ( name && strcmp( name,glyph_name ) == 0 )
+      if ( name && name[0] == glyph_name[0] && strcmp( name,glyph_name ) == 0 )
         return n;
     }
 
@@ -245,6 +245,7 @@
       glyph->format        = ft_glyph_format_composite;
 
       loader->current.num_subglyphs = 2;
+      goto Exit;
     }
 
     /* First load `bchar' in builder */
@@ -318,7 +319,7 @@
     FT_Byte*          ip;
     FT_Byte*          limit;
     T1_Builder*       builder = &decoder->builder;
-    FT_Pos            x, y;
+    FT_Pos            x, y, orig_x, orig_y;
 
     T1_Hints_Funcs    hinter;
 
@@ -345,8 +346,8 @@
 
     error = PSaux_Err_Ok;
 
-    x = builder->pos_x;
-    y = builder->pos_y;
+    x = orig_x = builder->pos_x;
+    y = orig_y = builder->pos_y;
 
     /* begin hints recording session, if any */
     if ( hinter )
@@ -740,8 +741,8 @@
           builder->advance.x       = top[1];
           builder->advance.y       = 0;
 
-          builder->last.x = x = builder->pos_x + top[0];
-          builder->last.y = y = builder->pos_y;
+          orig_x = builder->last.x = x = builder->pos_x + top[0];
+          orig_y = builder->last.y = y = builder->pos_y;
 
           /* the `metrics_only' indicates that we only want to compute */
           /* the glyph's metrics (lsb + advance width), not load the   */
@@ -1016,7 +1017,7 @@
           /* record vertical  hint */
           if ( hinter )
           {
-            top[0] += builder->left_bearing.x;
+            top[0] += orig_x;
             hinter->stem( hinter->hints, 1, top );
           }
 
@@ -1027,8 +1028,14 @@
 
           /* 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, 1, top );
-                           
+          }
           break;
 
         case op_setcurrentpoint:
diff --git a/src/pshinter/Jamfile b/src/pshinter/Jamfile
index 081ded4..3b749f1 100644
--- a/src/pshinter/Jamfile
+++ b/src/pshinter/Jamfile
@@ -10,7 +10,7 @@
 
   if $(FT2_MULTI)
   {
-    _sources = pshrec pshglob pshfit pshmod pshoptim ;
+    _sources = pshrec pshglob pshalgo1 pshalgo2 pshmod ;
   }
   else
   {
diff --git a/src/pshinter/pshalgo.h b/src/pshinter/pshalgo.h
new file mode 100644
index 0000000..6419311
--- /dev/null
+++ b/src/pshinter/pshalgo.h
@@ -0,0 +1,19 @@
+#ifndef __PS_HINTER_ALGO_H__
+#define __PS_HINTER_ALGO_H__
+
+FT_BEGIN_HEADER
+
+/* define to choose hinting algorithm */
+#define  PSH_ALGORITHM_2
+
+#ifdef PSH_ALGORITHM_1
+#  include  "pshalgo1.h"
+#  define  PS_HINTS_APPLY_FUNC   ps1_hints_apply
+#else
+#  include  "pshalgo2.h"
+#  define  PS_HINTS_APPLY_FUNC   ps2_hints_apply
+#endif
+
+FT_END_HEADER
+
+#endif /* __PS_HINTER_ALGO_H__ */
diff --git a/src/pshinter/pshalgo1.c b/src/pshinter/pshalgo1.c
new file mode 100644
index 0000000..eaa82de
--- /dev/null
+++ b/src/pshinter/pshalgo1.c
@@ -0,0 +1,736 @@
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include "pshalgo1.h"
+
+#ifdef DEBUG_HINTER
+  extern  PSH1_Hint_Table  ps1_debug_hint_table = 0;
+  extern  PSH1_HintFunc    ps1_debug_hint_func  = 0;
+#endif
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 BASIC HINTS RECORDINGS                       *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+ 
+ /* return true iff two stem hints overlap */
+  static FT_Int
+  psh1_hint_overlap( PSH1_Hint  hint1,
+                     PSH1_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
+  psh1_hint_table_done( PSH1_Hint_Table  table,
+                        FT_Memory        memory )
+  {
+    FREE( table->zones );
+    table->num_zones = 0;
+    table->zone      = 0;
+    
+    FREE( table->sort );
+    FREE( table->hints );
+    table->num_hints   = 0;
+    table->max_hints   = 0;
+    table->sort_global = 0;
+  }
+
+
+ /* deactivate all hints in a table */
+  static void
+  psh1_hint_table_deactivate( PSH1_Hint_Table  table )
+  {
+    FT_UInt   count = table->max_hints;
+    PSH1_Hint  hint  = table->hints;
+    
+    for ( ; count > 0; count--, hint++ )
+    {
+      psh1_hint_deactivate(hint);
+      hint->order = -1;
+    }
+  }
+
+
+ /* internal function used to record a new hint */
+  static void
+  psh1_hint_table_record( PSH1_Hint_Table  table,
+                          FT_UInt          index )
+  {
+    PSH1_Hint  hint = table->hints + index;
+
+    if ( index >= table->max_hints )
+    {
+      FT_ERROR(( "%s.activate: invalid hint index %d\n", index ));
+      return;
+    }
+        
+    /* ignore active hints */
+    if ( psh1_hint_is_active(hint) )
+      return;
+    
+    psh1_hint_activate(hint);
+    
+    /* now scan the current active hint set in order to determine */
+    /* if we're overlapping with another segment..                */
+    {
+      PSH1_Hint*  sorted = table->sort_global;
+      FT_UInt     count  = table->num_hints;
+      PSH1_Hint   hint2;
+
+      hint->parent = 0;      
+      for ( ; count > 0; count--, sorted++ )
+      {
+        hint2 = sorted[0];
+        
+        if ( psh1_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(( "%s.activate: too many sorted hints !! BUG !!\n",
+                 "ps.fitter" ));
+    }
+  }
+
+
+  static void
+  psh1_hint_table_record_mask( PSH1_Hint_Table  table,
+                               PS_Mask          hint_mask )
+  {
+    FT_Int    mask = 0, val = 0;
+    FT_Byte*  cursor = hint_mask->bytes;
+    FT_UInt   index, limit;
+
+    limit = hint_mask->num_bits; 
+    
+    if ( limit != table->max_hints )
+    {
+      FT_ERROR(( "%s.activate_mask: invalid bit count (%d instead of %d)\n",
+                 "ps.fitter", hint_mask->num_bits, table->max_hints ));
+    }
+        
+    for ( index = 0; index < limit; index++ )
+    {
+      if ( mask == 0 )
+      {
+        val  = *cursor++;
+        mask = 0x80;
+      }
+      
+      if ( val & mask )
+        psh1_hint_table_record( table, index );
+        
+      mask >>= 1;
+    }
+  }
+
+
+ /* create hints table */
+  static FT_Error
+  psh1_hint_table_init( PSH1_Hint_Table  table,
+                        PS_Hint_Table    hints,
+                        PS_Mask_Table    hint_masks,
+                        PS_Mask_Table    counter_masks,
+                        FT_Memory        memory )
+  {
+    FT_UInt   count = hints->num_hints;
+    FT_Error  error;
+
+    FT_UNUSED(counter_masks);
+    
+    /* allocate our tables */
+    if ( ALLOC_ARRAY( table->sort,  2*count,   PSH1_Hint    ) ||
+         ALLOC_ARRAY( table->hints,   count,   PSH1_HintRec ) ||
+         ALLOC_ARRAY( table->zones, 2*count+1, PSH1_ZoneRec ) )
+      goto Exit;
+    
+    table->max_hints   = count;
+    table->sort_global = table->sort + count;
+    table->num_hints   = 0;
+    table->num_zones   = 0;
+    table->zone        = 0;
+    
+    /* now, initialise the "hints" array */
+    {
+      PSH1_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 )
+    {
+      FT_UInt  count = hint_masks->num_masks;
+      PS_Mask  mask  = hint_masks->masks;
+
+      table->hint_masks = hint_masks;
+      
+      for ( ; count > 0; count--, mask++ )
+        psh1_hint_table_record_mask( table, mask );
+    }
+    
+    /* now, do a linear parse in case some hints were left alone */
+    if ( table->num_hints != table->max_hints )
+    {
+      FT_UInt   index, count;
+      
+      FT_ERROR(( "%s.init: missing/incorrect hint masks !!\n" ));
+      count = table->max_hints;
+      for ( index = 0; index < count; index++ )
+        psh1_hint_table_record( table, index );
+    }    
+    
+  Exit:
+    return error;
+  }
+
+
+
+  static void
+  psh1_hint_table_activate_mask( PSH1_Hint_Table  table,
+                                 PS_Mask          hint_mask )
+  {
+    FT_Int    mask = 0, val = 0;
+    FT_Byte*  cursor = hint_mask->bytes;
+    FT_UInt   index, limit, count;
+
+    limit = hint_mask->num_bits; 
+    count = 0;
+
+    psh1_hint_table_deactivate( table );
+    
+    for ( index = 0; index < limit; index++ )
+    {
+      if ( mask == 0 )
+      {
+        val  = *cursor++;
+        mask = 0x80;
+      }
+      
+      if ( val & mask )
+      {
+        PSH1_Hint  hint = &table->hints[index];
+        
+        if ( !psh1_hint_is_active(hint) )
+        {
+          PSH1_Hint*  sort   = table->sort;
+          FT_UInt    count2;
+          PSH1_Hint   hint2;
+          
+          for ( count2 = count; count2 > 0; count2--, sort++ )
+          {
+            hint2 = sort[0];
+            if ( psh1_hint_overlap( hint, hint2 ) )
+            {
+              FT_ERROR(( "%s.activate_mask: found overlapping hints\n",
+                         "psf.hint" ));
+              break;
+            }
+          }
+          
+          if ( count2 == 0 )
+          {
+            psh1_hint_activate( hint );
+            if ( count < table->max_hints )
+              table->sort[count++] = hint;
+            else
+            {
+              FT_ERROR(( "%s.activate_mask: too many active hints\n",
+                         "psf.hint" ));
+            } 
+          }
+        }
+      }
+        
+      mask >>= 1;
+    }
+    table->num_hints = count;
+    
+    /* now, sort the hints, they're guaranteed to not overlap */
+    /* so we can compare their "org_pos" field directly..     */
+    {
+      FT_Int     i1, i2;
+      PSH1_Hint   hint1, hint2;
+      PSH1_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[i1] = hint2;
+          sort[i2] = hint1;
+        }
+      }
+    }
+  }
+
+
+
+
+
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****               HINTS GRID-FITTING AND OPTIMISATION            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+ 
+#ifdef DEBUG_HINTER
+  void
+  ps_simple_scale( PSH1_Hint_Table  table,
+                   FT_Fixed         scale,
+                   FT_Fixed         delta,
+                   FT_Bool          vertical )
+  {
+    PSH1_Hint  hint;
+    FT_UInt    count;
+  
+    for ( count = 0; count < table->num_hints; count++ )
+    {
+      hint = table->sort[count];
+      if ( psh1_hint_is_active(hint) )
+      {
+        hint->cur_pos = FT_MulFix( hint->org_pos, scale ) + delta;
+        hint->cur_len = FT_MulFix( hint->org_len, scale );
+        
+        if (ps1_debug_hint_func)
+          ps1_debug_hint_func( hint, vertical );
+      }
+    }
+  }                
+#endif
+
+  FT_LOCAL_DEF  FT_Error
+  psh1_hint_table_optimize( PSH1_Hint_Table  table,
+                            PSH_Globals      globals,
+                            FT_Outline*      outline,
+                            FT_Bool          vertical )
+  {
+    PSH_Dimension  dim   = &globals->dimension[vertical];
+    FT_Fixed       scale = dim->scale_mult;
+    FT_Fixed       delta = dim->scale_delta;
+
+#ifdef DEBUG_HINTER
+    if ( ps_debug_no_vert_hints && vertical )
+    {
+      ps_simple_scale( table, scale, delta, vertical );
+      return 0;
+    }
+      
+    if ( ps_debug_no_horz_hints && !vertical )
+    {
+      ps_simple_scale( table, scale, delta, vertical );
+      return 0;
+    }
+#endif
+
+    /* XXXX: for now, we only scale the hints to test all other aspects */
+    /*       of the Postscript Hinter..                                 */
+    {  
+      PSH1_Hint  hint;
+      FT_UInt   count;
+    
+      for ( count = 0; count < table->num_hints; count++ )
+      {
+        hint = table->sort[count];
+        if ( psh1_hint_is_active(hint) )
+        {
+# if 1
+          FT_Pos   pos = FT_MulFix( hint->org_pos, scale ) + delta;
+          FT_Pos   len = FT_MulFix( hint->org_len, scale );
+          
+          FT_Pos   fit_center;
+          FT_Pos   fit_len;
+          
+          PSH_AlignmentRec  align;
+
+          /* compute fitted width/height */
+          fit_len = psh_dimension_snap_width( dim, hint->org_len );
+          if ( fit_len < 64 )
+            fit_len = 64;
+          else
+            fit_len = (fit_len + 32 ) & -64;
+            
+          hint->cur_len = fit_len;
+            
+          /* check blue zones for horizontal stems */
+          align.align = 0;
+          if (!vertical)
+          {
+            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:
+              /* normal processing */
+              if ( (fit_len/64) & 1 )
+              {
+                /* odd number of pixels */
+                fit_center = ((pos + (len >> 1)) & -64) + 32;
+              }
+              else
+              {
+                /* even number of pixels */
+                fit_center = (pos + (len >> 1) + 32) & -64;
+              }
+              
+              hint->cur_pos = fit_center - (fit_len >> 1);
+          }
+# else
+          hint->cur_pos = (FT_MulFix( hint->org_pos, scale ) + delta + 32) & -64;
+          hint->cur_len =  FT_MulFix( hint->org_len, scale );
+# endif          
+
+#ifdef DEBUG_HINTER
+        if (ps1_debug_hint_func)
+          ps1_debug_hint_func( hint, vertical );
+#endif        
+        }
+      }
+    }
+    
+    return 0;
+  }
+
+
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****               POINTS INTERPOLATION ROUTINES                  *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+ 
+#define  PSH1_ZONE_MIN  -3200000
+#define  PSH1_ZONE_MAX  +3200000
+
+
+#define xxDEBUG_ZONES
+
+#ifdef DEBUG_ZONES
+
+#include <stdio.h>
+
+  static void
+  print_zone( PSH1_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  print_zone(x)   do { } while (0)
+#endif
+
+ /* setup interpolation zones once the hints have been grid-fitted */
+ /* by the optimizer..                                             */
+  static void
+  psh1_hint_table_setup_zones( PSH1_Hint_Table  table,
+                               FT_Fixed         scale,
+                               FT_Fixed         delta )
+  {
+    FT_UInt   count;
+    PSH1_Zone  zone;
+    PSH1_Hint *sort, hint, hint2;
+    
+    zone  = table->zones;
+    
+    /* special case, no hints defined */
+    if ( table->num_hints == 0 )
+    {
+      zone->scale = scale;
+      zone->delta = delta;
+      zone->min   = PSH1_ZONE_MIN;
+      zone->max   = PSH1_ZONE_MAX;
+      
+      table->num_zones = 1;
+      table->zone      = zone;
+      return;
+    }
+    
+    /* the first zone is before the first hint */
+    /* x' = (x-x0)*s + x0' = x*s + ( x0' - x0*s ) */
+    sort  = table->sort;
+    hint  = sort[0];
+    
+    zone->scale = scale;
+    zone->delta = hint->cur_pos - FT_MulFix( hint->org_pos, scale );
+    zone->min   = PSH1_ZONE_MIN;
+    zone->max   = hint->org_pos;
+    
+    print_zone( zone );
+    
+    zone++;
+    
+    for ( count = table->num_hints; count > 0; count-- )
+    {
+      FT_Fixed  scale2;
+
+      if ( hint->org_len > 0 )
+      {
+        /* setup a zone for inner-stem interpolation */
+        /* (x' - x0') = (x - x0)*(x1'-x0')/(x1-x0)   */
+        /* x' = x*s2 + x0' - x0*s2                   */
+        
+        scale2      = FT_DivFix( hint->cur_len, hint->org_len );
+        zone->scale = scale2;
+        zone->min   = hint->org_pos;
+        zone->max   = hint->org_pos + hint->org_len;
+        zone->delta = hint->cur_pos - FT_MulFix( zone->min, scale2 );
+
+        print_zone( zone );
+    
+        zone++;
+      }
+      
+      if ( count == 1 )
+        break;
+        
+      sort++;
+      hint2 = sort[0];
+      
+      /* setup zone for inter-stem interpolation */
+      /* (x'-x1') = (x-x1)*(x2'-x1')/(x2-x1)     */
+      /* x' = x*s3 + x1' - x1*s3                 */
+      scale2 = FT_DivFix( hint2->cur_pos - (hint->cur_pos + hint->cur_len),
+                          hint2->org_pos - (hint->org_pos + hint->org_len) );
+      zone->scale = scale2;
+      zone->min   = hint->org_pos + hint->org_len;
+      zone->max   = hint2->org_pos;
+      zone->delta = hint->cur_pos + hint->cur_len - FT_MulFix( zone->min, scale2 );
+
+      print_zone( zone );
+    
+      zone++;
+      
+      hint  = hint2;
+    }
+
+    /* the last zone */
+    zone->scale = scale;
+    zone->min   = hint->org_pos + hint->org_len;
+    zone->max   = PSH1_ZONE_MAX;
+    zone->delta = hint->cur_pos + hint->cur_len - FT_MulFix( zone->min, scale );
+
+    print_zone( zone );
+    
+    zone++;
+    
+    table->num_zones = zone - table->zones;
+    table->zone      = table->zones;
+  }
+
+
+ /* tune a single coordinate with the current interpolation zones */  
+  static FT_Pos
+  psh1_hint_table_tune_coord( PSH1_Hint_Table  table,
+                              FT_Int           coord )
+  {
+    PSH1_Zone   zone;
+    
+    zone = table->zone;
+      
+    if ( coord < zone->min )
+    {
+      do
+      {
+        if ( zone == table->zones )
+          break;
+          
+        zone--;
+      }
+      while ( coord < zone->min );
+      table->zone = zone;
+    }
+    else if ( coord > zone->max )
+    {
+      do
+      {
+        if ( zone == table->zones + table->num_zones - 1 )
+          break;
+          
+        zone++;
+      }
+      while ( coord > zone->max );
+      table->zone = zone;
+    }
+        
+    return FT_MulFix( coord, zone->scale ) + zone->delta;
+  }
+
+
+ /* tune a given outline with current interpolation zones */
+ /* the function only works in a single dimension..       */
+  static void
+  psh1_hint_table_tune_outline( PSH1_Hint_Table  table,
+                                FT_Outline*      outline,
+                                PSH_Globals      globals,
+                                FT_Bool          vertical )
+
+  {
+    FT_UInt         count, first, last;
+    PS_Mask_Table   hint_masks = table->hint_masks;
+    PS_Mask         mask;
+    PSH_Dimension  dim        = &globals->dimension[vertical];
+    FT_Fixed        scale      = dim->scale_mult;
+    FT_Fixed        delta      = dim->scale_delta;
+    
+    if ( hint_masks && hint_masks->num_masks > 0 )
+    {
+      first = 0;
+      mask  = hint_masks->masks;
+      count = hint_masks->num_masks;
+      for ( ; count > 0; count--, mask++ )
+      {
+        last = mask->end_point;
+        
+        if ( last > first )
+        {
+          FT_Vector*   vec;
+          FT_Int       count2;
+          
+          psh1_hint_table_activate_mask( table, mask );
+          psh1_hint_table_optimize( table, globals, outline, vertical );
+          psh1_hint_table_setup_zones( table, scale, delta );
+          last = mask->end_point;
+          
+          vec    = outline->points + first;
+          count2 = last - first;
+          for ( ; count2 > 0; count2--, vec++ )
+          {
+            FT_Pos  x, *px;
+            
+            px  = vertical ? &vec->x : &vec->y;
+            x   = *px;
+            
+            *px = psh1_hint_table_tune_coord( table, (FT_Int)x );
+          }
+        }
+          
+        first = last;
+      }
+    }
+    else    /* no hints in this glyph, simply scale the outline */
+    {
+      FT_Vector*  vec;
+      
+      vec   = outline->points;
+      count = outline->n_points;
+      
+      if ( vertical )
+      {
+        for ( ; count > 0; count--, vec++ )
+          vec->x = FT_MulFix( vec->x, scale ) + delta;
+      }
+      else
+      {
+        for ( ; count > 0; count--, vec++ )
+          vec->y = FT_MulFix( vec->y, scale ) + delta;
+      }
+    }
+  }
+  
+  
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                     HIGH-LEVEL INTERFACE                     *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+  
+  FT_Error
+  ps1_hints_apply( PS_Hints     ps_hints,
+                   FT_Outline*  outline,
+                   PSH_Globals  globals )
+  {
+    PSH1_Hint_TableRec  hints;
+    FT_Error           error;
+    FT_Int             dimension;
+    
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      PS_Dimension  dim = &ps_hints->dimension[dimension];
+      
+      /* initialise hints table */
+      memset( &hints, 0, sizeof(hints) );
+      error = psh1_hint_table_init( &hints,
+                                    &dim->hints,
+                                    &dim->masks,
+                                    &dim->counters,
+                                    ps_hints->memory );
+      if (error) goto Exit;
+      
+      psh1_hint_table_tune_outline( &hints,
+                                    outline,
+                                    globals,
+                                    dimension );
+                                   
+      psh1_hint_table_done( &hints, ps_hints->memory );
+    }
+    
+  Exit:
+    return error;                                   
+  }
diff --git a/src/pshinter/pshalgo1.h b/src/pshinter/pshalgo1.h
new file mode 100644
index 0000000..1b0dd5d
--- /dev/null
+++ b/src/pshinter/pshalgo1.h
@@ -0,0 +1,100 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshalgo1.h                                                             */
+/*                                                                         */
+/*    First (basic) Postscript hinting routines                            */
+/*                                                                         */
+/*  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 __PS_HINTER_ALGO1_H__
+#define __PS_HINTER_ALGO1_H__
+
+#include "pshrec.h"
+
+FT_BEGIN_HEADER
+
+  typedef struct PSH1_HintRec_*   PSH1_Hint;
+
+  typedef enum
+  {
+    PSH1_HINT_FLAG_GHOST  = PS_HINT_FLAG_GHOST,
+    PSH1_HINT_FLAG_BOTTOM = PS_HINT_FLAG_BOTTOM,
+    PSH1_HINT_FLAG_ACTIVE = 4
+  
+  } PSH1_Hint_Flags;
+
+#define  psh1_hint_is_active(x)  (((x)->flags  & PSH1_HINT_FLAG_ACTIVE) != 0)
+#define  psh1_hint_is_ghost(x)   (((x)->flags  & PSH1_HINT_FLAG_GHOST ) != 0)  
+
+#define  psh1_hint_activate(x)     (x)->flags |= PSH1_HINT_FLAG_ACTIVE
+#define  psh1_hint_deactivate(x)   (x)->flags &= ~PSH1_HINT_FLAG_ACTIVE
+
+  typedef struct PSH1_HintRec_
+  {
+    FT_Int    org_pos;
+    FT_Int    org_len;
+    FT_Pos    cur_pos;
+    FT_Pos    cur_len;
+    
+    FT_UInt   flags;
+    
+    PSH1_Hint  parent;
+    FT_Int    order;
+  
+  } PSH1_HintRec;
+
+
+ /* this is an interpolation zone used for strong points   */
+ /* weak points are interpolated according to their strong */
+ /* neighbours..                                           */
+  typedef struct PSH1_ZoneRec_
+  {
+    FT_Fixed  scale;
+    FT_Fixed  delta;
+    FT_Pos    min;
+    FT_Pos    max;
+    
+  } PSH1_ZoneRec, *PSH1_Zone;
+
+
+  typedef struct PSH1_Hint_TableRec_
+  {
+    FT_UInt        max_hints;
+    FT_UInt        num_hints;
+    PSH1_Hint      hints;
+    PSH1_Hint*     sort;
+    PSH1_Hint*     sort_global;
+    FT_UInt        num_zones;
+    PSH1_Zone      zones;
+    PSH1_Zone      zone;
+    PS_Mask_Table  hint_masks;
+    PS_Mask_Table  counter_masks;
+    
+  } PSH1_Hint_TableRec, *PSH1_Hint_Table;
+
+
+  extern FT_Error
+  ps1_hints_apply( PS_Hints      ps_hints,
+                   FT_Outline*   outline,
+                   PSH_Globals   globals );
+
+
+#ifdef DEBUG_HINTER
+  extern  PSH1_Hint_Table  ps1_debug_hint_table;
+
+  typedef void  (*PSH1_HintFunc)( PSH1_Hint  hint, FT_Bool vertical );
+  extern  PSH1_HintFunc    ps1_debug_hint_func;
+#endif
+
+FT_END_HEADER
+
+#endif /* __PS_HINTER_FITTER_H__ */
diff --git a/src/pshinter/pshalgo2.c b/src/pshinter/pshalgo2.c
new file mode 100644
index 0000000..c98aa78
--- /dev/null
+++ b/src/pshinter/pshalgo2.c
@@ -0,0 +1,1484 @@
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include "pshalgo2.h"
+
+
+#ifdef DEBUG_HINTER  
+  extern  PSH2_Hint_Table  ps2_debug_hint_table  = 0;
+  extern  PSH2_HintFunc    ps2_debug_hint_func   = 0;
+  extern  PSH2_Glyph       ps2_debug_glyph       = 0;
+#endif
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 BASIC HINTS RECORDINGS                       *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+ 
+ /* return true iff two stem hints overlap */
+  static FT_Int
+  psh2_hint_overlap( PSH2_Hint  hint1,
+                     PSH2_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
+  psh2_hint_table_done( PSH2_Hint_Table  table,
+                        FT_Memory        memory )
+  {
+    FREE( table->zones );
+    table->num_zones = 0;
+    table->zone      = 0;
+    
+    FREE( table->sort );
+    FREE( table->hints );
+    table->num_hints   = 0;
+    table->max_hints   = 0;
+    table->sort_global = 0;
+  }
+
+
+ /* deactivate all hints in a table */
+  static void
+  psh2_hint_table_deactivate( PSH2_Hint_Table  table )
+  {
+    FT_UInt   count = table->max_hints;
+    PSH2_Hint  hint  = table->hints;
+    
+    for ( ; count > 0; count--, hint++ )
+    {
+      psh2_hint_deactivate(hint);
+      hint->order = -1;
+    }
+  }
+
+
+ /* internal function used to record a new hint */
+  static void
+  psh2_hint_table_record( PSH2_Hint_Table  table,
+                          FT_UInt          index )
+  {
+    PSH2_Hint  hint = table->hints + index;
+
+    if ( index >= table->max_hints )
+    {
+      FT_ERROR(( "%s.activate: invalid hint index %d\n", index ));
+      return;
+    }
+        
+    /* ignore active hints */
+    if ( psh2_hint_is_active(hint) )
+      return;
+    
+    psh2_hint_activate(hint);
+    
+    /* now scan the current active hint set in order to determine */
+    /* if we're overlapping with another segment..                */
+    {
+      PSH2_Hint*  sorted = table->sort_global;
+      FT_UInt     count  = table->num_hints;
+      PSH2_Hint   hint2;
+
+      hint->parent = 0;      
+      for ( ; count > 0; count--, sorted++ )
+      {
+        hint2 = sorted[0];
+        
+        if ( psh2_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(( "%s.activate: too many sorted hints !! BUG !!\n",
+                 "ps.fitter" ));
+    }
+  }
+
+
+  static void
+  psh2_hint_table_record_mask( PSH2_Hint_Table  table,
+                               PS_Mask          hint_mask )
+  {
+    FT_Int    mask = 0, val = 0;
+    FT_Byte*  cursor = hint_mask->bytes;
+    FT_UInt   index, limit;
+
+    limit = hint_mask->num_bits; 
+    
+    if ( limit != table->max_hints )
+    {
+      FT_ERROR(( "%s.activate_mask: invalid bit count (%d instead of %d)\n",
+                 "ps.fitter", hint_mask->num_bits, table->max_hints ));
+    }
+        
+    for ( index = 0; index < limit; index++ )
+    {
+      if ( mask == 0 )
+      {
+        val  = *cursor++;
+        mask = 0x80;
+      }
+      
+      if ( val & mask )
+        psh2_hint_table_record( table, index );
+        
+      mask >>= 1;
+    }
+  }
+
+
+ /* create hints table */
+  static FT_Error
+  psh2_hint_table_init( PSH2_Hint_Table  table,
+                        PS_Hint_Table    hints,
+                        PS_Mask_Table    hint_masks,
+                        PS_Mask_Table    counter_masks,
+                        FT_Memory        memory )
+  {
+    FT_UInt   count = hints->num_hints;
+    FT_Error  error;
+
+    FT_UNUSED(counter_masks);
+    
+    /* allocate our tables */
+    if ( ALLOC_ARRAY( table->sort,  2*count,   PSH2_Hint    ) ||
+         ALLOC_ARRAY( table->hints,   count,   PSH2_HintRec ) ||
+         ALLOC_ARRAY( table->zones, 2*count+1, PSH2_ZoneRec ) )
+      goto Exit;
+    
+    table->max_hints   = count;
+    table->sort_global = table->sort + count;
+    table->num_hints   = 0;
+    table->num_zones   = 0;
+    table->zone        = 0;
+    
+    /* now, initialise the "hints" array */
+    {
+      PSH2_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 )
+    {
+      FT_UInt  count = hint_masks->num_masks;
+      PS_Mask  mask  = hint_masks->masks;
+
+      table->hint_masks = hint_masks;
+      
+      for ( ; count > 0; count--, mask++ )
+        psh2_hint_table_record_mask( table, mask );
+    }
+    
+    /* now, do a linear parse in case some hints were left alone */
+    if ( table->num_hints != table->max_hints )
+    {
+      FT_UInt   index, count;
+      
+      FT_ERROR(( "%s.init: missing/incorrect hint masks !!\n" ));
+      count = table->max_hints;
+      for ( index = 0; index < count; index++ )
+        psh2_hint_table_record( table, index );
+    }    
+    
+  Exit:
+    return error;
+  }
+
+
+
+  static void
+  psh2_hint_table_activate_mask( PSH2_Hint_Table  table,
+                                 PS_Mask          hint_mask )
+  {
+    FT_Int    mask = 0, val = 0;
+    FT_Byte*  cursor = hint_mask->bytes;
+    FT_UInt   index, limit, count;
+
+    limit = hint_mask->num_bits; 
+    count = 0;
+
+    psh2_hint_table_deactivate( table );
+    
+    for ( index = 0; index < limit; index++ )
+    {
+      if ( mask == 0 )
+      {
+        val  = *cursor++;
+        mask = 0x80;
+      }
+      
+      if ( val & mask )
+      {
+        PSH2_Hint  hint = &table->hints[index];
+        
+        if ( !psh2_hint_is_active(hint) )
+        {
+          PSH2_Hint*  sort = table->sort;
+          FT_UInt     count2;
+          PSH2_Hint   hint2;
+          
+#if 0
+          for ( count2 = count; count2 > 0; count2--, sort++ )
+          {
+            hint2 = sort[0];
+            if ( psh2_hint_overlap( hint, hint2 ) )
+            {
+              FT_ERROR(( "%s.activate_mask: found overlapping hints\n",
+                         "psf.hint" ));
+            }
+          }
+#else
+          count2 = 0;
+#endif
+          
+          if ( count2 == 0 )
+          {
+            psh2_hint_activate( hint );
+            if ( count < table->max_hints )
+              table->sort[count++] = hint;
+            else
+            {
+              FT_ERROR(( "%s.activate_mask: too many active hints\n",
+                         "psf.hint" ));
+            } 
+          }
+        }
+      }
+        
+      mask >>= 1;
+    }
+    table->num_hints = count;
+    
+    /* now, sort the hints, they're guaranteed to not overlap */
+    /* so we can compare their "org_pos" field directly..     */
+    {
+      FT_Int     i1, i2;
+      PSH2_Hint   hint1, hint2;
+      PSH2_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[i1] = hint2;
+          sort[i2] = hint1;
+        }
+      }
+    }
+  }
+
+
+
+
+
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****               HINTS GRID-FITTING AND OPTIMISATION            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+ 
+#ifdef DEBUG_HINTER
+  static void
+  ps_simple_scale( PSH2_Hint_Table  table,
+                   FT_Fixed         scale,
+                   FT_Fixed         delta,
+                   FT_Bool          vertical )
+  {
+    PSH2_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 (ps2_debug_hint_func)
+        ps2_debug_hint_func( hint, vertical );
+    }
+  }                
+#endif
+
+
+  static void
+  psh2_hint_align( PSH2_Hint    hint,
+                   PSH_Globals  globals,
+                   FT_Bool      vertical )
+  {
+    PSH_Dimension  dim   = &globals->dimension[vertical];
+    FT_Fixed       scale = dim->scale_mult;
+    FT_Fixed       delta = dim->scale_delta;
+
+    if ( !psh2_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_center;
+      FT_Pos   fit_len;
+      
+      PSH_AlignmentRec  align;
+
+      /* compute fitted width/height */
+      fit_len = 0;
+      if ( hint->org_len )
+      {
+        fit_len = psh_dimension_snap_width( dim, hint->org_len );
+        if ( fit_len < 64 )
+          fit_len = 64;
+        else
+          fit_len = (fit_len + 32 ) & -64;
+      }
+        
+      hint->cur_len = fit_len;
+        
+      /* check blue zones for horizontal stems */
+      align.align = 0;
+      if (!vertical)
+      {
+        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:
+          {
+            PSH2_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 ( !psh2_hint_is_fitted(parent) )
+                psh2_hint_align( parent, globals, vertical );
+                
+              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 );
+#if 0              
+              if ( cur_delta >= 0 )
+                cur_delta = (cur_delta+16) & -64;
+              else
+                cur_delta = -((-cur_delta+16) & -64);
+#endif
+              pos = par_cur_center + cur_delta - (len >> 1);
+            }
+
+            /* normal processing */
+            if ( (fit_len/64) & 1 )
+            {
+              /* odd number of pixels */
+              fit_center = ((pos + (len >> 1)) & -64) + 32;
+            }
+            else
+            {
+              /* even number of pixels */
+              fit_center = (pos + (len >> 1) + 32) & -64;
+            }
+          
+            hint->cur_pos = fit_center - (fit_len >> 1);
+          }
+      }
+      
+      psh2_hint_set_fitted(hint);
+      
+#ifdef DEBUG_HINTER
+      if (ps2_debug_hint_func)
+        ps2_debug_hint_func( hint, vertical );
+#endif
+    }
+  }                              
+
+
+  static void
+  psh2_hint_table_align_hints( PSH2_Hint_Table  table,
+                               PSH_Globals      globals,
+                               FT_Bool          vertical )
+  {
+    PSH_Dimension  dim   = &globals->dimension[vertical];
+    FT_Fixed       scale = dim->scale_mult;
+    FT_Fixed       delta = dim->scale_delta;
+
+    PSH2_Hint      hint;
+    FT_UInt        count;
+
+#ifdef DEBUG_HINTER
+    if ( ps_debug_no_vert_hints && vertical )
+    {
+      ps_simple_scale( table, scale, delta, vertical );
+      return;
+    }
+      
+    if ( ps_debug_no_horz_hints && !vertical )
+    {
+      ps_simple_scale( table, scale, delta, vertical );
+      return;
+    }
+#endif
+
+    hint  = table->hints;
+    count = table->max_hints;
+    for ( ; count > 0; count--, hint++ )
+      psh2_hint_align( hint, globals, vertical );
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****               POINTS INTERPOLATION ROUTINES                  *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+ 
+#define  PSH2_ZONE_MIN  -3200000
+#define  PSH2_ZONE_MAX  +3200000
+
+
+#define xxDEBUG_ZONES
+
+#ifdef DEBUG_ZONES
+
+#include <stdio.h>
+
+  static void
+  print_zone( PSH2_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  print_zone(x)   do { } while (0)
+#endif
+
+ /* setup interpolation zones once the hints have been grid-fitted */
+ /* by the optimizer..                                             */
+  static void
+  psh2_hint_table_setup_zones( PSH2_Hint_Table  table,
+                               FT_Fixed         scale,
+                               FT_Fixed         delta )
+  {
+    FT_UInt   count;
+    PSH2_Zone  zone;
+    PSH2_Hint *sort, hint, hint2;
+    
+    zone  = table->zones;
+    
+    /* special case, no hints defined */
+    if ( table->num_hints == 0 )
+    {
+      zone->scale = scale;
+      zone->delta = delta;
+      zone->min   = PSH2_ZONE_MIN;
+      zone->max   = PSH2_ZONE_MAX;
+      
+      table->num_zones = 1;
+      table->zone      = zone;
+      return;
+    }
+    
+    /* the first zone is before the first hint */
+    /* x' = (x-x0)*s + x0' = x*s + ( x0' - x0*s ) */
+    sort  = table->sort;
+    hint  = sort[0];
+    
+    zone->scale = scale;
+    zone->delta = hint->cur_pos - FT_MulFix( hint->org_pos, scale );
+    zone->min   = PSH2_ZONE_MIN;
+    zone->max   = hint->org_pos;
+    
+    print_zone( zone );
+    
+    zone++;
+    
+    for ( count = table->num_hints; count > 0; count-- )
+    {
+      FT_Fixed  scale2;
+
+      if ( hint->org_len > 0 )
+      {
+        /* setup a zone for inner-stem interpolation */
+        /* (x' - x0') = (x - x0)*(x1'-x0')/(x1-x0)   */
+        /* x' = x*s2 + x0' - x0*s2                   */
+        
+        scale2      = FT_DivFix( hint->cur_len, hint->org_len );
+        zone->scale = scale2;
+        zone->min   = hint->org_pos;
+        zone->max   = hint->org_pos + hint->org_len;
+        zone->delta = hint->cur_pos - FT_MulFix( zone->min, scale2 );
+
+        print_zone( zone );
+    
+        zone++;
+      }
+      
+      if ( count == 1 )
+        break;
+        
+      sort++;
+      hint2 = sort[0];
+      
+      /* setup zone for inter-stem interpolation */
+      /* (x'-x1') = (x-x1)*(x2'-x1')/(x2-x1)     */
+      /* x' = x*s3 + x1' - x1*s3                 */
+      scale2 = FT_DivFix( hint2->cur_pos - (hint->cur_pos + hint->cur_len),
+                          hint2->org_pos - (hint->org_pos + hint->org_len) );
+      zone->scale = scale2;
+      zone->min   = hint->org_pos + hint->org_len;
+      zone->max   = hint2->org_pos;
+      zone->delta = hint->cur_pos + hint->cur_len - FT_MulFix( zone->min, scale2 );
+
+      print_zone( zone );
+    
+      zone++;
+      
+      hint  = hint2;
+    }
+
+    /* the last zone */
+    zone->scale = scale;
+    zone->min   = hint->org_pos + hint->org_len;
+    zone->max   = PSH2_ZONE_MAX;
+    zone->delta = hint->cur_pos + hint->cur_len - FT_MulFix( zone->min, scale );
+
+    print_zone( zone );
+    
+    zone++;
+    
+    table->num_zones = zone - table->zones;
+    table->zone      = table->zones;
+  }
+
+
+ /* tune a single coordinate with the current interpolation zones */  
+  static FT_Pos
+  psh2_hint_table_tune_coord( PSH2_Hint_Table  table,
+                              FT_Int           coord )
+  {
+    PSH2_Zone   zone;
+    
+    zone = table->zone;
+      
+    if ( coord < zone->min )
+    {
+      do
+      {
+        if ( zone == table->zones )
+          break;
+          
+        zone--;
+      }
+      while ( coord < zone->min );
+      table->zone = zone;
+    }
+    else if ( coord > zone->max )
+    {
+      do
+      {
+        if ( zone == table->zones + table->num_zones - 1 )
+          break;
+          
+        zone++;
+      }
+      while ( coord > zone->max );
+      table->zone = zone;
+    }
+        
+    return FT_MulFix( coord, zone->scale ) + zone->delta;
+  }
+
+
+#if 0
+ /* tune a given outline with current interpolation zones */
+ /* the function only works in a single dimension..       */
+  static void
+  psh2_hint_table_tune_outline( PSH2_Hint_Table  table,
+                                FT_Outline*      outline,
+                                PSH_Globals      globals,
+                                FT_Bool          vertical )
+
+  {
+    FT_UInt        count, first, last;
+    PS_Mask_Table  hint_masks = table->hint_masks;
+    PS_Mask        mask;
+    PSH_Dimension  dim        = &globals->dimension[vertical];
+    FT_Fixed       scale      = dim->scale_mult;
+    FT_Fixed       delta      = dim->scale_delta;
+    
+    if ( hint_masks && hint_masks->num_masks > 0 )
+    {
+      first = 0;
+      mask  = hint_masks->masks;
+      count = hint_masks->num_masks;
+      for ( ; count > 0; count--, mask++ )
+      {
+        last = mask->end_point;
+        
+        if ( last > first )
+        {
+          FT_Vector*   vec;
+          FT_Int       count2;
+          
+          psh2_hint_table_activate_mask( table, mask );
+          psh2_hint_table_optimize( table, globals, outline, vertical );
+          psh2_hint_table_setup_zones( table, scale, delta );
+          last = mask->end_point;
+          
+          vec    = outline->points + first;
+          count2 = last - first;
+          for ( ; count2 > 0; count2--, vec++ )
+          {
+            FT_Pos  x, *px;
+            
+            px  = vertical ? &vec->x : &vec->y;
+            x   = *px;
+            
+            *px = psh2_hint_table_tune_coord( table, (FT_Int)x );
+          }
+        }
+          
+        first = last;
+      }
+    }
+    else    /* no hints in this glyph, simply scale the outline */
+    {
+      FT_Vector*  vec;
+      
+      vec   = outline->points;
+      count = outline->n_points;
+      
+      if ( vertical )
+      {
+        for ( ; count > 0; count--, vec++ )
+          vec->x = FT_MulFix( vec->x, scale ) + delta;
+      }
+      else
+      {
+        for ( ; count > 0; count--, vec++ )
+          vec->y = FT_MulFix( vec->y, scale ) + delta;
+      }
+    }
+  }
+#endif
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                    HINTER GLYPH MANAGEMENT                   *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static int
+  psh2_point_is_extremum( PSH2_Point  point )
+  {
+    PSH2_Point  before = point;
+    PSH2_Point  after  = point;
+    FT_Pos      d_before;
+    FT_Pos      d_after;
+
+    do
+    {
+      before = before->prev;
+      if ( before == point )
+        return 0;
+        
+      d_before = before->org_u - point->org_u;
+    }
+    while ( d_before == 0 );
+    
+    do
+    {
+      after = after->next;
+      if ( after == point )
+        return 0;
+        
+      d_after = after->org_u - point->org_u;
+    }
+    while ( d_after == 0 );
+
+    return ( ( d_before > 0 && d_after > 0 ) ||
+             ( d_before < 0 && d_after < 0 ) );
+  }
+
+
+
+  static void
+  psh2_glyph_done( PSH2_Glyph  glyph )
+  {
+    FT_Memory  memory = glyph->memory;
+
+    psh2_hint_table_done( &glyph->hint_tables[1], memory );
+    psh2_hint_table_done( &glyph->hint_tables[0], memory );
+    
+    FREE( glyph->points );
+    FREE( glyph->contours );
+
+    glyph->num_points   = 0;
+    glyph->num_contours = 0;
+
+    glyph->memory = 0;
+  }
+
+
+  static int
+  psh2_compute_dir( FT_Pos  dx, FT_Pos  dy )
+  {
+    FT_Pos  ax, ay;
+    int     result = PSH2_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 ) ? PSH2_DIR_RIGHT : PSH2_DIR_LEFT;
+    }
+    else if ( ax*12 < ay )
+    {
+      /* |dx| <<< |dy|  means a near-vertical segment */
+      result = ( dy >= 0 ) ? PSH2_DIR_UP : PSH2_DIR_DOWN;
+    }
+    return result;
+  }
+
+
+  static FT_Error
+  psh2_glyph_init( PSH2_Glyph   glyph,
+                   FT_Outline*  outline,
+                   PS_Hints     ps_hints,
+                   PSH_Globals  globals )
+  {
+    FT_Error   error;
+    FT_Memory  memory;
+    
+    /* clear all fields */
+    memset( glyph, 0, sizeof(*glyph) );
+    
+    memory = globals->memory;
+    
+    /* allocate and setup points + contours arrays */
+    if ( ALLOC_ARRAY( glyph->points,   outline->n_points,   PSH2_PointRec   ) ||
+         ALLOC_ARRAY( glyph->contours, outline->n_contours, PSH2_ContourRec ) )
+      goto Exit;
+    
+    glyph->num_points   = outline->n_points;
+    glyph->num_contours = outline->n_contours;
+    
+    {
+      FT_UInt       first = 0, next, n;
+      PSH2_Point    points  = glyph->points;
+      PSH2_Contour  contour = glyph->contours;
+      
+      for ( n = 0; n < glyph->num_contours; n++ )
+      {
+        FT_Int      count;
+        PSH2_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;
+      }
+    }
+
+    {
+      PSH2_Point  points = glyph->points;
+      PSH2_Point  point  = points;
+      FT_Vector*  vec    = outline->points;
+      FT_UInt     n;
+      
+      for ( n = 0; n < glyph->num_points; n++, point++ )
+      {
+        FT_Int    n_prev = point->prev - points;
+        FT_Int    n_next = point->next - points;
+        FT_Pos    dxi, dyi, dxo, dyo;
+        
+        if ( !(outline->tags[n] & FT_Curve_Tag_On) )
+          point->flags = PSH2_POINT_OFF;
+        
+        dxi = vec[n].x - vec[n_prev].x;
+        dyi = vec[n].y - vec[n_prev].y;
+        
+        point->dir_in    = psh2_compute_dir( dxi, dyi );
+
+        dxo = vec[n_next].x - vec[n].x;
+        dyo = vec[n_next].y - vec[n].y;
+
+        point->dir_out   = psh2_compute_dir( dxo, dyo );
+        
+        /* detect smooth points */
+        if ( point->flags & PSH2_POINT_OFF )
+        {
+          point->flags |= PSH2_POINT_SMOOTH;
+        }
+        else if ( point->dir_in  != PSH2_DIR_NONE ||
+                  point->dir_out != PSH2_DIR_NONE )
+        {
+          if ( point->dir_in == point->dir_out )
+            point->flags |= PSH2_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 |= PSH2_POINT_SMOOTH;
+        }
+      }
+    }
+
+    glyph->memory  = memory;
+    glyph->outline = outline;
+    glyph->globals = globals;
+
+    /* now deal with hints tables */
+    error = psh2_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 = psh2_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;
+  }
+
+
+ /* load outline point coordinates into hinter glyph */
+  static void
+  psh2_glyph_load_points( PSH2_Glyph  glyph,
+                          FT_Bool     vertical )
+  {
+    FT_Vector*  vec   = glyph->outline->points;
+    PSH2_Point  point = glyph->points;
+    FT_UInt     count = glyph->num_points;
+
+    for ( ; count > 0; count--, point++, vec++ )
+    {
+      point->flags &= PSH2_POINT_OFF | PSH2_POINT_SMOOTH;
+      point->hint   = 0;
+      if (vertical)
+        point->org_u = vec->x;
+      else
+        point->org_u = vec->y;
+        
+#ifdef DEBUG_HINTER
+      point->org_x  = vec->x;
+      point->org_y  = vec->y;
+#endif        
+    }
+  }
+
+  
+ /* save hinted point coordinates back to outline */
+  static void
+  psh2_glyph_save_points( PSH2_Glyph  glyph,
+                          FT_Bool     vertical )
+  {
+    FT_UInt     n;
+    PSH2_Point  point = glyph->points;
+    FT_Vector*  vec   = glyph->outline->points;
+    char*       tags  = glyph->outline->tags;
+    
+    for ( n = 0; n < glyph->num_points; n++ )
+    { 
+      if (vertical)
+        vec[n].x = point->cur_u;
+      else
+        vec[n].y = point->cur_u;
+      
+      if ( psh2_point_is_strong(point) )
+        tags[n] |= vertical ? 32 : 64;
+
+#ifdef DEBUG_HINTER
+      if (vertical)
+      {
+        point->cur_x   = point->cur_u;
+        point->flags_x = point->flags;
+      }
+      else
+      {
+        point->cur_y   = point->cur_u;
+        point->flags_y = point->flags;
+      }
+#endif            
+      point++;
+    }
+  }
+
+
+  static void
+  psh2_hint_table_find_strong_point( PSH2_Hint_Table  table,
+                                     PSH2_Point       point,
+                                     FT_Int           major_dir )
+  {
+    PSH2_Hint*   sort      = table->sort;
+    FT_UInt      num_hints = table->num_hints;
+    
+    for ( ; num_hints > 0; num_hints--, sort++ )
+    {
+      PSH2_Hint  hint = sort[0];
+      
+      if ( ABS(point->dir_in)  == major_dir ||
+           ABS(point->dir_out) == major_dir )
+      {
+        FT_Pos  d;
+        
+        d = point->org_u - hint->org_pos;
+        if ( ABS(d) < 3 )
+        {
+        Is_Strong:
+          psh2_point_set_strong(point);
+          point->hint = hint;
+          break;
+        }
+        
+        d -= hint->org_len;
+        if ( ABS(d) < 3 )
+          goto Is_Strong;
+      }
+
+#if 1              
+      if ( point->org_u >= hint->org_pos &&
+           point->org_u <= hint->org_pos + hint->org_len &&
+           psh2_point_is_extremum( point ) )
+      {
+        /* attach to hint, but don't mark as strong */
+        point->hint = hint;
+        break;
+      }
+#endif                
+    }
+  }
+                                        
+                                         
+
+ /* find strong points in a glyph */
+  static void
+  psh2_glyph_find_strong_points( PSH2_Glyph  glyph,
+                                 FT_Bool     vertical )
+  {
+    /* a point is strong if it is located on a stem                   */
+    /* edge and has an "in" or "out" tangent to the hint's direction  */
+    {
+      PSH2_Hint_Table  table     = &glyph->hint_tables[vertical];
+      PS_Mask          mask      = table->hint_masks->masks;
+      FT_UInt          num_masks = table->hint_masks->num_masks;
+      FT_UInt          first     = 0;
+      FT_Int           major_dir = vertical ? PSH2_DIR_UP    : PSH2_DIR_RIGHT;
+      FT_Int           minor_dir = vertical ? PSH2_DIR_RIGHT : PSH2_DIR_UP;
+      
+      /* process secondary hints to "selected" points */
+      if ( num_masks > 1 )
+      {
+        mask++;
+        for ( ; num_masks > 1; num_masks--, mask++ )
+        {
+          FT_UInt  next;
+          FT_Int   count;
+          
+          next  = mask->end_point;
+          count = next - first;
+          if ( count > 0 )
+          {
+            PSH2_Point  point = glyph->points + first;
+            
+            psh2_hint_table_activate_mask( table, mask );
+            
+            for ( ; count > 0; count--, point++ )
+              psh2_hint_table_find_strong_point( table, point, major_dir );
+          }
+          first = next;
+        }
+      }
+      
+      /* process primary hints for all points */
+      if ( num_masks == 1 )
+      {
+        FT_UInt     count = glyph->num_points;
+        PSH2_Point  point = glyph->points;
+        
+        psh2_hint_table_activate_mask( table, table->hint_masks->masks );
+        for ( ; count > 0; count--, point++ )
+        {
+          if ( !psh2_point_is_strong(point) )
+            psh2_hint_table_find_strong_point( table, point, major_dir );
+        }
+      }
+      
+      /* now, certain points may have been attached to hint and */
+      /* not marked as strong, update their flags then..        */
+      {
+        FT_UInt  count = glyph->num_points;
+        PSH2_Point  point = glyph->points;
+        
+        for ( ; count > 0; count--, point++ )
+          if ( point->hint && !psh2_point_is_strong(point) )
+            psh2_point_set_strong(point);
+      }
+    }
+  }
+
+
+
+ /* interpolate strong points with the help of hinted coordinates */
+  static void
+  psh2_glyph_interpolate_strong_points( PSH2_Glyph  glyph,
+                                        FT_Bool     vertical )
+  {
+    PSH_Dimension    dim   = &glyph->globals->dimension[vertical];
+    FT_Fixed         scale = dim->scale_mult;
+    FT_Fixed         delta = dim->scale_delta;
+
+    {
+      FT_UInt     count = glyph->num_points;
+      PSH2_Point  point = glyph->points;
+      
+      for ( ; count > 0; count--, point++ )
+      {
+        PSH2_Hint  hint = point->hint;
+        
+        if ( hint )
+        {
+          FT_Pos  delta;
+          
+          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;
+          
+          psh2_point_set_fitted(point);
+        } 
+      }
+    }
+  }
+
+
+  static void
+  psh2_glyph_interpolate_normal_points( PSH2_Glyph  glyph,
+                                        FT_Bool     vertical )
+  {
+#if 1
+    PSH_Dimension    dim   = &glyph->globals->dimension[vertical];
+    FT_Fixed         scale = dim->scale_mult;
+
+    /* first technique: a point is strong if it is a local extrema */
+    {
+      FT_UInt     count = glyph->num_points;
+      PSH2_Point  point = glyph->points;
+      
+      for ( ; count > 0; count--, point++ )
+      {
+        if ( psh2_point_is_strong(point) )
+          continue;
+          
+        /* sometimes, some local extremas are smooth points */
+        if ( psh2_point_is_smooth(point) )
+        {
+          if ( point->dir_in == PSH2_DIR_NONE  ||
+               point->dir_in != point->dir_out )
+            continue;
+            
+          if ( !psh2_point_is_extremum( point ) )
+            continue;
+            
+          point->flags &= ~PSH2_POINT_SMOOTH;
+        }
+          
+        /* find best enclosing point coordinates */
+        {
+          PSH2_Point  before = 0;
+          PSH2_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;
+          PSH2_Point  cur    = glyph->points;
+          
+          for ( ; count2 > 0; count2--, cur++ )
+          {
+            if ( psh2_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're 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're 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 );
+          }
+          
+          psh2_point_set_fitted(point);
+        }
+      }
+    }
+#endif    
+  }  
+
+
+
+ /* interpolate other points */
+  static void
+  psh2_glyph_interpolate_other_points( PSH2_Glyph  glyph,
+                                       FT_Bool     vertical )
+  {
+    PSH_Dimension dim          = &glyph->globals->dimension[vertical];
+    FT_Fixed      scale        = dim->scale_mult;
+    FT_Fixed      delta        = dim->scale_delta;
+    PSH2_Contour  contour      = glyph->contours;
+    FT_UInt       num_contours = glyph->num_contours;
+    
+    for ( ; num_contours > 0; num_contours--, contour++ )
+    {
+      PSH2_Point   start = contour->start;
+      PSH2_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 ( psh2_point_is_fitted(point) )
+        {
+          if ( !first )
+            first = point;
+            
+          fit_count++;
+        }
+      
+      /* if there is less than 2 fitted points in the contour, we'll */
+      /* 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'll */
+      /* 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 ( !psh2_point_is_fitted(next) )
+            break;
+            
+          first = next;
+        }
+        
+        /* find next fitted point after unfitted one */
+        for (;;)
+        {
+          next = next->next;
+          if ( psh2_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
+  ps2_hints_apply( PS_Hints     ps_hints,
+                   FT_Outline*  outline,
+                   PSH_Globals  globals )
+  {
+    PSH2_Glyph     glyph;
+    PSH2_GlyphRec  glyphrec;
+    FT_Error       error;
+    FT_Memory      memory;
+    FT_Int         dimension;
+
+    memory = globals->memory;
+
+#ifdef DEBUG_HINTER
+    if ( ps2_debug_glyph )
+    {
+      psh2_glyph_done( ps2_debug_glyph );
+      FREE( ps2_debug_glyph );
+    }
+    
+    if ( ALLOC( glyph, sizeof(*glyph) ) )
+      return error;
+      
+    ps2_debug_glyph = glyph;
+#else 
+    glyph = &glyphrec;    
+#endif
+    
+    error = psh2_glyph_init( glyph, outline, ps_hints, globals );
+    if (error) goto Exit;
+    
+    for ( dimension = 1; dimension >= 0; dimension-- )
+    {
+      /* load outline coordinates into glyph */
+      psh2_glyph_load_points( glyph, dimension );
+      
+      /* compute aligned stem/hints positions */
+      psh2_hint_table_align_hints( &glyph->hint_tables[dimension],
+                                   glyph->globals,
+                                   dimension );
+
+      /* find strong points, align them, then interpolate others */
+      psh2_glyph_find_strong_points( glyph, dimension );
+      psh2_glyph_interpolate_strong_points( glyph, dimension );
+      psh2_glyph_interpolate_normal_points( glyph, dimension );
+      psh2_glyph_interpolate_other_points( glyph, dimension );
+      
+      /* save hinted coordinates back to outline */
+      psh2_glyph_save_points( glyph, dimension );
+    }
+    
+  Exit:    
+#ifndef DEBUG_HINTER  
+    psh2_glyph_done( glyph );
+#endif
+    return error;
+  }
diff --git a/src/pshinter/pshalgo2.h b/src/pshinter/pshalgo2.h
new file mode 100644
index 0000000..575712c
--- /dev/null
+++ b/src/pshinter/pshalgo2.h
@@ -0,0 +1,185 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshalgo2.h                                                             */
+/*                                                                         */
+/*    First (basic) Postscript hinting routines                            */
+/*                                                                         */
+/*  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 __PS_HINTER_ALGO2_H__
+#define __PS_HINTER_ALGO2_H__
+
+#include "pshrec.h"
+#include "pshglob.h"
+#include FT_TRIGONOMETRY_H
+
+FT_BEGIN_HEADER
+
+  typedef struct PSH2_HintRec_*   PSH2_Hint;
+
+  typedef enum
+  {
+    PSH2_HINT_GHOST  = PS_HINT_FLAG_GHOST,
+    PSH2_HINT_BOTTOM = PS_HINT_FLAG_BOTTOM,
+    PSH2_HINT_ACTIVE = 4,
+    PSH2_HINT_FITTED = 8  
+  } PSH2_Hint_Flags;
+
+#define  psh2_hint_is_active(x)  (((x)->flags  & PSH2_HINT_ACTIVE) != 0)
+#define  psh2_hint_is_ghost(x)   (((x)->flags  & PSH2_HINT_GHOST)  != 0)  
+#define  psh2_hint_is_fitted(x)  (((x)->flags  & PSH2_HINT_FITTED) != 0)
+
+#define  psh2_hint_activate(x)     (x)->flags |=  PSH2_HINT_ACTIVE
+#define  psh2_hint_deactivate(x)   (x)->flags &= ~PSH2_HINT_ACTIVE
+#define  psh2_hint_set_fitted(x)   (x)->flags |=  PSH2_HINT_FITTED
+
+  typedef struct PSH2_HintRec_
+  {
+    FT_Int     org_pos;
+    FT_Int     org_len;
+    FT_Pos     cur_pos;
+    FT_Pos     cur_len;
+    FT_UInt    flags;
+    PSH2_Hint  parent;
+    FT_Int     order;
+  
+  } PSH2_HintRec;
+
+
+ /* this is an interpolation zone used for strong points   */
+ /* weak points are interpolated according to their strong */
+ /* neighbours..                                           */
+  typedef struct PSH2_ZoneRec_
+  {
+    FT_Fixed  scale;
+    FT_Fixed  delta;
+    FT_Pos    min;
+    FT_Pos    max;
+    
+  } PSH2_ZoneRec, *PSH2_Zone;
+
+
+  typedef struct PSH2_Hint_TableRec_
+  {
+    FT_UInt        max_hints;
+    FT_UInt        num_hints;
+    PSH2_Hint      hints;
+    PSH2_Hint*     sort;
+    PSH2_Hint*     sort_global;
+    FT_UInt        num_zones;
+    PSH2_Zone      zones;
+    PSH2_Zone      zone;
+    PS_Mask_Table  hint_masks;
+    PS_Mask_Table  counter_masks;
+    
+  } PSH2_Hint_TableRec, *PSH2_Hint_Table;
+
+  typedef struct PSH2_PointRec_*    PSH2_Point;
+  typedef struct PSH2_ContourRec_*  PSH2_Contour;
+  
+  enum
+  {
+    PSH2_DIR_NONE   =  4,
+    PSH2_DIR_UP     =  1,
+    PSH2_DIR_DOWN   = -1,
+    PSH2_DIR_LEFT   = -2,
+    PSH2_DIR_RIGHT  =  2
+  };
+  
+  enum
+  {
+    PSH2_POINT_OFF    = 1,   /* point is off the curve  */
+    PSH2_POINT_STRONG = 2,   /* point is strong         */
+    PSH2_POINT_SMOOTH = 4,   /* point is smooth         */
+    PSH2_POINT_FITTED = 8    /* point is already fitted */
+  };
+
+
+  typedef struct PSH2_PointRec_
+  {
+    PSH2_Point    prev;
+    PSH2_Point    next;
+    PSH2_Contour  contour;
+    FT_UInt       flags;
+    FT_Char       dir_in;
+    FT_Char       dir_out;
+    FT_Angle      angle_in;
+    FT_Angle      angle_out;
+    PSH2_Hint     hint;
+    FT_Pos        org_u;
+    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    
+    
+  } PSH2_PointRec;
+
+#define  psh2_point_is_strong(p)   ((p)->flags & PSH2_POINT_STRONG)
+#define  psh2_point_is_fitted(p)   ((p)->flags & PSH2_POINT_FITTED)
+#define  psh2_point_is_smooth(p)   ((p)->flags & PSH2_POINT_SMOOTH)
+
+#define  psh2_point_set_strong(p)  (p)->flags |= PSH2_POINT_STRONG
+#define  psh2_point_set_fitted(p)  (p)->flags |= PSH2_POINT_FITTED
+#define  psh2_point_set_smooth(p)  (p)->flags |= PSH2_POINT_SMOOTH
+
+  typedef struct PSH2_ContourRec_
+  {
+    PSH2_Point  start;
+    FT_UInt     count;
+   
+  } PSH2_ContourRec;
+
+  
+
+  typedef struct PSH2_GlyphRec_
+  {
+    FT_UInt             num_points;
+    FT_UInt             num_contours;
+    
+    PSH2_Point          points;
+    PSH2_Contour        contours;
+               
+    FT_Memory           memory;
+    FT_Outline*         outline;
+    PSH_Globals         globals;
+    PSH2_Hint_TableRec  hint_tables[2];
+    
+    FT_Bool             vertical;
+    FT_Int              major_dir;
+    FT_Int              minor_dir;
+    
+  } PSH2_GlyphRec, *PSH2_Glyph;
+
+
+#ifdef DEBUG_HINTER  
+  extern  PSH2_Hint_Table  ps2_debug_hint_table;
+
+  typedef void  (*PSH2_HintFunc)( PSH2_Hint  hint, FT_Bool vertical );
+  extern  PSH2_HintFunc    ps2_debug_hint_func;
+  
+  extern  PSH2_Glyph       ps2_debug_glyph;
+#endif
+
+
+  extern FT_Error
+  ps2_hints_apply( PS_Hints      ps_hints,
+                   FT_Outline*   outline,
+                   PSH_Globals   globals );
+
+FT_END_HEADER
+
+#endif /* __PS_HINTS_ALGO_2_H__ */
diff --git a/src/pshinter/pshfit.c b/src/pshinter/pshfit.c
deleted file mode 100644
index 1f9a70b..0000000
--- a/src/pshinter/pshfit.c
+++ /dev/null
@@ -1,555 +0,0 @@
-#include <ft2build.h>
-#include FT_INTERNAL_OBJECTS_H
-#include FT_INTERNAL_DEBUG_H
-#include "pshfit.h"
-#include "pshoptim.h"
- 
- /* return true iff 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 )
-  {
-    FREE( table->zones );
-    table->num_zones = 0;
-    table->zone      = 0;
-    
-    FREE( table->sort );
-    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 used to record a new hint */
-  static void
-  psh_hint_table_record( PSH_Hint_Table  table,
-                         FT_UInt         index )
-  {
-    PSH_Hint  hint = table->hints + index;
-
-    if ( index >= table->max_hints )
-    {
-      FT_ERROR(( "%s.activate: invalid hint index %d\n", index ));
-      return;
-    }
-        
-    /* ignore active hints */
-    if ( psh_hint_is_active(hint) )
-      return;
-    
-    psh_hint_activate(hint);
-    
-    /* now scan the current active hint set in order to determine */
-    /* if we're overlapping with another segment..                */
-    {
-      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(( "%s.activate: too many sorted hints !! BUG !!\n",
-                 "ps.fitter" ));
-    }
-  }
-
-
-  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   index, limit;
-
-    limit = hint_mask->num_bits; 
-    
-    if ( limit != table->max_hints )
-    {
-      FT_ERROR(( "%s.activate_mask: invalid bit count (%d instead of %d)\n",
-                 "ps.fitter", hint_mask->num_bits, table->max_hints ));
-    }
-        
-    for ( index = 0; index < limit; index++ )
-    {
-      if ( mask == 0 )
-      {
-        val  = *cursor++;
-        mask = 0x80;
-      }
-      
-      if ( val & mask )
-        psh_hint_table_record( table, index );
-        
-      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 = hints->num_hints;
-    FT_Error  error;
-
-    FT_UNUSED(counter_masks);
-    
-    /* allocate our tables */
-    if ( ALLOC_ARRAY( table->sort,  2*count,   PSH_Hint    ) ||
-         ALLOC_ARRAY( table->hints,   count,   PSH_HintRec ) ||
-         ALLOC_ARRAY( table->zones, 2*count+1, PSH_ZoneRec ) )
-      goto Exit;
-    
-    table->max_hints   = count;
-    table->sort_global = table->sort + count;
-    table->num_hints   = 0;
-    table->num_zones   = 0;
-    table->zone        = 0;
-    
-    /* now, initialise the "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 )
-    {
-      FT_UInt  count = hint_masks->num_masks;
-      PS_Mask  mask  = hint_masks->masks;
-
-      table->hint_masks = hint_masks;
-      
-      for ( ; count > 0; count--, mask++ )
-        psh_hint_table_record_mask( table, mask );
-    }
-    
-    /* now, do a linear parse in case some hints were left alone */
-    if ( table->num_hints != table->max_hints )
-    {
-      FT_UInt   index, count;
-      
-      FT_ERROR(( "%s.init: missing/incorrect hint masks !!\n" ));
-      count = table->max_hints;
-      for ( index = 0; index < count; index++ )
-        psh_hint_table_record( table, index );
-    }    
-    
-  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   index, limit, count;
-
-    limit = hint_mask->num_bits; 
-    count = 0;
-
-    psh_hint_table_deactivate( table );
-    
-    for ( index = 0; index < limit; index++ )
-    {
-      if ( mask == 0 )
-      {
-        val  = *cursor++;
-        mask = 0x80;
-      }
-      
-      if ( val & mask )
-      {
-        PSH_Hint  hint = &table->hints[index];
-        
-        if ( !psh_hint_is_active(hint) )
-        {
-          PSH_Hint*  sort   = table->sort;
-          FT_UInt    count2;
-          PSH_Hint   hint2;
-          
-          for ( count2 = count; count2 > 0; count2--, sort++ )
-          {
-            hint2 = sort[0];
-            if ( psh_hint_overlap( hint, hint2 ) )
-            {
-              FT_ERROR(( "%s.activate_mask: found overlapping hints\n",
-                         "psf.hint" ));
-              break;
-            }
-          }
-          
-          if ( count2 == 0 )
-          {
-            psh_hint_activate( hint );
-            if ( count < table->max_hints )
-              table->sort[count++] = hint;
-            else
-            {
-              FT_ERROR(( "%s.activate_mask: too many active hints\n",
-                         "psf.hint" ));
-            } 
-          }
-        }
-      }
-        
-      mask >>= 1;
-    }
-    table->num_hints = count;
-    
-    /* now, sort the hints, they're 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[i1] = hint2;
-          sort[i2] = hint1;
-        }
-      }
-    }
-  }
-
-
-#define  PSH_ZONE_MIN  -3200000
-#define  PSH_ZONE_MAX  +3200000
-
-
-#define xxDEBUG_ZONES
-
-#ifdef DEBUG_ZONES
-
-#include <stdio.h>
-
-  static void
-  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  print_zone(x)   do { } while (0)
-#endif
-
- /* setup interpolation zones once the hints have been grid-fitted */
- /* by the optimizer..                                             */
-  static void
-  psh_hint_table_setup_zones( PSH_Hint_Table  table,
-                              FT_Fixed        scale,
-                              FT_Fixed        delta )
-  {
-    FT_UInt   count;
-    PSH_Zone  zone;
-    PSH_Hint *sort, hint, hint2;
-    
-    zone  = table->zones;
-    
-    /* special case, no hints defined */
-    if ( table->num_hints == 0 )
-    {
-      zone->scale = scale;
-      zone->delta = delta;
-      zone->min   = PSH_ZONE_MIN;
-      zone->max   = PSH_ZONE_MAX;
-      table->num_zones = 1;
-      return;
-    }
-    
-    /* the first zone is before the first hint */
-    /* x' = (x-x0)*s + x0' = x*s + ( x0' - x0*s ) */
-    sort  = table->sort;
-    hint  = sort[0];
-    
-    zone->scale = scale;
-    zone->delta = hint->cur_pos - FT_MulFix( hint->org_pos, scale );
-    zone->min   = PSH_ZONE_MIN;
-    zone->max   = hint->org_pos;
-    
-    print_zone( zone );
-    
-    zone++;
-    
-    for ( count = table->num_hints; count > 0; count-- )
-    {
-      FT_Fixed  scale2;
-
-      if ( hint->org_len > 0 )
-      {
-        /* setup a zone for inner-stem interpolation */
-        /* (x' - x0') = (x - x0)*(x1'-x0')/(x1-x0)   */
-        /* x' = x*s2 + x0' - x0*s2                   */
-        
-        scale2      = FT_DivFix( hint->cur_len, hint->org_len );
-        zone->scale = scale2;
-        zone->min   = hint->org_pos;
-        zone->max   = hint->org_pos + hint->org_len;
-        zone->delta = hint->cur_pos - FT_MulFix( zone->min, scale2 );
-
-        print_zone( zone );
-    
-        zone++;
-      }
-      
-      if ( count == 1 )
-        break;
-        
-      sort++;
-      hint2 = sort[0];
-      
-      /* setup zone for inter-stem interpolation */
-      /* (x'-x1') = (x-x1)*(x2'-x1')/(x2-x1)     */
-      /* x' = x*s3 + x1' - x1*s3                 */
-      scale2 = FT_DivFix( hint2->cur_pos - (hint->cur_pos + hint->cur_len),
-                          hint2->org_pos - (hint->org_pos + hint->org_len) );
-      zone->scale = scale2;
-      zone->min   = hint->org_pos + hint->org_len;
-      zone->max   = hint2->org_pos;
-      zone->delta = hint->cur_pos + hint->cur_len - FT_MulFix( zone->min, scale2 );
-
-      print_zone( zone );
-    
-      zone++;
-      
-      hint  = hint2;
-    }
-
-    /* the last zone */
-    zone->scale = scale;
-    zone->min   = hint->org_pos + hint->org_len;
-    zone->max   = PSH_ZONE_MAX;
-    zone->delta = hint->cur_pos + hint->cur_len - FT_MulFix( zone->min, scale );
-
-    print_zone( zone );
-    
-    zone++;
-    
-    table->num_zones = zone - table->zones;
-    table->zone      = table->zones;
-  }
-
-
- /* tune a single coordinate with the current interpolation zones */  
-  static FT_Pos
-  psh_hint_table_tune_coord( PSH_Hint_Table  table,
-                             FT_Int          coord )
-  {
-    PSH_Zone   zone;
-    
-    zone = table->zone;
-      
-    if ( coord < zone->min )
-    {
-      do
-      {
-        if ( zone == table->zones )
-          break;
-          
-        zone--;
-      }
-      while ( coord < zone->min );
-      table->zone = zone;
-    }
-    else if ( coord > zone->max )
-    {
-      do
-      {
-        if ( zone == table->zones + table->num_zones - 1 )
-          break;
-          
-        zone++;
-      }
-      while ( coord > zone->max );
-      table->zone = zone;
-    }
-        
-    return FT_MulFix( coord, zone->scale ) + zone->delta;
-  }
-
-
- /* tune a given outline with current interpolation zones */
- /* the function only works in a single dimension..       */
-  static void
-  psh_hint_table_tune_outline( PSH_Hint_Table  table,
-                               FT_Outline*     outline,
-                               PSH_Globals     globals,
-                               FT_Bool         vertical )
-
-  {
-    FT_UInt        count, first, last;
-    PS_Mask_Table  hint_masks = table->hint_masks;
-    PS_Mask        mask;
-    PSH_Dimension  dim        = &globals->dimension[vertical];
-    FT_Fixed       scale      = dim->scale_mult;
-    FT_Fixed       delta      = dim->scale_delta;
-    
-    if ( hint_masks && hint_masks->num_masks > 0 )
-    {
-      first = 0;
-      mask  = hint_masks->masks;
-      count = hint_masks->num_masks;
-      for ( ; count > 0; count--, mask++ )
-      {
-        last = mask->end_point;
-        
-        if ( last > first )
-        {
-          FT_Vector*   vec;
-          FT_Int       count2;
-          
-          psh_hint_table_activate_mask( table, mask );
-          psh_hint_table_optimize( table, globals, outline, vertical );
-          psh_hint_table_setup_zones( table, scale, delta );
-          last = mask->end_point;
-          
-          vec    = outline->points + first;
-          count2 = last - first;
-          for ( ; count2 > 0; count2--, vec++ )
-          {
-            FT_Pos  x, *px;
-            
-            px  = vertical ? &vec->x : &vec->y;
-            x   = *px;
-            
-            *px = psh_hint_table_tune_coord( table, (FT_Int)x );
-          }
-        }
-          
-        first = last;
-      }
-    }
-    else    /* no hints in this glyph, simply scale the outline */
-    {
-      FT_Vector*  vec;
-      
-      vec   = outline->points;
-      count = outline->n_points;
-      
-      if ( vertical )
-      {
-        for ( ; count > 0; count--, vec++ )
-          vec->x = FT_MulFix( vec->x, scale ) + delta;
-      }
-      else
-      {
-        for ( ; count > 0; count--, vec++ )
-          vec->y = FT_MulFix( vec->y, scale ) + delta;
-      }
-    }
-  }
-  
-  
-  
-
-
-  
-  
-  
-  
-  
-  FT_LOCAL_DEF FT_Error
-  ps_hints_apply( PS_Hints     ps_hints,
-                  FT_Outline*  outline,
-                  PSH_Globals  globals )
-  {
-    PSH_Hint_TableRec  hints;
-    FT_Error           error;
-    FT_Int             dimension;
-    
-    for ( dimension = 1; dimension >= 0; dimension-- )
-    {
-      PS_Dimension  dim = &ps_hints->dimension[dimension];
-      
-      /* initialise hints table */
-      memset( &hints, 0, sizeof(hints) );
-      error = psh_hint_table_init( &hints,
-                                   &dim->hints,
-                                   &dim->masks,
-                                   &dim->counters,
-                                   ps_hints->memory );
-      if (error) goto Exit;
-      
-      psh_hint_table_tune_outline( &hints,
-                                   outline,
-                                   globals,
-                                   dimension );
-                                   
-      psh_hint_table_done( &hints, ps_hints->memory );
-    }
-    
-  Exit:
-    return error;                                   
-  }                   
\ No newline at end of file
diff --git a/src/pshinter/pshfit.h b/src/pshinter/pshfit.h
deleted file mode 100644
index 22b8537..0000000
--- a/src/pshinter/pshfit.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/***************************************************************************/
-/*                                                                         */
-/*  pshfit.h                                                               */
-/*                                                                         */
-/*    Postscript (Type 1/CFF) outline grid-fitter                          */
-/*                                                                         */
-/*  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.                                        */
-/*                                                                         */
-/*                                                                         */
-/*  process the hints provided by the Postscript hints recorder. This      */
-/*  means sorting and scaling the hints, calling the "optimiser" to        */
-/*  process them, then grid-fitting the glyph outline based on the         */
-/*  optimised hints information.                                           */
-/*                                                                         */
-/*  (the real hinting "intelligence" is in "pshoptim.h", not here)         */
-/*                                                                         */
-/***************************************************************************/
-
-#ifndef __PS_HINTER_FITTER_H__
-#define __PS_HINTER_FITTER_H__
-
-#include "pshrec.h"
-
-FT_BEGIN_HEADER
-
-  typedef struct PSH_HintRec_*   PSH_Hint;
-
-  typedef enum
-  {
-    PSH_HINT_FLAG_GHOST  = PS_HINT_FLAG_GHOST,
-    PSH_HINT_FLAG_BOTTOM = PS_HINT_FLAG_BOTTOM,
-    PSH_HINT_FLAG_ACTIVE = 4
-  
-  } PSH_Hint_Flags;
-
-#define  psh_hint_is_active(x)  (((x)->flags  & PSH_HINT_FLAG_ACTIVE) != 0)
-#define  psh_hint_is_ghost(x)   (((x)->flags  & PSH_HINT_FLAG_GHOST ) != 0)  
-
-#define  psh_hint_activate(x)     (x)->flags |= PSH_HINT_FLAG_ACTIVE
-#define  psh_hint_deactivate(x)   (x)->flags &= ~PSH_HINT_FLAG_ACTIVE
-
-  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_Zone       zones;
-    PSH_Zone       zone;
-    PS_Mask_Table  hint_masks;
-    PS_Mask_Table  counter_masks;
-    
-  } PSH_Hint_TableRec, *PSH_Hint_Table;
-
-
-  FT_LOCAL FT_Error
-  ps_hints_apply( PS_Hints     ps_hints,
-                  FT_Outline*  outline,
-                  PSH_Globals  globals );
-
-
-#ifdef DEBUG_VIEW
-  extern  int             ps_debug_no_horz_hints;
-  extern  int             ps_debug_no_vert_hints;
-  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;
-#endif
-
-FT_END_HEADER
-
-#endif /* __PS_HINTER_FITTER_H__ */
diff --git a/src/pshinter/pshglob.c b/src/pshinter/pshglob.c
index 02c2e14..3dfdd24 100644
--- a/src/pshinter/pshglob.c
+++ b/src/pshinter/pshglob.c
@@ -3,6 +3,10 @@
 #include FT_INTERNAL_OBJECTS_H
 #include "pshglob.h"
 
+#ifdef DEBUG_HINTER
+  extern PSH_Globals   ps_debug_globals = 0;
+#endif  
+
 /* "simple" ps hinter globals management, inspired from the new auto-hinter */
 
  /*************************************************************************/
@@ -87,6 +91,7 @@
 
   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,
@@ -94,26 +99,34 @@
   {
     FT_UInt    count_top = top_table->count;
     FT_UInt    count_bot = bot_table->count;
+    FT_Bool    first     = 1;
     
     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 */
-      reference = read[0];
-      delta     = read[1] - reference;
-      
-      if ( delta >= 0 )
+      top = 0;
+      if ( first || is_others )
       {
-        zones = top_table->zones;
-        count = count_top;
+        reference = read[1];
+        delta     = read[0] - reference;
+
+        zones = bot_table->zones;
+        count = count_bot;
+        first = 0;
       }
       else
       {
-        zones = bot_table->zones;
-        count = count_bot;
+        reference = read[0];
+        delta     = read[1] - reference;
+      
+        zones = top_table->zones;
+        count = count_top;
+        top   = 1;
       }
       
       /* insert into sorted table */
@@ -149,7 +162,7 @@
       zone->org_ref   = reference;
       zone->org_delta = delta;
       
-      if ( delta >= 0 )
+      if ( top )
         count_top ++;
       else
         count_bot ++;
@@ -195,8 +208,8 @@
     bot_table->count = 0;
     
     /* first, the blues */
-    psh_blues_set_zones_0( target, count, blues, top_table, bot_table );
-    psh_blues_set_zones_0( target, count_others, other_blues, top_table, bot_table );
+    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;
@@ -206,13 +219,16 @@
     {
       PSH_Blue_Zone  zone = top_table->zones;
       
-      for ( count = count_top-1; count > 0; count--, zone++ )
+      for ( count = count_top; count > 0; count--, zone++ )
       {
         FT_Int  delta;
-      
-        delta = zone[1].org_ref - zone[0].org_ref;
-        if ( zone->org_delta > delta )
-          zone->org_delta = 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;
@@ -224,13 +240,16 @@
     {
       PSH_Blue_Zone  zone = bot_table->zones;
 
-      for ( count = count_bot-1; count > 0; count--, zone++ )
+      for ( count = count_bot; count > 0; count--, zone++ )
       {
         FT_Int  delta;
         
-        delta = zone[0].org_ref - zone[1].org_ref;
-        if ( zone->org_delta < delta )
-          zone->org_delta = 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;
@@ -256,7 +275,7 @@
           /* checking that the interval is smaller than the fuzz */
           top = zone->org_top;
           
-          for ( count--; count > 0; count--, zone++ )
+          for ( count--; count > 0; count-- )
           {
             bot   = zone[1].org_bottom;
             delta = bot - top;
@@ -318,6 +337,13 @@
         
         /* round scaled reference position */
         zone->cur_ref = ( zone->cur_ref + 32 ) & -64;
+
+#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          
       }
     }
     
@@ -326,10 +352,10 @@
 
 
   FT_LOCAL_DEF void
-  psh_blues_snap_stem( PSH_Blues            blues,
-                       FT_Int               stem_top,
-                       FT_Int               stem_bot,
-                       PSH_Blue_Alignement  alignment )
+  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;
@@ -341,7 +367,7 @@
     table = &blues->normal_top;
     count = table->count;
     zone  = table->zones;
-    for ( ; count > 0; count-- )
+    for ( ; count > 0; count--, zone++ )
     {
       if ( stem_top < zone->org_bottom )
         break;
@@ -358,7 +384,7 @@
     table = &blues->normal_bottom;
     count = table->count;
     zone  = table->zones;
-    for ( ; count > 0; count-- )
+    for ( ; count > 0; count--, zone++ )
     {
       if ( stem_bot < zone->org_bottom )
         break;
@@ -367,6 +393,7 @@
       {
         alignment->align    |= PSH_BLUE_ALIGN_BOT;
         alignment->align_bot = zone->cur_ref;
+        break;
       }
     }
   }
@@ -397,6 +424,10 @@
       globals->blues.family_bottom.count = 0;
       
       FREE( globals );
+
+#ifdef DEBUG_HINTER
+      ps_debug_globals = 0;
+#endif      
     }
   }
 
@@ -467,6 +498,10 @@
       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;
diff --git a/src/pshinter/pshglob.h b/src/pshinter/pshglob.h
index 6fdda05..dae74b4 100644
--- a/src/pshinter/pshglob.h
+++ b/src/pshinter/pshglob.h
@@ -141,7 +141,7 @@
     FT_Pos           align_top;
     FT_Pos           align_bot;
     
-  } PSH_Blue_AlignementRec, *PSH_Blue_Alignement;
+  } PSH_AlignmentRec, *PSH_Alignment;
 
 
   FT_LOCAL void
@@ -156,12 +156,15 @@
 
  /* 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_Blue_Alignement  alignment );
+  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
 
diff --git a/src/pshinter/pshinter.c b/src/pshinter/pshinter.c
index 592cda3..07c6330 100644
--- a/src/pshinter/pshinter.c
+++ b/src/pshinter/pshinter.c
@@ -21,8 +21,9 @@
 #include <ft2build.h>
 #include "pshrec.c"  
 #include "pshglob.c"
-#include "pshfit.c"
+#include "pshalgo1.c" 
+#include "pshalgo2.c"
 #include "pshmod.c"
-#include "pshoptim.c"
+
 
 /* END */
diff --git a/src/pshinter/pshmod.c b/src/pshinter/pshmod.c
index 2838400..65b360d 100644
--- a/src/pshinter/pshmod.c
+++ b/src/pshinter/pshmod.c
@@ -18,6 +18,7 @@
 #include <ft2build.h>
 #include FT_INTERNAL_OBJECTS_H
 #include "pshrec.h"
+#include "pshalgo.h"
 
  /* the Postscript Hinter module structure */
   typedef struct
diff --git a/src/pshinter/pshoptim.c b/src/pshinter/pshoptim.c
deleted file mode 100644
index eef2f84..0000000
--- a/src/pshinter/pshoptim.c
+++ /dev/null
@@ -1,145 +0,0 @@
-#include "pshoptim.h"
-
-
-#ifdef DEBUG_VIEW
-  void
-  ps_simple_scale( PSH_Hint_Table  table,
-                   FT_Fixed        scale,
-                   FT_Fixed        delta,
-                   FT_Bool         vertical )
-  {
-    PSH_Hint  hint;
-    FT_UInt   count;
-  
-    for ( count = 0; count < table->num_hints; count++ )
-    {
-      hint = table->sort[count];
-      if ( psh_hint_is_active(hint) )
-      {
-        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, vertical );
-      }
-    }
-  }                
-#endif
-
-  FT_LOCAL_DEF  FT_Error
-  psh_hint_table_optimize( PSH_Hint_Table  table,
-                           PSH_Globals     globals,
-                           FT_Outline*     outline,
-                           FT_Bool         vertical )
-  {
-    PSH_Dimension  dim   = &globals->dimension[vertical];
-    FT_Fixed       scale = dim->scale_mult;
-    FT_Fixed       delta = dim->scale_delta;
-
-#ifdef DEBUG_VIEW
-    if ( ps_debug_no_vert_hints && vertical )
-    {
-      ps_simple_scale( table, scale, delta, vertical );
-      return 0;
-    }
-      
-    if ( ps_debug_no_horz_hints && !vertical )
-    {
-      ps_simple_scale( table, scale, delta, vertical );
-      return 0;
-    }
-#endif
-
-    /* XXXX: for now, we only scale the hints to test all other aspects */
-    /*       of the Postscript Hinter..                                 */
-    {  
-      PSH_Hint  hint;
-      FT_UInt   count;
-    
-      for ( count = 0; count < table->num_hints; count++ )
-      {
-        hint = table->sort[count];
-        if ( psh_hint_is_active(hint) )
-        {
-# if 1
-          FT_Pos   pos = FT_MulFix( hint->org_pos, scale ) + delta;
-          FT_Pos   len = FT_MulFix( hint->org_len, scale );
-          
-          FT_Pos   fit_center;
-          FT_Pos   fit_len;
-          
-          PSH_Blue_AlignementRec  align;
-
-          /* compute fitted width/height */
-          fit_len = psh_dimension_snap_width( dim, hint->org_len );
-          if ( fit_len < 64 )
-            fit_len = 64;
-          else
-            fit_len = (fit_len + 16 ) & -64;
-            
-          hint->cur_len = fit_len;
-            
-          /* check blue zones for horizontal stems */
-          align.align = 0;
-          if (!vertical)
-          {
-            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:
-              /* normal processing */
-              if ( (fit_len/64) & 1 )
-              {
-                /* odd number of pixels */
-                fit_center = ((pos + (len >> 1)) & -64) + 32;
-              }
-              else
-              {
-                /* even number of pixels */
-                fit_center = (pos + (len >> 1) + 32) & -64;
-              }
-              
-              hint->cur_pos = fit_center - (fit_len >> 1);
-          }
-# else
-          hint->cur_pos = (FT_MulFix( hint->org_pos, scale ) + delta + 32) & -64;
-          hint->cur_len =  FT_MulFix( hint->org_len, scale );
-# endif          
-
-#ifdef DEBUG_VIEW
-        if (ps_debug_hint_func)
-          ps_debug_hint_func( hint, vertical );
-#endif        
-        }
-      }
-    }
-    
-    return 0;
-  }
diff --git a/src/pshinter/pshoptim.h b/src/pshinter/pshoptim.h
deleted file mode 100644
index eb1605e..0000000
--- a/src/pshinter/pshoptim.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/***************************************************************************/
-/*                                                                         */
-/*  pshoptim.h                                                             */
-/*                                                                         */
-/*    Postscript Hints optimiser and grid-fitter                           */
-/*                                                                         */
-/*  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.                                        */
-/*                                                                         */
-/*                                                                         */
-/*  process the hints provided by the fitter in order to optimize them     */
-/*  for the pixel grid, depending on the current glyph outline and         */
-/*  globals. This is where most of the PS Hinter's intelligence is         */
-/*                                                                         */
-/*  XXXX: Until now, only a dummy implementation is provided in order      */
-/*        to test all other functions of the Postscript Hinter.            */
-/*                                                                         */
-/***************************************************************************/
-
-#ifndef __PS_HINTER_OPTIMISER_H__
-#define __PS_HINTER_OPTIMISER_H__
-
-#include "pshfit.h"
-
-FT_BEGIN_HEADER
-
-  FT_LOCAL  FT_Error
-  psh_hint_table_optimize( PSH_Hint_Table  table,
-                           PSH_Globals     globals,
-                           FT_Outline*     outline,
-                           FT_Bool         vertical );
-
-FT_END_HEADER
-
-#endif /* __PS_HINTER_OPTIMISER_H__ */
diff --git a/src/pshinter/pshrec.c b/src/pshinter/pshrec.c
index 5c63f68..8eb6810 100644
--- a/src/pshinter/pshrec.c
+++ b/src/pshinter/pshrec.c
@@ -3,7 +3,15 @@
 #include FT_INTERNAL_OBJECTS_H
 #include FT_INTERNAL_DEBUG_H
 #include "pshrec.h"
-#include "pshfit.h"
+#include "pshalgo.h"
+
+
+#ifdef DEBUG_HINTER
+  extern PS_Hints    ps_debug_hints         = 0;
+  extern  int        ps_debug_no_horz_hints = 0;
+  extern  int        ps_debug_no_vert_hints = 0;
+#endif
+
 
  /***********************************************************************/
  /***********************************************************************/
@@ -1041,7 +1049,7 @@
     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;
+    funcs->apply    = (T1_Hints_ApplyFunc)     PS_HINTS_APPLY_FUNC;
   }
   
   
@@ -1097,7 +1105,7 @@
     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;
+    funcs->apply    = (T2_Hints_ApplyFunc)    PS_HINTS_APPLY_FUNC;
   }
   
 
diff --git a/src/pshinter/pshrec.h b/src/pshinter/pshrec.h
index fbf7ddb..cdcf057 100644
--- a/src/pshinter/pshrec.h
+++ b/src/pshinter/pshrec.h
@@ -151,10 +151,11 @@
   FT_LOCAL void
   t2_hints_funcs_init( T2_Hints_FuncsRec*  funcs );
 
-#define  xxxDEBUG_VIEW
 
-#ifdef DEBUG_VIEW
-  extern PS_Hints   the_ps_hints;
+#ifdef DEBUG_HINTER
+  extern PS_Hints   ps_debug_hints;
+  extern  int       ps_debug_no_horz_hints;
+  extern  int       ps_debug_no_vert_hints;
 #endif
 
  /* */
diff --git a/src/smooth/ftgrays.c b/src/smooth/ftgrays.c
index a12a9ec..9de0141 100644
--- a/src/smooth/ftgrays.c
+++ b/src/smooth/ftgrays.c
@@ -82,7 +82,7 @@
 
 
 #include <string.h>             /* for memcpy() */
-
+#include <setjmp.h>
 
   /*************************************************************************/
   /*                                                                       */
@@ -94,6 +94,8 @@
 #define FT_COMPONENT  trace_aaraster
 
 
+#define ErrRaster_MemoryOverflow   -4
+
 #ifdef _STANDALONE_
 
 
@@ -264,12 +266,13 @@
     void*                render_span_data;
     int                  span_y;
 
-    int    band_size;
-    int    band_shoot;
-    int    conic_level;
-    int    cubic_level;
+    int     band_size;
+    int     band_shoot;
+    int     conic_level;
+    int     cubic_level;
 
-    void*  memory;
+    void*   memory;
+    jmp_buf  jump_buffer;
 
   } TRaster, *PRaster;
 
@@ -296,10 +299,11 @@
   /* Compute the outline bounding box.                                     */
   /*                                                                       */
   static
-  void  compute_cbox( RAS_ARG_ FT_Outline*  outline )
+  void  compute_cbox( RAS_ARG )
   {
-    FT_Vector*  vec   = outline->points;
-    FT_Vector*  limit = vec + outline->n_points;
+    FT_Outline*  outline = &ras.outline;
+    FT_Vector*   vec     = outline->points;
+    FT_Vector*   limit   = vec + outline->n_points;
 
 
     if ( outline->n_points <= 0 )
@@ -339,7 +343,7 @@
   /* Record the current cell in the table.                                 */
   /*                                                                       */
   static
-  int  record_cell( RAS_ARG )
+  void  record_cell( RAS_ARG )
   {
     PCell  cell;
 
@@ -347,7 +351,7 @@
     if ( !ras.invalid && ( ras.area | ras.cover ) )
     {
       if ( ras.num_cells >= ras.max_cells )
-        return 1;
+        longjmp( ras.jump_buffer, 1 );
 
       cell        = ras.cells + ras.num_cells++;
       cell->x     = ras.ex - ras.min_ex;
@@ -355,8 +359,6 @@
       cell->area  = ras.area;
       cell->cover = ras.cover;
     }
-
-    return 0;
   }
 
 
@@ -365,8 +367,8 @@
   /* Set the current cell to a new position.                               */
   /*                                                                       */
   static
-  int  set_cell( RAS_ARG_ TScan  ex,
-                          TScan  ey )
+  void  set_cell( RAS_ARG_ TScan  ex,
+                           TScan  ey )
   {
     int  invalid, record, clean;
 
@@ -402,8 +404,8 @@
 
     /* record the previous cell if needed (i.e., if we changed the cell */
     /* position, of changed the `invalid' flag)                         */
-    if ( ( ras.invalid != invalid || record ) && record_cell( RAS_VAR ) )
-      return 1;
+    if ( ras.invalid != invalid || record )
+      record_cell( RAS_VAR );
 
     if ( clean )
     {
@@ -414,7 +416,6 @@
     ras.invalid = invalid;
     ras.ex      = ex;
     ras.ey      = ey;
-    return 0;
   }
 
 
@@ -436,7 +437,7 @@
     ras.last_ey = SUBPIXELS( ey );
     ras.invalid = 0;
 
-    (void)set_cell( RAS_VAR_ ex, ey );
+    set_cell( RAS_VAR_ ex, ey );
   }
 
 
@@ -445,11 +446,11 @@
   /* Render a scanline as one or more cells.                               */
   /*                                                                       */
   static
-  int  render_scanline( RAS_ARG_  TScan  ey,
-                                  TPos   x1,
-                                  TScan  y1,
-                                  TPos   x2,
-                                  TScan  y2 )
+  void  render_scanline( RAS_ARG_  TScan  ey,
+                                   TPos   x1,
+                                   TScan  y1,
+                                   TPos   x2,
+                                   TScan  y2 )
   {
     TScan  ex1, ex2, fx1, fx2, delta;
     long   p, first, dx;
@@ -465,7 +466,10 @@
 
     /* trivial case.  Happens often */
     if ( y1 == y2 )
-      return set_cell( RAS_VAR_ ex2, ey );
+    {
+      set_cell( RAS_VAR_ ex2, ey );
+      return;
+    }
 
     /* everything is located in a single cell.  That is easy! */
     /*                                                        */
@@ -474,7 +478,7 @@
       delta      = y2 - y1;
       ras.area  += ( fx1 + fx2 ) * delta;
       ras.cover += delta;
-      return 0;
+      return;
     }
 
     /* ok, we'll have to render a run of adjacent cells on the same */
@@ -504,8 +508,7 @@
     ras.cover += delta;
 
     ex1 += incr;
-    if ( set_cell( RAS_VAR_ ex1, ey ) )
-      goto Error;
+    set_cell( RAS_VAR_ ex1, ey );
     y1  += delta;
 
     if ( ex1 != ex2 )
@@ -535,19 +538,13 @@
         ras.cover += delta;
         y1        += delta;
         ex1       += incr;
-        if ( set_cell( RAS_VAR_ ex1, ey ) )
-          goto Error;
+        set_cell( RAS_VAR_ ex1, ey );
       }
     }
 
     delta      = y2 - y1;
     ras.area  += ( fx2 + ONE_PIXEL - first ) * delta;
     ras.cover += delta;
-
-    return 0;
-
-  Error:
-    return 1;
   }
 
 
@@ -556,7 +553,7 @@
   /* Render a given line as a series of scanlines.                         */
   /*                                                                       */
   static
-  int  render_line( RAS_ARG_ TPos  to_x,
+  void render_line( RAS_ARG_ TPos  to_x,
                              TPos  to_y )
   {
     TScan  ey1, ey2, fy1, fy2;
@@ -594,8 +591,7 @@
     /* everything is on a single scanline */
     if ( ey1 == ey2 )
     {
-      if ( render_scanline( RAS_VAR_ ey1, ras.x, fy1, to_x, fy2 ) )
-        goto Error;
+      render_scanline( RAS_VAR_ ey1, ras.x, fy1, to_x, fy2 );
       goto End;
     }
 
@@ -621,12 +617,10 @@
     }
 
     x = ras.x + delta;
-    if ( render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, first ) )
-      goto Error;
+    render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, first );
 
     ey1 += incr;
-    if ( set_cell( RAS_VAR_ TRUNC( x ), ey1 ) )
-      goto Error;
+    set_cell( RAS_VAR_ TRUNC( x ), ey1 );
 
     if ( ey1 != ey2 )
     {
@@ -651,29 +645,20 @@
         }
 
         x2 = x + delta;
-        if ( render_scanline( RAS_VAR_ ey1,
-                              x, ONE_PIXEL - first, x2, first ) )
-          goto Error;
+        render_scanline( RAS_VAR_ ey1, x, ONE_PIXEL - first, x2, first );
         x = x2;
+
         ey1 += incr;
-        if ( set_cell( RAS_VAR_ TRUNC( x ), ey1 ) )
-          goto Error;
+        set_cell( RAS_VAR_ TRUNC( x ), ey1 );
       }
     }
 
-    if ( render_scanline( RAS_VAR_ ey1,
-                          x, ONE_PIXEL - first, to_x, fy2 ) )
-      goto Error;
+    render_scanline( RAS_VAR_ ey1, x, ONE_PIXEL - first, to_x, fy2 );
 
   End:
     ras.x       = to_x;
     ras.y       = to_y;
     ras.last_ey = SUBPIXELS( ey2 );
-
-    return 0;
-
-  Error:
-    return 1;
   }
 
 
@@ -698,7 +683,7 @@
 
 
   static
-  int  render_conic( RAS_ARG_ FT_Vector*  control,
+  void render_conic( RAS_ARG_ FT_Vector*  control,
                               FT_Vector*  to )
   {
     TPos        dx, dy;
@@ -737,8 +722,9 @@
       mid_x = ( ras.x + to_x + 2 * UPSCALE( control->x ) ) / 4;
       mid_y = ( ras.y + to_y + 2 * UPSCALE( control->y ) ) / 4;
 
-      return render_line( RAS_VAR_ mid_x, mid_y ) ||
-             render_line( RAS_VAR_ to_x, to_y );
+      render_line( RAS_VAR_ mid_x, mid_y );
+      render_line( RAS_VAR_ to_x, to_y );
+      return;
     }
 
     arc       = ras.bez_stack;
@@ -792,15 +778,14 @@
         mid_x = ( ras.x + to_x + 2 * arc[1].x ) / 4;
         mid_y = ( ras.y + to_y + 2 * arc[1].y ) / 4;
 
-        if ( render_line( RAS_VAR_ mid_x, mid_y ) ||
-             render_line( RAS_VAR_ to_x, to_y )   )
-          return 1;
+        render_line( RAS_VAR_ mid_x, mid_y );
+        render_line( RAS_VAR_ to_x, to_y );
 
         top--;
         arc -= 2;
       }
     }
-    return 0;
+    return;
   }
 
 
@@ -833,7 +818,7 @@
 
 
   static
-  int  render_cubic( RAS_ARG_ FT_Vector*  control1,
+  void render_cubic( RAS_ARG_ FT_Vector*  control1,
                               FT_Vector*  control2,
                               FT_Vector*  to )
   {
@@ -885,8 +870,9 @@
       mid_y = ( ras.y + to_y +
                 3 * UPSCALE( control1->y + control2->y ) ) / 8;
 
-      return render_line( RAS_VAR_ mid_x, mid_y ) ||
-             render_line( RAS_VAR_ to_x, to_y );
+      render_line( RAS_VAR_ mid_x, mid_y );
+      render_line( RAS_VAR_ to_x, to_y );
+      return;
     }
 
     arc      = ras.bez_stack;
@@ -941,14 +927,13 @@
         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;
 
-        if ( render_line( RAS_VAR_ mid_x, mid_y ) ||
-             render_line( RAS_VAR_ to_x, to_y )   )
-          return 1;
+        render_line( RAS_VAR_ mid_x, mid_y );
+        render_line( RAS_VAR_ to_x, to_y );
         top --;
         arc -= 3;
       }
     }
-    return 0;
+    return;
   }
 
 
@@ -1157,7 +1142,9 @@
     /* start to a new position */
     x = UPSCALE( to->x );
     y = UPSCALE( to->y );
+    
     start_cell( (PRaster)raster, TRUNC( x ), TRUNC( y ) );
+      
     ((PRaster)raster)->x = x;
     ((PRaster)raster)->y = y;
     return 0;
@@ -1168,8 +1155,9 @@
   int  Line_To( FT_Vector*  to,
                 FT_Raster   raster )
   {
-    return render_line( (PRaster)raster,
-                        UPSCALE( to->x ), UPSCALE( to->y ) );
+    render_line( (PRaster)raster,
+                  UPSCALE( to->x ), UPSCALE( to->y ) );
+    return 0;
   }
 
 
@@ -1178,7 +1166,8 @@
                  FT_Vector*  to,
                  FT_Raster   raster )
   {
-    return render_conic( (PRaster)raster, control, to );
+    render_conic( (PRaster)raster, control, to );
+    return 0;
   }
 
 
@@ -1188,7 +1177,8 @@
                  FT_Vector*  to,
                  FT_Raster   raster )
   {
-    return render_cubic( (PRaster)raster, control1, control2, to );
+    render_cubic( (PRaster)raster, control1, control2, to );
+    return 0;
   }
 
 
@@ -1487,7 +1477,11 @@
                              void*                    user )
   {
 #undef SCALED
-#define SCALED( x )  ( ( (x) << shift ) - delta )
+#if 0
+#  define SCALED( x )  ( ( (x) << shift ) - delta )
+#else
+#  define SCALED( x)   (x)
+#endif
 
     FT_Vector   v_last;
     FT_Vector   v_control;
@@ -1502,8 +1496,10 @@
     int     error;
     char    tag;       /* current point's state           */
 
+#if 0
     int     shift = interface->shift;
     FT_Pos  delta = interface->delta;
+#endif
 
 
     first = 0;
@@ -1691,8 +1687,8 @@
   } TBand;
 
 
-  static
-  int  grays_convert_glyph( RAS_ARG_ FT_Outline*  outline )
+  static int
+  grays_convert_glyph_inner( RAS_ARG )
   {
     static
     const FT_Outline_Funcs  interface =
@@ -1705,6 +1701,25 @@
       0
     };
 
+    volatile int  error = 0;
+    
+    if ( setjmp( ras.jump_buffer ) == 0 )
+    {
+      error = FT_Outline_Decompose( &ras.outline, &interface, &ras );
+      record_cell( RAS_VAR );
+    }
+    else
+    {
+      error = ErrRaster_MemoryOverflow;
+    }
+
+    return error;
+  }
+
+
+  static
+  int  grays_convert_glyph( RAS_ARG_ FT_Outline*  outline )
+  {
     TBand     bands[40], *band;
     int       n, num_bands;
     TPos      min, max, max_y;
@@ -1712,7 +1727,7 @@
 
 
     /* Set up state in the raster object */
-    compute_cbox( RAS_VAR_ outline );
+    compute_cbox( RAS_VAR );
 
     /* clip to target bitmap, exit if nothing to do */
     clip = &ras.clip_box;
@@ -1776,8 +1791,12 @@
         ras.min_ey    = band->min;
         ras.max_ey    = band->max;
 
+#if 1
+        error = grays_convert_glyph_inner( RAS_VAR );
+#else       
         error = FT_Outline_Decompose( outline, &interface, &ras ) ||
                 record_cell( RAS_VAR );
+#endif
 
         if ( !error )
         {
@@ -1796,6 +1815,8 @@
           band--;
           continue;
         }
+        else if ( error != ErrRaster_MemoryOverflow )
+          return 1;
 
         /* render pool overflow, we will reduce the render band by half */
         bottom = band->min;
diff --git a/tests/Jamfile b/tests/Jamfile
index 74d3aef..06625a9 100644
--- a/tests/Jamfile
+++ b/tests/Jamfile
@@ -16,7 +16,7 @@
     Main  $(t) : $(t).c ;
     
     LinkLibraries $(t) : $(FT2_LIB) ;
-
+    
     if $(TOOLSET) = MINGW
     {
       LINKKLIBS on $(t)$(SUFEXE) = "-luser32 -lgdi32" ;
diff --git a/tests/gview.c b/tests/gview.c
index b894aa2..35d2369 100644
--- a/tests/gview.c
+++ b/tests/gview.c
@@ -7,7 +7,17 @@
 
 /* include FreeType internals to debug hints */
 #include <../src/pshinter/pshrec.h>
-#include <../src/pshinter/pshfit.h>
+#include <../src/pshinter/pshalgo1.h>
+#include <../src/pshinter/pshalgo2.h>
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                     ROOT DEFINITIONS                         *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
 
 #include <time.h>    /* for clock() */
 
@@ -18,7 +28,7 @@
 #define CLOCKS_PER_SEC HZ
 #endif
 
-static int  depth = 0;
+static int  first_glyph = 0;
 
 static NV_Renderer   renderer;
 static NV_Painter    painter;
@@ -42,12 +52,23 @@
 
 static  int   glyph_index;
 static  int   pixel_size = 12;
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 OPTIONS, COLORS and OTHERS                   *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
 static  int   option_show_axis   = 1;
 static  int   option_show_dots   = 1;
-static  int   option_show_stroke = 1;
+static  int   option_show_stroke = 0;
 static  int   option_show_glyph  = 1;
 static  int   option_show_grid   = 1;
 static  int   option_show_em     = 0;
+static  int   option_show_smooth = 1;
+static  int   option_show_blues  = 0;
 
 static  int   option_show_ps_hints   = 1;
 static  int   option_show_horz_hints = 1;
@@ -58,18 +79,18 @@
 
 static  char  temp_message[1024];
 
-PS_Hints      the_ps_hints = 0;
-int           ps_debug_no_horz_hints = 0;
-int           ps_debug_no_vert_hints = 0;
-PSH_HintFunc  ps_debug_hint_func     = 0;
-
 #define  AXIS_COLOR        0xFFFF0000
 #define  GRID_COLOR        0xFFD0D0D0
 #define  ON_COLOR          0xFFFF2000
 #define  OFF_COLOR         0xFFFF0080
+#define  STRONG_COLOR      0xFF404040
+#define  INTERP_COLOR      0xFF206040
+#define  SMOOTH_COLOR      0xF000B040
 #define  BACKGROUND_COLOR  0xFFFFFFFF
 #define  TEXT_COLOR        0xFF000000
 #define  EM_COLOR          0x80008000
+#define  BLUES_TOP_COLOR   0x4000008F
+#define  BLUES_BOT_COLOR   0x40008F00
 
 #define  GHOST_HINT_COLOR  0xE00000FF
 #define  STEM_HINT_COLOR   0xE02020FF
@@ -84,6 +105,13 @@
 }
 
 
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                     COMMON GRID DRAWING ROUTINES             *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
 
 static void
 reset_scale( NV_Scale  scale )
@@ -188,11 +216,114 @@
 }
 
 
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****            POSTSCRIPT GLOBALS ROUTINES                       *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#include <../src/pshinter/pshglob.h>
+
+static void
+draw_ps_blue_zones( void )
+{
+  if ( option_show_blues && ps_debug_globals )
+  {
+    PSH_Blues       blues = &ps_debug_globals->blues;
+    PSH_Blue_Table  table;
+    NV_Vector       v;
+    FT_Int          y1, y2;
+    FT_UInt         count;
+    PSH_Blue_Zone   zone;
+    
+    /* draw top zones */
+    table = &blues->normal_top;
+    count = table->count;
+    zone  = table->zones;
+    
+    for ( ; count > 0; count--, zone++ )
+    {
+      v.x = 0;
+      if ( !ps_debug_no_horz_hints )
+      {
+        v.y = zone->cur_ref + zone->cur_delta;
+        nv_vector_transform( &v, &size_transform );
+      }
+      else
+      {
+        v.y = zone->org_ref + zone->org_delta;
+        nv_vector_transform( &v, &glyph_transform );
+      }
+      y1  = (int)(v.y + 0.5);
+      
+      v.x = 0;
+      if ( !ps_debug_no_horz_hints )
+      {
+        v.y = zone->cur_ref;
+        nv_vector_transform( &v, &size_transform );
+      }
+      else
+      {
+        v.y = zone->org_ref;
+        nv_vector_transform( &v, &glyph_transform );
+      }
+      y2 = (int)(v.y + 0.5);
+      
+      nv_pixmap_fill_rect( target, 0, y1,
+                           target->width, y2-y1+1,
+                           BLUES_TOP_COLOR );
+
+#if 0                           
+      printf( "top [%.3f %.3f]\n", zone->cur_bottom/64.0, zone->cur_top/64.0 );
+#endif      
+    }
+    
+    
+    /* draw bottom zones */
+    table = &blues->normal_bottom;
+    count = table->count;
+    zone  = table->zones;
+    
+    for ( ; count > 0; count--, zone++ )
+    {
+      v.x = 0;
+      v.y = zone->cur_ref;
+      nv_vector_transform( &v, &size_transform );
+      y1  = (int)(v.y + 0.5);
+      
+      v.x = 0;
+      v.y = zone->cur_ref + zone->cur_delta;
+      nv_vector_transform( &v, &size_transform );
+      y2 = (int)(v.y + 0.5);
+      
+      nv_pixmap_fill_rect( target, 0, y1,
+                           target->width, y2-y1+1,
+                           BLUES_BOT_COLOR );
+
+#if 0
+      printf( "bot [%.3f %.3f]\n", zone->cur_bottom/64.0, zone->cur_top/64.0 );
+#endif
+    }
+  }
+}
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****            POSTSCRIPT HINTER ALGORITHM 1 ROUTINES            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#include <../src/pshinter/pshalgo1.h>
+
 static int pshint_cpos     = 0;
 static int pshint_vertical = -1;
 
 static void
-draw_ps_hint( PSH_Hint   hint, FT_Bool  vertical )
+draw_ps1_hint( PSH1_Hint   hint, FT_Bool  vertical )
 {
   int        x1, x2;
   NV_Vector  v;
@@ -224,17 +355,17 @@
     x2 = (int)(v.x + 0.5);
 
     nv_pixmap_fill_rect( target, x1, 0, 1, target->height,
-                         psh_hint_is_ghost(hint)
+                         psh1_hint_is_ghost(hint)
                          ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
 
-    if ( psh_hint_is_ghost(hint) )
+    if ( psh1_hint_is_ghost(hint) )
     {
       x1 --;
       x2 = x1 + 2;
     }
     else
       nv_pixmap_fill_rect( target, x2, 0, 1, target->height,
-                           psh_hint_is_ghost(hint)
+                           psh1_hint_is_ghost(hint)
                            ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
 
     nv_pixmap_fill_rect( target, x1, pshint_cpos, x2+1-x1, 1,
@@ -256,37 +387,208 @@
     x2 = (int)(v.y + 0.5);
 
     nv_pixmap_fill_rect( target, 0, x1, target->width, 1,
-                         psh_hint_is_ghost(hint)
+                         psh1_hint_is_ghost(hint)
                          ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
 
-    if ( psh_hint_is_ghost(hint) )
+    if ( psh1_hint_is_ghost(hint) )
     {
       x1 --;
       x2 = x1 + 2;
     }
     else
       nv_pixmap_fill_rect( target, 0, x2, target->width, 1,
-                           psh_hint_is_ghost(hint)
+                           psh1_hint_is_ghost(hint)
                            ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
 
     nv_pixmap_fill_rect( target, pshint_cpos, x2, 1, x1+1-x2,
                          STEM_JOIN_COLOR );
   }
 
+#if 0
   printf( "[%7.3f %7.3f] %c\n", hint->cur_pos/64.0, (hint->cur_pos+hint->cur_len)/64.0, vertical ? 'v' : 'h' );
+#endif
   
   pshint_cpos += 10;
 }
 
 
 
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****            POSTSCRIPT HINTER ALGORITHM 2 ROUTINES            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#include <../src/pshinter/pshalgo2.h>
+
+static void
+draw_ps2_hint( PSH2_Hint   hint, FT_Bool  vertical )
+{
+  int        x1, x2;
+  NV_Vector  v;
+  
+  if ( pshint_vertical != vertical )
+  {
+    if (vertical)
+      pshint_cpos = 40;
+    else
+      pshint_cpos = 10;
+      
+    pshint_vertical = vertical;
+  }
+  
+  if (vertical)
+  {
+    if ( !option_show_vert_hints )
+      return;
+      
+    v.x = hint->cur_pos;
+    v.y = 0;
+    nv_vector_transform( &v, &size_transform );
+    x1 = (int)(v.x + 0.5);
+
+    v.x = hint->cur_pos + hint->cur_len;
+    v.y = 0;
+    nv_vector_transform( &v, &size_transform );
+    x2 = (int)(v.x + 0.5);
+
+    nv_pixmap_fill_rect( target, x1, 0, 1, target->height,
+                         psh2_hint_is_ghost(hint)
+                         ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
+
+    if ( psh2_hint_is_ghost(hint) )
+    {
+      x1 --;
+      x2 = x1 + 2;
+    }
+    else
+      nv_pixmap_fill_rect( target, x2, 0, 1, target->height,
+                           psh2_hint_is_ghost(hint)
+                           ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
+
+    nv_pixmap_fill_rect( target, x1, pshint_cpos, x2+1-x1, 1,
+                         STEM_JOIN_COLOR );
+  }
+  else
+  {
+    if (!option_show_horz_hints)
+      return;
+      
+    v.y = hint->cur_pos;
+    v.x = 0;
+    nv_vector_transform( &v, &size_transform );
+    x1 = (int)(v.y + 0.5);
+
+    v.y = hint->cur_pos + hint->cur_len;
+    v.x = 0;
+    nv_vector_transform( &v, &size_transform );
+    x2 = (int)(v.y + 0.5);
+
+    nv_pixmap_fill_rect( target, 0, x1, target->width, 1,
+                         psh2_hint_is_ghost(hint)
+                         ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
+
+    if ( psh2_hint_is_ghost(hint) )
+    {
+      x1 --;
+      x2 = x1 + 2;
+    }
+    else
+      nv_pixmap_fill_rect( target, 0, x2, target->width, 1,
+                           psh2_hint_is_ghost(hint)
+                           ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
+
+    nv_pixmap_fill_rect( target, pshint_cpos, x2, 1, x1+1-x2,
+                         STEM_JOIN_COLOR );
+  }
+
+#if 0
+  printf( "[%7.3f %7.3f] %c\n", hint->cur_pos/64.0, (hint->cur_pos+hint->cur_len)/64.0, vertical ? 'v' : 'h' );
+#endif
+  
+  pshint_cpos += 10;
+}
+
+
+static void
+ps2_draw_control_points( void )
+{
+  if ( ps2_debug_glyph )
+  {
+    PSH2_Glyph    glyph = ps2_debug_glyph;
+    PSH2_Point    point = glyph->points;
+    FT_UInt       count = glyph->num_points;
+    NV_Transform  transform, *trans = &transform;
+    NV_Path       vert_rect;
+    NV_Path       horz_rect;
+    NV_Path       dot, circle;
+    
+    nv_path_new_rectangle( renderer, -1, -6, 2, 12, 0, 0, &vert_rect );
+    nv_path_new_rectangle( renderer, -6, -1, 12, 2, 0, 0, &horz_rect );
+    nv_path_new_circle( renderer, 0, 0, 3., &dot );
+    nv_path_stroke( dot, 0.6, nv_path_linecap_butt, nv_path_linejoin_miter, 1., &circle );
+    
+    for ( ; count > 0; count--, point++ )
+    {
+      NV_Vector  vec;
+      
+      vec.x = point->cur_x;
+      vec.y = point->cur_y;
+      nv_vector_transform( &vec, &size_transform );
+      
+      nv_transform_set_translate( trans, vec.x, vec.y );
+
+      if ( option_show_smooth && !psh2_point_is_smooth(point) )
+      {
+        nv_painter_set_color( painter, SMOOTH_COLOR, 256 );
+        nv_painter_fill_path( painter, trans, 0, circle );
+      }
+        
+      if (option_show_horz_hints)
+      {
+        if ( point->flags_y & PSH2_POINT_STRONG )
+        {
+          nv_painter_set_color( painter, STRONG_COLOR, 256 );
+          nv_painter_fill_path( painter, trans, 0, horz_rect );
+        }
+      }
+      
+      if (option_show_vert_hints)
+      {
+        if ( point->flags_x & PSH2_POINT_STRONG )
+        {
+          nv_painter_set_color( painter, STRONG_COLOR, 256 );
+          nv_painter_fill_path( painter, trans, 0, vert_rect );
+        }
+      }
+    }
+
+    nv_path_destroy( circle );
+    nv_path_destroy( dot );    
+    nv_path_destroy( horz_rect );
+    nv_path_destroy( vert_rect );
+  }
+}
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                        MAIN LOOP(S)                          *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
 static void
 draw_glyph( int  glyph_index )
 {
   NV_Path   path;
 
   pshint_vertical    = -1;
-  ps_debug_hint_func = option_show_ps_hints ? draw_ps_hint : 0;
+  
+  ps1_debug_hint_func = option_show_ps_hints ? draw_ps1_hint : 0;
+  ps2_debug_hint_func = option_show_ps_hints ? draw_ps2_hint : 0;
 
   error = FT_Load_Glyph( face, glyph_index, option_hinting
                                           ? FT_LOAD_NO_BITMAP
@@ -334,6 +636,7 @@
     NV_Int      n, first, last;
 
     nv_path_new_circle( renderer, 0, 0, 2., &plot );
+    
     nv_path_get_outline( path, NULL, memory, &out );
     
     first = 0;
@@ -355,8 +658,10 @@
         vec = out.points + m;
 
         nv_transform_set_translate( &trans, vec->x/64.0, vec->y/64.0 );        
+
         nv_painter_set_color( painter, color, 256 );
         nv_painter_fill_path( painter, &trans, 0, plot );
+
       }
       
       first = last + 1;
@@ -390,105 +695,25 @@
 }
 
 
-#if 0
 
-static void
-draw_ps_hints( void )
-{
-  if ( option_show_ps_hints && the_ps_hints )
-  {
-    PS_Dimension  dim;
-    PS_Hint       hint;
-    NV_UInt       count;
-    NV_Int        cpos;
-    NV_Vector     v;
-    
-    /* draw vertical stems */
-    if ( option_show_vert_hints )
-    {
-      dim  = &the_ps_hints->dimension[1];
-      hint = dim->hints.hints;
-      cpos = 40;
-      for ( count = dim->hints.num_hints; count > 0; count--, hint++ )
-      {
-        NV_Int   x1, x2;
-  
-        v.x = hint->pos;
-        v.y = 0;
-        nv_vector_transform( &v, &glyph_transform );
-        x1  = (int)(v.x+0.5);
-        x1  = glyph_org_x + hint->pos*glyph_scale;
-        nv_pixmap_fill_rect( target, x1, 0, 1, target->height,
-                                  ps_hint_is_ghost(hint)
-                                  ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
-        
-        if ( !ps_hint_is_ghost(hint) )
-        {
-          v.x = hint->pos + hint->len;
-          v.y = 0;
-          nv_vector_transform( &v, &glyph_transform );
-          x2  = (int)(v.x+0.5);
-          x2  = glyph_org_x + (hint->pos + hint->len)*glyph_scale;
-          nv_pixmap_fill_rect( target, x2, 0, 1, target->height,
-                                    STEM_HINT_COLOR );
-        }
-        else
-        {
-          x1 -= 1;
-          x2  = x1 + 2;
-        }
-        
-        nv_pixmap_fill_rect( target, x1, cpos, x2-x1+1, 1,
-                                  STEM_JOIN_COLOR );
-        cpos += 10;
-      }
-    }
+#define  TOGGLE_OPTION(var,prefix)                           \
+            {                                                \
+              var = !var;                                    \
+              sprintf( temp_message, prefix " is now %s",    \
+                       var ? "on" : "off" );                 \
+              break;                                         \
+            }
 
-    /* draw horizontal stems */
-    if ( option_show_horz_hints )
-    {
-      dim  = &the_ps_hints->dimension[0];
-      hint = dim->hints.hints;
-      cpos = 10;
-      for ( count = dim->hints.num_hints; count > 0; count--, hint++ )
-      {
-        NV_Int   y1, y2;
-  
-        v.x = 0;
-        v.y = hint->pos;
-        nv_vector_transform( &v, &glyph_transform );
-        y1  = (int)(v.y+0.5);
-        y1  = glyph_org_y - hint->pos*glyph_scale;
-        nv_pixmap_fill_rect( target, 0, y1, target->width, 1,
-                                  ps_hint_is_ghost(hint)
-                                  ? GHOST_HINT_COLOR : STEM_HINT_COLOR );
-        
-        if ( !ps_hint_is_ghost(hint) )
-        {
-          v.x = 0;
-          v.y = hint->pos + hint->len;
-          nv_vector_transform( &v, &glyph_transform );
-          y2  = (int)(v.y+0.5);
-          y2  = glyph_org_y - (hint->pos + hint->len)*glyph_scale;
-          nv_pixmap_fill_rect( target, 0, y2, target->width, 1,
-                                    STEM_HINT_COLOR );
-        }
-        else
-        {
-          y1 -= 1;
-          y2  = y1 + 2;
-        }
-        
-        nv_pixmap_fill_rect( target, cpos, y2, 1, y1-y2+1,
-                                  STEM_JOIN_COLOR );
-        cpos += 10;
-      }
-    }
-  }
-}
 
-#endif
+#define  TOGGLE_OPTION_NEG(var,prefix)                       \
+            {                                                \
+              var = !var;                                    \
+              sprintf( temp_message, prefix " is now %s",    \
+                       !var ? "on" : "off" );                \
+              break;                                         \
+            }
 
+            
 static void
 handle_event( NVV_EventRec*   ev )
 {
@@ -509,34 +734,19 @@
       }
 
     case NVV_KEY('x'):
-      {
-        option_show_axis = !option_show_axis;
-        break;
-      }
+      TOGGLE_OPTION( option_show_axis, "grid axis display" )
 
     case NVV_KEY('s'):
-      {
-        option_show_stroke = !option_show_stroke;
-        break;
-      }
+      TOGGLE_OPTION( option_show_stroke, "glyph stroke display" )
     
     case NVV_KEY('g'):
-      {
-        option_show_glyph = !option_show_glyph;
-        break;
-      }
+      TOGGLE_OPTION( option_show_glyph, "glyph fill display" )
       
     case NVV_KEY('d'):
-      {
-        option_show_dots = !option_show_dots;
-        break;
-      }
+      TOGGLE_OPTION( option_show_dots, "control points display" )
       
     case NVV_KEY('e'):
-      {
-        option_show_em = !option_show_em;
-        break;
-      }
+      TOGGLE_OPTION( option_show_em, "EM square display" )
     
     case NVV_KEY('+'):
       {
@@ -575,51 +785,90 @@
       }
 
     case NVV_KEY('z'):
-      {
-        ps_debug_no_vert_hints = !ps_debug_no_vert_hints;
-        sprintf( temp_message, "vertical hints processing is now %s",
-                 ps_debug_no_vert_hints ? "off" : "on" );
-        break;
-      }      
+      TOGGLE_OPTION_NEG( ps_debug_no_vert_hints, "vertical hints processing" )
 
     case NVV_KEY('a'):
-      {
-        ps_debug_no_horz_hints = !ps_debug_no_horz_hints;
-        sprintf( temp_message, "horizontal hints processing is now %s",
-                 ps_debug_no_horz_hints ? "off" : "on" );
-        break;
-      }      
+      TOGGLE_OPTION_NEG( ps_debug_no_horz_hints, "horizontal hints processing" )
 
     case NVV_KEY('Z'):
-      {
-        option_show_vert_hints = !option_show_vert_hints;
-        sprintf( temp_message, "vertical hints display is now %s",
-                 option_show_vert_hints ? "off" : "on" );
-        break;
-      }      
+      TOGGLE_OPTION( option_show_vert_hints, "vertical hints display" )
 
     case NVV_KEY('A'):
-      {
-        option_show_horz_hints = !option_show_horz_hints;
-        sprintf( temp_message, "horizontal hints display is now %s",
-                 option_show_horz_hints ? "off" : "on" );
-        break;
-      }      
+      TOGGLE_OPTION( option_show_horz_hints, "horizontal hints display" )
 
+    case NVV_KEY('S'):
+      TOGGLE_OPTION( option_show_smooth, "smooth points display" );
+
+    case NVV_KEY('b'):
+      TOGGLE_OPTION( option_show_blues, "blue zones display" );
 
     case NVV_KEY('h'):
-      {
-        option_hinting = !option_hinting;
-        sprintf( temp_message, "hinting is now %s",
-                 option_hinting ? "off" : "on" );
-        break;
-      }      
+      TOGGLE_OPTION( option_hinting, "hinting" )
+      
+    default:
+      ;
   }
 }
 
 
+
+static void
+usage()
+{
+  Panic( "no usage" );
+}
+
+
+#define  OPTION1(n,code)   \
+           case n :        \
+             code          \
+             argc--;       \
+             argv++;       \
+             break;
+
+#define  OPTION2(n,code)     \
+           case n :          \
+             code            \
+             argc -= 2;      \
+             argv += 2;      \
+             break;
+
+
+static void
+parse_options( int*  argc_p, char*** argv_p )
+{
+  int    argc = *argc_p;
+  char** argv = *argv_p;
+  
+  while (argc > 2 && argv[1][0] == '-')
+  {
+    switch (argv[1][1])
+    {
+      OPTION2( 'f', first_glyph = atoi( argv[2] ); )
+
+      OPTION2( 's', pixel_size = atoi( argv[2] ); )
+      
+      default:
+        usage();
+    }
+  }
+  
+  *argc_p = argc;
+  *argv_p = argv;
+}
+  
+  
+
 int  main( int  argc, char**  argv )
 {
+  char*  filename = "/fonts/lcdxsr.pfa";
+  
+  parse_options( &argc, &argv );
+  
+  if ( argc >= 2 )
+    filename = argv[1];
+   
+  
   /* create library */
   error = nv_renderer_new( 0, &renderer );
   if (error) Panic( "could not create Nirvana renderer" );
@@ -629,7 +878,7 @@
   error = nvv_display_new( renderer, &display );
   if (error) Panic( "could not create display" );
   
-  error = nvv_surface_new( display, 400, 400, nv_pixmap_type_argb, &surface );
+  error = nvv_surface_new( display, 460, 460, nv_pixmap_type_argb, &surface );
   if (error) Panic( "could not create surface" );
 
   target = nvv_surface_get_pixmap( surface );
@@ -644,7 +893,7 @@
   error = FT_Init_FreeType( &freetype );
   if (error) Panic( "could not initialise FreeType" );
   
-  error = FT_New_Face( freetype, "h:/fonts/cour.pfa", 0, &face );
+  error = FT_New_Face( freetype, filename, 0, &face );
   if (error) Panic( "could not open font face" );
 
   reset_size( pixel_size, grid_scale );
@@ -655,15 +904,16 @@
   {
     NVV_EventRec  event;
 
-    glyph_index = 0;    
+    glyph_index = first_glyph;    
     for ( ;; )
     {
       clear_background();
       draw_grid();
 
-      the_ps_hints = 0;
+      ps_debug_hints = 0;
+      draw_ps_blue_zones();
       draw_glyph( glyph_index );
-      /* draw_ps_hints(); */
+      ps2_draw_control_points();
       
       nvv_surface_refresh( surface, NULL );