Update freetype to 2.5.4.

third_party/freetype/src/cff/cf2hints.c

 /***************************************************************************/
 /*                                                                         */
 /*  cf2hints.c                                                             */
 /*                                                                         */
 /*    Adobe's code for handling CFF hints (body).                          */
 /*                                                                         */
-/*  Copyright 2007-2013 Adobe Systems Incorporated.                        */
+/*  Copyright 2007-2014 Adobe Systems Incorporated.                        */
 /*                                                                         */
 /*  This software, and all works of authorship, whether in source or       */
 /*  object code form as indicated by the copyright notice(s) included      */
 /*  herein (collectively, the "Work") is made available, and may only be   */
 /*  used, modified, and distributed under the FreeType Project License,    */
 /*  LICENSE.TXT.  Additionally, subject to the terms and conditions of the */
 /*  FreeType Project License, each contributor to the Work hereby grants   */
 /*  to any individual or legal entity exercising permissions granted by    */
 /*  the FreeType Project License and this section (hereafter, "You" or     */
 /*  "Your") a perpetual, worldwide, non-exclusive, no-charge,              */
@@ skipping 12 matching lines @@
 /*                                                                         */
 /*  By using, modifying, or distributing the Work you indicate that you    */
 /*  have read and understood the terms and conditions of the               */
 /*  FreeType Project License as well as those provided in this section,    */
 /*  and you accept them fully.                                             */
 /*                                                                         */
 /***************************************************************************/
 
 
 #include "cf2ft.h"
-#include "../../include/freetype/internal/ftdebug.h"
+#include FT_INTERNAL_DEBUG_H
 
 #include "cf2glue.h"
 #include "cf2font.h"
 #include "cf2hints.h"
 #include "cf2intrp.h"
 
 
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ skipping 246 matching lines @@
   {
     return hintmap->isValid;
   }
 
 
   /* transform character space coordinate to device space using hint map */
   static CF2_Fixed
   cf2_hintmap_map( CF2_HintMap  hintmap,
                    CF2_Fixed    csCoord )
   {
-    FT_ASSERT( hintmap->isValid );  /* must call Build before Map */
-    FT_ASSERT( hintmap->lastIndex < CF2_MAX_HINT_EDGES );
-
     if ( hintmap->count == 0 || ! hintmap->hinted )
     {
       /* there are no hints; use uniform scale and zero offset */
       return FT_MulFix( csCoord, hintmap->scale );
     }
     else
     {
       /* start linear search from last hit */
       CF2_UInt  i = hintmap->lastIndex;
 
+      FT_ASSERT( hintmap->lastIndex < CF2_MAX_HINT_EDGES );
 
       /* search up */
       while ( i < hintmap->count - 1                  &&
               csCoord >= hintmap->edge[i + 1].csCoord )
         i += 1;
 
       /* search down */
       while ( i > 0 && csCoord < hintmap->edge[i].csCoord )
         i -= 1;
 
@@ skipping 259 matching lines @@
     }
 
     /* paired edges must be in proper order */
     FT_ASSERT( !isPair                                         ||
                topHintEdge->csCoord >= bottomHintEdge->csCoord );
 
     /* linear search to find index value of insertion point */
     indexInsert = 0;
     for ( ; indexInsert < hintmap->count; indexInsert++ )
     {
-      if ( hintmap->edge[indexInsert].csCoord > firstHintEdge->csCoord )
+      if ( hintmap->edge[indexInsert].csCoord >= firstHintEdge->csCoord )
         break;
     }
 
     /*
-     * Discard any hints that overlap in character space.  Most often,
-     * this is while building the initial map, but in theory, it can also
-     * occur because of darkening.
+     * Discard any hints that overlap in character space.  Most often, this
+     * is while building the initial map, where captured hints from all
+     * zones are combined.  Define overlap to include hints that `touch'
+     * (overlap zero).  Hiragino Sans/Gothic fonts have numerous hints that
+     * touch.  Some fonts have non-ideographic glyphs that overlap our
+     * synthetic hints.
+     *
+     * Overlap also occurs when darkening stem hints that are close.
      *
      */
     if ( indexInsert < hintmap->count )
     {
-      /* we are inserting before an existing edge:              */
+      /* we are inserting before an existing edge:    */
+      /* verify that an existing edge is not the same */
+      if ( hintmap->edge[indexInsert].csCoord == firstHintEdge->csCoord )
+        return; /* ignore overlapping stem hint */
+
       /* verify that a new pair does not straddle the next edge */
-      if ( isPair                                                       &&
-           hintmap->edge[indexInsert].csCoord < secondHintEdge->csCoord )
+      if ( isPair                                                        &&
+           hintmap->edge[indexInsert].csCoord <= secondHintEdge->csCoord )
         return; /* ignore overlapping stem hint */
 
       /* verify that we are not inserting between paired edges */
       if ( cf2_hint_isPairTop( &hintmap->edge[indexInsert] ) )
         return; /* ignore overlapping stem hint */
     }
 
     /* recompute device space locations using initial hint map */
     if ( cf2_hintmap_isValid( hintmap->initialHintMap ) &&
          !cf2_hint_isLocked( firstHintEdge )            )
@@ skipping 13 matching lines @@
 
 
         firstHintEdge->dsCoord  = midpoint - halfWidth;
         secondHintEdge->dsCoord = midpoint + halfWidth;
       }
       else
         firstHintEdge->dsCoord = cf2_hintmap_map( hintmap->initialHintMap,
                                                   firstHintEdge->csCoord );
     }
 
