Update freetype to the latest version of Android external/freetype

src/base/ftcalc.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftcalc.c                                                               */
 /*                                                                         */
 /*    Arithmetic computations (body).                                      */
 /*                                                                         */
-/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008 by             */
+/*  Copyright 1996-2006, 2008, 2012 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 282 matching lines @@
     if ( r >= y )
       return (FT_UInt32)0x7FFFFFFFL;
 
     i = 32;
     do
     {
       r <<= 1;
       q <<= 1;
       r  |= lo >> 31;
 
-      if ( r >= (FT_UInt32)y )
+      if ( r >= y )
       {
         r -= y;
         q |= 1;
       }
       lo <<= 1;
     } while ( --i );
 
     return q;
   }
 
@@ skipping 45 matching lines @@
     if ( a == 0 || b == c )
       return a;
 
     s  = a; a = FT_ABS( a );
     s ^= b; b = FT_ABS( b );
     s ^= c; c = FT_ABS( c );
 
     if ( a <= 46340L && b <= 46340L && c <= 176095L && c > 0 )
       a = ( a * b + ( c >> 1 ) ) / c;
 
-    else if ( c > 0 )
+    else if ( (FT_Int32)c > 0 )
     {
       FT_Int64  temp, temp2;
 
 
       ft_multo64( (FT_Int32)a, (FT_Int32)b, &temp );
 
       temp2.hi = 0;
       temp2.lo = (FT_UInt32)(c >> 1);
       FT_Add64( &temp, &temp2, &temp );
       a = ft_div64by32( temp.hi, temp.lo, (FT_Int32)c );
@@ skipping 18 matching lines @@
     if ( a == 0 || b == c )
       return a;
 
     s  = a; a = FT_ABS( a );
     s ^= b; b = FT_ABS( b );
     s ^= c; c = FT_ABS( c );
 
     if ( a <= 46340L && b <= 46340L && c > 0 )
       a = a * b / c;
 
-    else if ( c > 0 )
+    else if ( (FT_Int32)c > 0 )
     {
       FT_Int64  temp;
 
 
       ft_multo64( (FT_Int32)a, (FT_Int32)b, &temp );
       a = ft_div64by32( temp.hi, temp.lo, (FT_Int32)c );
     }
     else
       a = 0x7FFFFFFFL;
 
@@ skipping 31 matching lines @@
 
     /*
      *  This is a clever way of converting a signed number `a' into its
      *  absolute value (stored back into `a') and its sign.  The sign is
      *  stored in `sa'; 0 means `a' was positive or zero, and -1 means `a'
      *  was negative.  (Similarly for `b' and `sb').
      *
      *  Unfortunately, it doesn't work (at least not portably).
      *
      *  It makes the assumption that right-shift on a negative signed value
-     *  fills the leftmost bits by copying the sign bit.  This is wrong. 
+     *  fills the leftmost bits by copying the sign bit.  This is wrong.
      *  According to K&R 2nd ed, section `A7.8 Shift Operators' on page 206,
      *  the result of right-shift of a negative signed value is
      *  implementation-defined.  At least one implementation fills the
      *  leftmost bits with 0s (i.e., it is exactly the same as an unsigned
      *  right shift).  This means that when `a' is negative, `sa' ends up
      *  with the value 1 rather than -1.  After that, everything else goes
      *  wrong.
      */
     sa = ( a >> ( sizeof ( a ) * 8 - 1 ) );
     a  = ( a ^ sa ) - sa;
@@ skipping 59 matching lines @@
              FT_Long  b )
   {
     FT_Int32   s;
     FT_UInt32  q;
 
 
     /* XXX: this function does not allow 64-bit arguments */
     s  = (FT_Int32)a; a = FT_ABS( a );
     s ^= (FT_Int32)b; b = FT_ABS( b );
 
-    if ( b == 0 )
+    if ( (FT_UInt32)b == 0 )
     {
       /* check for division by 0 */
       q = (FT_UInt32)0x7FFFFFFFL;
     }
     else if ( ( a >> 16 ) == 0 )
     {
       /* compute result directly */
-      q = (FT_UInt32)( (a << 16) + (b >> 1) ) / (FT_UInt32)b;
+      q = (FT_UInt32)( ( a << 16 ) + ( b >> 1 ) ) / (FT_UInt32)b;
     }
     else
     {
       /* we need more bits; we have to do it by hand */
       FT_Int64  temp, temp2;
 
-      temp.hi  = (FT_Int32) (a >> 16);
-      temp.lo  = (FT_UInt32)(a << 16);
+
+      temp.hi  = (FT_Int32) ( a >> 16 );
+      temp.lo  = (FT_UInt32)( a << 16 );
       temp2.hi = 0;
       temp2.lo = (FT_UInt32)( b >> 1 );
       FT_Add64( &temp, &temp2, &temp );
       q = ft_div64by32( temp.hi, temp.lo, (FT_Int32)b );
     }
 
     return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
   }
 
 
@@ skipping 374 matching lines @@
     ay = out_y + in_y;
     if ( ay < 0 )
       ay = -ay;
     d_corner = ax + ay;
 
     return ( d_in + d_out - d_corner ) < ( d_corner >> 4 );
   }
 
 
 /* END */