rem: hinter->pp1.x = ( ( new_lsb    - old_lsb ) + 32 ) & -64; hinter->pp2.x = ( ( edge2->pos + old_rsb ) + 32 ) & -64;   if ( hinter->pp2.x + hinter->pp1.x == edge2->pos && old_rsb > 4 ) hinter->pp2.x += 64;
add: if ( hinter->do_horz_hints ) { hinter->pp1.x = ( ( new_lsb    - old_lsb - fit_shift/2 ) + 32 ) & -64; hinter->pp2.x = ( ( edge2->pos + old_rsb - fit_shift/2 ) + 32 ) & -64; } else { hinter->pp1.x -= fit_shift / 2; hinter->pp2.x -= fit_shift / 2; }
context:   ah_hinter_load( AH_Hinter  hinter,                  FT_UInt    glyph_index,                  FT_Int32   load_flags,                  FT_UInt    depth )  {    FT_Face           face     = hinter->face;    FT_GlyphSlot      slot     = face->glyph;    FT_Slot_Internal  internal = slot->internal;    FT_Fixed          x_scale  = face->size->metrics.x_scale;    FT_Fixed          y_scale  = face->size->metrics.y_scale;    FT_Error          error;    AH_Outline        outline  = hinter->glyph;    AH_Loader         gloader  = hinter->loader;    /* load the glyph */    error = FT_Load_Glyph( face, glyph_index, load_flags );    if ( error )      goto Exit;    /* Set `hinter->transformed' after loading with FT_LOAD_NO_RECURSE. */    hinter->transformed = internal->glyph_transformed;    if ( hinter->transformed )    {      FT_Matrix  imatrix;      imatrix              = internal->glyph_matrix;      hinter->trans_delta  = internal->glyph_delta;      hinter->trans_matrix = imatrix;      FT_Matrix_Invert( &imatrix );      FT_Vector_Transform( &hinter->trans_delta, &imatrix );    }    /* set linear horizontal metrics */    slot->linearHoriAdvance = slot->metrics.horiAdvance;    slot->linearVertAdvance = slot->metrics.vertAdvance;    switch ( slot->format )    {    case FT_GLYPH_FORMAT_OUTLINE:      /* translate glyph outline if we need to */      if ( hinter->transformed )      {        FT_UInt     n     = slot->outline.n_points;        FT_Vector*  point = slot->outline.points;        for ( ; n > 0; point++, n-- )        {          point->x += hinter->trans_delta.x;          point->y += hinter->trans_delta.y;        }      }      /* copy the outline points in the loader's current                */      /* extra points, which is used to keep original glyph coordinates */      error = ah_loader_check_points( gloader, slot->outline.n_points + 2,                                      slot->outline.n_contours );      if ( error )        goto Exit;      FT_MEM_COPY( gloader->current.extra_points, slot->outline.points,                   slot->outline.n_points * sizeof ( FT_Vector ) );      FT_MEM_COPY( gloader->current.outline.contours, slot->outline.contours,                   slot->outline.n_contours * sizeof ( short ) );      FT_MEM_COPY( gloader->current.outline.tags, slot->outline.tags,                   slot->outline.n_points * sizeof ( char ) );      gloader->current.outline.n_points   = slot->outline.n_points;      gloader->current.outline.n_contours = slot->outline.n_contours;      /* compute original phantom points */      hinter->pp1.x = 0;      hinter->pp1.y = 0;      hinter->pp2.x = FT_MulFix( slot->metrics.horiAdvance, x_scale );      hinter->pp2.y = 0;      /* be sure to check for spacing glyphs */      if ( slot->outline.n_points == 0 )        goto Hint_Metrics;      /* now, load the slot image into the auto-outline, and run the */      /* automatic hinting process                                   */      error = ah_outline_load( outline, face );   /* XXX: change to slot */      if ( error )        goto Exit;      /* perform feature detection */      ah_outline_detect_features( outline );      if ( hinter->do_vert_hints )      {        ah_outline_compute_blue_edges( outline, hinter->globals );        ah_outline_scale_blue_edges( outline, hinter->globals );      }      /* perform alignment control */      ah_hinter_hint_edges( hinter );      ah_hinter_align( hinter );      /* now save the current outline into the loader's current table */      ah_outline_save( outline, gloader );      /* we now need to hint the metrics according to the change in */      /* width/positioning that occured during the hinting process  */      {        FT_Pos   old_advance, old_rsb, old_lsb, new_lsb;        AH_Edge  edge1 = outline->vert_edges;     /* leftmost edge  */        AH_Edge  edge2 = edge1 +                         outline->num_vedges - 1; /* rightmost edge */        old_advance = hinter->pp2.x;        old_rsb     = old_advance - edge2->opos;        old_lsb     = edge1->opos;        new_lsb     = edge1->pos;        hinter->pp1.x = ( ( new_lsb    - old_lsb ) + 32 ) & -64;        hinter->pp2.x = ( ( edge2->pos + old_rsb ) + 32 ) & -64;        /* try to fix certain bad advance computations */        if ( hinter->pp2.x + hinter->pp1.x == edge2->pos && old_rsb > 4 )          hinter->pp2.x += 64;      }      /* good, we simply add the glyph to our loader's base */      ah_loader_add( gloader );      break;    case FT_GLYPH_FORMAT_COMPOSITE:      {        FT_UInt      nn, num_subglyphs = slot->num_subglyphs;        FT_UInt      num_base_subgs, start_point;        FT_SubGlyph  subglyph;        start_point   = gloader->base.outline.n_points;        /* first of all, copy the subglyph descriptors in the glyph loader */        error = ah_loader_check_subglyphs( gloader, num_subglyphs );        if ( error )          goto Exit;        FT_MEM_COPY( gloader->current.subglyphs, slot->subglyphs,                     num_subglyphs * sizeof ( FT_SubGlyph ) );        gloader->current.num_subglyphs = num_subglyphs;        num_base_subgs = gloader->base.num_subglyphs;        /* now, read each subglyph independently */        for ( nn = 0; nn < num_subglyphs; nn++ )        {          FT_Vector  pp1, pp2;          FT_Pos     x, y;          FT_UInt    num_points, num_new_points, num_base_points;          /* gloader.current.subglyphs can change during glyph loading due */          /* to re-allocation -- we must recompute the current subglyph on */          /* each iteration                                                */          subglyph = gloader->base.subglyphs + num_base_subgs + nn;          pp1 = hinter->pp1;          pp2 = hinter->pp2;          num_base_points = gloader->base.outline.n_points;          error = ah_hinter_load( hinter, subglyph->index,                                  load_flags, depth + 1 );          if ( error )            goto Exit;          /* recompute subglyph pointer */          subglyph = gloader->base.subglyphs + num_base_subgs + nn;          if ( subglyph->flags & FT_SUBGLYPH_FLAG_USE_MY_METRICS )          {            pp1 = hinter->pp1;            pp2 = hinter->pp2;          }          else          {            hinter->pp1 = pp1;            hinter->pp2 = pp2;          }          num_points     = gloader->base.outline.n_points;          num_new_points = num_points - num_base_points;          /* now perform the transform required for this subglyph */          if ( subglyph->flags & ( FT_SUBGLYPH_FLAG_SCALE    |                                   FT_SUBGLYPH_FLAG_XY_SCALE |                                   FT_SUBGLYPH_FLAG_2X2      ) )          {            FT_Vector*  cur   = gloader->base.outline.points +                                num_base_points;            FT_Vector*  org   = gloader->base.extra_points +                                num_base_points;            FT_Vector*  limit = cur + num_new_points;            for ( ; cur < limit; cur++, org++ )            {              FT_Vector_Transform( cur, &subglyph->transform );              FT_Vector_Transform( org, &subglyph->transform );            }          }          /* apply offset */          if ( !( subglyph->flags & FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES ) )          {            FT_Int      k = subglyph->arg1;            FT_UInt     l = subglyph->arg2;            FT_Vector*  p1;            FT_Vector*  p2;            if ( start_point + k >= num_base_points          ||                               l >= (FT_UInt)num_new_points  )            {              error = AH_Err_Invalid_Composite;              goto Exit;            }            l += num_base_points;            /* for now, only use the current point coordinates     */            /* we may consider another approach in the near future */            p1 = gloader->base.outline.points + start_point + k;            p2 = gloader->base.outline.points + start_point + l;            x = p1->x - p2->x;            y = p1->y - p2->y;          }          else          {            x = FT_MulFix( subglyph->arg1, x_scale );            y = FT_MulFix( subglyph->arg2, y_scale );            x = ( x + 32 ) & -64;            y = ( y + 32 ) & -64;          }          {            FT_Outline  dummy = gloader->base.outline;            dummy.points  += num_base_points;            dummy.n_points = (short)num_new_points;            FT_Outline_Translate( &dummy, x, y );          }        }      }      break;    default:      /* we don't support other formats (yet?) */      error = AH_Err_Unimplemented_Feature;    }  Hint_Metrics:    if ( depth == 0 )    {      FT_BBox  bbox;      /* transform the hinted outline if needed */      if ( hinter->transformed )        FT_Outline_Transform( &gloader->base.outline, &hinter->trans_matrix );      /* we must translate our final outline by -pp1.x, and compute */      /* the new metrics                                            */      if ( hinter->pp1.x )        FT_Outline_Translate( &gloader->base.outline, -hinter->pp1.x, 0 );      FT_Outline_Get_CBox( &gloader->base.outline, &bbox );      bbox.xMin &= -64;      bbox.yMin &= -64;      bbox.xMax  = ( bbox.xMax + 63 ) & -64;      bbox.yMax  = ( bbox.yMax + 63 ) & -64;      slot->metrics.width        = bbox.xMax - bbox.xMin;      slot->metrics.height       = bbox.yMax - bbox.yMin;      slot->metrics.horiBearingX = bbox.xMin;      slot->metrics.horiBearingY = bbox.yMax;      /* for mono-width fonts (like Andale, Courier, etc.), we need */      /* to keep the original rounded advance width                 */      if ( !FT_IS_FIXED_WIDTH( slot->face ) )        slot->metrics.horiAdvance = hinter->pp2.x - hinter->pp1.x;      else        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,                                               x_scale );      slot->metrics.horiAdvance = ( slot->metrics.horiAdvance + 32 ) & -64;      /* now copy outline into glyph slot */      ah_loader_rewind( slot->internal->loader );      error = ah_loader_copy_points( slot->internal->loader, gloader );      if ( error )        goto Exit;      slot->outline = slot->internal->loader->base.outline;      slot->format  = FT_GLYPH_FORMAT_OUTLINE;    }#ifdef DEBUG_HINTER    ah_debug_hinter = hinter;#endif  Exit:    return error;  }