-    /* discard any hints that overlap in device space; this can occur */
-    /* because locked hints have been moved to align with blue zones  */
+    /*
+     * Discard any hints that overlap in device space; this can occur
+     * because locked hints have been moved to align with blue zones.
+     *
+     * TODO: Although we might correct this later during adjustment, we
+     * don't currently have a way to delete a conflicting hint once it has
+     * been inserted.  See v2.030 MinionPro-Regular, 12 ppem darkened,
+     * initial hint map for second path, glyph 945 (the perispomeni (tilde)
+     * in U+1F6E, Greek omega with psili and perispomeni).  Darkening is
+     * 25.  Pair 667,747 initially conflicts in design space with top edge
+     * 660.  This is because 667 maps to 7.87, and the top edge was
+     * captured by a zone at 8.0.  The pair is later successfully inserted
+     * in a zone without the top edge.  In this zone it is adjusted to 8.0,
+     * and no longer conflicts with the top edge in design space.  This
+     * means it can be included in yet a later zone which does have the top
+     * edge hint.  This produces a small mismatch between the first and
+     * last points of this path, even though the hint masks are the same.
+     * The density map difference is tiny (1/256).
+     *
+     */
+
     if ( indexInsert > 0 )
     {
       /* we are inserting after an existing edge */
       if ( firstHintEdge->dsCoord < hintmap->edge[indexInsert - 1].dsCoord )
         return;
     }
 
     if ( indexInsert < hintmap->count )
     {
       /* we are inserting before an existing edge */
@@ skipping 58 matching lines @@
    */
   FT_LOCAL_DEF( void )
   cf2_hintmap_build( CF2_HintMap   hintmap,
                      CF2_ArrStack  hStemHintArray,
                      CF2_ArrStack  vStemHintArray,
                      CF2_HintMask  hintMask,
                      CF2_Fixed     hintOrigin,
                      FT_Bool       initialMap )
   {
     FT_Byte*  maskPtr;
-        FT_Byte*  maskEndPtr;   // add by Xiaochuan_Liu
 
     CF2_Font         font = hintmap->font;
     CF2_HintMaskRec  tempHintMask;
 
     size_t   bitCount, i;
     FT_Byte  maskByte;
 
 
     /* check whether initial map is constructed */
     if ( !initialMap && !cf2_hintmap_isValid( hintmap->initialHintMap ) )
     {
       /* make recursive call with initialHintMap and temporary mask; */
       /* temporary mask will get all bits set, below */
       cf2_hintmask_init( &tempHintMask, hintMask->error );
       cf2_hintmap_build( hintmap->initialHintMap,
                          hStemHintArray,
                          vStemHintArray,
                          &tempHintMask,
                          hintOrigin,
                          TRUE );
     }
 
     if ( !cf2_hintmask_isValid( hintMask ) )
     {
       /* without a hint mask, assume all hints are active */
       cf2_hintmask_setAll( hintMask,
                            cf2_arrstack_size( hStemHintArray ) +
                              cf2_arrstack_size( vStemHintArray ) );
+      if ( !cf2_hintmask_isValid( hintMask ) )
+          return;                   /* too many stem hints */
     }
 
     /* begin by clearing the map */
     hintmap->count     = 0;
     hintmap->lastIndex = 0;
 
     /* make a copy of the hint mask so we can modify it */
     tempHintMask = *hintMask;
     maskPtr      = cf2_hintmask_getMaskPtr( &tempHintMask );
-        maskEndPtr   = maskPtr + ( CF2_MAX_HINTS + 7 ) / 8;
-
 
     /* use the hStem hints only, which are first in the mask */
-    /* TODO: compare this to cffhintmaskGetBitCount */
     bitCount = cf2_arrstack_size( hStemHintArray );
 
+    /* Defense-in-depth.  Should never return here. */
+    if ( bitCount > hintMask->bitCount )
+        return;
+
     /* synthetic embox hints get highest priority */
     if ( font->blues.doEmBoxHints )
     {
       CF2_HintRec  dummy;
 
 
       cf2_hint_initZero( &dummy );   /* invalid hint map element */
 
       /* ghost bottom */
       cf2_hintmap_insertHint( hintmap,
@@ skipping 40 matching lines @@
           cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge );
 
           *maskPtr &= ~maskByte;      /* turn off the bit for this hint */
         }
       }
 
       if ( ( i & 7 ) == 7 )
       {
         /* move to next mask byte */
         maskPtr++;
-                if (maskPtr >= maskEndPtr)
-                {
-                        break;
-                }
-                
         maskByte = 0x80;
       }
       else
         maskByte >>= 1;
     }
 
     /* initial hint map includes only captured hints plus maybe one at 0 */
 
     /*
      * TODO: There is a problem here because we are trying to build a
@@ skipping 40 matching lines @@
 
         cf2_hint_initZero( &invalid );
         cf2_hintmap_insertHint( hintmap, &edge, &invalid );
       }
     }
     else
     {
       /* insert remaining hints */
 
       maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask );
