Update freetype to latest version of ASOP.

src/raster/ftraster.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftraster.c                                                             */
 /*                                                                         */
 /*    The FreeType glyph rasterizer (body).                                */
 /*                                                                         */
-/*  Copyright 1996-2003, 2005, 2007-2012 by                                */
+/*  Copyright 1996-2003, 2005, 2007-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 35 matching lines @@
 
 #include <string.h>           /* for memset */
 
 #include "ftmisc.h"
 #include "ftimage.h"
 
 #else /* !_STANDALONE_ */
 
 #include <ft2build.h>
 #include "ftraster.h"
-#include FT_INTERNAL_CALC_H   /* for FT_MulDiv only */
+#include FT_INTERNAL_CALC_H   /* for FT_MulDiv and FT_MulDiv_No_Round */
 
 #include "rastpic.h"
 
 #endif /* !_STANDALONE_ */
 
 
   /*************************************************************************/
   /*                                                                       */
   /* A simple technical note on how the raster works                       */
   /* -----------------------------------------------                       */
@@ skipping 98 matching lines @@
   /* 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_raster
 
 
 #ifdef _STANDALONE_
 
+  /* Auxiliary macros for token concatenation. */
+#define FT_ERR_XCAT( x, y )  x ## y
+#define FT_ERR_CAT( x, y )   FT_ERR_XCAT( x, y )
 
   /* This macro is used to indicate that a function parameter is unused. */
   /* Its purpose is simply to reduce compiler warnings.  Note also that  */
   /* simply defining it as `(void)x' doesn't avoid warnings with certain */
   /* ANSI compilers (e.g. LCC).                                          */
 #define FT_UNUSED( x )  (x) = (x)
 
   /* Disable the tracing mechanism for simplicity -- developers can      */
-  /* activate it easily by redefining these two macros.                  */
+  /* activate it easily by redefining these macros.                      */
 #ifndef FT_ERROR
 #define FT_ERROR( x )  do { } while ( 0 )     /* nothing */
 #endif
 
 #ifndef FT_TRACE
 #define FT_TRACE( x )   do { } while ( 0 )    /* nothing */
 #define FT_TRACE1( x )  do { } while ( 0 )    /* nothing */
 #define FT_TRACE6( x )  do { } while ( 0 )    /* nothing */
 #endif
 
+#ifndef FT_THROW
+#define FT_THROW( e )  FT_ERR_CAT( Raster_Err_, e )
+#endif
+
 #define Raster_Err_None          0
 #define Raster_Err_Not_Ini      -1
 #define Raster_Err_Overflow     -2
 #define Raster_Err_Neg_Height   -3
 #define Raster_Err_Invalid      -4
 #define Raster_Err_Unsupported  -5
 
 #define ft_memset  memset
 
 #define FT_DEFINE_RASTER_FUNCS( class_, glyph_format_, raster_new_, \
                                 raster_reset_, raster_set_mode_,    \
                                 raster_render_, raster_done_ )      \
           const FT_Raster_Funcs class_ =                            \
           {                                                         \
             glyph_format_,                                          \
             raster_new_,                                            \
             raster_reset_,                                          \
             raster_set_mode_,                                       \
             raster_render_,                                         \
             raster_done_                                            \
          };
 
 #else /* !_STANDALONE_ */
 
 
 #include FT_INTERNAL_OBJECTS_H
-#include FT_INTERNAL_DEBUG_H        /* for FT_TRACE() and FT_ERROR() */
+#include FT_INTERNAL_DEBUG_H       /* for FT_TRACE, FT_ERROR, and FT_THROW */
 
 #include "rasterrs.h"
 
