mirrors/freetype
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* renaming stream functions to the FT_Subject_Action scheme:

Browse Source 
FT_Seek_Stream         => FT_Stream_Seek
          FT_Skip_Stream         => FT_Stream_Skip
          FT_Read_Stream         => FT_Stream_Read
          FT_Read_Stream_At      => FT_Stream_Read_At
          FT_Access_Frame        => FT_Stream_Enter_Frame
          FT_Forget_Frame        => FT_Stream_Exit_Frame
          FT_Extract_Frame       => FT_Stream_Extract_Frame
          FT_Release_Frame       => FT_Stream_Release_Frame
          FT_Get_XXXX            => FT_Stream_Get_XXXX
          FT_Read_XXXX           => FT_Stream_Read_XXXX

          note also that:

          FT_New_Stream( filename, stream ) =>
            FT_Stream_Open( stream, filename )

          (the function doesn't create the FT_Stream structure, it simply
           initializes it for reading)

          FT_New_Memory_Stream( library, FT_Byte*  base, size, stream ) =>
            FT_Stream_Open_Memory( stream, const FT_Byte* base, size )

          FT_Done_Stream => FT_Stream_Close

          note that the name of the stream methods, defined in
          "include/freetype/ftsystem.h" have also been changed without
          problems:

            FT_Stream_IO    => FT_Stream_IOFunc
            FT_Stream_Close => FT_Stream_CloseFunc
This commit is contained in:
David Turner 2002-02-24 05:26:57 +00:00
parent 4d57024d1c
commit 53b3fa1da5
18 changed files with 383 additions and 1229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
ChangeLog
View File

@ -1,5 +1,43 @@
2002-02-24 David Turner <david@freetype.org>
* renaming stream functions to the FT_Subject_Action scheme:
FT_Seek_Stream => FT_Stream_Seek
FT_Skip_Stream => FT_Stream_Skip
FT_Read_Stream => FT_Stream_Read
FT_Read_Stream_At => FT_Stream_Read_At
FT_Access_Frame => FT_Stream_Enter_Frame
FT_Forget_Frame => FT_Stream_Exit_Frame
FT_Extract_Frame => FT_Stream_Extract_Frame
FT_Release_Frame => FT_Stream_Release_Frame
FT_Get_XXXX => FT_Stream_Get_XXXX
FT_Read_XXXX => FT_Stream_Read_XXXX
note also that:
FT_New_Stream( filename, stream ) =>
FT_Stream_Open( stream, filename )
(the function doesn't create the FT_Stream structure, it simply
initializes it for reading)
FT_New_Memory_Stream( library, FT_Byte* base, size, stream ) =>
FT_Stream_Open_Memory( stream, const FT_Byte* base, size )
FT_Done_Stream => FT_Stream_Close
note that the name of the stream methods, defined in
"include/freetype/ftsystem.h" have also been changed without
problems:
FT_Stream_IO => FT_Stream_IOFunc
FT_Stream_Close => FT_Stream_CloseFunc
* moving all memory and list management code to "src/base/ftutil.c"
(previously in "ftobjs.c" and "ftlist.c" respectively)
* moving all code related to glyph loaders to "internal/ftgloadr.h"
and "src/base/ftgloadr.c".

42
builds/amiga/src/base/ftsystem.c
View File

@ -307,22 +307,22 @@ void FreeVecPooled(APTR poolHeader, APTR memory)
/* documentation is in ftobjs.h */
FT_EXPORT_DEF( FT_Error )
FT_New_Stream( const char* filepathname,
FT_Stream astream )
FT_Stream_Open( FT_Stream stream,
const char* filepathname )
{
// FILE* file;
BPTR file; // TetiSoft
struct FileInfoBlock *fib; // TetiSoft
if ( !astream )
if ( !stream )
return FT_Err_Invalid_Stream_Handle;
// file = fopen( filepathname, "rb" );
file = Open( filepathname, MODE_OLDFILE ); // TetiSoft
if ( !file )
{
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
return FT_Err_Cannot_Open_Resource;
@ -335,7 +335,7 @@ void FreeVecPooled(APTR poolHeader, APTR memory)
if ( !fib )
{
Close ( file );
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
return FT_Err_Cannot_Open_Resource;
@ -344,26 +344,26 @@ void FreeVecPooled(APTR poolHeader, APTR memory)
{
FreeDosObject(DOS_FIB, fib);
Close ( file );
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
return FT_Err_Cannot_Open_Resource;
}
astream->size = fib->fib_Size;
stream->size = fib->fib_Size;
FreeDosObject(DOS_FIB, fib);
// astream->descriptor.pointer = file;
astream->descriptor.pointer = (void *)file;
// stream->descriptor.pointer = file;
stream->descriptor.pointer = (void *)file;
astream->pathname.pointer = (char*)filepathname;
astream->pos = 0;
stream->pathname.pointer = (char*)filepathname;
stream->pos = 0;
astream->read = ft_io_stream;
astream->close = ft_close_stream;
stream->read = ft_io_stream;
stream->close = ft_close_stream;
FT_TRACE1(( "FT_New_Stream:" ));
FT_TRACE1(( "FT_Stream_Open:" ));
FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
filepathname, astream->size ));
filepathname, stream->size ));
return FT_Err_Ok;
}
@ -374,12 +374,12 @@ void FreeVecPooled(APTR poolHeader, APTR memory)
extern FT_Int
ft_mem_debug_init( FT_Memory memory );
extern void
ft_mem_debug_done( FT_Memory memory );
#endif
#endif
/* documentation is in ftobjs.h */
@ -411,7 +411,7 @@ void FreeVecPooled(APTR poolHeader, APTR memory)
memory->free = ft_free;
#ifdef FT_DEBUG_MEMORY
ft_mem_debug_init( memory );
#endif
#endif
}
}
@ -426,7 +426,7 @@ void FreeVecPooled(APTR poolHeader, APTR memory)
{
#ifdef FT_DEBUG_MEMORY
ft_mem_debug_done( memory );
#endif
#endif
#ifdef __GNUC__
DeletePool( memory->user );

24
builds/unix/ftsystem.c
View File

@ -204,8 +204,8 @@
/* documentation is in ftobjs.h */
FT_EXPORT_DEF( FT_Error )
FT_New_Stream( const char* filepathname,
FT_Stream stream )
FT_Stream_Open( FT_Stream stream,
const char* filepathname )
{
int file;
struct stat stat_buf;
@ -218,7 +218,7 @@
file = open( filepathname, O_RDONLY );
if ( file < 0 )
{
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
return FT_Err_Cannot_Open_Resource;
}
@ -238,7 +238,7 @@
if ( fstat( file, &stat_buf ) < 0 )
{
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `fstat' file `%s'\n", filepathname ));
goto Fail_Map;
}
@ -254,7 +254,7 @@
if ( (long)stream->base == -1 )
{
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));
goto Fail_Map;
}
@ -267,7 +267,7 @@
stream->close = ft_close_stream;
stream->read = 0;
FT_TRACE1(( "FT_New_Stream:" ));
FT_TRACE1(( "FT_Stream_Open:" ));
FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
filepathname, stream->size ));
@ -288,12 +288,12 @@
extern FT_Int
ft_mem_debug_init( FT_Memory memory );
extern void
ft_mem_debug_done( FT_Memory memory );
#endif
#endif
/* documentation is in ftobjs.h */
@ -312,7 +312,7 @@
memory->free = ft_free;
#ifdef FT_DEBUG_MEMORY
ft_mem_debug_init( memory );
#endif
#endif
}
return memory;
@ -326,7 +326,7 @@
{
#ifdef FT_DEBUG_MEMORY
ft_mem_debug_done( memory );
#endif
#endif
memory->free( memory, memory );
}

24
builds/vms/ftsystem.c
View File

@ -204,8 +204,8 @@
/* documentation is in ftobjs.h */
FT_EXPORT_DEF( FT_Error )
FT_New_Stream( const char* filepathname,
FT_Stream stream )
FT_Stream_Open( FT_Stream stream,
const char* filepathname )
{
int file;
struct stat stat_buf;
@ -218,14 +218,14 @@
file = open( filepathname, O_RDONLY );
if ( file < 0 )
{
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
return FT_Err_Cannot_Open_Resource;
}
if ( fstat( file, &stat_buf ) < 0 )
{
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `fstat' file `%s'\n", filepathname ));
goto Fail_Map;
}
@ -241,7 +241,7 @@
if ( (long)stream->base == -1 )
{
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));
goto Fail_Map;
}
@ -254,7 +254,7 @@
stream->close = ft_close_stream;
stream->read = 0;
FT_TRACE1(( "FT_New_Stream:" ));
FT_TRACE1(( "FT_Stream_Open:" ));
FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
filepathname, stream->size ));
@ -275,12 +275,12 @@
extern FT_Int
ft_mem_debug_init( FT_Memory memory );
extern void
ft_mem_debug_done( FT_Memory memory );
#endif
#endif
/* documentation is in ftobjs.h */
@ -299,7 +299,7 @@
memory->free = ft_free;
#ifdef FT_DEBUG_MEMORY
ft_mem_debug_init( memory );
#endif
#endif
}
return memory;
@ -313,7 +313,7 @@
{
#ifdef FT_DEBUG_MEMORY
ft_mem_debug_done( memory );
#endif
#endif
memory->free( memory, memory );
}