-          maskEndPtr   = maskPtr + ( CF2_MAX_HINTS + 7 ) / 8;
 
       for ( i = 0, maskByte = 0x80; i < bitCount; i++ )
       {
         if ( maskByte & *maskPtr )
         {
           CF2_HintRec  bottomHintEdge, topHintEdge;
 
 
           cf2_hint_init( &bottomHintEdge,
                          hStemHintArray,
@@ skipping 10 matching lines @@
                          hintmap->scale,
                          FALSE /* top */ );
 
           cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge );
         }
 
         if ( ( i & 7 ) == 7 )
         {
           /* move to next mask byte */
           maskPtr++;
-                  if (maskPtr >= maskEndPtr)
-                  {
-                        break;
-                  }
           maskByte = 0x80;
         }
         else
           maskByte >>= 1;
       }
     }
 
     /*
      * Note: The following line is a convenient place to break when
      *       debugging hinting.  Examine `hintmap->edge' for the list of
@@ skipping 98 matching lines @@
     glyphpath->yOffset        = font->darkenY;
     glyphpath->miterLimit     = 2 * FT_MAX(
                                      cf2_fixedAbs( glyphpath->xOffset ),
                                      cf2_fixedAbs( glyphpath->yOffset ) );
 
     /* .1 character space unit */
     glyphpath->snapThreshold = cf2_floatToFixed( 0.1f );
 
     glyphpath->moveIsPending = TRUE;
     glyphpath->pathIsOpen    = FALSE;
+    glyphpath->pathIsClosing = FALSE;
     glyphpath->elemIsQueued  = FALSE;
   }
 
 
   FT_LOCAL_DEF( void )
   cf2_glyphpath_finalize( CF2_GlyphPath  glyphpath )
   {
     cf2_arrstack_finalize( &glyphpath->hintMoves );
   }
 
@@ skipping 120 matching lines @@
            glyphpath->miterLimit                                   )
       return FALSE;
 
     return TRUE;
   }
 
 
   /*
    * Push the cached element (glyphpath->prevElem*) to the outline
    * consumer.  When a darkening offset is used, the end point of the
-   * cached element may be adjusted to an intersection point or it may be
-   * connected by a line to the current element.  This calculation must
-   * use a HintMap that was valid at the time the element was saved.  For
-   * the first point in a subpath, that is a saved HintMap.  For most
-   * elements, it just means the caller has delayed building a HintMap
-   * from the current HintMask.
+   * cached element may be adjusted to an intersection point or we may
+   * synthesize a connecting line to the current element.  If we are
+   * closing a subpath, we may also generate a connecting line to the start
+   * point.
+   *
+   * This is where Character Space (CS) is converted to Device Space (DS)
+   * using a hint map.  This calculation must use a HintMap that was valid
+   * at the time the element was saved.  For the first point in a subpath,
+   * that is a saved HintMap.  For most elements, it just means the caller
+   * has delayed building a HintMap from the current HintMask.
    *
    * Transform each point with outerTransform and call the outline
    * callbacks.  This is a general 3x3 transform:
    *
    *   x' = a*x + c*y + tx, y' = b*x + d*y + ty
    *
    * but it uses 4 elements from CF2_Font and the translation part
    * from CF2_GlyphPath.
    *
    */
