Update freetype to latest version of ASOP.

src/base/ftrfork.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftrfork.c                                                              */
 /*                                                                         */
 /*    Embedded resource forks accessor (body).                             */
 /*                                                                         */
-/*  Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010 by                  */
+/*  Copyright 2004-2010, 2013 by                                           */
 /*  Masatake YAMATO and Redhat K.K.                                        */
 /*                                                                         */
 /*  FT_Raccess_Get_HeaderInfo() and raccess_guess_darwin_hfsplus() are     */
 /*  derived from ftobjs.c.                                                 */
 /*                                                                         */
 /*  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 61 matching lines @@
                                   ( head[6] <<  8 ) |
                                     head[7]         );
     rdata_len = ( head[ 8] << 24 ) |
                 ( head[ 9] << 16 ) |
                 ( head[10] <<  8 ) |
                   head[11];
 
     /* map_len = head[12] .. head[15] */
 
     if ( *rdata_pos + rdata_len != map_pos || map_pos == rfork_offset )
-      return FT_Err_Unknown_File_Format;
+      return FT_THROW( Unknown_File_Format );
 
     error = FT_Stream_Seek( stream, map_pos );
     if ( error )
       return error;
 
     head2[15] = (FT_Byte)( head[15] + 1 );       /* make it be different */
 
     error = FT_Stream_Read( stream, (FT_Byte*)head2, 16 );
     if ( error )
       return error;
 
     allzeros = 1;
     allmatch = 1;
     for ( i = 0; i < 16; ++i )
     {
       if ( head2[i] != 0 )
         allzeros = 0;
       if ( head2[i] != head[i] )
         allmatch = 0;
     }
     if ( !allzeros && !allmatch )
-      return FT_Err_Unknown_File_Format;
+      return FT_THROW( Unknown_File_Format );
 
     /* If we have reached this point then it is probably a mac resource */
     /* file.  Now, does it contain any interesting resources?           */
     /* Skip handle to next resource map, the file resource number, and  */
     /* attributes.                                                      */
     (void)FT_STREAM_SKIP( 4        /* skip handle to next resource map */
                           + 2      /* skip file resource number */
                           + 2 );   /* skip attributes */
 
     if ( FT_READ_USHORT( type_list ) )
       return error;
     if ( type_list == -1 )
-      return FT_Err_Unknown_File_Format;
+      return FT_THROW( Unknown_File_Format );
 
     error = FT_Stream_Seek( stream, map_pos + type_list );
     if ( error )
       return error;
 
     *map_offset = map_pos + type_list;
     return FT_Err_Ok;
   }
 
 
@@ skipping 91 matching lines @@
 
         *offsets = offsets_internal;
         error    = FT_Err_Ok;
 
       Exit:
         FT_FREE( ref );
         return error;
       }
     }
 
-    return FT_Err_Cannot_Open_Resource;
+    return FT_THROW( Cannot_Open_Resource );
   }
 
 
 #ifdef FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK
 
   /*************************************************************************/
   /*************************************************************************/
   /*************************************************************************/
   /****                                                                 ****/
   /****                                                                 ****/
