Update bundled freetype to 2.6.1

third_party/freetype/src/base/ftstream.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftstream.c                                                             */
 /*                                                                         */
 /*    I/O stream support (body).                                           */
 /*                                                                         */
-/*  Copyright 2000-2002, 2004-2006, 2008-2011, 2013 by                     */
+/*  Copyright 2000-2015 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 14 matching lines @@
 
 
   FT_BASE_DEF( void )
   FT_Stream_OpenMemory( FT_Stream       stream,
                         const FT_Byte*  base,
                         FT_ULong        size )
   {
     stream->base   = (FT_Byte*) base;
     stream->size   = size;
     stream->pos    = 0;
-    stream->cursor = 0;
-    stream->read   = 0;
-    stream->close  = 0;
+    stream->cursor = NULL;
+    stream->read   = NULL;
+    stream->close  = NULL;
   }
 
 
   FT_BASE_DEF( void )
   FT_Stream_Close( FT_Stream  stream )
   {
     if ( stream && stream->close )
       stream->close( stream );
   }
 
@@ skipping 33 matching lines @@
   }
 
 
   FT_BASE_DEF( FT_Error )
   FT_Stream_Skip( FT_Stream  stream,
                   FT_Long    distance )
   {
     if ( distance < 0 )
       return FT_THROW( Invalid_Stream_Operation );
 
-    return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );
+    return FT_Stream_Seek( stream, stream->pos + (FT_ULong)distance );
   }
 
 
-  FT_BASE_DEF( FT_Long )
+  FT_BASE_DEF( FT_ULong )
   FT_Stream_Pos( FT_Stream  stream )
   {
     return stream->pos;
   }
 
 
   FT_BASE_DEF( FT_Error )
   FT_Stream_Read( FT_Stream  stream,
                   FT_Byte*   buffer,
                   FT_ULong   count )
@@ skipping 83 matching lines @@
   {
     FT_Error  error;
 
 
     error = FT_Stream_EnterFrame( stream, count );
     if ( !error )
     {
       *pbytes = (FT_Byte*)stream->cursor;
 
       /* equivalent to FT_Stream_ExitFrame(), with no memory block release */
-      stream->cursor = 0;
-      stream->limit  = 0;
+      stream->cursor = NULL;
+      stream->limit  = NULL;
     }
 
     return error;
   }
 
 
   FT_BASE_DEF( void )
   FT_Stream_ReleaseFrame( FT_Stream  stream,
                           FT_Byte**  pbytes )
   {
     if ( stream && stream->read )
     {
       FT_Memory  memory = stream->memory;
 
 #ifdef FT_DEBUG_MEMORY
       ft_mem_free( memory, *pbytes );
       *pbytes = NULL;
 #else
       FT_FREE( *pbytes );
 #endif
     }
-    *pbytes = 0;
+    *pbytes = NULL;
   }
 
 
   FT_BASE_DEF( FT_Error )
   FT_Stream_EnterFrame( FT_Stream  stream,
                         FT_ULong   count )
   {
     FT_Error  error = FT_Err_Ok;
     FT_ULong  read_bytes;
 
@@ skipping 13 matching lines @@
         FT_ERROR(( "FT_Stream_EnterFrame:"
                    " frame size (%lu) larger than stream size (%lu)\n",
                    count, stream->size ));
 
         error = FT_THROW( Invalid_Stream_Operation );
         goto Exit;
       }
 
 #ifdef FT_DEBUG_MEMORY
       /* assume _ft_debug_file and _ft_debug_lineno are already set */
-      stream->base = (unsigned char*)ft_mem_qalloc( memory, count, &error );
+      stream->base = (unsigned char*)ft_mem_qalloc( memory,
+                                                    (FT_Long)count,
+                                                    &error );
       if ( error )
         goto Exit;
 #else
       if ( FT_QALLOC( stream->base, count ) )
         goto Exit;
 #endif
       /* read it */
       read_bytes = stream->read( stream, stream->pos,
                                  stream->base, count );
       if ( read_bytes < count )