@@ skipping 49 matching lines @@
     }
 
     params.pt0 = glyphpath->currentDS;
 
     switch( glyphpath->prevElemOp )
     {
     case CF2_PathOpLineTo:
       params.op = CF2_PathOpLineTo;
 
       /* note: pt2 and pt3 are unused */
-      cf2_glyphpath_hintPoint( glyphpath,
-                               hintmap,
-                               &params.pt1,
-                               glyphpath->prevElemP1.x,
-                               glyphpath->prevElemP1.y );
 
-      glyphpath->callbacks->lineTo( glyphpath->callbacks, &params );
+      if ( close )
+      {
+        /* use first hint map if closing */
+        cf2_glyphpath_hintPoint( glyphpath,
+                                 &glyphpath->firstHintMap,
+                                 &params.pt1,
+                                 glyphpath->prevElemP1.x,
+                                 glyphpath->prevElemP1.y );
+      }
+      else
+      {
+        cf2_glyphpath_hintPoint( glyphpath,
+                                 hintmap,
+                                 &params.pt1,
+                                 glyphpath->prevElemP1.x,
+                                 glyphpath->prevElemP1.y );
+      }
 
-      glyphpath->currentDS = params.pt1;
+      /* output only non-zero length lines */
+      if ( params.pt0.x != params.pt1.x || params.pt0.y != params.pt1.y )
+      {
+        glyphpath->callbacks->lineTo( glyphpath->callbacks, &params );
 
+        glyphpath->currentDS = params.pt1;
+      }
       break;
 
     case CF2_PathOpCubeTo:
       params.op = CF2_PathOpCubeTo;
 
       /* TODO: should we intersect the interior joins (p1-p2 and p2-p3)? */
       cf2_glyphpath_hintPoint( glyphpath,
                                hintmap,
                                &params.pt1,
                                glyphpath->prevElemP1.x,
@@ skipping 16 matching lines @@
       break;
     }
 
     if ( !useIntersection || close )
     {
       /* insert connecting line between end of previous element and start */
       /* of current one                                                   */
       /* note: at the end of a subpath, we might do both, so use `nextP0' */
       /* before we change it, below                                       */
 
-      cf2_glyphpath_hintPoint( glyphpath,
-                               hintmap,
-                               &params.pt1,
-                               nextP0->x,
-                               nextP0->y );
+      if ( close )
+      {
+        /* if we are closing the subpath, then nextP0 is in the first     */
+        /* hint zone                                                      */
+        cf2_glyphpath_hintPoint( glyphpath,
+                                 &glyphpath->firstHintMap,
+                                 &params.pt1,
+                                 nextP0->x,
+                                 nextP0->y );
+      }
+      else
+      {
+        cf2_glyphpath_hintPoint( glyphpath,
+                                 hintmap,
+                                 &params.pt1,
+                                 nextP0->x,
+                                 nextP0->y );
+      }
 
       if ( params.pt1.x != glyphpath->currentDS.x ||
            params.pt1.y != glyphpath->currentDS.y )
       {
         /* length is nonzero */
         params.op  = CF2_PathOpLineTo;
         params.pt0 = glyphpath->currentDS;
 
         /* note: pt2 and pt3 are unused */
         glyphpath->callbacks->lineTo( glyphpath->callbacks, &params );
@@ skipping 175 matching lines @@
         if ( -dx > -2 * dy )
         {
           /* -x */
           *x = 0;
           *y = 2 * glyphpath->yOffset;
         }
         else if ( -dy > -2 * dx )
         {
           /* -y */
           *x = -glyphpath->xOffset;
-          *y = glyphpath->xOffset;
+          *y = glyphpath->yOffset;
         }
         else
         {
           /* -x -y */
           *x = FT_MulFix( cf2_floatToFixed( -0.7 ),
                           glyphpath->xOffset );
           *y = FT_MulFix( cf2_floatToFixed( 1.0 + 0.7 ),
                           glyphpath->yOffset );
         }
       }
     }
   }
 
 
