Update freetype to latest version of ASOP.

src/psaux/t1decode.c

 /***************************************************************************/
 /*                                                                         */
 /*  t1decode.c                                                             */
 /*                                                                         */
 /*    PostScript Type 1 decoding routines (body).                          */
 /*                                                                         */
-/*  Copyright 2000-2011 by                                                 */
+/*  Copyright 2000-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 180 matching lines @@
     FT_Vector    left_bearing, advance;
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     T1_Face      face  = (T1_Face)decoder->builder.face;
 #endif
 
 
     if ( decoder->seac )
     {
       FT_ERROR(( "t1operator_seac: invalid nested seac\n" ));
-      return PSaux_Err_Syntax_Error;
+      return FT_THROW( Syntax_Error );
+    }
+
+    if ( decoder->builder.metrics_only )
+    {
+      FT_ERROR(( "t1operator_seac: unexpected seac\n" ));
+      return FT_THROW( Syntax_Error );
     }
 
     /* seac weirdness */
     adx += decoder->builder.left_bearing.x;
 
     /* `glyph_names' is set to 0 for CID fonts which do not */
     /* include an encoding.  How can we deal with these?    */
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     if ( decoder->glyph_names == 0                   &&
          !face->root.internal->incremental_interface )
 #else
     if ( decoder->glyph_names == 0 )
 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
     {
       FT_ERROR(( "t1operator_seac:"
                  " glyph names table not available in this font\n" ));
-      return PSaux_Err_Syntax_Error;
+      return FT_THROW( Syntax_Error );
     }
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     if ( face->root.internal->incremental_interface )
     {
       /* the caller must handle the font encoding also */
       bchar_index = bchar;
       achar_index = achar;
     }
     else
 #endif
     {
       bchar_index = t1_lookup_glyph_by_stdcharcode( decoder, bchar );
       achar_index = t1_lookup_glyph_by_stdcharcode( decoder, achar );
     }
 
     if ( bchar_index < 0 || achar_index < 0 )
     {
       FT_ERROR(( "t1operator_seac:"
                  " invalid seac character code arguments\n" ));
-      return PSaux_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 ( decoder->builder.no_recurse )
     {
       FT_GlyphSlot    glyph  = (FT_GlyphSlot)decoder->builder.glyph;
       FT_GlyphLoader  loader = glyph->internal->loader;
       FT_SubGlyph     subg;
 
@@ skipping 145 matching lines @@
                  0,
                  sizeof ( decoder->buildchar[0] ) * decoder->len_buildchar );
 
     FT_TRACE4(( "\n"
                 "Start charstring\n" ));
 
     zone->base           = charstring_base;
     limit = zone->limit  = charstring_base + charstring_len;
     ip    = zone->cursor = zone->base;
 
-    error = PSaux_Err_Ok;
+    error = FT_Err_Ok;
 
     x = orig_x = builder->pos_x;
     y = orig_y = builder->pos_y;
 
     /* begin hints recording session, if any */
     if ( hinter )
       hinter->open( hinter->hints );
 
     large_int = FALSE;
 
@@ skipping 129 matching lines @@
         break;
 
       case 255:    /* four bytes integer */
         if ( ip + 4 > limit )
         {
           FT_ERROR(( "t1_decoder_parse_charstrings:"
                      " unexpected EOF in integer\n" ));
           goto Syntax_Error;
         }
 
-        value = (FT_Int32)( ( (FT_Long)ip[0] << 24 ) |
-                            ( (FT_Long)ip[1] << 16 ) |
-                            ( (FT_Long)ip[2] << 8  ) |
-                                       ip[3]         );
+        value = (FT_Int32)( ( (FT_UInt32)ip[0] << 24 ) |
+                            ( (FT_UInt32)ip[1] << 16 ) |
+                            ( (FT_UInt32)ip[2] << 8  ) |
+                              (FT_UInt32)ip[3]         );
         ip += 4;
 
         /* According to the specification, values > 32000 or < -32000 must */
         /* be followed by a `div' operator to make the result be in the    */
         /* range [-32000;32000].  We expect that the second argument of    */
         /* `div' is not a large number.  Additionally, we don't handle     */
         /* stuff like `<large1> <large2> <num> div <num> div' or           */
         /* <large1> <large2> <num> div div'.  This is probably not allowed */
         /* anyway.                                                         */
         if ( value > 32000 || value < -32000 )
         {
           if ( large_int )
           {
             FT_ERROR(( "t1_decoder_parse_charstrings:"
                        " no `div' after large integer\n" ));
           }
           else
             large_int = TRUE;
         }
         else
         {
           if ( !large_int )
-            value <<= 16;
+            value = (FT_Int32)( (FT_UInt32)value << 16 );
         }
 
         break;
 
       default:
         if ( ip[-1] >= 32 )
         {
           if ( ip[-1] < 247 )
             value = (FT_Int32)ip[-1] - 139;
           else
           {
             if ( ++ip > limit )
             {
               FT_ERROR(( "t1_decoder_parse_charstrings:"
                          " unexpected EOF in integer\n" ));
               goto Syntax_Error;
             }
 
             if ( ip[-2] < 251 )
-              value =  ( ( (FT_Int32)ip[-2] - 247 ) << 8 ) + ip[-1] + 108;
+              value =    ( ( ip[-2] - 247 ) * 256 ) + ip[-1] + 108;
             else
-              value = -( ( ( (FT_Int32)ip[-2] - 251 ) << 8 ) + ip[-1] + 108 );
+              value = -( ( ( ip[-2] - 251 ) * 256 ) + ip[-1] + 108 );
           }
 
           if ( !large_int )
-            value <<= 16;
+            value = (FT_Int32)( (FT_UInt32)value << 16 );
         }
         else
         {
           FT_ERROR(( "t1_decoder_parse_charstrings:"
                      " invalid byte (%d)\n", ip[-1] ));
           goto Syntax_Error;
         }
       }
 
       if ( unknown_othersubr_result_cnt > 0 )
