ReactOS 0.4.16-dev-2357-g35d0dfe
Classes | Macros | Typedefs | Enumerations | Functions
ftstream.h File Reference
#include <ft2build.h>
#include <freetype/ftsystem.h>
#include <freetype/internal/ftobjs.h>
Include dependency graph for ftstream.h:

Go to the source code of this file.

Classes

struct  FT_Frame_Field_
 

Macros

#define FT_FRAME_OP_SHIFT   2
 
#define FT_FRAME_OP_SIGNED   1
 
#define FT_FRAME_OP_LITTLE   2
 
#define FT_FRAME_OP_COMMAND(x)   ( x >> FT_FRAME_OP_SHIFT )
 
#define FT_MAKE_FRAME_OP(command, little, sign)    ( ( command << FT_FRAME_OP_SHIFT ) | ( little << 1 ) | sign )
 
#define FT_FRAME_OP_END   0
 
#define FT_FRAME_OP_START   1 /* start a new frame */
 
#define FT_FRAME_OP_BYTE   2 /* read 1-byte value */
 
#define FT_FRAME_OP_SHORT   3 /* read 2-byte value */
 
#define FT_FRAME_OP_LONG   4 /* read 4-byte value */
 
#define FT_FRAME_OP_OFF3   5 /* read 3-byte value */
 
#define FT_FRAME_OP_BYTES   6 /* read a bytes sequence */
 
#define FT_FIELD_SIZE(f)    (FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f )
 
#define FT_FIELD_SIZE_DELTA(f)    (FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f[0] )
 
#define FT_FIELD_OFFSET(f)    (FT_UShort)( offsetof( FT_STRUCTURE, f ) )
 
#define FT_FRAME_FIELD(frame_op, field)
 
#define FT_MAKE_EMPTY_FIELD(frame_op)   { frame_op, 0, 0 }
 
#define FT_FRAME_START(size)   { ft_frame_start, 0, size }
 
#define FT_FRAME_END   { ft_frame_end, 0, 0 }
 
#define FT_FRAME_LONG(f)   FT_FRAME_FIELD( ft_frame_long_be, f )
 
#define FT_FRAME_ULONG(f)   FT_FRAME_FIELD( ft_frame_ulong_be, f )
 
#define FT_FRAME_SHORT(f)   FT_FRAME_FIELD( ft_frame_short_be, f )
 
#define FT_FRAME_USHORT(f)   FT_FRAME_FIELD( ft_frame_ushort_be, f )
 
#define FT_FRAME_OFF3(f)   FT_FRAME_FIELD( ft_frame_off3_be, f )
 
#define FT_FRAME_UOFF3(f)   FT_FRAME_FIELD( ft_frame_uoff3_be, f )
 
#define FT_FRAME_BYTE(f)   FT_FRAME_FIELD( ft_frame_byte, f )
 
#define FT_FRAME_CHAR(f)   FT_FRAME_FIELD( ft_frame_schar, f )
 
#define FT_FRAME_LONG_LE(f)   FT_FRAME_FIELD( ft_frame_long_le, f )
 
#define FT_FRAME_ULONG_LE(f)   FT_FRAME_FIELD( ft_frame_ulong_le, f )
 
#define FT_FRAME_SHORT_LE(f)   FT_FRAME_FIELD( ft_frame_short_le, f )
 
#define FT_FRAME_USHORT_LE(f)   FT_FRAME_FIELD( ft_frame_ushort_le, f )
 
#define FT_FRAME_OFF3_LE(f)   FT_FRAME_FIELD( ft_frame_off3_le, f )
 
#define FT_FRAME_UOFF3_LE(f)   FT_FRAME_FIELD( ft_frame_uoff3_le, f )
 
#define FT_FRAME_SKIP_LONG   { ft_frame_long_be, 0, 0 }
 
#define FT_FRAME_SKIP_SHORT   { ft_frame_short_be, 0, 0 }
 
#define FT_FRAME_SKIP_BYTE   { ft_frame_byte, 0, 0 }
 
#define FT_FRAME_BYTES(field, count)
 
#define FT_FRAME_SKIP_BYTES(count)   { ft_frame_skip, count, 0 }
 
#define FT_BYTE_(p, i)   ( ((const FT_Byte*)(p))[(i)] )
 
#define FT_INT16(x)   ( (FT_Int16)(x) )
 
#define FT_UINT16(x)   ( (FT_UInt16)(x) )
 
#define FT_INT32(x)   ( (FT_Int32)(x) )
 
#define FT_UINT32(x)   ( (FT_UInt32)(x) )
 
#define FT_BYTE_U16(p, i, s)   ( FT_UINT16( FT_BYTE_( p, i ) ) << (s) )
 
#define FT_BYTE_U32(p, i, s)   ( FT_UINT32( FT_BYTE_( p, i ) ) << (s) )
 
#define FT_PEEK_SHORT(p)
 
#define FT_PEEK_USHORT(p)
 
#define FT_PEEK_LONG(p)
 
#define FT_PEEK_ULONG(p)
 
#define FT_PEEK_OFF3(p)
 
#define FT_PEEK_UOFF3(p)
 
#define FT_PEEK_SHORT_LE(p)
 
#define FT_PEEK_USHORT_LE(p)
 
#define FT_PEEK_LONG_LE(p)
 
#define FT_PEEK_ULONG_LE(p)
 
#define FT_PEEK_OFF3_LE(p)
 
#define FT_PEEK_UOFF3_LE(p)
 
#define FT_NEXT_CHAR(buffer)    ( (signed char)*buffer++ )
 
#define FT_NEXT_BYTE(buffer)    ( (unsigned char)*buffer++ )
 
#define FT_NEXT_SHORT(buffer)    ( (short)( buffer += 2, FT_PEEK_SHORT( buffer - 2 ) ) )
 
#define FT_NEXT_USHORT(buffer)    ( (unsigned short)( buffer += 2, FT_PEEK_USHORT( buffer - 2 ) ) )
 
#define FT_NEXT_OFF3(buffer)    ( (long)( buffer += 3, FT_PEEK_OFF3( buffer - 3 ) ) )
 
#define FT_NEXT_UOFF3(buffer)    ( (unsigned long)( buffer += 3, FT_PEEK_UOFF3( buffer - 3 ) ) )
 
#define FT_NEXT_LONG(buffer)    ( (long)( buffer += 4, FT_PEEK_LONG( buffer - 4 ) ) )
 
#define FT_NEXT_ULONG(buffer)    ( (unsigned long)( buffer += 4, FT_PEEK_ULONG( buffer - 4 ) ) )
 
#define FT_NEXT_SHORT_LE(buffer)    ( (short)( buffer += 2, FT_PEEK_SHORT_LE( buffer - 2 ) ) )
 
#define FT_NEXT_USHORT_LE(buffer)    ( (unsigned short)( buffer += 2, FT_PEEK_USHORT_LE( buffer - 2 ) ) )
 
#define FT_NEXT_OFF3_LE(buffer)    ( (long)( buffer += 3, FT_PEEK_OFF3_LE( buffer - 3 ) ) )
 
#define FT_NEXT_UOFF3_LE(buffer)    ( (unsigned long)( buffer += 3, FT_PEEK_UOFF3_LE( buffer - 3 ) ) )
 
#define FT_NEXT_LONG_LE(buffer)    ( (long)( buffer += 4, FT_PEEK_LONG_LE( buffer - 4 ) ) )
 
#define FT_NEXT_ULONG_LE(buffer)    ( (unsigned long)( buffer += 4, FT_PEEK_ULONG_LE( buffer - 4 ) ) )
 
#define FT_GET_MACRO(func, type)   ( (type)func( stream ) )
 
#define FT_GET_CHAR()   FT_GET_MACRO( FT_Stream_GetChar, FT_Char )
 
#define FT_GET_BYTE()   FT_GET_MACRO( FT_Stream_GetChar, FT_Byte )
 
#define FT_GET_SHORT()   FT_GET_MACRO( FT_Stream_GetUShort, FT_Short )
 
#define FT_GET_USHORT()   FT_GET_MACRO( FT_Stream_GetUShort, FT_UShort )
 
#define FT_GET_OFF3()   FT_GET_MACRO( FT_Stream_GetUOffset, FT_Long )
 
#define FT_GET_UOFF3()   FT_GET_MACRO( FT_Stream_GetUOffset, FT_ULong )
 
#define FT_GET_LONG()   FT_GET_MACRO( FT_Stream_GetULong, FT_Long )
 
#define FT_GET_ULONG()   FT_GET_MACRO( FT_Stream_GetULong, FT_ULong )
 
#define FT_GET_TAG4()   FT_GET_MACRO( FT_Stream_GetULong, FT_ULong )
 
#define FT_GET_SHORT_LE()   FT_GET_MACRO( FT_Stream_GetUShortLE, FT_Short )
 
#define FT_GET_USHORT_LE()   FT_GET_MACRO( FT_Stream_GetUShortLE, FT_UShort )
 
#define FT_GET_LONG_LE()   FT_GET_MACRO( FT_Stream_GetULongLE, FT_Long )
 
#define FT_GET_ULONG_LE()   FT_GET_MACRO( FT_Stream_GetULongLE, FT_ULong )
 
#define FT_READ_MACRO(func, type, var)
 
#define FT_READ_BYTE(var)   FT_READ_MACRO( FT_Stream_ReadChar, FT_Byte, var )
 
#define FT_READ_CHAR(var)   FT_READ_MACRO( FT_Stream_ReadChar, FT_Char, var )
 
#define FT_READ_SHORT(var)   FT_READ_MACRO( FT_Stream_ReadUShort, FT_Short, var )
 