+  /*
+   * The functions cf2_glyphpath_{moveTo,lineTo,curveTo,closeOpenPath} are
+   * called by the interpreter with Character Space (CS) coordinates.  Each
+   * path element is placed into a queue of length one to await the
+   * calculation of the following element.  At that time, the darkening
+   * offset of the following element is known and joins can be computed,
+   * including possible modification of this element, before mapping to
+   * Device Space (DS) and passing it on to the outline consumer.
+   *
+   */
   FT_LOCAL_DEF( void )
   cf2_glyphpath_moveTo( CF2_GlyphPath  glyphpath,
                         CF2_Fixed      x,
                         CF2_Fixed      y )
   {
     cf2_glyphpath_closeOpenPath( glyphpath );
 
     /* save the parameters of the move for later, when we'll know how to */
     /* offset it;                                                        */
     /* also save last move point */
@@ skipping 17 matching lines @@
   }
 
 
   FT_LOCAL_DEF( void )
   cf2_glyphpath_lineTo( CF2_GlyphPath  glyphpath,
                         CF2_Fixed      x,
                         CF2_Fixed      y )
   {
     CF2_Fixed  xOffset, yOffset;
     FT_Vector  P0, P1;
+    FT_Bool    newHintMap;
 
+    /*
+     * New hints will be applied after cf2_glyphpath_pushPrevElem has run.
+     * In case this is a synthesized closing line, any new hints should be
+     * delayed until this path is closed (`cf2_hintmask_isNew' will be
+     * called again before the next line or curve).
+     */
 
-    /* can't compute offset of zero length line, so ignore them */
-    if ( glyphpath->currentCS.x == x && glyphpath->currentCS.y == y )
+    /* true if new hint map not on close */
+    newHintMap = cf2_hintmask_isNew( glyphpath->hintMask ) &&
+                 !glyphpath->pathIsClosing;
+
+    /*
+     * Zero-length lines may occur in the charstring.  Because we cannot
+     * compute darkening offsets or intersections from zero-length lines,
+     * it is best to remove them and avoid artifacts.  However, zero-length
+     * lines in CS at the start of a new hint map can generate non-zero
+     * lines in DS due to hint substitution.  We detect a change in hint
+     * map here and pass those zero-length lines along.
+     */
+
+    /*
+     * Note: Find explicitly closed paths here with a conditional
+     *       breakpoint using
+     *
+     *         !gp->pathIsClosing && gp->start.x == x && gp->start.y == y
+     *
+     */
+
+    if ( glyphpath->currentCS.x == x &&
+         glyphpath->currentCS.y == y &&
+         !newHintMap                 )
+      /*
+       * Ignore zero-length lines in CS where the hint map is the same
+       * because the line in DS will also be zero length.
+       *
+       * Ignore zero-length lines when we synthesize a closing line because
+       * the close will be handled in cf2_glyphPath_pushPrevElem.
+       */
       return;
 
     cf2_glyphpath_computeOffset( glyphpath,
                                  glyphpath->currentCS.x,
                                  glyphpath->currentCS.y,
                                  x,
                                  y,
                                  &xOffset,
                                  &yOffset );
 
     /* construct offset points */
     P0.x = glyphpath->currentCS.x + xOffset;
     P0.y = glyphpath->currentCS.y + yOffset;
     P1.x = x + xOffset;
     P1.y = y + yOffset;
 
     if ( glyphpath->moveIsPending )
     {
       /* emit offset 1st point as MoveTo */
       cf2_glyphpath_pushMove( glyphpath, P0 );
-          if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
 
       glyphpath->moveIsPending = FALSE;  /* adjust state machine */
       glyphpath->pathIsOpen    = TRUE;
 
       glyphpath->offsetStart1 = P1;              /* record second point */
     }
 
     if ( glyphpath->elemIsQueued )
     {
-      FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) );
+      FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) ||
+                 glyphpath->hintMap.count == 0              );
 
       cf2_glyphpath_pushPrevElem( glyphpath,
                                   &glyphpath->hintMap,
                                   &P0,
                                   P1,
                                   FALSE );
