Update freetype to latest version of ASOP.

src/autofit/afhints.c

 /***************************************************************************/
 /*                                                                         */
 /*  afhints.c                                                              */
 /*                                                                         */
 /*    Auto-fitter hinting routines (body).                                 */
 /*                                                                         */
-/*  Copyright 2003-2007, 2009-2011 by                                      */
+/*  Copyright 2003-2007, 2009-2013 by                                      */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
 /*  modified, and distributed under the terms of the FreeType project      */
 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 /*  this file you indicate that you have read the license and              */
 /*  understand and accept it fully.                                        */
 /*                                                                         */
 /***************************************************************************/
 
 
 #include "afhints.h"
 #include "aferrors.h"
 #include FT_INTERNAL_CALC_H
+#include FT_INTERNAL_DEBUG_H
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_afhints
 
 
   /* Get new segment for given axis. */
 
   FT_LOCAL_DEF( FT_Error )
   af_axis_hints_new_segment( AF_AxisHints  axis,
                              FT_Memory     memory,
                              AF_Segment   *asegment )
   {
-    FT_Error    error   = AF_Err_Ok;
+    FT_Error    error   = FT_Err_Ok;
     AF_Segment  segment = NULL;
 
 
     if ( axis->num_segments >= axis->max_segments )
     {
       FT_Int  old_max = axis->max_segments;
       FT_Int  new_max = old_max;
       FT_Int  big_max = (FT_Int)( FT_INT_MAX / sizeof ( *segment ) );
 
 
       if ( old_max >= big_max )
       {
-        error = AF_Err_Out_Of_Memory;
+        error = FT_THROW( Out_Of_Memory );
         goto Exit;
       }
 
       new_max += ( new_max >> 2 ) + 4;
       if ( new_max < old_max || new_max > big_max )
         new_max = big_max;
 
       if ( FT_RENEW_ARRAY( axis->segments, old_max, new_max ) )
         goto Exit;
 
       axis->max_segments = new_max;
     }
 
     segment = axis->segments + axis->num_segments++;
 
   Exit:
     *asegment = segment;
     return error;
   }
 
 
   /* Get new edge for given axis, direction, and position. */
 
   FT_LOCAL( FT_Error )
   af_axis_hints_new_edge( AF_AxisHints  axis,
                           FT_Int        fpos,
                           AF_Direction  dir,
                           FT_Memory     memory,
-                          AF_Edge      *aedge )
+                          AF_Edge      *anedge )
   {
-    FT_Error  error = AF_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
     AF_Edge   edge  = NULL;
     AF_Edge   edges;
 
 
     if ( axis->num_edges >= axis->max_edges )
     {
       FT_Int  old_max = axis->max_edges;
       FT_Int  new_max = old_max;
       FT_Int  big_max = (FT_Int)( FT_INT_MAX / sizeof ( *edge ) );
 
 
       if ( old_max >= big_max )
       {
-        error = AF_Err_Out_Of_Memory;
+        error = FT_THROW( Out_Of_Memory );
         goto Exit;
       }
 
       new_max += ( new_max >> 2 ) + 4;
       if ( new_max < old_max || new_max > big_max )
         new_max = big_max;
 
       if ( FT_RENEW_ARRAY( axis->edges, old_max, new_max ) )
         goto Exit;
 
@@ skipping 17 matching lines @@
       edge--;
     }
 
     axis->num_edges++;
 
     FT_ZERO( edge );
     edge->fpos = (FT_Short)fpos;
     edge->dir  = (FT_Char)dir;
 
   Exit:
-    *aedge = edge;
+    *anedge = edge;
     return error;
   }
 
 
 #ifdef FT_DEBUG_AUTOFIT
 
 #include FT_CONFIG_STANDARD_LIBRARY_H
 
   static const char*
   af_dir_str( AF_Direction  dir )