#define FT_READ_USHORT(var)   FT_READ_MACRO( FT_Stream_ReadUShort, FT_UShort, var )
 
#define FT_READ_OFF3(var)   FT_READ_MACRO( FT_Stream_ReadUOffset, FT_Long, var )
 
#define FT_READ_UOFF3(var)   FT_READ_MACRO( FT_Stream_ReadUOffset, FT_ULong, var )
 
#define FT_READ_LONG(var)   FT_READ_MACRO( FT_Stream_ReadULong, FT_Long, var )
 
#define FT_READ_ULONG(var)   FT_READ_MACRO( FT_Stream_ReadULong, FT_ULong, var )
 
#define FT_READ_SHORT_LE(var)   FT_READ_MACRO( FT_Stream_ReadUShortLE, FT_Short, var )
 
#define FT_READ_USHORT_LE(var)   FT_READ_MACRO( FT_Stream_ReadUShortLE, FT_UShort, var )
 
#define FT_READ_LONG_LE(var)   FT_READ_MACRO( FT_Stream_ReadULongLE, FT_Long, var )
 
#define FT_READ_ULONG_LE(var)   FT_READ_MACRO( FT_Stream_ReadULongLE, FT_ULong, var )
 
#define FT_STREAM_POS()    FT_Stream_Pos( stream )
 
#define FT_STREAM_SEEK(position)
 
#define FT_STREAM_SKIP(distance)
 
#define FT_STREAM_READ(buffer, count)
 
#define FT_STREAM_READ_AT(position, buffer, count)
 
#define FT_STREAM_READ_FIELDS(fields, object)    FT_SET_ERROR( FT_Stream_ReadFields( stream, fields, object ) )
 
#define FT_FRAME_ENTER(size)
 
#define FT_FRAME_EXIT()    FT_DEBUG_INNER( FT_Stream_ExitFrame( stream ) )
 
#define FT_FRAME_EXTRACT(size, bytes)
 
#define FT_FRAME_RELEASE(bytes)
 

Typedefs

typedef enum FT_Frame_Op_ FT_Frame_Op
 
typedef struct FT_Frame_Field_ FT_Frame_Field
 

Enumerations

enum  FT_Frame_Op_ {
  ft_frame_end = 0 , ft_frame_start = FT_MAKE_FRAME_OP( FT_FRAME_OP_START, 0, 0 ) , ft_frame_byte = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE, 0, 0 ) , ft_frame_schar = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE, 0, 1 ) ,
  ft_frame_ushort_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 0 ) , ft_frame_short_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 1 ) , ft_frame_ushort_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 0 ) , ft_frame_short_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 1 ) ,
  ft_frame_ulong_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 0 ) , ft_frame_long_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 1 ) , ft_frame_ulong_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 0 ) , ft_frame_long_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 1 ) ,
  ft_frame_uoff3_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 0 ) , ft_frame_off3_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 1 ) , ft_frame_uoff3_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 0 ) , ft_frame_off3_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 1 ) ,
  ft_frame_bytes = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTES, 0, 0 ) , ft_frame_skip = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTES, 0, 1 )
}
 

Functions

 FT_Stream_Open (FT_Stream stream, const char *filepathname)
 
 FT_Stream_New (FT_Library library, const FT_Open_Args *args, FT_Stream *astream)
 
 FT_Stream_Free (FT_Stream stream, FT_Int external)
 
 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_EnterFrame (FT_Stream stream, FT_ULong count)
 
 FT_Stream_ExitFrame (FT_Stream stream)
 
 FT_Stream_ExtractFrame (FT_Stream stream, FT_ULong count, FT_Byte **pbytes)
 
 FT_Stream_ReleaseFrame (FT_Stream stream, FT_Byte **pbytes)
 
 FT_Stream_GetChar (FT_Stream stream)
 
 FT_Stream_GetUShort (FT_Stream stream)
 
 FT_Stream_GetUOffset (FT_Stream stream)
 
 FT_Stream_GetULong (FT_Stream stream)
 
 FT_Stream_GetUShortLE (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_ReadUOffset (FT_Stream stream, FT_Error *error)
 
 FT_Stream_ReadULong (FT_Stream stream, FT_Error *error)
 
 FT_Stream_ReadUShortLE (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_BYTE_

#define FT_BYTE_ (   p,
  i 
)    ( ((const FT_Byte*)(p))[(i)] )

Definition at line 156 of file ftstream.h.

◆ FT_BYTE_U16

#define FT_BYTE_U16 (   p,
  i,
  s 
)    ( FT_UINT16( FT_BYTE_( p, i ) ) << (s) )

Definition at line 164 of file ftstream.h.

◆ FT_BYTE_U32

#define FT_BYTE_U32 (   p,
  i,
  s 
)    ( FT_UINT32( FT_BYTE_( p, i ) ) << (s) )

Definition at line 165 of file ftstream.h.

◆ FT_FIELD_OFFSET

#define FT_FIELD_OFFSET (   f)     (FT_UShort)( offsetof( FT_STRUCTURE, f ) )

Definition at line 105 of file ftstream.h.

◆ FT_FIELD_SIZE

#define FT_FIELD_SIZE (   f)     (FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f )

Definition at line 99 of file ftstream.h.

◆ FT_FIELD_SIZE_DELTA

#define FT_FIELD_SIZE_DELTA (   f)     (FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f[0] )

Definition at line 102 of file ftstream.h.

◆ FT_FRAME_BYTE

#define FT_FRAME_BYTE (   f)    FT_FRAME_FIELD( ft_frame_byte, f )

Definition at line 126 of file ftstream.h.

◆ FT_FRAME_BYTES

#define FT_FRAME_BYTES (   field,
  count 
)
Value:
{ \
ft_frame_bytes, \
count, \
FT_FIELD_OFFSET( field ) \
}
ft_frame_bytes
@ ft_frame_bytes
Definition: ftstream.h:80
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
field
Definition: parser.c:44

Definition at line 140 of file ftstream.h.

◆ FT_FRAME_CHAR

#define FT_FRAME_CHAR (   f)    FT_FRAME_FIELD( ft_frame_schar, f )

Definition at line 127 of file ftstream.h.

◆ FT_FRAME_END

#define FT_FRAME_END   { ft_frame_end, 0, 0 }

Definition at line 118 of file ftstream.h.

◆ FT_FRAME_ENTER

#define FT_FRAME_ENTER (   size)
Value:
FT_SET_ERROR( \
FT_DEBUG_INNER( FT_Stream_EnterFrame( stream, \
(FT_ULong)(size) ) ) )
FT_SET_ERROR
#define FT_SET_ERROR(expression)
Definition: ftmemory.h:43
FT_DEBUG_INNER
#define FT_DEBUG_INNER(exp)
Definition: ftmemory.h:112
FT_Stream_EnterFrame
FT_Stream_EnterFrame(FT_Stream stream, FT_ULong count)
Definition: ftstream.c:234
FT_ULong
unsigned long FT_ULong
Definition: fttypes.h:253
size
GLsizeiptr size
Definition: glext.h:5919
stream
Definition: parse.h:23

Definition at line 548 of file ftstream.h.

◆ FT_FRAME_EXIT

#define FT_FRAME_EXIT ( )     FT_DEBUG_INNER( FT_Stream_ExitFrame( stream ) )

Definition at line 553 of file ftstream.h.

◆ FT_FRAME_EXTRACT

#define FT_FRAME_EXTRACT (   size,
  bytes 
)
Value:
FT_SET_ERROR( \
FT_DEBUG_INNER( FT_Stream_ExtractFrame( stream, \
(FT_ULong)(size), \
(FT_Byte**)&(bytes) ) ) )
bytes
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
FT_Stream_ExtractFrame
FT_Stream_ExtractFrame(FT_Stream stream, FT_ULong count, FT_Byte **pbytes)
Definition: ftstream.c:192
FT_Byte
unsigned char FT_Byte
Definition: fttypes.h:154

Definition at line 556 of file ftstream.h.

◆ FT_FRAME_FIELD

#define FT_FRAME_FIELD (   frame_op,
  field 
)
Value:
{ \
frame_op, \
FT_FIELD_SIZE( field ), \
FT_FIELD_OFFSET( field ) \
}

Definition at line 108 of file ftstream.h.

◆ FT_FRAME_LONG

#define FT_FRAME_LONG (   f)    FT_FRAME_FIELD( ft_frame_long_be, f )

Definition at line 120 of file ftstream.h.

◆ FT_FRAME_LONG_LE

#define FT_FRAME_LONG_LE (   f)    FT_FRAME_FIELD( ft_frame_long_le, f )

Definition at line 129 of file ftstream.h.

◆ FT_FRAME_OFF3

#define FT_FRAME_OFF3 (   f)    FT_FRAME_FIELD( ft_frame_off3_be, f )

Definition at line 124 of file ftstream.h.

◆ FT_FRAME_OFF3_LE

#define FT_FRAME_OFF3_LE (   f)    FT_FRAME_FIELD( ft_frame_off3_le, f )

Definition at line 133 of file ftstream.h.

◆ FT_FRAME_OP_BYTE

#define FT_FRAME_OP_BYTE   2 /* read 1-byte value */

Definition at line 50 of file ftstream.h.

◆ FT_FRAME_OP_BYTES

#define FT_FRAME_OP_BYTES   6 /* read a bytes sequence */

Definition at line 54 of file ftstream.h.

◆ FT_FRAME_OP_COMMAND

#define FT_FRAME_OP_COMMAND (   x)    ( x >> FT_FRAME_OP_SHIFT )

Definition at line 43 of file ftstream.h.

◆ FT_FRAME_OP_END

