Update freetype to latest version of ASOP.

src/cff/cffparse.c

 /***************************************************************************/
 /*                                                                         */
 /*  cffparse.c                                                             */
 /*                                                                         */
 /*    CFF token stream parser (body)                                       */
 /*                                                                         */
-/*  Copyright 1996-2004, 2007-2011 by                                      */
+/*  Copyright 1996-2004, 2007-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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
@@ skipping 40 matching lines @@
     FT_Byte*  p   = start;
     FT_Int    v   = *p++;
     FT_Long   val = 0;
 
 
     if ( v == 28 )
     {
       if ( p + 2 > limit )
         goto Bad;
 
-      val = (FT_Short)( ( (FT_Int)p[0] << 8 ) | p[1] );
+      val = (FT_Short)( ( (FT_UShort)p[0] << 8 ) | p[1] );
       p  += 2;
     }
     else if ( v == 29 )
     {
       if ( p + 4 > limit )
         goto Bad;
 
-      val = ( (FT_Long)p[0] << 24 ) |
-            ( (FT_Long)p[1] << 16 ) |
-            ( (FT_Long)p[2] <<  8 ) |
-                       p[3];
+      val = (FT_Long)( ( (FT_ULong)p[0] << 24 ) |
+                       ( (FT_ULong)p[1] << 16 ) |
+                       ( (FT_ULong)p[2] <<  8 ) |
+                         (FT_ULong)p[3]         );
       p += 4;
     }
     else if ( v < 247 )
     {
       val = v - 139;
     }
     else if ( v < 251 )
     {
       if ( p + 1 > limit )
         goto Bad;
 
       val = ( v - 247 ) * 256 + p[0] + 108;
       p++;
     }
     else
     {
       if ( p + 1 > limit )
         goto Bad;
 
       val = -( v - 251 ) * 256 - p[0] - 108;
       p++;
     }
 
   Exit:
     return val;
 
   Bad:
     val = 0;
+    FT_TRACE4(( "!!!END OF DATA:!!!" ));
     goto Exit;
   }
 
 
   static const FT_Long power_tens[] =
   {
     1L,
     10L,
     100L,
     1000L,
@@ skipping 11 matching lines @@
   cff_parse_real( FT_Byte*  start,
                   FT_Byte*  limit,
                   FT_Long   power_ten,
                   FT_Long*  scaling )
   {
     FT_Byte*  p = start;
     FT_UInt   nib;
     FT_UInt   phase;
 
     FT_Long   result, number, exponent;
-    FT_Int    sign = 0, exponent_sign = 0;
+    FT_Int    sign = 0, exponent_sign = 0, have_overflow = 0;
     FT_Long   exponent_add, integer_length, fraction_length;
 
 
     if ( scaling )
       *scaling = 0;
 
     result = 0;
 
     number   = 0;
     exponent = 0;
 
     exponent_add    = 0;
     integer_length  = 0;
     fraction_length = 0;
 
     /* First of all, read the integer part. */
     phase = 4;
 
     for (;;)
     {
       /* If we entered this iteration with phase == 4, we need to */
       /* read a new byte.  This also skips past the initial 0x1E. */
       if ( phase )
       {
         p++;
 
         /* Make sure we don't read past the end. */
         if ( p >= limit )
-          goto Exit;
+          goto Bad;
       }
 
       /* Get the nibble. */
       nib   = ( p[0] >> phase ) & 0xF;
       phase = 4 - phase;
 
       if ( nib == 0xE )
         sign = 1;
       else if ( nib > 9 )
         break;
@@ skipping 16 matching lines @@
       for (;;)
       {
         /* If we entered this iteration with phase == 4, we need */
         /* to read a new byte.                                   */
         if ( phase )
         {
           p++;
 
           /* Make sure we don't read past the end. */
           if ( p >= limit )
-            goto Exit;
+            goto Bad;
         }
 
         /* Get the nibble. */
         nib   = ( p[0] >> phase ) & 0xF;
         phase = 4 - phase;
         if ( nib >= 10 )
           break;
 
         /* Skip leading zeros if possible. */
         if ( !nib && !number )
@@ skipping 18 matching lines @@
       for (;;)
       {
         /* If we entered this iteration with phase == 4, */
         /* we need to read a new byte.                   */
         if ( phase )
         {
           p++;
 
           /* Make sure we don't read past the end. */
           if ( p >= limit )
-            goto Exit;
+            goto Bad;
         }
 
         /* Get the nibble. */
         nib   = ( p[0] >> phase ) & 0xF;
         phase = 4 - phase;
         if ( nib >= 10 )
           break;
 
-        exponent = exponent * 10 + nib;
-
         /* Arbitrarily limit exponent. */
         if ( exponent > 1000 )
-          goto Exit;
+          have_overflow = 1;
+        else
+          exponent = exponent * 10 + nib;
       }
 
       if ( exponent_sign )
         exponent = -exponent;
     }
 
+    if ( !number )
+      goto Exit;
+
+    if ( have_overflow )
+    {
+      if ( exponent_sign )
+        goto Underflow;
+      else
+        goto Overflow;
+    }
+
     /* We don't check `power_ten' and `exponent_add'. */
     exponent += power_ten + exponent_add;
 
     if ( scaling )
     {
       /* Only use `fraction_length'. */
       fraction_length += integer_length;
       exponent        += integer_length;
 
       if ( fraction_length <= 5 )
       {
         if ( number > 0x7FFFL )
         {
           result   = FT_DivFix( number, 10 );
           *scaling = exponent - fraction_length + 1;
         }
         else
         {
           if ( exponent > 0 )
           {
             FT_Long  new_fraction_length, shift;
 
 
             /* Make `scaling' as small as possible. */
             new_fraction_length = FT_MIN( exponent, 5 );
-            exponent           -= new_fraction_length;
             shift               = new_fraction_length - fraction_length;
 
-            number *= power_tens[shift];
-            if ( number > 0x7FFFL )
+            if ( shift > 0 )
             {
-              number   /= 10;
-              exponent += 1;
+              exponent -= new_fraction_length;
+              number   *= power_tens[shift];
+              if ( number > 0x7FFFL )
+              {
+                number   /= 10;
+                exponent += 1;
+              }
             }
+            else
+              exponent -= fraction_length;
           }
           else
             exponent -= fraction_length;
 
-          result   = number << 16;
+          result   = (FT_Long)( (FT_ULong)number << 16 );
           *scaling = exponent;
         }
       }
       else
       {
         if ( ( number / power_tens[fraction_length - 5] ) > 0x7FFFL )
         {
           result   = FT_DivFix( number, power_tens[fraction_length - 4] );
           *scaling = exponent - 4;
         }
         else
         {
           result   = FT_DivFix( number, power_tens[fraction_length - 5] );
           *scaling = exponent - 5;
         }
       }
     }
     else
     {
       integer_length  += exponent;
       fraction_length -= exponent;
 
-      /* Check for overflow and underflow. */
-      if ( FT_ABS( integer_length ) > 5 )
-        goto Exit;
+      if ( integer_length > 5 )
+        goto Overflow;
+      if ( integer_length < -5 )
+        goto Underflow;
 
       /* Remove non-significant digits. */
       if ( integer_length < 0 )
       {
         number          /= power_tens[-integer_length];
         fraction_length += integer_length;
       }
 
       /* this can only happen if exponent was non-zero */
       if ( fraction_length == 10 )
       {
         number          /= 10;
         fraction_length -= 1;
       }
 
       /* Convert into 16.16 format. */
       if ( fraction_length > 0 )
       {
         if ( ( number / power_tens[fraction_length] ) > 0x7FFFL )
           goto Exit;
 
         result = FT_DivFix( number, power_tens[fraction_length] );
       }
       else
       {
         number *= power_tens[-fraction_length];
 
         if ( number > 0x7FFFL )
-          goto Exit;
+          goto Overflow;
 
-        result = number << 16;
+        result = (FT_Long)( (FT_ULong)number << 16 );
       }
     }
 
+  Exit:
     if ( sign )
       result = -result;
 
-  Exit:
     return result;
+
+  Overflow:
+    result = 0x7FFFFFFFL;
+    FT_TRACE4(( "!!!OVERFLOW:!!!" ));
+    goto Exit;
+
+  Underflow:
+    result = 0;
+    FT_TRACE4(( "!!!UNDERFLOW:!!!" ));
+    goto Exit;
+
+  Bad:
+    result = 0;
+    FT_TRACE4(( "!!!END OF DATA:!!!" ));
+    goto Exit;
   }
 
 
   /* read a number, either integer or real */
   static FT_Long
   cff_parse_num( FT_Byte**  d )
   {
     return **d == 30 ? ( cff_parse_real( d[0], d[1], 0, NULL ) >> 16 )
                      :   cff_parse_integer( d[0], d[1] );
   }
 
 
   /* read a floating point number, either integer or real */
   static FT_Fixed
