Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
3918 | Serge | 1 | /***************************************************************************/ |
2 | /* */ |
||
3 | /* ftconfig.in */ |
||
4 | /* */ |
||
5 | /* UNIX-specific configuration file (specification only). */ |
||
6 | /* */ |
||
7 | /* Copyright 1996-2004, 2006-2009, 2011, 2013 by */ |
||
8 | /* David Turner, Robert Wilhelm, and Werner Lemberg. */ |
||
9 | /* */ |
||
10 | /* This file is part of the FreeType project, and may only be used, */ |
||
11 | /* modified, and distributed under the terms of the FreeType project */ |
||
12 | /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ |
||
13 | /* this file you indicate that you have read the license and */ |
||
14 | /* understand and accept it fully. */ |
||
15 | /* */ |
||
16 | /***************************************************************************/ |
||
17 | |||
18 | |||
19 | /*************************************************************************/ |
||
20 | /* */ |
||
21 | /* This header file contains a number of macro definitions that are used */ |
||
22 | /* by the rest of the engine. Most of the macros here are automatically */ |
||
23 | /* determined at compile time, and you should not need to change it to */ |
||
24 | /* port FreeType, except to compile the library with a non-ANSI */ |
||
25 | /* compiler. */ |
||
26 | /* */ |
||
27 | /* Note however that if some specific modifications are needed, we */ |
||
28 | /* advise you to place a modified copy in your build directory. */ |
||
29 | /* */ |
||
30 | /* The build directory is usually `freetype/builds/ |
||
31 | /* contains system-specific files that are always included first when */ |
||
32 | /* building the library. */ |
||
33 | /* */ |
||
34 | /*************************************************************************/ |
||
35 | |||
36 | |||
37 | #ifndef __FTCONFIG_H__ |
||
38 | #define __FTCONFIG_H__ |
||
39 | |||
40 | #include |
||
41 | #include FT_CONFIG_OPTIONS_H |
||
42 | #include FT_CONFIG_STANDARD_LIBRARY_H |
||
43 | |||
44 | |||
45 | FT_BEGIN_HEADER |
||
46 | |||
47 | |||
48 | /*************************************************************************/ |
||
49 | /* */ |
||
50 | /* PLATFORM-SPECIFIC CONFIGURATION MACROS */ |
||
51 | /* */ |
||
52 | /* These macros can be toggled to suit a specific system. The current */ |
||
53 | /* ones are defaults used to compile FreeType in an ANSI C environment */ |
||
54 | /* (16bit compilers are also supported). Copy this file to your own */ |
||
55 | /* `freetype/builds/ |
||
56 | /* */ |
||
57 | /*************************************************************************/ |
||
58 | |||
59 | |||
60 | #undef HAVE_UNISTD_H |
||
61 | #undef HAVE_FCNTL_H |
||
62 | #undef HAVE_STDINT_H |
||
63 | |||
64 | |||
65 | /* There are systems (like the Texas Instruments 'C54x) where a `char' */ |
||
66 | /* has 16 bits. ANSI C says that sizeof(char) is always 1. Since an */ |
||
67 | /* `int' has 16 bits also for this system, sizeof(int) gives 1 which */ |
||
68 | /* is probably unexpected. */ |
||
69 | /* */ |
||
70 | /* `CHAR_BIT' (defined in limits.h) gives the number of bits in a */ |
||
71 | /* `char' type. */ |
||
72 | |||
73 | #ifndef FT_CHAR_BIT |
||
74 | #define FT_CHAR_BIT CHAR_BIT |
||
75 | #endif |
||
76 | |||
77 | |||
78 | #undef FT_USE_AUTOCONF_SIZEOF_TYPES |
||
79 | #ifdef FT_USE_AUTOCONF_SIZEOF_TYPES |
||
80 | |||
81 | #undef SIZEOF_INT |
||
82 | #undef SIZEOF_LONG |
||
83 | #define FT_SIZEOF_INT SIZEOF_INT |
||
84 | #define FT_SIZEOF_LONG SIZEOF_LONG |
||
85 | |||
86 | #else /* !FT_USE_AUTOCONF_SIZEOF_TYPES */ |
||
87 | |||
88 | /* Following cpp computation of the bit length of int and long */ |
||
89 | /* is copied from default include/freetype/config/ftconfig.h. */ |
||
90 | /* If any improvement is required for this file, it should be */ |
||
91 | /* applied to the original header file for the builders that */ |
||
92 | /* does not use configure script. */ |
||
93 | |||
94 | /* The size of an `int' type. */ |
||
95 | #if FT_UINT_MAX == 0xFFFFUL |
||
96 | #define FT_SIZEOF_INT (16 / FT_CHAR_BIT) |
||
97 | #elif FT_UINT_MAX == 0xFFFFFFFFUL |
||
98 | #define FT_SIZEOF_INT (32 / FT_CHAR_BIT) |
||
99 | #elif FT_UINT_MAX > 0xFFFFFFFFUL && FT_UINT_MAX == 0xFFFFFFFFFFFFFFFFUL |
||
100 | #define FT_SIZEOF_INT (64 / FT_CHAR_BIT) |
||
101 | #else |
||
102 | #error "Unsupported size of `int' type!" |
||
103 | #endif |
||
104 | |||
105 | /* The size of a `long' type. A five-byte `long' (as used e.g. on the */ |
||
106 | /* DM642) is recognized but avoided. */ |
||
107 | #if FT_ULONG_MAX == 0xFFFFFFFFUL |
||
108 | #define FT_SIZEOF_LONG (32 / FT_CHAR_BIT) |
||
109 | #elif FT_ULONG_MAX > 0xFFFFFFFFUL && FT_ULONG_MAX == 0xFFFFFFFFFFUL |
||
110 | #define FT_SIZEOF_LONG (32 / FT_CHAR_BIT) |
||
111 | #elif FT_ULONG_MAX > 0xFFFFFFFFUL && FT_ULONG_MAX == 0xFFFFFFFFFFFFFFFFUL |
||
112 | #define FT_SIZEOF_LONG (64 / FT_CHAR_BIT) |
||
113 | #else |
||
114 | #error "Unsupported size of `long' type!" |
||
115 | #endif |
||
116 | |||
117 | #endif /* !FT_USE_AUTOCONF_SIZEOF_TYPES */ |
||
118 | |||
119 | |||
120 | /* FT_UNUSED is a macro used to indicate that a given parameter is not */ |
||
121 | /* used -- this is only used to get rid of unpleasant compiler warnings */ |
||
122 | #ifndef FT_UNUSED |
||
123 | #define FT_UNUSED( arg ) ( (arg) = (arg) ) |
||
124 | #endif |
||
125 | |||
126 | |||
127 | /*************************************************************************/ |
||
128 | /* */ |
||
129 | /* AUTOMATIC CONFIGURATION MACROS */ |
||
130 | /* */ |
||
131 | /* These macros are computed from the ones defined above. Don't touch */ |
||
132 | /* their definition, unless you know precisely what you are doing. No */ |
||
133 | /* porter should need to mess with them. */ |
||
134 | /* */ |
||
135 | /*************************************************************************/ |
||
136 | |||
137 | |||
138 | /*************************************************************************/ |
||
139 | /* */ |
||
140 | /* Mac support */ |
||
141 | /* */ |
||
142 | /* This is the only necessary change, so it is defined here instead */ |
||
143 | /* providing a new configuration file. */ |
||
144 | /* */ |
||
145 | #if defined( __APPLE__ ) || ( defined( __MWERKS__ ) && defined( macintosh ) ) |
||
146 | /* no Carbon frameworks for 64bit 10.4.x */ |
||
147 | /* AvailabilityMacros.h is available since Mac OS X 10.2, */ |
||
148 | /* so guess the system version by maximum errno before inclusion */ |
||
149 | #include |
||
150 | #ifdef ECANCELED /* defined since 10.2 */ |
||
151 | #include "AvailabilityMacros.h" |
||
152 | #endif |
||
153 | #if defined( __LP64__ ) && \ |
||
154 | ( MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4 ) |
||
155 | /undef FT_MACINTOSH |
||
156 | #endif |
||
157 | |||
158 | #elif defined( __SC__ ) || defined( __MRC__ ) |
||
159 | /* Classic MacOS compilers */ |
||
160 | #include "ConditionalMacros.h" |
||
161 | #if TARGET_OS_MAC |
||
162 | #define FT_MACINTOSH 1 |
||
163 | #endif |
||
164 | |||
165 | #endif |
||
166 | |||
167 | |||
168 | /* Fix compiler warning with sgi compiler */ |
||
169 | #if defined( __sgi ) && !defined( __GNUC__ ) |
||
170 | #if defined( _COMPILER_VERSION ) && ( _COMPILER_VERSION >= 730 ) |
||
171 | #pragma set woff 3505 |
||
172 | #endif |
||
173 | #endif |
||
174 | |||
175 | |||
176 | /*************************************************************************/ |
||
177 | /* */ |
||
178 | /* |
||
179 | /* basic_types */ |
||
180 | /* */ |
||
181 | /*************************************************************************/ |
||
182 | |||
183 | |||
184 | /*************************************************************************/ |
||
185 | /* */ |
||
186 | /* |
||
187 | /* FT_Int16 */ |
||
188 | /* */ |
||
189 | /* |
||
190 | /* A typedef for a 16bit signed integer type. */ |
||
191 | /* */ |
||
192 | typedef signed short FT_Int16; |
||
193 | |||
194 | |||
195 | /*************************************************************************/ |
||
196 | /* */ |
||
197 | /* |
||
198 | /* FT_UInt16 */ |
||
199 | /* */ |
||
200 | /* |
||
201 | /* A typedef for a 16bit unsigned integer type. */ |
||
202 | /* */ |
||
203 | typedef unsigned short FT_UInt16; |
||
204 | |||
205 | /* */ |
||
206 | |||
207 | |||
208 | /* this #if 0 ... #endif clause is for documentation purposes */ |
||
209 | #if 0 |
||
210 | |||
211 | /*************************************************************************/ |
||
212 | /* */ |
||
213 | /* |
||
214 | /* FT_Int32 */ |
||
215 | /* */ |
||
216 | /* |
||
217 | /* A typedef for a 32bit signed integer type. The size depends on */ |
||
218 | /* the configuration. */ |
||
219 | /* */ |
||
220 | typedef signed XXX FT_Int32; |
||
221 | |||
222 | |||
223 | /*************************************************************************/ |
||
224 | /* */ |
||
225 | /* |
||
226 | /* FT_UInt32 */ |
||
227 | /* */ |
||
228 | /* A typedef for a 32bit unsigned integer type. The size depends on */ |
||
229 | /* the configuration. */ |
||
230 | /* */ |
||
231 | typedef unsigned XXX FT_UInt32; |
||
232 | |||
233 | |||
234 | /*************************************************************************/ |
||
235 | /* */ |
||
236 | /* |
||
237 | /* FT_Int64 */ |
||
238 | /* */ |
||
239 | /* A typedef for a 64bit signed integer type. The size depends on */ |
||
240 | /* the configuration. Only defined if there is real 64bit support; */ |
||
241 | /* otherwise, it gets emulated with a structure (if necessary). */ |
||
242 | /* */ |
||
243 | typedef signed XXX FT_Int64; |
||
244 | |||
245 | |||
246 | /*************************************************************************/ |
||
247 | /* */ |
||
248 | /* |
||
249 | /* FT_UInt64 */ |
||
250 | /* */ |
||
251 | /* A typedef for a 64bit unsigned integer type. The size depends on */ |
||
252 | /* the configuration. Only defined if there is real 64bit support; */ |
||
253 | /* otherwise, it gets emulated with a structure (if necessary). */ |
||
254 | /* */ |
||
255 | typedef unsigned XXX FT_UInt64; |
||
256 | |||
257 | /* */ |
||
258 | |||
259 | #endif |
||
260 | |||
261 | #if FT_SIZEOF_INT == 4 |
||
262 | |||
263 | typedef signed int FT_Int32; |
||
264 | typedef unsigned int FT_UInt32; |
||
265 | |||
266 | #elif FT_SIZEOF_LONG == 4 |
||
267 | |||
268 | typedef signed long FT_Int32; |
||
269 | typedef unsigned long FT_UInt32; |
||
270 | |||
271 | #else |
||
272 | #error "no 32bit type found -- please check your configuration files" |
||
273 | #endif |
||
274 | |||
275 | |||
276 | /* look up an integer type that is at least 32 bits */ |
||
277 | #if FT_SIZEOF_INT >= 4 |
||
278 | |||
279 | typedef int FT_Fast; |
||
280 | typedef unsigned int FT_UFast; |
||
281 | |||
282 | #elif FT_SIZEOF_LONG >= 4 |
||
283 | |||
284 | typedef long FT_Fast; |
||
285 | typedef unsigned long FT_UFast; |
||
286 | |||
287 | #endif |
||
288 | |||
289 | |||
290 | /* determine whether we have a 64-bit int type for platforms without */ |
||
291 | /* Autoconf */ |
||
292 | #if FT_SIZEOF_LONG == 8 |
||
293 | |||
294 | /* FT_LONG64 must be defined if a 64-bit type is available */ |
||
295 | #define FT_LONG64 |
||
296 | #define FT_INT64 long |
||
297 | |||
298 | #elif defined( _MSC_VER ) && _MSC_VER >= 900 /* Visual C++ (and Intel C++) */ |
||
299 | |||
300 | /* this compiler provides the __int64 type */ |
||
301 | #define FT_LONG64 |
||
302 | #define FT_INT64 __int64 |
||
303 | |||
304 | #elif defined( __BORLANDC__ ) /* Borland C++ */ |
||
305 | |||
306 | /* XXXX: We should probably check the value of __BORLANDC__ in order */ |
||
307 | /* to test the compiler version. */ |
||
308 | |||
309 | /* this compiler provides the __int64 type */ |
||
310 | #define FT_LONG64 |
||
311 | #define FT_INT64 __int64 |
||
312 | |||
313 | #elif defined( __WATCOMC__ ) /* Watcom C++ */ |
||
314 | |||
315 | /* Watcom doesn't provide 64-bit data types */ |
||
316 | |||
317 | #elif defined( __MWERKS__ ) /* Metrowerks CodeWarrior */ |
||
318 | |||
319 | #define FT_LONG64 |
||
320 | #define FT_INT64 long long int |
||
321 | |||
322 | #elif defined( __GNUC__ ) |
||
323 | |||
324 | /* GCC provides the `long long' type */ |
||
325 | #define FT_LONG64 |
||
326 | #define FT_INT64 long long int |
||
327 | |||
328 | #endif /* FT_SIZEOF_LONG == 8 */ |
||
329 | |||
330 | |||
331 | /*************************************************************************/ |
||
332 | /* */ |
||
333 | /* A 64-bit data type will create compilation problems if you compile */ |
||
334 | /* in strict ANSI mode. To avoid them, we disable its use if __STDC__ */ |
||
335 | /* is defined. You can however ignore this rule by defining the */ |
||
336 | /* FT_CONFIG_OPTION_FORCE_INT64 configuration macro. */ |
||
337 | /* */ |
||
338 | #if defined( FT_LONG64 ) && !defined( FT_CONFIG_OPTION_FORCE_INT64 ) |
||
339 | |||
340 | #ifdef __STDC__ |
||
341 | |||
342 | /* Undefine the 64-bit macros in strict ANSI compilation mode. */ |
||
343 | /* Since `#undef' doesn't survive in configuration header files */ |
||
344 | /* we use the postprocessing facility of AC_CONFIG_HEADERS to */ |
||
345 | /* replace the leading `/' with `#'. */ |
||
346 | /undef FT_LONG64 |
||
347 | /undef FT_INT64 |
||
348 | |||
349 | #endif /* __STDC__ */ |
||
350 | |||
351 | #endif /* FT_LONG64 && !FT_CONFIG_OPTION_FORCE_INT64 */ |
||
352 | |||
353 | #ifdef FT_LONG64 |
||
354 | typedef FT_INT64 FT_Int64; |
||
355 | typedef FT_UINT64 FT_UInt64; |
||
356 | #endif |
||
357 | |||
358 | |||
359 | #define FT_BEGIN_STMNT do { |
||
360 | #define FT_END_STMNT } while ( 0 ) |
||
361 | #define FT_DUMMY_STMNT FT_BEGIN_STMNT FT_END_STMNT |
||
362 | |||
363 | |||
364 | #ifndef FT_CONFIG_OPTION_NO_ASSEMBLER |
||
365 | /* Provide assembler fragments for performance-critical functions. */ |
||
366 | /* These must be defined `static __inline__' with GCC. */ |
||
367 | |||
368 | #if defined( __CC_ARM ) || defined( __ARMCC__ ) /* RVCT */ |
||
369 | #define FT_MULFIX_ASSEMBLER FT_MulFix_arm |
||
370 | |||
371 | /* documentation is in freetype.h */ |
||
372 | |||
373 | static __inline FT_Int32 |
||
374 | FT_MulFix_arm( FT_Int32 a, |
||
375 | FT_Int32 b ) |
||
376 | { |
||
377 | register FT_Int32 t, t2; |
||
378 | |||
379 | |||
380 | __asm |
||
381 | { |
||
382 | smull t2, t, b, a /* (lo=t2,hi=t) = a*b */ |
||
383 | mov a, t, asr #31 /* a = (hi >> 31) */ |
||
384 | add a, a, #0x8000 /* a += 0x8000 */ |
||
385 | adds t2, t2, a /* t2 += a */ |
||
386 | adc t, t, #0 /* t += carry */ |
||
387 | mov a, t2, lsr #16 /* a = t2 >> 16 */ |
||
388 | orr a, a, t, lsl #16 /* a |= t << 16 */ |
||
389 | } |
||
390 | return a; |
||
391 | } |
||
392 | |||
393 | #endif /* __CC_ARM || __ARMCC__ */ |
||
394 | |||
395 | |||
396 | #ifdef __GNUC__ |
||
397 | |||
398 | #if defined( __arm__ ) && !defined( __thumb__ ) && \ |
||
399 | !( defined( __CC_ARM ) || defined( __ARMCC__ ) ) |
||
400 | #define FT_MULFIX_ASSEMBLER FT_MulFix_arm |
||
401 | |||
402 | /* documentation is in freetype.h */ |
||
403 | |||
404 | static __inline__ FT_Int32 |
||
405 | FT_MulFix_arm( FT_Int32 a, |
||
406 | FT_Int32 b ) |
||
407 | { |
||
408 | register FT_Int32 t, t2; |
||
409 | |||
410 | |||
411 | __asm__ __volatile__ ( |
||
412 | "smull %1, %2, %4, %3\n\t" /* (lo=%1,hi=%2) = a*b */ |
||
413 | "mov %0, %2, asr #31\n\t" /* %0 = (hi >> 31) */ |
||
414 | "add %0, %0, #0x8000\n\t" /* %0 += 0x8000 */ |
||
415 | "adds %1, %1, %0\n\t" /* %1 += %0 */ |
||
416 | "adc %2, %2, #0\n\t" /* %2 += carry */ |
||
417 | "mov %0, %1, lsr #16\n\t" /* %0 = %1 >> 16 */ |
||
418 | "orr %0, %0, %2, lsl #16\n\t" /* %0 |= %2 << 16 */ |
||
419 | : "=r"(a), "=&r"(t2), "=&r"(t) |
||
420 | : "r"(a), "r"(b) |
||
421 | : "cc" ); |
||
422 | return a; |
||
423 | } |
||
424 | |||
425 | #endif /* __arm__ && !__thumb__ && !( __CC_ARM || __ARMCC__ ) */ |
||
426 | |||
427 | #if defined( __i386__ ) |
||
428 | #define FT_MULFIX_ASSEMBLER FT_MulFix_i386 |
||
429 | |||
430 | /* documentation is in freetype.h */ |
||
431 | |||
432 | static __inline__ FT_Int32 |
||
433 | FT_MulFix_i386( FT_Int32 a, |
||
434 | FT_Int32 b ) |
||
435 | { |
||
436 | register FT_Int32 result; |
||
437 | |||
438 | |||
439 | __asm__ __volatile__ ( |
||
440 | "imul %%edx\n" |
||
441 | "movl %%edx, %%ecx\n" |
||
442 | "sarl $31, %%ecx\n" |
||
443 | "addl $0x8000, %%ecx\n" |
||
444 | "addl %%ecx, %%eax\n" |
||
445 | "adcl $0, %%edx\n" |
||
446 | "shrl $16, %%eax\n" |
||
447 | "shll $16, %%edx\n" |
||
448 | "addl %%edx, %%eax\n" |
||
449 | : "=a"(result), "=d"(b) |
||
450 | : "a"(a), "d"(b) |
||
451 | : "%ecx", "cc" ); |
||
452 | return result; |
||
453 | } |
||
454 | |||
455 | #endif /* i386 */ |
||
456 | |||
457 | #endif /* __GNUC__ */ |
||
458 | |||
459 | |||
460 | #ifdef _MSC_VER /* Visual C++ */ |
||
461 | |||
462 | #ifdef _M_IX86 |
||
463 | |||
464 | #define FT_MULFIX_ASSEMBLER FT_MulFix_i386 |
||
465 | |||
466 | /* documentation is in freetype.h */ |
||
467 | |||
468 | static __inline FT_Int32 |
||
469 | FT_MulFix_i386( FT_Int32 a, |
||
470 | FT_Int32 b ) |
||
471 | { |
||
472 | register FT_Int32 result; |
||
473 | |||
474 | __asm |
||
475 | { |
||
476 | mov eax, a |
||
477 | mov edx, b |
||
478 | imul edx |
||
479 | mov ecx, edx |
||
480 | sar ecx, 31 |
||
481 | add ecx, 8000h |
||
482 | add eax, ecx |
||
483 | adc edx, 0 |
||
484 | shr eax, 16 |
||
485 | shl edx, 16 |
||
486 | add eax, edx |
||
487 | mov result, eax |
||
488 | } |
||
489 | return result; |
||
490 | } |
||
491 | |||
492 | #endif /* _M_IX86 */ |
||
493 | |||
494 | #endif /* _MSC_VER */ |
||
495 | |||
496 | #endif /* !FT_CONFIG_OPTION_NO_ASSEMBLER */ |
||
497 | |||
498 | |||
499 | #ifdef FT_CONFIG_OPTION_INLINE_MULFIX |
||
500 | #ifdef FT_MULFIX_ASSEMBLER |
||
501 | #define FT_MULFIX_INLINED FT_MULFIX_ASSEMBLER |
||
502 | #endif |
||
503 | #endif |
||
504 | |||
505 | |||
506 | #ifdef FT_MAKE_OPTION_SINGLE_OBJECT |
||
507 | |||
508 | #define FT_LOCAL( x ) static x |
||
509 | #define FT_LOCAL_DEF( x ) static x |
||
510 | |||
511 | #else |
||
512 | |||
513 | #ifdef __cplusplus |
||
514 | #define FT_LOCAL( x ) extern "C" x |
||
515 | #define FT_LOCAL_DEF( x ) extern "C" x |
||
516 | #else |
||
517 | #define FT_LOCAL( x ) extern x |
||
518 | #define FT_LOCAL_DEF( x ) x |
||
519 | #endif |
||
520 | |||
521 | #endif /* FT_MAKE_OPTION_SINGLE_OBJECT */ |
||
522 | |||
523 | |||
524 | #ifndef FT_BASE |
||
525 | |||
526 | #ifdef __cplusplus |
||
527 | #define FT_BASE( x ) extern "C" x |
||
528 | #else |
||
529 | #define FT_BASE( x ) extern x |
||
530 | #endif |
||
531 | |||
532 | #endif /* !FT_BASE */ |
||
533 | |||
534 | |||
535 | #ifndef FT_BASE_DEF |
||
536 | |||
537 | #ifdef __cplusplus |
||
538 | #define FT_BASE_DEF( x ) x |
||
539 | #else |
||
540 | #define FT_BASE_DEF( x ) x |
||
541 | #endif |
||
542 | |||
543 | #endif /* !FT_BASE_DEF */ |
||
544 | |||
545 | |||
546 | #ifndef FT_EXPORT |
||
547 | |||
548 | #ifdef __cplusplus |
||
549 | #define FT_EXPORT( x ) extern "C" x |
||
550 | #else |
||
551 | #define FT_EXPORT( x ) extern x |
||
552 | #endif |
||
553 | |||
554 | #endif /* !FT_EXPORT */ |
||
555 | |||
556 | |||
557 | #ifndef FT_EXPORT_DEF |
||
558 | |||
559 | #ifdef __cplusplus |
||
560 | #define FT_EXPORT_DEF( x ) extern "C" x |
||
561 | #else |
||
562 | #define FT_EXPORT_DEF( x ) extern x |
||
563 | #endif |
||
564 | |||
565 | #endif /* !FT_EXPORT_DEF */ |
||
566 | |||
567 | |||
568 | #ifndef FT_EXPORT_VAR |
||
569 | |||
570 | #ifdef __cplusplus |
||
571 | #define FT_EXPORT_VAR( x ) extern "C" x |
||
572 | #else |
||
573 | #define FT_EXPORT_VAR( x ) extern x |
||
574 | #endif |
||
575 | |||
576 | #endif /* !FT_EXPORT_VAR */ |
||
577 | |||
578 | /* The following macros are needed to compile the library with a */ |
||
579 | /* C++ compiler and with 16bit compilers. */ |
||
580 | /* */ |
||
581 | |||
582 | /* This is special. Within C++, you must specify `extern "C"' for */ |
||
583 | /* functions which are used via function pointers, and you also */ |
||
584 | /* must do that for structures which contain function pointers to */ |
||
585 | /* assure C linkage -- it's not possible to have (local) anonymous */ |
||
586 | /* functions which are accessed by (global) function pointers. */ |
||
587 | /* */ |
||
588 | /* */ |
||
589 | /* FT_CALLBACK_DEF is used to _define_ a callback function. */ |
||
590 | /* */ |
||
591 | /* FT_CALLBACK_TABLE is used to _declare_ a constant variable that */ |
||
592 | /* contains pointers to callback functions. */ |
||
593 | /* */ |
||
594 | /* FT_CALLBACK_TABLE_DEF is used to _define_ a constant variable */ |
||
595 | /* that contains pointers to callback functions. */ |
||
596 | /* */ |
||
597 | /* */ |
||
598 | /* Some 16bit compilers have to redefine these macros to insert */ |
||
599 | /* the infamous `_cdecl' or `__fastcall' declarations. */ |
||
600 | /* */ |
||
601 | #ifndef FT_CALLBACK_DEF |
||
602 | #ifdef __cplusplus |
||
603 | #define FT_CALLBACK_DEF( x ) extern "C" x |
||
604 | #else |
||
605 | #define FT_CALLBACK_DEF( x ) static x |
||
606 | #endif |
||
607 | #endif /* FT_CALLBACK_DEF */ |
||
608 | |||
609 | #ifndef FT_CALLBACK_TABLE |
||
610 | #ifdef __cplusplus |
||
611 | #define FT_CALLBACK_TABLE extern "C" |
||
612 | #define FT_CALLBACK_TABLE_DEF extern "C" |
||
613 | #else |
||
614 | #define FT_CALLBACK_TABLE extern |
||
615 | #define FT_CALLBACK_TABLE_DEF /* nothing */ |
||
616 | #endif |
||
617 | #endif /* FT_CALLBACK_TABLE */ |
||
618 | |||
619 | |||
620 | FT_END_HEADER |
||
621 | |||
622 | |||
623 | #endif /* __FTCONFIG_H__ */ |
||
624 | |||
625 | |||
626 | /* END */><>><>=> |