Update freetype to latest version of ASOP.

src/base/ftglyph.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftglyph.c                                                              */
 /*                                                                         */
 /*    FreeType convenience functions to handle glyphs (body).              */
 /*                                                                         */
-/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2007, 2008, 2010 by       */
+/*  Copyright 1996-2005, 2007, 2008, 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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
   /*************************************************************************/
   /*                                                                       */
   /*  This file contains the definition of several convenience functions   */
   /*  that can be used by client applications to easily retrieve glyph     */
   /*  bitmaps and outlines from a given face.                              */
   /*                                                                       */
   /*  These functions should be optional if you are writing a font server  */
   /*  or text layout engine on top of FreeType.  However, they are pretty  */
   /*  handy for many other simple uses of the library.                     */
   /*                                                                       */
   /*************************************************************************/
 
 
 #include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+
 #include FT_GLYPH_H
 #include FT_OUTLINE_H
 #include FT_BITMAP_H
 #include FT_INTERNAL_OBJECTS_H
 
 #include "basepic.h"
 
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ skipping 16 matching lines @@
   ft_bitmap_glyph_init( FT_Glyph      bitmap_glyph,
                         FT_GlyphSlot  slot )
   {
     FT_BitmapGlyph  glyph   = (FT_BitmapGlyph)bitmap_glyph;
     FT_Error        error   = FT_Err_Ok;
     FT_Library      library = FT_GLYPH( glyph )->library;
 
 
     if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
     {
-      error = FT_Err_Invalid_Glyph_Format;
+      error = FT_THROW( Invalid_Glyph_Format );
       goto Exit;
     }
 
     glyph->left = slot->bitmap_left;
     glyph->top  = slot->bitmap_top;
 
     /* do lazy copying whenever possible */
     if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
     {
       glyph->bitmap = slot->bitmap;
@@ skipping 80 matching lines @@
     FT_OutlineGlyph  glyph   = (FT_OutlineGlyph)outline_glyph;
     FT_Error         error   = FT_Err_Ok;
     FT_Library       library = FT_GLYPH( glyph )->library;
     FT_Outline*      source  = &slot->outline;
     FT_Outline*      target  = &glyph->outline;
 
 
     /* check format in glyph slot */
     if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )
     {
-      error = FT_Err_Invalid_Glyph_Format;
+      error = FT_THROW( Invalid_Glyph_Format );
       goto Exit;
     }
 
     /* allocate new outline */
     error = FT_Outline_New( library, source->n_points, source->n_contours,
                             &glyph->outline );
     if ( error )
       goto Exit;
 
     FT_Outline_Copy( source, target );
@@ skipping 127 matching lines @@
                  FT_Glyph  *target )
   {
     FT_Glyph               copy;
     FT_Error               error;
     const FT_Glyph_Class*  clazz;
 
 
     /* check arguments */
     if ( !target )
     {
-      error = FT_Err_Invalid_Argument;
+      error = FT_THROW( Invalid_Argument );
       goto Exit;
     }
 
     *target = 0;
 
     if ( !source || !source->clazz )
     {
-      error = FT_Err_Invalid_Argument;
+      error = FT_THROW( Invalid_Argument );
       goto Exit;
     }
 
     clazz = source->clazz;
     error = ft_new_glyph( source->library, clazz, &copy );
     if ( error )
       goto Exit;
 
     copy->advance = source->advance;
     copy->format  = source->format;
@@ skipping 18 matching lines @@
                 FT_Glyph     *aglyph )
   {
     FT_Library  library;
     FT_Error    error;
     FT_Glyph    glyph;
 
     const FT_Glyph_Class*  clazz = 0;
 
 
     if ( !slot )
-      return FT_Err_Invalid_Slot_Handle;
+      return FT_THROW( Invalid_Slot_Handle );
 
     library = slot->library;
 
     if ( !aglyph )
-      return FT_Err_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
 
     /* if it is a bitmap, that's easy :-) */
     if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
       clazz = FT_BITMAP_GLYPH_CLASS_GET;
 
     /* if it is an outline */
     else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
       clazz = FT_OUTLINE_GLYPH_CLASS_GET;
 
     else
     {
       /* try to find a renderer that supports the glyph image format */
       FT_Renderer  render = FT_Lookup_Renderer( library, slot->format, 0 );
 
 
       if ( render )
         clazz = &render->glyph_class;
     }
 
     if ( !clazz )
     {
-      error = FT_Err_Invalid_Glyph_Format;
+      error = FT_THROW( Invalid_Glyph_Format );
       goto Exit;
     }
 
     /* create FT_Glyph object */
     error = ft_new_glyph( library, clazz, &glyph );
     if ( error )
       goto Exit;
 
     /* copy advance while converting it to 16.16 format */
     glyph->advance.x = slot->advance.x << 10;
@@ skipping 18 matching lines @@
   FT_EXPORT_DEF( FT_Error )
   FT_Glyph_Transform( FT_Glyph    glyph,
                       FT_Matrix*  matrix,
                       FT_Vector*  delta )
   {
     const FT_Glyph_Class*  clazz;
     FT_Error               error = FT_Err_Ok;
 
 
     if ( !glyph || !glyph->clazz )
-      error = FT_Err_Invalid_Argument;
+      error = FT_THROW( Invalid_Argument );
     else
     {
       clazz = glyph->clazz;
       if ( clazz->glyph_transform )
       {
         /* transform glyph image */
         clazz->glyph_transform( glyph, matrix, delta );
 
         /* transform advance vector */
         if ( matrix )
           FT_Vector_Transform( &glyph->advance, matrix );
       }
       else
-        error = FT_Err_Invalid_Glyph_Format;
+        error = FT_THROW( Invalid_Glyph_Format );
     }
     return error;
   }
 
 
   /* documentation is in ftglyph.h */
 
   FT_EXPORT_DEF( void )
   FT_Glyph_Get_CBox( FT_Glyph  glyph,
                      FT_UInt   bbox_mode,
@@ skipping 48 matching lines @@
 
   FT_EXPORT_DEF( FT_Error )
   FT_Glyph_To_Bitmap( FT_Glyph*       the_glyph,
                       FT_Render_Mode  render_mode,
                       FT_Vector*      origin,
                       FT_Bool         destroy )
   {
     FT_GlyphSlotRec           dummy;
     FT_GlyphSlot_InternalRec  dummy_internal;
     FT_Error                  error = FT_Err_Ok;
-    FT_Glyph                  glyph;
+    FT_Glyph                  b, glyph;
     FT_BitmapGlyph            bitmap = NULL;
     const FT_Glyph_Class*     clazz;
 
     /* FT_BITMAP_GLYPH_CLASS_GET derefers `library' in PIC mode */
     FT_Library                library;
 
 
     /* check argument */
     if ( !the_glyph )
       goto Bad;
@@ skipping 16 matching lines @@
     /* we render the glyph into a glyph bitmap using a `dummy' glyph slot */
     /* then calling FT_Render_Glyph_Internal()                            */
 
     FT_MEM_ZERO( &dummy, sizeof ( dummy ) );
     FT_MEM_ZERO( &dummy_internal, sizeof ( dummy_internal ) );
     dummy.internal = &dummy_internal;
     dummy.library  = library;
     dummy.format   = clazz->glyph_format;
 
     /* create result bitmap glyph */
-    error = ft_new_glyph( library, FT_BITMAP_GLYPH_CLASS_GET,
-                          (FT_Glyph*)(void*)&bitmap );
+    error = ft_new_glyph( library, FT_BITMAP_GLYPH_CLASS_GET, &b );
     if ( error )
       goto Exit;
+    bitmap = (FT_BitmapGlyph)b;
 
 #if 1
     /* if `origin' is set, translate the glyph image */
     if ( origin )
       FT_Glyph_Transform( glyph, 0, origin );
 #else
     FT_UNUSED( origin );
 #endif
 
     /* prepare dummy slot for rendering */
@@ skipping 29 matching lines @@
 
     *the_glyph = FT_GLYPH( bitmap );
 
   Exit:
     if ( error && bitmap )
       FT_Done_Glyph( FT_GLYPH( bitmap ) );
 
     return error;
 
   Bad:
-    error = FT_Err_Invalid_Argument;
+    error = FT_THROW( Invalid_Argument );
     goto Exit;
   }
 
 
   /* documentation is in ftglyph.h */
 
   FT_EXPORT_DEF( void )
   FT_Done_Glyph( FT_Glyph  glyph )
   {
     if ( glyph )
     {
       FT_Memory              memory = glyph->library->memory;
       const FT_Glyph_Class*  clazz  = glyph->clazz;
 
 
       if ( clazz->glyph_done )
         clazz->glyph_done( glyph );
 
       FT_FREE( glyph );
     }
   }
 
 
 /* END */