Update freetype to latest version of ASOP.

src/cff/cffgload.c

 /***************************************************************************/
 /*                                                                         */
 /*  cffgload.c                                                             */
 /*                                                                         */
 /*    OpenType Glyph Loader (body).                                        */
 /*                                                                         */
-/*  Copyright 1996-2012 by                                                 */
+/*  Copyright 1996-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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
 
 #include <ft2build.h>
 #include FT_INTERNAL_DEBUG_H
 #include FT_INTERNAL_STREAM_H
 #include FT_INTERNAL_SFNT_H
 #include FT_OUTLINE_H
+#include FT_CFF_DRIVER_H
 
 #include "cffobjs.h"
 #include "cffload.h"
 #include "cffgload.h"
+#include "cf2ft.h"      /* for cf2_decoder_parse_charstrings */
 
 #include "cfferrs.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.                                            */
   /*                                                                       */
 #undef  FT_COMPONENT
 #define FT_COMPONENT  trace_cffgload
 
 
+#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
+
   typedef enum  CFF_Operator_
   {
     cff_op_unknown = 0,
 
     cff_op_rmoveto,
     cff_op_hmoveto,
     cff_op_vmoveto,
 
     cff_op_rlineto,
     cff_op_hlineto,
@@ skipping 150 matching lines @@
 
     2, /* hsbw */
     0,
     0,
     0,
     5, /* seac */
     4, /* sbw */
     2  /* setcurrentpoint */
   };
 
+#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
+
 
   /*************************************************************************/
   /*************************************************************************/
   /*************************************************************************/
   /**********                                                      *********/
   /**********                                                      *********/
   /**********             GENERIC CHARSTRING PARSING               *********/
   /**********                                                      *********/
   /**********                                                      *********/
   /*************************************************************************/
