/***************************************************************************//*                                                                         *//*  ftstream.c                                                             *//*                                                                         *//*    I/O stream support (body).                                           *//*                                                                         *//*  Copyright 2000-2001, 2002 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.                                        *//*                                                                         *//***************************************************************************/#include <ft2build.h>#include FT_INTERNAL_STREAM_H#include FT_INTERNAL_DEBUG_H  /*************************************************************************/  /*                                                                       */  /* 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_stream  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;  }  FT_BASE_DEF( void )  FT_Stream_Close( FT_Stream  stream )  {    if ( stream && stream->close )    {      stream->close( stream );      stream->close = NULL;    }  }  FT_BASE_DEF( FT_Error )  FT_Stream_Seek( FT_Stream  stream,                  FT_ULong   pos )  {    FT_Error  error = FT_Err_Ok;    stream->pos = pos;    if ( stream->read )    {      if ( stream->read( stream, pos, 0, 0 ) )      {        FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",                   pos, stream->size ));        error = FT_Err_Invalid_Stream_Operation;      }    }    /* note that seeking to the first position after the file is valid */    else if ( pos > stream->size )    {      FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",                 pos, stream->size ));      error = FT_Err_Invalid_Stream_Operation;    }    return error;  }  FT_BASE_DEF( FT_Error )  FT_Stream_Skip( FT_Stream  stream,                  FT_Long    distance )  {    return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );  }  FT_BASE_DEF( FT_Long )  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 )  {    return FT_Stream_ReadAt( stream, stream->pos, buffer, count );  }  FT_BASE_DEF( FT_Error )  FT_Stream_ReadAt( FT_Stream  stream,                    FT_ULong   pos,                    FT_Byte*   buffer,                    FT_ULong   count )  {    FT_Error  error = FT_Err_Ok;    FT_ULong  read_bytes;    if ( pos >= stream->size )    {      FT_ERROR(( "FT_Stream_ReadAt: invalid i/o; pos = 0x%lx, size = 0x%lx\n",                 pos, stream->size ));      return FT_Err_Invalid_Stream_Operation;    }    if ( stream->read )      read_bytes = stream->read( stream, pos, buffer, count );    else    {      read_bytes = stream->size - pos;      if ( read_bytes > count )        read_bytes = count;      FT_MEM_COPY( buffer, stream->base + pos, read_bytes );    }    stream->pos = pos + read_bytes;    if ( read_bytes < count )    {      FT_ERROR(( "FT_Stream_ReadAt:" ));      FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",                 count, read_bytes ));      error = FT_Err_Invalid_Stream_Operation;    }    return error;  }  FT_BASE_DEF( FT_Error )  FT_Stream_ExtractFrame( FT_Stream  stream,                          FT_ULong   count,                          FT_Byte**  pbytes )  {    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;    }    return error;  }  FT_BASE_DEF( void )  FT_Stream_ReleaseFrame( FT_Stream  stream,                          FT_Byte**  pbytes )  {    if ( stream->read )    {      FT_Memory  memory = stream->memory;      FT_FREE( *pbytes );    }    *pbytes = 0;  }  FT_BASE_DEF( FT_Error )  FT_Stream_EnterFrame( FT_Stream  stream,                        FT_ULong   count )  {    FT_Error  error = FT_Err_Ok;    FT_ULong  read_bytes;    /* check for nested frame access */    FT_ASSERT( stream && stream->cursor == 0 );    if ( stream->read )    {      /* allocate the frame in memory */      FT_Memory  memory = stream->memory;      if ( FT_ALLOC( stream->base, count ) )        goto Exit;      /* read it */      read_bytes = stream->read( stream, stream->pos,                                 stream->base, count );      if ( read_bytes < count )      {        FT_ERROR(( "FT_Stream_EnterFrame:" ));        FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",                   count, read_bytes ));        FT_FREE( stream->base );        error = FT_Err_Invalid_Stream_Operation;      }      stream->cursor = stream->base;      stream->limit  = stream->cursor + count;      stream->pos   += read_bytes;    }    else    {      /* check current and new position */      if ( stream->pos >= stream->size        ||           stream->pos + count > stream->size )      {        FT_ERROR(( "FT_Stream_EnterFrame:" ));        FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",                   stream->pos, count, stream->size ));        error = FT_Err_Invalid_Stream_Operation;        goto Exit;      }      /* set cursor */      stream->cursor = stream->base + stream->pos;      stream->limit  = stream->cursor + count;      stream->pos   += count;    }  Exit:    return error;  }  FT_BASE_DEF( void )  FT_Stream_ExitFrame( FT_Stream  stream )  {    /* IMPORTANT: The assertion stream->cursor != 0 was removed, given    */    /*            that it is possible to access a frame of length 0 in    */    /*            some weird fonts (usually, when accessing an array of   */    /*            0 records, like in some strange kern tables).           */    /*                                                                    */    /*  In this case, the loader code handles the 0-length table          */    /*  gracefully; however, stream.cursor is really set to 0 by the      */    /*  FT_Stream_EnterFrame() call, and this is not an error.            */    /*                                                                    */    FT_ASSERT( stream );    if ( stream->read )    {      FT_Memory  memory = stream->memory;      FT_FREE( stream->base );    }    stream->cursor = 0;    stream->limit  = 0;  }  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++;    return result;  }  FT_BASE_DEF( FT_Short )  FT_Stream_GetShort( FT_Stream  stream )  {    FT_Byte*  p;    FT_Short  result;    FT_ASSERT( stream && stream->cursor );    result         = 0;    p              = stream->cursor;    if ( p + 1 < stream->limit )      result       = FT_NEXT_SHORT( p );    stream->cursor = p;    return result;  }  FT_BASE_DEF( FT_Short )  FT_Stream_GetShortLE( FT_Stream  stream )  {    FT_Byte*  p;    FT_Short  result;    FT_ASSERT( stream && stream->cursor );    result         = 0;    p              = stream->cursor;    if ( p + 1 < stream->limit )      result       = FT_NEXT_SHORT_LE( p );    stream->cursor = p;    return result;  }  FT_BASE_DEF( FT_Long )  FT_Stream_GetOffset( FT_Stream  stream )  {    FT_Byte*  p;    FT_Long   result;    FT_ASSERT( stream && stream->cursor );    result         = 0;    p              = stream->cursor;    if ( p + 2 < stream->limit )      result       = FT_NEXT_OFF3( p );    stream->cursor = p;    return result;  }  FT_BASE_DEF( FT_Long )  FT_Stream_GetLong( FT_Stream  stream )  {    FT_Byte*  p;    FT_Long   result;    FT_ASSERT( stream && stream->cursor );    result         = 0;    p              = stream->cursor;    if ( p + 3 < stream->limit )      result       = FT_NEXT_LONG( p );    stream->cursor = p;    return result;  }  FT_BASE_DEF( FT_Long )  FT_Stream_GetLongLE( FT_Stream  stream )  {    FT_Byte*  p;    FT_Long   result;    FT_ASSERT( stream && stream->cursor );    result         = 0;    p              = stream->cursor;    if ( p + 3 < stream->limit )      result       = FT_NEXT_LONG_LE( p );    stream->cursor = p;    return result;  }  FT_BASE_DEF( FT_Char )  FT_Stream_ReadChar( FT_Stream  stream,                      FT_Error*  error )  {    FT_Byte  result = 0;    FT_ASSERT( stream );    *error = FT_Err_Ok;    if ( stream->read )