rgraves
/
freetype2
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

major reformatting of the sources: 

FT_EXPORT_DEF    => FT_EXPORT
  FT_EXPORT_FUNC => FT_EXPORT_DEF
  BASE_DEF               => FT_BASE
  BASE_FUNC            => FT_BASE_DEF
  LOCAL_DEF             => FT_LOCAL
  LOCAL_FUNC          => FT_LOCAL_DEF
  LOCAL_FUNC_X     => FT_CALLBACK_DEF
  LOCAL_DEF_X       => FT_CALLBACK_TABLE
  FT_CPLUSPLUS     => FT_CALLBACK_TABLE_DEF
This commit is contained in:
David Turner 2000-11-04 01:55:49 +00:00
parent 4091109486
commit 76a5f62323
133 changed files with 1248 additions and 1167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
builds/cygwin/devel/freetype/config/ftoption.h
View File

@ -155,34 +155,34 @@
/* declarations. */
/* */
/* Two macros are used within the FreeType source code to define */
/* exported library functions: FT_EXPORT_DEF and FT_EXPORT_FUNC. */
/* exported library functions: FT_EXPORT and FT_EXPORT_DEF. */
/* */
/* FT_EXPORT_DEF( return_type ) */
/* FT_EXPORT( return_type ) */
/* */
/* is used in a function declaration, as in */
/* */
/* FT_EXPORT_DEF( FT_Error ) */
/* FT_EXPORT( FT_Error ) */
/* FT_Init_FreeType( FT_Library* alibrary ); */
/* */
/* */
/* FT_EXPORT_FUNC( return_type ) */
/* FT_EXPORT_DEF( return_type ) */
/* */
/* is used in a function definition, as in */
/* */
/* FT_EXPORT_FUNC( FT_Error ) */
/* FT_EXPORT_DEF( FT_Error ) */
/* FT_Init_FreeType( FT_Library* alibrary ) */
/* { */
/* ... some code ... */
/* return FT_Err_Ok; */
/* } */
/* */
/* You can provide your own implementation of FT_EXPORT_DEF and */
/* FT_EXPORT_FUNC here if you want. If you leave them undefined, they */
/* You can provide your own implementation of FT_EXPORT and */
/* FT_EXPORT_DEF here if you want. If you leave them undefined, they */
/* will be later automatically defined as `extern return_type' to */
/* allow normal compilation. */
/* */
#undef FT_EXPORT
#undef FT_EXPORT_DEF
#undef FT_EXPORT_FUNC
/*************************************************************************/

14
builds/cygwin/ftsystem.c
View File

