kc3-lang/freetype/src/base/ftstream.c

• Show log

  Commit

• Hash : 7d3a2642
  Author :
  Date : 2002-03-20T10:49:31
  

  * renaming stream macros. Examples: FILE_Skip => FT_STREAM_SKIP FILE_Read => FT_STREAM_READ ACCESS_Frame => FT_FRAME_ENTER FORGET_Frame => FT_FRAME_EXIT etc...

Download

• src/base/ftstream.c

• /***************************************************************************/
  /*                                                                         */
  /*  ftstream.c                                                             */
  /*                                                                         */
  /*    I/O stream support (body).                                           */
  /*                                                                         */
  /*  Copyright 2000-2001 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(( "%s: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                     "FT_Stream_Seek", 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(( "%s: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                   "FT_Stream_Seek", 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(( "%s: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                   "FT_Stream_ReadAt", 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;
  
        MEM_Copy( buffer, stream->base + pos, read_bytes );
      }
  
      stream->pos = pos + read_bytes;
  
      if ( read_bytes < count )
      {
        FT_ERROR(( "%s: invalid read; expected %lu bytes, got %lu\n",
                   "FT_Stream_ReadAt", 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;
  
  
        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 ( 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 ));
  
          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;
  
  
        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       = 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       = NEXT_ShortLE( 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       = NEXT_Offset( 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       = 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       = NEXT_LongLE( 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 )
      {
        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 result;
  
    Fail:
      *error = FT_Err_Invalid_Stream_Operation;
      FT_ERROR(( "%s: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                 "FT_Stream_ReadChar", stream->pos, stream->size ));
  
      return 0;
    }
  
  
    FT_BASE_DEF( FT_Short )
    FT_Stream_ReadShort( FT_Stream  stream,
                         FT_Error*  error )
    {
      FT_Byte   reads[2];
      FT_Byte*  p = 0;
      FT_Short  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 = NEXT_Short( p );
      }
      else
        goto Fail;
  
      stream->pos += 2;
  
      return result;
  
    Fail:
      *error = FT_Err_Invalid_Stream_Operation;
      FT_ERROR(( "FT_Stream_ReadShort:" ));
      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                 stream->pos, stream->size ));
  
      return 0;
    }
  
  
    FT_BASE_DEF( FT_Short )
    FT_Stream_ReadShortLE( FT_Stream  stream,
                           FT_Error*  error )
    {
      FT_Byte   reads[2];
      FT_Byte*  p = 0;
      FT_Short  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 = NEXT_ShortLE( p );
      }
      else
        goto Fail;
  
      stream->pos += 2;
  
      return result;
  
    Fail:
      *error = FT_Err_Invalid_Stream_Operation;
      FT_ERROR(( "FT_Stream_ReadShort:" ));
      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                 stream->pos, stream->size ));
  
      return 0;
    }
  
  
    FT_BASE_DEF( FT_Long )
    FT_Stream_ReadOffset( FT_Stream  stream,
                          FT_Error*  error )
    {
      FT_Byte   reads[3];
      FT_Byte*  p = 0;
      FT_Long   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 = NEXT_Offset( p );
      }
      else
        goto Fail;
  
      stream->pos += 3;
  
      return result;
  
    Fail:
      *error = FT_Err_Invalid_Stream_Operation;
      FT_ERROR(( "%s: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                 "FT_Stream_ReadOffset", stream->pos, stream->size ));
  
      return 0;
    }
  
  
    FT_BASE_DEF( FT_Long )
    FT_Stream_ReadLong( FT_Stream  stream,
                        FT_Error*  error )
    {
         FT_Byte   reads[4];
      FT_Byte*  p = 0;
      FT_Long   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 = NEXT_Long( p );
      }
      else
        goto Fail;
  
      stream->pos += 4;
  
      return result;
  
    Fail:
      FT_ERROR(( "%s: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                 "FT_Stream_ReadLong", stream->pos, stream->size ));
      *error = FT_Err_Invalid_Stream_Operation;
  
      return 0;
    }
  
  
    FT_BASE_DEF( FT_Long )
    FT_Stream_ReadLongLE( FT_Stream  stream,
                          FT_Error*  error )
    {
      FT_Byte   reads[4];
      FT_Byte*  p = 0;
      FT_Long   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 = NEXT_LongLE( p );
      }
      else
        goto Fail;
  
      stream->pos += 4;
  
      return result;
  
    Fail:
      FT_ERROR(( "FT_Stream_ReadLong:" ));
      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                 stream->pos, stream->size ));
      *error = FT_Err_Invalid_Stream_Operation;
  
      return 0;
    }
  
  
    FT_BASE_DEF( FT_Error )
    FT_Stream_ReadFields( FT_Stream              stream,
                          const FT_Frame_Field*  fields,
                          void*                  structure )
    {
      FT_Error  error;
      FT_Bool   frame_accessed = 0;
      FT_Byte*  cursor = stream->cursor;
  
  
      if ( !fields || !stream )
        return FT_Err_Invalid_Argument;
  
      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_Err_Invalid_Stream_Operation;
              goto Exit;
            }
  
            if ( fields->value == ft_frame_bytes )
            {
              p = (FT_Byte*)structure + fields->offset;
              MEM_Copy( p, cursor, len );
            }
            cursor += len;
            fields++;
            continue;
          }
  
        case ft_frame_byte:
        case ft_frame_schar:  /* read a single byte */
          value = 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 = 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 = NEXT_UShortLE(cursor);
          sign_shift = 16;
          break;
  
        case ft_frame_long_be:
        case ft_frame_ulong_be:  /* read a 4-byte big-endian long */
          value = 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 = NEXT_ULongLE(cursor);
          sign_shift = 0;
          break;
  
        case ft_frame_off3_be:
        case ft_frame_uoff3_be:  /* read a 3-byte big-endian long */
          value = NEXT_UOffset(cursor);
          sign_shift = 8;
          break;
  
        case ft_frame_off3_le:
        case ft_frame_uoff3_le:  /* read a 3-byte little-endian long */
          value = NEXT_UOffsetLE(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 1:
          *(FT_Byte*)p = (FT_Byte)value;
          break;
  
        case 2:
          *(FT_UShort*)p = (FT_UShort)value;
          break;
  
        case 4:
          *(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;
    }
  
  
  /* END */
  

Download