Update bundled freetype to 2.6.1

third_party/freetype/src/cff/cf2intrp.c

 /***************************************************************************/
 /*                                                                         */
 /*  cf2intrp.c                                                             */
 /*                                                                         */
 /*    Adobe's CFF Interpreter (body).                                      */
 /*                                                                         */
 /*  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      */
@@ skipping 25 matching lines @@
 /***************************************************************************/
 
 
 #include "cf2ft.h"
 #include FT_INTERNAL_DEBUG_H
 
 #include "cf2glue.h"
 #include "cf2font.h"
 #include "cf2stack.h"
 #include "cf2hints.h"
+#include "cf2intrp.h"
 
 #include "cf2error.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.                                            */
   /*                                                                       */
@@ skipping 697 matching lines @@
 
           if ( charstringIndex > CF2_MAX_SUBR )
           {
             /* max subr plus one for charstring */
             lastError = FT_THROW( Invalid_Glyph_Format );
             goto exit;                      /* overflow of stack */
           }
 
           /* push our current CFF charstring region on subrStack */
           charstring = (CF2_Buffer)
-                         cf2_arrstack_getPointer( &subrStack,
-                                                  charstringIndex + 1 );
+                         cf2_arrstack_getPointer(
+                           &subrStack,
+                           (size_t)charstringIndex + 1 );
 
           /* set up the new CFF region and pointer */
-          subrIndex = cf2_stack_popInt( opStack );
+          subrIndex = (CF2_UInt)cf2_stack_popInt( opStack );
 
           switch ( op1 )
           {
           case cf2_cmdCALLGSUBR:
-            FT_TRACE4(( "(%d)\n", subrIndex + decoder->globals_bias ));
+            FT_TRACE4(( " (idx %d, entering level %d)\n",
+                        subrIndex + (CF2_UInt)decoder->globals_bias,
+                        charstringIndex + 1 ));
 
             if ( cf2_initGlobalRegionBuffer( decoder,
                                              subrIndex,
                                              charstring ) )
             {
               lastError = FT_THROW( Invalid_Glyph_Format );
               goto exit;  /* subroutine lookup or stream error */
             }
             break;
 
           default:
             /* cf2_cmdCALLSUBR */
-            FT_TRACE4(( "(%d)\n", subrIndex + decoder->locals_bias ));
+            FT_TRACE4(( " (idx %d, entering level %d)\n",
+                        subrIndex + (CF2_UInt)decoder->locals_bias,
+                        charstringIndex + 1 ));
 
             if ( cf2_initLocalRegionBuffer( decoder,
                                             subrIndex,
                                             charstring ) )
             {
               lastError = FT_THROW( Invalid_Glyph_Format );
               goto exit;  /* subroutine lookup or stream error */
             }
           }
 
           charstringIndex += 1;       /* entry is valid now */
         }
         continue; /* do not clear the stack */
 
       case cf2_cmdRETURN:
-        FT_TRACE4(( " return\n" ));
+        FT_TRACE4(( " return (leaving level %d)\n", charstringIndex ));
 
         if ( charstringIndex < 1 )
         {
           /* Note: cannot return from top charstring */
           lastError = FT_THROW( Invalid_Glyph_Format );
           goto exit;                      /* underflow of stack */
         }
 
         /* restore position in previous charstring */
         charstring = (CF2_Buffer)
