ftstream.c File Reference

#include <ft2build.h>

Include dependency graph for ftstream.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FT_COMPONENT   trace_stream

Functions
	FT_Stream_OpenMemory (FT_Stream stream, const FT_Byte *base, FT_ULong size)
	FT_Stream_Close (FT_Stream stream)
	FT_Stream_Seek (FT_Stream stream, FT_ULong pos)
	FT_Stream_Skip (FT_Stream stream, FT_Long distance)
	FT_Stream_Pos (FT_Stream stream)
	FT_Stream_Read (FT_Stream stream, FT_Byte *buffer, FT_ULong count)
	FT_Stream_ReadAt (FT_Stream stream, FT_ULong pos, FT_Byte *buffer, FT_ULong count)
	FT_Stream_TryRead (FT_Stream stream, FT_Byte *buffer, FT_ULong count)
	FT_Stream_ExtractFrame (FT_Stream stream, FT_ULong count, FT_Byte **pbytes)
	FT_Stream_ReleaseFrame (FT_Stream stream, FT_Byte **pbytes)
	FT_Stream_EnterFrame (FT_Stream stream, FT_ULong count)
	FT_Stream_ExitFrame (FT_Stream stream)
	FT_Stream_GetChar (FT_Stream stream)
	FT_Stream_GetUShort (FT_Stream stream)
	FT_Stream_GetUShortLE (FT_Stream stream)
	FT_Stream_GetUOffset (FT_Stream stream)
	FT_Stream_GetULong (FT_Stream stream)
	FT_Stream_GetULongLE (FT_Stream stream)
	FT_Stream_ReadChar (FT_Stream stream, FT_Error *error)
	FT_Stream_ReadUShort (FT_Stream stream, FT_Error *error)
	FT_Stream_ReadUShortLE (FT_Stream stream, FT_Error *error)
	FT_Stream_ReadUOffset (FT_Stream stream, FT_Error *error)
	FT_Stream_ReadULong (FT_Stream stream, FT_Error *error)
	FT_Stream_ReadULongLE (FT_Stream stream, FT_Error *error)
	FT_Stream_ReadFields (FT_Stream stream, const FT_Frame_Field *fields, void *structure)

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   trace_stream

Definition at line 31 of file ftstream.c.

Function Documentation

FT_Stream_Close()

FT_Stream_Close

(

FT_Stream

stream

)

Definition at line 49 of file ftstream.c.

  {
    if ( stream && stream->close )
      stream->close( stream );
  }

Referenced by FT_Stream_Free(), main(), PCF_Face_Done(), and woff_open_font().

FT_Stream_EnterFrame()

FT_Stream_EnterFrame	(	FT_Stream	stream,
		FT_ULong	count
	)

