Update freetype to 2.5.4.

third_party/freetype/src/base/ftstroke.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftstroke.c                                                             */
 /*                                                                         */
 /*    FreeType path stroker (body).                                        */
 /*                                                                         */
-/*  Copyright 2002-2006, 2008-2011, 2013 by                                */
+/*  Copyright 2002-2006, 2008-2011, 2013, 2014 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 "../../include/ft2build.h"
-#include "../../include/freetype/ftstroke.h"
-#include "../../include/freetype/fttrigon.h"
-#include "../../include/freetype/ftoutln.h"
-#include "../../include/freetype/internal/ftmemory.h"
-#include "../../include/freetype/internal/ftdebug.h"
-#include "../../include/freetype/internal/ftobjs.h"
+#include <ft2build.h>
+#include FT_STROKER_H
+#include FT_TRIGONOMETRY_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_MEMORY_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_OBJECTS_H
 
 
   /* documentation is in ftstroke.h */
 
   FT_EXPORT_DEF( FT_StrokerBorder )
   FT_Outline_GetInsideBorder( FT_Outline*  outline )
   {
     FT_Orientation  o = FT_Outline_Get_Orientation( outline );
 
 
@@ skipping 752 matching lines @@
   FT_EXPORT_DEF( FT_Error )
   FT_Stroker_New( FT_Library   library,
                   FT_Stroker  *astroker )
   {
     FT_Error    error;           /* assigned in FT_NEW */
     FT_Memory   memory;
     FT_Stroker  stroker = NULL;
 
 
     if ( !library )
+      return FT_THROW( Invalid_Library_Handle );
+
+    if ( !astroker )
       return FT_THROW( Invalid_Argument );
 
     memory = library->memory;
 
     if ( !FT_NEW( stroker ) )
     {
       stroker->library = library;
 
       ft_stroke_border_init( &stroker->borders[0], memory );
       ft_stroke_border_init( &stroker->borders[1], memory );
     }
 
     *astroker = stroker;
 
     return error;
   }
 
 
   /* documentation is in ftstroke.h */
 
   FT_EXPORT_DEF( void )
   FT_Stroker_Set( FT_Stroker           stroker,
                   FT_Fixed             radius,
                   FT_Stroker_LineCap   line_cap,
                   FT_Stroker_LineJoin  line_join,
                   FT_Fixed             miter_limit )
   {
+    if ( !stroker )
+      return;
+
     stroker->radius      = radius;
     stroker->line_cap    = line_cap;
     stroker->line_join   = line_join;
     stroker->miter_limit = miter_limit;
 
     /* ensure miter limit has sensible value */
     if ( stroker->miter_limit < 0x10000 )
       stroker->miter_limit = 0x10000;
 
     /* save line join style:                                           */
@@ skipping 160 matching lines @@
     /* lines are long enough (line_length is zero for curves). */
     if ( !border->movable || line_length == 0 )
       intersect = FALSE;
     else
     {
       /* compute minimum required length of lines */
       FT_Fixed  min_length = ft_pos_abs( FT_MulFix( stroker->radius,
                                                     FT_Tan( theta ) ) );
 
 
-      intersect = FT_BOOL( stroker->line_length >= min_length &&
+      intersect = FT_BOOL( min_length                         &&
+                           stroker->line_length >= min_length &&
                            line_length          >= min_length );
     }
 
     if ( !intersect )
     {
       FT_Vector_From_Polar( &delta, stroker->radius,
                             stroker->angle_out + rotate );
       delta.x += stroker->center.x;
       delta.y += stroker->center.y;
 
@@ skipping 264 matching lines @@
                      FT_Vector*  to )
   {
     FT_Error         error = FT_Err_Ok;
     FT_StrokeBorder  border;
     FT_Vector        delta;
     FT_Angle         angle;
     FT_Int           side;
     FT_Fixed         line_length;
 
 
+    if ( !stroker || !to )
+      return FT_THROW( Invalid_Argument );
+
     delta.x = to->x - stroker->center.x;
     delta.y = to->y - stroker->center.y;
 
     /* a zero-length lineto is a no-op; avoid creating a spurious corner */
     if ( delta.x == 0 && delta.y == 0 )
        goto Exit;
 
     /* compute length of line */
     line_length = FT_Vector_Length( &delta );
 
@@ skipping 53 matching lines @@
                       FT_Vector*  control,
                       FT_Vector*  to )
   {
     FT_Error    error = FT_Err_Ok;
     FT_Vector   bez_stack[34];
     FT_Vector*  arc;
     FT_Vector*  limit = bez_stack + 30;
     FT_Bool     first_arc = TRUE;
 
 
+    if ( !stroker || !control || !to )
+    {
+      error = FT_THROW( Invalid_Argument );
+      goto Exit;
+    }
+
     /* if all control points are coincident, this is a no-op; */
     /* avoid creating a spurious corner                       */
     if ( FT_IS_SMALL( stroker->center.x - control->x ) &&
          FT_IS_SMALL( stroker->center.y - control->y ) &&
          FT_IS_SMALL( control->x        - to->x      ) &&
          FT_IS_SMALL( control->y        - to->y      ) )
     {
        stroker->center = *to;
        goto Exit;
     }
@@ skipping 176 matching lines @@
                       FT_Vector*  control2,
                       FT_Vector*  to )
   {
     FT_Error    error = FT_Err_Ok;
     FT_Vector   bez_stack[37];
     FT_Vector*  arc;
     FT_Vector*  limit = bez_stack + 32;
     FT_Bool     first_arc = TRUE;
 
 
+    if ( !stroker || !control1 || !control2 || !to )
+    {
+      error = FT_THROW( Invalid_Argument );
+      goto Exit;
+    }
+
     /* if all control points are coincident, this is a no-op; */
     /* avoid creating a spurious corner */
     if ( FT_IS_SMALL( stroker->center.x - control1->x ) &&
          FT_IS_SMALL( stroker->center.y - control1->y ) &&
          FT_IS_SMALL( control1->x       - control2->x ) &&
          FT_IS_SMALL( control1->y       - control2->y ) &&
          FT_IS_SMALL( control2->x       - to->x       ) &&
          FT_IS_SMALL( control2->y       - to->y       ) )
     {
        stroker->center = *to;
@@ skipping 182 matching lines @@
   }
 
 
   /* documentation is in ftstroke.h */
 
   FT_EXPORT_DEF( FT_Error )
   FT_Stroker_BeginSubPath( FT_Stroker  stroker,
                            FT_Vector*  to,
                            FT_Bool     open )
   {
+    if ( !stroker || !to )
+      return FT_THROW( Invalid_Argument );
+
     /* We cannot process the first point, because there is not enough      */
     /* information regarding its corner/cap.  The latter will be processed */
     /* in the `FT_Stroker_EndSubPath' routine.                             */
     /*                                                                     */
     stroker->first_point  = TRUE;
     stroker->center       = *to;
     stroker->subpath_open = open;
 
     /* Determine if we need to check whether the border radius is greater */
     /* than the radius of curvature of a curve, to handle this case       */
@@ skipping 80 matching lines @@
 
   /* documentation is in ftstroke.h */
 
   /* there's a lot of magic in this function! */
   FT_EXPORT_DEF( FT_Error )
   FT_Stroker_EndSubPath( FT_Stroker  stroker )
   {
     FT_Error  error = FT_Err_Ok;
 
 
+    if ( !stroker )
+    {
+      error = FT_THROW( Invalid_Argument );
+      goto Exit;
+    }
+
     if ( stroker->subpath_open )
     {
       FT_StrokeBorder  right = stroker->borders;
 
 
       /* All right, this is an opened path, we need to add a cap between */
       /* right & left, add the reverse of left, then add a final cap     */
       /* between left & right.                                           */
       error = ft_stroker_cap( stroker, stroker->angle_in, 0 );
       if ( error )
@@ skipping 105 matching lines @@
   FT_EXPORT_DEF( FT_Error )
   FT_Stroker_GetCounts( FT_Stroker  stroker,
                         FT_UInt    *anum_points,
                         FT_UInt    *anum_contours )
   {
     FT_UInt   count1, count2, num_points   = 0;
     FT_UInt   count3, count4, num_contours = 0;
     FT_Error  error;
 
 
+    if ( !stroker )
+    {
+      error = FT_THROW( Invalid_Argument );
+      goto Exit;
+    }
+
     error = ft_stroke_border_get_counts( stroker->borders + 0,
                                          &count1, &count2 );
     if ( error )
       goto Exit;
 
     error = ft_stroke_border_get_counts( stroker->borders + 1,
                                          &count3, &count4 );
     if ( error )
       goto Exit;
 
     num_points   = count1 + count3;
     num_contours = count2 + count4;
 
   Exit:
-    *anum_points   = num_points;
-    *anum_contours = num_contours;
+    if ( anum_points )
+      *anum_points   = num_points;
+
+    if ( anum_contours )
+      *anum_contours = num_contours;
+
     return error;
   }
 
 
   /* documentation is in ftstroke.h */
 
   FT_EXPORT_DEF( void )
   FT_Stroker_ExportBorder( FT_Stroker        stroker,
                            FT_StrokerBorder  border,
                            FT_Outline*       outline )
   {
+    if ( !stroker || !outline )
+      return;
+
     if ( border == FT_STROKER_BORDER_LEFT  ||
          border == FT_STROKER_BORDER_RIGHT )
     {
       FT_StrokeBorder  sborder = & stroker->borders[border];
 
 
       if ( sborder->valid )
         ft_stroke_border_export( sborder, outline );
     }
   }
@@ skipping 29 matching lines @@
     FT_Vector*  limit;
     char*       tags;
 
     FT_Error    error;
 
     FT_Int      n;         /* index of contour in outline     */
     FT_UInt     first;     /* index of first point in contour */
     FT_Int      tag;       /* current point's state           */
 
 
-    if ( !outline || !stroker )
+    if ( !outline )
+      return FT_THROW( Invalid_Outline );
+
+    if ( !stroker )
       return FT_THROW( Invalid_Argument );
 
     FT_Stroker_Rewind( stroker );
 
     first = 0;
 
     for ( n = 0; n < outline->n_contours; n++ )
     {
       FT_UInt  last;  /* index of last point in contour */
 
@@ skipping 178 matching lines @@
 #include "basepic.h"
 
 
   /* documentation is in ftstroke.h */
 
   FT_EXPORT_DEF( FT_Error )
   FT_Glyph_Stroke( FT_Glyph    *pglyph,
                    FT_Stroker   stroker,
                    FT_Bool      destroy )
   {
-    FT_Error    error   = FT_ERR( Invalid_Argument );
-    FT_Glyph    glyph   = NULL;
+    FT_Error  error = FT_ERR( Invalid_Argument );
+    FT_Glyph  glyph = NULL;
+
+    /* for FT_OUTLINE_GLYPH_CLASS_GET (in PIC mode) */
     FT_Library  library = stroker->library;
 
     FT_UNUSED( library );
 
 
-    if ( pglyph == NULL )
+    if ( !pglyph )
       goto Exit;
 
     glyph = *pglyph;
-    if ( glyph == NULL || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET )
+    if ( !glyph || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET )
       goto Exit;
 
     {
       FT_Glyph  copy;
 
 
       error = FT_Glyph_Copy( glyph, &copy );
       if ( error )
         goto Exit;
 
       glyph = copy;
     }
 
     {
       FT_OutlineGlyph  oglyph  = (FT_OutlineGlyph)glyph;
       FT_Outline*      outline = &oglyph->outline;
       FT_UInt          num_points, num_contours;
 
 
       error = FT_Stroker_ParseOutline( stroker, outline, FALSE );
       if ( error )
         goto Fail;
 
-      (void)FT_Stroker_GetCounts( stroker, &num_points, &num_contours );
+      FT_Stroker_GetCounts( stroker, &num_points, &num_contours );
 
       FT_Outline_Done( glyph->library, outline );
 
       error = FT_Outline_New( glyph->library,
                               num_points, num_contours, outline );
       if ( error )
         goto Fail;
 
       outline->n_points   = 0;
       outline->n_contours = 0;
@@ skipping 20 matching lines @@
 
 
   /* documentation is in ftstroke.h */
 
   FT_EXPORT_DEF( FT_Error )
   FT_Glyph_StrokeBorder( FT_Glyph    *pglyph,
                          FT_Stroker   stroker,
                          FT_Bool      inside,
                          FT_Bool      destroy )
   {
-    FT_Error    error   = FT_ERR( Invalid_Argument );
-    FT_Glyph    glyph   = NULL;
+    FT_Error  error = FT_ERR( Invalid_Argument );
+    FT_Glyph  glyph = NULL;
+
+    /* for FT_OUTLINE_GLYPH_CLASS_GET (in PIC mode) */
     FT_Library  library = stroker->library;
 
     FT_UNUSED( library );
 
 
-    if ( pglyph == NULL )
+    if ( !pglyph )
       goto Exit;
 
     glyph = *pglyph;
-    if ( glyph == NULL || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET )
+    if ( !glyph || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET )
       goto Exit;
 
     {
       FT_Glyph  copy;
 
 
       error = FT_Glyph_Copy( glyph, &copy );
       if ( error )
         goto Exit;
 
@@ skipping 13 matching lines @@
         if ( border == FT_STROKER_BORDER_LEFT )
           border = FT_STROKER_BORDER_RIGHT;
         else
           border = FT_STROKER_BORDER_LEFT;
       }
 
       error = FT_Stroker_ParseOutline( stroker, outline, FALSE );
       if ( error )
         goto Fail;
 
-      (void)FT_Stroker_GetBorderCounts( stroker, border,
-                                        &num_points, &num_contours );
+      FT_Stroker_GetBorderCounts( stroker, border,
+                                  &num_points, &num_contours );
 
       FT_Outline_Done( glyph->library, outline );
 
       error = FT_Outline_New( glyph->library,
                               num_points,
                               num_contours,
                               outline );
       if ( error )
         goto Fail;
 
@@ skipping 15 matching lines @@
 
     if ( !destroy )
       *pglyph = NULL;
 
   Exit:
     return error;
   }
 
 
 /* END */