@@ skipping 183 matching lines @@
   /* this function is used to select the subfont */
   /* and the locals subrs array                  */
   FT_LOCAL_DEF( FT_Error )
   cff_decoder_prepare( CFF_Decoder*  decoder,
                        CFF_Size      size,
                        FT_UInt       glyph_index )
   {
     CFF_Builder  *builder = &decoder->builder;
     CFF_Font      cff     = (CFF_Font)builder->face->extra.data;
     CFF_SubFont   sub     = &cff->top_font;
-    FT_Error      error   = CFF_Err_Ok;
+    FT_Error      error   = FT_Err_Ok;
 
 
     /* manage CID fonts */
     if ( cff->num_subfonts )
     {
       FT_Byte  fd_index = cff_fd_select_get( &cff->fd_select, glyph_index );
 
 
       if ( fd_index >= cff->num_subfonts )
       {
         FT_TRACE4(( "cff_decoder_prepare: invalid CID subfont index\n" ));
-        error = CFF_Err_Invalid_File_Format;
+        error = FT_THROW( Invalid_File_Format );
         goto Exit;
       }
 
       FT_TRACE3(( "glyph index %d (subfont %d):\n", glyph_index, fd_index ));
 
       sub = cff->subfonts[fd_index];
 
       if ( builder->hints_funcs && size )
       {
         CFF_Internal  internal = (CFF_Internal)size->root.internal;
@@ skipping 10 matching lines @@
 
     decoder->num_locals    = sub->local_subrs_index.count;
     decoder->locals        = sub->local_subrs;
     decoder->locals_bias   = cff_compute_bias(
                                decoder->cff->top_font.font_dict.charstring_type,
                                decoder->num_locals );
 
     decoder->glyph_width   = sub->private_dict.default_width;
     decoder->nominal_width = sub->private_dict.nominal_width;
 
+    decoder->current_subfont = sub;     /* for Adobe's CFF handler */
+
   Exit:
     return error;
   }
 
 
   /* check that there is enough space for `count' more points */
-  static FT_Error
-  check_points( CFF_Builder*  builder,
-                FT_Int        count )
+  FT_LOCAL_DEF( FT_Error )
+  cff_check_points( CFF_Builder*  builder,
+                    FT_Int        count )
   {
     return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
   }
 
 
   /* add a new point, do not check space */
-  static void
+  FT_LOCAL_DEF( void )
   cff_builder_add_point( CFF_Builder*  builder,
                          FT_Pos        x,
                          FT_Pos        y,
                          FT_Byte       flag )
   {
     FT_Outline*  outline = builder->current;
 
 
     if ( builder->load_points )
     {
       FT_Vector*  point   = outline->points + outline->n_points;
       FT_Byte*    control = (FT_Byte*)outline->tags + outline->n_points;
 
+#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
+      CFF_Driver  driver  = (CFF_Driver)FT_FACE_DRIVER( builder->face );
 
-      point->x = x >> 16;
-      point->y = y >> 16;
+
+      if ( driver->hinting_engine == FT_CFF_HINTING_FREETYPE )
+      {
+        point->x = x >> 16;
+        point->y = y >> 16;
+      }
+      else
+#endif
+      {
+        /* cf2_decoder_parse_charstrings uses 16.16 coordinates */
+        point->x = x >> 10;
+        point->y = y >> 10;
+      }
       *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
     }
 
     outline->n_points++;
   }
 
 
   /* check space for a new on-curve point, then add it */
-  static FT_Error
+  FT_LOCAL_DEF( FT_Error )
   cff_builder_add_point1( CFF_Builder*  builder,
                           FT_Pos        x,
                           FT_Pos        y )
   {
     FT_Error  error;
 
 
-    error = check_points( builder, 1 );
+    error = cff_check_points( builder, 1 );
     if ( !error )
       cff_builder_add_point( builder, x, y, 1 );
 
     return error;
   }
 
 
   /* check space for a new contour, then add it */
   static FT_Error
   cff_builder_add_contour( CFF_Builder*  builder )
   {
     FT_Outline*  outline = builder->current;
     FT_Error     error;
 
 
     if ( !builder->load_points )
     {
       outline->n_contours++;
-      return CFF_Err_Ok;
+      return FT_Err_Ok;
     }
 
     error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
     if ( !error )
     {
       if ( outline->n_contours > 0 )
         outline->contours[outline->n_contours - 1] =
           (short)( outline->n_points - 1 );
 
       outline->n_contours++;
     }
 
     return error;
   }
 
 
   /* if a path was begun, add its first on-curve point */
-  static FT_Error
+  FT_LOCAL_DEF( FT_Error )
   cff_builder_start_point( CFF_Builder*  builder,
                            FT_Pos        x,
                            FT_Pos        y )
   {
-    FT_Error  error = CFF_Err_Ok;
+    FT_Error  error = FT_Err_Ok;
 
 
     /* test whether we are building a new contour */
     if ( !builder->path_begun )
     {
       builder->path_begun = 1;
       error = cff_builder_add_contour( builder );
       if ( !error )
         error = cff_builder_add_point1( builder, x, y );
     }
 
     return error;
   }
 
 
   /* close the current contour */
-  static void
+  FT_LOCAL_DEF( void )
   cff_builder_close_contour( CFF_Builder*  builder )
   {
     FT_Outline*  outline = builder->current;
     FT_Int       first;
 
 
     if ( !outline )
       return;
 
     first = outline->n_contours <= 1
@@ skipping 24 matching lines @@
         outline->n_contours--;
         outline->n_points--;
       }
       else
         outline->contours[outline->n_contours - 1] =
           (short)( outline->n_points - 1 );
     }
   }
 
 
-  static FT_Int
+  FT_LOCAL_DEF( FT_Int )
   cff_lookup_glyph_by_stdcharcode( CFF_Font  cff,
                                    FT_Int    charcode )
   {
     FT_UInt    n;
     FT_UShort  glyph_sid;
 
 
     /* CID-keyed fonts don't have glyph names */
     if ( !cff->charset.sids )
       return -1;
 
     /* check range of standard char code */
     if ( charcode < 0 || charcode > 255 )
       return -1;
 
     /* Get code to SID mapping from `cff_standard_encoding'. */
     glyph_sid = cff_get_standard_encoding( (FT_UInt)charcode );
 
     for ( n = 0; n < cff->num_glyphs; n++ )
     {
       if ( cff->charset.sids[n] == glyph_sid )
         return n;
     }
 
     return -1;
   }
 
 