@@ skipping 118 matching lines @@
           known_othersubr_result_cnt = 2;
           break;
 
         case 1:                     /* start flex feature */
           if ( arg_cnt != 0 )
             goto Unexpected_OtherSubr;
 
           decoder->flex_state        = 1;
           decoder->num_flex_vectors  = 0;
           if ( ( error = t1_builder_start_point( builder, x, y ) )
-                 != PSaux_Err_Ok                                   ||
+                 != FT_Err_Ok                                   ||
                ( error = t1_builder_check_points( builder, 6 ) )
-                 != PSaux_Err_Ok                                   )
+                 != FT_Err_Ok                                   )
             goto Fail;
           break;
 
         case 2:                     /* add flex vectors */
           {
             FT_Int  idx;
 
 
             if ( arg_cnt != 0 )
               goto Unexpected_OtherSubr;
@@ skipping 350 matching lines @@
               FT_TRACE4(( "%d ", decoder->buildchar[i] ));
 
             FT_TRACE4(( "]\n" ));
           }
 
 #endif /* FT_DEBUG_LEVEL_TRACE */
 
           FT_TRACE4(( "\n" ));
 
           /* return now! */
-          return PSaux_Err_Ok;
+          return FT_Err_Ok;
 
         case op_hsbw:
           FT_TRACE4(( " hsbw" ));
 
           builder->parse_state = T1_Parse_Have_Width;
 
           builder->left_bearing.x += top[0];
           builder->advance.x       = top[1];
           builder->advance.y       = 0;
 
           orig_x = x = builder->pos_x + top[0];
           orig_y = y = builder->pos_y;
 
           FT_UNUSED( orig_y );
 
           /* the `metrics_only' indicates that we only want to compute */
           /* the glyph's metrics (lsb + advance width), not load the   */
           /* rest of it; so exit immediately                           */
           if ( builder->metrics_only )
-            return PSaux_Err_Ok;
+            return FT_Err_Ok;
 
           break;
 
         case op_seac:
           return t1operator_seac( decoder,
                                   top[0],
                                   top[1],
                                   top[2],
                                   Fix2Int( top[3] ),
                                   Fix2Int( top[4] ) );
 
         case op_sbw:
           FT_TRACE4(( " sbw" ));
 
           builder->parse_state = T1_Parse_Have_Width;
 
           builder->left_bearing.x += top[0];
           builder->left_bearing.y += top[1];
           builder->advance.x       = top[2];
           builder->advance.y       = top[3];
 
           x = builder->pos_x + top[0];
           y = builder->pos_y + top[1];
 
           /* the `metrics_only' indicates that we only want to compute */
           /* the glyph's metrics (lsb + advance width), not load the   */
           /* rest of it; so exit immediately                           */
           if ( builder->metrics_only )