-#define Raster_Err_None         Raster_Err_Ok
+#define Raster_Err_None         FT_Err_Ok
 #define Raster_Err_Not_Ini      Raster_Err_Raster_Uninitialized
 #define Raster_Err_Overflow     Raster_Err_Raster_Overflow
 #define Raster_Err_Neg_Height   Raster_Err_Raster_Negative_Height
 #define Raster_Err_Invalid      Raster_Err_Invalid_Outline
 #define Raster_Err_Unsupported  Raster_Err_Cannot_Render_Glyph
 
 
 #endif /* !_STANDALONE_ */
 
 
 #ifndef FT_MEM_SET
 #define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
 #endif
 
 #ifndef FT_MEM_ZERO
 #define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
 #endif
 
   /* FMulDiv means `Fast MulDiv'; it is used in case where `b' is       */
   /* typically a small value and the result of a*b is known to fit into */
   /* 32 bits.                                                           */
 #define FMulDiv( a, b, c )  ( (a) * (b) / (c) )
 
   /* On the other hand, SMulDiv means `Slow MulDiv', and is used typically */
   /* for clipping computations.  It simply uses the FT_MulDiv() function   */
   /* defined in `ftcalc.h'.                                                */
-#define SMulDiv  FT_MulDiv
+#define SMulDiv           FT_MulDiv
+#define SMulDiv_No_Round  FT_MulDiv_No_Round
 
   /* The rasterizer is a very general purpose component; please leave */
   /* the following redefinitions there (you never know your target    */
   /* environment).                                                    */
 
 #ifndef TRUE
 #define TRUE   1
 #endif
 
 #ifndef FALSE
@@ skipping 26 matching lines @@
   /**  SIMPLE TYPE DECLARATIONS                                           **/
   /**                                                                     **/
   /*************************************************************************/
   /*************************************************************************/
 
   typedef int             Int;
   typedef unsigned int    UInt;
   typedef short           Short;
   typedef unsigned short  UShort, *PUShort;
   typedef long            Long, *PLong;
