1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
|
/****************************************************************************
*
* 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.
*
* Example:
*
* #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 defined statement macros.
*
* Example:
*
* #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.
*
* Example:
*
* #define PAD_( x, n ) ( (x) & ~FT_TYPEOF( x )( (n) - 1 ) )
*
* (The `typeof` condition is 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.
*/
/* Visual C, mingw */
#if defined( _WIN32 )
#define FT_INTERNAL_FUNCTION_ATTRIBUTE /* empty */
/* gcc, clang */
#elif ( defined( __GNUC__ ) && __GNUC__ >= 4 ) || defined( __clang__ )
#define FT_INTERNAL_FUNCTION_ATTRIBUTE \
__attribute__(( visibility( "hidden" ) ))
/* Sun */
#elif defined( __SUNPRO_C ) && __SUNPRO_C >= 0x550
#define FT_INTERNAL_FUNCTION_ATTRIBUTE __hidden
#else
#define FT_INTERNAL_FUNCTION_ATTRIBUTE /* empty */
#endif
/*
* FreeType supports compilation of its C sources with a C++ compiler (in
* C++ mode); 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
* functions with C linkage (i.e., within an `extern "C" { ... }` block
* due to the magic of FT_BEGIN_HEADER and FT_END_HEADER), 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` and its
* siblings below.
*/
/*
* `FT_FUNCTION_DECLARATION( type )` can be used to write a C function
* declaration to 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 of `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`, and `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`, and
* `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` and `FT_LOCAL_DEF` to declare and define, respectively,
* an internal FreeType function that is only used by the sources of a
* single `src/module/` directory. This ensures that 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` and `FT_LOCAL_ARRAY_DEF` to declare and define,
* respectively, a constant array that must be accessed from several
* sources in the same `src/module/` sub-directory, and which are 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` and `FT_BASE_DEF` to declare and define, respectively, an
* internal library function that is used by more than a 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_ */
|