+  do_fixed( FT_Byte**  d,
+            FT_Long    scaling )
+  {
+    if ( **d == 30 )
+      return cff_parse_real( d[0], d[1], scaling, NULL );
+    else
+    {
+      FT_Long  val = cff_parse_integer( d[0], d[1] );
+
+
+      if ( scaling )
+        val *= power_tens[scaling];
+
+      if ( val > 0x7FFF )
+      {
+        val = 0x7FFFFFFFL;
+        goto Overflow;
+      }
+      else if ( val < -0x7FFF )
+      {
+        val = -0x7FFFFFFFL;
+        goto Overflow;
+      }
+
+      return (FT_Long)( (FT_ULong)val << 16 );
+
+    Overflow:
+      FT_TRACE4(( "!!!OVERFLOW:!!!" ));
+      return val;
+    }
+  }
+
+
+  /* read a floating point number, either integer or real */
+  static FT_Fixed
   cff_parse_fixed( FT_Byte**  d )
   {
-    return **d == 30 ? cff_parse_real( d[0], d[1], 0, NULL )
-                     : cff_parse_integer( d[0], d[1] ) << 16;
+    return do_fixed( d, 0 );
   }
 
 
   /* read a floating point number, either integer or real, */
   /* but return `10^scaling' times the number read in      */
   static FT_Fixed
   cff_parse_fixed_scaled( FT_Byte**  d,
                           FT_Long    scaling )
   {
-    return **d == 30 ? cff_parse_real( d[0], d[1], scaling, NULL )
-                     : ( cff_parse_integer( d[0], d[1] ) *
-                           power_tens[scaling] ) << 16;
+    return do_fixed( d, scaling );
   }
 
 
   /* read a floating point number, either integer or real,     */
   /* and return it as precise as possible -- `scaling' returns */
   /* the scaling factor (as a power of 10)                     */
   static FT_Fixed
   cff_parse_fixed_dynamic( FT_Byte**  d,
                            FT_Long*   scaling )
   {
@@ skipping 22 matching lines @@
         }
         else
         {
           *scaling = integer_length - 5;
           return FT_DivFix( number, power_tens[integer_length - 5] );
         }
       }
       else
       {
         *scaling = 0;
-        return number << 16;
+        return (FT_Long)( (FT_ULong)number << 16 );
       }
     }
   }
 
 
   static FT_Error
   cff_parse_font_matrix( CFF_Parser  parser )
   {
     CFF_FontRecDict  dict   = (CFF_FontRecDict)parser->object;
     FT_Matrix*       matrix = &dict->font_matrix;
     FT_Vector*       offset = &dict->font_offset;
     FT_ULong*        upm    = &dict->units_per_em;
     FT_Byte**        data   = parser->stack;
-    FT_Error         error  = CFF_Err_Stack_Underflow;
+    FT_Error         error  = FT_ERR( Stack_Underflow );
 
 
     if ( parser->top >= parser->stack + 6 )
     {
       FT_Long  scaling;
 
 
-      error = CFF_Err_Ok;
+      error = FT_Err_Ok;
 
       dict->has_font_matrix = TRUE;
 
       /* We expect a well-formed font matrix, this is, the matrix elements */
       /* `xx' and `yy' are of approximately the same magnitude.  To avoid  */
       /* loss of precision, we use the magnitude of element `xx' to scale  */
       /* all other elements.  The scaling factor is then contained in the  */
       /* `units_per_em' value.                                             */
 
       matrix->xx = cff_parse_fixed_dynamic( data++, &scaling );
@@ skipping 44 matching lines @@
 
   static FT_Error
   cff_parse_font_bbox( CFF_Parser  parser )
   {
     CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
     FT_BBox*         bbox = &dict->font_bbox;
     FT_Byte**        data = parser->stack;
     FT_Error         error;
 
 
-    error = CFF_Err_Stack_Underflow;
+    error = FT_ERR( Stack_Underflow );
 
     if ( parser->top >= parser->stack + 4 )
     {
       bbox->xMin = FT_RoundFix( cff_parse_fixed( data++ ) );
       bbox->yMin = FT_RoundFix( cff_parse_fixed( data++ ) );
       bbox->xMax = FT_RoundFix( cff_parse_fixed( data++ ) );
       bbox->yMax = FT_RoundFix( cff_parse_fixed( data   ) );
-      error = CFF_Err_Ok;
+      error = FT_Err_Ok;
 
       FT_TRACE4(( " [%d %d %d %d]\n",
                   bbox->xMin / 65536,
                   bbox->yMin / 65536,
                   bbox->xMax / 65536,
                   bbox->yMax / 65536 ));
     }
 
     return error;
   }
 
 
   static FT_Error
   cff_parse_private_dict( CFF_Parser  parser )
   {
     CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
     FT_Byte**        data = parser->stack;
     FT_Error         error;
 
 
-    error = CFF_Err_Stack_Underflow;
+    error = FT_ERR( Stack_Underflow );
 
     if ( parser->top >= parser->stack + 2 )
     {
       dict->private_size   = cff_parse_num( data++ );
       dict->private_offset = cff_parse_num( data   );
       FT_TRACE4(( " %lu %lu\n",
                   dict->private_size, dict->private_offset ));
 
-      error = CFF_Err_Ok;
+      error = FT_Err_Ok;
     }
 
     return error;
   }
 
 
   static FT_Error
   cff_parse_cid_ros( CFF_Parser  parser )
   {
     CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
     FT_Byte**        data = parser->stack;
     FT_Error         error;
 
 
-    error = CFF_Err_Stack_Underflow;
+    error = FT_ERR( Stack_Underflow );
 
     if ( parser->top >= parser->stack + 3 )
     {
       dict->cid_registry = (FT_UInt)cff_parse_num( data++ );
       dict->cid_ordering = (FT_UInt)cff_parse_num( data++ );
       if ( **data == 30 )
         FT_TRACE1(( "cff_parse_cid_ros: real supplement is rounded\n" ));
       dict->cid_supplement = cff_parse_num( data );
       if ( dict->cid_supplement < 0 )
         FT_TRACE1(( "cff_parse_cid_ros: negative supplement %d is found\n",
                    dict->cid_supplement ));
-      error = CFF_Err_Ok;
+      error = FT_Err_Ok;
 
       FT_TRACE4(( " %d %d %d\n",
                   dict->cid_registry,
                   dict->cid_ordering,
                   dict->cid_supplement ));
     }
 
     return error;
   }
 
@@ skipping 121 matching lines @@
 
     if ( clazz )
       FT_FREE( clazz );
   }
 
 
   FT_Error
   FT_Create_Class_cff_field_handlers( FT_Library           library,
                                       CFF_Field_Handler**  output_class )
   {
-    CFF_Field_Handler*  clazz;
+    CFF_Field_Handler*  clazz  = NULL;
     FT_Error            error;
     FT_Memory           memory = library->memory;
 
     int  i = 0;
 
 
 #undef CFF_FIELD
 #define CFF_FIELD( code, name, id, kind ) i++;
 #undef CFF_FIELD_DELTA
 #define CFF_FIELD_DELTA( code, name, max, id ) i++;
@@ skipping 106 matching lines @@
     clazz[i].array_max    = 0;
     clazz[i].count_offset = 0;
     clazz[i].id           = 0;
 
 
 #endif /* FT_DEBUG_LEVEL_TRACE */
 
 
     *output_class = clazz;
 
-    return CFF_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
 #endif /* FT_CONFIG_OPTION_PIC */
 
 
   FT_LOCAL_DEF( FT_Error )
   cff_parser_run( CFF_Parser  parser,
                   FT_Byte*    start,
                   FT_Byte*    limit )
   {
     FT_Byte*    p       = start;
-    FT_Error    error   = CFF_Err_Ok;
+    FT_Error    error   = FT_Err_Ok;
     FT_Library  library = parser->library;
     FT_UNUSED( library );
 
 
     parser->top    = parser->stack;
     parser->start  = start;
     parser->limit  = limit;
     parser->cursor = start;
 
     while ( p < limit )
@@ skipping 53 matching lines @@
         {
           /* two byte operator */
           p++;
           if ( p >= limit )
             goto Syntax_Error;
 
           code = 0x100 | p[0];
         }
         code = code | parser->object_code;
 
-        for ( field = FT_CFF_FIELD_HANDLERS_GET; field->kind; field++ )
+        for ( field = CFF_FIELD_HANDLERS_GET; field->kind; field++ )
         {
           if ( field->code == (FT_Int)code )
           {
             /* we found our field's handler; read it */
             FT_Long   val;
             FT_Byte*  q = (FT_Byte*)parser->object + field->offset;
 
 
 #ifdef FT_DEBUG_LEVEL_TRACE
             FT_TRACE4(( "  %s", field->id ));
@@ skipping 131 matching lines @@
         /* clear stack */
         parser->top = parser->stack;
       }
       p++;
     }
 
   Exit:
     return error;
 
   Stack_Overflow:
-    error = CFF_Err_Invalid_Argument;
+    error = FT_THROW( Invalid_Argument );
     goto Exit;
 
   Stack_Underflow:
-    error = CFF_Err_Invalid_Argument;
+    error = FT_THROW( Invalid_Argument );
     goto Exit;
 
   Syntax_Error:
-    error = CFF_Err_Invalid_Argument;
+    error = FT_THROW( Invalid_Argument );
     goto Exit;
   }
 
 
 /* END */