@@ skipping 52 matching lines @@
     {
       FT_Memory  memory = stream->memory;
 
 #ifdef FT_DEBUG_MEMORY
       ft_mem_free( memory, stream->base );
       stream->base = NULL;
 #else
       FT_FREE( stream->base );
 #endif
     }
-    stream->cursor = 0;
-    stream->limit  = 0;
+    stream->cursor = NULL;
+    stream->limit  = NULL;
   }
 
 
   FT_BASE_DEF( FT_Char )
   FT_Stream_GetChar( FT_Stream  stream )
   {
     FT_Char  result;
 
 
     FT_ASSERT( stream && stream->cursor );
 
     result = 0;
     if ( stream->cursor < stream->limit )
-      result = *stream->cursor++;
+      result = (FT_Char)*stream->cursor++;
 
     return result;
   }
 
 
   FT_BASE_DEF( FT_UShort )
   FT_Stream_GetUShort( FT_Stream  stream )
   {
-    FT_Byte*  p;
-    FT_Short  result;
+    FT_Byte*   p;
+    FT_UShort  result;
 
 
     FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 1 < stream->limit )
       result       = FT_NEXT_USHORT( p );
     stream->cursor = p;
 
     return result;
   }
 
 
   FT_BASE_DEF( FT_UShort )
   FT_Stream_GetUShortLE( FT_Stream  stream )
   {
-    FT_Byte*  p;
-    FT_Short  result;
+    FT_Byte*   p;
+    FT_UShort  result;
 
 
     FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 1 < stream->limit )
       result       = FT_NEXT_USHORT_LE( p );
     stream->cursor = p;
 
     return result;
   }
 
 
   FT_BASE_DEF( FT_ULong )
   FT_Stream_GetUOffset( FT_Stream  stream )
   {
     FT_Byte*  p;
-    FT_Long   result;
+    FT_ULong  result;
 
 
     FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 2 < stream->limit )
       result       = FT_NEXT_UOFF3( p );
     stream->cursor = p;
     return result;
   }
 
 
   FT_BASE_DEF( FT_ULong )
   FT_Stream_GetULong( FT_Stream  stream )
   {
     FT_Byte*  p;
-    FT_Long   result;
+    FT_ULong  result;
 
 
     FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 3 < stream->limit )
       result       = FT_NEXT_ULONG( p );
     stream->cursor = p;
     return result;
   }
 
 
   FT_BASE_DEF( FT_ULong )
   FT_Stream_GetULongLE( FT_Stream  stream )
   {
     FT_Byte*  p;
-    FT_Long   result;
+    FT_ULong  result;
 
 
     FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 3 < stream->limit )
       result       = FT_NEXT_ULONG_LE( p );
     stream->cursor = p;
     return result;
@@ skipping 18 matching lines @@
     }
     else
     {
       if ( stream->pos < stream->size )
         result = stream->base[stream->pos];
       else
         goto Fail;
     }
     stream->pos++;
 