@@ skipping 108 matching lines @@
                           const char  *insertion );
 
   FT_BASE_DEF( void )
   FT_Raccess_Guess( FT_Library  library,
                     FT_Stream   stream,
                     char*       base_name,
                     char      **new_names,
                     FT_Long    *offsets,
                     FT_Error   *errors )
   {
-    FT_Long  i;
+    FT_Int  i;
 
 
     for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
     {
       new_names[i] = NULL;
       if ( NULL != stream )
         errors[i] = FT_Stream_Seek( stream, 0 );
       else
         errors[i] = FT_Err_Ok;
 
@@ skipping 52 matching lines @@
                               FT_Long    *result_offset )
   {
     FT_Int32  magic = ( 0x00 << 24 ) |
                       ( 0x05 << 16 ) |
                       ( 0x16 <<  8 ) |
                         0x07;
 
 
     *result_file_name = NULL;
     if ( NULL == stream )
-      return FT_Err_Cannot_Open_Stream;
+      return FT_THROW( Cannot_Open_Stream );
 
     return raccess_guess_apple_generic( library, stream, base_file_name,
                                         magic, result_offset );
   }
 
 
   static FT_Error
   raccess_guess_apple_single( FT_Library  library,
                               FT_Stream   stream,
                               char       *base_file_name,
                               char      **result_file_name,
                               FT_Long    *result_offset )
   {
     FT_Int32  magic = ( 0x00 << 24 ) |
                       ( 0x05 << 16 ) |
                       ( 0x16 <<  8 ) |
                         0x00;
 
 
     *result_file_name = NULL;
     if ( NULL == stream )
-      return FT_Err_Cannot_Open_Stream;
+      return FT_THROW( Cannot_Open_Stream );
 
     return raccess_guess_apple_generic( library, stream, base_file_name,
                                         magic, result_offset );
   }
 
 
   static FT_Error
   raccess_guess_darwin_ufs_export( FT_Library  library,
                                    FT_Stream   stream,
                                    char       *base_file_name,
                                    char      **result_file_name,
                                    FT_Long    *result_offset )
   {
     char*      newpath;
     FT_Error   error;
     FT_Memory  memory;
 
     FT_UNUSED( stream );
 
 
     memory  = library->memory;
     newpath = raccess_make_file_name( memory, base_file_name, "._" );
     if ( !newpath )
-      return FT_Err_Out_Of_Memory;
+      return FT_THROW( Out_Of_Memory );
 
     error = raccess_guess_linux_double_from_file_name( library, newpath,
                                                        result_offset );
     if ( !error )
       *result_file_name = newpath;
     else
       FT_FREE( newpath );
 
     return error;
   }
 
 
   static FT_Error
   raccess_guess_darwin_hfsplus( FT_Library  library,
                                 FT_Stream   stream,
                                 char       *base_file_name,
                                 char      **result_file_name,
                                 FT_Long    *result_offset )
   {
     /*
       Only meaningful on systems with hfs+ drivers (or Macs).
      */
     FT_Error   error;
     char*      newpath = NULL;
     FT_Memory  memory;
-    FT_Long    base_file_len = ft_strlen( base_file_name );
+    FT_Long    base_file_len = (FT_Long)ft_strlen( base_file_name );
 
     FT_UNUSED( stream );
 
 
     memory = library->memory;
 
     if ( base_file_len + 6 > FT_INT_MAX )
-      return FT_Err_Array_Too_Large;
+      return FT_THROW( Array_Too_Large );
 
     if ( FT_ALLOC( newpath, base_file_len + 6 ) )
       return error;
 
     FT_MEM_COPY( newpath, base_file_name, base_file_len );
     FT_MEM_COPY( newpath + base_file_len, "/rsrc", 6 );
 
     *result_file_name = newpath;
     *result_offset    = 0;
 
     return FT_Err_Ok;
   }
 
 
   static FT_Error
   raccess_guess_darwin_newvfs( FT_Library  library,
                                FT_Stream   stream,
                                char       *base_file_name,
                                char      **result_file_name,
                                FT_Long    *result_offset )
   {
     /*
       Only meaningful on systems with Mac OS X (> 10.1).
      */
     FT_Error   error;
     char*      newpath = NULL;
     FT_Memory  memory;
-    FT_Long    base_file_len = ft_strlen( base_file_name );
+    FT_Long    base_file_len = (FT_Long)ft_strlen( base_file_name );
 
     FT_UNUSED( stream );
 
 
     memory = library->memory;
 
     if ( base_file_len + 18 > FT_INT_MAX )
-      return FT_Err_Array_Too_Large;
+      return FT_THROW( Array_Too_Large );
 
     if ( FT_ALLOC( newpath, base_file_len + 18 ) )
       return error;
 
     FT_MEM_COPY( newpath, base_file_name, base_file_len );
     FT_MEM_COPY( newpath + base_file_len, "/..namedfork/rsrc", 18 );
 
     *result_file_name = newpath;
     *result_offset    = 0;
 
@@ skipping 12 matching lines @@
     FT_Memory  memory;
 
     FT_UNUSED( stream );
 
 
     memory = library->memory;
 
     newpath = raccess_make_file_name( memory, base_file_name,
                                       "resource.frk/" );
     if ( !newpath )
-      return FT_Err_Out_Of_Memory;
+      return FT_THROW( Out_Of_Memory );
 
     *result_file_name = newpath;
     *result_offset    = 0;
 
     return FT_Err_Ok;
   }
 
 
   static FT_Error
   raccess_guess_linux_cap( FT_Library  library,
                            FT_Stream   stream,
                            char       *base_file_name,
                            char      **result_file_name,
                            FT_Long    *result_offset )
   {
     char*      newpath;
     FT_Memory  memory;
 
     FT_UNUSED( stream );
 
 
     memory = library->memory;
 
     newpath = raccess_make_file_name( memory, base_file_name, ".resource/" );
     if ( !newpath )
-      return FT_Err_Out_Of_Memory;
+      return FT_THROW( Out_Of_Memory );
 
     *result_file_name = newpath;
     *result_offset    = 0;
 
     return FT_Err_Ok;
   }
 
 
   static FT_Error
   raccess_guess_linux_double( FT_Library  library,
                               FT_Stream   stream,
                               char       *base_file_name,
                               char      **result_file_name,
                               FT_Long    *result_offset )
   {
     char*      newpath;
     FT_Error   error;
     FT_Memory  memory;
 
     FT_UNUSED( stream );
 
 
     memory = library->memory;
 
     newpath = raccess_make_file_name( memory, base_file_name, "%" );
     if ( !newpath )
-      return FT_Err_Out_Of_Memory;
+      return FT_THROW( Out_Of_Memory );
 
     error = raccess_guess_linux_double_from_file_name( library, newpath,
                                                        result_offset );
     if ( !error )
       *result_file_name = newpath;
     else
       FT_FREE( newpath );
 
     return error;
   }
@@ skipping 11 matching lines @@
     FT_Memory  memory;
 
     FT_UNUSED( stream );
 
 
     memory = library->memory;
 
     newpath = raccess_make_file_name( memory, base_file_name,
                                       ".AppleDouble/" );
     if ( !newpath )
-      return FT_Err_Out_Of_Memory;
+      return FT_THROW( Out_Of_Memory );
 
     error = raccess_guess_linux_double_from_file_name( library, newpath,
                                                        result_offset );
     if ( !error )
       *result_file_name = newpath;
     else
       FT_FREE( newpath );
 
     return error;
   }