34
include/freetype/ftsystem.h
View File

@ -197,7 +197,7 @@ FT_BEGIN_HEADER
/*************************************************************************/
/* */
/* @functype: */
/* FT_Stream_IO */
/* FT_Stream_IoFunc */
/* */
/* @description: */
/* A function used to seek and read data from a given input stream. */
@ -219,16 +219,16 @@ FT_BEGIN_HEADER
/* with a `count' of 0. */
/* */
typedef unsigned long
(*FT_Stream_IO)( FT_Stream stream,
unsigned long offset,
unsigned char* buffer,
unsigned long count );
(*FT_Stream_IoFunc)( FT_Stream stream,
unsigned long offset,
unsigned char* buffer,
unsigned long count );
/*************************************************************************/
/* */
/* @functype: */
/* FT_Stream_Close */
/* FT_Stream_CloseFunc */
/* */
/* @description: */
/* A function used to close a given input stream. */
@ -237,7 +237,7 @@ FT_BEGIN_HEADER
/* stream :: A handle to the target stream. */
/* */
typedef void
(*FT_Stream_Close)( FT_Stream stream );
(*FT_Stream_CloseFunc)( FT_Stream stream );
/*************************************************************************/
@ -281,18 +281,18 @@ FT_BEGIN_HEADER
/* */
struct FT_StreamRec_
{
unsigned char* base;
unsigned long size;
unsigned long pos;
unsigned char* base;
unsigned long size;
unsigned long pos;
FT_StreamDesc descriptor;
FT_StreamDesc pathname;
FT_Stream_IO read;
FT_Stream_Close close;
FT_StreamDesc descriptor;
FT_StreamDesc pathname;
FT_Stream_IoFunc read;
FT_Stream_CloseFunc close;
FT_Memory memory;
unsigned char* cursor;
unsigned char* limit;
FT_Memory memory;
unsigned char* cursor;
unsigned char* limit;
};

37
include/freetype/internal/ftobjs.h
View File

@ -635,43 +635,6 @@ FT_BEGIN_HEADER
#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
/*************************************************************************/
/* */
/* <Function> */
/* FT_New_Stream */
/* */
/* <Description> */
/* Creates a new stream object. */
/* */
/* <Input> */
/* filepathname :: The name of the stream (usually a file) to be */
/* opened. */
/* */
/* stream :: A pointer to the stream object. */
/* */
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT( FT_Error )
FT_New_Stream( const char* filepathname,
FT_Stream astream );
/*************************************************************************/
/* */
/* <Function> */
/* FT_Done_Stream */
/* */
/* <Description> */
/* Closes and destroys a stream object. */
/* */
/* <Input> */
/* stream :: The stream to be closed and destroyed. */
/* */
FT_EXPORT( void )
FT_Done_Stream( FT_Stream stream );
/*************************************************************************/
/* */
/* <Function> */

203
include/freetype/internal/ftstream.h
View File

