[wxWidgets.git] / src / freetype / base / ftstream.c

/***************************************************************************/
/*                                                                         */
/*  ftstream.c                                                             */
/*                                                                         */
/*    I/O stream support (body).                                           */
/*                                                                         */
/*  Copyright 2000 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 <freetype/internal/ftstream.h>
#include <freetype/internal/ftdebug.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


  BASE_FUNC( void )  FT_New_Memory_Stream( FT_Library  library,
                                           FT_Byte*    base,
                                           FT_ULong    size,
                                           FT_Stream   stream )
  {
    stream->memory = library->memory;
    stream->base   = base;
    stream->size   = size;
    stream->pos    = 0;
    stream->cursor = 0;
    stream->read   = 0;
    stream->close  = 0;
  }


  BASE_FUNC( FT_Error )  FT_Seek_Stream( FT_Stream  stream,
                                         FT_ULong   pos )
  {
    FT_Error  error;


    stream->pos = pos;

    if ( stream->read )
    {
      if ( stream->read( stream, pos, 0, 0 ) )
      {
        FT_ERROR(( "FT_Seek_Stream:" ));
        FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                   pos, stream->size ));

        error = FT_Err_Invalid_Stream_Operation;
      }
      else
        error = FT_Err_Ok;
    }
    /* note that seeking to the first position after the file is valid */
    else if ( pos > stream->size )
    {
      FT_ERROR(( "FT_Seek_Stream:" ));
      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                 pos, stream->size ));

      error = FT_Err_Invalid_Stream_Operation;
    }

    else
      error = FT_Err_Ok;

    return error;
  }


  BASE_FUNC( FT_Error )  FT_Skip_Stream( FT_Stream  stream,
                                         FT_Long    distance )
  {
    return FT_Seek_Stream( stream, (FT_ULong)( stream->pos + distance ) );
  }


  BASE_FUNC( FT_Long )  FT_Stream_Pos( FT_Stream  stream )
  {
    return stream->pos;
  }


  BASE_FUNC( FT_Error )  FT_Read_Stream( FT_Stream  stream,
                                         FT_Byte*   buffer,
                                         FT_ULong   count )
  {
    return FT_Read_Stream_At( stream, stream->pos, buffer, count );
  }


  BASE_FUNC( FT_Error )  FT_Read_Stream_At( 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_Read_Stream_At:" ));
      FT_ERROR(( " 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;

      MEM_Copy( buffer, stream->base + pos, read_bytes );
    }

    stream->pos = pos + read_bytes;

    if ( read_bytes < count )
    {
      FT_ERROR(( "FT_Read_Stream_At:" ));
      FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
                 count, read_bytes ));

      error = FT_Err_Invalid_Stream_Operation;
    }

    return error;
  }


  BASE_FUNC( FT_Error )  FT_Extract_Frame( FT_Stream  stream,
                                           FT_ULong   count,
                                           FT_Byte**  pbytes )
  {
    FT_Error  error;


    error = FT_Access_Frame( stream, count );
    if ( !error )
    {
      *pbytes = (FT_Byte*)stream->cursor;

      /* equivalent to FT_Forget_Frame(), with no memory block release */
      stream->cursor = 0;
      stream->limit  = 0;
    }

    return error;
  }


  BASE_FUNC( void )  FT_Release_Frame( FT_Stream  stream,
                                       FT_Byte**  pbytes )
  {
    if ( stream->read )
    {
      FT_Memory  memory = stream->memory;


      FREE( *pbytes );
    }
    *pbytes = 0;
  }


  BASE_FUNC( FT_Error )  FT_Access_Frame( 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_Access_Frame:" ));
        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_Access_Frame:" ));
        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;
  }


  BASE_FUNC( void )  FT_Forget_Frame( 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_Access_Frame() 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;
  }


  BASE_FUNC( FT_Char )  FT_Get_Char( FT_Stream  stream )
  {
    FT_Char  result;


    FT_Assert( stream && stream->cursor );

    result = 0;
    if ( stream->cursor < stream->limit )
      result = *stream->cursor++;

    return result;
  }


  BASE_FUNC( FT_Short )  FT_Get_Short( 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;
  }


  BASE_FUNC( FT_Short )  FT_Get_ShortLE( 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;
  }


  BASE_FUNC( FT_Long )  FT_Get_Offset( 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;
  }


  BASE_FUNC( FT_Long )  FT_Get_Long( 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;
  }


  BASE_FUNC( FT_Long )  FT_Get_LongLE( 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;
  }


  BASE_FUNC( FT_Char )  FT_Read_Char( 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(( "FT_Read_Char:" ));
    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
               stream->pos, stream->size ));

    return 0;
  }


  BASE_FUNC( FT_Short )  FT_Read_Short( 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_Read_Short:" ));
    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
               stream->pos, stream->size ));

    return 0;
  }


  BASE_FUNC( FT_Short )  FT_Read_ShortLE( 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_Read_Short:" ));
    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
               stream->pos, stream->size ));

    return 0;
  }


  BASE_FUNC( FT_Long )  FT_Read_Offset( 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(( "FT_Read_Offset:" ));
    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
               stream->pos, stream->size ));

    return 0;
  }


  BASE_FUNC( FT_Long )  FT_Read_Long( 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(( "FT_Read_Long:" ));
    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
               stream->pos, stream->size ));
    *error = FT_Err_Invalid_Stream_Operation;

    return 0;
  }


  BASE_FUNC( FT_Long )  FT_Read_LongLE( 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_Read_Long:" ));
    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
               stream->pos, stream->size ));
    *error = FT_Err_Invalid_Stream_Operation;

    return 0;
  }


  BASE_FUNC( FT_Error ) FT_Read_Fields( FT_Stream              stream,
                                        const FT_Frame_Field*  fields,
                                        void*                  structure )
  {
    FT_Error  error;
    FT_Bool   frame_accessed = 0;


    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_Access_Frame( stream, fields->offset );
        if ( error )
          goto Exit;

        frame_accessed = 1;
        fields++;
        continue;  /* loop! */

      case ft_frame_bytes:  /* read a byte sequence */
      case ft_frame_skip:   /* skip some bytes      */
        {
          FT_Int  len = fields->size;


          if ( stream->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, stream->cursor, len );
          }
          stream->cursor += len;
          fields++;
          continue;
        }

      case ft_frame_byte:
      case ft_frame_schar:  /* read a single byte */
        value = GET_Byte();
        sign_shift = 24;
        break;

      case ft_frame_short_be:
      case ft_frame_ushort_be:  /* read a 2-byte big-endian short */
        value = GET_UShort();
        sign_shift = 16;
        break;

      case ft_frame_short_le:
      case ft_frame_ushort_le:  /* read a 2-byte little-endian short */
        {
          FT_Byte*  p;


          value = 0;
          p     = stream->cursor;

          if ( p + 1 < stream->limit )
          {
            value = ( FT_UShort)p[0] | ((FT_UShort)p[1] << 8 );
            stream->cursor += 2;
          }
          sign_shift = 16;
          break;
        }

      case ft_frame_long_be:
      case ft_frame_ulong_be:  /* read a 4-byte big-endian long */
        value = GET_ULong();
        sign_shift = 0;
        break;

      case ft_frame_long_le:
      case ft_frame_ulong_le:  /* read a 4-byte little-endian long */
        {
          FT_Byte*  p;


          value = 0;
          p     = stream->cursor;

          if ( p + 3 < stream->limit )
          {
            value =   (FT_ULong)p[0]         |
                    ( (FT_ULong)p[1] << 8  ) |
                    ( (FT_ULong)p[2] << 16 ) |
                    ( (FT_ULong)p[3] << 24 );
            stream->cursor += 4;
          }
          sign_shift = 0;
          break;
        }

      case ft_frame_off3_be:
      case ft_frame_uoff3_be:  /* read a 3-byte big-endian long */
        value = GET_UOffset();
        sign_shift = 8;
        break;

      case ft_frame_off3_le:
      case ft_frame_uoff3_le:  /* read a 3-byte little-endian long */
        {
          FT_Byte*  p;


          value = 0;
          p     = stream->cursor;

          if ( p + 2 < stream->limit )
          {
            value =   (FT_ULong)p[0]         |
                    ( (FT_ULong)p[1] << 8  ) |
                    ( (FT_ULong)p[2] << 16 );
            stream->cursor += 3;
          }
          sign_shift = 8;
          break;
        }

      default:
        /* otherwise, exit the loop */
        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_Forget_Frame( stream );

    return error;
  }