#define FT_FRAME_OP_END   0

Definition at line 48 of file ftstream.h.

◆ FT_FRAME_OP_LITTLE

#define FT_FRAME_OP_LITTLE   2

Definition at line 42 of file ftstream.h.

◆ FT_FRAME_OP_LONG

#define FT_FRAME_OP_LONG   4 /* read 4-byte value */

Definition at line 52 of file ftstream.h.

◆ FT_FRAME_OP_OFF3

#define FT_FRAME_OP_OFF3   5 /* read 3-byte value */

Definition at line 53 of file ftstream.h.

◆ FT_FRAME_OP_SHIFT

#define FT_FRAME_OP_SHIFT   2

Definition at line 40 of file ftstream.h.

◆ FT_FRAME_OP_SHORT

#define FT_FRAME_OP_SHORT   3 /* read 2-byte value */

Definition at line 51 of file ftstream.h.

◆ FT_FRAME_OP_SIGNED

#define FT_FRAME_OP_SIGNED   1

Definition at line 41 of file ftstream.h.

◆ FT_FRAME_OP_START

#define FT_FRAME_OP_START   1 /* start a new frame */

Definition at line 49 of file ftstream.h.

◆ FT_FRAME_RELEASE

#define FT_FRAME_RELEASE (   bytes)
Value:
FT_DEBUG_INNER( FT_Stream_ReleaseFrame( stream, \
(FT_Byte**)&(bytes) ) )
FT_Stream_ReleaseFrame
FT_Stream_ReleaseFrame(FT_Stream stream, FT_Byte **pbytes)
Definition: ftstream.c:214

Definition at line 562 of file ftstream.h.

◆ FT_FRAME_SHORT

#define FT_FRAME_SHORT (   f)    FT_FRAME_FIELD( ft_frame_short_be, f )

Definition at line 122 of file ftstream.h.

◆ FT_FRAME_SHORT_LE

#define FT_FRAME_SHORT_LE (   f)    FT_FRAME_FIELD( ft_frame_short_le, f )

Definition at line 131 of file ftstream.h.

◆ FT_FRAME_SKIP_BYTE

#define FT_FRAME_SKIP_BYTE   { ft_frame_byte, 0, 0 }

Definition at line 138 of file ftstream.h.

◆ FT_FRAME_SKIP_BYTES

#define FT_FRAME_SKIP_BYTES (   count)    { ft_frame_skip, count, 0 }

Definition at line 147 of file ftstream.h.

◆ FT_FRAME_SKIP_LONG

#define FT_FRAME_SKIP_LONG   { ft_frame_long_be, 0, 0 }

Definition at line 136 of file ftstream.h.

◆ FT_FRAME_SKIP_SHORT

#define FT_FRAME_SKIP_SHORT   { ft_frame_short_be, 0, 0 }

Definition at line 137 of file ftstream.h.

◆ FT_FRAME_START

#define FT_FRAME_START (   size)    { ft_frame_start, 0, size }

Definition at line 117 of file ftstream.h.

◆ FT_FRAME_ULONG

#define FT_FRAME_ULONG (   f)    FT_FRAME_FIELD( ft_frame_ulong_be, f )

Definition at line 121 of file ftstream.h.

◆ FT_FRAME_ULONG_LE

#define FT_FRAME_ULONG_LE (   f)    FT_FRAME_FIELD( ft_frame_ulong_le, f )

Definition at line 130 of file ftstream.h.

◆ FT_FRAME_UOFF3

#define FT_FRAME_UOFF3 (   f)    FT_FRAME_FIELD( ft_frame_uoff3_be, f )

Definition at line 125 of file ftstream.h.

◆ FT_FRAME_UOFF3_LE

#define FT_FRAME_UOFF3_LE (   f)    FT_FRAME_FIELD( ft_frame_uoff3_le, f )

Definition at line 134 of file ftstream.h.

◆ FT_FRAME_USHORT

#define FT_FRAME_USHORT (   f)    FT_FRAME_FIELD( ft_frame_ushort_be, f )

Definition at line 123 of file ftstream.h.

◆ FT_FRAME_USHORT_LE

#define FT_FRAME_USHORT_LE (   f)    FT_FRAME_FIELD( ft_frame_ushort_le, f )

Definition at line 132 of file ftstream.h.

◆ FT_GET_BYTE

#define FT_GET_BYTE ( )    FT_GET_MACRO( FT_Stream_GetChar, FT_Byte )

Definition at line 309 of file ftstream.h.

◆ FT_GET_CHAR

#define FT_GET_CHAR ( )    FT_GET_MACRO( FT_Stream_GetChar, FT_Char )

Definition at line 308 of file ftstream.h.

◆ FT_GET_LONG

#define FT_GET_LONG ( )    FT_GET_MACRO( FT_Stream_GetULong, FT_Long )

Definition at line 314 of file ftstream.h.

◆ FT_GET_LONG_LE

#define FT_GET_LONG_LE ( )    FT_GET_MACRO( FT_Stream_GetULongLE, FT_Long )

Definition at line 320 of file ftstream.h.

◆ FT_GET_MACRO

#define FT_GET_MACRO (   func,
  type 
)    ( (type)func( stream ) )

Definition at line 306 of file ftstream.h.

◆ FT_GET_OFF3

#define FT_GET_OFF3 ( )    FT_GET_MACRO( FT_Stream_GetUOffset, FT_Long )

Definition at line 312 of file ftstream.h.

◆ FT_GET_SHORT

#define FT_GET_SHORT ( )    FT_GET_MACRO( FT_Stream_GetUShort, FT_Short )

Definition at line 310 of file ftstream.h.

◆ FT_GET_SHORT_LE

#define FT_GET_SHORT_LE ( )    FT_GET_MACRO( FT_Stream_GetUShortLE, FT_Short )

Definition at line 318 of file ftstream.h.

◆ FT_GET_TAG4

#define FT_GET_TAG4 ( )    FT_GET_MACRO( FT_Stream_GetULong, FT_ULong )

Definition at line 316 of file ftstream.h.

◆ FT_GET_ULONG

#define FT_GET_ULONG ( )    FT_GET_MACRO( FT_Stream_GetULong, FT_ULong )

Definition at line 315 of file ftstream.h.

◆ FT_GET_ULONG_LE

#define FT_GET_ULONG_LE ( )    FT_GET_MACRO( FT_Stream_GetULongLE, FT_ULong )

Definition at line 321 of file ftstream.h.

◆ FT_GET_UOFF3

#define FT_GET_UOFF3 ( )    FT_GET_MACRO( FT_Stream_GetUOffset, FT_ULong )

Definition at line 313 of file ftstream.h.

◆ FT_GET_USHORT

#define FT_GET_USHORT ( )    FT_GET_MACRO( FT_Stream_GetUShort, FT_UShort )

Definition at line 311 of file ftstream.h.

◆ FT_GET_USHORT_LE

#define FT_GET_USHORT_LE ( )    FT_GET_MACRO( FT_Stream_GetUShortLE, FT_UShort )

Definition at line 319 of file ftstream.h.

◆ FT_INT16

#define FT_INT16 (   x)    ( (FT_Int16)(x) )

Definition at line 158 of file ftstream.h.

◆ FT_INT32

#define FT_INT32 (   x)    ( (FT_Int32)(x) )

Definition at line 160 of file ftstream.h.

◆ FT_MAKE_EMPTY_FIELD

#define FT_MAKE_EMPTY_FIELD (   frame_op)    { frame_op, 0, 0 }

Definition at line 115 of file ftstream.h.

◆ FT_MAKE_FRAME_OP

#define FT_MAKE_FRAME_OP (   command,
  little,
  sign 
)     ( ( command << FT_FRAME_OP_SHIFT ) | ( little << 1 ) | sign )

Definition at line 45 of file ftstream.h.

◆ FT_NEXT_BYTE

#define FT_NEXT_BYTE (   buffer)     ( (unsigned char)*buffer++ )

Definition at line 238 of file ftstream.h.

◆ FT_NEXT_CHAR

#define FT_NEXT_CHAR (   buffer)     ( (signed char)*buffer++ )

Definition at line 235 of file ftstream.h.

◆ FT_NEXT_LONG

#define FT_NEXT_LONG (   buffer)     ( (long)( buffer += 4, FT_PEEK_LONG( buffer - 4 ) ) )

Definition at line 253 of file ftstream.h.

◆ FT_NEXT_LONG_LE

#define FT_NEXT_LONG_LE (   buffer)     ( (long)( buffer += 4, FT_PEEK_LONG_LE( buffer - 4 ) ) )

Definition at line 272 of file ftstream.h.

◆ FT_NEXT_OFF3

#define FT_NEXT_OFF3 (   buffer)     ( (long)( buffer += 3, FT_PEEK_OFF3( buffer - 3 ) ) )

Definition at line 247 of file ftstream.h.

◆ FT_NEXT_OFF3_LE

#define FT_NEXT_OFF3_LE (   buffer)     ( (long)( buffer += 3, FT_PEEK_OFF3_LE( buffer - 3 ) ) )

Definition at line 266 of file ftstream.h.

◆ FT_NEXT_SHORT

#define FT_NEXT_SHORT (   buffer)     ( (short)( buffer += 2, FT_PEEK_SHORT( buffer - 2 ) ) )

Definition at line 241 of file ftstream.h.

◆ FT_NEXT_SHORT_LE

#define FT_NEXT_SHORT_LE (   buffer)     ( (short)( buffer += 2, FT_PEEK_SHORT_LE( buffer - 2 ) ) )

Definition at line 260 of file ftstream.h.

◆ FT_NEXT_ULONG