Definition at line 234 of file ftstream.c.

  {
    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;
 
 
      /* simple sanity check */
      if ( count > stream->size )
      {
        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,
                                                    (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 )
      {
        FT_ERROR(( "FT_Stream_EnterFrame:"
                   " invalid read; expected %lu bytes, got %lu\n",
                   count, read_bytes ));
 
        FT_FREE( stream->base );
        error = FT_THROW( 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->size - stream->pos < count )
      {
        FT_ERROR(( "FT_Stream_EnterFrame:"
                   " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
                   stream->pos, count, stream->size ));
 
        error = FT_THROW( Invalid_Stream_Operation );
        goto Exit;
      }
 
      /* set cursor */
      stream->cursor = stream->base + stream->pos;
      stream->limit  = stream->cursor + count;
      stream->pos   += count;
    }
 
  Exit:
    return error;
  }

Referenced by FT_Access_Frame(), FT_Stream_ExtractFrame(), FT_Stream_ReadFields(), parse_afm(), pcf_get_bitmaps(), and pcf_get_encodings().

FT_Stream_ExitFrame()

FT_Stream_ExitFrame

(

FT_Stream

stream

)

Definition at line 314 of file ftstream.c.

  {
    /* 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;
 
#ifdef FT_DEBUG_MEMORY
      ft_mem_free( memory, stream->base );
      stream->base = NULL;
#else
      FT_FREE( stream->base );
#endif
    }
    stream->cursor = NULL;
    stream->limit  = NULL;
  }

Referenced by FT_Forget_Frame(), FT_Stream_ReadFields(), pcf_get_bitmaps(), and pcf_get_encodings().

FT_Stream_ExtractFrame()

FT_Stream_ExtractFrame	(	FT_Stream	stream,
		FT_ULong	count,
		FT_Byte **	pbytes
	)

Definition at line 193 of file ftstream.c.

  {
    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 = NULL;
      stream->limit  = NULL;
    }
 
    return error;
  }

Referenced by FT_Extract_Frame().

FT_Stream_GetChar()

FT_Stream_GetChar

(

FT_Stream

stream

)

Definition at line 344 of file ftstream.c.

  {
    FT_Char  result;
 
 
    FT_ASSERT( stream && stream->cursor );
 
    result = 0;
    if ( stream->cursor < stream->limit )
      result = (FT_Char)*stream->cursor++;
 
    return result;
  }

FT_Stream_GetULong()

FT_Stream_GetULong

(

FT_Stream

stream

)

Definition at line 416 of file ftstream.c.

  {
    FT_Byte*  p;
    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_Stream_GetULongLE()

FT_Stream_GetULongLE

(

FT_Stream

stream

)

Definition at line 434 of file ftstream.c.

  {
    FT_Byte*  p;
    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;
  }

FT_Stream_GetUOffset()

FT_Stream_GetUOffset

(

FT_Stream

stream

)

Definition at line 398 of file ftstream.c.

  {
    FT_Byte*  p;
    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_Stream_GetUShort()

FT_Stream_GetUShort

(

FT_Stream

stream

)

Definition at line 360 of file ftstream.c.

  {
    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_Stream_GetUShortLE()

FT_Stream_GetUShortLE

(

FT_Stream

stream

)

Definition at line 379 of file ftstream.c.

  {
    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_Stream_OpenMemory()

FT_Stream_OpenMemory	(	FT_Stream	stream,
		const FT_Byte *	base,
		FT_ULong	size
	)

Definition at line 35 of file ftstream.c.

  {
    stream->base   = (FT_Byte*) base;
    stream->size   = size;
    stream->pos    = 0;
    stream->cursor = NULL;
    stream->read   = NULL;
    stream->close  = NULL;
  }

Referenced by cid_face_open(), FT_New_Memory_Stream(), FT_Stream_New(), load_truetype_glyph(), and woff_open_font().

FT_Stream_Pos()

FT_Stream_Pos

(

FT_Stream

stream

)

Definition at line 103 of file ftstream.c.

  {
    return stream->pos;
  }

FT_Stream_Read()

FT_Stream_Read	(	FT_Stream	stream,
		FT_Byte *	buffer,
		FT_ULong	count
	)

Definition at line 110 of file ftstream.c.

  {
    return FT_Stream_ReadAt( stream, stream->pos, buffer, count );
  }

Referenced by FT_Raccess_Get_HeaderInfo(), FT_Read_Stream(), and pcf_get_properties().

FT_Stream_ReadAt()

FT_Stream_ReadAt	(	FT_Stream	stream,
		FT_ULong	pos,
		FT_Byte *	buffer,
		FT_ULong	count
	)

Definition at line 119 of file ftstream.c.

  {
    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_THROW( 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:"
                 " invalid read; expected %lu bytes, got %lu\n",
                 count, read_bytes ));
 
      error = FT_THROW( Invalid_Stream_Operation );
    }
 
    return error;
  }

Referenced by FT_Read_Stream_At(), and FT_Stream_Read().

FT_Stream_ReadChar()

FT_Stream_ReadChar	(	FT_Stream	stream,
		FT_Error *	error
	)

Definition at line 452 of file ftstream.c.

  {
    FT_Byte  result = 0;
 
 
    FT_ASSERT( stream );
 
    *error = FT_Err_Ok;
 
    if ( stream->read )
    {
      if ( stream->read( stream, stream->pos, &result, 1L ) != 1L )
        goto Fail;
    }
    else
    {
      if ( stream->pos < stream->size )
        result = stream->base[stream->pos];
      else
        goto Fail;
    }
    stream->pos++;
 
    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_Stream_ReadFields()

FT_Stream_ReadFields	(	FT_Stream	stream,
		const FT_Frame_Field *	fields,
		void *	structure
	)

Definition at line 714 of file ftstream.c.

  {
    FT_Error  error;
    FT_Bool   frame_accessed = 0;
    FT_Byte*  cursor;
 
 
    if ( !fields )
      return FT_THROW( Invalid_Argument );
 
    if ( !stream )
      return FT_THROW( Invalid_Stream_Handle );
 
    cursor = stream->cursor;
 
    error = FT_Err_Ok;
    do
    {
      FT_ULong  value;
      FT_Int    sign_shift;
      FT_Byte*  p;
 
 
      switch ( fields->value )
      {
      case ft_frame_start:  /* access a new frame */
        error = FT_Stream_EnterFrame( stream, fields->offset );
        if ( error )
          goto Exit;
 
        frame_accessed = 1;
        cursor         = stream->cursor;
        fields++;
        continue;  /* loop! */
 
      case ft_frame_bytes:  /* read a byte sequence */
      case ft_frame_skip:   /* skip some bytes      */
        {
          FT_UInt  len = fields->size;
 
 
          if ( cursor + len > stream->limit )
          {
            error = FT_THROW( Invalid_Stream_Operation );
            goto Exit;
          }
 
          if ( fields->value == ft_frame_bytes )
          {
            p = (FT_Byte*)structure + fields->offset;
            FT_MEM_COPY( p, cursor, len );
          }
          cursor += len;
          fields++;
          continue;
        }
 
      case ft_frame_byte:
      case ft_frame_schar:  /* read a single byte */
        value = FT_NEXT_BYTE( cursor );
        sign_shift = 24;
        break;
 
      case ft_frame_short_be:
      case ft_frame_ushort_be:  /* read a 2-byte big-endian short */
        value = FT_NEXT_USHORT( cursor );
        sign_shift = 16;
        break;
 
      case ft_frame_short_le:
      case ft_frame_ushort_le:  /* read a 2-byte little-endian short */
        value = FT_NEXT_USHORT_LE( cursor );
        sign_shift = 16;
        break;
 
      case ft_frame_long_be:
      case ft_frame_ulong_be:  /* read a 4-byte big-endian long */
        value = FT_NEXT_ULONG( cursor );
        sign_shift = 0;
        break;
 
      case ft_frame_long_le:
      case ft_frame_ulong_le:  /* read a 4-byte little-endian long */
        value = FT_NEXT_ULONG_LE( cursor );
        sign_shift = 0;
        break;
 
      case ft_frame_off3_be:
      case ft_frame_uoff3_be:  /* read a 3-byte big-endian long */
        value = FT_NEXT_UOFF3( cursor );
        sign_shift = 8;
        break;
 
      case ft_frame_off3_le:
      case ft_frame_uoff3_le:  /* read a 3-byte little-endian long */
        value = FT_NEXT_UOFF3_LE( cursor );
        sign_shift = 8;
        break;
 
      default:
        /* otherwise, exit the loop */
        stream->cursor = cursor;
        goto Exit;
      }
 
      /* now, compute the signed value is necessary */
      if ( fields->value & FT_FRAME_OP_SIGNED )
        value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift );
 
      /* finally, store the value in the object */
 
      p = (FT_Byte*)structure + fields->offset;
      switch ( fields->size )
      {
      case ( 8 / FT_CHAR_BIT ):
        *(FT_Byte*)p = (FT_Byte)value;
        break;
 
      case ( 16 / FT_CHAR_BIT ):
        *(FT_UShort*)p = (FT_UShort)value;
        break;
 
      case ( 32 / FT_CHAR_BIT ):
        *(FT_UInt32*)p = (FT_UInt32)value;
        break;
 
      default:  /* for 64-bit systems */
        *(FT_ULong*)p = (FT_ULong)value;
      }
 
      /* go to next field */
      fields++;
    }
    while ( 1 );
 
  Exit:
    /* close the frame if it was opened by this read */
    if ( frame_accessed )
      FT_Stream_ExitFrame( stream );
 
    return error;
  }