+  typedef unsigned long   ULong;
 
   typedef unsigned char   Byte, *PByte;
   typedef char            Bool;
 
 
   typedef union  Alignment_
   {
     long    l;
     void*   p;
     void  (*f)(void);
@@ skipping 118 matching lines @@
 
 
   /* NOTE: These operations are only valid on 2's complement processors */
 #undef FLOOR
 #undef CEILING
 #undef TRUNC
 #undef SCALED
 
 #define FLOOR( x )    ( (x) & -ras.precision )
 #define CEILING( x )  ( ( (x) + ras.precision - 1 ) & -ras.precision )
-#define TRUNC( x )    ( (signed long)(x) >> ras.precision_bits )
+#define TRUNC( x )    ( (Long)(x) >> ras.precision_bits )
 #define FRAC( x )     ( (x) & ( ras.precision - 1 ) )
-#define SCALED( x )   ( ( (x) << ras.scale_shift ) - ras.precision_half )
+#define SCALED( x )   ( ( (ULong)(x) << ras.scale_shift ) - ras.precision_half )
 
 #define IS_BOTTOM_OVERSHOOT( x )  ( CEILING( x ) - x >= ras.precision_half )
 #define IS_TOP_OVERSHOOT( x )     ( x - FLOOR( x ) >= ras.precision_half )
 
   /* The most used variables are positioned at the top of the structure. */
   /* Thus, their offset can be coded with less opcodes, resulting in a   */
   /* smaller executable.                                                 */
 
   struct  black_TWorker_
   {
@@ skipping 191 matching lines @@
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    Set_High_Precision                                                 */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Set precision variables according to param flag.                   */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    High :: Set to True for high precision (typically for ppem < 18),  */
+  /*    High :: Set to True for high precision (typically for ppem < 24),  */
   /*            false otherwise.                                           */
   /*                                                                       */
   static void
   Set_High_Precision( RAS_ARGS Int  High )
   {
     /*
      * `precision_step' is used in `Bezier_Up' to decide when to split a
      * given y-monotonous Bezier arc that crosses a scanline before
      * approximating it as a straight segment.  The default value of 32 (for
      * low accuracy) corresponds to
@@ skipping 59 matching lines @@
   {
     if ( !ras.fProfile )
     {
       ras.cProfile  = (PProfile)ras.top;
       ras.fProfile  = ras.cProfile;
       ras.top      += AlignProfileSize;
     }
 
     if ( ras.top >= ras.maxBuff )
     {
-      ras.error = Raster_Err_Overflow;
+      ras.error = FT_THROW( Overflow );
       return FAILURE;
     }
 
     ras.cProfile->flags  = 0;
     ras.cProfile->start  = 0;
     ras.cProfile->height = 0;
     ras.cProfile->offset = ras.top;
     ras.cProfile->link   = (PProfile)0;
     ras.cProfile->next   = (PProfile)0;
     ras.cProfile->flags  = ras.dropOutControl;
 
     switch ( aState )
     {
     case Ascending_State:
       ras.cProfile->flags |= Flow_Up;
       if ( overshoot )
         ras.cProfile->flags |= Overshoot_Bottom;
 
       FT_TRACE6(( "New ascending profile = %p\n", ras.cProfile ));
       break;
 
     case Descending_State:
       if ( overshoot )
         ras.cProfile->flags |= Overshoot_Top;
       FT_TRACE6(( "New descending profile = %p\n", ras.cProfile ));
       break;
 
     default:
       FT_ERROR(( "New_Profile: invalid profile direction\n" ));
-      ras.error = Raster_Err_Invalid;
+      ras.error = FT_THROW( Invalid );
       return FAILURE;
     }
 
     if ( !ras.gProfile )
       ras.gProfile = ras.cProfile;
 
     ras.state = aState;
     ras.fresh = TRUE;
     ras.joint = FALSE;
 
@@ skipping 12 matching lines @@
   /* <Input>                                                               */
   /*    overshoot :: Whether the profile's unrounded end position differs  */
   /*                 by at least a half pixel.                             */
   /*                                                                       */
   /* <Return>                                                              */
   /*    SUCCESS on success.  FAILURE in case of overflow or incoherency.   */
   /*                                                                       */
   static Bool
   End_Profile( RAS_ARGS Bool  overshoot )
   {
-    Long      h;
-    PProfile  oldProfile;
+    Long  h;
 
 
     h = (Long)( ras.top - ras.cProfile->offset );
 
     if ( h < 0 )
     {
       FT_ERROR(( "End_Profile: negative height encountered\n" ));
-      ras.error = Raster_Err_Neg_Height;
+      ras.error = FT_THROW( Neg_Height );
       return FAILURE;
     }
 
     if ( h > 0 )
     {
+      PProfile  oldProfile;
+
+
       FT_TRACE6(( "Ending profile %p, start = %ld, height = %ld\n",
                   ras.cProfile, ras.cProfile->start, h ));
 
       ras.cProfile->height = h;
       if ( overshoot )
       {
         if ( ras.cProfile->flags & Flow_Up )
           ras.cProfile->flags |= Overshoot_Top;
         else
           ras.cProfile->flags |= Overshoot_Bottom;
       }
 
       oldProfile   = ras.cProfile;
       ras.cProfile = (PProfile)ras.top;
 
       ras.top += AlignProfileSize;
 
       ras.cProfile->height = 0;
       ras.cProfile->offset = ras.top;
 
       oldProfile->next = ras.cProfile;
       ras.num_Profs++;
     }
 
     if ( ras.top >= ras.maxBuff )
     {
       FT_TRACE1(( "overflow in End_Profile\n" ));
-      ras.error = Raster_Err_Overflow;
+      ras.error = FT_THROW( Overflow );
       return FAILURE;
     }
 
     ras.joint = FALSE;
 
     return SUCCESS;
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    Insert_Y_Turn                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Insert a salient into the sorted list placed on top of the render  */
   /*    pool.                                                              */
   /*                                                                       */
   /* <Input>                                                               */
   /*    New y scanline position.                                           */
   /*                                                                       */
   /* <Return>                                                              */
   /*    SUCCESS on success.  FAILURE in case of overflow.                  */
   /*                                                                       */
   static Bool
   Insert_Y_Turn( RAS_ARGS Int  y )
   {
     PLong  y_turns;
-    Int    y2, n;
+    Int    n;
 
 
     n       = ras.numTurns - 1;
     y_turns = ras.sizeBuff - ras.numTurns;
 
     /* look for first y value that is <= */
     while ( n >= 0 && y < y_turns[n] )
       n--;
 
     /* if it is <, simply insert it, ignore if == */
     if ( n >= 0 && y > y_turns[n] )
       while ( n >= 0 )
       {
-        y2 = (Int)y_turns[n];
+        Int  y2 = (Int)y_turns[n];
+
+
         y_turns[n] = y;
         y = y2;
         n--;
       }
 
     if ( n < 0 )
     {
       ras.maxBuff--;
       if ( ras.maxBuff <= ras.top )
       {
-        ras.error = Raster_Err_Overflow;
+        ras.error = FT_THROW( Overflow );
         return FAILURE;
       }
       ras.numTurns++;
       ras.sizeBuff[-ras.numTurns] = y;
     }
 
     return SUCCESS;
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    Finalize_Profile_Table                                             */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Adjust all links in the profiles list.                             */
   /*                                                                       */
   /* <Return>                                                              */
   /*    SUCCESS on success.  FAILURE in case of overflow.                  */
   /*                                                                       */
   static Bool
   Finalize_Profile_Table( RAS_ARG )
   {
-    Int       bottom, top;
     UShort    n;
     PProfile  p;
 
 
     n = ras.num_Profs;
     p = ras.fProfile;
 
     if ( n > 1 && p )
     {
       while ( n > 0 )
       {
+        Int  bottom, top;
+
+
         if ( n > 1 )
           p->link = (PProfile)( p->offset + p->height );
         else
           p->link = NULL;
 
         if ( p->flags & Flow_Up )
         {
           bottom = (Int)p->start;
           top    = (Int)( p->start + p->height - 1 );
         }
@@ skipping 194 matching lines @@
 
     if ( ras.fresh )
     {
       ras.cProfile->start = e1;
       ras.fresh           = FALSE;
     }
 
     size = e2 - e1 + 1;
     if ( ras.top + size >= ras.maxBuff )
     {
-      ras.error = Raster_Err_Overflow;
+      ras.error = FT_THROW( Overflow );
       return FAILURE;
     }
 
     if ( Dx > 0 )
     {
-      Ix = SMulDiv( ras.precision, Dx, Dy);
+      Ix = SMulDiv_No_Round( ras.precision, Dx, Dy );
       Rx = ( ras.precision * Dx ) % Dy;
       Dx = 1;
     }
     else
     {
-      Ix = SMulDiv( ras.precision, -Dx, Dy) * -1;
-      Rx =    ( ras.precision * -Dx ) % Dy;
+      Ix = -SMulDiv_No_Round( ras.precision, -Dx, Dy );
+      Rx = ( ras.precision * -Dx ) % Dy;
       Dx = -1;
     }
 
     Ax  = -Dy;
     top = ras.top;
 
     while ( size > 0 )
     {
       *top++ = x1;
 
@@ skipping 141 matching lines @@
       ras.cProfile->start = TRUNC( e0 );
       ras.fresh = FALSE;
     }
 
     if ( e2 < e )
       goto Fin;
 
     if ( ( top + TRUNC( e2 - e ) + 1 ) >= ras.maxBuff )
     {
       ras.top   = top;
-      ras.error = Raster_Err_Overflow;
+      ras.error = FT_THROW( Overflow );
       return FAILURE;
     }
 
     start_arc = arc;
 
     while ( arc >= start_arc && e <= e2 )
     {
       ras.joint = FALSE;
 
       y2 = arc[0].y;
@@ skipping 654 matching lines @@
     }
 
     /* close the contour with a line segment */
     if ( Line_To( RAS_VARS v_start.x, v_start.y ) )
       goto Fail;
 
   Close:
     return SUCCESS;
 
   Invalid_Outline:
-    ras.error = Raster_Err_Invalid;
+    ras.error = FT_THROW( Invalid );
 
   Fail:
     return FAILURE;
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    Convert_Glyph                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Convert a glyph into a series of segments and arcs and make a      */
   /*    profiles list with them.                                           */
   /*                                                                       */
   /* <Input>                                                               */
   /*    flipped :: If set, flip the direction of curve.                    */
   /*                                                                       */
   /* <Return>                                                              */
   /*    SUCCESS on success, FAILURE if any error was encountered during    */
   /*    rendering.                                                         */
   /*                                                                       */
   static Bool
   Convert_Glyph( RAS_ARGS int  flipped )
   {
     int       i;
     unsigned  start;
 
-    PProfile  lastProfile;
-
 
     ras.fProfile = NULL;
     ras.joint    = FALSE;
     ras.fresh    = FALSE;
 
     ras.maxBuff  = ras.sizeBuff - AlignProfileSize;
 
     ras.numTurns = 0;
 
     ras.cProfile         = (PProfile)ras.top;
     ras.cProfile->offset = ras.top;
     ras.num_Profs        = 0;
 
     start = 0;
 
     for ( i = 0; i < ras.outline.n_contours; i++ )
     {
-      Bool  o;
+      PProfile  lastProfile;
+      Bool      o;
 
 
       ras.state    = Unknown_State;
       ras.gProfile = NULL;
 
       if ( Decompose_Curve( RAS_VARS (unsigned short)start,
                                      ras.outline.contours[i],
                                      flipped ) )
         return FAILURE;
 
@@ skipping 203 matching lines @@
 
 
   static void
   Vertical_Sweep_Span( RAS_ARGS Short       y,
                                 FT_F26Dot6  x1,
                                 FT_F26Dot6  x2,
                                 PProfile    left,
                                 PProfile    right )
   {
     Long   e1, e2;
-    int    c1, c2;
-    Byte   f1, f2;
     Byte*  target;
 
     FT_UNUSED( y );
     FT_UNUSED( left );
     FT_UNUSED( right );
 
 
     /* Drop-out control */
 
     e1 = TRUNC( CEILING( x1 ) );
 
     if ( x2 - x1 - ras.precision <= ras.precision_jitter )
       e2 = e1;
     else
       e2 = TRUNC( FLOOR( x2 ) );
 
     if ( e2 >= 0 && e1 < ras.bWidth )
     {
+      int   c1, c2;
+      Byte  f1, f2;
+
+
       if ( e1 < 0 )
         e1 = 0;
       if ( e2 >= ras.bWidth )
         e2 = ras.bWidth - 1;
 
       c1 = (Short)( e1 >> 3 );
       c2 = (Short)( e2 >> 3 );
 
       f1 = (Byte)  ( 0xFF >> ( e1 & 7 ) );
       f2 = (Byte) ~( 0x7F >> ( e2 & 7 ) );
@@ skipping 203 matching lines @@
   }
 
 
   static void
   Horizontal_Sweep_Span( RAS_ARGS Short       y,
                                   FT_F26Dot6  x1,
                                   FT_F26Dot6  x2,
                                   PProfile    left,
                                   PProfile    right )
   {
-    Long   e1, e2;
-    PByte  bits;
-    Byte   f1;
-
     FT_UNUSED( left );
     FT_UNUSED( right );
 
 
     if ( x2 - x1 < ras.precision )
     {
+      Long  e1, e2;
+
+
       e1 = CEILING( x1 );
       e2 = FLOOR  ( x2 );
 
       if ( e1 == e2 )
       {
+        Byte   f1;
+        PByte  bits;
+
+
         bits = ras.bTarget + ( y >> 3 );
         f1   = (Byte)( 0x80 >> ( y & 7 ) );
 
         e1 = TRUNC( e1 );
 
         if ( e1 >= 0 && e1 < ras.target.rows )
         {
           PByte  p;
 
 
@@ skipping 176 matching lines @@
     }
 
     ras.gray_min_x =  (Short)byte_len;
     ras.gray_max_x = -(Short)byte_len;
   }
 
 
   static void
   Vertical_Gray_Sweep_Step( RAS_ARG )
   {
-    Int     c1, c2;
-    PByte   pix, bit, bit2;
     short*  count = (short*)count_table;
     Byte*   grays;
 
 
     ras.traceOfs += ras.gray_width;
 
     if ( ras.traceOfs > ras.gray_width )
     {
+      PByte  pix;
+
+
       pix   = ras.gTarget + ras.traceG + ras.gray_min_x * 4;
       grays = ras.grays;
 
       if ( ras.gray_max_x >= 0 )
       {
         Long  last_pixel = ras.target.width - 1;
         Int   last_cell  = last_pixel >> 2;
         Int   last_bit   = last_pixel & 3;
         Bool  over       = 0;
 
+        Int    c1, c2;
+        PByte  bit, bit2;
+
 
         if ( ras.gray_max_x >= last_cell && last_bit != 3 )
         {
           ras.gray_max_x = last_cell - 1;
           over = 1;
         }
 
         if ( ras.gray_min_x < 0 )
           ras.gray_min_x = 0;
 
@@ skipping 72 matching lines @@
 
   static void
   Horizontal_Gray_Sweep_Drop( RAS_ARGS Short       y,
                                        FT_F26Dot6  x1,
                                        FT_F26Dot6  x2,
                                        PProfile    left,
                                        PProfile    right )
   {
     Long   e1, e2;
     PByte  pixel;
-    Byte   color;
 
 
     /* During the horizontal sweep, we only take care of drop-outs */
 
     e1 = CEILING( x1 );
     e2 = FLOOR  ( x2 );
 
     if ( e1 > e2 )
     {
       Int  dropOutControl = left->flags & 7;
@@ skipping 33 matching lines @@
         default: /* modes 2, 3, 6, 7 */
           return;  /* no drop-out control */
         }
       }
       else
         return;
     }
 
     if ( e1 >= 0 )
     {
+      Byte  color;
+
+
       if ( x2 - x1 >= ras.precision_half )
         color = ras.grays[2];
       else
         color = ras.grays[1];
 
       e1 = TRUNC( e1 ) / 2;
       if ( e1 < ras.target.rows )
       {
         pixel = ras.gTarget - e1 * ras.target.pitch + y / 2;
         if ( ras.target.pitch > 0 )
@@ skipping 57 matching lines @@
 
       P->X = 0;
       InsNew( &waiting, P );
 
       P = Q;
     }
 
     /* check the Y-turns */
     if ( ras.numTurns == 0 )
     {
-      ras.error = Raster_Err_Invalid;
+      ras.error = FT_THROW( Invalid );
       return FAILURE;
     }
 
     /* now initialize the sweep */
 
     ras.Proc_Sweep_Init( RAS_VARS &min_Y, &max_Y );
 
     /* then compute the distance of each profile from min_Y */
 
     P = waiting;
@@ skipping 220 matching lines @@
 #endif
 
         i = ras.band_stack[ras.band_top].y_min;
         j = ras.band_stack[ras.band_top].y_max;
 
         k = (Short)( ( i + j ) / 2 );
 
         if ( ras.band_top >= 7 || k < i )
         {
           ras.band_top = 0;
-          ras.error    = Raster_Err_Invalid;
+          ras.error    = FT_THROW( Invalid );
 
           return ras.error;
         }
 
         ras.band_stack[ras.band_top + 1].y_min = k;
         ras.band_stack[ras.band_top + 1].y_max = j;
 
         ras.band_stack[ras.band_top].y_max = (Short)( k - 1 );
 
         ras.band_top++;
@@ skipping 168 matching lines @@
     return Raster_Err_None;
   }
 
 #else /* !FT_RASTER_OPTION_ANTI_ALIASING */
 
   FT_LOCAL_DEF( FT_Error )
   Render_Gray_Glyph( RAS_ARG )
   {
     FT_UNUSED_RASTER;
 
-    return Raster_Err_Unsupported;
+    return FT_THROW( Unsupported );
   }
 
 #endif /* !FT_RASTER_OPTION_ANTI_ALIASING */
 
 
   static void
   ft_black_init( black_PRaster  raster )
   {
 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
     FT_UInt  n;
@@ skipping 84 matching lines @@
                   long           pool_size )
   {
     if ( raster )
     {
       if ( pool_base && pool_size >= (long)sizeof ( black_TWorker ) + 2048 )
       {
         black_PWorker  worker = (black_PWorker)pool_base;
 
 
         raster->buffer      = pool_base + ( ( sizeof ( *worker ) + 7 ) & ~7 );
-        raster->buffer_size = pool_base + pool_size - (char*)raster->buffer;
+        raster->buffer_size = (long)( pool_base + pool_size -
+                                        (char*)raster->buffer );
         raster->worker      = worker;
       }
       else
       {
         raster->buffer      = NULL;
         raster->buffer_size = 0;
         raster->worker      = NULL;
       }
     }
   }
@@ skipping 29 matching lines @@
   static int
   ft_black_render( black_PRaster            raster,
                    const FT_Raster_Params*  params )
   {
     const FT_Outline*  outline    = (const FT_Outline*)params->source;
     const FT_Bitmap*   target_map = params->target;
     black_PWorker      worker;
 
 
     if ( !raster || !raster->buffer || !raster->buffer_size )
-      return Raster_Err_Not_Ini;
+      return FT_THROW( Not_Ini );
 
     if ( !outline )
-      return Raster_Err_Invalid;
+      return FT_THROW( Invalid );
 
     /* return immediately if the outline is empty */
     if ( outline->n_points == 0 || outline->n_contours <= 0 )
       return Raster_Err_None;
 
     if ( !outline->contours || !outline->points )
-      return Raster_Err_Invalid;
+      return FT_THROW( Invalid );
 
     if ( outline->n_points !=
            outline->contours[outline->n_contours - 1] + 1 )
-      return Raster_Err_Invalid;
+      return FT_THROW( Invalid );
 
     worker = raster->worker;
 
     /* this version of the raster does not support direct rendering, sorry */
     if ( params->flags & FT_RASTER_FLAG_DIRECT )
-      return Raster_Err_Unsupported;
+      return FT_THROW( Unsupported );
 
     if ( !target_map )
-      return Raster_Err_Invalid;
+      return FT_THROW( Invalid );
 
     /* nothing to do */
     if ( !target_map->width || !target_map->rows )
       return Raster_Err_None;
 
     if ( !target_map->buffer )
-      return Raster_Err_Invalid;
+      return FT_THROW( Invalid );
 
     ras.outline = *outline;
     ras.target  = *target_map;
 
     worker->buff       = (PLong) raster->buffer;
     worker->sizeBuff   = worker->buff +
                            raster->buffer_size / sizeof ( Long );
 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
     worker->grays      = raster->grays;
     worker->gray_width = raster->gray_width;
@@ skipping 11 matching lines @@
     FT_GLYPH_FORMAT_OUTLINE,
     (FT_Raster_New_Func)     ft_black_new,
     (FT_Raster_Reset_Func)   ft_black_reset,
     (FT_Raster_Set_Mode_Func)ft_black_set_mode,
     (FT_Raster_Render_Func)  ft_black_render,
     (FT_Raster_Done_Func)    ft_black_done
   )
 
 
 /* END */