-                       cf2_arrstack_getPointer( &subrStack,
-                                                --charstringIndex );
+                       cf2_arrstack_getPointer(
+                         &subrStack,
+                         (CF2_UInt)--charstringIndex );
         continue;     /* do not clear the stack */
 
       case cf2_cmdESC:
         {
           FT_Byte  op2 = (FT_Byte)cf2_buf_readByte( charstring );
 
 
           switch ( op2 )
           {
           case cf2_escDOTSECTION:
@@ skipping 257 matching lines @@
             goto exit;
 
         /* close path if still open */
         cf2_glyphpath_closeOpenPath( &glyphPath );
 
         if ( cf2_stack_count( opStack ) > 1 )
         {
           /* must be either 4 or 5 --                       */
           /* this is a (deprecated) implied `seac' operator */
 
-          CF2_UInt       achar;
-          CF2_UInt       bchar;
+          CF2_Int        achar;
+          CF2_Int        bchar;
           CF2_BufferRec  component;
           CF2_Fixed      dummyWidth;   /* ignore component width */
           FT_Error       error2;
 
 
           if ( doingSeac )
           {
             lastError = FT_THROW( Invalid_Glyph_Format );
             goto exit;      /* nested seac */
           }
@@ skipping 181 matching lines @@
             curY   = y3;
             index += 6;
           }
 
           cf2_stack_clear( opStack );
         }
         continue; /* no need to clear stack again */
 
       case cf2_cmdVVCURVETO:
         {
-          CF2_UInt  count = cf2_stack_count( opStack );
+          CF2_UInt  count, count1 = cf2_stack_count( opStack );
           CF2_UInt  index = 0;
 
 
+          /* if `cf2_stack_count' isn't of the form 4n or 4n+1, */
+          /* we enforce it by clearing the second bit           */
+          /* (and sorting the stack indexing to suit)           */
+          count  = count1 & ~2U;
+          index += count1 - count;
+
           FT_TRACE4(( " vvcurveto\n" ));
 
           while ( index < count )
           {
             CF2_Fixed  x1, y1, x2, y2, x3, y3;
 
 
             if ( ( count - index ) & 1 )
             {
               x1 = cf2_stack_getReal( opStack, index ) + curX;
@@ skipping 15 matching lines @@
             curY   = y3;
             index += 4;
           }
 
           cf2_stack_clear( opStack );
         }
         continue; /* no need to clear stack again */
 
       case cf2_cmdHHCURVETO:
         {
-          CF2_UInt  count = cf2_stack_count( opStack );
+          CF2_UInt  count, count1 = cf2_stack_count( opStack );
           CF2_UInt  index = 0;
 
 
+          /* if `cf2_stack_count' isn't of the form 4n or 4n+1, */
+          /* we enforce it by clearing the second bit           */
+          /* (and sorting the stack indexing to suit)           */
+          count  = count1 & ~2U;
+          index += count1 - count;
+
           FT_TRACE4(( " hhcurveto\n" ));
 
           while ( index < count )
           {
             CF2_Fixed  x1, y1, x2, y2, x3, y3;
 
 
             if ( ( count - index ) & 1 )
             {
               y1 = cf2_stack_getReal( opStack, index ) + curY;
@@ skipping 16 matching lines @@
             index += 4;
           }
 
           cf2_stack_clear( opStack );
         }
         continue; /* no need to clear stack again */
 
       case cf2_cmdVHCURVETO:
       case cf2_cmdHVCURVETO:
         {
-          CF2_UInt  count = cf2_stack_count( opStack );
+          CF2_UInt  count, count1 = cf2_stack_count( opStack );
           CF2_UInt  index = 0;
 
           FT_Bool  alternate = op1 == cf2_cmdHVCURVETO;
 
 
+          /* if `cf2_stack_count' isn't of the form 8n, 8n+1, */
+          /* 8n+4, or 8n+5, we enforce it by clearing the     */
+          /* second bit                                       */
+          /* (and sorting the stack indexing to suit)         */
+          count  = count1 & ~2U;
+          index += count1 - count;
+
           FT_TRACE4(( alternate ? " hvcurveto\n" : " vhcurveto\n" ));
 
           while ( index < count )
           {
             CF2_Fixed x1, x2, x3, y1, y2, y3;
 
 
             if ( alternate )
             {
               x1 = cf2_stack_getReal( opStack, index + 0 ) + curX;
@@ skipping 147 matching lines @@
     cf2_arrstack_finalize( &subrStack );
     cf2_stack_free( opStack );
 
     FT_TRACE4(( "\n" ));
 
     return;
   }
 
 
 /* END */