#define FT_NEXT_ULONG (   buffer)     ( (unsigned long)( buffer += 4, FT_PEEK_ULONG( buffer - 4 ) ) )

Definition at line 256 of file ftstream.h.

◆ FT_NEXT_ULONG_LE

#define FT_NEXT_ULONG_LE (   buffer)     ( (unsigned long)( buffer += 4, FT_PEEK_ULONG_LE( buffer - 4 ) ) )

Definition at line 275 of file ftstream.h.

◆ FT_NEXT_UOFF3

#define FT_NEXT_UOFF3 (   buffer)     ( (unsigned long)( buffer += 3, FT_PEEK_UOFF3( buffer - 3 ) ) )

Definition at line 250 of file ftstream.h.

◆ FT_NEXT_UOFF3_LE

#define FT_NEXT_UOFF3_LE (   buffer)     ( (unsigned long)( buffer += 3, FT_PEEK_UOFF3_LE( buffer - 3 ) ) )

Definition at line 269 of file ftstream.h.

◆ FT_NEXT_USHORT

#define FT_NEXT_USHORT (   buffer)     ( (unsigned short)( buffer += 2, FT_PEEK_USHORT( buffer - 2 ) ) )

Definition at line 244 of file ftstream.h.

◆ FT_NEXT_USHORT_LE

#define FT_NEXT_USHORT_LE (   buffer)     ( (unsigned short)( buffer += 2, FT_PEEK_USHORT_LE( buffer - 2 ) ) )

Definition at line 263 of file ftstream.h.

◆ FT_PEEK_LONG

#define FT_PEEK_LONG (   p)
Value:
FT_INT32( FT_BYTE_U32( p, 0, 24 ) | \
FT_BYTE_U32( p, 1, 16 ) | \
FT_BYTE_U32( p, 2, 8 ) | \
FT_BYTE_U32( p, 3, 0 ) )
FT_INT32
#define FT_INT32(x)
Definition: ftstream.h:160
FT_BYTE_U32
#define FT_BYTE_U32(p, i, s)
Definition: ftstream.h:165
p
GLfloat GLfloat p
Definition: glext.h:8902

Definition at line 189 of file ftstream.h.

◆ FT_PEEK_LONG_LE

#define FT_PEEK_LONG_LE (   p)
Value:
FT_INT32( FT_BYTE_U32( p, 3, 24 ) | \
FT_BYTE_U32( p, 2, 16 ) | \
FT_BYTE_U32( p, 1, 8 ) | \
FT_BYTE_U32( p, 0, 0 ) )

Definition at line 213 of file ftstream.h.

◆ FT_PEEK_OFF3

#define FT_PEEK_OFF3 (   p)
Value:
FT_INT32( FT_BYTE_U32( p, 0, 16 ) | \
FT_BYTE_U32( p, 1, 8 ) | \
FT_BYTE_U32( p, 2, 0 ) )

Definition at line 199 of file ftstream.h.

◆ FT_PEEK_OFF3_LE

#define FT_PEEK_OFF3_LE (   p)
Value:
FT_INT32( FT_BYTE_U32( p, 2, 16 ) | \
FT_BYTE_U32( p, 1, 8 ) | \
FT_BYTE_U32( p, 0, 0 ) )

Definition at line 223 of file ftstream.h.

◆ FT_PEEK_SHORT

#define FT_PEEK_SHORT (   p)
Value:
FT_INT16( FT_BYTE_U16( p, 0, 8 ) | \
FT_BYTE_U16( p, 1, 0 ) )
FT_INT16
#define FT_INT16(x)
Definition: ftstream.h:158
FT_BYTE_U16
#define FT_BYTE_U16(p, i, s)
Definition: ftstream.h:164

Definition at line 183 of file ftstream.h.

◆ FT_PEEK_SHORT_LE

#define FT_PEEK_SHORT_LE (   p)
Value:
FT_INT16( FT_BYTE_U16( p, 1, 8 ) | \
FT_BYTE_U16( p, 0, 0 ) )

Definition at line 207 of file ftstream.h.

◆ FT_PEEK_ULONG

#define FT_PEEK_ULONG (   p)
Value:
FT_UINT32( FT_BYTE_U32( p, 0, 24 ) | \
FT_BYTE_U32( p, 1, 16 ) | \
FT_BYTE_U32( p, 2, 8 ) | \
FT_BYTE_U32( p, 3, 0 ) )
FT_UINT32
#define FT_UINT32(x)
Definition: ftstream.h:161

Definition at line 194 of file ftstream.h.

◆ FT_PEEK_ULONG_LE

#define FT_PEEK_ULONG_LE (   p)
Value:
FT_UINT32( FT_BYTE_U32( p, 3, 24 ) | \
FT_BYTE_U32( p, 2, 16 ) | \
FT_BYTE_U32( p, 1, 8 ) | \
FT_BYTE_U32( p, 0, 0 ) )

Definition at line 218 of file ftstream.h.

◆ FT_PEEK_UOFF3

#define FT_PEEK_UOFF3 (   p)
Value:
FT_UINT32( FT_BYTE_U32( p, 0, 16 ) | \
FT_BYTE_U32( p, 1, 8 ) | \
FT_BYTE_U32( p, 2, 0 ) )

Definition at line 203 of file ftstream.h.

◆ FT_PEEK_UOFF3_LE

#define FT_PEEK_UOFF3_LE (   p)
Value:
FT_UINT32( FT_BYTE_U32( p, 2, 16 ) | \
FT_BYTE_U32( p, 1, 8 ) | \
FT_BYTE_U32( p, 0, 0 ) )

Definition at line 227 of file ftstream.h.

◆ FT_PEEK_USHORT

#define FT_PEEK_USHORT (   p)
Value:
FT_UINT16( FT_BYTE_U16( p, 0, 8 ) | \
FT_BYTE_U16( p, 1, 0 ) )
FT_UINT16
#define FT_UINT16(x)
Definition: ftstream.h:159

Definition at line 186 of file ftstream.h.

◆ FT_PEEK_USHORT_LE

#define FT_PEEK_USHORT_LE (   p)
Value:
FT_UINT16( FT_BYTE_U16( p, 1, 8 ) | \
FT_BYTE_U16( p, 0, 0 ) )

Definition at line 210 of file ftstream.h.

◆ FT_READ_BYTE

#define FT_READ_BYTE (   var)    FT_READ_MACRO( FT_Stream_ReadChar, FT_Byte, var )

Definition at line 336 of file ftstream.h.

◆ FT_READ_CHAR

#define FT_READ_CHAR (   var)    FT_READ_MACRO( FT_Stream_ReadChar, FT_Char, var )

Definition at line 337 of file ftstream.h.

◆ FT_READ_LONG

#define FT_READ_LONG (   var)    FT_READ_MACRO( FT_Stream_ReadULong, FT_Long, var )

Definition at line 342 of file ftstream.h.

◆ FT_READ_LONG_LE

#define FT_READ_LONG_LE (   var)    FT_READ_MACRO( FT_Stream_ReadULongLE, FT_Long, var )

Definition at line 347 of file ftstream.h.

◆ FT_READ_MACRO

#define FT_READ_MACRO (   func,
  type,
  var 
)
Value:
( var = (type)func( stream, &error ), \
error != FT_Err_Ok )
FT_Err_Ok
return FT_Err_Ok
Definition: ftbbox.c:526
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
func
GLenum func
Definition: glext.h:6028
error
#define error(str)
Definition: mkdosfs.c:1605
var
const char * var
Definition: shader.c:5666

Definition at line 325 of file ftstream.h.

◆ FT_READ_OFF3

#define FT_READ_OFF3 (   var)    FT_READ_MACRO( FT_Stream_ReadUOffset, FT_Long, var )

Definition at line 340 of file ftstream.h.

◆ FT_READ_SHORT

#define FT_READ_SHORT (   var)    FT_READ_MACRO( FT_Stream_ReadUShort, FT_Short, var )

Definition at line 338 of file ftstream.h.

◆ FT_READ_SHORT_LE

#define FT_READ_SHORT_LE (   var)    FT_READ_MACRO( FT_Stream_ReadUShortLE, FT_Short, var )

Definition at line 345 of file ftstream.h.

◆ FT_READ_ULONG

#define FT_READ_ULONG (   var)    FT_READ_MACRO( FT_Stream_ReadULong, FT_ULong, var )

Definition at line 343 of file ftstream.h.

◆ FT_READ_ULONG_LE

#define FT_READ_ULONG_LE (   var)    FT_READ_MACRO( FT_Stream_ReadULongLE, FT_ULong, var )

Definition at line 348 of file ftstream.h.

◆ FT_READ_UOFF3

#define FT_READ_UOFF3 (   var)    FT_READ_MACRO( FT_Stream_ReadUOffset, FT_ULong, var )

Definition at line 341 of file ftstream.h.

◆ FT_READ_USHORT

#define FT_READ_USHORT (   var)    FT_READ_MACRO( FT_Stream_ReadUShort, FT_UShort, var )

Definition at line 339 of file ftstream.h.

◆ FT_READ_USHORT_LE

#define FT_READ_USHORT_LE (   var)    FT_READ_MACRO( FT_Stream_ReadUShortLE, FT_UShort, var )

Definition at line 346 of file ftstream.h.

◆ FT_STREAM_POS

#define FT_STREAM_POS ( )     FT_Stream_Pos( stream )

Definition at line 522 of file ftstream.h.

◆ FT_STREAM_READ

#define FT_STREAM_READ (   buffer,
  count 
)
Value:
FT_SET_ERROR( FT_Stream_Read( stream, \
(FT_Byte*)(buffer), \
(FT_ULong)(count) ) )
FT_Stream_Read
FT_Stream_Read(FT_Stream stream, FT_Byte *buffer, FT_ULong count)
Definition: ftstream.c:109
buffer
GLuint buffer
Definition: glext.h:5915