@@ skipping 30 matching lines @@
   extern "C" {
 #endif
   void
   af_glyph_hints_dump_points( AF_GlyphHints  hints )
   {
     AF_Point  points = hints->points;
     AF_Point  limit  = points + hints->num_points;
     AF_Point  point;
 
 
-    printf( "Table of points:\n" );
-    printf(   "  [ index |  xorg |  yorg | xscale | yscale"
-              " |  xfit |  yfit |  flags ]\n" );
+    FT_TRACE7(( "Table of points:\n"
+                "  [ index |  xorg |  yorg | xscale | yscale"
+                " |  xfit |  yfit |  flags ]\n" ));
 
     for ( point = points; point < limit; point++ )
-    {
-      printf( "  [ %5d | %5d | %5d | %6.2f | %6.2f"
-              " | %5.2f | %5.2f | %c%c%c%c%c%c ]\n",
-              point - points,
-              point->fx,
-              point->fy,
-              point->ox / 64.0,
-              point->oy / 64.0,
-              point->x / 64.0,
-              point->y / 64.0,
-              ( point->flags & AF_FLAG_WEAK_INTERPOLATION ) ? 'w' : ' ',
-              ( point->flags & AF_FLAG_INFLECTION )         ? 'i' : ' ',
-              ( point->flags & AF_FLAG_EXTREMA_X )          ? '<' : ' ',
-              ( point->flags & AF_FLAG_EXTREMA_Y )          ? 'v' : ' ',
-              ( point->flags & AF_FLAG_ROUND_X )            ? '(' : ' ',
-              ( point->flags & AF_FLAG_ROUND_Y )            ? 'u' : ' ');
-    }
-    printf( "\n" );
+      FT_TRACE7(( "  [ %5d | %5d | %5d | %6.2f | %6.2f"
+                  " | %5.2f | %5.2f | %c%c%c%c%c%c ]\n",
+                  point - points,
+                  point->fx,
+                  point->fy,
+                  point->ox / 64.0,
+                  point->oy / 64.0,
+                  point->x / 64.0,
+                  point->y / 64.0,
+                  ( point->flags & AF_FLAG_WEAK_INTERPOLATION ) ? 'w' : ' ',
+                  ( point->flags & AF_FLAG_INFLECTION )         ? 'i' : ' ',
+                  ( point->flags & AF_FLAG_EXTREMA_X )          ? '<' : ' ',
+                  ( point->flags & AF_FLAG_EXTREMA_Y )          ? 'v' : ' ',
+                  ( point->flags & AF_FLAG_ROUND_X )            ? '(' : ' ',
+                  ( point->flags & AF_FLAG_ROUND_Y )            ? 'u' : ' '));
+    FT_TRACE7(( "\n" ));
   }
 #ifdef __cplusplus
   }
 #endif
 
 
   static const char*
   af_edge_flags_to_string( AF_Edge_Flags  flags )
   {
     static char  temp[32];
     int          pos = 0;
 
 
     if ( flags & AF_EDGE_ROUND )
     {
       ft_memcpy( temp + pos, "round", 5 );
       pos += 5;
     }
     if ( flags & AF_EDGE_SERIF )
     {
       if ( pos > 0 )
         temp[pos++] = ' ';
       ft_memcpy( temp + pos, "serif", 5 );
       pos += 5;
     }
     if ( pos == 0 )
       return "normal";
 
-    temp[pos] = 0;
+    temp[pos] = '\0';
 
     return temp;
   }
 
 
   /* Dump the array of linked segments. */
 
 #ifdef __cplusplus
   extern "C" {
 #endif
   void
   af_glyph_hints_dump_segments( AF_GlyphHints  hints )
   {
     FT_Int  dimension;
 
 
     for ( dimension = 1; dimension >= 0; dimension-- )
     {
       AF_AxisHints  axis     = &hints->axis[dimension];
+      AF_Point      points   = hints->points;
+      AF_Edge       edges    = axis->edges;
       AF_Segment    segments = axis->segments;
       AF_Segment    limit    = segments + axis->num_segments;
       AF_Segment    seg;
 
 
-      printf ( "Table of %s segments:\n",
-               dimension == AF_DIMENSION_HORZ ? "vertical" : "horizontal" );
-      printf ( "  [ index |  pos  |  dir  | link | serif |"
-               " height | extra |    flags    ]\n" );
+      FT_TRACE7(( "Table of %s segments:\n",
+                  dimension == AF_DIMENSION_HORZ ? "vertical"
+                                                 : "horizontal" ));
+      if ( axis->num_segments )
+        FT_TRACE7(( "  [ index |  pos  |  dir  | from"
+                    " |  to  | link | serif | edge"
+                    " | height | extra |    flags    ]\n" ));
+      else
+        FT_TRACE7(( "  (none)\n" ));
 
       for ( seg = segments; seg < limit; seg++ )
-      {
-        printf ( "  [ %5d | %5.2g | %5s | %4d | %5d | %6d | %5d | %11s ]\n",
-                 seg - segments,
-                 dimension == AF_DIMENSION_HORZ ? (int)seg->first->ox / 64.0
-                                                : (int)seg->first->oy / 64.0,
-                 af_dir_str( (AF_Direction)seg->dir ),
-                 AF_INDEX_NUM( seg->link, segments ),
-                 AF_INDEX_NUM( seg->serif, segments ),
-                 seg->height,
-                 seg->height - ( seg->max_coord - seg->min_coord ),
-                 af_edge_flags_to_string( (AF_Edge_Flags)seg->flags ) );
-      }
-      printf( "\n" );
+        FT_TRACE7(( "  [ %5d | %5.2g | %5s | %4d"
+                    " | %4d | %4d | %5d | %4d"
+                    " | %6d | %5d | %11s ]\n",
+                    seg - segments,
+                    dimension == AF_DIMENSION_HORZ
+                                 ? (int)seg->first->ox / 64.0
+                                 : (int)seg->first->oy / 64.0,
+                    af_dir_str( (AF_Direction)seg->dir ),
+                    AF_INDEX_NUM( seg->first, points ),
+                    AF_INDEX_NUM( seg->last, points ),
+                    AF_INDEX_NUM( seg->link, segments ),
+                    AF_INDEX_NUM( seg->serif, segments ),
+                    AF_INDEX_NUM( seg->edge, edges ),
+                    seg->height,
+                    seg->height - ( seg->max_coord - seg->min_coord ),
+                    af_edge_flags_to_string( (AF_Edge_Flags)seg->flags ) ));
+      FT_TRACE7(( "\n" ));
     }
   }
 #ifdef __cplusplus
   }
 #endif
 
 
   /* Fetch number of segments. */
 
 #ifdef __cplusplus
   extern "C" {
 #endif
   FT_Error
   af_glyph_hints_get_num_segments( AF_GlyphHints  hints,
                                    FT_Int         dimension,
                                    FT_Int*        num_segments )
   {
     AF_Dimension  dim;
     AF_AxisHints  axis;
 
 
     dim = ( dimension == 0 ) ? AF_DIMENSION_HORZ : AF_DIMENSION_VERT;
 
     axis          = &hints->axis[dim];
     *num_segments = axis->num_segments;
 
-    return AF_Err_Ok;
+    return FT_Err_Ok;
   }
 #ifdef __cplusplus
   }
 #endif
 
 
   /* Fetch offset of segments into user supplied offset array. */
 
 #ifdef __cplusplus
   extern "C" {
 #endif
   FT_Error
   af_glyph_hints_get_segment_offset( AF_GlyphHints  hints,
                                      FT_Int         dimension,
                                      FT_Int         idx,
                                      FT_Pos*        offset )
   {
     AF_Dimension  dim;
     AF_AxisHints  axis;
     AF_Segment    seg;
 
 
     if ( !offset )
-      return AF_Err_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
 
     dim = ( dimension == 0 ) ? AF_DIMENSION_HORZ : AF_DIMENSION_VERT;
 
     axis = &hints->axis[dim];
 
     if ( idx < 0 || idx >= axis->num_segments )
-      return AF_Err_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
 
     seg     = &axis->segments[idx];
-    *offset = (dim == AF_DIMENSION_HORZ) ? seg->first->ox
-                                         : seg->first->oy;
+    *offset = ( dim == AF_DIMENSION_HORZ ) ? seg->first->ox
+                                           : seg->first->oy;
 
-    return AF_Err_Ok;
+    return FT_Err_Ok;
   }
 #ifdef __cplusplus
   }
 #endif
 
 
   /* Dump the array of linked edges. */
 
 #ifdef __cplusplus
   extern "C" {
 #endif
   void
   af_glyph_hints_dump_edges( AF_GlyphHints  hints )
   {
     FT_Int  dimension;
 
 
     for ( dimension = 1; dimension >= 0; dimension-- )
     {
       AF_AxisHints  axis  = &hints->axis[dimension];
       AF_Edge       edges = axis->edges;
       AF_Edge       limit = edges + axis->num_edges;
       AF_Edge       edge;
 
 
       /*
        *  note: AF_DIMENSION_HORZ corresponds to _vertical_ edges
        *        since they have a constant X coordinate.
        */
-      printf ( "Table of %s edges:\n",
-               dimension == AF_DIMENSION_HORZ ? "vertical" : "horizontal" );
-      printf ( "  [ index |  pos  |  dir  | link |"
-               " serif | blue | opos  |  pos  |    flags    ]\n" );
+      FT_TRACE7(( "Table of %s edges:\n",
+                  dimension == AF_DIMENSION_HORZ ? "vertical"
+                                                 : "horizontal" ));
+      if ( axis->num_edges )
+        FT_TRACE7(( "  [ index |  pos  |  dir  | link"
+                    " | serif | blue | opos  |  pos  |    flags    ]\n" ));
+      else
+        FT_TRACE7(( "  (none)\n" ));
 
       for ( edge = edges; edge < limit; edge++ )
-      {
-        printf ( "  [ %5d | %5.2g | %5s | %4d |"
-                 " %5d |   %c  | %5.2f | %5.2f | %11s ]\n",
-                 edge - edges,
-                 (int)edge->opos / 64.0,
-                 af_dir_str( (AF_Direction)edge->dir ),
-                 AF_INDEX_NUM( edge->link, edges ),
-                 AF_INDEX_NUM( edge->serif, edges ),
-                 edge->blue_edge ? 'y' : 'n',
-                 edge->opos / 64.0,
-                 edge->pos / 64.0,
-                 af_edge_flags_to_string( (AF_Edge_Flags)edge->flags ) );
-      }
-      printf( "\n" );
+        FT_TRACE7(( "  [ %5d | %5.2g | %5s | %4d"
+                    " | %5d |   %c  | %5.2f | %5.2f | %11s ]\n",
+                    edge - edges,
+                    (int)edge->opos / 64.0,
+                    af_dir_str( (AF_Direction)edge->dir ),
+                    AF_INDEX_NUM( edge->link, edges ),
+                    AF_INDEX_NUM( edge->serif, edges ),
+                    edge->blue_edge ? 'y' : 'n',
+                    edge->opos / 64.0,
+                    edge->pos / 64.0,
+                    af_edge_flags_to_string( (AF_Edge_Flags)edge->flags ) ));
+      FT_TRACE7(( "\n" ));
     }
   }
 #ifdef __cplusplus
   }
 #endif
 
 #else /* !FT_DEBUG_AUTOFIT */
 
   /* these empty stubs are only used to link the `ftgrid' test program */
   /* if debugging is disabled                                          */