FT_Stream_ReadULong()

FT_Stream_ReadULong	(	FT_Stream	stream,
		FT_Error *	error
	)

Definition at line 624 of file ftstream.c.

  {
    FT_Byte   reads[4];
    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_Stream_ReadULongLE()

FT_Stream_ReadULongLE	(	FT_Stream	stream,
		FT_Error *	error
	)

Definition at line 669 of file ftstream.c.

  {
    FT_Byte   reads[4];
    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;
 
  Fail:
    *error = FT_THROW( Invalid_Stream_Operation );
    FT_ERROR(( "FT_Stream_ReadULongLE:"
               " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
               stream->pos, stream->size ));
 
    return 0;
  }

FT_Stream_ReadUOffset()

FT_Stream_ReadUOffset	(	FT_Stream	stream,
		FT_Error *	error
	)

Definition at line 579 of file ftstream.c.

  {
    FT_Byte   reads[3];
    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_Stream_ReadUShort()

FT_Stream_ReadUShort	(	FT_Stream	stream,
		FT_Error *	error
	)

Definition at line 489 of file ftstream.c.

  {
    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_Stream_ReadUShortLE()

FT_Stream_ReadUShortLE	(	FT_Stream	stream,
		FT_Error *	error
	)

Definition at line 534 of file ftstream.c.

  {
    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_Stream_ReleaseFrame()

FT_Stream_ReleaseFrame	(	FT_Stream	stream,
		FT_Byte **	pbytes
	)

Definition at line 215 of file ftstream.c.

  {
    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 = NULL;
  }

Referenced by FT_Release_Frame().

FT_Stream_Seek()

FT_Stream_Seek	(	FT_Stream	stream,
		FT_ULong	pos
	)

Definition at line 57 of file ftstream.c.

  {
    FT_Error  error = FT_Err_Ok;
 
 
    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_THROW( 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_THROW( Invalid_Stream_Operation );
    }
 
    if ( !error )
      stream->pos = pos;
 
    return error;
  }

Referenced by ft_lzwstate_io(), ft_open_face_internal(), FT_Raccess_Get_DataOffsets(), FT_Raccess_Get_HeaderInfo(), FT_Seek_Stream(), and FT_Stream_Skip().

FT_Stream_Skip()

FT_Stream_Skip	(	FT_Stream	stream,
		FT_Long	distance
	)

Definition at line 92 of file ftstream.c.

  {
    if ( distance < 0 )
      return FT_THROW( Invalid_Stream_Operation );
 
    return FT_Stream_Seek( stream, stream->pos + (FT_ULong)distance );
  }

Referenced by FT_Skip_Stream().

FT_Stream_TryRead()

FT_Stream_TryRead	(	FT_Stream	stream,
		FT_Byte *	buffer,
		FT_ULong	count
	)

Definition at line 164 of file ftstream.c.

  {
    FT_ULong  read_bytes = 0;
 
 
    if ( stream->pos >= stream->size )
      goto Exit;
 
    if ( stream->read )
      read_bytes = stream->read( stream, stream->pos, buffer, count );
    else
    {
      read_bytes = stream->size - stream->pos;
      if ( read_bytes > count )
        read_bytes = count;
 
      FT_MEM_COPY( buffer, stream->base + stream->pos, read_bytes );
    }
 
    stream->pos += read_bytes;
 
  Exit:
    return read_bytes;
  }

Referenced by _bdf_readstream(), ft_lzwstate_io(), and ft_lzwstate_refill().