Definition at line 533 of file ftstream.h.

◆ FT_STREAM_READ_AT

#define FT_STREAM_READ_AT (   position,
  buffer,
  count 
)
Value:
FT_SET_ERROR( FT_Stream_ReadAt( stream, \
(FT_ULong)(position), \
(FT_Byte*)(buffer), \
(FT_ULong)(count) ) )
FT_Stream_ReadAt
FT_Stream_ReadAt(FT_Stream stream, FT_ULong pos, FT_Byte *buffer, FT_ULong count)
Definition: ftstream.c:118

Definition at line 538 of file ftstream.h.

◆ FT_STREAM_READ_FIELDS

#define FT_STREAM_READ_FIELDS (   fields,
  object 
)     FT_SET_ERROR( FT_Stream_ReadFields( stream, fields, object ) )

Definition at line 544 of file ftstream.h.

◆ FT_STREAM_SEEK

#define FT_STREAM_SEEK (   position)
Value:
FT_SET_ERROR( FT_Stream_Seek( stream, \
(FT_ULong)(position) ) )
FT_Stream_Seek
FT_Stream_Seek(FT_Stream stream, FT_ULong pos)
Definition: ftstream.c:56

Definition at line 525 of file ftstream.h.

◆ FT_STREAM_SKIP

#define FT_STREAM_SKIP (   distance)
Value:
FT_SET_ERROR( FT_Stream_Skip( stream, \
(FT_Long)(distance) ) )
FT_Stream_Skip
FT_Stream_Skip(FT_Stream stream, FT_Long distance)
Definition: ftstream.c:91
FT_Long
signed long FT_Long
Definition: fttypes.h:242
distance
GLsizei GLsizei GLfloat distance
Definition: glext.h:11755

Definition at line 529 of file ftstream.h.

◆ FT_UINT16

#define FT_UINT16 (   x)    ( (FT_UInt16)(x) )

Definition at line 159 of file ftstream.h.

◆ FT_UINT32

#define FT_UINT32 (   x)    ( (FT_UInt32)(x) )

Definition at line 161 of file ftstream.h.

Typedef Documentation

◆ FT_Frame_Field

typedef struct FT_Frame_Field_ FT_Frame_Field

◆ FT_Frame_Op

typedef enum FT_Frame_Op_ FT_Frame_Op

Enumeration Type Documentation

◆ FT_Frame_Op_

enum FT_Frame_Op_
Enumerator
ft_frame_end 
ft_frame_start 
ft_frame_byte 
ft_frame_schar 
ft_frame_ushort_be 
ft_frame_short_be 
ft_frame_ushort_le 
ft_frame_short_le 
ft_frame_ulong_be 
ft_frame_long_be 
ft_frame_ulong_le 
ft_frame_long_le 
ft_frame_uoff3_be 
ft_frame_off3_be 
ft_frame_uoff3_le 
ft_frame_off3_le 
ft_frame_bytes 
ft_frame_skip 

Definition at line 57 of file ftstream.h.

58 {
59 ft_frame_end = 0,
60 ft_frame_start = FT_MAKE_FRAME_OP( FT_FRAME_OP_START, 0, 0 ),
61
62 ft_frame_byte = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE, 0, 0 ),
63 ft_frame_schar = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE, 0, 1 ),
64
65 ft_frame_ushort_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 0 ),
66 ft_frame_short_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 1 ),
67 ft_frame_ushort_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 0 ),
68 ft_frame_short_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 1 ),
69
70 ft_frame_ulong_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 0 ),
71 ft_frame_long_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 1 ),
72 ft_frame_ulong_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 0 ),
73 ft_frame_long_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 1 ),
74
75 ft_frame_uoff3_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 0 ),
76 ft_frame_off3_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 1 ),
77 ft_frame_uoff3_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 0 ),
78 ft_frame_off3_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 1 ),
79
80 ft_frame_bytes = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTES, 0, 0 ),
81 ft_frame_skip = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTES, 0, 1 )
82
83 } FT_Frame_Op;
FT_FRAME_OP_SHORT
#define FT_FRAME_OP_SHORT
Definition: ftstream.h:51
ft_frame_uoff3_be
@ ft_frame_uoff3_be
Definition: ftstream.h:75
ft_frame_byte
@ ft_frame_byte
Definition: ftstream.h:62
ft_frame_short_le
@ ft_frame_short_le
Definition: ftstream.h:68
ft_frame_off3_be
@ ft_frame_off3_be
Definition: ftstream.h:76
ft_frame_long_le
@ ft_frame_long_le
Definition: ftstream.h:73
ft_frame_ulong_le
@ ft_frame_ulong_le
Definition: ftstream.h:72
ft_frame_ulong_be
@ ft_frame_ulong_be
Definition: ftstream.h:70
ft_frame_skip
@ ft_frame_skip
Definition: ftstream.h:81
ft_frame_short_be
@ ft_frame_short_be
Definition: ftstream.h:66
ft_frame_end
@ ft_frame_end
Definition: ftstream.h:59
ft_frame_uoff3_le
@ ft_frame_uoff3_le
Definition: ftstream.h:77
ft_frame_ushort_be
@ ft_frame_ushort_be
Definition: ftstream.h:65
ft_frame_start
@ ft_frame_start
Definition: ftstream.h:60
ft_frame_off3_le
@ ft_frame_off3_le
Definition: ftstream.h:78
ft_frame_ushort_le
@ ft_frame_ushort_le
Definition: ftstream.h:67
ft_frame_long_be
@ ft_frame_long_be
Definition: ftstream.h:71
ft_frame_schar
@ ft_frame_schar
Definition: ftstream.h:63
FT_FRAME_OP_BYTE
#define FT_FRAME_OP_BYTE
Definition: ftstream.h:50
FT_MAKE_FRAME_OP
#define FT_MAKE_FRAME_OP(command, little, sign)
Definition: ftstream.h:45
FT_FRAME_OP_LONG
#define FT_FRAME_OP_LONG
Definition: ftstream.h:52
FT_Frame_Op
enum FT_Frame_Op_ FT_Frame_Op
FT_FRAME_OP_START
#define FT_FRAME_OP_START
Definition: ftstream.h:49
FT_FRAME_OP_OFF3
#define FT_FRAME_OP_OFF3
Definition: ftstream.h:53
FT_FRAME_OP_BYTES
#define FT_FRAME_OP_BYTES
Definition: ftstream.h:54

Function Documentation

◆ FT_Stream_Close()

FT_Stream_Close ( FT_Stream  stream)

Definition at line 48 of file ftstream.c.

49 {
50 if ( stream && stream->close )
51 stream->close( stream );
52 }

Referenced by FT_Stream_Free(), PCF_Face_Done(), reconstruct_font(), woff2_open_font(), and woff_open_font().

◆ FT_Stream_EnterFrame()

FT_Stream_EnterFrame ( FT_Stream  stream,
FT_ULong  count 
)

Definition at line 234 of file ftstream.c.

236 {
237 FT_Error error = FT_Err_Ok;
238 FT_ULong read_bytes;
239
240
241 FT_TRACE7(( "FT_Stream_EnterFrame: %ld bytes\n", count ));
242
243 /* check for nested frame access */
244 FT_ASSERT( stream && stream->cursor == 0 );
245
246 if ( stream->read )
247 {
248 /* allocate the frame in memory */
249 FT_Memory memory = stream->memory;
250
251
252 /* simple sanity check */
253 if ( count > stream->size )
254 {
255 FT_ERROR(( "FT_Stream_EnterFrame:"
256 " frame size (%lu) larger than stream size (%lu)\n",
257 count, stream->size ));
258
259 error = FT_THROW( Invalid_Stream_Operation );
260 goto Exit;
261 }
262
263#ifdef FT_DEBUG_MEMORY
264 /* assume _ft_debug_file and _ft_debug_lineno are already set */
265 stream->base = (unsigned char*)ft_mem_qalloc( memory,
266 (FT_Long)count,
267 &error );
268 if ( error )
269 goto Exit;
270#else
271 if ( FT_QALLOC( stream->base, count ) )
272 goto Exit;
273#endif
274 /* read it */
275 read_bytes = stream->read( stream, stream->pos,
276 stream->base, count );
277 if ( read_bytes < count )
278 {
279 FT_ERROR(( "FT_Stream_EnterFrame:"
280 " invalid read; expected %lu bytes, got %lu\n",
281 count, read_bytes ));
282
283 FT_FREE( stream->base );
284 error = FT_THROW( Invalid_Stream_Operation );
285 }
286
287 stream->cursor = stream->base;
288 stream->limit = FT_OFFSET( stream->cursor, count );
289 stream->pos += read_bytes;
290 }
291 else
292 {
293 /* check current and new position */
294 if ( stream->pos >= stream->size ||
295 stream->size - stream->pos < count )
296 {
297 FT_ERROR(( "FT_Stream_EnterFrame:"
298 " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
299 stream->pos, count, stream->size ));
300
301 error = FT_THROW( Invalid_Stream_Operation );
302 goto Exit;
303 }
304
305 /* set cursor */
306 stream->cursor = stream->base + stream->pos;
307 stream->limit = stream->cursor + count;
308 stream->pos += count;
309 }
310
311 Exit:
312 return error;
313 }
FT_ASSERT
#define FT_ASSERT(condition)
Definition: ftdebug.h:241
FT_ERROR
#define FT_ERROR(varformat)
Definition: ftdebug.h:211
FT_TRACE7
#define FT_TRACE7(varformat)
Definition: ftdebug.h:194
FT_THROW
#define FT_THROW(e)
Definition: ftdebug.h:243
ft_mem_qalloc
ft_mem_qalloc(FT_Memory memory, FT_Long size, FT_Error *p_error)
Definition: ftutil.c:65
FT_FREE
#define FT_FREE(ptr)
Definition: ftmemory.h:337
FT_OFFSET
#define FT_OFFSET(base, count)
Definition: ftmemory.h:66
FT_QALLOC
#define FT_QALLOC(ptr, size)
Definition: ftmemory.h:324
FT_Memory
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:64
FT_Error
int FT_Error
Definition: fttypes.h:299
memory
static char memory[1024 *256]
Definition: process.c:122
read_bytes
static BOOL read_bytes(parse_buffer *buf, LPVOID data, DWORD size)
Definition: parsing.c:168
Exit
static void Exit(void)
Definition: sock.c:1330
stream::pos
ULARGE_INTEGER pos
Definition: request.c:4380
stream::size
unsigned int size
Definition: parse.h:27

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

◆ FT_Stream_ExitFrame()

FT_Stream_ExitFrame ( FT_Stream  stream)

Definition at line 317 of file ftstream.c.

318 {
319 /* IMPORTANT: The assertion stream->cursor != 0 was removed, given */
320 /* that it is possible to access a frame of length 0 in */
321 /* some weird fonts (usually, when accessing an array of */
322 /* 0 records, like in some strange kern tables). */
323 /* */
324 /* In this case, the loader code handles the 0-length table */
325 /* gracefully; however, stream.cursor is really set to 0 by the */
326 /* FT_Stream_EnterFrame() call, and this is not an error. */
327
328 FT_TRACE7(( "FT_Stream_ExitFrame\n" ));
329
330 FT_ASSERT( stream );
331
332 if ( stream->read )
333 {
334 FT_Memory memory = stream->memory;
335
336
337#ifdef FT_DEBUG_MEMORY
338 ft_mem_free( memory, stream->base );
339 stream->base = NULL;
340#else
341 FT_FREE( stream->base );
342#endif
343 }
344
345 stream->cursor = NULL;
346 stream->limit = NULL;
347 }
NULL
#define NULL
Definition: types.h:112
ft_mem_free
ft_mem_free(FT_Memory memory, const void *P)
Definition: ftutil.c:169

Referenced by 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 192 of file ftstream.c.

195 {
196 FT_Error error;
197
198
199 error = FT_Stream_EnterFrame( stream, count );
200 if ( !error )
201 {
202 *pbytes = (FT_Byte*)stream->cursor;
203
204 /* equivalent to FT_Stream_ExitFrame(), with no memory block release */
205 stream->cursor = NULL;
206 stream->limit = NULL;
207 }
208
209 return error;
210 }
FT_Stream_EnterFrame
FT_Stream_EnterFrame(FT_Stream stream, FT_ULong count)
Definition: ftstream.c:234

◆ FT_Stream_Free()

FT_Stream_Free ( FT_Stream  stream,
FT_Int  external 
)

Definition at line 257 of file ftobjs.c.

259 {
260 if ( stream )
261 {
262 FT_Memory memory = stream->memory;
263
264
265 FT_Stream_Close( stream );
266
267 if ( !external )
268 FT_FREE( stream );
269 }
270 }
FT_Stream_Close
FT_Stream_Close(FT_Stream stream)
Definition: ftstream.c:48

Referenced by destroy_face(), FT_Attach_Stream(), ft_open_face_internal(), woff2_open_font(), and woff_open_font().

◆ FT_Stream_GetChar()

FT_Stream_GetChar ( FT_Stream  stream)

Definition at line 351 of file ftstream.c.

352 {
353 FT_Char result;
354
355
356 FT_ASSERT( stream && stream->cursor );
357
358 result = 0;
359 if ( stream->cursor < stream->limit )
360 result = (FT_Char)*stream->cursor++;
361
362 return result;
363 }
FT_Char
signed char FT_Char
Definition: fttypes.h:143
result
GLuint64EXT * result
Definition: glext.h:11304

◆ FT_Stream_GetULong()

FT_Stream_GetULong ( FT_Stream  stream)

Definition at line 423 of file ftstream.c.

424 {
425 FT_Byte* p;
426 FT_ULong result;
427
428
429 FT_ASSERT( stream && stream->cursor );
430
431 result = 0;
432 p = stream->cursor;
433 if ( p + 3 < stream->limit )
434 result = FT_NEXT_ULONG( p );
435 stream->cursor = p;
436 return result;
437 }
FT_NEXT_ULONG
#define FT_NEXT_ULONG(buffer)
Definition: ftstream.h:256

◆ FT_Stream_GetULongLE()

FT_Stream_GetULongLE ( FT_Stream  stream)

Definition at line 441 of file ftstream.c.

442 {
443 FT_Byte* p;
444 FT_ULong result;
445
446
447 FT_ASSERT( stream && stream->cursor );
448
449 result = 0;
450 p = stream->cursor;
451 if ( p + 3 < stream->limit )
452 result = FT_NEXT_ULONG_LE( p );
453 stream->cursor = p;
454 return result;
455 }
FT_NEXT_ULONG_LE
#define FT_NEXT_ULONG_LE(buffer)
Definition: ftstream.h:275

◆ FT_Stream_GetUOffset()

FT_Stream_GetUOffset ( FT_Stream  stream)

Definition at line 405 of file ftstream.c.

406 {
407 FT_Byte* p;
408 FT_ULong result;
409
410
411 FT_ASSERT( stream && stream->cursor );
412
413 result = 0;
414 p = stream->cursor;
415 if ( p + 2 < stream->limit )
416 result = FT_NEXT_UOFF3( p );
417 stream->cursor = p;
418 return result;
419 }
FT_NEXT_UOFF3
#define FT_NEXT_UOFF3(buffer)
Definition: ftstream.h:250

◆ FT_Stream_GetUShort()

FT_Stream_GetUShort ( FT_Stream  stream)

Definition at line 367 of file ftstream.c.

368 {
369 FT_Byte* p;
370 FT_UShort result;
371
372
373 FT_ASSERT( stream && stream->cursor );
374
375 result = 0;
376 p = stream->cursor;
377 if ( p + 1 < stream->limit )
378 result = FT_NEXT_USHORT( p );
379 stream->cursor = p;
380
381 return result;
382 }
FT_NEXT_USHORT
#define FT_NEXT_USHORT(buffer)
Definition: ftstream.h:244
FT_UShort
unsigned short FT_UShort
Definition: fttypes.h:209

◆ FT_Stream_GetUShortLE()

FT_Stream_GetUShortLE ( FT_Stream  stream)

Definition at line 386 of file ftstream.c.

387 {
388 FT_Byte* p;
389 FT_UShort result;
390
391
392 FT_ASSERT( stream && stream->cursor );
393
394 result = 0;
395 p = stream->cursor;
396 if ( p + 1 < stream->limit )
397 result = FT_NEXT_USHORT_LE( p );
398 stream->cursor = p;
399
400 return result;
401 }
FT_NEXT_USHORT_LE
#define FT_NEXT_USHORT_LE(buffer)
Definition: ftstream.h:263

◆ FT_Stream_New()

FT_Stream_New ( FT_Library  library,
const FT_Open_Args *  args,
FT_Stream *  astream 
)

Definition at line 189 of file ftobjs.c.

192 {
193 FT_Error error;
194 FT_Memory memory;
195 FT_Stream stream = NULL;
196
197
198 *astream = NULL;
199
200 if ( !library )
201 return FT_THROW( Invalid_Library_Handle );
202
203 if ( !args )
204 return FT_THROW( Invalid_Argument );
205
206 memory = library->memory;
207
208 if ( FT_NEW( stream ) )
209 goto Exit;
210
211 stream->memory = memory;
212
213 if ( args->flags & FT_OPEN_MEMORY )
214 {
215 /* create a memory-based stream */
216 FT_Stream_OpenMemory( stream,
217 (const FT_Byte*)args->memory_base,
218 (FT_ULong)args->memory_size );
219 }
220
221#ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT
222
223 else if ( args->flags & FT_OPEN_PATHNAME )
224 {
225 /* create a normal system stream */
226 error = FT_Stream_Open( stream, args->pathname );
227 stream->pathname.pointer = args->pathname;
228 }
229 else if ( ( args->flags & FT_OPEN_STREAM ) && args->stream )
230 {
231 /* use an existing, user-provided stream */
232
233 /* in this case, we do not need to allocate a new stream object */
234 /* since the caller is responsible for closing it himself */
235 FT_FREE( stream );
236 stream = args->stream;
237 }
238
239#endif
240
241 else
242 error = FT_THROW( Invalid_Argument );
243
244 if ( error )
245 FT_FREE( stream );
246 else
247 stream->memory = memory; /* just to be certain */
248
249 *astream = stream;
250
251 Exit:
252 return error;
253 }
library
FT_Library library
Definition: cffdrivr.c:660
FT_OPEN_PATHNAME
#define FT_OPEN_PATHNAME
Definition: freetype.h:2005
FT_OPEN_MEMORY
#define FT_OPEN_MEMORY
Definition: freetype.h:2003
FT_OPEN_STREAM
#define FT_OPEN_STREAM
Definition: freetype.h:2004
FT_NEW
#define FT_NEW(ptr)
Definition: ftmemory.h:339
FT_Stream_Open
FT_Stream_Open(FT_Stream stream, const char *filepathname)
Definition: ftsystem.c:237
FT_Stream_OpenMemory
FT_Stream_OpenMemory(FT_Stream stream, const FT_Byte *base, FT_ULong size)
Definition: ftstream.c:34
FT_LibraryRec_::memory
FT_Memory memory
Definition: ftobjs.h:895
FT_StreamRec_
Definition: ftsystem.h:328
args
Definition: match.c:390

Referenced by FT_Attach_Stream(), and ft_open_face_internal().

◆ FT_Stream_Open()

FT_Stream_Open ( FT_Stream  stream,
const char *  filepathname 
)

Definition at line 237 of file ftsystem.c.

239 {
240 FT_FILE* file;
241
242
243 if ( !stream )
244 return FT_THROW( Invalid_Stream_Handle );
245
246 stream->descriptor.pointer = NULL;
247 stream->pathname.pointer = (char*)filepathname;
248 stream->base = NULL;
249 stream->pos = 0;
250 stream->read = NULL;
251 stream->close = NULL;
252
253 file = ft_fopen( filepathname, "rb" );
254 if ( !file )
255 {
256 FT_ERROR(( "FT_Stream_Open:"
257 " could not open `%s'\n", filepathname ));
258
259 return FT_THROW( Cannot_Open_Resource );
260 }
261
262 ft_fseek( file, 0, SEEK_END );
263 stream->size = (unsigned long)ft_ftell( file );
264 if ( !stream->size )
265 {
266 FT_ERROR(( "FT_Stream_Open:" ));
267 FT_ERROR(( " opened `%s' but zero-sized\n", filepathname ));
268 ft_fclose( file );
269 return FT_THROW( Cannot_Open_Stream );
270 }
271 ft_fseek( file, 0, SEEK_SET );
272
273 stream->descriptor.pointer = file;
274 stream->read = ft_ansi_stream_io;
275 stream->close = ft_ansi_stream_close;
276
277 FT_TRACE1(( "FT_Stream_Open:" ));
278 FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
279 filepathname, stream->size ));
280
281 return FT_Err_Ok;
282 }
SEEK_END
#define SEEK_END
Definition: cabinet.c:29
FT_TRACE1
#define FT_TRACE1(varformat)
Definition: ftdebug.h:188
FT_FILE
#define FT_FILE
Definition: ftstdlib.h:104
ft_fseek
#define ft_fseek
Definition: ftstdlib.h:108
ft_fclose
#define ft_fclose
Definition: ftstdlib.h:105
ft_ftell
#define ft_ftell
Definition: ftstdlib.h:109
ft_fopen
#define ft_fopen
Definition: ftstdlib.h:106
ft_ansi_stream_close
ft_ansi_stream_close(FT_Stream stream)
Definition: ftsystem.c:177
ft_ansi_stream_io
ft_ansi_stream_io(FT_Stream stream, unsigned long offset, unsigned char *buffer, unsigned long count)
Definition: ftsystem.c:214
SEEK_SET
#define SEEK_SET
Definition: jmemansi.c:26
long
#define long
Definition: qsort.c:33
file
Definition: fci.c:127

Referenced by FT_Stream_New().

◆ FT_Stream_OpenMemory()

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

Definition at line 34 of file ftstream.c.

37 {
38 stream->base = (FT_Byte*) base;
39 stream->size = size;
40 stream->pos = 0;
41 stream->cursor = NULL;
42 stream->read = NULL;
43 stream->close = NULL;
44 }

Referenced by cid_face_open(), FT_Stream_New(), load_truetype_glyph(), reconstruct_font(), woff2_open_font(), and woff_open_font().

◆ FT_Stream_Pos()

FT_Stream_Pos ( FT_Stream  stream)

Definition at line 102 of file ftstream.c.

103 {
104 return stream->pos;
105 }

◆ FT_Stream_Read()

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

Definition at line 109 of file ftstream.c.

112 {
113 return FT_Stream_ReadAt( stream, stream->pos, buffer, count );
114 }
FT_Stream_ReadAt
FT_Stream_ReadAt(FT_Stream stream, FT_ULong pos, FT_Byte *buffer, FT_ULong count)
Definition: ftstream.c:118

Referenced by FT_Raccess_Get_HeaderInfo(), 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 118 of file ftstream.c.

122 {
123 FT_Error error = FT_Err_Ok;
124 FT_ULong read_bytes;
125
126
127 if ( pos >= stream->size )
128 {
129 FT_ERROR(( "FT_Stream_ReadAt:"
130 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
131 pos, stream->size ));
132
133 return FT_THROW( Invalid_Stream_Operation );
134 }
135
136 if ( stream->read )
137 read_bytes = stream->read( stream, pos, buffer, count );
138 else
139 {
140 read_bytes = stream->size - pos;
141 if ( read_bytes > count )
142 read_bytes = count;
143
144 FT_MEM_COPY( buffer, stream->base + pos, read_bytes );
145 }
146
147 stream->pos = pos + read_bytes;
148
149 if ( read_bytes < count )
150 {
151 FT_ERROR(( "FT_Stream_ReadAt:"
152 " invalid read; expected %lu bytes, got %lu\n",
153 count, read_bytes ));
154
155 error = FT_THROW( Invalid_Stream_Operation );
156 }
157
158 return error;
159 }
FT_MEM_COPY
#define FT_MEM_COPY(dest, source, count)
Definition: ftmemory.h:237

Referenced by FT_Stream_Read().

◆ FT_Stream_ReadChar()

FT_Stream_ReadChar ( FT_Stream  stream,
FT_Error *  error 
)

Definition at line 459 of file ftstream.c.

461 {
462 FT_Byte result = 0;
463
464
465 FT_ASSERT( stream );
466
467 *error = FT_Err_Ok;
468
469 if ( stream->read )
470 {
471 if ( stream->read( stream, stream->pos, &result, 1L ) != 1L )
472 goto Fail;
473 }
474 else
475 {
476 if ( stream->pos < stream->size )
477 result = stream->base[stream->pos];
478 else
479 goto Fail;
480 }
481 stream->pos++;
482
483 return (FT_Char)result;
484
485 Fail:
486 *error = FT_THROW( Invalid_Stream_Operation );
487 FT_ERROR(( "FT_Stream_ReadChar:"
488 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
489 stream->pos, stream->size ));
490
491 return 0;
492 }
Fail
int Fail
Definition: ehthrow.cxx:24

◆ FT_Stream_ReadFields()

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

Definition at line 721 of file ftstream.c.

724 {
725 FT_Error error;
726 FT_Bool frame_accessed = 0;
727 FT_Byte* cursor;
728
729
730 if ( !fields )
731 return FT_THROW( Invalid_Argument );
732
733 if ( !stream )
734 return FT_THROW( Invalid_Stream_Handle );
735
736 cursor = stream->cursor;
737
738 error = FT_Err_Ok;
739 do
740 {
741 FT_ULong value;
742 FT_Int sign_shift;
743 FT_Byte* p;
744
745
746 switch ( fields->value )
747 {
748 case ft_frame_start: /* access a new frame */
749 error = FT_Stream_EnterFrame( stream, fields->offset );
750 if ( error )
751 goto Exit;
752
753 frame_accessed = 1;
754 cursor = stream->cursor;
755 fields++;
756 continue; /* loop! */
757
758 case ft_frame_bytes: /* read a byte sequence */
759 case ft_frame_skip: /* skip some bytes */
760 {
761 FT_UInt len = fields->size;
762
763
764 if ( cursor + len > stream->limit )
765 {
766 error = FT_THROW( Invalid_Stream_Operation );
767 goto Exit;
768 }
769
770 if ( fields->value == ft_frame_bytes )
771 {
772 p = (FT_Byte*)structure + fields->offset;
773 FT_MEM_COPY( p, cursor, len );
774 }
775 cursor += len;
776 fields++;
777 continue;
778 }
779
780 case ft_frame_byte:
781 case ft_frame_schar: /* read a single byte */
782 value = FT_NEXT_BYTE( cursor );
783 sign_shift = 24;
784 break;
785
786 case ft_frame_short_be:
787 case ft_frame_ushort_be: /* read a 2-byte big-endian short */
788 value = FT_NEXT_USHORT( cursor );
789 sign_shift = 16;
790 break;
791
792 case ft_frame_short_le:
793 case ft_frame_ushort_le: /* read a 2-byte little-endian short */
794 value = FT_NEXT_USHORT_LE( cursor );
795 sign_shift = 16;
796 break;
797
798 case ft_frame_long_be:
799 case ft_frame_ulong_be: /* read a 4-byte big-endian long */
800 value = FT_NEXT_ULONG( cursor );
801 sign_shift = 0;
802 break;
803
804 case ft_frame_long_le:
805 case ft_frame_ulong_le: /* read a 4-byte little-endian long */
806 value = FT_NEXT_ULONG_LE( cursor );
807 sign_shift = 0;
808 break;
809
810 case ft_frame_off3_be:
811 case ft_frame_uoff3_be: /* read a 3-byte big-endian long */
812 value = FT_NEXT_UOFF3( cursor );
813 sign_shift = 8;
814 break;
815
816 case ft_frame_off3_le:
817 case ft_frame_uoff3_le: /* read a 3-byte little-endian long */
818 value = FT_NEXT_UOFF3_LE( cursor );
819 sign_shift = 8;
820 break;
821
822 default:
823 /* otherwise, exit the loop */
824 stream->cursor = cursor;
825 goto Exit;
826 }
827
828 /* now, compute the signed value is necessary */
829 if ( fields->value & FT_FRAME_OP_SIGNED )
830 value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift );
831
832 /* finally, store the value in the object */
833
834 p = (FT_Byte*)structure + fields->offset;
835 switch ( fields->size )
836 {
837 case ( 8 / FT_CHAR_BIT ):
838 *(FT_Byte*)p = (FT_Byte)value;
839 break;
840
841 case ( 16 / FT_CHAR_BIT ):
842 *(FT_UShort*)p = (FT_UShort)value;
843 break;
844
845 case ( 32 / FT_CHAR_BIT ):
846 *(FT_UInt32*)p = (FT_UInt32)value;
847 break;
848
849 default: /* for 64-bit systems */
850 *(FT_ULong*)p = (FT_ULong)value;
851 }
852
853 /* go to next field */
854 fields++;
855 }
856 while ( 1 );
857
858 Exit:
859 /* close the frame if it was opened by this read */
860 if ( frame_accessed )
861 FT_Stream_ExitFrame( stream );
862
863 return error;
864 }
switch
switch(r->id)
Definition: btrfs.c:3046
FT_CHAR_BIT
#define FT_CHAR_BIT
Definition: ftstdlib.h:61
FT_Stream_ExitFrame
FT_Stream_ExitFrame(FT_Stream stream)
Definition: ftstream.c:317
FT_FRAME_OP_SIGNED
#define FT_FRAME_OP_SIGNED
Definition: ftstream.h:41
FT_NEXT_UOFF3_LE
#define FT_NEXT_UOFF3_LE(buffer)
Definition: ftstream.h:269
FT_NEXT_BYTE
#define FT_NEXT_BYTE(buffer)
Definition: ftstream.h:238
FT_Bool
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
FT_UInt
unsigned int FT_UInt
Definition: fttypes.h:231
FT_Int
signed int FT_Int
Definition: fttypes.h:220
len
GLenum GLsizei len
Definition: glext.h:6722
cursor
const char cursor[]
Definition: icontest.c:13
fields
const char * fields[10]
Definition: parser.c:313
value
Definition: pdh_main.c:96

◆ FT_Stream_ReadULong()

FT_Stream_ReadULong ( FT_Stream  stream,
FT_Error *  error 
)

Definition at line 631 of file ftstream.c.

633 {
634 FT_Byte reads[4];
635 FT_Byte* p = 0;
636 FT_ULong result = 0;
637
638
639 FT_ASSERT( stream );
640
641 *error = FT_Err_Ok;
642
643 if ( stream->pos + 3 < stream->size )
644 {
645 if ( stream->read )
646 {
647 if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
648 goto Fail;
649
650 p = reads;
651 }
652 else
653 p = stream->base + stream->pos;
654
655 if ( p )
656 result = FT_NEXT_ULONG( p );
657 }
658 else
659 goto Fail;
660
661 stream->pos += 4;
662
663 return result;
664
665 Fail:
666 *error = FT_THROW( Invalid_Stream_Operation );
667 FT_ERROR(( "FT_Stream_ReadULong:"
668 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
669 stream->pos, stream->size ));
670
671 return 0;
672 }

◆ FT_Stream_ReadULongLE()

FT_Stream_ReadULongLE ( FT_Stream  stream,
FT_Error *  error 
)

Definition at line 676 of file ftstream.c.

678 {
679 FT_Byte reads[4];
680 FT_Byte* p = 0;
681 FT_ULong result = 0;
682
683
684 FT_ASSERT( stream );
685
686 *error = FT_Err_Ok;
687
688 if ( stream->pos + 3 < stream->size )
689 {
690 if ( stream->read )
691 {
692 if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
693 goto Fail;
694
695 p = reads;
696 }
697 else
698 p = stream->base + stream->pos;
699
700 if ( p )
701 result = FT_NEXT_ULONG_LE( p );
702 }
703 else
704 goto Fail;
705
706 stream->pos += 4;
707
708 return result;
709
710 Fail:
711 *error = FT_THROW( Invalid_Stream_Operation );
712 FT_ERROR(( "FT_Stream_ReadULongLE:"
713 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
714 stream->pos, stream->size ));
715
716 return 0;
717 }

◆ FT_Stream_ReadUOffset()

FT_Stream_ReadUOffset ( FT_Stream  stream,
FT_Error *  error 
)

Definition at line 586 of file ftstream.c.

588 {
589 FT_Byte reads[3];
590 FT_Byte* p = 0;
591 FT_ULong result = 0;
592
593
594 FT_ASSERT( stream );
595
596 *error = FT_Err_Ok;
597
598 if ( stream->pos + 2 < stream->size )
599 {
600 if ( stream->read )
601 {
602 if (stream->read( stream, stream->pos, reads, 3L ) != 3L )
603 goto Fail;
604
605 p = reads;
606 }
607 else
608 p = stream->base + stream->pos;
609
610 if ( p )
611 result = FT_NEXT_UOFF3( p );
612 }
613 else
614 goto Fail;
615
616 stream->pos += 3;
617
618 return result;
619
620 Fail:
621 *error = FT_THROW( Invalid_Stream_Operation );
622 FT_ERROR(( "FT_Stream_ReadUOffset:"
623 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
624 stream->pos, stream->size ));
625
626 return 0;
627 }

◆ FT_Stream_ReadUShort()

FT_Stream_ReadUShort ( FT_Stream  stream,
FT_Error *  error 
)

Definition at line 496 of file ftstream.c.

498 {
499 FT_Byte reads[2];
500 FT_Byte* p = 0;
501 FT_UShort result = 0;
502
503
504 FT_ASSERT( stream );
505
506 *error = FT_Err_Ok;
507
508 if ( stream->pos + 1 < stream->size )
509 {
510 if ( stream->read )
511 {
512 if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
513 goto Fail;
514
515 p = reads;
516 }
517 else
518 p = stream->base + stream->pos;
519
520 if ( p )
521 result = FT_NEXT_USHORT( p );
522 }
523 else
524 goto Fail;
525
526 stream->pos += 2;
527
528 return result;
529
530 Fail:
531 *error = FT_THROW( Invalid_Stream_Operation );
532 FT_ERROR(( "FT_Stream_ReadUShort:"
533 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
534 stream->pos, stream->size ));
535
536 return 0;
537 }

◆ FT_Stream_ReadUShortLE()

FT_Stream_ReadUShortLE ( FT_Stream  stream,
FT_Error *  error 
)

Definition at line 541 of file ftstream.c.

543 {
544 FT_Byte reads[2];
545 FT_Byte* p = 0;
546 FT_UShort result = 0;
547
548
549 FT_ASSERT( stream );
550
551 *error = FT_Err_Ok;
552
553 if ( stream->pos + 1 < stream->size )
554 {
555 if ( stream->read )
556 {
557 if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
558 goto Fail;
559
560 p = reads;
561 }
562 else
563 p = stream->base + stream->pos;
564
565 if ( p )
566 result = FT_NEXT_USHORT_LE( p );
567 }
568 else
569 goto Fail;
570
571 stream->pos += 2;
572
573 return result;
574
575 Fail:
576 *error = FT_THROW( Invalid_Stream_Operation );
577 FT_ERROR(( "FT_Stream_ReadUShortLE:"
578 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
579 stream->pos, stream->size ));
580
581 return 0;
582 }

◆ FT_Stream_ReleaseFrame()

FT_Stream_ReleaseFrame ( FT_Stream  stream,
FT_Byte **  pbytes 
)

Definition at line 214 of file ftstream.c.

216 {
217 if ( stream && stream->read )
218 {
219 FT_Memory memory = stream->memory;
220
221
222#ifdef FT_DEBUG_MEMORY
223 ft_mem_free( memory, *pbytes );
224#else
225 FT_FREE( *pbytes );
226#endif
227 }
228
229 *pbytes = NULL;
230 }

◆ FT_Stream_Seek()

FT_Stream_Seek ( FT_Stream  stream,
FT_ULong  pos 
)

Definition at line 56 of file ftstream.c.

58 {
59 FT_Error error = FT_Err_Ok;
60
61
62 if ( stream->read )
63 {
64 if ( stream->read( stream, pos, 0, 0 ) )
65 {
66 FT_ERROR(( "FT_Stream_Seek:"
67 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
68 pos, stream->size ));
69
70 error = FT_THROW( Invalid_Stream_Operation );
71 }
72 }
73 /* note that seeking to the first position after the file is valid */
74 else if ( pos > stream->size )
75 {
76 FT_ERROR(( "FT_Stream_Seek:"
77 " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
78 pos, stream->size ));
79
80 error = FT_THROW( Invalid_Stream_Operation );
81 }
82
83 if ( !error )
84 stream->pos = pos;
85
86 return error;
87 }

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

◆ FT_Stream_Skip()

FT_Stream_Skip ( FT_Stream  stream,
FT_Long  distance 
)

Definition at line 91 of file ftstream.c.

93 {
94 if ( distance < 0 )
95 return FT_THROW( Invalid_Stream_Operation );
96
97 return FT_Stream_Seek( stream, stream->pos + (FT_ULong)distance );
98 }
FT_Stream_Seek
FT_Stream_Seek(FT_Stream stream, FT_ULong pos)
Definition: ftstream.c:56

◆ FT_Stream_TryRead()

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

Definition at line 163 of file ftstream.c.

166 {
167 FT_ULong read_bytes = 0;
168
169
170 if ( stream->pos >= stream->size )
171 goto Exit;
172
173 if ( stream->read )
174 read_bytes = stream->read( stream, stream->pos, buffer, count );
175 else
176 {
177 read_bytes = stream->size - stream->pos;
178 if ( read_bytes > count )
179 read_bytes = count;
180
181 FT_MEM_COPY( buffer, stream->base + stream->pos, read_bytes );
182 }
183
184 stream->pos += read_bytes;
185
186 Exit:
187 return read_bytes;
188 }

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