-          if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
     }
 
     /* queue the current element with offset points */
     glyphpath->elemIsQueued = TRUE;
     glyphpath->prevElemOp   = CF2_PathOpLineTo;
     glyphpath->prevElemP0   = P0;
     glyphpath->prevElemP1   = P1;
 
     /* update current map */
-    if ( cf2_hintmask_isNew( glyphpath->hintMask ) )
+    if ( newHintMap )
       cf2_hintmap_build( &glyphpath->hintMap,
                          glyphpath->hStemHintArray,
                          glyphpath->vStemHintArray,
                          glyphpath->hintMask,
                          glyphpath->hintOriginY,
                          FALSE );
 
     glyphpath->currentCS.x = x;     /* pre-offset current point */
     glyphpath->currentCS.y = y;
   }
@@ skipping 40 matching lines @@
     /* note: preserve angle of final segment by using offset3 at both ends */
     P2.x = x2 + xOffset3;
     P2.y = y2 + yOffset3;
     P3.x = x3 + xOffset3;
     P3.y = y3 + yOffset3;
 
     if ( glyphpath->moveIsPending )
     {
       /* emit offset 1st point as MoveTo */
       cf2_glyphpath_pushMove( glyphpath, P0 );
-          if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
 
       glyphpath->moveIsPending = FALSE;
       glyphpath->pathIsOpen    = TRUE;
 
       glyphpath->offsetStart1 = P1;              /* record second point */
     }
 
     if ( glyphpath->elemIsQueued )
     {
-      FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) );
+      FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) ||
+                 glyphpath->hintMap.count == 0              );
 
       cf2_glyphpath_pushPrevElem( glyphpath,
                                   &glyphpath->hintMap,
                                   &P0,
                                   P1,
                                   FALSE );
-          if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
     }
 
     /* queue the current element with offset points */
     glyphpath->elemIsQueued = TRUE;
     glyphpath->prevElemOp   = CF2_PathOpCubeTo;
     glyphpath->prevElemP0   = P0;
     glyphpath->prevElemP1   = P1;
     glyphpath->prevElemP2   = P2;
     glyphpath->prevElemP3   = P3;
 
     /* update current map */
     if ( cf2_hintmask_isNew( glyphpath->hintMask ) )
       cf2_hintmap_build( &glyphpath->hintMap,
                          glyphpath->hStemHintArray,
                          glyphpath->vStemHintArray,
                          glyphpath->hintMask,
                          glyphpath->hintOriginY,
                          FALSE );
 
     glyphpath->currentCS.x = x3;       /* pre-offset current point */
     glyphpath->currentCS.y = y3;
   }
 
 
   FT_LOCAL_DEF( void )
   cf2_glyphpath_closeOpenPath( CF2_GlyphPath  glyphpath )
   {
     if ( glyphpath->pathIsOpen )
     {
-      FT_ASSERT( cf2_hintmap_isValid( &glyphpath->firstHintMap ) );
+      /*
+       * A closing line in Character Space line is always generated below
+       * with `cf2_glyphPath_lineTo'.  It may be ignored later if it turns
+       * out to be zero length in Device Space.
+       */
+      glyphpath->pathIsClosing = TRUE;
 
-      /* since we need to apply an offset to the implicit lineto, we make */
-      /* it explicit here                                                 */
       cf2_glyphpath_lineTo( glyphpath,
                             glyphpath->start.x,
                             glyphpath->start.y );
-          if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
 
-      /* Draw previous element (the explicit LineTo we just created,      */
-      /* above) and connect it to the start point, but with the offset we */
-      /* saved from the first element.                                    */
-      /* Use the saved HintMap, too. */
-      FT_ASSERT( glyphpath->elemIsQueued );
-
-      cf2_glyphpath_pushPrevElem( glyphpath,
-                                  &glyphpath->firstHintMap,
-                                  &glyphpath->offsetStart0,
-                                  glyphpath->offsetStart1,
-                                  TRUE );
+      /* empty the final element from the queue and close the path */
+      if ( glyphpath->elemIsQueued )
+        cf2_glyphpath_pushPrevElem( glyphpath,
+                                    &glyphpath->hintMap,
+                                    &glyphpath->offsetStart0,
+                                    glyphpath->offsetStart1,
+                                    TRUE );
 
       /* reset state machine */
       glyphpath->moveIsPending = TRUE;
       glyphpath->pathIsOpen    = FALSE;
+      glyphpath->pathIsClosing = FALSE;
       glyphpath->elemIsQueued  = FALSE;
     }
   }
 
 
 /* END */