Update freetype to the latest version of Android external/freetype

src/cff/cffparse.c

 /***************************************************************************/
 /*                                                                         */
 /*  cffparse.c                                                             */
 /*                                                                         */
 /*    CFF token stream parser (body)                                       */
 /*                                                                         */
 /*  Copyright 1996-2004, 2007-2011 by                                      */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ skipping 442 matching lines @@
     FT_Error         error  = CFF_Err_Stack_Underflow;
 
 
     if ( parser->top >= parser->stack + 6 )
     {
       FT_Long  scaling;
 
 
       error = CFF_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 );
 
       scaling = -scaling;
 
@@ skipping 18 matching lines @@
       }
 
       matrix->yx = cff_parse_fixed_scaled( data++, scaling );
       matrix->xy = cff_parse_fixed_scaled( data++, scaling );
       matrix->yy = cff_parse_fixed_scaled( data++, scaling );
       offset->x  = cff_parse_fixed_scaled( data++, scaling );
       offset->y  = cff_parse_fixed_scaled( data,   scaling );
 
       *upm = power_tens[scaling];
 
-      FT_TRACE4(( " font matrix: [%f %f %f %f]\n",
+      FT_TRACE4(( " [%f %f %f %f %f %f]\n",
                   (double)matrix->xx / *upm / 65536,
                   (double)matrix->xy / *upm / 65536,
                   (double)matrix->yx / *upm / 65536,
-                  (double)matrix->yy / *upm / 65536 ));
+                  (double)matrix->yy / *upm / 65536,
+                  (double)offset->x  / *upm / 65536,
+                  (double)offset->y  / *upm / 65536 ));
     }
 
   Exit:
     return error;
   }
 
 
   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;
 
     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;
 