@@ skipping 18 matching lines @@
 
     FT_UNUSED( library );
     FT_UNUSED( base_file_name );
     FT_UNUSED( version_number );
     FT_UNUSED( entry_length   );
 
 
     if ( FT_READ_LONG( magic_from_stream ) )
       return error;
     if ( magic_from_stream != magic )
-      return FT_Err_Unknown_File_Format;
+      return FT_THROW( Unknown_File_Format );
 
     if ( FT_READ_LONG( version_number ) )
       return error;
 
     /* filler */
     error = FT_Stream_Skip( stream, 16 );
     if ( error )
       return error;
 
     if ( FT_READ_USHORT( n_of_entries ) )
       return error;
     if ( n_of_entries == 0 )
-      return FT_Err_Unknown_File_Format;
+      return FT_THROW( Unknown_File_Format );
 
     for ( i = 0; i < n_of_entries; i++ )
     {
       if ( FT_READ_LONG( entry_id ) )
         return error;
       if ( entry_id == resource_fork_entry_id )
       {
         if ( FT_READ_LONG( entry_offset ) ||
              FT_READ_LONG( entry_length ) )
           continue;
         *result_offset = entry_offset;
 
         return FT_Err_Ok;
       }
       else
       {
         error = FT_Stream_Skip( stream, 4 + 4 );    /* offset + length */
         if ( error )
           return error;
       }
     }
 
-    return FT_Err_Unknown_File_Format;
+    return FT_THROW( Unknown_File_Format );
   }
 
 
   static FT_Error
   raccess_guess_linux_double_from_file_name( FT_Library  library,
                                              char       *file_name,
                                              FT_Long    *result_offset )
   {
     FT_Open_Args  args2;
     FT_Stream     stream2;
@@ skipping 62 matching lines @@
   /*************************************************************************/
 
   FT_BASE_DEF( void )
   FT_Raccess_Guess( FT_Library  library,
                     FT_Stream   stream,
                     char       *base_name,
                     char      **new_names,
                     FT_Long    *offsets,
                     FT_Error   *errors )
   {
-    int  i;
+    FT_Int  i;
 
     FT_UNUSED( library );
     FT_UNUSED( stream );
     FT_UNUSED( base_name );
 
 
     for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
     {
       new_names[i] = NULL;
       offsets[i]   = 0;
-      errors[i]    = FT_Err_Unimplemented_Feature;
+      errors[i]    = FT_ERR( Unimplemented_Feature );
     }
   }
 
 
 #endif  /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
 
 
 /* END */