forked from minhngoc25a/freetype2
268 lines
11 KiB
C
268 lines
11 KiB
C
/****************************************************************************
|
|
*
|
|
* internal/compiler-macros.h
|
|
*
|
|
* Compiler-specific macro definitions used internally by FreeType.
|
|
*
|
|
* Copyright (C) 2020 by
|
|
* David Turner, Robert Wilhelm, and Werner Lemberg.
|
|
*
|
|
* This file is part of the FreeType project, and may only be used,
|
|
* modified, and distributed under the terms of the FreeType project
|
|
* license, LICENSE.TXT. By continuing to use, modify, or distribute
|
|
* this file you indicate that you have read the license and
|
|
* understand and accept it fully.
|
|
*
|
|
*/
|
|
|
|
#ifndef INTERNAL_COMPILER_MACROS_H_
|
|
#define INTERNAL_COMPILER_MACROS_H_
|
|
|
|
#include <freetype/config/public-macros.h>
|
|
|
|
FT_BEGIN_HEADER
|
|
|
|
/* Fix compiler warning with sgi compiler. */
|
|
#if defined( __sgi ) && !defined( __GNUC__ )
|
|
# if defined( _COMPILER_VERSION ) && ( _COMPILER_VERSION >= 730 )
|
|
# pragma set woff 3505
|
|
# endif
|
|
#endif
|
|
|
|
/* Fix compiler warning with sgi compiler. */
|
|
#if defined( __sgi ) && !defined( __GNUC__ )
|
|
# if defined( _COMPILER_VERSION ) && ( _COMPILER_VERSION >= 730 )
|
|
# pragma set woff 3505
|
|
# endif
|
|
#endif
|
|
|
|
/* When defining a macro that expands to a non-trivial C statement, use
|
|
* FT_BEGIN_STMNT and FT_END_STMNT to enclose the macro's body. This ensures
|
|
* there are no surprises when the macro is invoked in conditional branches.
|
|
*
|
|
* E.g.:
|
|
* #define LOG(...) \
|
|
* FT_BEGIN_STMNT \
|
|
* if (logging_enabled) \
|
|
* log(__VA_ARGS__); \
|
|
* FT_END_STMNT
|
|
*/
|
|
#define FT_BEGIN_STMNT do {
|
|
#define FT_END_STMNT } while ( 0 )
|
|
|
|
/* FT_DUMMY_STMNT expands to an empty C statement. Useful for conditionally
|
|
* define statement macros, as in:
|
|
*
|
|
* #ifdef BUILD_CONFIG_LOGGING
|
|
* # define LOG(...) \
|
|
* FT_BEGIN_STMNT \
|
|
* if (logging_enabled) \
|
|
* log(__VA_ARGS__); \
|
|
* FT_END_STMNT
|
|
* #else
|
|
* # define LOG(...) FT_DUMMY_STMNT
|
|
* #endif
|
|
*/
|
|
#define FT_DUMMY_STMNT FT_BEGIN_STMNT FT_END_STMNT
|
|
|
|
#ifdef _WIN64
|
|
/* only 64bit Windows uses the LLP64 data model, i.e., */
|
|
/* 32-bit integers, 64-bit pointers. */
|
|
#define FT_UINT_TO_POINTER( x ) (void*)(unsigned __int64)(x)
|
|
#else
|
|
#define FT_UINT_TO_POINTER( x ) (void*)(unsigned long)(x)
|
|
#endif
|
|
|
|
/* Use FT_TYPEOF(type) to cast a value to |type|. This is useful to suppress
|
|
* signedness compilation warnings in macros as in:
|
|
*
|
|
* #define PAD_(x, n) ( (x) & ~FT_TYPEOF( x )( (n) - 1 ) )
|
|
*
|
|
* `typeof` condition taken from gnulib's `intprops.h` header file
|
|
*/
|
|
#if ( ( defined( __GNUC__ ) && __GNUC__ >= 2 ) || \
|
|
( defined( __IBMC__ ) && __IBMC__ >= 1210 && \
|
|
defined( __IBM__TYPEOF__ ) ) || \
|
|
( defined( __SUNPRO_C ) && __SUNPRO_C >= 0x5110 && !__STDC__ ) )
|
|
#define FT_TYPEOF( type ) ( __typeof__ ( type ) )
|
|
#else
|
|
#define FT_TYPEOF( type ) /* empty */
|
|
#endif
|
|
|
|
/* Mark a function declaration as internal to the library. This ensures that
|
|
* it will not be exposed by default to client code, and helps generate smaller
|
|
* and faster code on ELF-based platforms. Place this before a function
|
|
* declaration.
|
|
*/
|
|
#if (defined(__GNUC__) && __GNUC__ >= 4) || defined(__clang__)
|
|
#define FT_INTERNAL_FUNCTION_ATTRIBUTE __attribute__((visibility("hidden")))
|
|
#else
|
|
#define FT_INTERNAL_FUNCTION_ATTRIBUTE /* nothing */
|
|
#endif
|
|
|
|
/* FreeType supports compiling its C sources to be compiled as C++ instead,
|
|
* this introduces a number of subtle issues.
|
|
*
|
|
* The main one is that a C++ function declaration and its definition must have
|
|
* the same 'linkage'. Because all FreeType headers declare their function with
|
|
* C linkage (i.e. within an extern "C" { .. } block, due to the magic of
|
|
* FT_BEGIN_HEADER and FT_END_HEADER), then their definition in FreeType
|
|
* sources should also be prefixed with 'extern "C"' when compiled in C++ mode.
|
|
*
|
|
* The FT_FUNCTION_DECLARATION() and FT_FUNCTION_DEFINITION() macros are
|
|
* provided to deal with this case, as well as FT_CALLBACK_DEF et al below.
|
|
*/
|
|
|
|
/* FT_FUNCTION_DECLARATION(type) can be used to write a C function declaration,
|
|
* and ensure it will have C linkage when the library is built with a C++
|
|
* compiler. The parameter is the function's return type, so a declaration
|
|
* would look like:
|
|
*
|
|
* FT_FUNCTION_DECLARATION(int) foo(int x);
|
|
*
|
|
* NOTE: This requires that all uses are inside FT_BEGIN_HEADER..FT_END_HEADER
|
|
* blocks. Which guarantees that the declarations have C linkage when the
|
|
* headers are included by C++ sources.
|
|
*
|
|
* NOTE: Do not use directly, use FT_LOCAL()/FT_BASE()/FT_EXPORT() instead.
|
|
*/
|
|
#define FT_FUNCTION_DECLARATION( x ) extern x
|
|
|
|
/* Same as FT_FUNCTION_DECLARATION(), but for function definitions instead.
|
|
* NOTE: Do not use directly, use FT_LOCAL_DEF()/FT_BASE_DEF()/FT_EXPORT_DEF()
|
|
* instead.
|
|
*/
|
|
#ifdef __cplusplus
|
|
#define FT_FUNCTION_DEFINITION( x ) extern "C" x
|
|
#else
|
|
#define FT_FUNCTION_DEFINITION( x ) x
|
|
#endif
|
|
|
|
/* Use FT_LOCAL()/FT_LOCAL_DEF() to declare and define an internal FreeType
|
|
* function that is only used by the sources of a single src/module/ directory.
|
|
* This ensures the functions are turned into static ones at build time,
|
|
* resulting in smaller and faster code.
|
|
*/
|
|
#ifdef FT_MAKE_OPTION_SINGLE_OBJECT
|
|
|
|
# define FT_LOCAL( x ) static x
|
|
# define FT_LOCAL_DEF( x ) static x
|
|
|
|
#else
|
|
|
|
#define FT_LOCAL( x ) FT_INTERNAL_FUNCTION_ATTRIBUTE FT_FUNCTION_DECLARATION( x )
|
|
#define FT_LOCAL_DEF( x ) FT_FUNCTION_DEFINITION( x )
|
|
|
|
#endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
|
|
|
|
/* Use FT_LOCAL_ARRAY()/FT_LOCAL_ARRAY_DEF() to declare and define a constant
|
|
* array that must be accessed from several sources in the same src/module/
|
|
* sub-directory, but are otherwise internal to the library.
|
|
*/
|
|
#define FT_LOCAL_ARRAY( x ) FT_INTERNAL_FUNCTION_ATTRIBUTE extern const x
|
|
#define FT_LOCAL_ARRAY_DEF( x ) FT_FUNCTION_DEFINITION( const x )
|
|
|
|
/* Use FT_BASE()/FT_BASE_DEF() to declare or define an internal library
|
|
* function that are used by more than one single module.
|
|
*/
|
|
#define FT_BASE( x ) FT_INTERNAL_FUNCTION_ATTRIBUTE FT_FUNCTION_DECLARATION( x )
|
|
#define FT_BASE_DEF( x ) FT_FUNCTION_DEFINITION( x )
|
|
|
|
|
|
/* NOTE: Conditionally define FT_EXPORT_VAR() due to its definition in
|
|
* src/smooth/ftgrays.h to make the header more portable.
|
|
*/
|
|
#ifndef FT_EXPORT_VAR
|
|
#define FT_EXPORT_VAR( x ) FT_FUNCTION_DECLARATION( x )
|
|
#endif
|
|
|
|
/* When compiling FreeType as a DLL or DSO with hidden visibility */
|
|
/* some systems/compilers need a special attribute in front OR after */
|
|
/* the return type of function declarations. */
|
|
/* */
|
|
/* Two macros are used within the FreeType source code to define */
|
|
/* exported library functions: `FT_EXPORT` and `FT_EXPORT_DEF`. */
|
|
/* */
|
|
/* - `FT_EXPORT( return_type )` */
|
|
/* */
|
|
/* is used in a function declaration, as in */
|
|
/* */
|
|
/* ``` */
|
|
/* FT_EXPORT( FT_Error ) */
|
|
/* FT_Init_FreeType( FT_Library* alibrary ); */
|
|
/* ``` */
|
|
/* */
|
|
/* - `FT_EXPORT_DEF( return_type )` */
|
|
/* */
|
|
/* is used in a function definition, as in */
|
|
/* */
|
|
/* ``` */
|
|
/* 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` and */
|
|
/* `FT_EXPORT_DEF` here if you want. */
|
|
/* */
|
|
/* To export a variable, use `FT_EXPORT_VAR`. */
|
|
/* */
|
|
|
|
/* See <freetype/config/compiler_macros.h> for the FT_EXPORT() definition */
|
|
#define FT_EXPORT_DEF( x ) FT_FUNCTION_DEFINITION( x )
|
|
|
|
/* The following macros are needed to compile the library with a */
|
|
/* C++ compiler and with 16bit compilers. */
|
|
/* */
|
|
|
|
/* This is special. Within C++, you must specify `extern "C"` for */
|
|
/* functions which are used via function pointers, and you also */
|
|
/* must do that for structures which contain function pointers to */
|
|
/* 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, */
|
|
/* located in the same source code file as the structure that uses */
|
|
/* it. */
|
|
/* */
|
|
/* FT_BASE_CALLBACK and FT_BASE_CALLBACK_DEF are used to declare */
|
|
/* and define a callback function, respectively, in a similar way */
|
|
/* as FT_BASE and FT_BASE_DEF work. */
|
|
/* */
|
|
/* 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. */
|
|
/* */
|
|
/* */
|
|
/* Some 16bit compilers have to redefine these macros to insert */
|
|
/* the infamous `_cdecl` or `__fastcall` declarations. */
|
|
/* */
|
|
#ifdef __cplusplus
|
|
#define FT_CALLBACK_DEF( x ) extern "C" x
|
|
#else
|
|
#define FT_CALLBACK_DEF( x ) static x
|
|
#endif
|
|
|
|
#define FT_BASE_CALLBACK( x ) FT_FUNCTION_DECLARATION( x )
|
|
#define FT_BASE_CALLBACK_DEF( x ) FT_FUNCTION_DEFINITION( x )
|
|
|
|
#ifndef FT_CALLBACK_TABLE
|
|
#ifdef __cplusplus
|
|
#define FT_CALLBACK_TABLE extern "C"
|
|
#define FT_CALLBACK_TABLE_DEF extern "C"
|
|
#else
|
|
#define FT_CALLBACK_TABLE extern
|
|
#define FT_CALLBACK_TABLE_DEF /* nothing */
|
|
#endif
|
|
#endif /* FT_CALLBACK_TABLE */
|
|
|
|
FT_END_HEADER
|
|
|
|
#endif /* INTERNAL_COMPILER_MACROS_H_ */
|