@@ skipping 91 matching lines @@
         ss  = dy;
       }
       else
       {
         dir = AF_DIR_DOWN;
         ll  = dy;
         ss  = dx;
       }
     }
 
-    /* return no direction if arm lengths differ too much */
-    /* (value 14 is heuristic)                            */
+    /* return no direction if arm lengths differ too much            */
+    /* (value 14 is heuristic, corresponding to approx. 4.1 degrees) */
     ss *= 14;
     if ( FT_ABS( ll ) <= FT_ABS( ss ) )
       dir = AF_DIR_NONE;
 
     return dir;
   }
 
 
   FT_LOCAL_DEF( void )
   af_glyph_hints_init( AF_GlyphHints  hints,
                        FT_Memory      memory )
   {
     FT_ZERO( hints );
     hints->memory = memory;
   }
 
 
   FT_LOCAL_DEF( void )
   af_glyph_hints_done( AF_GlyphHints  hints )
   {
-    if ( hints && hints->memory )
-    {
-      FT_Memory  memory = hints->memory;
-      int        dim;
+    FT_Memory  memory = hints->memory;
+    int        dim;
 
 
-      /*
-       *  note that we don't need to free the segment and edge
-       *  buffers since they are really within the hints->points array
-       */
-      for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
-      {
-        AF_AxisHints  axis = &hints->axis[dim];
+    if ( !( hints && hints->memory ) )
+      return;
+
+    /*
+     *  note that we don't need to free the segment and edge
+     *  buffers since they are really within the hints->points array
+     */
+    for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
+    {
+      AF_AxisHints  axis = &hints->axis[dim];
 
 
-        axis->num_segments = 0;
-        axis->max_segments = 0;
-        FT_FREE( axis->segments );
+      axis->num_segments = 0;
+      axis->max_segments = 0;
+      FT_FREE( axis->segments );
 
-        axis->num_edges = 0;
-        axis->max_edges = 0;
-        FT_FREE( axis->edges );
-      }
+      axis->num_edges = 0;
+      axis->max_edges = 0;
+      FT_FREE( axis->edges );
+    }
 
-      FT_FREE( hints->contours );
-      hints->max_contours = 0;
-      hints->num_contours = 0;
+    FT_FREE( hints->contours );
+    hints->max_contours = 0;
+    hints->num_contours = 0;
 
-      FT_FREE( hints->points );
-      hints->num_points = 0;
-      hints->max_points = 0;
+    FT_FREE( hints->points );
+    hints->num_points = 0;
+    hints->max_points = 0;
 
-      hints->memory = NULL;
-    }
+    hints->memory = NULL;
   }
 
 
   /* Reset metrics. */
 
   FT_LOCAL_DEF( void )
   af_glyph_hints_rescale( AF_GlyphHints     hints,
                           AF_ScriptMetrics  metrics )
   {
     hints->metrics      = metrics;
     hints->scaler_flags = metrics->scaler.flags;
   }
 
 
   /* Recompute all AF_Point in AF_GlyphHints from the definitions */
   /* in a source outline.                                         */
 
   FT_LOCAL_DEF( FT_Error )
   af_glyph_hints_reload( AF_GlyphHints  hints,
                          FT_Outline*    outline )
   {
-    FT_Error   error   = AF_Err_Ok;
+    FT_Error   error   = FT_Err_Ok;
     AF_Point   points;
     FT_UInt    old_max, new_max;
     FT_Fixed   x_scale = hints->x_scale;
     FT_Fixed   y_scale = hints->y_scale;
     FT_Pos     x_delta = hints->x_delta;
     FT_Pos     y_delta = hints->y_delta;
     FT_Memory  memory  = hints->memory;
 
 
     hints->num_points   = 0;
@@ skipping 153 matching lines @@
 
           next  = point->next;
           out_x = next->fx - point->fx;
           out_y = next->fy - point->fy;
 
           in_dir         = af_direction_compute( out_x, out_y );
           point->out_dir = (FT_Char)in_dir;
 
           /* check for weak points */
 
-          if ( point->flags & ( AF_FLAG_CONIC | AF_FLAG_CUBIC ) )
+          if ( point->flags & AF_FLAG_CONTROL )
           {
           Is_Weak_Point:
             point->flags |= AF_FLAG_WEAK_INTERPOLATION;
           }
           else if ( point->out_dir == point->in_dir )
           {
             if ( point->out_dir != AF_DIR_NONE )
               goto Is_Weak_Point;
 
             if ( ft_corner_is_flat( in_x, in_y, out_x, out_y ) )
@@ skipping 531 matching lines @@
     else
     {
       for ( point = points; point < points_limit; point++ )
         point->y = FT_MulFix( point->fy, scale ) + delta;
     }
   }
 
 #endif /* AF_CONFIG_OPTION_USE_WARPER */
 
 /* END */