/* END */
Commit	Line	Data
cabec872 RR	1	/***************************************************************************/
	2	/* */
	3	/* ftstream.c */
	4	/* */
	5	/* I/O stream support (body). */
	6	/* */
	7	/* Copyright 2000 by */
	8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
	9	/* */
	10	/* This file is part of the FreeType project, and may only be used, */
	11	/* modified, and distributed under the terms of the FreeType project */
	12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
	13	/* this file you indicate that you have read the license and */
	14	/* understand and accept it fully. */
	15	/* */
	16	/***************************************************************************/
	17
	18
	19	#include <freetype/internal/ftstream.h>
	20	#include <freetype/internal/ftdebug.h>
	21
	22
	23	/*************************************************************************/
	24	/* */
	25	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
	26	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
	27	/* messages during execution. */
	28	/* */
	29	#undef FT_COMPONENT
	30	#define FT_COMPONENT trace_stream
	31
	32
	33	BASE_FUNC( void ) FT_New_Memory_Stream( FT_Library library,
	34	FT_Byte* base,
	35	FT_ULong size,
	36	FT_Stream stream )
	37	{
	38	stream->memory = library->memory;
	39	stream->base = base;
	40	stream->size = size;
	41	stream->pos = 0;
	42	stream->cursor = 0;
	43	stream->read = 0;
	44	stream->close = 0;
	45	}
	46
	47
	48	BASE_FUNC( FT_Error ) FT_Seek_Stream( FT_Stream stream,
	49	FT_ULong pos )
	50	{
	51	FT_Error error;
	52
	53
	54	stream->pos = pos;
	55
	56	if ( stream->read )
	57	{
	58	if ( stream->read( stream, pos, 0, 0 ) )
	59	{
	60	FT_ERROR(( "FT_Seek_Stream:" ));
	61	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
	62	pos, stream->size ));
	63
	64	error = FT_Err_Invalid_Stream_Operation;
65	}
66	else
67	error = FT_Err_Ok;
68	}
69	/* note that seeking to the first position after the file is valid */
70	else if ( pos > stream->size )
71	{
72	FT_ERROR(( "FT_Seek_Stream:" ));
73	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
74	pos, stream->size ));
75
76	error = FT_Err_Invalid_Stream_Operation;
77	}
78
79	else
80	error = FT_Err_Ok;
81
82	return error;
83	}
84
85
86	BASE_FUNC( FT_Error ) FT_Skip_Stream( FT_Stream stream,
87	FT_Long distance )
88	{
89	return FT_Seek_Stream( stream, (FT_ULong)( stream->pos + distance ) );
90	}
91
92
93	BASE_FUNC( FT_Long ) FT_Stream_Pos( FT_Stream stream )
94	{
95	return stream->pos;
96	}
97
98
99	BASE_FUNC( FT_Error ) FT_Read_Stream( FT_Stream stream,
100	FT_Byte* buffer,
101	FT_ULong count )
102	{
103	return FT_Read_Stream_At( stream, stream->pos, buffer, count );
104	}
105
106
107	BASE_FUNC( FT_Error ) FT_Read_Stream_At( FT_Stream stream,
108	FT_ULong pos,
109	FT_Byte* buffer,
110	FT_ULong count )
111	{
112	FT_Error error = FT_Err_Ok;
113	FT_ULong read_bytes;
114
115
116	if ( pos >= stream->size )
117	{
118	FT_ERROR(( "FT_Read_Stream_At:" ));
119	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
120	pos, stream->size ));
121
122	return FT_Err_Invalid_Stream_Operation;
123	}
124
125	if ( stream->read )
126	read_bytes = stream->read( stream, pos, buffer, count );
127	else
128	{
129	read_bytes = stream->size - pos;
130	if ( read_bytes > count )
131	read_bytes = count;
132
133	MEM_Copy( buffer, stream->base + pos, read_bytes );
134	}
135
136	stream->pos = pos + read_bytes;
137
138	if ( read_bytes < count )
139	{
140	FT_ERROR(( "FT_Read_Stream_At:" ));
141	FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
142	count, read_bytes ));
143
144	error = FT_Err_Invalid_Stream_Operation;
145	}
146
147	return error;
148	}
149
150
151	BASE_FUNC( FT_Error ) FT_Extract_Frame( FT_Stream stream,
152	FT_ULong count,
153	FT_Byte** pbytes )
154	{
155	FT_Error error;
156
157
158	error = FT_Access_Frame( stream, count );
159	if ( !error )
160	{
161	pbytes = (FT_Byte)stream->cursor;
162
163	/* equivalent to FT_Forget_Frame(), with no memory block release */
164	stream->cursor = 0;
165	stream->limit = 0;
166	}
167
168	return error;
169	}
170
171
172	BASE_FUNC( void ) FT_Release_Frame( FT_Stream stream,
173	FT_Byte** pbytes )
174	{
175	if ( stream->read )
176	{
177	FT_Memory memory = stream->memory;
178
179
180	FREE( *pbytes );
181	}
182	*pbytes = 0;
183	}
184
185
186	BASE_FUNC( FT_Error ) FT_Access_Frame( FT_Stream stream,
187	FT_ULong count )
188	{
189	FT_Error error = FT_Err_Ok;
190	FT_ULong read_bytes;
191
192
193	/* check for nested frame access */
194	FT_Assert( stream && stream->cursor == 0 );
195
196	if ( stream->read )
197	{
198	/* allocate the frame in memory */
199	FT_Memory memory = stream->memory;
200
201
202	if ( ALLOC( stream->base, count ) )
203	goto Exit;
204
205	/* read it */
206	read_bytes = stream->read( stream, stream->pos,
207	stream->base, count );
208	if ( read_bytes < count )
209	{
210	FT_ERROR(( "FT_Access_Frame:" ));
211	FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
212	count, read_bytes ));
213
214	FREE( stream->base );
215	error = FT_Err_Invalid_Stream_Operation;
216	}
217	stream->cursor = stream->base;
218	stream->limit = stream->cursor + count;
219	stream->pos += read_bytes;
220	}
221	else
222	{
223	/* check current and new position */
224	if ( stream->pos >= stream->size \|\|
225	stream->pos + count > stream->size )
226	{
227	FT_ERROR(( "FT_Access_Frame:" ));
228	FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
229	stream->pos, count, stream->size ));
230
231	error = FT_Err_Invalid_Stream_Operation;
232	goto Exit;
233	}
234
235	/* set cursor */
236	stream->cursor = stream->base + stream->pos;
237	stream->limit = stream->cursor + count;
238	stream->pos += count;
239	}
240
241	Exit:
242	return error;
243	}
244
245
246	BASE_FUNC( void ) FT_Forget_Frame( FT_Stream stream )
247	{
248	/* IMPORTANT: The assertion stream->cursor != 0 was removed, given */
249	/* that it is possible to access a frame of length 0 in */
250	/* some weird fonts (usually, when accessing an array of */
251	/* 0 records, like in some strange kern tables). */
252	/* */
253	/* In this case, the loader code handles the 0-length table */
254	/* gracefully; however, stream.cursor is really set to 0 by the */
255	/* FT_Access_Frame() call, and this is not an error. */
256	/* */
257	FT_Assert( stream );
258
259	if ( stream->read )
260	{
261	FT_Memory memory = stream->memory;
262
263
264	FREE( stream->base );
265	}
266	stream->cursor = 0;
267	stream->limit = 0;
268	}
269
270
271	BASE_FUNC( FT_Char ) FT_Get_Char( FT_Stream stream )
272	{
273	FT_Char result;
274
275
276	FT_Assert( stream && stream->cursor );
277
278	result = 0;
279	if ( stream->cursor < stream->limit )
280	result = *stream->cursor++;
281
282	return result;
283	}
284
285
286	BASE_FUNC( FT_Short ) FT_Get_Short( FT_Stream stream )
287	{
288	FT_Byte* p;
289	FT_Short result;
290
291
292	FT_Assert( stream && stream->cursor );
293
294	result = 0;
295	p = stream->cursor;
296	if ( p + 1 < stream->limit )
297	result = NEXT_Short( p );
298	stream->cursor = p;
299
300	return result;
301	}
302
303
304	BASE_FUNC( FT_Short ) FT_Get_ShortLE( FT_Stream stream )
305	{
306	FT_Byte* p;
307	FT_Short result;
308
309
310	FT_Assert( stream && stream->cursor );
311
312	result = 0;
313	p = stream->cursor;
314	if ( p + 1 < stream->limit )
315	result = NEXT_ShortLE( p );
316	stream->cursor = p;
317
318	return result;
319	}
320
321
322	BASE_FUNC( FT_Long ) FT_Get_Offset( FT_Stream stream )
323	{
324	FT_Byte* p;
325	FT_Long result;
326
327
328	FT_Assert( stream && stream->cursor );
329
330	result = 0;
331	p = stream->cursor;
332	if ( p + 2 < stream->limit )
333	result = NEXT_Offset( p );
334	stream->cursor = p;
335	return result;
336	}
337
338
339	BASE_FUNC( FT_Long ) FT_Get_Long( FT_Stream stream )
340	{
341	FT_Byte* p;
342	FT_Long result;
343
344
345	FT_Assert( stream && stream->cursor );
346
347	result = 0;
348	p = stream->cursor;
349	if ( p + 3 < stream->limit )
350	result = NEXT_Long( p );
351	stream->cursor = p;
352	return result;
353	}
354
355
356	BASE_FUNC( FT_Long ) FT_Get_LongLE( FT_Stream stream )
357	{
358	FT_Byte* p;
359	FT_Long result;
360
361
362	FT_Assert( stream && stream->cursor );
363
364	result = 0;
365	p = stream->cursor;
366	if ( p + 3 < stream->limit )
367	result = NEXT_LongLE( p );
368	stream->cursor = p;
369	return result;
370	}
371
372
373	BASE_FUNC( FT_Char ) FT_Read_Char( FT_Stream stream,
374	FT_Error* error )
375	{
376	FT_Byte result = 0;
377
378
379	FT_Assert( stream );
380
381	*error = FT_Err_Ok;
382
383	if ( stream->read )
384	{
385	if ( stream->read( stream, stream->pos, &result, 1L ) != 1L )
386	goto Fail;
387	}
388	else
389	{
390	if ( stream->pos < stream->size )
391	result = stream->base[stream->pos];
392	else
393	goto Fail;
394	}
395	stream->pos++;
396
397	return result;
398
399	Fail:
400	*error = FT_Err_Invalid_Stream_Operation;
401	FT_ERROR(( "FT_Read_Char:" ));
402	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
403	stream->pos, stream->size ));
404
405	return 0;
406	}
407
408
409	BASE_FUNC( FT_Short ) FT_Read_Short( FT_Stream stream,
410	FT_Error* error )
411	{
412	FT_Byte reads[2];
413	FT_Byte* p = 0;
414	FT_Short result = 0;
415
416
417	FT_Assert( stream );
418
419	*error = FT_Err_Ok;
420
421	if ( stream->pos + 1 < stream->size )
422	{
423	if ( stream->read )
424	{
425	if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
426	goto Fail;
427
428	p = reads;
429	}
430	else
431	{
432	p = stream->base + stream->pos;
433	}
434
435	if ( p )
436	result = NEXT_Short( p );
437	}
438	else
439	goto Fail;
440
441	stream->pos += 2;
442
443	return result;
444
445	Fail:
446	*error = FT_Err_Invalid_Stream_Operation;
447	FT_ERROR(( "FT_Read_Short:" ));
448	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
449	stream->pos, stream->size ));
450
451	return 0;
452	}
453
454
455	BASE_FUNC( FT_Short ) FT_Read_ShortLE( FT_Stream stream,
456	FT_Error* error )
457	{
458	FT_Byte reads[2];
459	FT_Byte* p = 0;
460	FT_Short result = 0;
461
462
463	FT_Assert( stream );
464
465	*error = FT_Err_Ok;
466
467	if ( stream->pos + 1 < stream->size )
468	{
469	if ( stream->read )
470	{
471	if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
472	goto Fail;
473
474	p = reads;
475	}
476	else
477	{
478	p = stream->base + stream->pos;
479	}
480
481	if ( p )
482	result = NEXT_ShortLE( p );
483	}
484	else
485	goto Fail;
486
487	stream->pos += 2;
488
489	return result;
490
491	Fail:
492	*error = FT_Err_Invalid_Stream_Operation;
493	FT_ERROR(( "FT_Read_Short:" ));
494	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
495	stream->pos, stream->size ));
496
497	return 0;
498	}
499
500
501	BASE_FUNC( FT_Long ) FT_Read_Offset( FT_Stream stream,
502	FT_Error* error )
503	{
504	FT_Byte reads[3];
505	FT_Byte* p = 0;
506	FT_Long result = 0;
507
508
509	FT_Assert( stream );
510
511	*error = FT_Err_Ok;
512
513	if ( stream->pos + 2 < stream->size )
514	{
515	if ( stream->read )
516	{
517	if (stream->read( stream, stream->pos, reads, 3L ) != 3L )
518	goto Fail;
519
520	p = reads;
521	}
522	else
523	{
524	p = stream->base + stream->pos;
525	}
526
527	if ( p )
528	result = NEXT_Offset( p );
529	}
530	else
531	goto Fail;
532
533	stream->pos += 3;
534
535	return result;
536
537	Fail:
538	*error = FT_Err_Invalid_Stream_Operation;
539	FT_ERROR(( "FT_Read_Offset:" ));
540	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
541	stream->pos, stream->size ));
542
543	return 0;
544	}
545
546
547	BASE_FUNC( FT_Long ) FT_Read_Long( FT_Stream stream,
548	FT_Error* error )
549	{
550	FT_Byte reads[4];
551	FT_Byte* p = 0;
552	FT_Long result = 0;
553
554
555	FT_Assert( stream );
556
557	*error = FT_Err_Ok;
558
559	if ( stream->pos + 3 < stream->size )
560	{
561	if ( stream->read )
562	{
563	if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
564	goto Fail;
565
566	p = reads;
567	}
568	else
569	{
570	p = stream->base + stream->pos;
571	}
572
573	if ( p )
574	result = NEXT_Long( p );
575	}
576	else
577	goto Fail;
578
579	stream->pos += 4;
580
581	return result;
582
583	Fail:
584	FT_ERROR(( "FT_Read_Long:" ));
585	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
586	stream->pos, stream->size ));
587	*error = FT_Err_Invalid_Stream_Operation;
588
589	return 0;
590	}
591
592
593	BASE_FUNC( FT_Long ) FT_Read_LongLE( FT_Stream stream,
594	FT_Error* error )
595	{
596	FT_Byte reads[4];
597	FT_Byte* p = 0;
598	FT_Long result = 0;
599
600
601	FT_Assert( stream );
602
603	*error = FT_Err_Ok;
604
605	if ( stream->pos + 3 < stream->size )
606	{
607	if ( stream->read )
608	{
609	if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
610	goto Fail;
611
612	p = reads;
613	}
614	else
615	{
616	p = stream->base + stream->pos;
617	}
618
619	if ( p )
620	result = NEXT_LongLE( p );
621	}
622	else
623	goto Fail;
624
625	stream->pos += 4;
626
627	return result;
628
629	Fail:
630	FT_ERROR(( "FT_Read_Long:" ));
631	FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
632	stream->pos, stream->size ));
633	*error = FT_Err_Invalid_Stream_Operation;
634
635	return 0;
636	}
637
638
639	BASE_FUNC( FT_Error ) FT_Read_Fields( FT_Stream stream,
640	const FT_Frame_Field* fields,
641	void* structure )
642	{
643	FT_Error error;
644	FT_Bool frame_accessed = 0;
645
646
647	if ( !fields \|\| !stream )
648	return FT_Err_Invalid_Argument;
649
650	error = FT_Err_Ok;
651	do
652	{
653	FT_ULong value;
654	FT_Int sign_shift;
655	FT_Byte* p;
656
657
658	switch ( fields->value )
659	{
660	case ft_frame_start: /* access a new frame */
661	error = FT_Access_Frame( stream, fields->offset );
662	if ( error )
663	goto Exit;
664
665	frame_accessed = 1;
666	fields++;
667	continue; /* loop! */
668
669	case ft_frame_bytes: /* read a byte sequence */
670	case ft_frame_skip: /* skip some bytes */
671	{
672	FT_Int len = fields->size;
673
674
675	if ( stream->cursor + len > stream->limit )
676	{
677	error = FT_Err_Invalid_Stream_Operation;
678	goto Exit;
679	}
680
681	if ( fields->value == ft_frame_bytes )
682	{
683	p = (FT_Byte*)structure + fields->offset;
684	MEM_Copy( p, stream->cursor, len );
685	}
686	stream->cursor += len;
687	fields++;
688	continue;
689	}
690
691	case ft_frame_byte:
692	case ft_frame_schar: /* read a single byte */
693	value = GET_Byte();
694	sign_shift = 24;
695	break;
696
697	case ft_frame_short_be:
698	case ft_frame_ushort_be: /* read a 2-byte big-endian short */
699	value = GET_UShort();
700	sign_shift = 16;
701	break;
702
703	case ft_frame_short_le:
704	case ft_frame_ushort_le: /* read a 2-byte little-endian short */
705	{
706	FT_Byte* p;
707
708
709	value = 0;
710	p = stream->cursor;
711
712	if ( p + 1 < stream->limit )
713	{
714	value = ( FT_UShort)p[0] \| ((FT_UShort)p[1] << 8 );
715	stream->cursor += 2;
716	}
717	sign_shift = 16;
718	break;
719	}
720
721	case ft_frame_long_be:
722	case ft_frame_ulong_be: /* read a 4-byte big-endian long */
723	value = GET_ULong();
724	sign_shift = 0;
725	break;
726
727	case ft_frame_long_le:
728	case ft_frame_ulong_le: /* read a 4-byte little-endian long */
729	{
730	FT_Byte* p;
731
732
733	value = 0;
734	p = stream->cursor;
735
736	if ( p + 3 < stream->limit )
737	{
738	value = (FT_ULong)p[0] \|
739	( (FT_ULong)p[1] << 8 ) \|
740	( (FT_ULong)p[2] << 16 ) \|
741	( (FT_ULong)p[3] << 24 );
742	stream->cursor += 4;
743	}
744	sign_shift = 0;
745	break;
746	}
747
748	case ft_frame_off3_be:
749	case ft_frame_uoff3_be: /* read a 3-byte big-endian long */
750	value = GET_UOffset();
751	sign_shift = 8;
752	break;
753
754	case ft_frame_off3_le:
755	case ft_frame_uoff3_le: /* read a 3-byte little-endian long */
756	{
757	FT_Byte* p;
758
759
760	value = 0;
761	p = stream->cursor;
762
763	if ( p + 2 < stream->limit )
764	{
765	value = (FT_ULong)p[0] \|
766	( (FT_ULong)p[1] << 8 ) \|
767	( (FT_ULong)p[2] << 16 );
768	stream->cursor += 3;
769	}
770	sign_shift = 8;
771	break;
772	}
773
774	default:
775	/* otherwise, exit the loop */
776	goto Exit;
777	}
778
779	/* now, compute the signed value is necessary */
780	if ( fields->value & FT_FRAME_OP_SIGNED )
781	value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift );
782
783	/* finally, store the value in the object */
784
785	p = (FT_Byte*)structure + fields->offset;
786	switch ( fields->size )
787	{
788	case 1:
789	(FT_Byte)p = (FT_Byte)value;
790	break;
791
792	case 2:
793	(FT_UShort)p = (FT_UShort)value;
794	break;
795
796	case 4:
797	(FT_UInt32)p = (FT_UInt32)value;
798	break;
799
800	default: /* for 64-bit systems */
801	(FT_ULong)p = (FT_ULong)value;
802	}
803
804	/* go to next field */
805	fields++;
806	}
807	while ( 1 );
808
809	Exit:
810	/* close the frame if it was opened by this read */
811	if ( frame_accessed )
812	FT_Forget_Frame( stream );
813
814	return error;
815	}
816
817
818	/* END */