-            return PSaux_Err_Ok;
+            return FT_Err_Ok;
 
           break;
 
         case op_closepath:
           FT_TRACE4(( " closepath" ));
 
           /* if there is no path, `closepath' is a no-op */
           if ( builder->parse_state == T1_Parse_Have_Path   ||
                builder->parse_state == T1_Parse_Have_Moveto )
             t1_builder_close_contour( builder );
 
           builder->parse_state = T1_Parse_Have_Width;
           break;
 
         case op_hlineto:
           FT_TRACE4(( " hlineto" ));
 
           if ( ( error = t1_builder_start_point( builder, x, y ) )
-                 != PSaux_Err_Ok )
+                 != FT_Err_Ok )
             goto Fail;
 
           x += top[0];
           goto Add_Line;
 
         case op_hmoveto:
           FT_TRACE4(( " hmoveto" ));
 
           x += top[0];
           if ( !decoder->flex_state )
           {
             if ( builder->parse_state == T1_Parse_Start )
               goto Syntax_Error;
             builder->parse_state = T1_Parse_Have_Moveto;
           }
           break;
 
         case op_hvcurveto:
           FT_TRACE4(( " hvcurveto" ));
 
           if ( ( error = t1_builder_start_point( builder, x, y ) )
-                 != PSaux_Err_Ok                                   ||
+                 != FT_Err_Ok                                   ||
                ( error = t1_builder_check_points( builder, 3 ) )
-                 != PSaux_Err_Ok                                   )
+                 != FT_Err_Ok                                   )
             goto Fail;
 
           x += top[0];
           t1_builder_add_point( builder, x, y, 0 );
           x += top[1];
           y += top[2];
           t1_builder_add_point( builder, x, y, 0 );
           y += top[3];
           t1_builder_add_point( builder, x, y, 1 );
           break;
 
         case op_rlineto:
           FT_TRACE4(( " rlineto" ));
 
           if ( ( error = t1_builder_start_point( builder, x, y ) )
-                 != PSaux_Err_Ok )
+                 != FT_Err_Ok )
             goto Fail;
 
           x += top[0];
           y += top[1];
 
         Add_Line:
           if ( ( error = t1_builder_add_point1( builder, x, y ) )
-                 != PSaux_Err_Ok )
+                 != FT_Err_Ok )
             goto Fail;
           break;
 
         case op_rmoveto:
           FT_TRACE4(( " rmoveto" ));
 
           x += top[0];
           y += top[1];
           if ( !decoder->flex_state )
           {
             if ( builder->parse_state == T1_Parse_Start )
               goto Syntax_Error;
             builder->parse_state = T1_Parse_Have_Moveto;
           }
           break;
 
         case op_rrcurveto:
           FT_TRACE4(( " rrcurveto" ));
 
           if ( ( error = t1_builder_start_point( builder, x, y ) )
-                 != PSaux_Err_Ok                                   ||
+                 != FT_Err_Ok                                   ||
                ( error = t1_builder_check_points( builder, 3 ) )
-                 != PSaux_Err_Ok                                   )
+                 != FT_Err_Ok                                   )
             goto Fail;
 
           x += top[0];
           y += top[1];
           t1_builder_add_point( builder, x, y, 0 );
 
           x += top[2];
           y += top[3];
           t1_builder_add_point( builder, x, y, 0 );
 
           x += top[4];
           y += top[5];
           t1_builder_add_point( builder, x, y, 1 );
           break;
 
         case op_vhcurveto:
           FT_TRACE4(( " vhcurveto" ));
 
           if ( ( error = t1_builder_start_point( builder, x, y ) )
-                 != PSaux_Err_Ok                                   ||
+                 != FT_Err_Ok                                   ||
                ( error = t1_builder_check_points( builder, 3 ) )
-                 != PSaux_Err_Ok                                   )
+                 != FT_Err_Ok                                   )
             goto Fail;
 
           y += top[0];
           t1_builder_add_point( builder, x, y, 0 );
           x += top[1];
           y += top[2];
           t1_builder_add_point( builder, x, y, 0 );
           x += top[3];
           t1_builder_add_point( builder, x, y, 1 );
           break;
 
         case op_vlineto:
           FT_TRACE4(( " vlineto" ));
 
           if ( ( error = t1_builder_start_point( builder, x, y ) )
-                 != PSaux_Err_Ok )
+                 != FT_Err_Ok )
             goto Fail;
 
           y += top[0];
           goto Add_Line;
 
         case op_vmoveto:
           FT_TRACE4(( " vmoveto" ));
 
           y += top[0];
           if ( !decoder->flex_state )
@@ skipping 218 matching lines @@
       } /* general operator processing */
 
     } /* while ip < limit */
 
     FT_TRACE4(( "..end..\n\n" ));
 
   Fail:
     return error;
 
   Syntax_Error:
-    return PSaux_Err_Syntax_Error;
+    return FT_THROW( Syntax_Error );
 
   Stack_Underflow:
-    return PSaux_Err_Stack_Underflow;
+    return FT_THROW( Stack_Underflow );
   }
 
 
   /* parse a single Type 1 glyph */
   FT_LOCAL_DEF( FT_Error )
   t1_decoder_parse_glyph( T1_Decoder  decoder,
                           FT_UInt     glyph )
   {
     return decoder->parse_callback( decoder, glyph );
   }
@@ skipping 16 matching lines @@
     /* retrieve PSNames interface from list of current modules */
     {
       FT_Service_PsCMaps  psnames = 0;
 
 
       FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
       if ( !psnames )
       {
         FT_ERROR(( "t1_decoder_init:"
                    " the `psnames' module is not available\n" ));
-        return PSaux_Err_Unimplemented_Feature;
+        return FT_THROW( Unimplemented_Feature );
       }
 
       decoder->psnames = psnames;
     }
 
     t1_builder_init( &decoder->builder, face, size, slot, hinting );
 
     /* decoder->buildchar and decoder->len_buildchar have to be  */
     /* initialized by the caller since we cannot know the length */
     /* of the BuildCharArray                                     */
 
     decoder->num_glyphs     = (FT_UInt)face->num_glyphs;
     decoder->glyph_names    = glyph_names;
     decoder->hint_mode      = hint_mode;
     decoder->blend          = blend;
     decoder->parse_callback = parse_callback;
 
     decoder->funcs          = t1_decoder_funcs;
 
-    return PSaux_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
   /* finalize T1 decoder */
   FT_LOCAL_DEF( void )
   t1_decoder_done( T1_Decoder  decoder )
   {
     t1_builder_done( &decoder->builder );
   }
 
 
 /* END */