Update freetype to latest version of ASOP.

src/psaux/afmparse.c

 /***************************************************************************/
 /*                                                                         */
 /*  afmparse.c                                                             */
 /*                                                                         */
 /*    AFM parser (body).                                                   */
 /*                                                                         */
-/*  Copyright 2006-2010, 2012 by                                           */
+/*  Copyright 2006-2010, 2012, 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_FREETYPE_H
+#include FT_INTERNAL_DEBUG_H
 #include FT_INTERNAL_POSTSCRIPT_AUX_H
 
 #include "afmparse.h"
 #include "psconv.h"
 
 #include "psauxerr.h"
 
 
 /***************************************************************************/
 /*                                                                         */
@@ skipping 82 matching lines @@
 
     return ch;
   }
 
 
   /* read a key or value in current column */
   static char*
   afm_stream_read_one( AFM_Stream  stream )
   {
     char*  str;
-    int    ch;
 
 
     afm_stream_skip_spaces( stream );
     if ( AFM_STATUS_EOC( stream ) )
       return NULL;
 
     str = AFM_STREAM_KEY_BEGIN( stream );
 
     while ( 1 )
     {
-      ch = AFM_GETC();
+      int  ch = AFM_GETC();
+
+
       if ( AFM_IS_SPACE( ch ) )
         break;
       else if ( AFM_IS_NEWLINE( ch ) )
       {
         stream->status = AFM_STREAM_STATUS_EOL;
         break;
       }
       else if ( AFM_IS_SEP( ch ) )
       {
         stream->status = AFM_STREAM_STATUS_EOC;
         break;
       }
       else if ( AFM_IS_EOF( ch ) )
       {
         stream->status = AFM_STREAM_STATUS_EOF;
         break;
       }
     }
 
     return str;
   }
 
 
   /* read a string (i.e., read to EOL) */
   static char*
   afm_stream_read_string( AFM_Stream  stream )
   {
     char*  str;
-    int    ch;
 
 
     afm_stream_skip_spaces( stream );
     if ( AFM_STATUS_EOL( stream ) )
       return NULL;
 
     str = AFM_STREAM_KEY_BEGIN( stream );
 
     /* scan to eol */
     while ( 1 )
     {
-      ch = AFM_GETC();
+      int  ch = AFM_GETC();
+
+
       if ( AFM_IS_NEWLINE( ch ) )
       {
         stream->status = AFM_STREAM_STATUS_EOL;
         break;
       }
       else if ( AFM_IS_EOF( ch ) )
       {
         stream->status = AFM_STREAM_STATUS_EOF;
         break;
       }
@@ skipping 353 matching lines @@
     stream->limit  = limit;
 
     /* don't skip the first line during the first call */
     stream->status = AFM_STREAM_STATUS_EOL;
 
     parser->memory    = memory;
     parser->stream    = stream;
     parser->FontInfo  = NULL;
     parser->get_index = NULL;
 
-    return PSaux_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
   FT_LOCAL( void )
   afm_parser_done( AFM_Parser  parser )
   {
     FT_Memory  memory = parser->memory;
 
 
     FT_FREE( parser->stream );
   }
 
 
   FT_LOCAL_DEF( FT_Error )
   afm_parser_read_int( AFM_Parser  parser,
                        FT_Int*     aint )
   {
     AFM_ValueRec  val;
 
 
     val.type = AFM_VALUE_TYPE_INTEGER;
 
     if ( afm_parser_read_vals( parser, &val, 1 ) == 1 )
     {
       *aint = val.u.i;
 
-      return PSaux_Err_Ok;
+      return FT_Err_Ok;
     }
     else
-      return PSaux_Err_Syntax_Error;
+      return FT_THROW( Syntax_Error );
   }
 
 
   static FT_Error
   afm_parse_track_kern( AFM_Parser  parser )
   {
     AFM_FontInfo   fi = parser->FontInfo;
     AFM_TrackKern  tk;
     char*          key;
     FT_Offset      len;
@@ skipping 41 matching lines @@
         tk->min_kern   = shared_vals[2].u.f;
         tk->max_ptsize = shared_vals[3].u.f;
         tk->max_kern   = shared_vals[4].u.f;
 
         break;
 
       case AFM_TOKEN_ENDTRACKKERN:
       case AFM_TOKEN_ENDKERNDATA:
       case AFM_TOKEN_ENDFONTMETRICS:
         fi->NumTrackKern = n + 1;
-        return PSaux_Err_Ok;
+        return FT_Err_Ok;
 
       case AFM_TOKEN_UNKNOWN:
         break;
 
       default:
         goto Fail;
       }
     }
 
   Fail:
-    return PSaux_Err_Syntax_Error;
+    return FT_THROW( Syntax_Error );
   }
 
 
 #undef  KERN_INDEX
 #define KERN_INDEX( g1, g2 )  ( ( (FT_ULong)g1 << 16 ) | g2 )
 
 
   /* compare two kerning pairs */
   FT_CALLBACK_DEF( int )
   afm_compare_kern_pairs( const void*  a,
@@ skipping 84 matching lines @@
         }
         break;
 
       case AFM_TOKEN_ENDKERNPAIRS:
       case AFM_TOKEN_ENDKERNDATA:
       case AFM_TOKEN_ENDFONTMETRICS:
         fi->NumKernPair = n + 1;
         ft_qsort( fi->KernPairs, fi->NumKernPair,
                   sizeof ( AFM_KernPairRec ),
                   afm_compare_kern_pairs );