-      FT_TRACE4(( " bbox: [%d %d %d %d]\n",
+      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;
 
     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;
     }
 
     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;
 
     if ( parser->top >= parser->stack + 3 )
     {
-      dict->cid_registry   = (FT_UInt)cff_parse_num( data++ );
-      dict->cid_ordering   = (FT_UInt)cff_parse_num( data++ );
+      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;
 
-      FT_TRACE4(( " ROS: registry sid %d, ordering sid %d, supplement %d\n",
+      FT_TRACE4(( " %d %d %d\n",
                   dict->cid_registry,
                   dict->cid_ordering,
                   dict->cid_supplement ));
     }
 
     return error;
   }
 
 
-#define CFF_FIELD_NUM( code, name ) \
-          CFF_FIELD( code, name, cff_kind_num )
-#define CFF_FIELD_FIXED( code, name ) \
-          CFF_FIELD( code, name, cff_kind_fixed )
-#define CFF_FIELD_FIXED_1000( code, name ) \
-          CFF_FIELD( code, name, cff_kind_fixed_thousand )
-#define CFF_FIELD_STRING( code, name ) \
-          CFF_FIELD( code, name, cff_kind_string )
-#define CFF_FIELD_BOOL( code, name ) \
-          CFF_FIELD( code, name, cff_kind_bool )
-#define CFF_FIELD_DELTA( code, name, max ) \
-          CFF_FIELD( code, name, cff_kind_delta )
+#define CFF_FIELD_NUM( code, name, id )             \
+          CFF_FIELD( code, name, id, cff_kind_num )
+#define CFF_FIELD_FIXED( code, name, id )             \
+          CFF_FIELD( code, name, id, cff_kind_fixed )
+#define CFF_FIELD_FIXED_1000( code, name, id )                 \
+          CFF_FIELD( code, name, id, cff_kind_fixed_thousand )
+#define CFF_FIELD_STRING( code, name, id )             \
+          CFF_FIELD( code, name, id, cff_kind_string )
+#define CFF_FIELD_BOOL( code, name, id )             \
+          CFF_FIELD( code, name, id, cff_kind_bool )
 
 #define CFFCODE_TOPDICT  0x1000
 #define CFFCODE_PRIVATE  0x2000
 
+
 #ifndef FT_CONFIG_OPTION_PIC
 
-#define CFF_FIELD_CALLBACK( code, name ) \
-          {                              \
-            cff_kind_callback,           \
-            code | CFFCODE,              \
-            0, 0,                        \
-            cff_parse_ ## name,          \
-            0, 0                         \
+
+#undef  CFF_FIELD
+#undef  CFF_FIELD_DELTA
+
+
+#ifndef FT_DEBUG_LEVEL_TRACE
+
+
+#define CFF_FIELD_CALLBACK( code, name, id ) \
+          {                                  \
+            cff_kind_callback,               \
+            code | CFFCODE,                  \
+            0, 0,                            \
+            cff_parse_ ## name,              \
+            0, 0                             \
           },
 
-#undef  CFF_FIELD
-#define CFF_FIELD( code, name, kind ) \
-          {                          \
-            kind,                    \
-            code | CFFCODE,          \
-            FT_FIELD_OFFSET( name ), \
-            FT_FIELD_SIZE( name ),   \
-            0, 0, 0                  \
+#define CFF_FIELD( code, name, id, kind ) \
+          {                               \
+            kind,                         \
+            code | CFFCODE,               \
+            FT_FIELD_OFFSET( name ),      \
+            FT_FIELD_SIZE( name ),        \
+            0, 0, 0                       \
           },
 
-#undef  CFF_FIELD_DELTA
-#define CFF_FIELD_DELTA( code, name, max ) \
-        {                                  \
-          cff_kind_delta,                  \
-          code | CFFCODE,                  \
-          FT_FIELD_OFFSET( name ),         \
-          FT_FIELD_SIZE_DELTA( name ),     \
-          0,                               \
-          max,                             \
-          FT_FIELD_OFFSET( num_ ## name )  \
-        },
+#define CFF_FIELD_DELTA( code, name, max, id ) \
+          {                                    \
+            cff_kind_delta,                    \
+            code | CFFCODE,                    \
+            FT_FIELD_OFFSET( name ),           \
+            FT_FIELD_SIZE_DELTA( name ),       \
+            0,                                 \
+            max,                               \
+            FT_FIELD_OFFSET( num_ ## name )    \
+          },
 
   static const CFF_Field_Handler  cff_field_handlers[] =
   {
 
 #include "cfftoken.h"
 
     { 0, 0, 0, 0, 0, 0, 0 }
   };
 
 
+#else /* FT_DEBUG_LEVEL_TRACE */
+
+
+
+#define CFF_FIELD_CALLBACK( code, name, id ) \
+          {                                  \
+            cff_kind_callback,               \
+            code | CFFCODE,                  \
+            0, 0,                            \
+            cff_parse_ ## name,              \
+            0, 0,                            \
+            id                               \
+          },
+
+#define CFF_FIELD( code, name, id, kind ) \
+          {                               \
+            kind,                         \
+            code | CFFCODE,               \
+            FT_FIELD_OFFSET( name ),      \
+            FT_FIELD_SIZE( name ),        \
+            0, 0, 0,                      \
+            id                            \
+          },
+
+#define CFF_FIELD_DELTA( code, name, max, id ) \
+          {                                    \
+            cff_kind_delta,                    \
+            code | CFFCODE,                    \
+            FT_FIELD_OFFSET( name ),           \
+            FT_FIELD_SIZE_DELTA( name ),       \
+            0,                                 \
+            max,                               \
+            FT_FIELD_OFFSET( num_ ## name ),   \
+            id                                 \
+          },
+
+  static const CFF_Field_Handler  cff_field_handlers[] =
+  {
+
+#include "cfftoken.h"
+
+    { 0, 0, 0, 0, 0, 0, 0, 0 }
+  };
+
+
+#endif /* FT_DEBUG_LEVEL_TRACE */
+
+
 #else /* FT_CONFIG_OPTION_PIC */
 
-  void FT_Destroy_Class_cff_field_handlers(FT_Library library, CFF_Field_Handler* clazz)
+
+  void
+  FT_Destroy_Class_cff_field_handlers( FT_Library          library,
+                                       CFF_Field_Handler*  clazz )
   {
-    FT_Memory memory = library->memory;
+    FT_Memory  memory = library->memory;
+
+
     if ( clazz )
       FT_FREE( clazz );
   }
 
-  FT_Error FT_Create_Class_cff_field_handlers(FT_Library library, CFF_Field_Handler** output_class)
+
+  FT_Error
+  FT_Create_Class_cff_field_handlers( FT_Library           library,
+                                      CFF_Field_Handler**  output_class )
   {
     CFF_Field_Handler*  clazz;
-    FT_Error          error;
-    FT_Memory memory = library->memory;
-    int i=0;
+    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++;
 #undef CFF_FIELD_CALLBACK
-#define CFF_FIELD_CALLBACK( code, name ) i++;
-#define CFF_FIELD( code, name, kind ) i++;
-#define CFF_FIELD_DELTA( code, name, max ) i++;
-
-#include "cfftoken.h"
-    i++;/*{ 0, 0, 0, 0, 0, 0, 0 }*/
-
-    if ( FT_ALLOC( clazz, sizeof(CFF_Field_Handler)*i ) )
+#define CFF_FIELD_CALLBACK( code, name, id ) i++;
+
+#include "cfftoken.h"
+
+    i++; /* { 0, 0, 0, 0, 0, 0, 0 } */
+
+    if ( FT_ALLOC( clazz, sizeof ( CFF_Field_Handler ) * i ) )
       return error;
 
-    i=0;
-#undef CFF_FIELD
-#undef CFF_FIELD_DELTA
+    i = 0;
+
+
+#ifndef FT_DEBUG_LEVEL_TRACE
+
+
 #undef CFF_FIELD_CALLBACK
-
-#define CFF_FIELD_CALLBACK( code_, name_ )                                   \
-    clazz[i].kind = cff_kind_callback;                                       \
-    clazz[i].code = code_ | CFFCODE;                                         \
-    clazz[i].offset = 0;                                                     \
-    clazz[i].size = 0;                                                       \
-    clazz[i].reader = cff_parse_ ## name_;                                   \
-    clazz[i].array_max = 0;                                                  \
-    clazz[i].count_offset = 0;                                               \
-    i++;
+#define CFF_FIELD_CALLBACK( code_, name_, id_ )        \
+          clazz[i].kind         = cff_kind_callback;   \
+          clazz[i].code         = code_ | CFFCODE;     \
+          clazz[i].offset       = 0;                   \
+          clazz[i].size         = 0;                   \
+          clazz[i].reader       = cff_parse_ ## name_; \
+          clazz[i].array_max    = 0;                   \
+          clazz[i].count_offset = 0;                   \
+          i++;
 
 #undef  CFF_FIELD
-#define CFF_FIELD( code_, name_, kind_ )                                     \
-    clazz[i].kind = kind_;                                                   \
-    clazz[i].code = code_ | CFFCODE;                                         \
-    clazz[i].offset = FT_FIELD_OFFSET( name_ );                              \
-    clazz[i].size = FT_FIELD_SIZE( name_ );                                  \
-    clazz[i].reader = 0;                                                     \
-    clazz[i].array_max = 0;                                                  \
-    clazz[i].count_offset = 0;                                               \
-    i++;                                                                     \
+#define CFF_FIELD( code_, name_, id_, kind_ )               \
+          clazz[i].kind         = kind_;                    \
+          clazz[i].code         = code_ | CFFCODE;          \
+          clazz[i].offset       = FT_FIELD_OFFSET( name_ ); \
+          clazz[i].size         = FT_FIELD_SIZE( name_ );   \
+          clazz[i].reader       = 0;                        \
+          clazz[i].array_max    = 0;                        \
+          clazz[i].count_offset = 0;                        \
+          i++;                                              \
 
 #undef  CFF_FIELD_DELTA
-#define CFF_FIELD_DELTA( code_, name_, max_ )                                \
-    clazz[i].kind = cff_kind_delta;                                          \
-    clazz[i].code = code_ | CFFCODE;                                         \
-    clazz[i].offset = FT_FIELD_OFFSET( name_ );                              \
-    clazz[i].size = FT_FIELD_SIZE_DELTA( name_ );                            \
-    clazz[i].reader = 0;                                                     \
-    clazz[i].array_max = max_;                                               \
-    clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ );                \
-    i++;
-
-#include "cfftoken.h"
-
-    clazz[i].kind = 0;
-    clazz[i].code = 0;
-    clazz[i].offset = 0;
-    clazz[i].size = 0;
-    clazz[i].reader = 0;
-    clazz[i].array_max = 0;
+#define CFF_FIELD_DELTA( code_, name_, max_, id_ )                  \
+          clazz[i].kind         = cff_kind_delta;                   \
+          clazz[i].code         = code_ | CFFCODE;                  \
+          clazz[i].offset       = FT_FIELD_OFFSET( name_ );         \
+          clazz[i].size         = FT_FIELD_SIZE_DELTA( name_ );     \
+          clazz[i].reader       = 0;                                \
+          clazz[i].array_max    = max_;                             \
+          clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ ); \
+          i++;
+
+#include "cfftoken.h"
+
+    clazz[i].kind         = 0;
+    clazz[i].code         = 0;
+    clazz[i].offset       = 0;
+    clazz[i].size         = 0;
+    clazz[i].reader       = 0;
+    clazz[i].array_max    = 0;
     clazz[i].count_offset = 0;
 
+
+#else /* FT_DEBUG_LEVEL_TRACE */
+
+
+#undef CFF_FIELD_CALLBACK
+#define CFF_FIELD_CALLBACK( code_, name_, id_ )        \
+          clazz[i].kind         = cff_kind_callback;   \
+          clazz[i].code         = code_ | CFFCODE;     \
+          clazz[i].offset       = 0;                   \
+          clazz[i].size         = 0;                   \
+          clazz[i].reader       = cff_parse_ ## name_; \
+          clazz[i].array_max    = 0;                   \
+          clazz[i].count_offset = 0;                   \
+          clazz[i].id           = id_;                 \
+          i++;
+
+#undef  CFF_FIELD
+#define CFF_FIELD( code_, name_, id_, kind_ )               \
+          clazz[i].kind         = kind_;                    \
+          clazz[i].code         = code_ | CFFCODE;          \
+          clazz[i].offset       = FT_FIELD_OFFSET( name_ ); \
+          clazz[i].size         = FT_FIELD_SIZE( name_ );   \
+          clazz[i].reader       = 0;                        \
+          clazz[i].array_max    = 0;                        \
+          clazz[i].count_offset = 0;                        \
+          clazz[i].id           = id_;                      \
+          i++;                                              \
+
+#undef  CFF_FIELD_DELTA
+#define CFF_FIELD_DELTA( code_, name_, max_, id_ )                  \
+          clazz[i].kind         = cff_kind_delta;                   \
+          clazz[i].code         = code_ | CFFCODE;                  \
+          clazz[i].offset       = FT_FIELD_OFFSET( name_ );         \
+          clazz[i].size         = FT_FIELD_SIZE_DELTA( name_ );     \
+          clazz[i].reader       = 0;                                \
+          clazz[i].array_max    = max_;                             \
+          clazz[i].count_offset = FT_FIELD_OFFSET( num_ ## name_ ); \
+          clazz[i].id           = id_;                              \
+          i++;
+
+#include "cfftoken.h"
+
+    clazz[i].kind         = 0;
+    clazz[i].code         = 0;
+    clazz[i].offset       = 0;
+    clazz[i].size         = 0;
+    clazz[i].reader       = 0;
+    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;
   }
 
 
 #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_Library  library = parser->library;
-    FT_UNUSED(library);
+    FT_UNUSED( library );
 
 
     parser->top    = parser->stack;
     parser->start  = start;
     parser->limit  = limit;
     parser->cursor = start;
 
     while ( p < limit )
     {
       FT_UInt  v = *p;
@@ skipping 60 matching lines @@
 
         for ( field = FT_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 ));
+#endif
+
             /* check that we have enough arguments -- except for */
             /* delta encoded arrays, which can be empty          */
             if ( field->kind != cff_kind_delta && num_args < 1 )
               goto Stack_Underflow;
 
             switch ( field->kind )
             {
             case cff_kind_bool:
             case cff_kind_string:
             case cff_kind_num:
@@ skipping 18 matching lines @@
                 *(FT_Short*)q = (FT_Short)val;
                 break;
 
               case (32 / FT_CHAR_BIT):
                 *(FT_Int32*)q = (FT_Int)val;
                 break;
 
               default:  /* for 64-bit systems */
                 *(FT_Long*)q = val;
               }
+
+#ifdef FT_DEBUG_LEVEL_TRACE
+              switch ( field->kind )
+              {
+              case cff_kind_bool:
+                FT_TRACE4(( " %s\n", val ? "true" : "false" ));
+                break;
+
+              case cff_kind_string:
+                FT_TRACE4(( " %ld (SID)\n", val ));
+                break;
+
+              case cff_kind_num:
+                FT_TRACE4(( " %ld\n", val ));
+                break;
+
+              case cff_kind_fixed:
+                FT_TRACE4(( " %f\n", (double)val / 65536 ));
+                break;
+
+              case cff_kind_fixed_thousand:
+                FT_TRACE4(( " %f\n", (double)val / 65536 / 1000 ));
+
+              default:
+                ; /* never reached */
+              }
+#endif
+
               break;
 
             case cff_kind_delta:
               {
                 FT_Byte*   qcount = (FT_Byte*)parser->object +
                                       field->count_offset;
 
                 FT_Byte**  data = parser->stack;
 
 
                 if ( num_args > field->array_max )
                   num_args = field->array_max;
 
+                FT_TRACE4(( " [" ));
+
                 /* store count */
                 *qcount = (FT_Byte)num_args;
 
                 val = 0;
                 while ( num_args > 0 )
                 {
                   val += cff_parse_num( data++ );
                   switch ( field->size )
                   {
                   case (8 / FT_CHAR_BIT):
                     *(FT_Byte*)q = (FT_Byte)val;
                     break;
 
                   case (16 / FT_CHAR_BIT):
                     *(FT_Short*)q = (FT_Short)val;
                     break;
 
                   case (32 / FT_CHAR_BIT):
                     *(FT_Int32*)q = (FT_Int)val;
                     break;
 
                   default:  /* for 64-bit systems */
                     *(FT_Long*)q = val;
                   }
 
+                  FT_TRACE4(( " %ld", val ));
+
                   q += field->size;
                   num_args--;
                 }
+
+                FT_TRACE4(( "]\n" ));
               }
               break;
 
             default:  /* callback */
               error = field->reader( parser );
               if ( error )
                 goto Exit;
             }
             goto Found;
           }
@@ skipping 20 matching lines @@
     error = CFF_Err_Invalid_Argument;
     goto Exit;
 
   Syntax_Error:
     error = CFF_Err_Invalid_Argument;
     goto Exit;
   }
 
 
 /* END */