{      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_Stream_ReadChar: invalid i/o; pos = 0x%lx, size = 0x%lx\n",               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 = FT_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 = FT_NEXT_SHORT_LE( p );    }    else      goto Fail;    stream->pos += 2;    return result;  Fail:    *error = FT_Err_Invalid_Stream_Operation;    FT_ERROR(( "FT_Stream_ReadShortLE:" ));    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 = FT_NEXT_OFF3( p );    }    else      goto Fail;    stream->pos += 3;    return result;  Fail:    *error = FT_Err_Invalid_Stream_Operation;    FT_ERROR(( "FT_Stream_ReadOffset:" ));    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_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 = FT_NEXT_LONG( p );    }    else      goto Fail;    stream->pos += 4;    return result;  Fail:    FT_ERROR(( "FT_Stream_ReadLong: 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_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 = FT_NEXT_LONG_LE( p );    }    else      goto Fail;    stream->pos += 4;    return result;  Fail:    FT_ERROR(( "FT_Stream_ReadLongLE:" ));    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;            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 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 */