-  static FT_Error
+  FT_LOCAL_DEF( FT_Error )
   cff_get_glyph_data( TT_Face    face,
                       FT_UInt    glyph_index,
                       FT_Byte**  pointer,
                       FT_ULong*  length )
   {
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     /* For incremental fonts get the character data using the */
     /* callback function.                                     */
     if ( face->root.internal->incremental_interface )
     {
@@ skipping 15 matching lines @@
     {
       CFF_Font  cff  = (CFF_Font)(face->extra.data);
 
 
       return cff_index_access_element( &cff->charstrings_index, glyph_index,
                                        pointer, length );
     }
   }
 
 
-  static void
+  FT_LOCAL_DEF( void )
   cff_free_glyph_data( TT_Face    face,
                        FT_Byte**  pointer,
                        FT_ULong   length )
   {
 #ifndef FT_CONFIG_OPTION_INCREMENTAL
     FT_UNUSED( length );
 #endif
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     /* For incremental fonts get the character data using the */
@@ skipping 14 matching lines @@
 
     {
       CFF_Font  cff = (CFF_Font)(face->extra.data);
 
 
       cff_index_forget_element( &cff->charstrings_index, pointer );
     }
   }
 
 
+#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
+
   static FT_Error
   cff_operator_seac( CFF_Decoder*  decoder,
                      FT_Pos        asb,
                      FT_Pos        adx,
                      FT_Pos        ady,
                      FT_Int        bchar,
                      FT_Int        achar )
   {
     FT_Error      error;
     CFF_Builder*  builder = &decoder->builder;
     FT_Int        bchar_index, achar_index;
     TT_Face       face = decoder->builder.face;
     FT_Vector     left_bearing, advance;
     FT_Byte*      charstring;
     FT_ULong      charstring_len;
     FT_Pos        glyph_width;
 
 
     if ( decoder->seac )
     {
       FT_ERROR(( "cff_operator_seac: invalid nested seac\n" ));
-      return CFF_Err_Syntax_Error;
+      return FT_THROW( Syntax_Error );
     }
 
     adx += decoder->builder.left_bearing.x;
     ady += decoder->builder.left_bearing.y;
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     /* Incremental fonts don't necessarily have valid charsets.        */
     /* They use the character code, not the glyph index, in this case. */
     if ( face->root.internal->incremental_interface )
     {
       bchar_index = bchar;
       achar_index = achar;
     }
     else
 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
     {
       CFF_Font cff = (CFF_Font)(face->extra.data);
 
 
       bchar_index = cff_lookup_glyph_by_stdcharcode( cff, bchar );
       achar_index = cff_lookup_glyph_by_stdcharcode( cff, achar );
     }
 
     if ( bchar_index < 0 || achar_index < 0 )
     {
       FT_ERROR(( "cff_operator_seac:"
                  " invalid seac character code arguments\n" ));
-      return CFF_Err_Syntax_Error;
+      return FT_THROW( Syntax_Error );
     }
 
     /* If we are trying to load a composite glyph, do not load the */
     /* accent character and return the array of subglyphs.         */
     if ( builder->no_recurse )
     {
       FT_GlyphSlot    glyph  = (FT_GlyphSlot)builder->glyph;
       FT_GlyphLoader  loader = glyph->internal->loader;
       FT_SubGlyph     subg;
 
@@ skipping 148 matching lines @@
     stack         = decoder->top;
 
     hinter = (T2_Hints_Funcs)builder->hints_funcs;
 
     builder->path_begun = 0;
 
     zone->base           = charstring_base;
     limit = zone->limit  = charstring_base + charstring_len;
     ip    = zone->cursor = zone->base;
 
-    error = CFF_Err_Ok;
+    error = FT_Err_Ok;
 
     x = builder->pos_x;
     y = builder->pos_y;
 
     /* begin hints recording session, if any */
     if ( hinter )
       hinter->open( hinter->hints );
 
     /* now execute loop */
     while ( ip < limit )
     {
       CFF_Operator  op;
       FT_Byte       v;
 
 
       /********************************************************************/
       /*                                                                  */
       /* Decode operator or operand                                       */
       /*                                                                  */
       v = *ip++;
       if ( v >= 32 || v == 28 )
       {
         FT_Int    shift = 16;
         FT_Int32  val;
 
 
         /* this is an operand, push it on the stack */
+
+        /* if we use shifts, all computations are done with unsigned */
+        /* values; the conversion to a signed value is the last step */
         if ( v == 28 )
         {
           if ( ip + 1 >= limit )
             goto Syntax_Error;
-          val = (FT_Short)( ( (FT_Short)ip[0] << 8 ) | ip[1] );
+          val = (FT_Short)( ( (FT_UShort)ip[0] << 8 ) | ip[1] );
           ip += 2;
         }
         else if ( v < 247 )
           val = (FT_Int32)v - 139;
         else if ( v < 251 )
         {
           if ( ip >= limit )
             goto Syntax_Error;
           val = ( (FT_Int32)v - 247 ) * 256 + *ip++ + 108;
         }
         else if ( v < 255 )
         {
           if ( ip >= limit )
             goto Syntax_Error;
           val = -( (FT_Int32)v - 251 ) * 256 - *ip++ - 108;
         }
         else
         {
           if ( ip + 3 >= limit )
             goto Syntax_Error;
-          val = ( (FT_Int32)ip[0] << 24 ) |
-                ( (FT_Int32)ip[1] << 16 ) |
-                ( (FT_Int32)ip[2] <<  8 ) |
-                            ip[3];
+          val = (FT_Int32)( ( (FT_UInt32)ip[0] << 24 ) |
+                            ( (FT_UInt32)ip[1] << 16 ) |
+                            ( (FT_UInt32)ip[2] <<  8 ) |
+                              (FT_UInt32)ip[3]         );
           ip    += 4;
           if ( charstring_type == 2 )
             shift = 0;
         }
         if ( decoder->top - stack >= CFF_MAX_OPERANDS )
           goto Stack_Overflow;
 
-        val           <<= shift;
+        val             = (FT_Int32)( (FT_UInt32)val << shift );
         *decoder->top++ = val;
 
 #ifdef FT_DEBUG_LEVEL_TRACE
         if ( !( val & 0xFFFFL ) )
-          FT_TRACE4(( " %ld", (FT_Int32)( val >> 16 ) ));
+          FT_TRACE4(( " %hd", (FT_Short)( (FT_UInt32)val >> 16 ) ));
         else
           FT_TRACE4(( " %.2f", val / 65536.0 ));
 #endif
 
       }
       else
       {
         /* The specification says that normally arguments are to be taken */
         /* from the bottom of the stack.  However, this seems not to be   */
         /* correct, at least for Acroread 7.0.8 on GNU/Linux: It pops the */
@@ skipping 396 matching lines @@
 
           cff_builder_close_contour( builder );
           builder->path_begun = 0;
           x   += args[-1];
           args = stack;
           break;
 
         case cff_op_rlineto:
           FT_TRACE4(( " rlineto\n" ));
 
-          if ( cff_builder_start_point ( builder, x, y ) ||
-               check_points( builder, num_args / 2 )     )
+          if ( cff_builder_start_point( builder, x, y )  ||
+               cff_check_points( builder, num_args / 2 ) )
             goto Fail;
 
           if ( num_args < 2 )
             goto Stack_Underflow;
 
           args -= num_args & ~1;
           while ( args < decoder->top )
           {
             x += args[0];
             y += args[1];
@@ skipping 13 matching lines @@
                                              : " vlineto\n" ));
 
             if ( num_args < 0 )
               goto Stack_Underflow;
 
             /* there exist subsetted fonts (found in PDFs) */
             /* which call `hlineto' without arguments      */
             if ( num_args == 0 )
               break;
 
-            if ( cff_builder_start_point ( builder, x, y ) ||
-                 check_points( builder, num_args )         )
+            if ( cff_builder_start_point( builder, x, y ) ||
+                 cff_check_points( builder, num_args )    )
               goto Fail;
 
             args = stack;
             while ( args < decoder->top )
             {
               if ( phase )
                 x += args[0];
               else
                 y += args[0];
 
@@ skipping 12 matching lines @@
             FT_Int  nargs;
 
 
             FT_TRACE4(( " rrcurveto\n" ));
 
             if ( num_args < 6 )
               goto Stack_Underflow;
 
             nargs = num_args - num_args % 6;
 
-            if ( cff_builder_start_point ( builder, x, y ) ||
-                 check_points( builder, nargs / 2 )     )
+            if ( cff_builder_start_point( builder, x, y ) ||
+                 cff_check_points( builder, nargs / 2 )   )
               goto Fail;
 
             args -= nargs;
             while ( args < decoder->top )
             {
               x += args[0];
               y += args[1];
               cff_builder_add_point( builder, x, y, 0 );
               x += args[2];
               y += args[3];
@@ skipping 27 matching lines @@
 
             args -= nargs;
 
             if ( nargs & 1 )
             {
               x += args[0];
               args++;
               nargs--;
             }
 
-            if ( check_points( builder, 3 * ( nargs / 4 ) ) )
+            if ( cff_check_points( builder, 3 * ( nargs / 4 ) ) )
               goto Fail;
 
             while ( args < decoder->top )
             {
               y += args[0];
               cff_builder_add_point( builder, x, y, 0 );
               x += args[1];
               y += args[2];
               cff_builder_add_point( builder, x, y, 0 );
               y += args[3];
@@ skipping 23 matching lines @@
               goto Fail;
 
             args -= nargs;
             if ( nargs & 1 )
             {
               y += args[0];
               args++;
               nargs--;
             }
 
-            if ( check_points( builder, 3 * ( nargs / 4 ) ) )
+            if ( cff_check_points( builder, 3 * ( nargs / 4 ) ) )
               goto Fail;
 
             while ( args < decoder->top )
             {
               x += args[0];
               cff_builder_add_point( builder, x, y, 0 );
               x += args[1];
               y += args[2];
               cff_builder_add_point( builder, x, y, 0 );
               x += args[3];
@@ skipping 19 matching lines @@
 
             if ( num_args < 4 )
               goto Stack_Underflow;
 
             /* if num_args isn't of the form 8n, 8n+1, 8n+4, or 8n+5, */
             /* we enforce it by clearing the second bit               */
 
             nargs = num_args & ~2;
 
             args -= nargs;
-            if ( check_points( builder, ( nargs / 4 ) * 3 ) )
+            if ( cff_check_points( builder, ( nargs / 4 ) * 3 ) )
               goto Stack_Underflow;
 
             phase = ( op == cff_op_hvcurveto );
 
             while ( nargs >= 4 )
             {
               nargs -= 4;
               if ( phase )
               {
                 x += args[0];
@@ skipping 32 matching lines @@
 
 
             FT_TRACE4(( " rlinecurve\n" ));
 
             if ( num_args < 8 )
               goto Stack_Underflow;
 
             nargs     = num_args & ~1;
             num_lines = ( nargs - 6 ) / 2;
 
-            if ( cff_builder_start_point( builder, x, y ) ||
-                 check_points( builder, num_lines + 3 )   )
+            if ( cff_builder_start_point( builder, x, y )   ||
+                 cff_check_points( builder, num_lines + 3 ) )
               goto Fail;
 
             args -= nargs;
 
             /* first, add the line segments */
             while ( num_lines > 0 )
             {
               x += args[0];
               y += args[1];
               cff_builder_add_point( builder, x, y, 1 );
@@ skipping 23 matching lines @@
 
             FT_TRACE4(( " rcurveline\n" ));
 
             if ( num_args < 8 )
               goto Stack_Underflow;
 
             nargs      = num_args - 2;
             nargs      = nargs - nargs % 6 + 2;
             num_curves = ( nargs - 2 ) / 6;
 
-            if ( cff_builder_start_point ( builder, x, y ) ||
-                 check_points( builder, num_curves * 3 + 2 ) )
+            if ( cff_builder_start_point( builder, x, y )        ||
+                 cff_check_points( builder, num_curves * 3 + 2 ) )
               goto Fail;
 
             args -= nargs;
 
             /* first, add the curves */
             while ( num_curves > 0 )
             {
               x += args[0];
               y += args[1];
               cff_builder_add_point( builder, x, y, 0 );
@@ skipping 19 matching lines @@
           {
             FT_Pos start_y;
 
 
             FT_TRACE4(( " hflex1\n" ));
 
             /* adding five more points: 4 control points, 1 on-curve point */
             /* -- make sure we have enough space for the start point if it */
             /* needs to be added                                           */
             if ( cff_builder_start_point( builder, x, y ) ||
-                 check_points( builder, 6 )               )
+                 cff_check_points( builder, 6 )           )
               goto Fail;
 
             /* record the starting point's y position for later use */
             start_y = y;
 
             /* first control point */
             x += args[0];
             y += args[1];
             cff_builder_add_point( builder, x, y, 0 );
 
@@ skipping 28 matching lines @@
 
         case cff_op_hflex:
           {
             FT_Pos start_y;
 
 
             FT_TRACE4(( " hflex\n" ));
 
             /* adding six more points; 4 control points, 2 on-curve points */
             if ( cff_builder_start_point( builder, x, y ) ||
-                 check_points( builder, 6 )               )
+                 cff_check_points( builder, 6 )           )
               goto Fail;
 
             /* record the starting point's y-position for later use */
             start_y = y;
 
             /* first control point */
             x += args[0];
             cff_builder_add_point( builder, x, y, 0 );
 
             /* second control point */
@@ skipping 32 matching lines @@
             FT_Fixed   dx = 0, dy = 0;   /* used in horizontal/vertical  */
                                          /* algorithm below              */
             FT_Int     horizontal, count;
             FT_Fixed*  temp;
 
 
             FT_TRACE4(( " flex1\n" ));
 
             /* adding six more points; 4 control points, 2 on-curve points */
             if ( cff_builder_start_point( builder, x, y ) ||
-                 check_points( builder, 6 )               )
+                 cff_check_points( builder, 6 )           )
               goto Fail;
 
             /* record the starting point's x, y position for later use */
             start_x = x;
             start_y = y;
 
             /* XXX: figure out whether this is supposed to be a horizontal */
             /*      or vertical flex; the Type 2 specification is vague... */
 
             temp = args;
@@ skipping 42 matching lines @@
            }
 
         case cff_op_flex:
           {
             FT_UInt  count;
 
 
             FT_TRACE4(( " flex\n" ));
 
             if ( cff_builder_start_point( builder, x, y ) ||
-                 check_points( builder, 6 )               )
+                 cff_check_points( builder, 6 )           )
               goto Fail;
 
             for ( count = 6; count > 0; count-- )
             {
               x += args[0];
               y += args[1];
               cff_builder_add_point( builder, x, y,
                                      (FT_Bool)( count == 4 || count == 1 ) );
               args += 2;
             }
@@ skipping 30 matching lines @@
             error = cff_operator_seac( decoder,
                                        0L, args[-4], args[-3],
                                        (FT_Int)( args[-2] >> 16 ),
                                        (FT_Int)( args[-1] >> 16 ) );
 
             decoder->glyph_width = glyph_width;
           }
           else
           {
             if ( !error )
-              error = CFF_Err_Ok;
+              error = FT_Err_Ok;
 
             cff_builder_close_contour( builder );
 
             /* close hints recording session */
             if ( hinter )
             {
               if ( hinter->close( hinter->hints,
                                   builder->current->n_points ) )
                 goto Syntax_Error;
 
@@ skipping 481 matching lines @@
           break;
 
         default:
         Unimplemented:
           FT_ERROR(( "Unimplemented opcode: %d", ip[-1] ));
 
           if ( ip[-1] == 12 )
             FT_ERROR(( " %d", ip[0] ));
           FT_ERROR(( "\n" ));
 
-          return CFF_Err_Unimplemented_Feature;
+          return FT_THROW( Unimplemented_Feature );
         }
 
         decoder->top = args;
 
         if ( decoder->top - stack >= CFF_MAX_OPERANDS )
           goto Stack_Overflow;
 
       } /* general operator processing */
 
     } /* while ip < limit */
 
     FT_TRACE4(( "..end..\n\n" ));
 
   Fail:
     return error;
 
   Syntax_Error:
     FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error\n" ));
-    return CFF_Err_Invalid_File_Format;
+    return FT_THROW( Invalid_File_Format );
 
   Stack_Underflow:
     FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow\n" ));
-    return CFF_Err_Too_Few_Arguments;
+    return FT_THROW( Too_Few_Arguments );
 
   Stack_Overflow:
     FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow\n" ));
-    return CFF_Err_Stack_Overflow;
+    return FT_THROW( Stack_Overflow );
   }
 
+#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
+
 
   /*************************************************************************/
   /*************************************************************************/
   /*************************************************************************/
   /**********                                                      *********/
   /**********                                                      *********/
   /**********            COMPUTE THE MAXIMUM ADVANCE WIDTH         *********/
   /**********                                                      *********/
   /**********    The following code is in charge of computing      *********/
   /**********    the maximum advance width of the font.  It        *********/
   /**********    quickly processes each glyph charstring to        *********/
   /**********    extract the value from either a `sbw' or `seac'   *********/
   /**********    operator.                                         *********/
   /**********                                                      *********/
   /*************************************************************************/
   /*************************************************************************/
   /*************************************************************************/
 
 
 #if 0 /* unused until we support pure CFF fonts */
 
 
   FT_LOCAL_DEF( FT_Error )
   cff_compute_max_advance( TT_Face  face,
                            FT_Int*  max_advance )
   {
-    FT_Error     error = CFF_Err_Ok;
+    FT_Error     error = FT_Err_Ok;
     CFF_Decoder  decoder;
     FT_Int       glyph_index;
     CFF_Font     cff = (CFF_Font)face->other;
 
 
     *max_advance = 0;
 
     /* Initialize load decoder */
     cff_decoder_init( &decoder, face, 0, 0, 0, 0 );
 
@@ skipping 17 matching lines @@
         error = cff_decoder_prepare( &decoder, size, glyph_index );
         if ( !error )
           error = cff_decoder_parse_charstrings( &decoder,
                                                  charstring,
                                                  charstring_len );
 
         cff_free_glyph_data( face, &charstring, &charstring_len );
       }
 
       /* ignore the error if one has occurred -- skip to next glyph */
-      error = CFF_Err_Ok;
+      error = FT_Err_Ok;
     }
 
     *max_advance = decoder.builder.advance.x;
 
-    return CFF_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
 #endif /* 0 */
 
 
   FT_LOCAL_DEF( FT_Error )
   cff_slot_load( CFF_GlyphSlot  glyph,
                  CFF_Size       size,
                  FT_UInt        glyph_index,
                  FT_Int32       load_flags )
   {
     FT_Error     error;
     CFF_Decoder  decoder;
     TT_Face      face = (TT_Face)glyph->root.face;
-    FT_Bool      hinting, force_scaling;
+    FT_Bool      hinting, scaled, force_scaling;
     CFF_Font     cff  = (CFF_Font)face->extra.data;
 
     FT_Matrix    font_matrix;
     FT_Vector    font_offset;
 
 
     force_scaling = FALSE;
 
     /* in a CID-keyed font, consider `glyph_index' as a CID and map */
     /* it immediately to the real glyph_index -- if it isn't a      */
     /* subsetted font, glyph_indices and CIDs are identical, though */
     if ( cff->top_font.font_dict.cid_registry != 0xFFFFU &&
          cff->charset.cids                               )
     {
       /* don't handle CID 0 (.notdef) which is directly mapped to GID 0 */
       if ( glyph_index != 0 )
       {
         glyph_index = cff_charset_cid_to_gindex( &cff->charset,
                                                  glyph_index );
         if ( glyph_index == 0 )
-          return CFF_Err_Invalid_Argument;
+          return FT_THROW( Invalid_Argument );
       }
     }
     else if ( glyph_index >= cff->num_glyphs )
-      return CFF_Err_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
 
     if ( load_flags & FT_LOAD_NO_RECURSE )
       load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
 
     glyph->x_scale = 0x10000L;
     glyph->y_scale = 0x10000L;
     if ( size )
     {
       glyph->x_scale = size->root.metrics.x_scale;
       glyph->y_scale = size->root.metrics.y_scale;
@@ skipping 22 matching lines @@
         error = sfnt->load_sbit_image( face,
                                        size->strike_index,
                                        glyph_index,
                                        (FT_Int)load_flags,
                                        stream,
                                        &glyph->root.bitmap,
                                        &metrics );
 
         if ( !error )
         {
+          FT_Bool    has_vertical_info;
+          FT_UShort  advance;
+          FT_Short   dummy;
+
+
           glyph->root.outline.n_points   = 0;
           glyph->root.outline.n_contours = 0;
 
           glyph->root.metrics.width  = (FT_Pos)metrics.width  << 6;
           glyph->root.metrics.height = (FT_Pos)metrics.height << 6;
 
           glyph->root.metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6;
           glyph->root.metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6;
           glyph->root.metrics.horiAdvance  = (FT_Pos)metrics.horiAdvance  << 6;
 
           glyph->root.metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6;
           glyph->root.metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6;
           glyph->root.metrics.vertAdvance  = (FT_Pos)metrics.vertAdvance  << 6;
 
           glyph->root.format = FT_GLYPH_FORMAT_BITMAP;
 
           if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
           {
             glyph->root.bitmap_left = metrics.vertBearingX;
             glyph->root.bitmap_top  = metrics.vertBearingY;
           }
           else
           {
             glyph->root.bitmap_left = metrics.horiBearingX;
             glyph->root.bitmap_top  = metrics.horiBearingY;
           }
+
+          /* compute linear advance widths */
+
+          ( (SFNT_Service)face->sfnt )->get_metrics( face, 0,
+                                                     glyph_index,
+                                                     &dummy,
+                                                     &advance );
+          glyph->root.linearHoriAdvance = advance;
+
+          has_vertical_info = FT_BOOL(
+                                face->vertical_info                   &&
+                                face->vertical.number_Of_VMetrics > 0 );
+
+          /* get the vertical metrics from the vtmx table if we have one */
+          if ( has_vertical_info )
+          {
+            ( (SFNT_Service)face->sfnt )->get_metrics( face, 1,
+                                                       glyph_index,
+                                                       &dummy,
+                                                       &advance );
+            glyph->root.linearVertAdvance = advance;
+          }
+          else
+          {
+            /* make up vertical ones */
+            if ( face->os2.version != 0xFFFFU )
+              glyph->root.linearVertAdvance = (FT_Pos)
+                ( face->os2.sTypoAscender - face->os2.sTypoDescender );
+            else
+              glyph->root.linearVertAdvance = (FT_Pos)
+                ( face->horizontal.Ascender - face->horizontal.Descender );
+          }
+
           return error;
         }
       }
     }
 
 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
 
     /* return immediately if we only want the embedded bitmaps */
     if ( load_flags & FT_LOAD_SBITS_ONLY )
-      return CFF_Err_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
 
     /* if we have a CID subfont, use its matrix (which has already */
     /* been multiplied with the root matrix)                       */
 
     /* this scaling is only relevant if the PS hinter isn't active */
     if ( cff->num_subfonts )
     {
       FT_ULong  top_upm, sub_upm;
       FT_Byte   fd_index = cff_fd_select_get( &cff->fd_select,
                                               glyph_index );
 
+
       if ( fd_index >= cff->num_subfonts )
         fd_index = (FT_Byte)( cff->num_subfonts - 1 );
 
       top_upm = cff->top_font.font_dict.units_per_em;
       sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
 
 
       font_matrix = cff->subfonts[fd_index]->font_dict.font_matrix;
       font_offset = cff->subfonts[fd_index]->font_dict.font_offset;
 
       if ( top_upm != sub_upm )
       {
         glyph->x_scale = FT_MulDiv( glyph->x_scale, top_upm, sub_upm );
         glyph->y_scale = FT_MulDiv( glyph->y_scale, top_upm, sub_upm );
 
         force_scaling = TRUE;
       }
     }
     else
     {
       font_matrix = cff->top_font.font_dict.font_matrix;
       font_offset = cff->top_font.font_dict.font_offset;
     }
 
     glyph->root.outline.n_points   = 0;
     glyph->root.outline.n_contours = 0;
 
-    hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE   ) == 0 &&
-                       ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
+    /* top-level code ensures that FT_LOAD_NO_HINTING is set */
+    /* if FT_LOAD_NO_SCALE is active                         */
+    hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
+    scaled  = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE   ) == 0 );
 
+    glyph->hint        = hinting;
+    glyph->scaled      = scaled;
     glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;  /* by default */
 
     {
+#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
+      CFF_Driver  driver = (CFF_Driver)FT_FACE_DRIVER( face );
+#endif
+
+
       FT_Byte*  charstring;
       FT_ULong  charstring_len;
 
 
       cff_decoder_init( &decoder, face, size, glyph, hinting,
                         FT_LOAD_TARGET_MODE( load_flags ) );
 
       if ( load_flags & FT_LOAD_ADVANCE_ONLY )
         decoder.width_only = TRUE;
 
       decoder.builder.no_recurse =
         (FT_Bool)( load_flags & FT_LOAD_NO_RECURSE );
 
       /* now load the unscaled outline */
       error = cff_get_glyph_data( face, glyph_index,
                                   &charstring, &charstring_len );
       if ( error )
         goto Glyph_Build_Finished;
 
       error = cff_decoder_prepare( &decoder, size, glyph_index );
       if ( error )
         goto Glyph_Build_Finished;
 
-      error = cff_decoder_parse_charstrings( &decoder,
-                                             charstring,
-                                             charstring_len );
+#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
+      /* choose which CFF renderer to use */
+      if ( driver->hinting_engine == FT_CFF_HINTING_FREETYPE )
+        error = cff_decoder_parse_charstrings( &decoder,
+                                               charstring,
+                                               charstring_len );
+      else
+#endif
+      {
+        error = cf2_decoder_parse_charstrings( &decoder,
+                                               charstring,
+                                               charstring_len );
+
+        /* Adobe's engine uses 16.16 numbers everywhere;              */
+        /* as a consequence, glyphs larger than 2000ppem get rejected */
+        if ( FT_ERR_EQ( error, Glyph_Too_Big ) )
+        {
+          /* XXX to be implemented */
+        }
+      }
 
       cff_free_glyph_data( face, &charstring, charstring_len );
 
       if ( error )
         goto Glyph_Build_Finished;
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
       /* Control data and length may not be available for incremental */
       /* fonts.                                                       */
       if ( face->root.internal->incremental_interface )
@@ skipping 77 matching lines @@
         FT_Glyph_Metrics*  metrics = &glyph->root.metrics;
         FT_Vector          advance;
         FT_Bool            has_vertical_info;
 
 
         /* copy the _unscaled_ advance width */
         metrics->horiAdvance                    = decoder.glyph_width;
         glyph->root.linearHoriAdvance           = decoder.glyph_width;
         glyph->root.internal->glyph_transformed = 0;
 
-#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
-        has_vertical_info = FT_BOOL( face->vertical_info                   &&
-                                     face->vertical.number_Of_VMetrics > 0 &&
-                                     face->vertical.long_metrics           );
-#else
         has_vertical_info = FT_BOOL( face->vertical_info                   &&
                                      face->vertical.number_Of_VMetrics > 0 );
-#endif
 
         /* get the vertical metrics from the vtmx table if we have one */
         if ( has_vertical_info )
         {
           FT_Short   vertBearingY = 0;
           FT_UShort  vertAdvance  = 0;
 
 
           ( (SFNT_Service)face->sfnt )->get_metrics( face, 1,
                                                      glyph_index,
@@ skipping 86 matching lines @@
                                             metrics->vertAdvance );
         }
       }
     }
 
     return error;
   }
 
 
 /* END */