-        return PSaux_Err_Ok;
+        return FT_Err_Ok;
 
       case AFM_TOKEN_UNKNOWN:
         break;
 
       default:
         goto Fail;
       }
     }
 
   Fail:
-    return PSaux_Err_Syntax_Error;
+    return FT_THROW( Syntax_Error );
   }
 
 
   static FT_Error
   afm_parse_kern_data( AFM_Parser  parser )
   {
     FT_Error   error;
     char*      key;
     FT_Offset  len;
 
@@ skipping 10 matching lines @@
 
       case AFM_TOKEN_STARTKERNPAIRS:
       case AFM_TOKEN_STARTKERNPAIRS0:
         error = afm_parse_kern_pairs( parser );
         if ( error )
           return error;
         break;
 
       case AFM_TOKEN_ENDKERNDATA:
       case AFM_TOKEN_ENDFONTMETRICS:
-        return PSaux_Err_Ok;
+        return FT_Err_Ok;
 
       case AFM_TOKEN_UNKNOWN:
         break;
 
       default:
         goto Fail;
       }
     }
 
   Fail:
-    return PSaux_Err_Syntax_Error;
+    return FT_THROW( Syntax_Error );
   }
 
 
   static FT_Error
   afm_parser_skip_section( AFM_Parser  parser,
                            FT_UInt     n,
                            AFM_Token   end_section )
   {
     char*      key;
     FT_Offset  len;
 
 
     while ( n-- > 0 )
     {
       key = afm_parser_next_key( parser, 1, NULL );
       if ( !key )
         goto Fail;
     }
 
     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
     {
       AFM_Token  token = afm_tokenize( key, len );
 
 
       if ( token == end_section || token == AFM_TOKEN_ENDFONTMETRICS )
-        return PSaux_Err_Ok;
+        return FT_Err_Ok;
     }
 
   Fail:
-    return PSaux_Err_Syntax_Error;
+    return FT_THROW( Syntax_Error );
   }
 
 
   FT_LOCAL_DEF( FT_Error )
   afm_parser_parse( AFM_Parser  parser )
   {
     FT_Memory     memory = parser->memory;
     AFM_FontInfo  fi     = parser->FontInfo;
-    FT_Error      error  = PSaux_Err_Syntax_Error;
+    FT_Error      error  = FT_ERR( Syntax_Error );
     char*         key;
     FT_Offset     len;
     FT_Int        metrics_sets = 0;
 
 
     if ( !fi )
-      return PSaux_Err_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
 
     key = afm_parser_next_key( parser, 1, &len );
     if ( !key || len != 16                              ||
          ft_strncmp( key, "StartFontMetrics", 16 ) != 0 )
-      return PSaux_Err_Unknown_File_Format;
+      return FT_THROW( Unknown_File_Format );
 
     while ( ( key = afm_parser_next_key( parser, 1, &len ) ) != 0 )
     {
       AFM_ValueRec  shared_vals[4];
 
 
       switch ( afm_tokenize( key, len ) )
       {
       case AFM_TOKEN_METRICSSETS:
         if ( afm_parser_read_int( parser, &metrics_sets ) )
           goto Fail;
 
         if ( metrics_sets != 0 && metrics_sets != 2 )
         {
-          error = PSaux_Err_Unimplemented_Feature;
+          error = FT_THROW( Unimplemented_Feature );
 
           goto Fail;
         }
         break;
 
       case AFM_TOKEN_ISCIDFONT:
         shared_vals[0].type = AFM_VALUE_TYPE_BOOL;
         if ( afm_parser_read_vals( parser, shared_vals, 1 ) != 1 )
           goto Fail;
 
@@ skipping 45 matching lines @@
         }
         break;
 
       case AFM_TOKEN_STARTKERNDATA:
         error = afm_parse_kern_data( parser );
         if ( error )
           goto Fail;
         /* fall through since we only support kern data */
 
       case AFM_TOKEN_ENDFONTMETRICS:
-        return PSaux_Err_Ok;
+        return FT_Err_Ok;
 
       default:
         break;
       }
     }
 
   Fail:
     FT_FREE( fi->TrackKerns );
     fi->NumTrackKern = 0;
 
     FT_FREE( fi->KernPairs );
     fi->NumKernPair = 0;
 
     fi->IsCIDFont = 0;
 
     return error;
   }
 
 
 /* END */