-    return result;
+    return (FT_Char)result;
 
   Fail:
     *error = FT_THROW( Invalid_Stream_Operation );
     FT_ERROR(( "FT_Stream_ReadChar:"
                " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
     return 0;
   }
 
 
   FT_BASE_DEF( FT_UShort )
   FT_Stream_ReadUShort( FT_Stream  stream,
-                       FT_Error*  error )
+                        FT_Error*  error )
   {
-    FT_Byte   reads[2];
-    FT_Byte*  p = 0;
-    FT_Short  result = 0;
+    FT_Byte    reads[2];
+    FT_Byte*   p      = 0;
+    FT_UShort  result = 0;
 
 
     FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
     if ( stream->pos + 1 < stream->size )
     {
       if ( stream->read )
       {
         if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
           goto Fail;
 
         p = reads;
       }
       else
-      {
         p = stream->base + stream->pos;
-      }
 
       if ( p )
         result = FT_NEXT_USHORT( p );
     }
     else
       goto Fail;
 
     stream->pos += 2;
 
     return result;
 
   Fail:
     *error = FT_THROW( Invalid_Stream_Operation );
     FT_ERROR(( "FT_Stream_ReadUShort:"
                " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
     return 0;
   }
 
 
   FT_BASE_DEF( FT_UShort )
   FT_Stream_ReadUShortLE( FT_Stream  stream,
-                         FT_Error*  error )
+                          FT_Error*  error )
   {
-    FT_Byte   reads[2];
-    FT_Byte*  p = 0;
-    FT_Short  result = 0;
+    FT_Byte    reads[2];
+    FT_Byte*   p      = 0;
+    FT_UShort  result = 0;
 
 
     FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
     if ( stream->pos + 1 < stream->size )
     {
       if ( stream->read )
       {
         if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
           goto Fail;
 
         p = reads;
       }
       else
-      {
         p = stream->base + stream->pos;
-      }
 
       if ( p )
         result = FT_NEXT_USHORT_LE( p );
     }
     else
       goto Fail;
 
     stream->pos += 2;
 
     return result;
 
   Fail:
     *error = FT_THROW( Invalid_Stream_Operation );
     FT_ERROR(( "FT_Stream_ReadUShortLE:"
                " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
     return 0;
   }
 
 
   FT_BASE_DEF( FT_ULong )
   FT_Stream_ReadUOffset( FT_Stream  stream,
-                        FT_Error*  error )
+                         FT_Error*  error )
   {
     FT_Byte   reads[3];
-    FT_Byte*  p = 0;
-    FT_Long   result = 0;
+    FT_Byte*  p      = 0;
+    FT_ULong  result = 0;
 
 
     FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
     if ( stream->pos + 2 < stream->size )
     {
       if ( stream->read )
       {
         if (stream->read( stream, stream->pos, reads, 3L ) != 3L )
           goto Fail;
 
         p = reads;
       }
       else
-      {
         p = stream->base + stream->pos;
-      }
 
       if ( p )
         result = FT_NEXT_UOFF3( p );
     }
     else
       goto Fail;
 
     stream->pos += 3;
 
     return result;
 
   Fail:
     *error = FT_THROW( Invalid_Stream_Operation );
     FT_ERROR(( "FT_Stream_ReadUOffset:"
                " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
     return 0;
   }
 
 
   FT_BASE_DEF( FT_ULong )
   FT_Stream_ReadULong( FT_Stream  stream,
-                      FT_Error*  error )
+                       FT_Error*  error )
   {
     FT_Byte   reads[4];
-    FT_Byte*  p = 0;
-    FT_Long   result = 0;
+    FT_Byte*  p      = 0;
+    FT_ULong  result = 0;
 
 
     FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
     if ( stream->pos + 3 < stream->size )
     {
       if ( stream->read )
       {
         if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
           goto Fail;
 
         p = reads;
       }
       else
-      {
         p = stream->base + stream->pos;
-      }
 
       if ( p )
         result = FT_NEXT_ULONG( p );
     }
     else
       goto Fail;
 
     stream->pos += 4;
 
     return result;
 
   Fail:
     *error = FT_THROW( Invalid_Stream_Operation );
     FT_ERROR(( "FT_Stream_ReadULong:"
                " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
     return 0;
   }
 
 
   FT_BASE_DEF( FT_ULong )
   FT_Stream_ReadULongLE( FT_Stream  stream,
-                        FT_Error*  error )
+                         FT_Error*  error )
   {
     FT_Byte   reads[4];
-    FT_Byte*  p = 0;
-    FT_Long   result = 0;
+    FT_Byte*  p      = 0;
+    FT_ULong  result = 0;
 
 
     FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
     if ( stream->pos + 3 < stream->size )
     {
       if ( stream->read )
       {
         if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
           goto Fail;
 
         p = reads;
       }
       else
-      {
         p = stream->base + stream->pos;
-      }
 
       if ( p )
         result = FT_NEXT_ULONG_LE( p );
     }
     else
       goto Fail;
 
     stream->pos += 4;
 
     return result;
@@ skipping 149 matching lines @@
   Exit:
     /* close the frame if it was opened by this read */
     if ( frame_accessed )
       FT_Stream_ExitFrame( stream );
 
     return error;
   }
 
 
 /* END */