@ -92,7 +92,7 @@
/* <Return> */
/* block :: The address of newly allocated block. */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
void* ft_alloc( FT_Memory memory,
long size )
{
@ -122,7 +122,7 @@
/* <Return> */
/* The address of the reallocated memory block. */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
void* ft_realloc( FT_Memory memory,
long cur_size,
long new_size,
@ -148,7 +148,7 @@
/* */
/* block :: The address of block in memory to be freed. */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ft_free( FT_Memory memory,
void* block )
{
@ -190,7 +190,7 @@
/* <Input> */
/* stream :: A pointer to the stream object. */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ft_close_stream( FT_Stream stream )
{
munmap( (MUNMAP_ARG_CAST)stream->descriptor.pointer, stream->size );
@ -218,7 +218,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Stream( const char* filepathname,
FT_EXPORT_DEF( FT_Error ) FT_New_Stream( const char* filepathname,
FT_Stream stream )
{
int file;
@ -296,7 +296,7 @@
/* <Return> */
/* A pointer to the new memory object. 0 in case of error. */
/* */
FT_EXPORT_FUNC( FT_Memory ) FT_New_Memory( void )
FT_EXPORT_DEF( FT_Memory ) FT_New_Memory( void )
{
FT_Memory memory;
@ -325,7 +325,7 @@
/* <Input> */
/* memory :: A handle to the memory manager. */
/* */
FT_EXPORT_FUNC( void ) FT_Done_Memory( FT_Memory memory )
FT_EXPORT_DEF( void ) FT_Done_Memory( FT_Memory memory )
{
free( memory );
}

24
builds/dos/detect.mk
View File

@ -13,6 +13,30 @@
# fully.
# Test for DJGPP by checking the DJGPP environment variable, which must be
# set in order to use the system (ie. it will always be present when the
# `make' utility is run).
#
ifeq ($(PLATFORM),ansi)
ifdef DJGPP
# We are definitely using DJGPP
PLATFORM := dos
DELETE := del
COPY := copy
CONFIG_FILE := dos-gcc.mk
SEP := /
ifndef CC
CC := gcc
endif # test CC
setup : dos_setup
endif # test DJGPP
endif # test PLATFORM
# We test for the COMSPEC environment variable, then run the `ver'
# command-line program to see if its output contains the word `Dos'.
#

3
builds/dos/dos-gcc.mk
View File

@ -15,7 +15,8 @@
SEP := /
CLEAN_LIBRARY := $(DELETE) $@
include $(TOP)/builds/dos/dos-def.mk
include $(TOP)/builds/compiler/gcc.mk
include $(TOP)/builds/dos/dos-def.mk
# EOF

16
builds/unix/devel/freetype/config/ftoption.h
View File

@ -155,34 +155,34 @@
/* declarations. */
/* */
/* Two macros are used within the FreeType source code to define */
/* exported library functions: FT_EXPORT_DEF and FT_EXPORT_FUNC. */
/* exported library functions: FT_EXPORT and FT_EXPORT_DEF. */
/* */
/* FT_EXPORT_DEF( return_type ) */
/* FT_EXPORT( return_type ) */
/* */
/* is used in a function declaration, as in */
/* */
/* FT_EXPORT_DEF( FT_Error ) */
/* FT_EXPORT( FT_Error ) */
/* FT_Init_FreeType( FT_Library* alibrary ); */
/* */
/* */
/* FT_EXPORT_FUNC( return_type ) */
/* FT_EXPORT_DEF( return_type ) */
/* */
/* is used in a function definition, as in */
/* */
/* FT_EXPORT_FUNC( FT_Error ) */
/* FT_EXPORT_DEF( FT_Error ) */
/* FT_Init_FreeType( FT_Library* alibrary ) */
/* { */
/* ... some code ... */
/* return FT_Err_Ok; */
/* } */
/* */
/* You can provide your own implementation of FT_EXPORT_DEF and */
/* FT_EXPORT_FUNC here if you want. If you leave them undefined, they */
/* You can provide your own implementation of FT_EXPORT and */
/* FT_EXPORT_DEF here if you want. If you leave them undefined, they */
/* will be later automatically defined as `extern return_type' to */
/* allow normal compilation. */
/* */
#undef FT_EXPORT
#undef FT_EXPORT_DEF
#undef FT_EXPORT_FUNC
/*************************************************************************/

14
builds/unix/ftsystem.c
View File

@ -92,7 +92,7 @@
/* <Return> */
/* block :: The address of newly allocated block. */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
void* ft_alloc( FT_Memory memory,
long size )
{
@ -122,7 +122,7 @@
/* <Return> */
/* The address of the reallocated memory block. */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
void* ft_realloc( FT_Memory memory,
long cur_size,
long new_size,
@ -148,7 +148,7 @@
/* */
/* block :: The address of block in memory to be freed. */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ft_free( FT_Memory memory,
void* block )
{
@ -190,7 +190,7 @@
/* <Input> */
/* stream :: A pointer to the stream object. */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ft_close_stream( FT_Stream stream )
{
munmap( (MUNMAP_ARG_CAST)stream->descriptor.pointer, stream->size );
@ -218,7 +218,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Stream( const char* filepathname,
FT_EXPORT_DEF( FT_Error ) FT_New_Stream( const char* filepathname,
FT_Stream stream )
{
int file;
@ -296,7 +296,7 @@
/* <Return> */
/* A pointer to the new memory object. 0 in case of error. */
/* */
FT_EXPORT_FUNC( FT_Memory ) FT_New_Memory( void )
FT_EXPORT_DEF( FT_Memory ) FT_New_Memory( void )
{
FT_Memory memory;
@ -325,7 +325,7 @@
/* <Input> */
/* memory :: A handle to the memory manager. */
/* */
FT_EXPORT_FUNC( void ) FT_Done_Memory( FT_Memory memory )
FT_EXPORT_DEF( void ) FT_Done_Memory( FT_Memory memory )
{
free( memory );
}

16
builds/win32/devel/freetype/config/ftoption.h
View File

@ -155,34 +155,34 @@
/* declarations. */
/* */
/* Two macros are used within the FreeType source code to define */
/* exported library functions: FT_EXPORT_DEF and FT_EXPORT_FUNC. */
/* exported library functions: FT_EXPORT and FT_EXPORT_DEF. */
/* */
/* FT_EXPORT_DEF( return_type ) */
/* FT_EXPORT( return_type ) */
/* */
/* is used in a function declaration, as in */
/* */
/* FT_EXPORT_DEF( FT_Error ) */
/* FT_EXPORT( FT_Error ) */
/* FT_Init_FreeType( FT_Library* alibrary ); */
/* */
/* */
/* FT_EXPORT_FUNC( return_type ) */
/* FT_EXPORT_DEF( return_type ) */
/* */
/* is used in a function definition, as in */
/* */
/* FT_EXPORT_FUNC( FT_Error ) */
/* FT_EXPORT_DEF( FT_Error ) */
/* FT_Init_FreeType( FT_Library* alibrary ) */
/* { */
/* ... some code ... */
/* return FT_Err_Ok; */
/* } */
/* */
/* You can provide your own implementation of FT_EXPORT_DEF and */
/* FT_EXPORT_FUNC here if you want. If you leave them undefined, they */
/* You can provide your own implementation of FT_EXPORT and */
/* FT_EXPORT_DEF here if you want. If you leave them undefined, they */
/* will be later automatically defined as `extern return_type' to */
/* allow normal compilation. */
/* */
#undef FT_EXPORT
#undef FT_EXPORT_DEF
#undef FT_EXPORT_FUNC
/*************************************************************************/

2
docs/tutorial/step1.html
View File

@ -28,7 +28,7 @@
</h3>
<center>
<table width="75%">
<table width="550">
<tr><td>
<hr>

2
docs/tutorial/step2.html
View File

@ -28,7 +28,7 @@
</h3>
<center>
<table width="75%">
<table width="550">
<tr><td>
<hr>

22
include/freetype/cache/ftcchunk.h vendored
View File

@ -164,10 +164,10 @@
/* cache sub-system internals. */
/* */
FT_EXPORT_FUNC( FT_Error ) FTC_ChunkNode_Init( FTC_ChunkNode node,
FTC_ChunkSet cset,
FT_UInt index,
FT_Bool alloc );
FT_EXPORT( FT_Error ) FTC_ChunkNode_Init( FTC_ChunkNode node,
FTC_ChunkSet cset,
FT_UInt index,
FT_Bool alloc );
#define FTC_ChunkNode_Ref( n ) \
FTC_CACHENODE_TO_DATA_P( &(n)->root )->ref_count++
@ -176,18 +176,18 @@
FTC_CACHENODE_TO_DATA_P( &(n)->root )->ref_count--
FT_EXPORT_DEF( void ) FTC_ChunkNode_Destroy( FTC_ChunkNode node );
FT_EXPORT( void ) FTC_ChunkNode_Destroy( FTC_ChunkNode node );
FT_EXPORT_DEF( FT_Error ) FTC_Chunk_Cache_Init( FTC_Chunk_Cache cache );
FT_EXPORT( FT_Error ) FTC_Chunk_Cache_Init( FTC_Chunk_Cache cache );
FT_EXPORT_DEF( void ) FTC_Chunk_Cache_Done( FTC_Chunk_Cache cache );
FT_EXPORT( void ) FTC_Chunk_Cache_Done( FTC_Chunk_Cache cache );
FT_EXPORT_DEF( FT_Error ) FTC_ChunkSet_New( FTC_Chunk_Cache cache,
FT_Pointer type,
FTC_ChunkSet* aset );
FT_EXPORT( FT_Error ) FTC_ChunkSet_New( FTC_Chunk_Cache cache,
FT_Pointer type,
FTC_ChunkSet* aset );
FT_EXPORT_DEF( FT_Error ) FTC_ChunkSet_Lookup_Node(
FT_EXPORT( FT_Error ) FTC_ChunkSet_Lookup_Node(
FTC_ChunkSet cset,
FT_UInt glyph_index,
FTC_ChunkNode* anode,

18
include/freetype/cache/ftcglyph.h vendored
View File

@ -168,7 +168,7 @@
/* cache sub-system internals. */
/* */
FT_EXPORT_FUNC( void ) FTC_GlyphNode_Init( FTC_GlyphNode node,
FT_EXPORT_DEF( void ) FTC_GlyphNode_Init( FTC_GlyphNode node,
FTC_GlyphSet gset,
FT_UInt gindex );
@ -179,19 +179,19 @@
FTC_CACHENODE_TO_DATA_P( &(n)->root )->ref_count--
FT_EXPORT_DEF( void ) FTC_GlyphNode_Destroy( FTC_GlyphNode node,
FTC_Glyph_Cache cache );
FT_EXPORT( void ) FTC_GlyphNode_Destroy( FTC_GlyphNode node,
FTC_Glyph_Cache cache );
FT_EXPORT_DEF( FT_Error ) FTC_Glyph_Cache_Init( FTC_Glyph_Cache cache );
FT_EXPORT( FT_Error ) FTC_Glyph_Cache_Init( FTC_Glyph_Cache cache );
FT_EXPORT_DEF( void ) FTC_Glyph_Cache_Done( FTC_Glyph_Cache cache );
FT_EXPORT( void ) FTC_Glyph_Cache_Done( FTC_Glyph_Cache cache );
FT_EXPORT_DEF( FT_Error ) FTC_GlyphSet_New( FTC_Glyph_Cache cache,
FT_Pointer type,
FTC_GlyphSet* aset );
FT_EXPORT( FT_Error ) FTC_GlyphSet_New( FTC_Glyph_Cache cache,
FT_Pointer type,
FTC_GlyphSet* aset );
FT_EXPORT_DEF( FT_Error ) FTC_GlyphSet_Lookup_Node(
FT_EXPORT( FT_Error ) FTC_GlyphSet_Lookup_Node(
FTC_GlyphSet gset,
FT_UInt glyph_index,
FTC_GlyphNode* anode );

12
include/freetype/cache/ftcimage.h vendored
View File

@ -119,8 +119,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FTC_Image_Cache_New( FTC_Manager manager,
FTC_Image_Cache* acache );
FT_EXPORT( FT_Error ) FTC_Image_Cache_New( FTC_Manager manager,
FTC_Image_Cache* acache );
/*************************************************************************/
@ -154,10 +154,10 @@
/* taken by the glyphs it holds, the returned glyph might disappear */
/* on a later invocation of this function! It's a cache after all... */
/* */
FT_EXPORT_DEF( FT_Error ) FTC_Image_Cache_Lookup( FTC_Image_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FT_Glyph* aglyph );
FT_EXPORT( FT_Error ) FTC_Image_Cache_Lookup( FTC_Image_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FT_Glyph* aglyph );
#ifdef __cplusplus

2
include/freetype/cache/ftcmanag.h vendored
View File

@ -155,7 +155,7 @@
/* The reason this function is exported is to allow client-specific */
/* cache classes. */
/* */
FT_EXPORT_DEF( void ) FTC_Manager_Compress( FTC_Manager manager );
FT_EXPORT( void ) FTC_Manager_Compress( FTC_Manager manager );
/*************************************************************************/

12
include/freetype/cache/ftcsbits.h vendored
View File

@ -53,13 +53,13 @@
} FTC_SBitRec;
FT_EXPORT_DEF( FT_Error ) FTC_SBit_Cache_New( FTC_Manager manager,
FTC_SBit_Cache* acache );
FT_EXPORT( FT_Error ) FTC_SBit_Cache_New( FTC_Manager manager,
FTC_SBit_Cache* acache );
FT_EXPORT_DEF( FT_Error ) FTC_SBit_Cache_Lookup( FTC_SBit_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FTC_SBit *sbit );
FT_EXPORT( FT_Error ) FTC_SBit_Cache_Lookup( FTC_SBit_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FTC_SBit *sbit );
#ifdef __cplusplus

38
include/freetype/cache/ftlru.h vendored
View File

@ -141,33 +141,33 @@
} FT_LruRec;
FT_EXPORT_DEF( FT_Error ) FT_Lru_New( const FT_Lru_Class* clazz,
FT_UInt max_elements,
FT_Pointer user_data,
FT_Memory memory,
FT_Bool pre_alloc,
FT_Lru* alru );
FT_EXPORT( FT_Error ) FT_Lru_New( const FT_Lru_Class* clazz,
FT_UInt max_elements,
FT_Pointer user_data,
FT_Memory memory,
FT_Bool pre_alloc,
FT_Lru* alru );
FT_EXPORT_DEF( void ) FT_Lru_Reset( FT_Lru lru );
FT_EXPORT( void ) FT_Lru_Reset( FT_Lru lru );
FT_EXPORT_DEF( void ) FT_Lru_Done ( FT_Lru lru );
FT_EXPORT( void ) FT_Lru_Done ( FT_Lru lru );
FT_EXPORT_DEF( FT_Error ) FT_Lru_Lookup_Node( FT_Lru lru,
FT_LruKey key,
FT_LruNode* anode );
FT_EXPORT( FT_Error ) FT_Lru_Lookup_Node( FT_Lru lru,
FT_LruKey key,
FT_LruNode* anode );
FT_EXPORT_DEF( FT_Error ) FT_Lru_Lookup( FT_Lru lru,
FT_LruKey key,
FT_Pointer* aobject );
FT_EXPORT( FT_Error ) FT_Lru_Lookup( FT_Lru lru,
FT_LruKey key,
FT_Pointer* aobject );
FT_EXPORT_DEF( void ) FT_Lru_Remove_Node( FT_Lru lru,
FT_LruNode node );
FT_EXPORT( void ) FT_Lru_Remove_Node( FT_Lru lru,
FT_LruNode node );
FT_EXPORT_DEF( void ) FT_Lru_Remove_Selection( FT_Lru lru,
FT_Lru_Selector selector,
FT_Pointer data );
FT_EXPORT( void ) FT_Lru_Remove_Selection( FT_Lru lru,
FT_Lru_Selector selector,
FT_Pointer data );
#ifdef __cplusplus

79
include/freetype/config/ftconfig.h
View File

@ -159,42 +159,53 @@
#ifdef FT_MAKE_OPTION_SINGLE_OBJECT
#define LOCAL_DEF static
#define LOCAL_FUNC static
#define FT_LOCAL static
#define FT_LOCAL_DEF static
#else
#ifdef __cplusplus
#define LOCAL_DEF extern "C"
#define LOCAL_FUNC extern "C"
#define FT_LOCAL extern "C"
#define FT_LOCAL_DEF extern "C"
#else
#define LOCAL_DEF extern
#define LOCAL_FUNC extern
#define FT_LOCAL extern
#define FT_LOCAL_DEF extern
#endif
#endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
#ifndef BASE_DEF
#ifndef FT_BASE
#ifdef __cplusplus
#define BASE_DEF( x ) extern "C" x
#define FT_BASE( x ) extern "C" x
#else
#define BASE_DEF( x ) extern x
#define FT_BASE( x ) extern x
#endif
#endif /* !BASE_DEF */
#endif /* !FT_BASE */
#ifndef BASE_FUNC
#ifndef FT_BASE_DEF
#ifdef __cplusplus
#define BASE_FUNC( x ) extern "C" x
#define FT_BASE_DEF( x ) extern "C" x
#else
#define BASE_FUNC( x ) extern x
#define FT_BASE_DEF( x ) extern x
#endif
#endif /* !BASE_FUNC */
#endif /* !FT_BASE_DEF */
#ifndef FT_EXPORT
#ifdef __cplusplus
#define FT_EXPORT( x ) extern "C" x
#else
#define FT_EXPORT( x ) extern x
#endif
#endif /* !FT_EXPORT */
#ifndef FT_EXPORT_DEF
@ -208,17 +219,6 @@
#endif /* !FT_EXPORT_DEF */
#ifndef FT_EXPORT_FUNC
#ifdef __cplusplus
#define FT_EXPORT_FUNC( x ) extern "C" x
#else
#define FT_EXPORT_FUNC( x ) extern x
#endif
#endif /* !FT_EXPORT_FUNC */
#ifndef FT_EXPORT_VAR
#ifdef __cplusplus
@ -229,6 +229,10 @@
#endif /* !FT_EXPORT_VAR */
/* the following macros are needed to compile the library with a */
/* C++ compiler. Werner insisted on being able to do that even */
/* though we explicitely do not support C++ compilation */
/* */
/* This is special. Within C++, you must specify `extern "C"' for */
/* functions which are used via function pointers, and you also */
@ -236,21 +240,26 @@
/* assure C linkage -- it's not possible to have (local) anonymous */
/* functions which are accessed by (global) function pointers. */
/* */
/* */
/* FT_CALLBACK_DEF is used to _define_ a callback function */
/* */
/* FT_CALLBACK_TABLE is used to _declare_ a constant variable */
/* that contains pointers to callback functions */
/* */
/* FT_CALLBACK_TABLE_DEF is used to _define_ a constant variable */
/* that contains pointers to callback functions */
/* */
#ifdef __cplusplus
#define LOCAL_VAR extern "C"
#define LOCAL_FUNC_X extern "C"
#define FT_CPLUSPLUS( x ) extern "C" x
#define FT_CALLBACK_DEF extern "C"
#define FT_CALLBACK_TABLE extern "C"
#define FT_CALLBACK_TABLE_DEF extern "C"
#else
#define LOCAL_VAR extern
#define LOCAL_FUNC_X static
#define FT_CPLUSPLUS( x ) x
#define FT_CALLBACK_DEF static
#define FT_CALLBACK_TABLE extern
#define FT_CALLBACK_TABLE_DEF
#endif /* __cplusplus */

16
include/freetype/config/ftoption.h
View File

@ -155,34 +155,34 @@
/* declarations. */
/* */
/* Two macros are used within the FreeType source code to define */
/* exported library functions: FT_EXPORT_DEF and FT_EXPORT_FUNC. */
/* exported library functions: FT_EXPORT and FT_EXPORT_DEF. */
/* */
/* FT_EXPORT_DEF( return_type ) */
/* FT_EXPORT( return_type ) */
/* */
/* is used in a function declaration, as in */
/* */
/* FT_EXPORT_DEF( FT_Error ) */
/* FT_EXPORT( FT_Error ) */
/* FT_Init_FreeType( FT_Library* alibrary ); */
/* */
/* */
/* FT_EXPORT_FUNC( return_type ) */
/* FT_EXPORT_DEF( return_type ) */
/* */
/* is used in a function definition, as in */
/* */
/* FT_EXPORT_FUNC( FT_Error ) */
/* FT_EXPORT_DEF( FT_Error ) */
/* FT_Init_FreeType( FT_Library* alibrary ) */
/* { */
/* ... some code ... */
/* return FT_Err_Ok; */
/* } */
/* */
/* You can provide your own implementation of FT_EXPORT_DEF and */
/* FT_EXPORT_FUNC here if you want. If you leave them undefined, they */
/* You can provide your own implementation of FT_EXPORT and */
/* FT_EXPORT_DEF here if you want. If you leave them undefined, they */
/* will be later automatically defined as `extern return_type' to */
/* allow normal compilation. */
/* */
#undef FT_EXPORT
#undef FT_EXPORT_DEF
#undef FT_EXPORT_FUNC
/*************************************************************************/

132
include/freetype/freetype.h
View File

@ -1099,9 +1099,6 @@
/* Note that the app will need to know about the */
/* image format. */
/* */
/* loader :: This is a private object for the glyph slot. */
/* Do not touch this. */
/* */
/* <Note> */
/* If FT_Load_Glyph() is called with default flags (FT_LOAD_DEFAULT), */
/* the glyph image is loaded in the glyph slot in its native format */
@ -1152,6 +1149,9 @@
/*@private begin */
FT_GlyphLoader* loader;
FT_Bool glyph_transformed;
FT_Matrix glyph_matrix;
FT_Vector glyph_delta;
/*@private end */
@ -1182,7 +1182,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Init_FreeType( FT_Library* library );
FT_EXPORT( FT_Error ) FT_Init_FreeType( FT_Library* library );
/*************************************************************************/
@ -1200,7 +1200,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Done_FreeType( FT_Library library );
FT_EXPORT( FT_Error ) FT_Done_FreeType( FT_Library library );
/*************************************************************************/
@ -1361,10 +1361,10 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_New_Face( FT_Library library,
const char* filepathname,
FT_Long face_index,
FT_Face* face );
FT_EXPORT( FT_Error ) FT_New_Face( FT_Library library,
const char* filepathname,
FT_Long face_index,
FT_Face* face );
/*************************************************************************/
@ -1407,11 +1407,11 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_New_Memory_Face( FT_Library library,
FT_Byte* file_base,
FT_Long file_size,
FT_Long face_index,
FT_Face* face );
FT_EXPORT( FT_Error ) FT_New_Memory_Face( FT_Library library,
FT_Byte* file_base,
FT_Long file_size,
FT_Long face_index,
FT_Face* face );
/*************************************************************************/
@ -1454,10 +1454,10 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Open_Face( FT_Library library,
FT_Open_Args* args,
FT_Long face_index,
FT_Face* face );
FT_EXPORT( FT_Error ) FT_Open_Face( FT_Library library,
FT_Open_Args* args,
FT_Long face_index,
FT_Face* face );
/*************************************************************************/
@ -1492,8 +1492,8 @@
/* when invoking this function. Most drivers simply do not implement */
/* file attachments. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Attach_File( FT_Face face,
const char* filepathname );
FT_EXPORT( FT_Error ) FT_Attach_File( FT_Face face,
const char* filepathname );
/*************************************************************************/
@ -1522,8 +1522,8 @@
/* when invoking this function. Most drivers simply do not implement */
/* file attachments. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Attach_Stream( FT_Face face,
FT_Open_Args* parameters );
FT_EXPORT( FT_Error ) FT_Attach_Stream( FT_Face face,
FT_Open_Args* parameters );
/*************************************************************************/
@ -1541,7 +1541,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Done_Face( FT_Face face );
FT_EXPORT( FT_Error ) FT_Done_Face( FT_Face face );
/*************************************************************************/
@ -1578,11 +1578,11 @@
/* When dealing with fixed-size faces (i.e., non-scalable formats), */
/* use the function FT_Set_Pixel_Sizes(). */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Set_Char_Size( FT_Face face,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution );
FT_EXPORT( FT_Error ) FT_Set_Char_Size( FT_Face face,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution );
/*************************************************************************/
@ -1608,9 +1608,9 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Set_Pixel_Sizes( FT_Face face,
FT_UInt pixel_width,
FT_UInt pixel_height );
FT_EXPORT( FT_Error ) FT_Set_Pixel_Sizes( FT_Face face,
FT_UInt pixel_width,
FT_UInt pixel_height );
/*************************************************************************/
@ -1646,9 +1646,9 @@
/* Note that this also transforms the `face.glyph.advance' field, but */
/* *not* the values in `face.glyph.metrics'. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Load_Glyph( FT_Face face,
FT_UInt glyph_index,
FT_Int load_flags );
FT_EXPORT( FT_Error ) FT_Load_Glyph( FT_Face face,
FT_UInt glyph_index,
FT_Int load_flags );
/*************************************************************************/
@ -1689,9 +1689,9 @@
/* Note that this also transforms the `face.glyph.advance' field, but */
/* *not* the values in `face.glyph.metrics'. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Load_Char( FT_Face face,
FT_ULong char_code,
FT_Int load_flags );
FT_EXPORT( FT_Error ) FT_Load_Char( FT_Face face,
FT_ULong char_code,
FT_Int load_flags );
/*************************************************************************/
@ -1927,9 +1927,9 @@
/* the transformation and is performed on the character size given in */
/* the last call to FT_Set_Char_Sizes() or FT_Set_Pixel_Sizes(). */
/* */
FT_EXPORT_DEF( void ) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta );
FT_EXPORT( void ) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta );
/*************************************************************************/
@ -1988,8 +1988,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Render_Glyph( FT_GlyphSlot slot,
FT_UInt render_mode );
FT_EXPORT( FT_Error ) FT_Render_Glyph( FT_GlyphSlot slot,
FT_UInt render_mode );
/*************************************************************************/
@ -2053,11 +2053,11 @@
/* kernings, are out of the scope of this API function -- they can be */
/* implemented through format-specific interfaces. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Get_Kerning( FT_Face face,
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_UInt kern_mode,
FT_Vector* kerning );
FT_EXPORT( FT_Error ) FT_Get_Kerning( FT_Face face,
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_UInt kern_mode,
FT_Vector* kerning );
/*************************************************************************/
@ -2095,10 +2095,10 @@
/* macro FT_CONFIG_OPTION_NO_GLYPH_NAMES is defined in */
/* `include/freetype/config/ftoptions.h' */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Get_Glyph_Name( FT_Face face,
FT_UInt glyph_index,
FT_Pointer buffer,
FT_UInt buffer_max );
FT_EXPORT( FT_Error ) FT_Get_Glyph_Name( FT_Face face,
FT_UInt glyph_index,
FT_Pointer buffer,
FT_UInt buffer_max );
/*************************************************************************/
@ -2122,8 +2122,8 @@
/* This function will return an error if no charmap in the face */
/* corresponds to the encoding queried here. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Select_Charmap( FT_Face face,
FT_Encoding encoding );
FT_EXPORT( FT_Error ) FT_Select_Charmap( FT_Face face,
FT_Encoding encoding );
/*************************************************************************/
@ -2147,8 +2147,8 @@
/* the face (i.e., if it is not listed in the face->charmaps[] */
/* table). */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Set_Charmap( FT_Face face,
FT_CharMap charmap );
FT_EXPORT( FT_Error ) FT_Set_Charmap( FT_Face face,
FT_CharMap charmap );
/*************************************************************************/
@ -2168,8 +2168,8 @@
/* <Return> */
/* The glyph index. 0 means `undefined character code'. */
/* */
FT_EXPORT_DEF( FT_UInt ) FT_Get_Char_Index( FT_Face face,
FT_ULong charcode );
FT_EXPORT( FT_UInt ) FT_Get_Char_Index( FT_Face face,
FT_ULong charcode );
/*************************************************************************/
@ -2195,9 +2195,9 @@
/* divide by zero; it simply returns `MaxInt' or `MinInt' depending */
/* on the signs of `a' and `b'. */
/* */
FT_EXPORT_DEF( FT_Long ) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c );
FT_EXPORT( FT_Long ) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c );
/*************************************************************************/
@ -2229,8 +2229,8 @@
/* _second_ argument of this function; this can make a great */
/* difference. */
/* */
FT_EXPORT_DEF( FT_Long ) FT_MulFix( FT_Long a,
FT_Long b );
FT_EXPORT( FT_Long ) FT_MulFix( FT_Long a,
FT_Long b );
/*************************************************************************/
@ -2256,8 +2256,8 @@
/* 32 bits, then the division is computed directly. Otherwise, we */
/* use a specialized version of the old FT_MulDiv64(). */
/* */
FT_EXPORT_DEF( FT_Long ) FT_DivFix( FT_Long a,
FT_Long b );
FT_EXPORT( FT_Long ) FT_DivFix( FT_Long a,
FT_Long b );
/*************************************************************************/
@ -2280,8 +2280,8 @@
/* <Note> */
/* The result is undefined if either `vector' or `matrix' is invalid. */
/* */
FT_EXPORT_DEF( void ) FT_Vector_Transform( FT_Vector* vec,
FT_Matrix* matrix );
FT_EXPORT( void ) FT_Vector_Transform( FT_Vector* vec,
FT_Matrix* matrix );
/* */

4
include/freetype/ftbbox.h
View File

@ -58,8 +58,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Outline_Get_BBox( FT_Outline* outline,
FT_BBox* bbox );
FT_EXPORT( FT_Error ) FT_Outline_Get_BBox( FT_Outline* outline,
FT_BBox* bbox );
#ifdef __cplusplus

34
include/freetype/ftcache.h
View File

@ -194,13 +194,13 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FTC_Manager_New( FT_Library library,
FT_UInt max_faces,
FT_UInt max_sizes,
FT_ULong max_bytes,
FTC_Face_Requester requester,
FT_Pointer req_data,
FTC_Manager* amanager );
FT_EXPORT( FT_Error ) FTC_Manager_New( FT_Library library,
FT_UInt max_faces,
FT_UInt max_sizes,
FT_ULong max_bytes,
FTC_Face_Requester requester,
FT_Pointer req_data,
FTC_Manager* amanager );
/*************************************************************************/
@ -215,7 +215,7 @@
/* <Input> */
/* manager :: A handle to the manager. */
/* */
FT_EXPORT_DEF( void ) FTC_Manager_Reset( FTC_Manager manager );
FT_EXPORT( void ) FTC_Manager_Reset( FTC_Manager manager );
/*************************************************************************/
@ -229,7 +229,7 @@
/* <Input> */
/* manager :: A handle to the target cache manager object. */
/* */
FT_EXPORT_DEF( void ) FTC_Manager_Done( FTC_Manager manager );
FT_EXPORT( void ) FTC_Manager_Done( FTC_Manager manager );
/*************************************************************************/
@ -264,9 +264,9 @@
/* the FT_Set_Transform() function) on a returned face! If you need */
/* to transform glyphs, do it yourself after glyph loading. */
/* */
FT_EXPORT_DEF( FT_Error ) FTC_Manager_Lookup_Face( FTC_Manager manager,
FTC_FaceID face_id,
FT_Face* aface );
FT_EXPORT( FT_Error ) FTC_Manager_Lookup_Face( FTC_Manager manager,
FTC_FaceID face_id,
FT_Face* aface );
/*************************************************************************/
@ -308,10 +308,10 @@
/* The returned size object is the face's current size, which means */
/* that you can call FT_Load_Glyph() with the face if you need to. */
/* */
FT_EXPORT_DEF( FT_Error ) FTC_Manager_Lookup_Size( FTC_Manager manager,
FTC_Font font,
FT_Face* aface,
FT_Size* asize );
FT_EXPORT( FT_Error ) FTC_Manager_Lookup_Size( FTC_Manager manager,
FTC_Font font,
FT_Face* aface,
FT_Size* asize );
/* a cache class is used to describe a unique cache type to the manager */
@ -320,7 +320,7 @@
/* this must be used internally for the moment */
FT_EXPORT_DEF( FT_Error ) FTC_Manager_Register_Cache(
FT_EXPORT( FT_Error ) FTC_Manager_Register_Cache(
FTC_Manager manager,
FTC_Cache_Class* clazz,
FTC_Cache* acache );

36
include/freetype/ftglyph.h
View File

@ -161,8 +161,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Get_Glyph( FT_GlyphSlot slot,
FT_Glyph* aglyph );
FT_EXPORT( FT_Error ) FT_Get_Glyph( FT_GlyphSlot slot,
FT_Glyph* aglyph );
/*************************************************************************/
@ -183,8 +183,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Glyph_Copy( FT_Glyph source,
FT_Glyph* target );
FT_EXPORT( FT_Error ) FT_Glyph_Copy( FT_Glyph source,
FT_Glyph* target );
/*************************************************************************/
@ -211,9 +211,9 @@
/* The 2x2 transformation matrix is also applied to the glyph's */
/* advance vector. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Glyph_Transform( FT_Glyph glyph,
FT_Matrix* matrix,
FT_Vector* delta );
FT_EXPORT( FT_Error ) FT_Glyph_Transform( FT_Glyph glyph,
FT_Matrix* matrix,
FT_Vector* delta );
enum
@ -279,9 +279,9 @@
/* */
/* The default value for `bbox_mode' is `ft_glyph_bbox_pixels'. */
/* */
FT_EXPORT_DEF( void ) FT_Glyph_Get_CBox( FT_Glyph glyph,
FT_UInt bbox_mode,
FT_BBox* cbox );
FT_EXPORT( void ) FT_Glyph_Get_CBox( FT_Glyph glyph,
FT_UInt bbox_mode,
FT_BBox* cbox );
/*************************************************************************/
@ -355,10 +355,10 @@
/* This function will always fail if the glyph's format isn't */
/* scalable. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Glyph_To_Bitmap( FT_Glyph* the_glyph,
FT_ULong render_mode,
FT_Vector* origin,
FT_Bool destroy );
FT_EXPORT( FT_Error ) FT_Glyph_To_Bitmap( FT_Glyph* the_glyph,
FT_ULong render_mode,
FT_Vector* origin,
FT_Bool destroy );
/*************************************************************************/
@ -372,7 +372,7 @@
/* <Input> */
/* glyph :: A handle to the target glyph object. */
/* */
FT_EXPORT_DEF( void ) FT_Done_Glyph( FT_Glyph glyph );
FT_EXPORT( void ) FT_Done_Glyph( FT_Glyph glyph );
/* other helpful functions */
@ -398,8 +398,8 @@
/* <Note> */
/* The result is undefined if either `a' or `b' is zero. */
/* */
FT_EXPORT_DEF( void ) FT_Matrix_Multiply( FT_Matrix* a,
FT_Matrix* b );
FT_EXPORT( void ) FT_Matrix_Multiply( FT_Matrix* a,
FT_Matrix* b );
/*************************************************************************/
@ -420,7 +420,7 @@
/* <MT-Note> */
/* Yes. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Matrix_Invert( FT_Matrix* matrix );
FT_EXPORT( FT_Error ) FT_Matrix_Invert( FT_Matrix* matrix );
#ifdef __cplusplus

34
include/freetype/ftlist.h
View File

@ -34,20 +34,20 @@
#endif
FT_EXPORT_DEF( FT_ListNode ) FT_List_Find( FT_List list,
void* data );
FT_EXPORT( FT_ListNode ) FT_List_Find( FT_List list,
void* data );
FT_EXPORT_DEF( void ) FT_List_Add( FT_List list,
FT_ListNode node );
FT_EXPORT( void ) FT_List_Add ( FT_List list,
FT_ListNode node );
FT_EXPORT_DEF( void ) FT_List_Insert( FT_List list,
FT_ListNode node );
FT_EXPORT( void ) FT_List_Insert ( FT_List list,
FT_ListNode node );
FT_EXPORT_DEF( void ) FT_List_Remove( FT_List list,
FT_ListNode node );
FT_EXPORT( void ) FT_List_Remove ( FT_List list,
FT_ListNode node );
FT_EXPORT_DEF( void ) FT_List_Up( FT_List list,
FT_ListNode node );
FT_EXPORT( void ) FT_List_Up ( FT_List list,
FT_ListNode node );
/*************************************************************************/
@ -69,9 +69,9 @@
void* user );
FT_EXPORT_DEF( FT_Error ) FT_List_Iterate( FT_List list,
FT_List_Iterator iterator,
void* user );
FT_EXPORT( FT_Error ) FT_List_Iterate( FT_List list,
FT_List_Iterator iterator,
void* user );
/*************************************************************************/
@ -97,10 +97,10 @@
void* user );
FT_EXPORT_DEF( void ) FT_List_Finalize( FT_List list,
FT_List_Destructor destroy,
FT_Memory memory,
void* user );
FT_EXPORT( void ) FT_List_Finalize( FT_List list,
FT_List_Destructor destroy,
FT_Memory memory,
void* user );
#ifdef __cplusplus

2
include/freetype/ftmac.h
View File

@ -59,7 +59,7 @@
/* fond = GetResource( 'FOND', fontName ); */
/* error = FT_New_Face_From_FOND( library, fond, 0, &face ); */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Face_From_FOND(
FT_EXPORT_DEF( FT_Error ) FT_New_Face_From_FOND(
FT_Library library,
Handle fond,
FT_Long face_index,

8
include/freetype/ftmm.h
View File

@ -108,8 +108,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Get_Multi_Master( FT_Face face,
FT_Multi_Master* master );
FT_EXPORT( FT_Error ) FT_Get_Multi_Master( FT_Face face,
FT_Multi_Master* master );
/*************************************************************************/
@ -132,7 +132,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Set_MM_Design_Coordinates(
FT_EXPORT( FT_Error ) FT_Set_MM_Design_Coordinates(
FT_Face face,
FT_UInt num_coords,
FT_Long* coords );
@ -159,7 +159,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Set_MM_Blend_Coordinates(
FT_EXPORT( FT_Error ) FT_Set_MM_Blend_Coordinates(
FT_Face face,
FT_UInt num_coords,
FT_Fixed* coords );

26
include/freetype/ftmodule.h
View File

@ -123,8 +123,8 @@
/* An error will be returned if a module already exists by that name, */
/* or if the module requires a version of FreeType that is too great. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Add_Module( FT_Library library,
const FT_Module_Class* clazz );
FT_EXPORT( FT_Error ) FT_Add_Module( FT_Library library,
const FT_Module_Class* clazz );
/*************************************************************************/
@ -147,8 +147,8 @@
/* You should better be familiar with FreeType internals to know */
/* which module to look for :-) */
/* */
FT_EXPORT_DEF( FT_Module ) FT_Get_Module( FT_Library library,
const char* module_name );
FT_EXPORT( FT_Module ) FT_Get_Module( FT_Library library,
const char* module_name );
/*************************************************************************/
@ -170,8 +170,8 @@
/* <Note> */
/* The module object is destroyed by the function in case of success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Remove_Module( FT_Library library,
FT_Module module );
FT_EXPORT( FT_Error ) FT_Remove_Module( FT_Library library,
FT_Module module );
/*************************************************************************/
@ -193,8 +193,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_New_Library( FT_Memory memory,
FT_Library* library );
FT_EXPORT( FT_Error ) FT_New_Library( FT_Memory memory,
FT_Library* library );
/*************************************************************************/
@ -212,7 +212,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Done_Library( FT_Library library );
FT_EXPORT( FT_Error ) FT_Done_Library( FT_Library library );
@ -241,9 +241,9 @@
/* Currently, four debug hook slots are available, but only two (for */
/* the TrueType and the Type 1 interpreter) are defined. */
/* */
FT_EXPORT_DEF( void ) FT_Set_Debug_Hook( FT_Library library,
FT_UInt hook_index,
FT_DebugHook_Func debug_hook );
FT_EXPORT( void ) FT_Set_Debug_Hook( FT_Library library,
FT_UInt hook_index,
FT_DebugHook_Func debug_hook );
@ -260,7 +260,7 @@
/* <InOut> */
/* library :: A handle to a new library object. */
/* */
FT_EXPORT_DEF( void ) FT_Add_Default_Modules( FT_Library library );
FT_EXPORT( void ) FT_Add_Default_Modules( FT_Library library );
#ifdef __cplusplus

8
include/freetype/ftnames.h
View File

@ -86,7 +86,7 @@
/* <Return> */
/* The number of strings in the `name' table. */
/* */
FT_EXPORT_DEF( FT_UInt ) FT_Get_Sfnt_Name_Count( FT_Face face );
FT_EXPORT( FT_UInt ) FT_Get_Sfnt_Name_Count( FT_Face face );
/*************************************************************************/
@ -116,9 +116,9 @@
/* `name' table entries, then do a loop until you get the right */
/* platform, encoding, and name ID. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Get_Sfnt_Name( FT_Face face,
FT_UInt index,
FT_SfntName* aname );
FT_EXPORT( FT_Error ) FT_Get_Sfnt_Name( FT_Face face,
FT_UInt index,
FT_SfntName* aname );
#ifdef __cplusplus

52
include/freetype/ftoutln.h
View File

@ -52,7 +52,7 @@
/* <Return> */
/* FreeType error code. 0 means sucess. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Outline_Decompose(
FT_EXPORT( FT_Error ) FT_Outline_Decompose(
FT_Outline* outline,
const FT_Outline_Funcs* interface,
void* user );
@ -90,13 +90,13 @@
/* The reason why this function takes a `library' parameter is simply */
/* to use the library's memory allocator. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Outline_New( FT_Library library,
FT_UInt numPoints,
FT_Int numContours,
FT_Outline* outline );
FT_EXPORT( FT_Error ) FT_Outline_New( FT_Library library,
FT_UInt numPoints,
FT_Int numContours,
FT_Outline* outline );
FT_EXPORT_DEF( FT_Error ) FT_Outline_New_Internal(
FT_EXPORT( FT_Error ) FT_Outline_New_Internal(
FT_Memory memory,
FT_UInt numPoints,
FT_Int numContours,
@ -130,12 +130,12 @@
/* The reason why this function takes an `outline' parameter is */
/* simply to use FT_Free(). */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Outline_Done( FT_Library library,
FT_Outline* outline );
FT_EXPORT( FT_Error ) FT_Outline_Done( FT_Library library,
FT_Outline* outline );
FT_EXPORT_DEF( FT_Error ) FT_Outline_Done_Internal( FT_Memory memory,
FT_Outline* outline );
FT_EXPORT( FT_Error ) FT_Outline_Done_Internal( FT_Memory memory,
FT_Outline* outline );
/*************************************************************************/
@ -164,8 +164,8 @@
/* <MT-Note> */
/* Yes. */
/* */
FT_EXPORT_DEF( void ) FT_Outline_Get_CBox( FT_Outline* outline,
FT_BBox* cbox );
FT_EXPORT( void ) FT_Outline_Get_CBox( FT_Outline* outline,
FT_BBox* cbox );
/*************************************************************************/
@ -186,9 +186,9 @@
/* <MT-Note> */
/* Yes. */
/* */
FT_EXPORT_DEF( void ) FT_Outline_Translate( FT_Outline* outline,
FT_Pos xOffset,
FT_Pos yOffset );
FT_EXPORT( void ) FT_Outline_Translate( FT_Outline* outline,
FT_Pos xOffset,
FT_Pos yOffset );
/*************************************************************************/
@ -210,8 +210,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Outline_Copy( FT_Outline* source,
FT_Outline* target );
FT_EXPORT( FT_Error ) FT_Outline_Copy( FT_Outline* source,
FT_Outline* target );
/*************************************************************************/
@ -234,8 +234,8 @@
/* <Note> */
/* The result is undefined if either `vector' or `matrix' is invalid. */
/* */
FT_EXPORT_DEF( void ) FT_Outline_Transform( FT_Outline* outline,
FT_Matrix* matrix );
FT_EXPORT( void ) FT_Outline_Transform( FT_Outline* outline,
FT_Matrix* matrix );
/*************************************************************************/
@ -257,7 +257,7 @@
/* It shouldn't be used by a normal client application, unless it */
/* knows what it is doing. */
/* */
FT_EXPORT_DEF( void ) FT_Outline_Reverse( FT_Outline* outline );
FT_EXPORT( void ) FT_Outline_Reverse( FT_Outline* outline );
/*************************************************************************/
@ -289,9 +289,9 @@
/* */
/* It will use the raster correponding to the default glyph format. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Outline_Get_Bitmap( FT_Library library,
FT_Outline* outline,
FT_Bitmap* bitmap );
FT_EXPORT( FT_Error ) FT_Outline_Get_Bitmap( FT_Library library,
FT_Outline* outline,
FT_Bitmap* bitmap );
/*************************************************************************/
@ -328,9 +328,9 @@
/* converter is called, which means that the value you give to it is */
/* actually ignored. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Outline_Render( FT_Library library,
FT_Outline* outline,
FT_Raster_Params* params );
FT_EXPORT( FT_Error ) FT_Outline_Render( FT_Library library,
FT_Outline* outline,
FT_Raster_Params* params );
#ifdef __cplusplus

12
include/freetype/ftrender.h
View File

@ -144,8 +144,8 @@
/* To add a new renderer, simply use FT_Add_Module(). To retrieve a */
/* renderer by its name, use FT_Get_Module(). */
/* */
FT_EXPORT_DEF( FT_Renderer ) FT_Get_Renderer( FT_Library library,
FT_Glyph_Format format );
FT_EXPORT( FT_Renderer ) FT_Get_Renderer( FT_Library library,
FT_Glyph_Format format );
/*************************************************************************/
@ -174,10 +174,10 @@
/* */
/* This doesn't change the current renderer for other formats. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Set_Renderer( FT_Library library,
FT_Renderer renderer,
FT_UInt num_params,
FT_Parameter* parameters );
FT_EXPORT( FT_Error ) FT_Set_Renderer( FT_Library library,
FT_Renderer renderer,
FT_UInt num_params,
FT_Parameter* parameters );
#ifdef __cplusplus

12
include/freetype/ftsynth.h
View File

@ -48,13 +48,13 @@
/* This code is completely experimental -- use with care! */
/* It will probably be completely rewritten in the future */
/* or even integrated into the library. */
FT_EXPORT_DEF( FT_Error ) FT_Outline_Embolden( FT_GlyphSlot original,
FT_Outline* outline,
FT_Pos* advance );
FT_EXPORT( FT_Error ) FT_Outline_Embolden( FT_GlyphSlot original,
FT_Outline* outline,
FT_Pos* advance );
FT_EXPORT_DEF( FT_Error ) FT_Outline_Oblique( FT_GlyphSlot original,
FT_Outline* outline,
FT_Pos* advance );
FT_EXPORT( FT_Error ) FT_Outline_Oblique( FT_GlyphSlot original,
FT_Outline* outline,
FT_Pos* advance );
#ifdef __cplusplus

24
include/freetype/internal/ftcalc.h
View File

@ -40,7 +40,7 @@
#define SQRT_64( z ) FT_Sqrt64( z )
FT_EXPORT_DEF( FT_Int32 ) FT_Sqrt64( FT_Int64 l );
FT_EXPORT( FT_Int32 ) FT_Sqrt64( FT_Int64 l );
#endif /* FT_CONFIG_OPTION_OLD_CALCS */
@ -60,25 +60,25 @@
#define MUL_64( x, y, z ) FT_MulTo64( x, y, &z )
#define DIV_64( x, y ) FT_Div64by32( &x, y )
FT_EXPORT_DEF( void ) FT_Add64( FT_Int64* x,
FT_Int64* y,
FT_Int64* z );
FT_EXPORT( void ) FT_Add64( FT_Int64* x,
FT_Int64* y,
FT_Int64* z );
FT_EXPORT_DEF( void ) FT_MulTo64( FT_Int32 x,
FT_Int32 y,
FT_Int64* z );
FT_EXPORT( void ) FT_MulTo64( FT_Int32 x,
FT_Int32 y,
FT_Int64* z );
FT_EXPORT_DEF( FT_Int32 ) FT_Div64by32( FT_Int64* x,
FT_Int32 y );
FT_EXPORT( FT_Int32 ) FT_Div64by32( FT_Int64* x,
FT_Int32 y );
#ifdef FT_CONFIG_OPTION_OLD_CALCS
FT_EXPORT_DEF( FT_Int32 ) FT_SqrtFixed( FT_Int32 x );
FT_EXPORT( FT_Int32 ) FT_SqrtFixed( FT_Int32 x );
#define SQRT_64( z ) FT_Sqrt64( &z )
FT_EXPORT_DEF( FT_Int32 ) FT_Sqrt64( FT_Int64* x );
FT_EXPORT( FT_Int32 ) FT_Sqrt64( FT_Int64* x );
#endif /* FT_CONFIG_OPTION_OLD_CALCS */
@ -90,7 +90,7 @@
#define SQRT_32( x ) FT_Sqrt32( x )
BASE_DEF( FT_Int32 ) FT_Sqrt32( FT_Int32 x );
FT_BASE( FT_Int32 ) FT_Sqrt32( FT_Int32 x );
#endif /* !FT_CONFIG_OPTION_OLD_CALCS */

8
include/freetype/internal/ftdebug.h
View File

@ -138,8 +138,8 @@
} while ( 0 )
FT_EXPORT_DEF( void ) FT_SetTraceLevel( FT_Trace component,
char level );
FT_EXPORT( void ) FT_SetTraceLevel( FT_Trace component,
char level );
#elif defined( FT_DEBUG_LEVEL_ERROR )
@ -185,10 +185,10 @@
} while ( 0 )
/* print a message */
FT_EXPORT_DEF( void ) FT_Message( const char* fmt, ... );
FT_EXPORT( void ) FT_Message( const char* fmt, ... );
/* print a message and exit */
FT_EXPORT_DEF( void ) FT_Panic( const char* fmt, ... );
FT_EXPORT( void ) FT_Panic( const char* fmt, ... );
#define FT_ERROR( varformat ) FT_XCAT( FT_Message, varformat )

12
include/freetype/internal/ftextend.h
View File

@ -130,7 +130,7 @@
} FT_Extension_Class;
FT_EXPORT_DEF( FT_Error ) FT_Register_Extension(
FT_EXPORT( FT_Error ) FT_Register_Extension(
FT_Driver driver,
FT_Extension_Class* clazz );
@ -139,21 +139,21 @@
/* Initialize the extension component */
LOCAL_DEF
FT_LOCAL
FT_Error FT_Init_Extensions( FT_Library library );
/* Finalize the extension component */
LOCAL_DEF
FT_LOCAL
FT_Error FT_Done_Extensions( FT_Library library );
/* Create an extension within a face object. Called by the */
/* face object constructor. */
LOCAL_DEF
FT_LOCAL
FT_Error FT_Create_Extensions( FT_Face face );
/* Destroy all extensions within a face object. Called by the */
/* face object destructor. */
LOCAL_DEF
FT_LOCAL
FT_Error FT_Destroy_Extensions( FT_Face face );
@ -161,7 +161,7 @@
/* return an extension's data & interface according to its ID */
FT_EXPORT_DEF( void* ) FT_Get_Extension(
FT_EXPORT( void* ) FT_Get_Extension(
FT_Face face,
const char* extension_id,
void** extension_interface );

18
include/freetype/internal/ftmemory.h
View File

@ -56,17 +56,17 @@
/*************************************************************************/
/*************************************************************************/
BASE_DEF( FT_Error ) FT_Alloc( FT_Memory memory,
FT_Long size,
void** P );
FT_BASE( FT_Error ) FT_Alloc( FT_Memory memory,
FT_Long size,
void** P );
BASE_DEF( FT_Error ) FT_Realloc( FT_Memory memory,
FT_Long current,
FT_Long size,
void** P );
FT_BASE( FT_Error ) FT_Realloc( FT_Memory memory,
FT_Long current,
FT_Long size,
void** P );
BASE_DEF( void ) FT_Free( FT_Memory memory,
void** P );
FT_BASE( void ) FT_Free( FT_Memory memory,
void** P );

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

@ -165,8 +165,8 @@
/* You should better be familiar with FreeType internals to know */
/* which module to look for, and what its interface is :-) */
/* */
BASE_DEF( const void* ) FT_Get_Module_Interface( FT_Library library,
const char* mod_name );
FT_BASE( const void* ) FT_Get_Module_Interface( FT_Library library,
const char* mod_name );
/*************************************************************************/
@ -201,17 +201,17 @@
/* this must be kept exported -- tt will be used later in our own */
/* high-level caching font manager called SemTex (way after the */
/* 2.0 release though */
FT_EXPORT_DEF( FT_Error ) FT_New_Size( FT_Face face,
FT_Size* size );
FT_EXPORT( FT_Error ) FT_New_Size( FT_Face face,
FT_Size* size );
FT_EXPORT_DEF( FT_Error ) FT_Done_Size( FT_Size size );
FT_EXPORT( FT_Error ) FT_Done_Size( FT_Size size );
BASE_DEF( FT_Error ) FT_New_GlyphSlot( FT_Face face,
FT_GlyphSlot* aslot );
FT_BASE( FT_Error ) FT_New_GlyphSlot( FT_Face face,
FT_GlyphSlot* aslot );
BASE_DEF( void ) FT_Done_GlyphSlot( FT_GlyphSlot slot );
FT_BASE( void ) FT_Done_GlyphSlot( FT_GlyphSlot slot );
/*************************************************************************/
@ -278,33 +278,33 @@
};
BASE_DEF( FT_Error ) FT_GlyphLoader_New( FT_Memory memory,
FT_GlyphLoader** aloader );
FT_BASE( FT_Error ) FT_GlyphLoader_New( FT_Memory memory,
FT_GlyphLoader** aloader );
BASE_DEF( FT_Error ) FT_GlyphLoader_Create_Extra(
FT_GlyphLoader* loader );
FT_BASE( FT_Error ) FT_GlyphLoader_Create_Extra(
FT_GlyphLoader* loader );
BASE_DEF( void ) FT_GlyphLoader_Done( FT_GlyphLoader* loader );
FT_BASE( void ) FT_GlyphLoader_Done( FT_GlyphLoader* loader );
BASE_DEF( void ) FT_GlyphLoader_Reset( FT_GlyphLoader* loader );
FT_BASE( void ) FT_GlyphLoader_Reset( FT_GlyphLoader* loader );
BASE_DEF( void ) FT_GlyphLoader_Rewind( FT_GlyphLoader* loader );
FT_BASE( void ) FT_GlyphLoader_Rewind( FT_GlyphLoader* loader );
BASE_DEF( FT_Error ) FT_GlyphLoader_Check_Points(
FT_BASE( FT_Error ) FT_GlyphLoader_Check_Points(
FT_GlyphLoader* loader,
FT_UInt n_points,
FT_UInt n_contours );
BASE_DEF( FT_Error ) FT_GlyphLoader_Check_Subglyphs(
FT_BASE( FT_Error ) FT_GlyphLoader_Check_Subglyphs(
FT_GlyphLoader* loader,
FT_UInt n_subs );
BASE_DEF( void ) FT_GlyphLoader_Prepare( FT_GlyphLoader* loader );
FT_BASE( void ) FT_GlyphLoader_Prepare( FT_GlyphLoader* loader );
BASE_DEF( void ) FT_GlyphLoader_Add( FT_GlyphLoader* loader );
FT_BASE( void ) FT_GlyphLoader_Add( FT_GlyphLoader* loader );
BASE_DEF( FT_Error ) FT_GlyphLoader_Copy_Points( FT_GlyphLoader* target,
FT_GlyphLoader* source );
FT_BASE( FT_Error ) FT_GlyphLoader_Copy_Points( FT_GlyphLoader* target,
FT_GlyphLoader* source );
/*************************************************************************/
@ -483,11 +483,11 @@
} FT_LibraryRec;
BASE_DEF( FT_Renderer ) FT_Lookup_Renderer( FT_Library library,
FT_BASE( FT_Renderer ) FT_Lookup_Renderer( FT_Library library,
FT_Glyph_Format format,
FT_ListNode* node );
BASE_DEF( FT_Error ) FT_Render_Glyph_Internal( FT_Library library,
FT_BASE( FT_Error ) FT_Render_Glyph_Internal( FT_Library library,
FT_GlyphSlot slot,
FT_UInt render_mode );
@ -499,14 +499,14 @@
#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
FT_EXPORT_DEF( FT_Error ) FT_New_Stream( const char* filepathname,
FT_Stream astream );
FT_EXPORT( FT_Error ) FT_New_Stream( const char* filepathname,
FT_Stream astream );
FT_EXPORT_DEF( void ) FT_Done_Stream( FT_Stream stream );
FT_EXPORT( void ) FT_Done_Stream( FT_Stream stream );
FT_EXPORT_DEF( FT_Memory ) FT_New_Memory( void );
FT_EXPORT( FT_Memory ) FT_New_Memory( void );
FT_EXPORT_DEF( void ) FT_Done_Memory( FT_Memory memory );
FT_EXPORT( void ) FT_Done_Memory( FT_Memory memory );
#endif /* !FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */

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

@ -243,75 +243,75 @@
#define READ_ULongLE( var ) FT_READ_MACRO( FT_Read_LongLE, FT_ULong, var )
BASE_DEF( void ) FT_New_Memory_Stream( FT_Library library,
FT_Byte* base,
FT_ULong size,
FT_Stream stream );
FT_BASE( void ) FT_New_Memory_Stream( FT_Library library,
FT_Byte* base,
FT_ULong size,
FT_Stream stream );
BASE_DEF( FT_Error ) FT_Seek_Stream( FT_Stream stream,
FT_ULong pos );
FT_BASE( FT_Error ) FT_Seek_Stream( FT_Stream stream,
FT_ULong pos );
BASE_DEF( FT_Error ) FT_Skip_Stream( FT_Stream stream,
FT_Long distance );
FT_BASE( FT_Error ) FT_Skip_Stream( FT_Stream stream,
FT_Long distance );
BASE_DEF( FT_Long ) FT_Stream_Pos( FT_Stream stream );
FT_BASE( FT_Long ) FT_Stream_Pos( FT_Stream stream );
BASE_DEF( FT_Error ) FT_Read_Stream( FT_Stream stream,
FT_BASE( FT_Error ) FT_Read_Stream( FT_Stream stream,
FT_Byte* buffer,
FT_ULong count );
BASE_DEF( FT_Error ) FT_Read_Stream_At( FT_Stream stream,
FT_ULong pos,
FT_Byte* buffer,
FT_ULong count );
FT_BASE( FT_Error ) FT_Read_Stream_At( FT_Stream stream,
FT_ULong pos,
FT_Byte* buffer,
FT_ULong count );
BASE_DEF( FT_Error ) FT_Access_Frame( FT_Stream stream,
FT_ULong count );
FT_BASE( FT_Error ) FT_Access_Frame( FT_Stream stream,
FT_ULong count );
BASE_DEF( void ) FT_Forget_Frame( FT_Stream stream );
FT_BASE( void ) FT_Forget_Frame( FT_Stream stream );
BASE_DEF( FT_Error ) FT_Extract_Frame( FT_Stream stream,
FT_ULong count,
FT_Byte** pbytes );
FT_BASE( FT_Error ) FT_Extract_Frame( FT_Stream stream,
FT_ULong count,
FT_Byte** pbytes );
BASE_DEF( void ) FT_Release_Frame( FT_Stream stream,
FT_Byte** pbytes );
FT_BASE( void ) FT_Release_Frame( FT_Stream stream,
FT_Byte** pbytes );
BASE_DEF( FT_Char ) FT_Get_Char( FT_Stream stream );
FT_BASE( FT_Char ) FT_Get_Char( FT_Stream stream );
BASE_DEF( FT_Short ) FT_Get_Short( FT_Stream stream );
FT_BASE( FT_Short ) FT_Get_Short( FT_Stream stream );
BASE_DEF( FT_Long ) FT_Get_Offset( FT_Stream stream );
FT_BASE( FT_Long ) FT_Get_Offset( FT_Stream stream );
BASE_DEF( FT_Long ) FT_Get_Long( FT_Stream stream );
FT_BASE( FT_Long ) FT_Get_Long( FT_Stream stream );
BASE_DEF( FT_Short ) FT_Get_ShortLE( FT_Stream stream );
FT_BASE( FT_Short ) FT_Get_ShortLE( FT_Stream stream );
BASE_DEF( FT_Long ) FT_Get_LongLE( FT_Stream stream );
FT_BASE( FT_Long ) FT_Get_LongLE( FT_Stream stream );
BASE_DEF( FT_Char ) FT_Read_Char( FT_Stream stream,
FT_Error* error );
FT_BASE( FT_Char ) FT_Read_Char( FT_Stream stream,
FT_Error* error );
BASE_DEF( FT_Short ) FT_Read_Short( FT_Stream stream,
FT_BASE( FT_Short ) FT_Read_Short( FT_Stream stream,
FT_Error* error );
FT_BASE( FT_Long ) FT_Read_Offset( FT_Stream stream,
FT_Error* error );
BASE_DEF( FT_Long ) FT_Read_Offset( FT_Stream stream,
FT_Error* error );
BASE_DEF( FT_Long ) FT_Read_Long( FT_Stream stream,
FT_BASE( FT_Long ) FT_Read_Long( FT_Stream stream,
FT_Error* error );
BASE_DEF( FT_Short ) FT_Read_ShortLE( FT_Stream stream,
FT_BASE( FT_Short ) FT_Read_ShortLE( FT_Stream stream,
FT_Error* error );
BASE_DEF( FT_Long ) FT_Read_LongLE( FT_Stream stream,
FT_BASE( FT_Long ) FT_Read_LongLE( FT_Stream stream,
FT_Error* error );
BASE_DEF( FT_Error ) FT_Read_Fields( FT_Stream stream,
const FT_Frame_Field* fields,
void* structure );
FT_BASE( FT_Error ) FT_Read_Fields( FT_Stream stream,
const FT_Frame_Field* fields,
void* structure );
#define USE_Stream( resource, stream ) \

4
include/freetype/tttables.h
View File

@ -569,8 +569,8 @@
/* You can load any table using the (internal) SFNT_Interface */
/* structure -- this is available via FT_Get_Module_Interface(). */
/* */
FT_EXPORT_DEF( void* ) FT_Get_Sfnt_Table( FT_Face face,
FT_Sfnt_Tag tag );
FT_EXPORT( void* ) FT_Get_Sfnt_Table( FT_Face face,
FT_Sfnt_Tag tag );
#ifdef __cplusplus

2
src/autohint/ahangles.c
View File

@ -71,7 +71,7 @@
};
LOCAL_FUNC
FT_LOCAL_DEF
AH_Angle ah_angle( FT_Vector* v )
{
FT_Pos dx, dy;

2
src/autohint/ahangles.h
View File

@ -58,7 +58,7 @@
const AH_Angle ah_arctan[1L << AH_ATAN_BITS];
LOCAL_DEF
FT_LOCAL
AH_Angle ah_angle( FT_Vector* v );

2
src/autohint/ahglobal.c
View File

@ -391,7 +391,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error ah_hinter_compute_globals( AH_Hinter* hinter )
{
return ah_hinter_compute_widths( hinter ) ||

4
src/autohint/ahglobal.h
View File

@ -34,7 +34,7 @@
#endif
#include <freetype/internal/ftobjs.h> /* for LOCAL_DEF/LOCAL_FUNC */
#include <freetype/internal/ftobjs.h> /* for FT_LOCAL/FT_LOCAL_DEF */
#ifdef __cplusplus
@ -47,7 +47,7 @@
/* compute global metrics automatically */
LOCAL_DEF
FT_LOCAL
FT_Error ah_hinter_compute_globals( AH_Hinter* hinter );

20
src/autohint/ahglyph.c
View File

@ -206,7 +206,7 @@
/* <Description> */
/* Creates a new and empty AH_Outline object. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error ah_outline_new( FT_Memory memory,
AH_Outline** aoutline )
{
@ -232,7 +232,7 @@
/* <Description> */
/* Destroys a given AH_Outline object. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void ah_outline_done( AH_Outline* outline )
{
FT_Memory memory = outline->memory;
@ -256,7 +256,7 @@
/* Saves the content of a given AH_Outline object into a face's glyph */
/* slot. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void ah_outline_save( AH_Outline* outline,
AH_Loader* gloader )
{
@ -291,7 +291,7 @@
/* Loads an unscaled outline from a glyph slot into an AH_Outline */
/* object. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error ah_outline_load( AH_Outline* outline,
FT_Face face )
{
@ -545,7 +545,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void ah_setup_uv( AH_Outline* outline,
AH_UV source )
{
@ -599,7 +599,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void ah_outline_compute_segments( AH_Outline* outline )
{
int dimension;
@ -842,7 +842,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void ah_outline_link_segments( AH_Outline* outline )
{
AH_Segment* segments;
@ -1269,7 +1269,7 @@
/* <Description> */
/* Performs feature detection on a given AH_Outline object. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void ah_outline_detect_features( AH_Outline* outline )
{
ah_outline_compute_segments( outline );
@ -1287,7 +1287,7 @@
/* Computes the `blue edges' in a given outline (i.e. those that must */
/* be snapped to a blue zone edge (top or bottom). */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void ah_outline_compute_blue_edges( AH_Outline* outline,
AH_Face_Globals* face_globals )
{
@ -1383,7 +1383,7 @@
/* the contents of the detected edges (basically change the `blue */
/* edge' pointer from `design units' to `scaled ones'). */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void ah_outline_scale_blue_edges( AH_Outline* outline,
AH_Face_Globals* globals )
{

20
src/autohint/ahglyph.h
View File

@ -53,42 +53,42 @@
} AH_UV;
LOCAL_DEF
FT_LOCAL
void ah_setup_uv( AH_Outline* outline,
AH_UV source );
/* AH_Outline functions - they should be typically called in this order */
LOCAL_DEF
FT_LOCAL
FT_Error ah_outline_new( FT_Memory memory,
AH_Outline** aoutline );
LOCAL_DEF
FT_LOCAL
FT_Error ah_outline_load( AH_Outline* outline,
FT_Face face );
LOCAL_DEF
FT_LOCAL
void ah_outline_compute_segments( AH_Outline* outline );
LOCAL_DEF
FT_LOCAL
void ah_outline_link_segments( AH_Outline* outline );
LOCAL_DEF
FT_LOCAL
void ah_outline_detect_features( AH_Outline* outline );
LOCAL_DEF
FT_LOCAL
void ah_outline_compute_blue_edges( AH_Outline* outline,
AH_Face_Globals* globals );
LOCAL_DEF
FT_LOCAL
void ah_outline_scale_blue_edges( AH_Outline* outline,
AH_Face_Globals* globals );
LOCAL_DEF
FT_LOCAL
void ah_outline_save( AH_Outline* outline, AH_Loader* loader );
LOCAL_DEF
FT_LOCAL
void ah_outline_done( AH_Outline* outline );

12
src/autohint/ahhint.c
View File

@ -389,7 +389,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void ah_hinter_hint_edges( AH_Hinter* hinter,
int no_horz_edges,
int no_vert_edges )
@ -823,7 +823,7 @@
#endif /* !AH_OPTION_NO_WEAK_INTERPOLATION */
LOCAL_FUNC
FT_LOCAL_DEF
void ah_hinter_align_points( AH_Hinter* hinter )
{
ah_hinter_align_edge_points( hinter );
@ -912,6 +912,7 @@
/* finalize a hinter object */
FT_LOCAL_DEF
void ah_hinter_done( AH_Hinter* hinter )
{
if ( hinter )
@ -934,6 +935,7 @@
/* create a new empty hinter object */
FT_LOCAL_DEF
FT_Error ah_hinter_new( FT_Library library,
AH_Hinter** ahinter )
{
@ -969,6 +971,7 @@
/* create a face's autohint globals */
FT_LOCAL_DEF
FT_Error ah_hinter_new_face_globals( AH_Hinter* hinter,
FT_Face face,
AH_Globals* globals )
@ -1000,7 +1003,7 @@
/* discard a face's autohint globals */
LOCAL_FUNC
FT_LOCAL_DEF
void ah_hinter_done_face_globals( AH_Face_Globals* globals )
{
FT_Face face = globals->face;
@ -1298,6 +1301,7 @@
/* load and hint a given glyph */
FT_LOCAL_DEF
FT_Error ah_hinter_load_glyph( AH_Hinter* hinter,
FT_GlyphSlot slot,
FT_Size size,
@ -1344,6 +1348,7 @@
/* retrieve a face's autohint globals for client applications */
FT_LOCAL_DEF
void ah_hinter_get_global_hints( AH_Hinter* hinter,
FT_Face face,
void** global_hints,
@ -1380,6 +1385,7 @@
}
FT_LOCAL_DEF
void ah_hinter_done_global_hints( AH_Hinter* hinter,
void* global_hints )
{

7
src/autohint/ahhint.h
View File

@ -46,10 +46,12 @@
/* create a new empty hinter object */
FT_LOCAL
FT_Error ah_hinter_new( FT_Library library,
AH_Hinter** ahinter );
/* Load a hinted glyph in the hinter */
FT_LOCAL
FT_Error ah_hinter_load_glyph( AH_Hinter* hinter,
FT_GlyphSlot slot,
FT_Size size,
@ -57,16 +59,19 @@
FT_Int load_flags );
/* finalize a hinter object */
FT_LOCAL
void ah_hinter_done( AH_Hinter* hinter );
LOCAL_DEF
FT_LOCAL
void ah_hinter_done_face_globals( AH_Face_Globals* globals );
FT_LOCAL
void ah_hinter_get_global_hints( AH_Hinter* hinter,
FT_Face face,
void** global_hints,
long* global_len );
FT_LOCAL
void ah_hinter_done_global_hints( AH_Hinter* hinter,
void* global_hints );

20
src/autohint/ahloader.h
View File

@ -68,38 +68,38 @@
};
LOCAL_DEF
FT_LOCAL
FT_Error AH_GlyphLoader_New( FT_Memory memory,
AH_GlyphLoader** aloader );
LOCAL_DEF
FT_LOCAL
FT_Error AH_GlyphLoader_Create_Extra( AH_GlyphLoader* loader );
LOCAL_DEF
FT_LOCAL
void AH_GlyphLoader_Done( AH_GlyphLoader* loader );
LOCAL_DEF
FT_LOCAL
void AH_GlyphLoader_Reset( AH_GlyphLoader* loader );
LOCAL_DEF
FT_LOCAL
void AH_GlyphLoader_Rewind( AH_GlyphLoader* loader );
LOCAL_DEF
FT_LOCAL
FT_Error AH_GlyphLoader_Check_Points( AH_GlyphLoader* loader,
FT_UInt n_points,
FT_UInt n_contours );
LOCAL_DEF
FT_LOCAL
FT_Error AH_GlyphLoader_Check_Subglyphs( AH_GlyphLoader* loader,
FT_UInt n_subs );
LOCAL_DEF
FT_LOCAL
void AH_GlyphLoader_Prepare( AH_GlyphLoader* loader );
LOCAL_DEF
FT_LOCAL
void AH_GlyphLoader_Add( AH_GlyphLoader* loader );
LOCAL_DEF
FT_LOCAL
FT_Error AH_GlyphLoader_Copy_Points( AH_GlyphLoader* target,
FT_GlyphLoader* source );

17
src/autohint/ahmodule.c
View File

@ -41,21 +41,21 @@
} FT_AutoHinterRec;
static
FT_CALLBACK_DEF
FT_Error ft_autohinter_init( FT_AutoHinter module )
{
return ah_hinter_new( module->root.library, &module->hinter );
}
static
FT_CALLBACK_DEF
void ft_autohinter_done( FT_AutoHinter module )
{
ah_hinter_done( module->hinter );
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ft_autohinter_load( FT_AutoHinter module,
FT_GlyphSlot slot,
FT_Size size,
@ -67,7 +67,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ft_autohinter_reset( FT_AutoHinter module,
FT_Face face )
{
@ -78,7 +78,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ft_autohinter_get_globals( FT_AutoHinter module,
FT_Face face,
void** global_hints,
@ -89,7 +89,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ft_autohinter_done_globals( FT_AutoHinter module,
void* global_hints )
{
@ -97,7 +97,7 @@
}
static
FT_CALLBACK_TABLE_DEF
const FT_AutoHinter_Interface autohinter_interface =
{
ft_autohinter_reset,
@ -107,7 +107,8 @@
};
FT_CPLUSPLUS( const FT_Module_Class ) autohint_module_class =
FT_CALLBACK_TABLE_DEF
const FT_Module_Class autohint_module_class =
{
ft_module_hinter,
sizeof ( FT_AutoHinterRec ),

3
src/autohint/ahmodule.h
View File

@ -29,8 +29,7 @@
extern "C" {
#endif
FT_EXPORT_VAR( const FT_Module_Class ) autohint_module_class;
FT_CALLBACK_TABLE( const FT_Module_Class ) autohint_module_class;
#ifdef __cplusplus
}

2
src/autohint/ahtypes.h
View File

@ -24,7 +24,7 @@
#define AHTYPES_H
#include <freetype/internal/ftobjs.h> /* for freetype.h + LOCAL_DEF etc. */
#include <freetype/internal/ftobjs.h> /* for freetype.h + FT_LOCAL etc. */
#ifdef FT_FLAT_COMPILE

4
src/base/ftbbox.c
View File

@ -354,8 +354,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Outline_Get_BBox( FT_Outline* outline,
FT_BBox* abbox )
FT_EXPORT_DEF( FT_Error ) FT_Outline_Get_BBox( FT_Outline* outline,
FT_BBox* abbox )
{
FT_BBox cbox;
FT_BBox bbox;

54
src/base/ftcalc.c
View File

@ -82,7 +82,7 @@
/* <Return> */
/* The result of `sqrt(x)'. */
/* */
FT_EXPORT_FUNC( FT_Int32 ) FT_Sqrt32( FT_Int32 x )
FT_EXPORT_DEF( FT_Int32 ) FT_Sqrt32( FT_Int32 x )
{
FT_ULong val, root, newroot, mask;
@ -136,9 +136,9 @@
/* divide by zero; it simply returns `MaxInt' or `MinInt' depending */
/* on the signs of `a' and `b'. */
/* */
FT_EXPORT_FUNC( FT_Long ) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c )
FT_EXPORT_DEF( FT_Long ) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c )
{
FT_Int s;
@ -182,8 +182,8 @@
/* _second_ argument of this function; this can make a great */
/* difference. */
/* */
FT_EXPORT_FUNC( FT_Long ) FT_MulFix( FT_Long a,
FT_Long b )
FT_EXPORT_DEF( FT_Long ) FT_MulFix( FT_Long a,
FT_Long b )
{
FT_Int s;
@ -219,8 +219,8 @@
/* 32 bits, then the division is computed directly. Otherwise, we */
/* use a specialized version of the old FT_MulDiv64(). */
/* */
FT_EXPORT_FUNC( FT_Long ) FT_DivFix( FT_Long a,
FT_Long b )
FT_EXPORT_DEF( FT_Long ) FT_DivFix( FT_Long a,
FT_Long b )
{
FT_Int32 s;
FT_UInt32 q;
@ -275,7 +275,7 @@
/* <Return> */
/* The 32-bit square-root. */
/* */
FT_EXPORT_FUNC( FT_Int32 ) FT_Sqrt64( FT_Int64 l )
FT_EXPORT_DEF( FT_Int32 ) FT_Sqrt64( FT_Int64 l )
{
FT_Int64 r, s;
@ -296,7 +296,7 @@
}
FT_EXPORT_DEF( FT_Int32 ) FT_SqrtFixed( FT_Int32 x )
FT_EXPORT( FT_Int32 ) FT_SqrtFixed( FT_Int32 x )
{
FT_Int64 z;
@ -351,9 +351,9 @@
/* */
/* and 2*0x157F0 = 176096. */
/* */
FT_EXPORT_FUNC( FT_Long ) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c )
FT_EXPORT_DEF( FT_Long ) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c )
{
long s;
@ -418,8 +418,8 @@
/* idea is to use bounds like 2048 and 1048576 (=floor((2^31-1)/2048) */
/* for `a' and `b', respectively. */
/* */
FT_EXPORT_FUNC( FT_Long ) FT_MulFix( FT_Long a,
FT_Long b )
FT_EXPORT_DEF( FT_Long ) FT_MulFix( FT_Long a,
FT_Long b )
{
FT_Long s;
FT_ULong ua, ub;
@ -475,8 +475,8 @@
/* 32 bits, then the division is computed directly. Otherwise, we */
/* use a specialized version of the old FT_MulDiv64(). */
/* */
FT_EXPORT_FUNC( FT_Long ) FT_DivFix( FT_Long a,
FT_Long b )
FT_EXPORT_DEF( FT_Long ) FT_DivFix( FT_Long a,
FT_Long b )
{
FT_Int32 s;
FT_UInt32 q;
@ -530,9 +530,9 @@
/* <Note> */
/* Will be wrapped by the ADD_64() macro. */
/* */
FT_EXPORT_FUNC( void ) FT_Add64( FT_Int64* x,
FT_Int64* y,
FT_Int64* z )
FT_EXPORT_DEF( void ) FT_Add64( FT_Int64* x,
FT_Int64* y,
FT_Int64* z )
{
register FT_UInt32 lo, hi;
@ -563,9 +563,9 @@
/* <Note> */
/* Will be wrapped by the MUL_64() macro. */
/* */
FT_EXPORT_FUNC( void ) FT_MulTo64( FT_Int32 x,
FT_Int32 y,
FT_Int64* z )
FT_EXPORT_DEF( void ) FT_MulTo64( FT_Int32 x,
FT_Int32 y,
FT_Int64* z )
{
FT_Int32 s;
@ -628,8 +628,8 @@
/* <Note> */
/* Will be wrapped by the DIV_64() macro. */
/* */
FT_EXPORT_FUNC( FT_Int32 ) FT_Div64by32( FT_Int64* x,
FT_Int32 y )
FT_EXPORT_DEF( FT_Int32 ) FT_Div64by32( FT_Int64* x,
FT_Int32 y )
{
FT_Int32 s;
FT_UInt32 q, r, i, lo;
@ -741,7 +741,7 @@
/* <Return> */
/* The 32-bit square-root. */
/* */
FT_EXPORT_FUNC( FT_Int32 ) FT_Sqrt64( FT_Int64* l )
FT_EXPORT_DEF( FT_Int32 ) FT_Sqrt64( FT_Int64* l )
{
FT_Int64 l2;
FT_Int32 r, s;
@ -769,7 +769,7 @@
}
FT_EXPORT_DEF( FT_Int32 ) FT_SqrtFixed( FT_Int32 x )
FT_EXPORT( FT_Int32 ) FT_SqrtFixed( FT_Int32 x )
{
FT_Int64 z;

8
src/base/ftdebug.c
View File

@ -56,7 +56,7 @@
#include <string.h>
FT_EXPORT_FUNC( void ) FT_Message( const char* fmt, ... )
FT_EXPORT_DEF( void ) FT_Message( const char* fmt, ... )
{
va_list ap;
@ -67,7 +67,7 @@
}
FT_EXPORT_FUNC( void ) FT_Panic( const char* fmt, ... )
FT_EXPORT_DEF( void ) FT_Panic( const char* fmt, ... )
{
va_list ap;
@ -97,8 +97,8 @@
/* components will be traced. */
/* level :: The tracing level. */
/* */
FT_EXPORT_FUNC( void ) FT_SetTraceLevel( FT_Trace component,
char level )
FT_EXPORT_DEF( void ) FT_SetTraceLevel( FT_Trace component,
char level )
{
if ( component >= trace_max )
return;

12
src/base/ftextend.c
View File

@ -62,7 +62,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error FT_Init_Extensions( FT_Driver driver )
{
FT_Error error;
@ -98,7 +98,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error FT_Done_Extensions( FT_Driver driver )
{
FT_Memory memory = driver->root.memory;
@ -124,7 +124,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Register_Extension(
FT_EXPORT_DEF( FT_Error ) FT_Register_Extension(
FT_Driver driver,
FT_Extension_Class* clazz )
{
@ -183,7 +183,7 @@
/* <Return> */
/* A generic pointer to the extension block. */
/* */
FT_EXPORT_FUNC( void* ) FT_Get_Extension(
FT_EXPORT_DEF( void* ) FT_Get_Extension(
FT_Face face,
const char* extension_id,
void** extension_interface )
@ -239,7 +239,7 @@
/* <Note> */
/* Called by the face object destructor. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error FT_Destroy_Extensions( FT_Face face )
{
FT_Extension_Registry* registry;
@ -287,7 +287,7 @@
/* <Note> */
/* Called by the face object constructor. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error FT_Create_Extensions( FT_Face face )
{
FT_Extension_Registry* registry;

32
src/base/ftglyph.c
View File

@ -72,8 +72,8 @@
/* <Note> */
/* The result is undefined if either `a' or `b' is zero. */
/* */
FT_EXPORT_FUNC( void ) FT_Matrix_Multiply( FT_Matrix* a,
FT_Matrix* b )
FT_EXPORT_DEF( void ) FT_Matrix_Multiply( FT_Matrix* a,
FT_Matrix* b )
{
FT_Fixed xx, xy, yx, yy;
@ -109,7 +109,7 @@
/* <MT-Note> */
/* Yes. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Matrix_Invert( FT_Matrix* matrix )
FT_EXPORT_DEF( FT_Error ) FT_Matrix_Invert( FT_Matrix* matrix )
{
FT_Pos delta, xx, yy;
@ -423,7 +423,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Glyph_Copy( FT_Glyph source,
FT_EXPORT_DEF( FT_Error ) FT_Glyph_Copy( FT_Glyph source,
FT_Glyph* target )
{
FT_Glyph copy;
@ -475,8 +475,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Get_Glyph( FT_GlyphSlot slot,
FT_Glyph* aglyph )
FT_EXPORT_DEF( FT_Error ) FT_Get_Glyph( FT_GlyphSlot slot,
FT_Glyph* aglyph )
{
FT_Library library = slot->library;
FT_Error error;
@ -562,9 +562,9 @@
/* The 2x2 transformation matrix is also applied to the glyph's */
/* advance vector. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Glyph_Transform( FT_Glyph glyph,
FT_Matrix* matrix,
FT_Vector* delta )
FT_EXPORT_DEF( FT_Error ) FT_Glyph_Transform( FT_Glyph glyph,
FT_Matrix* matrix,
FT_Vector* delta )
{
const FT_Glyph_Class* clazz;
FT_Error error = FT_Err_Ok;
@ -644,9 +644,9 @@
/* */
/* The default value for `bbox_mode' is `ft_glyph_bbox_pixels'. */
/* */
FT_EXPORT_FUNC( void ) FT_Glyph_Get_CBox( FT_Glyph glyph,
FT_UInt bbox_mode,
FT_BBox* cbox )
FT_EXPORT_DEF( void ) FT_Glyph_Get_CBox( FT_Glyph glyph,
FT_UInt bbox_mode,
FT_BBox* cbox )
{
const FT_Glyph_Class* clazz;
FT_Error error = FT_Err_Ok;
@ -758,9 +758,9 @@
/* This function will always fail if the glyph's format isn't */
/* scalable. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Glyph_To_Bitmap( FT_Glyph* the_glyph,
FT_ULong render_mode,
FT_Vector* origin,
FT_EXPORT_DEF( FT_Error ) FT_Glyph_To_Bitmap( FT_Glyph* the_glyph,
FT_ULong render_mode,
FT_Vector* origin,
FT_Bool destroy )
{
FT_GlyphSlotRec dummy;
@ -855,7 +855,7 @@
/* <Input> */
/* glyph :: A handle to the target glyph object. */
/* */
FT_EXPORT_FUNC( void ) FT_Done_Glyph( FT_Glyph glyph )
FT_EXPORT_DEF( void ) FT_Done_Glyph( FT_Glyph glyph )
{
if ( glyph )
{

6
src/base/ftinit.c
View File

@ -85,7 +85,7 @@ const FT_Module_Class* const ft_default_modules[] =
/* <InOut> */
/* library :: A handle to a new library object. */
/* */
FT_EXPORT_FUNC( void ) FT_Add_Default_Modules( FT_Library library )
FT_EXPORT_DEF( void ) FT_Add_Default_Modules( FT_Library library )
{
FT_Error error;
const FT_Module_Class* const* cur;
@ -123,7 +123,7 @@ const FT_Module_Class* const ft_default_modules[] =
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Init_FreeType( FT_Library* library )
FT_EXPORT_DEF( FT_Error ) FT_Init_FreeType( FT_Library* library )
{
FT_Error error;
FT_Memory memory;
@ -165,7 +165,7 @@ const FT_Module_Class* const ft_default_modules[] =
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Done_FreeType( FT_Library library )
FT_EXPORT_DEF( FT_Error ) FT_Done_FreeType( FT_Library library )
{
if ( library )
{

34
src/base/ftlist.c
View File

@ -53,8 +53,8 @@
/* <Return> */
/* List node. NULL if it wasn't found. */
/* */
BASE_FUNC( FT_ListNode ) FT_List_Find( FT_List list,
void* data )
FT_BASE_DEF( FT_ListNode ) FT_List_Find( FT_List list,
void* data )
{
FT_ListNode cur;
@ -84,8 +84,8 @@
/* list :: A pointer to the parent list. */
/* node :: The node to append. */
/* */
BASE_FUNC( void ) FT_List_Add( FT_List list,
FT_ListNode node )
FT_BASE_DEF( void ) FT_List_Add( FT_List list,
FT_ListNode node )
{
FT_ListNode before = list->tail;
@ -114,8 +114,8 @@
/* list :: A pointer to parent list. */
/* node :: The node to insert. */
/* */
BASE_FUNC( void ) FT_List_Insert( FT_List list,
FT_ListNode node )
FT_BASE_DEF( void ) FT_List_Insert( FT_List list,
FT_ListNode node )
{
FT_ListNode after = list->head;
@ -147,8 +147,8 @@
/* <InOut> */
/* list :: A pointer to the parent list. */
/* */
BASE_FUNC( void ) FT_List_Remove( FT_List list,
FT_ListNode node )
FT_BASE_DEF( void ) FT_List_Remove( FT_List list,
FT_ListNode node )
{
FT_ListNode before, after;
@ -181,8 +181,8 @@
/* list :: A pointer to the parent list. */
/* node :: The node to move. */
/* */
BASE_FUNC( void ) FT_List_Up( FT_List list,
FT_ListNode node )
FT_BASE_DEF( void ) FT_List_Up( FT_List list,
FT_ListNode node )
{
FT_ListNode before, after;
@ -228,9 +228,9 @@
/* <Return> */
/* The result (a FreeType error code) of the last iterator call. */
/* */
BASE_FUNC( FT_Error ) FT_List_Iterate( FT_List list,
FT_List_Iterator iterator,
void* user )
FT_BASE_DEF( FT_Error ) FT_List_Iterate( FT_List list,
FT_List_Iterator iterator,
void* user )
{
FT_ListNode cur = list->head;
FT_Error error = FT_Err_Ok;
@ -271,10 +271,10 @@
/* user :: A user-supplied field which is passed as the last */
/* argument to the destructor. */
/* */
BASE_FUNC( void ) FT_List_Finalize( FT_List list,
FT_List_Destructor destroy,
FT_Memory memory,
void* user )
FT_BASE_DEF( void ) FT_List_Finalize( FT_List list,
FT_List_Destructor destroy,
FT_Memory memory,
void* user )
{
FT_ListNode cur;

16
src/base/ftmac.c
View File

@ -644,10 +644,10 @@
/* fond = GetResource( 'FOND', fontName ); */
/* error = FT_New_Face_From_FOND( library, fond, 0, &face ); */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Face_From_FOND( FT_Library library,
Handle fond,
FT_Long face_index,
FT_Face* aface )
FT_EXPORT_DEF( FT_Error ) FT_New_Face_From_FOND( FT_Library library,
Handle fond,
FT_Long face_index,
FT_Face* aface )
{
short sfnt_id, have_sfnt, have_lwfn = 0;
Str255 lwfn_file_name;
@ -700,10 +700,10 @@
/* accepts pathnames to Mac suitcase files. For further */
/* documentation see the original FT_New_Face() in ftobjs.c. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Face( FT_Library library,
const char* pathname,
FT_Long face_index,
FT_Face* aface )
FT_EXPORT_DEF( FT_Error ) FT_New_Face( FT_Library library,
const char* pathname,
FT_Long face_index,
FT_Face* aface )
{
FT_Open_Args args;
FSSpec spec;

8
src/base/ftmm.c
View File

@ -47,8 +47,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Get_Multi_Master( FT_Face face,
FT_Multi_Master* master )
FT_EXPORT_DEF( FT_Error ) FT_Get_Multi_Master( FT_Face face,
FT_Multi_Master* master )
{
FT_Error error;
@ -94,7 +94,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Set_MM_Design_Coordinates(
FT_EXPORT_DEF( FT_Error ) FT_Set_MM_Design_Coordinates(
FT_Face face,
FT_UInt num_coords,
FT_Long* coords )
@ -144,7 +144,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Set_MM_Blend_Coordinates(
FT_EXPORT_DEF( FT_Error ) FT_Set_MM_Blend_Coordinates(
FT_Face face,
FT_UInt num_coords,
FT_Fixed* coords )

8
src/base/ftnames.c
View File

@ -40,7 +40,7 @@
/* <Return> */
/* The number of strings in the `name' table. */
/* */
FT_EXPORT_FUNC( FT_UInt ) FT_Get_Sfnt_Name_Count( FT_Face face )
FT_EXPORT_DEF( FT_UInt ) FT_Get_Sfnt_Name_Count( FT_Face face )
{
return face && ( FT_IS_SFNT( face ) ? ((TT_Face)face)->num_names : 0 );
}
@ -73,9 +73,9 @@
/* `name' table entries, then do a loop until you get the right */
/* platform, encoding, and name ID. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Get_Sfnt_Name( FT_Face face,
FT_UInt index,
FT_SfntName* aname )
FT_EXPORT_DEF( FT_Error ) FT_Get_Sfnt_Name( FT_Face face,
FT_UInt index,
FT_SfntName* aname )
{
FT_Error error = FT_Err_Invalid_Argument;

214
src/base/ftobjs.c
View File

@ -70,9 +70,9 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
BASE_FUNC( FT_Error ) FT_Alloc( FT_Memory memory,
FT_Long size,
void** P )
FT_BASE_DEF( FT_Error ) FT_Alloc( FT_Memory memory,
FT_Long size,
void** P )
{
FT_Assert( P != 0 );
@ -128,10 +128,10 @@
/* All callers of FT_Realloc() _must_ provide the current block size */
/* as well as the new one. */
/* */
BASE_FUNC( FT_Error ) FT_Realloc( FT_Memory memory,
FT_Long current,
FT_Long size,
void** P )
FT_BASE_DEF( FT_Error ) FT_Realloc( FT_Memory memory,
FT_Long current,
FT_Long size,
void** P )
{
void* Q;
@ -187,8 +187,8 @@
/* This is a strong convention within all of FreeType and its */
/* drivers. */
/* */
BASE_FUNC( void ) FT_Free( FT_Memory memory,
void** P )
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",
@ -294,7 +294,7 @@
/* <Input> */
/* stream :: The stream to be closed and destroyed. */
/* */
FT_EXPORT_FUNC( void ) FT_Done_Stream( FT_Stream stream )
FT_EXPORT_DEF( void ) FT_Done_Stream( FT_Stream stream )
{
if ( stream && stream->close )
{
@ -370,8 +370,8 @@
/* create a new glyph loader */
BASE_FUNC( FT_Error ) FT_GlyphLoader_New( FT_Memory memory,
FT_GlyphLoader** aloader )
FT_BASE_DEF( FT_Error ) FT_GlyphLoader_New( FT_Memory memory,
FT_GlyphLoader** aloader )
{
FT_GlyphLoader* loader;
FT_Error error;
@ -387,7 +387,7 @@
/* rewind the glyph loader - reset counters to 0 */
BASE_FUNC( void ) FT_GlyphLoader_Rewind( FT_GlyphLoader* loader )
FT_BASE_DEF( void ) FT_GlyphLoader_Rewind( FT_GlyphLoader* loader )
{
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
@ -403,7 +403,7 @@
/* reset the glyph loader, frees all allocated tables */
/* and starts from zero */
BASE_FUNC( void ) FT_GlyphLoader_Reset( FT_GlyphLoader* loader )
FT_BASE_DEF( void ) FT_GlyphLoader_Reset( FT_GlyphLoader* loader )
{
FT_Memory memory = loader->memory;
@ -423,7 +423,7 @@
/* delete a glyph loader */
BASE_FUNC( void ) FT_GlyphLoader_Done( FT_GlyphLoader* loader )
FT_BASE_DEF( void ) FT_GlyphLoader_Done( FT_GlyphLoader* loader )
{
if ( loader )
{
@ -455,7 +455,7 @@
}
BASE_FUNC( FT_Error ) FT_GlyphLoader_Create_Extra(
FT_BASE_DEF( FT_Error ) FT_GlyphLoader_Create_Extra(
FT_GlyphLoader* loader )
{
FT_Error error;
@ -488,7 +488,7 @@
/* function reallocates its outline tables if necessary. Note that it */
/* DOESN'T change the number of points within the loader! */
/* */
BASE_FUNC( FT_Error ) FT_GlyphLoader_Check_Points(
FT_BASE_DEF( FT_Error ) FT_GlyphLoader_Check_Points(
FT_GlyphLoader* loader,
FT_UInt n_points,
FT_UInt n_contours )
@ -548,7 +548,7 @@
/* reallocates its subglyphs table if necessary. Note that it DOES */
/* NOT change the number of subglyphs within the loader! */
/* */
BASE_FUNC( FT_Error ) FT_GlyphLoader_Check_Subglyphs(
FT_BASE_DEF( FT_Error ) FT_GlyphLoader_Check_Subglyphs(
FT_GlyphLoader* loader,
FT_UInt n_subs )
{
@ -579,7 +579,7 @@
/* prepare loader for the addition of a new glyph on top of the base one */
BASE_FUNC( void ) FT_GlyphLoader_Prepare( FT_GlyphLoader* loader )
FT_BASE_DEF( void ) FT_GlyphLoader_Prepare( FT_GlyphLoader* loader )
{
FT_GlyphLoad* current = &loader->current;
@ -594,7 +594,7 @@
/* add current glyph to the base image - and prepare for another */
BASE_FUNC( void ) FT_GlyphLoader_Add( FT_GlyphLoader* loader )
FT_BASE_DEF( void ) FT_GlyphLoader_Add( FT_GlyphLoader* loader )
{
FT_GlyphLoad* base = &loader->base;
FT_GlyphLoad* current = &loader->current;
@ -617,7 +617,7 @@
}
BASE_FUNC( FT_Error ) FT_GlyphLoader_Copy_Points( FT_GlyphLoader* target,
FT_BASE_DEF( FT_Error ) FT_GlyphLoader_Copy_Points( FT_GlyphLoader* target,
FT_GlyphLoader* source )
{
FT_Error error;
@ -764,8 +764,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
BASE_FUNC( FT_Error ) FT_New_GlyphSlot( FT_Face face,
FT_GlyphSlot* aslot )
FT_BASE_DEF( FT_Error ) FT_New_GlyphSlot( FT_Face face,
FT_GlyphSlot* aslot )
{
FT_Error error;
FT_Driver driver;
@ -818,7 +818,7 @@
/* <Input> */
/* slot :: A handle to a target glyph slot. */
/* */
BASE_FUNC( void ) FT_Done_GlyphSlot( FT_GlyphSlot slot )
FT_BASE_DEF( void ) FT_Done_GlyphSlot( FT_GlyphSlot slot )
{
if ( slot )
{
@ -872,9 +872,9 @@
/* the transformation and is performed on the character size given in */
/* the last call to FT_Set_Char_Sizes() or FT_Set_Pixel_Sizes(). */
/* */
FT_EXPORT_FUNC( void ) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta )
FT_EXPORT_DEF( void ) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta )
{
if ( !face )
return;
@ -949,9 +949,9 @@
/* Note that this also transforms the `face.glyph.advance' field, but */
/* *not* the values in `face.glyph.metrics'. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Load_Glyph( FT_Face face,
FT_UInt glyph_index,
FT_Int load_flags )
FT_EXPORT_DEF( FT_Error ) FT_Load_Glyph( FT_Face face,
FT_UInt glyph_index,
FT_Int load_flags )
{
FT_Error error;
FT_Driver driver;
@ -1004,8 +1004,10 @@
hinting = (FT_AutoHinter_Interface*)hinter->clazz->module_interface;
error = hinting->load_glyph( (FT_AutoHinter)hinter, slot, face->size,
glyph_index, load_flags );
error = hinting->load_glyph( (FT_AutoHinter)hinter,
slot, face->size,
glyph_index, load_flags );
}
else
error = driver->clazz->load_glyph( slot,
@ -1113,9 +1115,9 @@
/* Note that this also transforms the `face.glyph.advance' field, but */
/* *not* the values in `face.glyph.metrics'. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Load_Char( FT_Face face,
FT_ULong char_code,
FT_Int load_flags )
FT_EXPORT_DEF( FT_Error ) FT_Load_Char( FT_Face face,
FT_ULong char_code,
FT_Int load_flags )
{
FT_UInt glyph_index;
@ -1304,10 +1306,10 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Face( FT_Library library,
const char* pathname,
FT_Long face_index,
FT_Face* aface )
FT_EXPORT_DEF( FT_Error ) FT_New_Face( FT_Library library,
const char* pathname,
FT_Long face_index,
FT_Face* aface )
{
FT_Open_Args args;
@ -1365,11 +1367,11 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Memory_Face( FT_Library library,
FT_Byte* file_base,
FT_Long file_size,
FT_Long face_index,
FT_Face* face )
FT_EXPORT_DEF( FT_Error ) FT_New_Memory_Face( FT_Library library,
FT_Byte* file_base,
FT_Long file_size,
FT_Long face_index,
FT_Face* face )
{
FT_Open_Args args;
@ -1426,10 +1428,10 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Open_Face( FT_Library library,
FT_Open_Args* args,
FT_Long face_index,
FT_Face* aface )
FT_EXPORT_DEF( FT_Error ) FT_Open_Face( FT_Library library,
FT_Open_Args* args,
FT_Long face_index,
FT_Face* aface )
{
FT_Error error;
FT_Driver driver;
@ -1626,8 +1628,8 @@
/* when invoking this function. Most drivers simply do not implement */
/* file attachments. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Attach_File( FT_Face face,
const char* filepathname )
FT_EXPORT_DEF( FT_Error ) FT_Attach_File( FT_Face face,
const char* filepathname )
{
FT_Open_Args open;
@ -1670,8 +1672,8 @@
/* when invoking this function. Most drivers simply do not implement */
/* file attachments. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Attach_Stream( FT_Face face,
FT_Open_Args* parameters )
FT_EXPORT_DEF( FT_Error ) FT_Attach_Stream( FT_Face face,
FT_Open_Args* parameters )
{
FT_Stream stream;
FT_Error error;
@ -1726,7 +1728,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Done_Face( FT_Face face )
FT_EXPORT_DEF( FT_Error ) FT_Done_Face( FT_Face face )
{
FT_Error error;
FT_Driver driver;
@ -1774,8 +1776,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Size( FT_Face face,
FT_Size* asize )
FT_EXPORT_DEF( FT_Error ) FT_New_Size( FT_Face face,
FT_Size* asize )
{
FT_Error error;
FT_Memory memory;
@ -1844,7 +1846,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Done_Size( FT_Size size )
FT_EXPORT_DEF( FT_Error ) FT_Done_Size( FT_Size size )
{
FT_Error error;
FT_Driver driver;
@ -1943,11 +1945,11 @@
/* When dealing with fixed-size faces (i.e., non-scalable formats), */
/* use the function FT_Set_Pixel_Sizes(). */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Set_Char_Size( FT_Face face,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution )
FT_EXPORT_DEF( FT_Error ) FT_Set_Char_Size( FT_Face face,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution )
{
FT_Error error = FT_Err_Ok;
FT_Driver driver;
@ -2036,9 +2038,9 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Set_Pixel_Sizes( FT_Face face,
FT_UInt pixel_width,
FT_UInt pixel_height )
FT_EXPORT_DEF( FT_Error ) FT_Set_Pixel_Sizes( FT_Face face,
FT_UInt pixel_width,
FT_UInt pixel_height )
{
FT_Error error = FT_Err_Ok;
FT_Driver driver;
@ -2121,11 +2123,11 @@
/* kernings, are out of the scope of this API function -- they can be */
/* implemented through format-specific interfaces. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Get_Kerning( FT_Face face,
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_UInt kern_mode,
FT_Vector* kerning )
FT_EXPORT_DEF( FT_Error ) FT_Get_Kerning( FT_Face face,
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_UInt kern_mode,
FT_Vector* kerning )
{
FT_Error error = FT_Err_Ok;
FT_Driver driver;
@ -2191,8 +2193,8 @@
/* This function will return an error if no charmap in the face */
/* corresponds to the encoding queried here. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Select_Charmap( FT_Face face,
FT_Encoding encoding )
FT_EXPORT_DEF( FT_Error ) FT_Select_Charmap( FT_Face face,
FT_Encoding encoding )
{
FT_CharMap* cur;
FT_CharMap* limit;
@ -2241,8 +2243,8 @@
/* the face (i.e., if it is not listed in the face->charmaps[] */
/* table). */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Set_Charmap( FT_Face face,
FT_CharMap charmap )
FT_EXPORT_DEF( FT_Error ) FT_Set_Charmap( FT_Face face,
FT_CharMap charmap )
{
FT_CharMap* cur;
FT_CharMap* limit;
@ -2286,8 +2288,8 @@
/* <Return> */
/* The glyph index. 0 means `undefined character code'. */
/* */
FT_EXPORT_FUNC( FT_UInt ) FT_Get_Char_Index( FT_Face face,
FT_ULong charcode )
FT_EXPORT_DEF( FT_UInt ) FT_Get_Char_Index( FT_Face face,
FT_ULong charcode )
{
FT_UInt result;
FT_Driver driver;
@ -2338,10 +2340,10 @@
/* macro FT_CONFIG_OPTION_NO_GLYPH_NAMES is defined in */
/* `include/freetype/config/ftoptions.h' */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Get_Glyph_Name( FT_Face face,
FT_UInt glyph_index,
FT_Pointer buffer,
FT_UInt buffer_max )
FT_EXPORT_DEF( FT_Error ) FT_Get_Glyph_Name( FT_Face face,
FT_UInt glyph_index,
FT_Pointer buffer,
FT_UInt buffer_max )
{
FT_Error error = FT_Err_Invalid_Argument;
@ -2401,8 +2403,8 @@
/* */
/* You can load any table with a different function.. XXX */
/* */
FT_EXPORT_FUNC( void* ) FT_Get_Sfnt_Table( FT_Face face,
FT_Sfnt_Tag tag )
FT_EXPORT_DEF( void* ) FT_Get_Sfnt_Table( FT_Face face,
FT_Sfnt_Tag tag )
{
void* table = 0;
FT_Get_Sfnt_Table_Func func;
@ -2436,9 +2438,9 @@
/*************************************************************************/
/* lookup a renderer by glyph format in the library's list */
BASE_FUNC( FT_Renderer ) FT_Lookup_Renderer( FT_Library library,
FT_Glyph_Format format,
FT_ListNode* node )
FT_BASE_DEF( FT_Renderer ) FT_Lookup_Renderer( FT_Library library,
FT_Glyph_Format format,
FT_ListNode* node )
{
FT_ListNode cur;
FT_Renderer result = 0;
@ -2601,8 +2603,8 @@
/* To add a new renderer, simply use FT_Add_Module(). To retrieve a */
/* renderer by its name, use FT_Get_Module(). */
/* */
FT_EXPORT_FUNC( FT_Renderer ) FT_Get_Renderer( FT_Library library,
FT_Glyph_Format format )
FT_EXPORT_DEF( FT_Renderer ) FT_Get_Renderer( FT_Library library,
FT_Glyph_Format format )
{
/* test for valid `library' delayed to FT_Lookup_Renderer() */
@ -2636,9 +2638,9 @@
/* */
/* This doesn't change the current renderer for other formats. */
/* */
FT_EXPORT_DEF( FT_Error ) FT_Set_Renderer( FT_Library library,
FT_Renderer renderer,
FT_UInt num_params,
FT_EXPORT( FT_Error ) FT_Set_Renderer( FT_Library library,
FT_Renderer renderer,
FT_UInt num_params,
FT_Parameter* parameters )
{
FT_ListNode node;
@ -2681,7 +2683,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error FT_Render_Glyph_Internal( FT_Library library,
FT_GlyphSlot slot,
FT_UInt render_mode )
@ -2760,8 +2762,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Render_Glyph( FT_GlyphSlot slot,
FT_UInt render_mode )
FT_EXPORT_DEF( FT_Error ) FT_Render_Glyph( FT_GlyphSlot slot,
FT_UInt render_mode )
{
FT_Library library;
@ -2855,8 +2857,8 @@
/* An error will be returned if a module already exists by that name, */
/* or if the module requires a version of FreeType that is too great. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Add_Module( FT_Library library,
const FT_Module_Class* clazz )
FT_EXPORT_DEF( FT_Error ) FT_Add_Module( FT_Library library,
const FT_Module_Class* clazz )
{
FT_Error error;
FT_Memory memory;
@ -2999,8 +3001,8 @@
/* You should better be familiar with FreeType internals to know */
/* which module to look for :-) */
/* */
FT_EXPORT_FUNC( FT_Module ) FT_Get_Module( FT_Library library,
const char* module_name )
FT_EXPORT_DEF( FT_Module ) FT_Get_Module( FT_Library library,
const char* module_name )
{
FT_Module result = 0;
FT_Module* cur;
@ -3045,8 +3047,8 @@
/* You should better be familiar with FreeType internals to know */
/* which module to look for, and what its interface is :-) */
/* */
BASE_FUNC( const void* ) FT_Get_Module_Interface( FT_Library library,
const char* mod_name )
FT_BASE_DEF( const void* ) FT_Get_Module_Interface( FT_Library library,
const char* mod_name )
{
FT_Module module;
@ -3078,8 +3080,8 @@
/* <Note> */
/* The module object is destroyed by the function in case of success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Remove_Module( FT_Library library,
FT_Module module )
FT_EXPORT_DEF( FT_Error ) FT_Remove_Module( FT_Library library,
FT_Module module )
{
/* try to find the module from the table, then remove it from there */
@ -3149,8 +3151,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Library( FT_Memory memory,
FT_Library* alibrary )
FT_EXPORT_DEF( FT_Error ) FT_New_Library( FT_Memory memory,
FT_Library* alibrary )
{
FT_Library library = 0;
FT_Error error;
@ -3196,7 +3198,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Done_Library( FT_Library library )
FT_EXPORT_DEF( FT_Error ) FT_Done_Library( FT_Library library )
{
FT_Memory memory;
FT_UInt n;
@ -3255,9 +3257,9 @@
/* Currently, four debug hook slots are available, but only two (for */
/* the TrueType and the Type 1 interpreter) are defined. */
/* */
FT_EXPORT_FUNC( void ) FT_Set_Debug_Hook( FT_Library library,
FT_UInt hook_index,
FT_DebugHook_Func debug_hook )
FT_EXPORT_DEF( void ) FT_Set_Debug_Hook( FT_Library library,
FT_UInt hook_index,
FT_DebugHook_Func debug_hook )
{
if ( library && debug_hook &&
hook_index <

50
src/base/ftoutln.c
View File

@ -65,7 +65,7 @@
/* <Return> */
/* FreeType error code. 0 means sucess. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Outline_Decompose(
FT_EXPORT_DEF( FT_Error ) FT_Outline_Decompose(
FT_Outline* outline,
const FT_Outline_Funcs* interface,
void* user )
@ -270,7 +270,7 @@
}
FT_EXPORT_FUNC( FT_Error ) FT_Outline_New_Internal(
FT_EXPORT_DEF( FT_Error ) FT_Outline_New_Internal(
FT_Memory memory,
FT_UInt numPoints,
FT_Int numContours,
@ -335,7 +335,7 @@
/* The reason why this function takes a `library' parameter is simply */
/* to use the library's memory allocator. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Outline_New( FT_Library library,
FT_EXPORT_DEF( FT_Error ) FT_Outline_New( FT_Library library,
FT_UInt numPoints,
FT_Int numContours,
FT_Outline* outline )
@ -367,8 +367,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Outline_Copy( FT_Outline* source,
FT_Outline* target )
FT_EXPORT_DEF( FT_Error ) FT_Outline_Copy( FT_Outline* source,
FT_Outline* target )
{
FT_Int is_owner;
@ -398,8 +398,8 @@
}
FT_EXPORT_FUNC( FT_Error ) FT_Outline_Done_Internal( FT_Memory memory,
FT_Outline* outline )
FT_EXPORT_DEF( FT_Error ) FT_Outline_Done_Internal( FT_Memory memory,
FT_Outline* outline )
{
if ( outline )
{
@ -445,8 +445,8 @@
/* The reason why this function takes an `outline' parameter is */
/* simply to use FT_Free(). */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Outline_Done( FT_Library library,
FT_Outline* outline )
FT_EXPORT_DEF( FT_Error ) FT_Outline_Done( FT_Library library,
FT_Outline* outline )
{
/* check for valid `outline' in FT_Outline_Done_Internal() */
@ -483,8 +483,8 @@
/* <MT-Note> */
/* Yes. */
/* */
FT_EXPORT_FUNC( void ) FT_Outline_Get_CBox( FT_Outline* outline,
FT_BBox* cbox )
FT_EXPORT_DEF( void ) FT_Outline_Get_CBox( FT_Outline* outline,
FT_BBox* cbox )
{
FT_Pos xMin, yMin, xMax, yMax;
@ -548,9 +548,9 @@
/* <MT-Note> */
/* Yes. */
/* */
FT_EXPORT_FUNC( void ) FT_Outline_Translate( FT_Outline* outline,
FT_Pos xOffset,
FT_Pos yOffset )
FT_EXPORT_DEF( void ) FT_Outline_Translate( FT_Outline* outline,
FT_Pos xOffset,
FT_Pos yOffset )
{
FT_UShort n;
FT_Vector* vec = outline->points;
@ -581,7 +581,7 @@
/* This functions toggles the bit flag `ft_outline_reverse_fill' in */
/* the outline's `flags' field. */
/* */
FT_EXPORT_FUNC( void ) FT_Outline_Reverse( FT_Outline* outline )
FT_EXPORT_DEF( void ) FT_Outline_Reverse( FT_Outline* outline )
{
FT_UShort n;
FT_Int first, last;
@ -668,9 +668,9 @@
/* converter is called, which means that the value you give to it is */
/* actually ignored. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Outline_Render( FT_Library library,
FT_Outline* outline,
FT_Raster_Params* params )
FT_EXPORT_DEF( FT_Error ) FT_Outline_Render( FT_Library library,
FT_Outline* outline,
FT_Raster_Params* params )
{
FT_Error error;
FT_Bool update = 0;
@ -745,9 +745,9 @@
/* */
/* It will use the raster correponding to the default glyph format. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_Outline_Get_Bitmap( FT_Library library,
FT_Outline* outline,
FT_Bitmap* bitmap )
FT_EXPORT_DEF( FT_Error ) FT_Outline_Get_Bitmap( FT_Library library,
FT_Outline* outline,
FT_Bitmap* bitmap )
{
FT_Raster_Params params;
@ -787,8 +787,8 @@
/* <Note> */
/* The result is undefined if either `vector' or `matrix' is invalid. */
/* */
FT_EXPORT_FUNC( void ) FT_Vector_Transform( FT_Vector* vector,
FT_Matrix* matrix )
FT_EXPORT_DEF( void ) FT_Vector_Transform( FT_Vector* vector,
FT_Matrix* matrix )
{
FT_Pos xz, yz;
@ -828,8 +828,8 @@
/* You can use FT_Outline_Translate() if you need to translate the */
/* outline's points. */
/* */
FT_EXPORT_FUNC( void ) FT_Outline_Transform( FT_Outline* outline,
FT_Matrix* matrix )
FT_EXPORT_DEF( void ) FT_Outline_Transform( FT_Outline* outline,
FT_Matrix* matrix )
{
FT_Vector* vec = outline->points;
FT_Vector* limit = vec + outline->n_points;

88
src/base/ftstream.c
View File

@ -30,10 +30,10 @@
#define FT_COMPONENT trace_stream
BASE_FUNC( void ) FT_New_Memory_Stream( FT_Library library,
FT_Byte* base,
FT_ULong size,
FT_Stream stream )
FT_BASE_DEF( void ) FT_New_Memory_Stream( FT_Library library,
FT_Byte* base,
FT_ULong size,
FT_Stream stream )
{
stream->memory = library->memory;
stream->base = base;
@ -45,7 +45,7 @@
}
BASE_FUNC( FT_Error ) FT_Seek_Stream( FT_Stream stream,
FT_BASE_DEF( FT_Error ) FT_Seek_Stream( FT_Stream stream,
FT_ULong pos )
{
FT_Error error;
@ -83,31 +83,31 @@
}
BASE_FUNC( FT_Error ) FT_Skip_Stream( FT_Stream stream,
FT_Long distance )
FT_BASE_DEF( FT_Error ) FT_Skip_Stream( FT_Stream stream,
FT_Long distance )
{
return FT_Seek_Stream( stream, (FT_ULong)( stream->pos + distance ) );
}
BASE_FUNC( FT_Long ) FT_Stream_Pos( FT_Stream stream )
FT_BASE_DEF( FT_Long ) FT_Stream_Pos( FT_Stream stream )
{
return stream->pos;
}
BASE_FUNC( FT_Error ) FT_Read_Stream( FT_Stream stream,
FT_Byte* buffer,
FT_ULong count )
FT_BASE_DEF( FT_Error ) FT_Read_Stream( FT_Stream stream,
FT_Byte* buffer,
FT_ULong count )
{
return FT_Read_Stream_At( stream, stream->pos, buffer, count );
}
BASE_FUNC( FT_Error ) FT_Read_Stream_At( FT_Stream stream,
FT_ULong pos,
FT_Byte* buffer,
FT_ULong count )
FT_BASE_DEF( FT_Error ) FT_Read_Stream_At( FT_Stream stream,
FT_ULong pos,
FT_Byte* buffer,
FT_ULong count )
{
FT_Error error = FT_Err_Ok;
FT_ULong read_bytes;
@ -148,9 +148,9 @@
}
BASE_FUNC( FT_Error ) FT_Extract_Frame( FT_Stream stream,
FT_ULong count,
FT_Byte** pbytes )
FT_BASE_DEF( FT_Error ) FT_Extract_Frame( FT_Stream stream,
FT_ULong count,
FT_Byte** pbytes )
{
FT_Error error;
@ -169,8 +169,8 @@
}
BASE_FUNC( void ) FT_Release_Frame( FT_Stream stream,
FT_Byte** pbytes )
FT_BASE_DEF( void ) FT_Release_Frame( FT_Stream stream,
FT_Byte** pbytes )
{
if ( stream->read )
{
@ -183,8 +183,8 @@
}
BASE_FUNC( FT_Error ) FT_Access_Frame( FT_Stream stream,
FT_ULong count )
FT_BASE_DEF( FT_Error ) FT_Access_Frame( FT_Stream stream,
FT_ULong count )
{
FT_Error error = FT_Err_Ok;
FT_ULong read_bytes;
@ -243,7 +243,7 @@
}
BASE_FUNC( void ) FT_Forget_Frame( FT_Stream stream )
FT_BASE_DEF( void ) FT_Forget_Frame( FT_Stream stream )
{
/* IMPORTANT: The assertion stream->cursor != 0 was removed, given */
/* that it is possible to access a frame of length 0 in */
@ -268,7 +268,7 @@
}
BASE_FUNC( FT_Char ) FT_Get_Char( FT_Stream stream )
FT_BASE_DEF( FT_Char ) FT_Get_Char( FT_Stream stream )
{
FT_Char result;
@ -283,7 +283,7 @@
}
BASE_FUNC( FT_Short ) FT_Get_Short( FT_Stream stream )
FT_BASE_DEF( FT_Short ) FT_Get_Short( FT_Stream stream )
{
FT_Byte* p;
FT_Short result;
@ -301,7 +301,7 @@
}
BASE_FUNC( FT_Short ) FT_Get_ShortLE( FT_Stream stream )
FT_BASE_DEF( FT_Short ) FT_Get_ShortLE( FT_Stream stream )
{
FT_Byte* p;
FT_Short result;
@ -319,7 +319,7 @@
}
BASE_FUNC( FT_Long ) FT_Get_Offset( FT_Stream stream )
FT_BASE_DEF( FT_Long ) FT_Get_Offset( FT_Stream stream )
{
FT_Byte* p;
FT_Long result;
@ -336,7 +336,7 @@
}
BASE_FUNC( FT_Long ) FT_Get_Long( FT_Stream stream )
FT_BASE_DEF( FT_Long ) FT_Get_Long( FT_Stream stream )
{
FT_Byte* p;
FT_Long result;
@ -353,7 +353,7 @@
}
BASE_FUNC( FT_Long ) FT_Get_LongLE( FT_Stream stream )
FT_BASE_DEF( FT_Long ) FT_Get_LongLE( FT_Stream stream )
{
FT_Byte* p;
FT_Long result;
@ -370,8 +370,8 @@
}
BASE_FUNC( FT_Char ) FT_Read_Char( FT_Stream stream,
FT_Error* error )
FT_BASE_DEF( FT_Char ) FT_Read_Char( FT_Stream stream,
FT_Error* error )
{
FT_Byte result = 0;
@ -406,8 +406,8 @@
}
BASE_FUNC( FT_Short ) FT_Read_Short( FT_Stream stream,
FT_Error* error )
FT_BASE_DEF( FT_Short ) FT_Read_Short( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[2];
FT_Byte* p = 0;
@ -452,8 +452,8 @@
}
BASE_FUNC( FT_Short ) FT_Read_ShortLE( FT_Stream stream,
FT_Error* error )
FT_BASE_DEF( FT_Short ) FT_Read_ShortLE( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[2];
FT_Byte* p = 0;
@ -498,8 +498,8 @@
}
BASE_FUNC( FT_Long ) FT_Read_Offset( FT_Stream stream,
FT_Error* error )
FT_BASE_DEF( FT_Long ) FT_Read_Offset( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[3];
FT_Byte* p = 0;
@ -544,8 +544,8 @@
}
BASE_FUNC( FT_Long ) FT_Read_Long( FT_Stream stream,
FT_Error* error )
FT_BASE_DEF( FT_Long ) FT_Read_Long( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[4];
FT_Byte* p = 0;
@ -590,8 +590,8 @@
}
BASE_FUNC( FT_Long ) FT_Read_LongLE( FT_Stream stream,
FT_Error* error )
FT_BASE_DEF( FT_Long ) FT_Read_LongLE( FT_Stream stream,
FT_Error* error )
{
FT_Byte reads[4];
FT_Byte* p = 0;
@ -636,9 +636,9 @@
}
BASE_FUNC( FT_Error ) FT_Read_Fields( FT_Stream stream,
const FT_Frame_Field* fields,
void* structure )
FT_BASE_DEF( FT_Error ) FT_Read_Fields( FT_Stream stream,
const FT_Frame_Field* fields,
void* structure )
{
FT_Error error;
FT_Bool frame_accessed = 0;

6
src/base/ftsynth.c
View File

@ -290,9 +290,9 @@
}
FT_EXPORT_FUNC(FT_Error) FT_Outline_Embolden( FT_GlyphSlot original,
FT_Outline* outline,
FT_Pos* advance )
FT_EXPORT_DEF(FT_Error) FT_Outline_Embolden( FT_GlyphSlot original,
FT_Outline* outline,
FT_Pos* advance )
{
FT_Vector u, v;
FT_Vector* points;

8
src/base/ftsystem.c
View File

@ -230,8 +230,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_EXPORT_FUNC( FT_Error ) FT_New_Stream( const char* filepathname,
FT_Stream stream )
FT_EXPORT_DEF( FT_Error ) FT_New_Stream( const char* filepathname,
FT_Stream stream )
{
FILE* file;
@ -278,7 +278,7 @@
/* <Return> */
/* A pointer to the new memory object. 0 in case of error. */
/* */
FT_EXPORT_FUNC( FT_Memory ) FT_New_Memory( void )
FT_EXPORT_DEF( FT_Memory ) FT_New_Memory( void )
{
FT_Memory memory;
@ -307,7 +307,7 @@
/* <Input> */
/* memory :: A handle to the memory manager. */
/* */
FT_EXPORT_FUNC( void ) FT_Done_Memory( FT_Memory memory )
FT_EXPORT_DEF( void ) FT_Done_Memory( FT_Memory memory )
{
free( memory );
}

38
src/cache/ftcchunk.c vendored
View File

@ -33,10 +33,10 @@
/* create a new chunk node, setting its cache index and ref count */
FT_EXPORT_FUNC( FT_Error ) FTC_ChunkNode_Init( FTC_ChunkNode node,
FTC_ChunkSet cset,
FT_UInt index,
FT_Bool alloc )
FT_EXPORT_DEF( FT_Error ) FTC_ChunkNode_Init( FTC_ChunkNode node,
FTC_ChunkSet cset,
FT_UInt index,
FT_Bool alloc )
{
FTC_Chunk_Cache cache = cset->cache;
FTC_CacheNode_Data* data = FTC_CACHENODE_TO_DATA_P( &node->root );
@ -65,7 +65,7 @@
}
FT_EXPORT_FUNC( void ) FTC_ChunkNode_Destroy( FTC_ChunkNode node )
FT_EXPORT_DEF( void ) FTC_ChunkNode_Destroy( FTC_ChunkNode node )
{
FTC_ChunkSet cset = node->cset;
@ -78,7 +78,7 @@
}
FT_EXPORT_FUNC( FT_ULong ) FTC_ChunkNode_Size( FTC_ChunkNode node )
FT_EXPORT_DEF( FT_ULong ) FTC_ChunkNode_Size( FTC_ChunkNode node )
{
FTC_ChunkSet cset = node->cset;
@ -87,7 +87,8 @@
}
FT_CPLUSPLUS( const FTC_CacheNode_Class ) ftc_chunk_cache_node_class =
FT_CALLBACK_TABLE_DEF
const FTC_CacheNode_Class ftc_chunk_cache_node_class =
{
(FTC_CacheNode_SizeFunc) FTC_ChunkNode_Size,
(FTC_CacheNode_DestroyFunc)FTC_ChunkNode_Destroy
@ -103,9 +104,9 @@
/*************************************************************************/
FT_EXPORT_FUNC( FT_Error ) FTC_ChunkSet_New( FTC_Chunk_Cache cache,
FT_Pointer type,
FTC_ChunkSet* aset )
FT_EXPORT_DEF( FT_Error ) FTC_ChunkSet_New( FTC_Chunk_Cache cache,
FT_Pointer type,
FTC_ChunkSet* aset )
{
FT_Error error;
FT_Memory memory = cache->root.memory;
@ -163,7 +164,7 @@
}
FT_EXPORT_FUNC( void ) FTC_ChunkSet_Destroy( FTC_ChunkSet cset )
FT_EXPORT_DEF( void ) FTC_ChunkSet_Destroy( FTC_ChunkSet cset )
{
FTC_Chunk_Cache cache = cset->cache;
FTC_Manager manager = cache->root.manager;
@ -202,7 +203,7 @@
}
FT_EXPORT_FUNC( FT_Error ) FTC_ChunkSet_Lookup_Node(
FT_EXPORT_DEF( FT_Error ) FTC_ChunkSet_Lookup_Node(
FTC_ChunkSet cset,
FT_UInt glyph_index,
FTC_ChunkNode* anode,
@ -279,7 +280,7 @@
( (FTC_ChunkSet)(node)->root.data )
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_chunk_set_lru_init( FT_Lru lru,
FT_LruNode node )
{
@ -302,7 +303,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ftc_chunk_set_lru_done( FT_Lru lru,
FT_LruNode node )
{
@ -315,7 +316,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Bool ftc_chunk_set_lru_compare( FT_LruNode node,
FT_LruKey key )
{
@ -326,7 +327,8 @@
}
FT_CPLUSPLUS( const FT_Lru_Class ) ftc_chunk_set_lru_class =
FT_CALLBACK_TABLE_DEF
const FT_Lru_Class ftc_chunk_set_lru_class =
{
sizeof( FT_LruRec ),
ftc_chunk_set_lru_init,
@ -345,7 +347,7 @@
/*************************************************************************/
FT_EXPORT_FUNC( FT_Error ) FTC_Chunk_Cache_Init( FTC_Chunk_Cache cache )
FT_EXPORT_DEF( FT_Error ) FTC_Chunk_Cache_Init( FTC_Chunk_Cache cache )
{
FT_Memory memory = cache->root.memory;
FT_Error error;
@ -365,7 +367,7 @@
}
FT_EXPORT_FUNC( void ) FTC_Chunk_Cache_Done( FTC_Chunk_Cache cache )
FT_EXPORT_DEF( void ) FTC_Chunk_Cache_Done( FTC_Chunk_Cache cache )
{
/* discard glyph sets */
FT_Lru_Done( cache->csets_lru );

40
src/cache/ftcglyph.c vendored
View File

@ -33,9 +33,9 @@
/* create a new glyph node, setting its cache index and ref count */
FT_EXPORT_FUNC( void ) FTC_GlyphNode_Init( FTC_GlyphNode node,
FTC_GlyphSet gset,
FT_UInt gindex )
FT_EXPORT_DEF( void ) FTC_GlyphNode_Init( FTC_GlyphNode node,
FTC_GlyphSet gset,
FT_UInt gindex )
{
FTC_Glyph_Cache cache = gset->cache;
FTC_CacheNode_Data* data = FTC_CACHENODE_TO_DATA_P( &node->root );
@ -55,8 +55,8 @@
/* set its `cache_data' field correctly, otherwise bad things */
/* will happen! */
FT_EXPORT_FUNC( void ) FTC_GlyphNode_Destroy( FTC_GlyphNode node,
FTC_Glyph_Cache cache )
FT_EXPORT_DEF( void ) FTC_GlyphNode_Destroy( FTC_GlyphNode node,
FTC_Glyph_Cache cache )
{
FT_LruNode gset_lru = cache->gsets_lru->nodes + node->gset_index;
FTC_GlyphSet gset = (FTC_GlyphSet)gset_lru->root.data;
@ -101,8 +101,8 @@
/* set its `user_data' field correctly, otherwise bad things */
/* will happen! */
FT_EXPORT_FUNC( FT_ULong ) FTC_GlyphNode_Size( FTC_GlyphNode node,
FTC_Glyph_Cache cache )
FT_EXPORT_DEF( FT_ULong ) FTC_GlyphNode_Size( FTC_GlyphNode node,
FTC_Glyph_Cache cache )
{
FT_LruNode gset_lru = cache->gsets_lru->nodes + node->gset_index;
FTC_GlyphSet gset = (FTC_GlyphSet)gset_lru->root.data;
@ -112,7 +112,8 @@
}
FT_CPLUSPLUS( const FTC_CacheNode_Class ) ftc_glyph_cache_node_class =
FT_CALLBACK_TABLE_DEF
const FTC_CacheNode_Class ftc_glyph_cache_node_class =
{
(FTC_CacheNode_SizeFunc) FTC_GlyphNode_Size,
(FTC_CacheNode_DestroyFunc)FTC_GlyphNode_Destroy
@ -128,9 +129,9 @@
/*************************************************************************/
FT_EXPORT_FUNC( FT_Error ) FTC_GlyphSet_New( FTC_Glyph_Cache cache,
FT_Pointer type,
FTC_GlyphSet* aset )
FT_EXPORT_DEF( FT_Error ) FTC_GlyphSet_New( FTC_Glyph_Cache cache,
FT_Pointer type,
FTC_GlyphSet* aset )
{
FT_Error error;
FT_Memory memory = cache->root.memory;
@ -180,7 +181,7 @@
}
FT_EXPORT_FUNC( void ) FTC_GlyphSet_Destroy( FTC_GlyphSet gset )
FT_EXPORT_DEF( void ) FTC_GlyphSet_Destroy( FTC_GlyphSet gset )
{
FTC_Glyph_Cache cache = gset->cache;
FTC_Manager manager = cache->root.manager;
@ -224,7 +225,7 @@
}
FT_EXPORT_FUNC( FT_Error ) FTC_GlyphSet_Lookup_Node(
FT_EXPORT_DEF( FT_Error ) FTC_GlyphSet_Lookup_Node(
FTC_GlyphSet gset,
FT_UInt glyph_index,
FTC_GlyphNode* anode )
@ -311,7 +312,7 @@
( (FTC_GlyphSet)(node)->root.data )
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_glyph_set_lru_init( FT_Lru lru,
FT_LruNode node )
{
@ -332,7 +333,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ftc_glyph_set_lru_done( FT_Lru lru,
FT_LruNode node )
{
@ -345,7 +346,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Bool ftc_glyph_set_lru_compare( FT_LruNode node,
FT_LruKey key )
{
@ -356,7 +357,8 @@
}
FT_CPLUSPLUS( const FT_Lru_Class ) ftc_glyph_set_lru_class =
FT_CALLBACK_TABLE_DEF
const FT_Lru_Class ftc_glyph_set_lru_class =
{
sizeof( FT_LruRec ),
ftc_glyph_set_lru_init,
@ -375,7 +377,7 @@
/*************************************************************************/
FT_EXPORT_FUNC( FT_Error ) FTC_Glyph_Cache_Init( FTC_Glyph_Cache cache )
FT_EXPORT_DEF( FT_Error ) FTC_Glyph_Cache_Init( FTC_Glyph_Cache cache )
{
FT_Memory memory = cache->root.memory;
FT_Error error;
@ -402,7 +404,7 @@
}
FT_EXPORT_FUNC( void ) FTC_Glyph_Cache_Done( FTC_Glyph_Cache cache )
FT_EXPORT_DEF( void ) FTC_Glyph_Cache_Done( FTC_Glyph_Cache cache )
{
/* discard glyph sets */
FT_Lru_Done( cache->gsets_lru );

28
src/cache/ftcimage.c vendored
View File

@ -58,7 +58,7 @@
/*************************************************************************/
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ftc_glyph_image_node_destroy( FTC_GlyphImage node,
FTC_GlyphSet gset )
{
@ -70,7 +70,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_glyph_image_node_new( FTC_GlyphSet gset,
FT_UInt glyph_index,
FTC_GlyphImage* anode )
@ -157,7 +157,7 @@
/* this function is important because it is both part of */
/* an FTC_GlyphSet_Class and an FTC_CacheNode_Class */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_ULong ftc_glyph_image_node_size( FTC_GlyphImage node )
{
FT_ULong size = 0;
@ -208,7 +208,7 @@
/*************************************************************************/
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_image_set_init( FTC_ImageSet iset,
FTC_Image_Desc* type )
{
@ -217,7 +217,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Bool ftc_image_set_compare( FTC_ImageSet iset,
FTC_Image_Desc* type )
{
@ -225,7 +225,8 @@
}
FT_CPLUSPLUS( const FTC_GlyphSet_Class ) ftc_glyph_image_set_class =
FT_CALLBACK_TABLE_DEF
const FTC_GlyphSet_Class ftc_glyph_image_set_class =
{
sizeof( FTC_ImageSetRec ),
@ -248,7 +249,8 @@
/*************************************************************************/
FT_CPLUSPLUS( const FTC_Glyph_Cache_Class ) ftc_glyph_image_cache_class =
FT_CALLBACK_TABLE_DEF
const FTC_Glyph_Cache_Class ftc_glyph_image_cache_class =
{
{
sizeof( FTC_Image_CacheRec ),
@ -259,8 +261,8 @@
};
FT_EXPORT_FUNC( FT_Error ) FTC_Image_Cache_New( FTC_Manager manager,
FTC_Image_Cache* acache )
FT_EXPORT_DEF( FT_Error ) FTC_Image_Cache_New( FTC_Manager manager,
FTC_Image_Cache* acache )
{
return FTC_Manager_Register_Cache(
manager,
@ -269,10 +271,10 @@
}
FT_EXPORT_DEF( FT_Error ) FTC_Image_Cache_Lookup( FTC_Image_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FT_Glyph* aglyph )
FT_EXPORT( FT_Error ) FTC_Image_Cache_Lookup( FTC_Image_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FT_Glyph* aglyph )
{
FT_Error error;
FTC_GlyphSet gset;

56
src/cache/ftcmanag.c vendored
View File

@ -37,7 +37,7 @@
/*************************************************************************/
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_manager_init_face( FT_Lru lru,
FT_LruNode node )
{
@ -63,7 +63,7 @@
/* helper function for ftc_manager_done_face() */
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Bool ftc_manager_size_selector( FT_Lru lru,
FT_LruNode node,
FT_Pointer data )
@ -74,7 +74,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ftc_manager_done_face( FT_Lru lru,
FT_LruNode node )
{
@ -103,7 +103,7 @@
} FTC_FontRequest;
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_manager_init_size( FT_Lru lru,
FT_LruNode node )
{
@ -132,7 +132,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ftc_manager_done_size( FT_Lru lru,
FT_LruNode node )
{
@ -142,7 +142,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_manager_flush_size( FT_Lru lru,
FT_LruNode node,
FT_LruKey key )
@ -169,7 +169,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Bool ftc_manager_compare_size( FT_LruNode node,
FT_LruKey key )
{
@ -185,7 +185,8 @@
}
FT_CPLUSPLUS( const FT_Lru_Class ) ftc_face_lru_class =
FT_CALLBACK_TABLE_DEF
const FT_Lru_Class ftc_face_lru_class =
{
sizeof ( FT_LruRec ),
ftc_manager_init_face,
@ -195,7 +196,8 @@
};
FT_CPLUSPLUS( const FT_Lru_Class ) ftc_size_lru_class =
FT_CALLBACK_TABLE_DEF
const FT_Lru_Class ftc_size_lru_class =
{
sizeof ( FT_LruRec ),
ftc_manager_init_size,
@ -205,13 +207,13 @@
};
FT_EXPORT_FUNC( FT_Error ) FTC_Manager_New( FT_Library library,
FT_UInt max_faces,
FT_UInt max_sizes,
FT_ULong max_bytes,
FTC_Face_Requester requester,
FT_Pointer req_data,
FTC_Manager* amanager )
FT_EXPORT_DEF( FT_Error ) FTC_Manager_New( FT_Library library,
FT_UInt max_faces,
FT_UInt max_sizes,
FT_ULong max_bytes,
FTC_Face_Requester requester,
FT_Pointer req_data,
FTC_Manager* amanager )
{
FT_Error error;
FT_Memory memory;
@ -271,7 +273,7 @@
}
FT_EXPORT_DEF( void ) FTC_Manager_Done( FTC_Manager manager )
FT_EXPORT( void ) FTC_Manager_Done( FTC_Manager manager )
{
FT_Memory memory;
FT_UInt index;
@ -304,7 +306,7 @@
}
FT_EXPORT_DEF( void ) FTC_Manager_Reset( FTC_Manager manager )
FT_EXPORT( void ) FTC_Manager_Reset( FTC_Manager manager )
{
if (manager )
{
@ -315,9 +317,9 @@
}
FT_EXPORT_DEF( FT_Error ) FTC_Manager_Lookup_Face( FTC_Manager manager,
FTC_FaceID face_id,
FT_Face* aface )
FT_EXPORT( FT_Error ) FTC_Manager_Lookup_Face( FTC_Manager manager,
FTC_FaceID face_id,
FT_Face* aface )
{
if ( !manager )
return FT_Err_Invalid_Cache_Handle;
@ -328,10 +330,10 @@
}
FT_EXPORT_DEF( FT_Error ) FTC_Manager_Lookup_Size( FTC_Manager manager,
FTC_Font font,
FT_Face* aface,
FT_Size* asize )
FT_EXPORT( FT_Error ) FTC_Manager_Lookup_Size( FTC_Manager manager,
FTC_Font font,
FT_Face* aface,
FT_Size* asize )
{
FTC_FontRequest req;
FT_Error error;
@ -375,7 +377,7 @@
/* `Compress' the manager's data, i.e., get rid of old cache nodes */
/* that are not referenced anymore in order to limit the total */
/* memory used by the cache. */
FT_EXPORT_FUNC( void ) FTC_Manager_Compress( FTC_Manager manager )
FT_EXPORT_DEF( void ) FTC_Manager_Compress( FTC_Manager manager )
{
FT_ListNode node;
@ -423,7 +425,7 @@
}
FT_EXPORT_DEF( FT_Error ) FTC_Manager_Register_Cache(
FT_EXPORT( FT_Error ) FTC_Manager_Register_Cache(
FTC_Manager manager,
FTC_Cache_Class* clazz,
FTC_Cache* acache )

32
src/cache/ftcsbits.c vendored
View File

@ -52,7 +52,7 @@
/*************************************************************************/
LOCAL_FUNC_X
FT_CALLBACK_DEF
void ftc_sbit_chunk_node_destroy( FTC_ChunkNode node )
{
FTC_ChunkSet cset = node->cset;
@ -69,7 +69,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_bitmap_copy( FT_Memory memory,
FT_Bitmap* source,
FTC_SBit target )
@ -91,7 +91,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_sbit_chunk_node_new( FTC_ChunkSet cset,
FT_UInt index,
FTC_ChunkNode* anode )
@ -236,7 +236,7 @@
/* this function is important because it is both part of */
/* an FTC_ChunkSet_Class and an FTC_CacheNode_Class */
/* */
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_ULong ftc_sbit_chunk_node_size( FTC_ChunkNode node )
{
FT_ULong size;
@ -277,7 +277,7 @@
/*************************************************************************/
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_sbit_chunk_set_sizes( FTC_ChunkSet cset,
FTC_Image_Desc* desc )
{
@ -298,7 +298,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error ftc_sbit_chunk_set_init( FTC_SBitSet sset,
FTC_Image_Desc* type )
{
@ -308,7 +308,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Bool ftc_sbit_chunk_set_compare( FTC_SBitSet sset,
FTC_Image_Desc* type )
{
@ -316,7 +316,8 @@
}
FT_CPLUSPLUS( const FTC_ChunkSet_Class ) ftc_sbit_chunk_set_class =
FT_CALLBACK_TABLE_DEF
const FTC_ChunkSet_Class ftc_sbit_chunk_set_class =
{
sizeof( FTC_SBitSetRec ),
@ -340,7 +341,8 @@
/*************************************************************************/
FT_CPLUSPLUS( const FTC_Chunk_Cache_Class ) ftc_sbit_cache_class =
FT_CALLBACK_TABLE_DEF
const FTC_Chunk_Cache_Class ftc_sbit_cache_class =
{
{
sizeof( FTC_SBit_CacheRec ),
@ -351,8 +353,8 @@
};
FT_EXPORT_FUNC( FT_Error ) FTC_SBit_Cache_New( FTC_Manager manager,
FTC_SBit_Cache* acache )
FT_EXPORT_DEF( FT_Error ) FTC_SBit_Cache_New( FTC_Manager manager,
FTC_SBit_Cache* acache )
{
return FTC_Manager_Register_Cache(
manager,
@ -361,10 +363,10 @@
}
FT_EXPORT_DEF( FT_Error ) FTC_SBit_Cache_Lookup( FTC_SBit_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FTC_SBit* asbit )
FT_EXPORT( FT_Error ) FTC_SBit_Cache_Lookup( FTC_SBit_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FTC_SBit* asbit )
{
FT_Error error;
FTC_ChunkSet cset;

22
src/cache/ftlru.c vendored
View File

@ -36,12 +36,12 @@
}
FT_EXPORT_FUNC( FT_Error ) FT_Lru_New( const FT_Lru_Class* clazz,
FT_UInt max_elements,
FT_Pointer user_data,
FT_Memory memory,
FT_Bool pre_alloc,
FT_Lru* alru )
FT_EXPORT_DEF( FT_Error ) FT_Lru_New( const FT_Lru_Class* clazz,
FT_UInt max_elements,
FT_Pointer user_data,
FT_Memory memory,
FT_Bool pre_alloc,
FT_Lru* alru )
{
FT_Error error;
FT_Lru lru;
@ -278,8 +278,8 @@
}
FT_EXPORT_FUNC( void ) FT_Lru_Remove_Node( FT_Lru lru,
FT_LruNode node )
FT_EXPORT_DEF( void ) FT_Lru_Remove_Node( FT_Lru lru,
FT_LruNode node )
{
if ( !lru || !node )
return;
@ -304,9 +304,9 @@
}
FT_EXPORT_FUNC( void ) FT_Lru_Remove_Selection( FT_Lru lru,
FT_Lru_Selector selector,
FT_Pointer data )
FT_EXPORT_DEF( void ) FT_Lru_Remove_Selection( FT_Lru lru,
FT_Lru_Selector selector,
FT_Pointer data )
{
if ( !lru || !selector )
return;

5
src/cff/t2driver.c
View File

@ -302,7 +302,8 @@
/* The FT_DriverInterface structure is defined in ftdriver.h. */
FT_CPLUSPLUS( const FT_Driver_Class ) cff_driver_class =
FT_CALLBACK_TABLE_DEF
const FT_Driver_Class cff_driver_class =
{
/* begin with the FT_Module_Class fields */
{
@ -365,7 +366,7 @@
/* format-specific interface can then be retrieved through the method */
/* interface->get_format_interface. */
/* */
FT_EXPORT_FUNC( const FT_Driver_Class* ) getDriverClass( void )
FT_EXPORT_DEF( const FT_Driver_Class* ) getDriverClass( void )
{
return &cff_driver_class;
}

2
src/cff/t2driver.h
View File

@ -26,7 +26,7 @@
#endif
FT_EXPORT_VAR( const FT_Driver_Class ) cff_driver_class;
FT_CALLBACK_TABLE const FT_Driver_Class cff_driver_class;
#ifdef __cplusplus

10
src/cff/t2gload.c
View File

@ -341,7 +341,7 @@
/* */
/* slot :: The current glyph object. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void T2_Init_Decoder( T2_Decoder* decoder,
TT_Face face,
T2_Size size,
@ -364,7 +364,7 @@
/* this function is used to select the locals subrs array */
LOCAL_DEF
FT_LOCAL_DEF
void T2_Prepare_Decoder( T2_Decoder* decoder,
FT_UInt glyph_index )
{
@ -551,7 +551,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T2_Parse_CharStrings( T2_Decoder* decoder,
FT_Byte* charstring_base,
FT_Int charstring_len )
@ -1832,7 +1832,7 @@
#if 0 /* unused until we support pure CFF fonts */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T2_Compute_Max_Advance( TT_Face face,
FT_Int* max_advance )
{
@ -1899,7 +1899,7 @@
/*************************************************************************/
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T2_Load_Glyph( T2_GlyphSlot glyph,
T2_Size size,
FT_Int glyph_index,

10
src/cff/t2gload.h
View File

@ -171,31 +171,31 @@
} T2_Decoder;
LOCAL_DEF
FT_LOCAL
void T2_Init_Decoder( T2_Decoder* decoder,
TT_Face face,
T2_Size size,
T2_GlyphSlot slot );
LOCAL_DEF
FT_LOCAL
void T2_Prepare_Decoder( T2_Decoder* decoder,
FT_UInt glyph_index );
#if 0 /* unused until we support pure CFF fonts */
/* Compute the maximum advance width of a font through quick parsing */
LOCAL_DEF
FT_LOCAL
FT_Error T2_Compute_Max_Advance( TT_Face face,
FT_Int* max_advance );
#endif /* 0 */
LOCAL_DEF
FT_LOCAL
FT_Error T2_Parse_CharStrings( T2_Decoder* decoder,
FT_Byte* charstring_base,
FT_Int charstring_len );
LOCAL_DEF
FT_LOCAL
FT_Error T2_Load_Glyph( T2_GlyphSlot glyph,
T2_Size size,
FT_Int glyph_index,

14
src/cff/t2load.c
View File

@ -189,7 +189,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T2_Access_Element( CFF_Index* index,
FT_UInt element,
FT_Byte** pbytes,
@ -254,7 +254,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void T2_Forget_Element( CFF_Index* index,
FT_Byte** pbytes )
{
@ -268,7 +268,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_String* T2_Get_Name( CFF_Index* index,
FT_UInt element )
{
@ -295,7 +295,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_String* T2_Get_String( CFF_Index* index,
FT_UInt sid,
PSNames_Interface* interface )
@ -396,7 +396,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Byte CFF_Get_FD( CFF_FD_Select* select,
FT_UInt glyph_index )
{
@ -565,7 +565,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T2_Load_CFF_Font( FT_Stream stream,
FT_Int face_index,
CFF_Font* font )
@ -733,7 +733,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void T2_Done_CFF_Font( CFF_Font* font )
{
FT_Memory memory = font->memory;

14
src/cff/t2load.h
View File

@ -26,34 +26,34 @@
extern "C" {
#endif
LOCAL_DEF
FT_LOCAL
FT_String* T2_Get_Name( CFF_Index* index,
FT_UInt element );
LOCAL_DEF
FT_LOCAL
FT_String* T2_Get_String( CFF_Index* index,
FT_UInt sid,
PSNames_Interface* interface );
LOCAL_DEF
FT_LOCAL
FT_Error T2_Access_Element( CFF_Index* index,
FT_UInt element,
FT_Byte** pbytes,
FT_ULong* pbyte_len );
LOCAL_DEF
FT_LOCAL
void T2_Forget_Element( CFF_Index* index,
FT_Byte** pbytes );
LOCAL_DEF
FT_LOCAL
FT_Error T2_Load_CFF_Font( FT_Stream stream,
FT_Int face_index,
CFF_Font* font );
LOCAL_DEF
FT_LOCAL
void T2_Done_CFF_Font( CFF_Font* font );
LOCAL_DEF
FT_LOCAL
FT_Byte CFF_Get_FD( CFF_FD_Select* select,
FT_UInt glyph_index );

8
src/cff/t2objs.c
View File

@ -269,7 +269,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_DEF
FT_LOCAL
FT_Error T2_Init_Face( FT_Stream stream,
T2_Face face,
FT_Int face_index,
@ -514,7 +514,7 @@
/* <Input> */
/* face :: A pointer to the face object to destroy. */
/* */
LOCAL_DEF
FT_LOCAL
void T2_Done_Face( T2_Face face )
{
FT_Memory memory = face->root.memory;
@ -551,7 +551,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T2_Init_Driver( T2_Driver driver )
{
/* init extension registry if needed */
@ -581,7 +581,7 @@
/* <Input> */
/* driver :: A handle to the target OpenType driver. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void T2_Done_Driver( T2_Driver driver )
{
/* destroy extensions registry if needed */

8
src/cff/t2objs.h
View File

@ -115,14 +115,14 @@
/* */
/* Face functions */
/* */
LOCAL_DEF
FT_LOCAL
FT_Error T2_Init_Face( FT_Stream stream,
T2_Face face,
FT_Int face_index,
FT_Int num_params,
FT_Parameter* params );
LOCAL_DEF
FT_LOCAL
void T2_Done_Face( T2_Face face );
@ -130,10 +130,10 @@
/* */
/* Driver functions */
/* */
LOCAL_DEF
FT_LOCAL
FT_Error T2_Init_Driver( T2_Driver driver );
LOCAL_DEF
FT_LOCAL
void T2_Done_Driver( T2_Driver driver );

4
src/cff/t2parse.c
View File

@ -75,7 +75,7 @@
} T2_Field_Handler;
LOCAL_FUNC
FT_LOCAL_DEF
void T2_Parser_Init( T2_Parser* parser,
FT_UInt code,
void* object )
@ -441,7 +441,7 @@
};
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T2_Parser_Run( T2_Parser* parser,
FT_Byte* start,
FT_Byte* limit )

4
src/cff/t2parse.h
View File

@ -48,12 +48,12 @@
} T2_Parser;
LOCAL_DEF
FT_LOCAL
void T2_Parser_Init( T2_Parser* parser,
FT_UInt code,
void* object );
LOCAL_DEF
FT_LOCAL
FT_Error T2_Parser_Run( T2_Parser* parser,
FT_Byte* start,
FT_Byte* limit );

6
src/cid/cidafm.c
View File

@ -46,7 +46,7 @@
#define FT_COMPONENT trace_cidafm
LOCAL_FUNC
FT_LOCAL_DEF
void CID_Done_AFM( FT_Memory memory,
CID_AFM* afm )
{
@ -166,7 +166,7 @@
/* parse an AFM file -- for now, only read the kerning pairs */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error CID_Read_AFM( FT_Face cid_face,
FT_Stream stream )
{
@ -252,7 +252,7 @@
/* find the kerning for a given glyph pair */
LOCAL_FUNC
FT_LOCAL_DEF
void CID_Get_Kerning( CID_AFM* afm,
FT_UInt glyph1,
FT_UInt glyph2,

6
src/cid/cidafm.h
View File

@ -52,15 +52,15 @@
} CID_AFM;
LOCAL_DEF
FT_LOCAL
FT_Error CID_Read_AFM( FT_Face cid_face,
FT_Stream stream );
LOCAL_DEF
FT_LOCAL
void CID_Done_AFM( FT_Memory memory,
CID_AFM* afm );
LOCAL_DEF
FT_LOCAL
void CID_Get_Kerning( CID_AFM* afm,
FT_UInt glyph1,
FT_UInt glyph2,

11
src/cid/cidgload.c
View File

@ -44,7 +44,7 @@
#define FT_COMPONENT trace_cidgload
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error cid_load_glyph( T1_Decoder* decoder,
FT_UInt glyph_index )
{
@ -138,7 +138,7 @@
/*************************************************************************/
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error CID_Compute_Max_Advance( CID_Face face,
FT_Int* max_advance )
{
@ -200,7 +200,7 @@
/*************************************************************************/
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error CID_Load_Glyph( CID_GlyphSlot glyph,
CID_Size size,
FT_Int glyph_index,
@ -266,6 +266,10 @@
{
glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
glyph->root.metrics.horiAdvance = decoder.builder.advance.x;
glyph->root.glyph_matrix = font_matrix;
glyph->root.glyph_delta = font_offset;
glyph->root.glyph_transformed = 1;
}
else
{
@ -276,6 +280,7 @@
/* copy the _unscaled_ advance width */
metrics->horiAdvance = decoder.builder.advance.x;
glyph->root.linearHoriAdvance = decoder.builder.advance.x;
glyph->root.glyph_transformed = 0;
/* make up vertical metrics */
metrics->vertBearingX = 0;

4
src/cid/cidgload.h
View File

@ -39,13 +39,13 @@
#if 0
/* Compute the maximum advance width of a font through quick parsing */
LOCAL_DEF
FT_LOCAL
FT_Error CID_Compute_Max_Advance( CID_Face face,
FT_Int* max_advance );
#endif /* 0 */
LOCAL_DEF
FT_LOCAL
FT_Error CID_Load_Glyph( CID_GlyphSlot glyph,
CID_Size size,
FT_Int glyph_index,

12
src/cid/cidload.c
View File

@ -50,7 +50,7 @@
/* read a single offset */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Long cid_get_offset( FT_Byte** start,
FT_Byte offsize )
{
@ -69,7 +69,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void cid_decrypt( FT_Byte* buffer,
FT_Int length,
FT_UShort seed )
@ -167,7 +167,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error parse_font_bbox( CID_Face face,
CID_Parser* parser )
{
@ -186,7 +186,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error parse_font_matrix( CID_Face face,
CID_Parser* parser )
{
@ -230,7 +230,7 @@
}
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Error parse_fd_array( CID_Face face,
CID_Parser* parser )
{
@ -519,7 +519,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error CID_Open_Face( CID_Face face )
{
CID_Loader loader;

6
src/cid/cidload.h
View File

@ -45,16 +45,16 @@
} CID_Loader;
LOCAL_DEF
FT_LOCAL
FT_Long cid_get_offset( FT_Byte** start,
FT_Byte offsize );
LOCAL_DEF
FT_LOCAL
void cid_decrypt( FT_Byte* buffer,
FT_Int length,
FT_UShort seed );
LOCAL_DEF
FT_LOCAL
FT_Error CID_Open_Face( CID_Face face );

8
src/cid/cidobjs.c
View File

@ -65,7 +65,7 @@
/* <Input> */
/* face :: A pointer to the face object to destroy. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void CID_Done_Face( CID_Face face )
{
FT_Memory memory;
@ -124,7 +124,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error CID_Init_Face( FT_Stream stream,
CID_Face face,
FT_Int face_index,
@ -361,7 +361,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error CID_Init_Driver( CID_Driver driver )
{
FT_UNUSED( driver );
@ -381,7 +381,7 @@
/* <Input> */
/* driver :: A handle to the target CID driver. */
/* */
LOCAL_DEF
FT_LOCAL
void CID_Done_Driver( CID_Driver driver )
{
FT_UNUSED( driver );

8
src/cid/cidobjs.h
View File

@ -112,21 +112,21 @@
} CID_GlyphSlotRec;
LOCAL_DEF
FT_LOCAL
FT_Error CID_Init_Face( FT_Stream stream,
CID_Face face,
FT_Int face_index,
FT_Int num_params,
FT_Parameter* params );
LOCAL_DEF
FT_LOCAL
void CID_Done_Face( CID_Face face );
LOCAL_DEF
FT_LOCAL
FT_Error CID_Init_Driver( CID_Driver driver );
LOCAL_DEF
FT_LOCAL
void CID_Done_Driver( CID_Driver driver );

4
src/cid/cidparse.c
View File

@ -58,7 +58,7 @@
/*************************************************************************/
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error CID_New_Parser( CID_Parser* parser,
FT_Stream stream,
FT_Memory memory,
@ -147,7 +147,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void CID_Done_Parser( CID_Parser* parser )
{
/* always free the private dictionary */

4
src/cid/cidparse.h
View File

@ -70,13 +70,13 @@
} CID_Parser;
LOCAL_DEF
FT_LOCAL
FT_Error CID_New_Parser( CID_Parser* parser,
FT_Stream stream,
FT_Memory memory,
PSAux_Interface* psaux );
LOCAL_DEF
FT_LOCAL
void CID_Done_Parser( CID_Parser* parser );

5
src/cid/cidriver.c
View File

@ -182,7 +182,8 @@
}
FT_CPLUSPLUS( const FT_Driver_Class ) t1cid_driver_class =
FT_CALLBACK_TABLE_DEF
const FT_Driver_Class t1cid_driver_class =
{
/* first of all, the FT_Module_Class fields */
{
@ -247,7 +248,7 @@
/* format-specific interface can then be retrieved through the method */
/* interface->get_format_interface. */
/* */
FT_EXPORT_FUNC( const FT_Driver_Class* ) getDriverClass( void )
FT_EXPORT_DEF( const FT_Driver_Class* ) getDriverClass( void )
{
return &t1cid_driver_class;
}

3
src/cid/cidriver.h
View File

@ -26,7 +26,8 @@
#endif
FT_EXPORT_VAR( const FT_Driver_Class ) t1cid_driver_class;
FT_CALLBACK_TABLE
const FT_Driver_Class t1cid_driver_class;
#ifdef __cplusplus
}

15
src/psaux/psauxmod.c
View File

@ -21,7 +21,8 @@
#include <psaux/t1decode.h>
FT_CPLUSPLUS( const PS_Table_Funcs ) ps_table_funcs =
FT_CALLBACK_TABLE_DEF
const PS_Table_Funcs ps_table_funcs =
{
PS_Table_New,
PS_Table_Done,
@ -30,7 +31,8 @@
};
FT_CPLUSPLUS( const T1_Parser_Funcs ) t1_parser_funcs =
FT_CALLBACK_TABLE_DEF
const T1_Parser_Funcs t1_parser_funcs =
{
T1_Init_Parser,
T1_Done_Parser,
@ -47,7 +49,8 @@
};
FT_CPLUSPLUS( const T1_Builder_Funcs ) t1_builder_funcs =
FT_CALLBACK_TABLE_DEF
const T1_Builder_Funcs t1_builder_funcs =
{
T1_Builder_Init,
T1_Builder_Done,
@ -60,7 +63,8 @@
};
FT_CPLUSPLUS( const T1_Decoder_Funcs ) t1_decoder_funcs =
FT_CALLBACK_TABLE_DEF
const T1_Decoder_Funcs t1_decoder_funcs =
{
T1_Decoder_Init,
T1_Decoder_Done,
@ -80,7 +84,8 @@
};
FT_CPLUSPLUS( const FT_Module_Class ) psaux_module_class =
FT_CALLBACK_TABLE_DEF
const FT_Module_Class psaux_module_class =
{
0,
sizeof( FT_ModuleRec ),

54
src/psaux/psobjs.c
View File

@ -59,7 +59,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error PS_Table_New( PS_Table* table,
FT_Int count,
FT_Memory memory )
@ -151,7 +151,7 @@
/* FreeType error code. 0 means success. An error is returned if a */
/* reallocation fails. */
/* */
LOCAL_DEF
FT_LOCAL
FT_Error PS_Table_Add( PS_Table* table,
FT_Int index,
void* object,
@ -203,7 +203,7 @@
/* This function does NOT release the heap's memory block. It is up */
/* to the caller to clean it, or reference it in its own structures. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void PS_Table_Done( PS_Table* table )
{
FT_Memory memory = table->memory;
@ -225,7 +225,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void PS_Table_Release( PS_Table* table )
{
FT_Memory memory = table->memory;
@ -256,7 +256,7 @@
#define IS_T1_SPACE( c ) ( IS_T1_WHITESPACE( c ) || IS_T1_LINESPACE( c ) )
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Skip_Spaces( T1_Parser* parser )
{
FT_Byte* cur = parser->cursor;
@ -276,7 +276,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Skip_Alpha( T1_Parser* parser )
{
FT_Byte* cur = parser->cursor;
@ -296,7 +296,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void T1_ToToken( T1_Parser* parser,
T1_Token* token )
{
@ -379,7 +379,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void T1_ToTokenArray( T1_Parser* parser,
T1_Token* tokens,
FT_UInt max_tokens,
@ -775,7 +775,7 @@
/* Load a simple field (i.e. non-table) into the current list of objects */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Load_Field( T1_Parser* parser,
const T1_Field* field,
void** objects,
@ -896,7 +896,7 @@
#define T1_MAX_TABLE_ELEMENTS 32
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Load_Field_Table( T1_Parser* parser,
const T1_Field* field,
void** objects,
@ -959,14 +959,14 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Long T1_ToInt( T1_Parser* parser )
{
return t1_toint( &parser->cursor, parser->limit );
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Fixed T1_ToFixed( T1_Parser* parser,
FT_Int power_ten )
{
@ -974,7 +974,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Int T1_ToCoordArray( T1_Parser* parser,
FT_Int max_coords,
FT_Short* coords )
@ -984,7 +984,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Int T1_ToFixedArray( T1_Parser* parser,
FT_Int max_values,
FT_Fixed* values,
@ -997,14 +997,14 @@
#if 0
LOCAL_FUNC
FT_LOCAL_DEF
FT_String* T1_ToString( T1_Parser* parser )
{
return t1_tostring( &parser->cursor, parser->limit, parser->memory );
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Bool T1_ToBool( T1_Parser* parser )
{
return t1_tobool( &parser->cursor, parser->limit );
@ -1013,7 +1013,7 @@
#endif /* 0 */
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Init_Parser( T1_Parser* parser,
FT_Byte* base,
FT_Byte* limit,
@ -1028,7 +1028,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Done_Parser( T1_Parser* parser )
{
FT_UNUSED( parser );
@ -1061,7 +1061,7 @@
/* */
/* glyph :: The current glyph object. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Builder_Init( T1_Builder* builder,
FT_Face face,
FT_Size size,
@ -1116,7 +1116,7 @@
/* <Input> */
/* builder :: A pointer to the glyph builder to finalize. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Builder_Done( T1_Builder* builder )
{
FT_GlyphSlot glyph = builder->glyph;
@ -1128,7 +1128,7 @@
/* check that there is enough room for `count' more points */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Builder_Check_Points( T1_Builder* builder,
FT_Int count )
{
@ -1137,7 +1137,7 @@
/* add a new point, do not check space */
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Builder_Add_Point( T1_Builder* builder,
FT_Pos x,
FT_Pos y,
@ -1168,7 +1168,7 @@
/* check space for a new on-curve point, then add it */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Builder_Add_Point1( T1_Builder* builder,
FT_Pos x,
FT_Pos y )
@ -1185,7 +1185,7 @@
/* check room for a new contour, then add it */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Builder_Add_Contour( T1_Builder* builder )
{
FT_Outline* outline = builder->current;
@ -1212,7 +1212,7 @@
/* if a path was begun, add its first on-curve point */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Builder_Start_Point( T1_Builder* builder,
FT_Pos x,
FT_Pos y )
@ -1233,7 +1233,7 @@
/* close the current contour */
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Builder_Close_Contour( T1_Builder* builder )
{
FT_Outline* outline = builder->current;
@ -1275,7 +1275,7 @@
/*************************************************************************/
/*************************************************************************/
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Decrypt( FT_Byte* buffer,
FT_Int length,
FT_UShort seed )

56
src/psaux/psobjs.h
View File

@ -36,32 +36,32 @@
/*************************************************************************/
LOCAL_VAR
FT_CALLBACK_TABLE
const PS_Table_Funcs ps_table_funcs;
LOCAL_VAR
FT_CALLBACK_TABLE
const T1_Parser_Funcs t1_parser_funcs;
LOCAL_VAR
FT_CALLBACK_TABLE
const T1_Builder_Funcs t1_builder_funcs;
LOCAL_DEF
FT_LOCAL
FT_Error PS_Table_New( PS_Table* table,
FT_Int count,
FT_Memory memory );
LOCAL_DEF
FT_LOCAL
FT_Error PS_Table_Add( PS_Table* table,
FT_Int index,
void* object,
FT_Int length );
LOCAL_DEF
FT_LOCAL
void PS_Table_Done( PS_Table* table );
LOCAL_DEF
FT_LOCAL
void PS_Table_Release( PS_Table* table );
@ -74,64 +74,64 @@
/*************************************************************************/
LOCAL_DEF
FT_LOCAL
void T1_Skip_Spaces( T1_Parser* parser );
LOCAL_DEF
FT_LOCAL
void T1_Skip_Alpha( T1_Parser* parser );
LOCAL_DEF
FT_LOCAL
void T1_ToToken( T1_Parser* parser,
T1_Token* token );
LOCAL_DEF
FT_LOCAL
void T1_ToTokenArray( T1_Parser* parser,
T1_Token* tokens,
FT_UInt max_tokens,
FT_Int* pnum_tokens );
LOCAL_DEF
FT_LOCAL
FT_Error T1_Load_Field( T1_Parser* parser,
const T1_Field* field,
void** objects,
FT_UInt max_objects,
FT_ULong* pflags );
LOCAL_DEF
FT_LOCAL
FT_Error T1_Load_Field_Table( T1_Parser* parser,
const T1_Field* field,
void** objects,
FT_UInt max_objects,
FT_ULong* pflags );
LOCAL_DEF
FT_LOCAL
FT_Long T1_ToInt( T1_Parser* parser );
LOCAL_DEF
FT_LOCAL
FT_Fixed T1_ToFixed( T1_Parser* parser,
FT_Int power_ten );
LOCAL_DEF
FT_LOCAL
FT_Int T1_ToCoordArray( T1_Parser* parser,
FT_Int max_coords,
FT_Short* coords );
LOCAL_DEF
FT_LOCAL
FT_Int T1_ToFixedArray( T1_Parser* parser,
FT_Int max_values,
FT_Fixed* values,
FT_Int power_ten );
LOCAL_DEF
FT_LOCAL
void T1_Init_Parser( T1_Parser* parser,
FT_Byte* base,
FT_Byte* limit,
FT_Memory memory );
LOCAL_DEF
FT_LOCAL
void T1_Done_Parser( T1_Parser* parser );
@ -143,41 +143,41 @@
/*************************************************************************/
/*************************************************************************/
LOCAL_DEF
FT_LOCAL
void T1_Builder_Init( T1_Builder* builder,
FT_Face face,
FT_Size size,
FT_GlyphSlot glyph );
LOCAL_DEF
FT_LOCAL
void T1_Builder_Done( T1_Builder* builder );
LOCAL_DEF
FT_LOCAL
FT_Error T1_Builder_Check_Points( T1_Builder* builder,
FT_Int count );
LOCAL_DEF
FT_LOCAL
void T1_Builder_Add_Point( T1_Builder* builder,
FT_Pos x,
FT_Pos y,
FT_Byte flag );
LOCAL_DEF
FT_LOCAL
FT_Error T1_Builder_Add_Point1( T1_Builder* builder,
FT_Pos x,
FT_Pos y );
LOCAL_DEF
FT_LOCAL
FT_Error T1_Builder_Add_Contour( T1_Builder* builder );
LOCAL_DEF
FT_LOCAL
FT_Error T1_Builder_Start_Point( T1_Builder* builder,
FT_Pos x,
FT_Pos y );
LOCAL_DEF
FT_LOCAL
void T1_Builder_Close_Contour( T1_Builder* builder );
@ -189,7 +189,7 @@
/*************************************************************************/
/*************************************************************************/
LOCAL_DEF
FT_LOCAL
void T1_Decrypt( FT_Byte* buffer,
FT_Int length,
FT_UShort seed );

8
src/psaux/t1decode.c
View File

@ -322,7 +322,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Decoder_Parse_Charstrings( T1_Decoder* decoder,
FT_Byte* charstring_base,
FT_UInt charstring_len )
@ -1018,7 +1018,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Decoder_Parse_Glyph( T1_Decoder* decoder,
FT_UInt glyph )
{
@ -1026,7 +1026,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error T1_Decoder_Init( T1_Decoder* decoder,
FT_Face face,
FT_Size size,
@ -1066,7 +1066,7 @@
}
LOCAL_FUNC
FT_LOCAL_DEF
void T1_Decoder_Done( T1_Decoder* decoder )
{
T1_Builder_Done( &decoder->builder );

11
src/psaux/t1decode.h
View File

@ -29,20 +29,19 @@
#endif
LOCAL_VAR
const T1_Decoder_Funcs t1_decoder_funcs;
FT_CALLBACK_TABLE const T1_Decoder_Funcs t1_decoder_funcs;
LOCAL_DEF
FT_LOCAL
FT_Error T1_Decoder_Parse_Glyph( T1_Decoder* decoder,
FT_UInt glyph_index );
LOCAL_DEF
FT_LOCAL
FT_Error T1_Decoder_Parse_Charstrings( T1_Decoder* decoder,
FT_Byte* base,
FT_UInt len );
LOCAL_DEF
FT_LOCAL
FT_Error T1_Decoder_Init( T1_Decoder* decoder,
FT_Face face,
FT_Size size,
@ -51,7 +50,7 @@
T1_Blend* blend,
T1_Decoder_Callback parse_glyph );
LOCAL_DEF
FT_LOCAL
void T1_Decoder_Done( T1_Decoder* decoder );

5
src/psnames/psmodule.c
View File

@ -139,7 +139,7 @@
/* qsort callback to sort the unicode map */
LOCAL_FUNC_X
FT_CALLBACK_DEF
int compare_uni_maps( const void* a,
const void* b )
{
@ -297,7 +297,8 @@
#endif /* !FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES */
FT_CPLUSPLUS( const FT_Module_Class ) psnames_module_class =
FT_CALLBACK_TABLE_DEF
const FT_Module_Class psnames_module_class =
{
0, /* this is not a font driver, nor a renderer */
sizeof( FT_ModuleRec ),

6
src/raster/ftraster.c
View File

@ -2971,7 +2971,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error Render_Glyph( RAS_ARG )
{
FT_Error error;
@ -3033,7 +3033,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error Render_Gray_Glyph( RAS_ARG )
{
Long pixel_width;
@ -3093,7 +3093,7 @@
#else /* FT_RASTER_OPTION_ANTI_ALIASING */
LOCAL_FUNC
FT_LOCAL_DEF
FT_Error Render_Gray_Glyph( RAS_ARG )
{
FT_UNUSED_RASTER;

6
src/raster/ftrend1.c
View File

@ -213,7 +213,8 @@
}
FT_CPLUSPLUS( const FT_Renderer_Class ) ft_raster1_renderer_class =
FT_CALLBACK_TABLE_DEF
const FT_Renderer_Class ft_raster1_renderer_class =
{
{
ft_module_renderer,
@ -245,7 +246,8 @@
/* to register it by hand in your application. It should only be */
/* used for backwards-compatibility with FT 1.x anyway. */
/* */
FT_CPLUSPLUS( const FT_Renderer_Class ) ft_raster5_renderer_class =
FT_CALLBACK_TABLE_DEF
const FT_Renderer_Class ft_raster5_renderer_class =
{
{
ft_module_renderer,

5
src/sfnt/sfdriver.c
View File

@ -122,7 +122,7 @@
#endif /* TT_CONFIG_OPTION_POSTSCRIPT_NAMES */
LOCAL_FUNC_X
FT_CALLBACK_DEF
FT_Module_Interface SFNT_Get_Interface( FT_Module module,
const char* interface )
{
@ -204,7 +204,8 @@
};
FT_CPLUSPLUS( const FT_Module_Class ) sfnt_module_class =
FT_CALLBACK_TABLE_DEF
const FT_Module_Class sfnt_module_class =
{
0, /* not a font driver or renderer */
sizeof( FT_ModuleRec ),

Some files were not shown because too many files have changed in this diff Show More