@ -27,6 +27,15 @@
FT_BEGIN_HEADER
/* format of an 8-bit frame_op value = [ xxxxx | e | s ] */
/* s is set to 1 if the value is signed, */
/* e is set to 1 if the value is little-endian */
@ -258,174 +267,234 @@ FT_BEGIN_HEADER
#define GET_Char() FT_GET_MACRO( FT_Get_Char, FT_Char )
#define GET_Byte() FT_GET_MACRO( FT_Get_Char, FT_Byte )
#define GET_Short() FT_GET_MACRO( FT_Get_Short, FT_Short )
#define GET_UShort() FT_GET_MACRO( FT_Get_Short, FT_UShort )
#define GET_Offset() FT_GET_MACRO( FT_Get_Offset, FT_Long )
#define GET_UOffset() FT_GET_MACRO( FT_Get_Offset, FT_ULong )
#define GET_Long() FT_GET_MACRO( FT_Get_Long, FT_Long )
#define GET_ULong() FT_GET_MACRO( FT_Get_Long, FT_ULong )
#define GET_Tag4() FT_GET_MACRO( FT_Get_Long, FT_ULong )
#define GET_Short() FT_GET_MACRO( FT_Stream_Get_Short, FT_Short )
#define GET_UShort() FT_GET_MACRO( FT_Stream_Get_Short, FT_UShort )
#define GET_Offset() FT_GET_MACRO( FT_Stream_Get_Offset, FT_Long )
#define GET_UOffset() FT_GET_MACRO( FT_Stream_Get_Offset, FT_ULong )
#define GET_Long() FT_GET_MACRO( FT_Stream_Get_Long, FT_Long )
#define GET_ULong() FT_GET_MACRO( FT_Stream_Get_Long, FT_ULong )
#define GET_Tag4() FT_GET_MACRO( FT_Stream_Get_Long, FT_ULong )
#define GET_ShortLE() FT_GET_MACRO( FT_Get_ShortLE, FT_Short )
#define GET_UShortLE() FT_GET_MACRO( FT_Get_ShortLE, FT_UShort )
#define GET_LongLE() FT_GET_MACRO( FT_Get_LongLE, FT_Long )
#define GET_ULongLE() FT_GET_MACRO( FT_Get_LongLE, FT_ULong )
#define GET_ShortLE() FT_GET_MACRO( FT_Stream_Get_ShortLE, FT_Short )
#define GET_UShortLE() FT_GET_MACRO( FT_Stream_Get_ShortLE, FT_UShort )
#define GET_LongLE() FT_GET_MACRO( FT_Stream_Get_LongLE, FT_Long )
#define GET_ULongLE() FT_GET_MACRO( FT_Stream_Get_LongLE, FT_ULong )
#define FT_READ_MACRO( func, type, var ) \
( var = (type)func( stream, &error ), \
error != FT_Err_Ok )
#define READ_Byte( var ) FT_READ_MACRO( FT_Read_Char, FT_Byte, var )
#define READ_Char( var ) FT_READ_MACRO( FT_Read_Char, FT_Char, var )
#define READ_Short( var ) FT_READ_MACRO( FT_Read_Short, FT_Short, var )
#define READ_UShort( var ) FT_READ_MACRO( FT_Read_Short, FT_UShort, var )
#define READ_Offset( var ) FT_READ_MACRO( FT_Read_Offset, FT_Long, var )
#define READ_UOffset( var ) FT_READ_MACRO( FT_Read_Offset, FT_ULong, var )
#define READ_Long( var ) FT_READ_MACRO( FT_Read_Long, FT_Long, var )
#define READ_ULong( var ) FT_READ_MACRO( FT_Read_Long, FT_ULong, var )
#define READ_Byte( var ) FT_READ_MACRO( FT_Stream_Read_Char, FT_Byte, var )
#define READ_Char( var ) FT_READ_MACRO( FT_Stream_Read_Char, FT_Char, var )
#define READ_Short( var ) FT_READ_MACRO( FT_Stream_Read_Short, FT_Short, var )
#define READ_UShort( var ) FT_READ_MACRO( FT_Stream_Read_Short, FT_UShort, var )
#define READ_Offset( var ) FT_READ_MACRO( FT_Stream_Read_Offset, FT_Long, var )
#define READ_UOffset( var ) FT_READ_MACRO( FT_Stream_Read_Offset, FT_ULong, var )
#define READ_Long( var ) FT_READ_MACRO( FT_Stream_Read_Long, FT_Long, var )
#define READ_ULong( var ) FT_READ_MACRO( FT_Stream_Read_Long, FT_ULong, var )
#define READ_ShortLE( var ) FT_READ_MACRO( FT_Read_ShortLE, FT_Short, var )
#define READ_UShortLE( var ) FT_READ_MACRO( FT_Read_ShortLE, FT_UShort, var )
#define READ_LongLE( var ) FT_READ_MACRO( FT_Read_LongLE, FT_Long, var )
#define READ_ULongLE( var ) FT_READ_MACRO( FT_Read_LongLE, FT_ULong, var )
#define READ_ShortLE( var ) FT_READ_MACRO( FT_Stream_Read_ShortLE, FT_Short, var )
#define READ_UShortLE( var ) FT_READ_MACRO( FT_Stream_Read_ShortLE, FT_UShort, var )
#define READ_LongLE( var ) FT_READ_MACRO( FT_Stream_Read_LongLE, FT_Long, var )
#define READ_ULongLE( var ) FT_READ_MACRO( FT_Stream_Read_LongLE, FT_ULong, var )
#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
/* initialize a stream for reading a regular system stream */
FT_EXPORT( FT_Error )
FT_Stream_Open( FT_Stream stream,
const char* filepathname );
#endif /* FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */
/* initialize a stream for reading in-memory data */
FT_BASE( void )
FT_New_Memory_Stream( FT_Library library,
FT_Byte* base,
FT_ULong size,
FT_Stream stream );
FT_Stream_Open_Memory( FT_Stream stream,
const FT_Byte* base,
FT_ULong size );
/* close a stream (does not destroy the stream structure) */
FT_BASE( void )
FT_Stream_Close( FT_Stream stream );
/* seek within a stream. position is relative to start of stream */
FT_BASE( FT_Error )
FT_Seek_Stream( FT_Stream stream,
FT_Stream_Seek( FT_Stream stream,
FT_ULong pos );
/* skip bytes in a stream */
FT_BASE( FT_Error )
FT_Skip_Stream( FT_Stream stream,
FT_Stream_Skip( FT_Stream stream,
FT_Long distance );
/* return current stream position */
FT_BASE( FT_Long )
FT_Stream_Pos( FT_Stream stream );
/* read bytes from a stream into a user-allocated buffer, returns an */
/* error if all bytes could not be read.. */
FT_BASE( FT_Error )
FT_Read_Stream( FT_Stream stream,
FT_Stream_Read( FT_Stream stream,
FT_Byte* buffer,
FT_ULong count );
/* read bytes from a stream at a given position */
FT_BASE( FT_Error )
FT_Read_Stream_At( FT_Stream stream,
FT_Stream_Read_At( FT_Stream stream,
FT_ULong pos,
FT_Byte* buffer,
FT_ULong count );
/* enter a frame of 'count' consecutive bytes in a stream. returns an */
/* error if the frame could not be read/accessed. The caller can use */
/* the FT_Stream_Get_XXX function to retrieve frame data without */
/* error checks.. */
/* */
/* you must _always_ call FT_Stream_Exit_Frame once you've entered */
/* a stream frame !! */
/* */
FT_BASE( FT_Error )
FT_Access_Frame( FT_Stream stream,
FT_ULong count );
FT_Stream_Enter_Frame( FT_Stream stream,
FT_ULong count );
/* exit a stream frame.. */
/* */
FT_BASE( void )
FT_Forget_Frame( FT_Stream stream );
FT_Stream_Exit_Frame( FT_Stream stream );
/* extract a stream frame. if the stream is disk-based, a heap block */
/* is allocated and the frame bytes are read into it. if the stream */
/* is memory-based, this function simply set a pointer to the data */
/* */
/* useful to optimize access to memory-based streams transparently. */
/* */
/* all extracted frames must be "freed" with a call to the function */
/* FT_Stream_Release_Frame */
/* */
FT_BASE( FT_Error )
FT_Extract_Frame( FT_Stream stream,
FT_Stream_Extract_Frame( FT_Stream stream,
FT_ULong count,
FT_Byte** pbytes );
/* release an extract frame (see FT_Stream_Extract_Frame) */
/* */
FT_BASE( void )
FT_Release_Frame( FT_Stream stream,
FT_Stream_Release_Frame( FT_Stream stream,
FT_Byte** pbytes );
/* read a byte from an entered frame */
FT_BASE( FT_Char )
FT_Get_Char( FT_Stream stream );
FT_Stream_Get_Char( FT_Stream stream );
/* read a 16-bit big-endian integer from an entered frame */
FT_BASE( FT_Short )
FT_Get_Short( FT_Stream stream );
FT_Stream_Get_Short( FT_Stream stream );
/* read a 24-bit big-endian integer from an entered frame */
FT_BASE( FT_Long )
FT_Get_Offset( FT_Stream stream );
FT_Stream_Get_Offset( FT_Stream stream );
/* read a 32-bit big-endian integer from an entered frame */
FT_BASE( FT_Long )
FT_Get_Long( FT_Stream stream );
FT_Stream_Get_Long( FT_Stream stream );
/* read a 16-bit little-endian integer from an entered frame */
FT_BASE( FT_Short )
FT_Get_ShortLE( FT_Stream stream );
FT_Stream_Get_ShortLE( FT_Stream stream );
/* read a 32-bit little-endian integer from an entered frame */
FT_BASE( FT_Long )
FT_Get_LongLE( FT_Stream stream );
FT_Stream_Get_LongLE( FT_Stream stream );
/* read a byte from a stream */
FT_BASE( FT_Char )
FT_Read_Char( FT_Stream stream,
FT_Error* error );
FT_Stream_Read_Char( FT_Stream stream,
FT_Error* error );
/* read a 16-bit big-endian integer from a stream */
FT_BASE( FT_Short )
FT_Read_Short( FT_Stream stream,
FT_Error* error );
FT_Stream_Read_Short( FT_Stream stream,
FT_Error* error );
/* read a 24-bit big-endian integer from a stream */
FT_BASE( FT_Long )
FT_Read_Offset( FT_Stream stream,
FT_Error* error );
FT_Stream_Read_Offset( FT_Stream stream,
FT_Error* error );
/* read a 32-bit big-endian integer from a stream */
FT_BASE( FT_Long )
FT_Read_Long( FT_Stream stream,
FT_Error* error );
FT_Stream_Read_Long( FT_Stream stream,
FT_Error* error );
/* read a 16-bit little-endian integer from a stream */
FT_BASE( FT_Short )
FT_Read_ShortLE( FT_Stream stream,
FT_Error* error );
FT_Stream_Read_ShortLE( FT_Stream stream,
FT_Error* error );
/* read a 32-bit little-endian integer from a stream */
FT_BASE( FT_Long )
FT_Read_LongLE( FT_Stream stream,
FT_Error* error );
FT_Stream_Read_LongLE( FT_Stream stream,
FT_Error* error );
/* read a structure from a stream. The structure must be described */
/* by an array of FT_Frame_Field records.. */
FT_BASE( FT_Error )
FT_Read_Fields( FT_Stream stream,
const FT_Frame_Field* fields,
void* structure );
FT_Stream_Read_Fields( FT_Stream stream,
const FT_Frame_Field* fields,
void* structure );
#define USE_Stream( resource, stream ) \
FT_SET_ERROR( FT_Open_Stream( resource, stream ) )
#define DONE_Stream( stream ) \
FT_Done_Stream( stream )
FT_Stream_Close( stream )
#define ACCESS_Frame( size ) \
FT_SET_ERROR( FT_Access_Frame( stream, size ) )
FT_SET_ERROR( FT_Stream_Enter_Frame( stream, size ) )
#define FORGET_Frame() \
FT_Forget_Frame( stream )
FT_Stream_Exit_Frame( stream )
#define EXTRACT_Frame( size, bytes ) \
FT_SET_ERROR( FT_Extract_Frame( stream, size, \
FT_SET_ERROR( FT_Stream_Extract_Frame( stream, size, \
(FT_Byte**)&(bytes) ) )
#define RELEASE_Frame( bytes ) \
FT_Release_Frame( stream, (FT_Byte**)&(bytes) )
FT_Stream_Release_Frame( stream, (FT_Byte**)&(bytes) )
#define FILE_Seek( position ) \
FT_SET_ERROR( FT_Seek_Stream( stream, position ) )
FT_SET_ERROR( FT_Stream_Seek( stream, position ) )
#define FILE_Skip( distance ) \
FT_SET_ERROR( FT_Skip_Stream( stream, distance ) )
FT_SET_ERROR( FT_Stream_Skip( stream, distance ) )
#define FILE_Pos() \
FT_Stream_Pos( stream )
#define FILE_Read( buffer, count ) \
FT_SET_ERROR( FT_Read_Stream( stream, \
FT_SET_ERROR( FT_Stream_Read( stream, \
(FT_Byte*)buffer, \
count ) )
#define FILE_Read_At( position, buffer, count ) \
FT_SET_ERROR( FT_Read_Stream_At( stream, \
FT_SET_ERROR( FT_Stream_Read_At( stream, \
position, \
(FT_Byte*)buffer, \
count ) )
#define READ_Fields( fields, object ) \
( ( error = FT_Read_Fields( stream, fields, object ) ) != FT_Err_Ok )
( ( error = FT_Stream_Read_Fields( stream, fields, object ) ) != FT_Err_Ok )
FT_END_HEADER

4
src/base/Jamfile
View File

@ -10,8 +10,8 @@ SubDirHdrs [ FT2_SubDir src base ] ;
if $(FT2_MULTI)
{
_sources = ftcalc ftgloadr ftlist ftobjs ftstream ftoutln ftnames fttrigon
ftdbgmem ;
_sources = ftutil ftdbgmem ftstream ftcalc fttrigon ftgloadr ftoutln
ftobjs ftnames ;
}
else
{

18
src/base/ftapi.c
View File

@ -2011,7 +2011,7 @@
FT_BASE_DEF( void )
FT_New_Memory_Stream( FT_Library library,
FT_Stream_OpenMemory( FT_Library library,
FT_Byte* base,
FT_ULong size,
FT_Stream stream )
@ -2021,7 +2021,7 @@
FT_BASE_DEF( FT_Error )
FT_Seek_Stream( FT_Stream stream,
FT_Stream_Seek( FT_Stream stream,
FT_ULong pos )
{
return FT_Stream_Seek( stream, pos );
@ -2029,7 +2029,7 @@
FT_BASE_DEF( FT_Error )
FT_Skip_Stream( FT_Stream stream,
FT_Stream_Skip( FT_Stream stream,
FT_Long distance )
{
return FT_Stream_Skip( stream, distance );
@ -2037,7 +2037,7 @@
FT_BASE_DEF( FT_Error )
FT_Read_Stream( FT_Stream stream,
FT_Stream_Read( FT_Stream stream,
FT_Byte* buffer,
FT_ULong count )
{
@ -2046,7 +2046,7 @@
FT_BASE_DEF( FT_Error )
FT_Read_Stream_At( FT_Stream stream,
FT_Stream_Read_At( FT_Stream stream,
FT_ULong pos,
FT_Byte* buffer,
FT_ULong count )
@ -2056,7 +2056,7 @@
FT_BASE_DEF( FT_Error )
FT_Extract_Frame( FT_Stream stream,
FT_Stream_Extract_Frame( FT_Stream stream,
FT_ULong count,
FT_Byte** pbytes )
{
@ -2065,14 +2065,14 @@
FT_BASE_DEF( void )
FT_Release_Frame( FT_Stream stream,
FT_Stream_Release_Frame( FT_Stream stream,
FT_Byte** pbytes )
{
FT_Stream_Release_Frame( stream, pbytes );
}
FT_BASE_DEF( FT_Error )
FT_Access_Frame( FT_Stream stream,
FT_Stream_Enter_Frame( FT_Stream stream,
FT_ULong count )
{
return FT_Stream_Enter_Frame( stream, count );
@ -2080,7 +2080,7 @@
FT_BASE_DEF( void )
FT_Forget_Frame( FT_Stream stream )
FT_Stream_Exit_Frame( FT_Stream stream )
{
FT_Stream_Exit_Frame( stream );
}

8
src/base/ftbase.c
View File

@ -20,14 +20,14 @@
#define FT_MAKE_OPTION_SINGLE_OBJECT
#include "ftutil.c"
#include "ftdbgmem.c"
#include "ftstream.c"
#include "ftcalc.c"
#include "fttrigon.c"
#include "ftoutln.c"
#include "ftgloadr.c"
#include "ftobjs.c"
#include "ftstream.c"
#include "ftlist.c"
#include "ftoutln.c"
#include "ftnames.c"
#include "ftdbgmem.c"
/* END */

4
src/base/ftmac.c
View File

@ -465,7 +465,7 @@
if ( ALLOC( stream, sizeof ( *stream ) ) )
goto Exit;
FT_New_Memory_Stream( library,
FT_Stream_OpenMemory( library,
base,
size,
stream );
@ -518,7 +518,7 @@
(*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
else
{
FT_Done_Stream( stream );
FT_Stream_Close( stream );
FREE( stream );
}
return error;

536
src/base/ftobjs.c
View File

@ -28,121 +28,6 @@
#include <string.h> /* for strcmp() */
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/**** ****/
/**** ****/
/**** M E M O R Y ****/
/**** ****/
/**** ****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* */
/* 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_memory
/* documentation is in ftmemory.h */
FT_BASE_DEF( FT_Error )
FT_Alloc( FT_Memory memory,
FT_Long size,
void* *P )
{
FT_ASSERT( P != 0 );
if ( size > 0 )
{
*P = memory->alloc( memory, size );
if ( !*P )
{
FT_ERROR(( "FT_Alloc:" ));
FT_ERROR(( " Out of memory? (%ld requested)\n",
size ));
return FT_Err_Out_Of_Memory;
}
MEM_Set( *P, 0, size );
}
else
*P = NULL;
FT_TRACE7(( "FT_Alloc:" ));
FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
size, *P, P ));
return FT_Err_Ok;
}
/* documentation is in ftmemory.h */
FT_BASE_DEF( FT_Error )
FT_Realloc( FT_Memory memory,
FT_Long current,
FT_Long size,
void** P )
{
void* Q;
FT_ASSERT( P != 0 );
/* if the original pointer is NULL, call FT_Alloc() */
if ( !*P )
return FT_Alloc( memory, size, P );
/* if the new block if zero-sized, clear the current one */
if ( size <= 0 )
{
FT_Free( memory, P );
return FT_Err_Ok;
}
Q = memory->realloc( memory, current, size, *P );
if ( !Q )
goto Fail;
if ( size > current )
memset( (char*)Q + current, 0, size - current );
*P = Q;
return FT_Err_Ok;
Fail:
FT_ERROR(( "FT_Realloc:" ));
FT_ERROR(( " Failed (current %ld, requested %ld)\n",
current, size ));
return FT_Err_Out_Of_Memory;
}
/* documentation is in ftmemory.h */
FT_BASE_DEF( void )
FT_Free( FT_Memory memory,
void** P )
{
FT_TRACE7(( "FT_Free:" ));
FT_TRACE7(( " Freeing block 0x%08p, ref 0x%08p\n",
P, P ? *P : (void*)0 ));
if ( P && *P )
{
memory->free( memory, *P );
*P = 0;
}
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
@ -156,19 +41,10 @@
/*************************************************************************/
/*************************************************************************/
/* */
/* <Function> */
/* ft_new_input_stream */
/* */
/* <Description> */
/* Creates a new input stream object from an FT_Open_Args structure. */
/* */
/* <Note> */
/* The function expects a valid `astream' parameter. */
/* */
/* create a new input stream from a FT_Open_Args structure */
/* */
static FT_Error
ft_new_input_stream( FT_Library library,
ft_input_stream_new( FT_Library library,
FT_Open_Args* args,
FT_Stream* astream )
{
@ -190,22 +66,23 @@
stream->memory = memory;
/* now, look at the stream flags */
if ( args->flags & ft_open_memory )
{
error = 0;
FT_New_Memory_Stream( library,
/* create a memory-based stream */
FT_Stream_Open_Memory( stream,
(FT_Byte*)args->memory_base,
args->memory_size,
stream );
args->memory_size );
}
else if ( args->flags & ft_open_pathname )
{
error = FT_New_Stream( args->pathname, stream );
/* create a normal system stream */
error = FT_Stream_Open( stream, args->pathname );
stream->pathname.pointer = args->pathname;
}
else if ( ( args->flags & ft_open_stream ) && args->stream )
{
/* use an existing, user-provided stream */
/* in this case, we do not need to allocate a new stream object */
/* since the caller is responsible for closing it himself */
FREE( stream );
@ -216,6 +93,8 @@
if ( error )
FREE( stream );
else
stream->memory = memory; /* just to be certain */
*astream = stream;
@ -224,37 +103,20 @@
}
/* documentation is in ftobjs.h */
FT_EXPORT_DEF( void )
FT_Done_Stream( FT_Stream stream )
{
if ( stream && stream->close )
{
stream->close( stream );
stream->close = 0;
}
}
static void
ft_done_stream( FT_Stream* astream,
FT_Int external )
ft_input_stream_free( FT_Stream stream,
FT_Int external )
{
FT_Stream stream = *astream;
if ( stream->close )
stream->close( stream );
if ( !external )
if ( stream )
{
FT_Memory memory = stream->memory;
FT_Stream_Close( stream );
FREE( stream );
if ( !external )
FREE( stream );
}
*astream = 0;
}
@ -262,346 +124,6 @@
#define FT_COMPONENT trace_objs
#if 0
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/**** ****/
/**** ****/
/**** G L Y P H L O A D E R ****/
/**** ****/
/**** ****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* */
/* The glyph loader is a simple object which is used to load a set of */
/* glyphs easily. It is critical for the correct loading of composites. */
/* */
/* Ideally, one can see it as a stack of abstract `glyph' objects. */
/* */
/* loader.base Is really the bottom of the stack. It describes a */
/* single glyph image made of the juxtaposition of */
/* several glyphs (those `in the stack'). */
/* */
/* loader.current Describes the top of the stack, on which a new */
/* glyph can be loaded. */
/* */
/* Rewind Clears the stack. */
/* Prepare Set up `loader.current' for addition of a new glyph */
/* image. */
/* Add Add the `current' glyph image to the `base' one, */
/* and prepare for another one. */
/* */
/* The glyph loader is now a base object. Each driver used to */
/* re-implement it in one way or the other, which wasted code and */
/* energy. */
/* */
/*************************************************************************/
/* create a new glyph loader */
FT_BASE_DEF( FT_Error )
FT_GlyphLoader_New( FT_Memory memory,
FT_GlyphLoader* *aloader )
{
FT_GlyphLoader* loader;
FT_Error error;
if ( !ALLOC( loader, sizeof ( *loader ) ) )
{
loader->memory = memory;
*aloader = loader;
}
return error;
}
/* rewind the glyph loader - reset counters to 0 */
FT_BASE_DEF( void )
FT_GlyphLoader_Rewind( FT_GlyphLoader* loader )
{
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
base->outline.n_points = 0;
base->outline.n_contours = 0;
base->num_subglyphs = 0;
*current = *base;
}
/* reset the glyph loader, frees all allocated tables */
/* and starts from zero */
FT_BASE_DEF( void )
FT_GlyphLoader_Reset( FT_GlyphLoader* loader )
{
FT_Memory memory = loader->memory;
FREE( loader->base.outline.points );
FREE( loader->base.outline.tags );
FREE( loader->base.outline.contours );
FREE( loader->base.extra_points );
FREE( loader->base.subglyphs );
loader->max_points = 0;
loader->max_contours = 0;
loader->max_subglyphs = 0;
FT_GlyphLoader_Rewind( loader );
}
/* delete a glyph loader */
FT_BASE_DEF( void )
FT_GlyphLoader_Done( FT_GlyphLoader* loader )
{
if ( loader )
{
FT_Memory memory = loader->memory;
FT_GlyphLoader_Reset( loader );
FREE( loader );
}
}
/* re-adjust the `current' outline fields */
static void
FT_GlyphLoader_Adjust_Points( FT_GlyphLoader* loader )
{
FT_Outline* base = &loader->base.outline;
FT_Outline* current = &loader->current.outline;
current->points = base->points + base->n_points;
current->tags = base->tags + base->n_points;
current->contours = base->contours + base->n_contours;
/* handle extra points table - if any */
if ( loader->use_extra )
loader->current.extra_points =
loader->base.extra_points + base->n_points;
}
FT_BASE_DEF( FT_Error )
FT_GlyphLoader_Create_Extra( FT_GlyphLoader* loader )
{
FT_Error error;
FT_Memory memory = loader->memory;
if ( !ALLOC_ARRAY( loader->base.extra_points,
loader->max_points, FT_Vector ) )
{
loader->use_extra = 1;
FT_GlyphLoader_Adjust_Points( loader );
}
return error;
}
/* re-adjust the `current' subglyphs field */
static void
FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader* loader )
{
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
current->subglyphs = base->subglyphs + base->num_subglyphs;
}
/* Ensure that we can add `n_points' and `n_contours' to our glyph. this */
/* function reallocates its outline tables if necessary. Note that it */
/* DOESN'T change the number of points within the loader! */
/* */
FT_BASE_DEF( FT_Error )
FT_GlyphLoader_Check_Points( FT_GlyphLoader* loader,
FT_UInt n_points,
FT_UInt n_contours )
{
FT_Memory memory = loader->memory;
FT_Error error = FT_Err_Ok;
FT_Outline* base = &loader->base.outline;
FT_Outline* current = &loader->current.outline;
FT_Bool adjust = 1;
FT_UInt new_max, old_max;
/* check points & tags */
new_max = base->n_points + current->n_points + n_points;
old_max = loader->max_points;
if ( new_max > old_max )
{
new_max = ( new_max + 7 ) & -8;
if ( REALLOC_ARRAY( base->points, old_max, new_max, FT_Vector ) ||
REALLOC_ARRAY( base->tags, old_max, new_max, FT_Byte ) )
goto Exit;
if ( loader->use_extra &&
REALLOC_ARRAY( loader->base.extra_points, old_max,
new_max, FT_Vector ) )
goto Exit;
adjust = 1;
loader->max_points = new_max;
}
/* check contours */
old_max = loader->max_contours;
new_max = base->n_contours + current->n_contours +
n_contours;
if ( new_max > old_max )
{
new_max = ( new_max + 3 ) & -4;
if ( REALLOC_ARRAY( base->contours, old_max, new_max, FT_Short ) )
goto Exit;
adjust = 1;
loader->max_contours = new_max;
}
if ( adjust )
FT_GlyphLoader_Adjust_Points( loader );
Exit:
return error;
}
/* Ensure that we can add `n_subglyphs' to our glyph. this function */
/* reallocates its subglyphs table if necessary. Note that it DOES */
/* NOT change the number of subglyphs within the loader! */
/* */
FT_BASE_DEF( FT_Error )
FT_GlyphLoader_Check_Subglyphs( FT_GlyphLoader* loader,
FT_UInt n_subs )
{
FT_Memory memory = loader->memory;
FT_Error error = FT_Err_Ok;
FT_UInt new_max, old_max;
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
old_max = loader->max_subglyphs;
if ( new_max > old_max )
{
new_max = ( new_max + 1 ) & -2;
if ( REALLOC_ARRAY( base->subglyphs, old_max, new_max, FT_SubGlyph ) )
goto Exit;
loader->max_subglyphs = new_max;
FT_GlyphLoader_Adjust_Subglyphs( loader );
}
Exit:
return error;
}
/* prepare loader for the addition of a new glyph on top of the base one */
FT_BASE_DEF( void )
FT_GlyphLoader_Prepare( FT_GlyphLoader* loader )
{
FT_GlyphLoad* current = &loader->current;
current->outline.n_points = 0;
current->outline.n_contours = 0;
current->num_subglyphs = 0;
FT_GlyphLoader_Adjust_Points ( loader );
FT_GlyphLoader_Adjust_Subglyphs( loader );
}
/* add current glyph to the base image - and prepare for another */
FT_BASE_DEF( void )
FT_GlyphLoader_Add( FT_GlyphLoader* loader )
{
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
FT_UInt n_curr_contours = current->outline.n_contours;
FT_UInt n_base_points = base->outline.n_points;
FT_UInt n;
base->outline.n_points =
(short)( base->outline.n_points + current->outline.n_points );
base->outline.n_contours =
(short)( base->outline.n_contours + current->outline.n_contours );
base->num_subglyphs += current->num_subglyphs;
/* adjust contours count in newest outline */
for ( n = 0; n < n_curr_contours; n++ )
current->outline.contours[n] =
(short)( current->outline.contours[n] + n_base_points );
/* prepare for another new glyph image */
FT_GlyphLoader_Prepare( loader );
}
FT_BASE_DEF( FT_Error )
FT_GlyphLoader_Copy_Points( FT_GlyphLoader* target,
FT_GlyphLoader* source )
{
FT_Error error;
FT_UInt num_points = source->base.outline.n_points;
FT_UInt num_contours = source->base.outline.n_contours;
error = FT_GlyphLoader_Check_Points( target, num_points, num_contours );
if ( !error )
{
FT_Outline* out = &target->base.outline;
FT_Outline* in = &source->base.outline;
MEM_Copy( out->points, in->points,
num_points * sizeof ( FT_Vector ) );
MEM_Copy( out->tags, in->tags,
num_points * sizeof ( char ) );
MEM_Copy( out->contours, in->contours,
num_contours * sizeof ( short ) );
/* do we need to copy the extra points? */
if ( target->use_extra && source->use_extra )
MEM_Copy( target->base.extra_points, source->base.extra_points,
num_points * sizeof ( FT_Vector ) );
out->n_points = (short)num_points;
out->n_contours = (short)num_contours;
FT_GlyphLoader_Adjust_Points( target );
}
return error;
}
#endif
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
@ -1064,10 +586,11 @@
clazz->done_face( face );
/* close the stream for this face if needed */
ft_done_stream(
&face->stream,
ft_input_stream_free( face->stream,
( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );
face->stream = 0;
/* get rid of it */
if ( face->internal )
{
@ -1225,7 +748,7 @@
/* test for valid `library' delayed to */
/* ft_new_input_stream() */
/* ft_input_stream_new() */
if ( !aface || !args )
return FT_Err_Invalid_Argument;
@ -1236,7 +759,7 @@
args->stream );
/* create input stream */
error = ft_new_input_stream( library, args, &stream );
error = ft_input_stream_new( library, args, &stream );
if ( error )
goto Exit;
@ -1269,7 +792,7 @@
else
error = FT_Err_Invalid_Handle;
ft_done_stream( &stream, external_stream );
ft_input_stream_free( stream, external_stream );
goto Fail;
}
else
@ -1310,7 +833,7 @@
error = FT_Err_Unknown_File_Format;
Fail2:
ft_done_stream( &stream, external_stream );
ft_input_stream_free( stream, external_stream );
goto Fail;
}
@ -1419,7 +942,7 @@
FT_Driver_Class* clazz;
/* test for valid `parameters' delayed to ft_new_input_stream() */
/* test for valid `parameters' delayed to ft_input_stream_new() */
if ( !face )
return FT_Err_Invalid_Face_Handle;
@ -1428,7 +951,7 @@
if ( !driver )
return FT_Err_Invalid_Driver_Handle;
error = ft_new_input_stream( driver->root.library, parameters, &stream );
error = ft_input_stream_new( driver->root.library, parameters, &stream );
if ( error )
goto Exit;
@ -1441,7 +964,7 @@
error = clazz->attach_file( face, stream );
/* close the attached stream */
ft_done_stream( &stream,
ft_input_stream_free( stream,
(FT_Bool)( parameters->stream &&
( parameters->flags & ft_open_stream ) ) );
@ -2636,6 +2159,9 @@
if ( !memory )
return FT_Err_Invalid_Argument;
/* init debugging support */
ft_debug_init();
/* first of all, allocate the library object */
if ( ALLOC( library, sizeof ( *library ) ) )
return error;

105
src/base/ftstream.c
View File

@ -32,13 +32,11 @@
FT_BASE_DEF( void )
FT_New_Memory_Stream( FT_Library library,
FT_Byte* base,
FT_ULong size,
FT_Stream stream )
FT_Stream_Open_Memory( FT_Stream stream,
const FT_Byte* base,
FT_ULong size )
{
stream->memory = library->memory;
stream->base = base;
stream->base = (FT_Byte*) base;
stream->size = size;
stream->pos = 0;
stream->cursor = 0;
@ -47,8 +45,19 @@
}
FT_BASE_DEF( void )
FT_Stream_Close( FT_Stream stream )
{
if ( stream && stream->close )
{
stream->close( stream );
stream->close = NULL;
}
}
FT_BASE_DEF( FT_Error )
FT_Seek_Stream( FT_Stream stream,
FT_Stream_Seek( FT_Stream stream,
FT_ULong pos )
{
FT_Error error;
@ -60,7 +69,7 @@
{
if ( stream->read( stream, pos, 0, 0 ) )
{
FT_ERROR(( "FT_Seek_Stream:" ));
FT_ERROR(( "FT_Stream_Seek:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
pos, stream->size ));
@ -72,7 +81,7 @@
/* note that seeking to the first position after the file is valid */
else if ( pos > stream->size )
{
FT_ERROR(( "FT_Seek_Stream:" ));
FT_ERROR(( "FT_Stream_Seek:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
pos, stream->size ));
@ -87,10 +96,10 @@
FT_BASE_DEF( FT_Error )
FT_Skip_Stream( FT_Stream stream,
FT_Stream_Skip( FT_Stream stream,
FT_Long distance )
{
return FT_Seek_Stream( stream, (FT_ULong)( stream->pos + distance ) );
return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );
}
@ -102,16 +111,16 @@
FT_BASE_DEF( FT_Error )
FT_Read_Stream( FT_Stream stream,
FT_Stream_Read( FT_Stream stream,
FT_Byte* buffer,
FT_ULong count )
{
return FT_Read_Stream_At( stream, stream->pos, buffer, count );
return FT_Stream_Read_At( stream, stream->pos, buffer, count );
}
FT_BASE_DEF( FT_Error )
FT_Read_Stream_At( FT_Stream stream,
FT_Stream_Read_At( FT_Stream stream,
FT_ULong pos,
FT_Byte* buffer,
FT_ULong count )
@ -122,7 +131,7 @@
if ( pos >= stream->size )
{
FT_ERROR(( "FT_Read_Stream_At:" ));
FT_ERROR(( "FT_Stream_Read_At:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
pos, stream->size ));
@ -144,7 +153,7 @@
if ( read_bytes < count )
{
FT_ERROR(( "FT_Read_Stream_At:" ));
FT_ERROR(( "FT_Stream_Read_At:" ));
FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
count, read_bytes ));
@ -156,19 +165,19 @@
FT_BASE_DEF( FT_Error )
FT_Extract_Frame( FT_Stream stream,
FT_Stream_Extract_Frame( FT_Stream stream,
FT_ULong count,
FT_Byte** pbytes )
{
FT_Error error;
error = FT_Access_Frame( stream, count );
error = FT_Stream_Enter_Frame( stream, count );
if ( !error )
{
*pbytes = (FT_Byte*)stream->cursor;
/* equivalent to FT_Forget_Frame(), with no memory block release */
/* equivalent to FT_Stream_Exit_Frame(), with no memory block release */
stream->cursor = 0;
stream->limit = 0;
}
@ -178,7 +187,7 @@
FT_BASE_DEF( void )
FT_Release_Frame( FT_Stream stream,
FT_Stream_Release_Frame( FT_Stream stream,
FT_Byte** pbytes )
{
if ( stream->read )
@ -193,7 +202,7 @@
FT_BASE_DEF( FT_Error )
FT_Access_Frame( FT_Stream stream,
FT_Stream_Enter_Frame( FT_Stream stream,
FT_ULong count )
{
FT_Error error = FT_Err_Ok;
@ -217,7 +226,7 @@
stream->base, count );
if ( read_bytes < count )
{
FT_ERROR(( "FT_Access_Frame:" ));
FT_ERROR(( "FT_Stream_Enter_Frame:" ));
FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
count, read_bytes ));
@ -234,7 +243,7 @@
if ( stream->pos >= stream->size ||
stream->pos + count > stream->size )
{
FT_ERROR(( "FT_Access_Frame:" ));
FT_ERROR(( "FT_Stream_Enter_Frame:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
stream->pos, count, stream->size ));
@ -254,7 +263,7 @@
FT_BASE_DEF( void )
FT_Forget_Frame( FT_Stream stream )
FT_Stream_Exit_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 */
@ -263,7 +272,7 @@
/* */
/* 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_Stream_Enter_Frame() call, and this is not an error. */
/* */
FT_ASSERT( stream );
@ -296,7 +305,7 @@
FT_BASE_DEF( FT_Short )
FT_Get_Short( FT_Stream stream )
FT_Stream_Get_Short( FT_Stream stream )
{
FT_Byte* p;
FT_Short result;
@ -315,7 +324,7 @@
FT_BASE_DEF( FT_Short )
FT_Get_ShortLE( FT_Stream stream )
FT_Stream_Get_ShortLE( FT_Stream stream )
{
FT_Byte* p;
FT_Short result;
@ -334,7 +343,7 @@
FT_BASE_DEF( FT_Long )
FT_Get_Offset( FT_Stream stream )
FT_Stream_Get_Offset( FT_Stream stream )
{
FT_Byte* p;
FT_Long result;
@ -352,7 +361,7 @@
FT_BASE_DEF( FT_Long )
FT_Get_Long( FT_Stream stream )
FT_Stream_Get_Long( FT_Stream stream )
{
FT_Byte* p;
FT_Long result;
@ -370,7 +379,7 @@
FT_BASE_DEF( FT_Long )
FT_Get_LongLE( FT_Stream stream )
FT_Stream_Get_LongLE( FT_Stream stream )
{
FT_Byte* p;
FT_Long result;
@ -388,7 +397,7 @@
FT_BASE_DEF( FT_Char )
FT_Read_Char( FT_Stream stream,
FT_Stream_Read_Char( FT_Stream stream,
FT_Error* error )
{
FT_Byte result = 0;
@ -416,7 +425,7 @@
Fail:
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Read_Char:" ));
FT_ERROR(( "FT_Stream_Read_Char:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
@ -425,8 +434,8 @@
FT_BASE_DEF( FT_Short )
FT_Read_Short( FT_Stream stream,
FT_Error* error )
FT_Stream_Read_Short( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[2];
FT_Byte* p = 0;
@ -463,7 +472,7 @@
Fail:
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Read_Short:" ));
FT_ERROR(( "FT_Stream_Read_Short:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
@ -472,7 +481,7 @@
FT_BASE_DEF( FT_Short )
FT_Read_ShortLE( FT_Stream stream,
FT_Stream_Read_ShortLE( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[2];
@ -510,7 +519,7 @@
Fail:
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Read_Short:" ));
FT_ERROR(( "FT_Stream_Read_Short:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
@ -519,7 +528,7 @@
FT_BASE_DEF( FT_Long )
FT_Read_Offset( FT_Stream stream,
FT_Stream_Read_Offset( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[3];
@ -557,7 +566,7 @@
Fail:
*error = FT_Err_Invalid_Stream_Operation;
FT_ERROR(( "FT_Read_Offset:" ));
FT_ERROR(( "FT_Stream_Read_Offset:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
@ -566,7 +575,7 @@
FT_BASE_DEF( FT_Long )
FT_Read_Long( FT_Stream stream,
FT_Stream_Read_Long( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[4];
@ -603,7 +612,7 @@
return result;
Fail:
FT_ERROR(( "FT_Read_Long:" ));
FT_ERROR(( "FT_Stream_Read_Long:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
*error = FT_Err_Invalid_Stream_Operation;
@ -613,7 +622,7 @@
FT_BASE_DEF( FT_Long )
FT_Read_LongLE( FT_Stream stream,
FT_Stream_Read_LongLE( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[4];
@ -650,7 +659,7 @@
return result;
Fail:
FT_ERROR(( "FT_Read_Long:" ));
FT_ERROR(( "FT_Stream_Read_Long:" ));
FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
stream->pos, stream->size ));
*error = FT_Err_Invalid_Stream_Operation;
@ -660,9 +669,9 @@
FT_BASE_DEF( FT_Error )
FT_Read_Fields( FT_Stream stream,
const FT_Frame_Field* fields,
void* structure )
FT_Stream_Read_Fields( FT_Stream stream,
const FT_Frame_Field* fields,
void* structure )
{
FT_Error error;
FT_Bool frame_accessed = 0;
@ -683,7 +692,7 @@
switch ( fields->value )
{
case ft_frame_start: /* access a new frame */
error = FT_Access_Frame( stream, fields->offset );
error = FT_Stream_Enter_Frame( stream, fields->offset );
if ( error )
goto Exit;
@ -795,7 +804,7 @@
Exit:
/* close the frame if it was opened by this read */
if ( frame_accessed )
FT_Forget_Frame( stream );
FT_Stream_Exit_Frame( stream );
return error;
}

52
src/base/ftsystem.c
View File

@ -158,7 +158,7 @@
/*************************************************************************/
/* */
/* <Function> */
/* ft_close_stream */
/* ft_ansi_stream_close */
/* */
/* <Description> */
/* The function to close a stream. */
@ -167,7 +167,7 @@
/* stream :: A pointer to the stream object. */
/* */
FT_CALLBACK_DEF( void )
ft_close_stream( FT_Stream stream )
ft_ansi_stream_close( FT_Stream stream )
{
fclose( STREAM_FILE( stream ) );
@ -180,7 +180,7 @@
/*************************************************************************/
/* */
/* <Function> */
/* ft_io_stream */
/* ft_ansi_stream_io */
/* */
/* <Description> */
/* The function to open a stream. */
@ -198,10 +198,10 @@
/* The number of bytes actually read. */
/* */
FT_CALLBACK_DEF( unsigned long )
ft_io_stream( FT_Stream stream,
unsigned long offset,
unsigned char* buffer,
unsigned long count )
ft_ansi_stream_io( FT_Stream stream,
unsigned long offset,
unsigned char* buffer,
unsigned long count )
{
FILE* file;
@ -217,38 +217,38 @@
/* documentation is in ftobjs.h */
FT_EXPORT_DEF( FT_Error )
FT_New_Stream( const char* filepathname,
FT_Stream astream )
FT_Stream_Open( FT_Stream stream,
const char* filepathname )
{
FILE* file;
if ( !astream )
if ( !stream )
return FT_Err_Invalid_Stream_Handle;
file = fopen( filepathname, "rb" );
if ( !file )
{
FT_ERROR(( "FT_New_Stream:" ));
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
return FT_Err_Cannot_Open_Resource;
}
fseek( file, 0, SEEK_END );
astream->size = ftell( file );
stream->size = ftell( file );
fseek( file, 0, SEEK_SET );
astream->descriptor.pointer = file;
astream->pathname.pointer = (char*)filepathname;
astream->pos = 0;
stream->descriptor.pointer = file;
stream->pathname.pointer = (char*)filepathname;
stream->pos = 0;
astream->read = ft_io_stream;
astream->close = ft_close_stream;
stream->read = ft_ansi_stream_io;
stream->close = ft_ansi_stream_close;
FT_TRACE1(( "FT_New_Stream:" ));
FT_TRACE1(( "FT_Stream_Open:" ));
FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
filepathname, astream->size ));
filepathname, stream->size ));
return FT_Err_Ok;
}
@ -259,13 +259,13 @@
extern FT_Int
ft_mem_debug_init( FT_Memory memory );
extern void
ft_mem_debug_done( FT_Memory memory );
#endif
#endif
/* documentation is in ftobjs.h */
FT_EXPORT_DEF( FT_Memory )
@ -283,7 +283,7 @@
memory->free = ft_free;
#ifdef FT_DEBUG_MEMORY
ft_mem_debug_init( memory );
#endif
#endif
}
return memory;
@ -297,7 +297,7 @@
{
#ifdef FT_DEBUG_MEMORY
ft_mem_debug_done( memory );
#endif
#endif
memory->free( memory, memory );
}

459
src/base/ftutil.c
View File

@ -1,6 +1,7 @@
#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_UTIL_H
#include FT_INTERNAL_MEMORY_H
#include FT_LIST_H
/*************************************************************************/
@ -32,7 +33,7 @@
FT_Long size,
void* *P )
{
FT_Assert( P != 0 );
FT_ASSERT( P != 0 );
if ( size > 0 )
{
@ -69,7 +70,7 @@
void* Q;
FT_Assert( P != 0 );
FT_ASSERT( P != 0 );
/* if the original pointer is NULL, call FT_Alloc() */
if ( !*P )
@ -308,455 +309,3 @@
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** *****/
/***** G L Y P H L O A D E R *****/
/***** *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* */
/* The glyph loader is a simple object which is used to load a set of */
/* glyphs easily. It is critical for the correct loading of composites. */
/* */
/* Ideally, one can see it as a stack of abstract `glyph' objects. */
/* */
/* loader.base Is really the bottom of the stack. It describes a */
/* single glyph image made of the juxtaposition of */
/* several glyphs (those `in the stack'). */
/* */
/* loader.current Describes the top of the stack, on which a new */
/* glyph can be loaded. */
/* */
/* Rewind Clears the stack. */
/* Prepare Set up `loader.current' for addition of a new glyph */
/* image. */
/* Add Add the `current' glyph image to the `base' one, */
/* and prepare for another one. */
/* */
/* The glyph loader is now a base object. Each driver used to */
/* re-implement it in one way or the other, which wasted code and */
/* energy. */
/* */
/*************************************************************************/
/* create a new glyph loader */
FT_BASE_DEF( FT_Error )
FT_GlyphLoader _New( FT_Memory memory,
FT_GlyphLoader *aloader )
{
FT_GlyphLoader loader;
FT_Error error;
if ( !ALLOC( loader, sizeof ( *loader ) ) )
{
loader->memory = memory;
*aloader = loader;
}
return error;
}
/* rewind the glyph loader - reset counters to 0 */
FT_BASE_DEF( void )
FT_GlyphLoader _Rewind( FT_GlyphLoader loader )
{
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
base->outline.n_points = 0;
base->outline.n_contours = 0;
base->num_subglyphs = 0;
*current = *base;
}
/* reset the glyph loader, frees all allocated tables */
/* and starts from zero */
FT_BASE_DEF( void )
FT_GlyphLoader _Reset( FT_GlyphLoader loader )
{
FT_Memory memory = loader->memory;
FREE( loader->base.outline.points );
FREE( loader->base.outline.tags );
FREE( loader->base.outline.contours );
FREE( loader->base.extra_points );
FREE( loader->base.subglyphs );
loader->max_points = 0;
loader->max_contours = 0;
loader->max_subglyphs = 0;
FT_GlyphLoader _Rewind( loader );
}
/* delete a glyph loader */
FT_BASE_DEF( void )
FT_GlyphLoader _Done( FT_GlyphLoader loader )
{
if ( loader )
{
FT_Memory memory = loader->memory;
FT_GlyphLoader _Reset( loader );
FREE( loader );
}
}
/* re-adjust the `current' outline fields */
static void
FT_GlyphLoader _Adjust_Points( FT_GlyphLoader loader )
{
FT_Outline* base = &loader->base.outline;
FT_Outline* current = &loader->current.outline;
current->points = base->points + base->n_points;
current->tags = base->tags + base->n_points;
current->contours = base->contours + base->n_contours;
/* handle extra points table - if any */
if ( loader->use_extra )
loader->current.extra_points =
loader->base.extra_points + base->n_points;
}
FT_BASE_DEF( FT_Error )
FT_GlyphLoader _Create_Extra( FT_GlyphLoader loader )
{
FT_Error error;
FT_Memory memory = loader->memory;
if ( !ALLOC_ARRAY( loader->base.extra_points,
loader->max_points, FT_Vector ) )
{
loader->use_extra = 1;
FT_GlyphLoader _Adjust_Points( loader );
}
return error;
}
/* re-adjust the `current' subglyphs field */
static void
FT_GlyphLoader _Adjust_Subglyphs( FT_GlyphLoader loader )
{
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
current->subglyphs = base->subglyphs + base->num_subglyphs;
}
/* Ensure that we can add `n_points' and `n_contours' to our glyph. this */
/* function reallocates its outline tables if necessary. Note that it */
/* DOESN'T change the number of points within the loader! */
/* */
FT_BASE_DEF( FT_Error )
FT_GlyphLoader _Check_Points( FT_GlyphLoader loader,
FT_UInt n_points,
FT_UInt n_contours )
{
FT_Memory memory = loader->memory;
FT_Error error = FT_Err_Ok;
FT_Outline* base = &loader->base.outline;
FT_Outline* current = &loader->current.outline;
FT_Bool adjust = 1;
FT_UInt new_max, old_max;
/* check points & tags */
new_max = base->n_points + current->n_points + n_points;
old_max = loader->max_points;
if ( new_max > old_max )
{
new_max = ( new_max + 7 ) & -8;
if ( REALLOC_ARRAY( base->points, old_max, new_max, FT_Vector ) ||
REALLOC_ARRAY( base->tags, old_max, new_max, FT_Byte ) )
goto Exit;
if ( loader->use_extra &&
REALLOC_ARRAY( loader->base.extra_points, old_max,
new_max, FT_Vector ) )
goto Exit;
adjust = 1;
loader->max_points = new_max;
}
/* check contours */
old_max = loader->max_contours;
new_max = base->n_contours + current->n_contours +
n_contours;
if ( new_max > old_max )
{
new_max = ( new_max + 3 ) & -4;
if ( REALLOC_ARRAY( base->contours, old_max, new_max, FT_Short ) )
goto Exit;
adjust = 1;
loader->max_contours = new_max;
}
if ( adjust )
FT_GlyphLoader _Adjust_Points( loader );
Exit:
return error;
}
/* Ensure that we can add `n_subglyphs' to our glyph. this function */
/* reallocates its subglyphs table if necessary. Note that it DOES */
/* NOT change the number of subglyphs within the loader! */
/* */
FT_BASE_DEF( FT_Error )
FT_GlyphLoader _Check_Subglyphs( FT_GlyphLoader loader,
FT_UInt n_subs )
{
FT_Memory memory = loader->memory;
FT_Error error = FT_Err_Ok;
FT_UInt new_max, old_max;
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
old_max = loader->max_subglyphs;
if ( new_max > old_max )
{
new_max = ( new_max + 1 ) & -2;
if ( REALLOC_ARRAY( base->subglyphs, old_max, new_max, FT_SubGlyph ) )
goto Exit;
loader->max_subglyphs = new_max;
FT_GlyphLoader _Adjust_Subglyphs( loader );
}
Exit:
return error;
}
/* prepare loader for the addition of a new glyph on top of the base one */
FT_BASE_DEF( void )
FT_GlyphLoader _Prepare( FT_GlyphLoader loader )
{
FT_GlyphLoad* current = &loader->current;
current->outline.n_points = 0;
current->outline.n_contours = 0;
current->num_subglyphs = 0;
FT_GlyphLoader _Adjust_Points ( loader );
FT_GlyphLoader _Adjust_Subglyphs( loader );
}
/* add current glyph to the base image - and prepare for another */
FT_BASE_DEF( void )
FT_GlyphLoader _Add( FT_GlyphLoader loader )
{
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
FT_UInt n_curr_contours = current->outline.n_contours;
FT_UInt n_base_points = base->outline.n_points;
FT_UInt n;
base->outline.n_points =
(short)( base->outline.n_points + current->outline.n_points );
base->outline.n_contours =
(short)( base->outline.n_contours + current->outline.n_contours );
base->num_subglyphs += current->num_subglyphs;
/* adjust contours count in newest outline */
for ( n = 0; n < n_curr_contours; n++ )
current->outline.contours[n] =
(short)( current->outline.contours[n] + n_base_points );
/* prepare for another new glyph image */
FT_GlyphLoader _Prepare( loader );
}
FT_BASE_DEF( FT_Error )
FT_GlyphLoader _Copy_Points( FT_GlyphLoader target,
FT_GlyphLoader source )
{
FT_Error error;
FT_UInt num_points = source->base.outline.n_points;
FT_UInt num_contours = source->base.outline.n_contours;
error = FT_GlyphLoader _Check_Points( target, num_points, num_contours );
if ( !error )
{
FT_Outline* out = &target->base.outline;
FT_Outline* in = &source->base.outline;
MEM_Copy( out->points, in->points,
num_points * sizeof ( FT_Vector ) );
MEM_Copy( out->tags, in->tags,
num_points * sizeof ( char ) );
MEM_Copy( out->contours, in->contours,
num_contours * sizeof ( short ) );
/* do we need to copy the extra points? */
if ( target->use_extra && source->use_extra )
MEM_Copy( target->base.extra_points, source->base.extra_points,
num_points * sizeof ( FT_Vector ) );
out->n_points = (short)num_points;
out->n_contours = (short)num_contours;
FT_GlyphLoader _Adjust_Points( target );
}
return error;
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** *****/
/***** S T R E A M S *****/
/***** *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
#undef FT_COMPONENT
#define FT_COMPONENT trace_stream
/*************************************************************************/
/* */
/* <Function> */
/* ft_new_input_stream */
/* */
/* <Description> */
/* Creates a new input stream object from an FT_Open_Args structure. */
/* */
/* <Note> */
/* The function expects a valid `astream' parameter. */
/* */
FT_EXPORT_DEF( FT_Error )
FT_Stream_Open( FT_Library library,
FT_Open_Args* args,
FT_Stream* astream )
{
FT_Error error;
FT_Memory memory;
FT_Stream stream;
if ( !library )
return FT_Err_Invalid_Library_Handle;
if ( !args )
return FT_Err_Invalid_Argument;
*astream = 0;
memory = library->memory;
if ( ALLOC( stream, sizeof ( *stream ) ) )
goto Exit;
stream->memory = memory;
/* now, look at the stream flags */
if ( args->flags & ft_open_memory )
{
error = 0;
FT_New_Memory_Stream( library,
(FT_Byte*)args->memory_base,
args->memory_size,
stream );
}
else if ( args->flags & ft_open_pathname )
{
error = FT_Stream_New( args->pathname, stream );
stream->pathname.pointer = args->pathname;
}
else if ( ( args->flags & ft_open_stream ) && args->stream )
{
/* in this case, we do not need to allocate a new stream object */
/* since the caller is responsible for closing it himself */
FREE( stream );
stream = args->stream;
}
else
error = FT_Err_Invalid_Argument;
if ( error )
FREE( stream );
*astream = stream;
Exit:
return error;
}
/* documentation is in ftobjs.h */
FT_EXPORT_DEF( void )
FT_Stream_Done( FT_Stream stream )
{
if ( stream && stream->close )
{
stream->close( stream );
stream->close = 0;
}
}
static void
ft_done_stream( FT_Stream* astream,
FT_Int external )
{
FT_Stream stream = *astream;
if ( stream->close )
stream->close( stream );
if ( !external )
{
FT_Memory memory = stream->memory;
FREE( stream );
}
*astream = 0;
}

6
src/base/rules.mk
View File

@ -34,11 +34,11 @@ BASE_COMPILE := $(FT_COMPILE) $I$(SRC_)base
#
BASE_SRC := $(BASE_)ftcalc.c \
$(BASE_)fttrigon.c \
$(BASE_)ftgloadr.c \
$(BASE_)ftlist.c \
$(BASE_)ftobjs.c \
$(BASE_)ftutil.c \
$(BASE_)ftstream.c \
$(BASE_)ftgloadr.c \
$(BASE_)ftoutln.c \
$(BASE_)ftobjs.c \
$(BASE_)ftnames.c \
$(BASE_)ftdbgmem.c

16
src/pcf/pcfread.c
View File

@ -408,7 +408,7 @@ THE SOFTWARE.
if ( nprops & 3 )
{
i = 4 - ( nprops & 3 );
FT_Skip_Stream( stream, i );
FT_Stream_Skip( stream, i );
}
if ( PCF_BYTE_ORDER( format ) == MSBFirst )
@ -423,7 +423,7 @@ THE SOFTWARE.
if ( ALLOC( strings, string_size * sizeof ( char ) ) )
goto Bail;
error = FT_Read_Stream( stream, (FT_Byte*)strings, string_size );
error = FT_Stream_Read( stream, (FT_Byte*)strings, string_size );
if ( error )
goto Bail;
@ -568,7 +568,7 @@ THE SOFTWARE.
if ( error )
return error;
error = FT_Access_Frame( stream, 8 );
error = FT_Stream_Enter_Frame( stream, 8 );
if ( error )
return error;
@ -578,7 +578,7 @@ THE SOFTWARE.
else
nbitmaps = GET_ULongLE();
FT_Forget_Frame( stream );
FT_Stream_Exit_Frame( stream );
if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
return PCF_Err_Invalid_File_Format;
@ -660,7 +660,7 @@ THE SOFTWARE.
if ( error )
return error;
error = FT_Access_Frame( stream, 14 );
error = FT_Stream_Enter_Frame( stream, 14 );
if ( error )
return error;
@ -683,7 +683,7 @@ THE SOFTWARE.
face->defaultChar = GET_ShortLE();
}
FT_Forget_Frame( stream );
FT_Stream_Exit_Frame( stream );
if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
return PCF_Err_Invalid_File_Format;
@ -696,7 +696,7 @@ THE SOFTWARE.
if ( ALLOC( tmpEncoding, nencoding * sizeof ( PCF_EncodingRec ) ) )
return PCF_Err_Out_Of_Memory;
error = FT_Access_Frame( stream, 2 * nencoding );
error = FT_Stream_Enter_Frame( stream, 2 * nencoding );
if ( error )
goto Bail;
@ -721,7 +721,7 @@ THE SOFTWARE.
FT_TRACE4(( "enc n. %d ; Uni %ld ; Glyph %d\n",
i, tmpEncoding[j - 1].enc, encodingOffset ));
}
FT_Forget_Frame( stream );
FT_Stream_Exit_Frame( stream );
if ( ALLOC( encoding, (--j) * sizeof ( PCF_EncodingRec ) ) )
goto Bail;

2
src/sfnt/ttsbit.c
View File

@ -1285,7 +1285,7 @@
range->image_format, metrics, stream );
case 8: /* compound format */
FT_Skip_Stream( stream, 1L );
FT_Stream_Skip( stream, 1L );
/* fallthrough */
case 9: