← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/freetype/include/freetype/config/ftconfig.h

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/freetype/include/freetype/config/ftconfig.h
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  ftconfig.h                                                             */
 
4
/*                                                                         */
 
5
/*    ANSI-specific configuration file (specification only).               */
 
6
/*                                                                         */
 
7
/*  Copyright 1996-2001, 2002, 2003, 2004 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/<system>', and        */
 
31
  /* contains system-specific files that are always included first when    */
 
32
  /* building the library.                                                 */
 
33
  /*                                                                       */
 
34
  /* This ANSI version should stay in `include/freetype/config'.           */
 
35
  /*                                                                       */
 
36
  /*************************************************************************/
 
37
 
 
38
 
 
39
#ifndef __FTCONFIG_H__
 
40
#define __FTCONFIG_H__
 
41
 
 
42
#include <ft2build.h>
 
43
#include FT_CONFIG_OPTIONS_H
 
44
#include FT_CONFIG_STANDARD_LIBRARY_H
 
45
 
 
46
FT_BEGIN_HEADER
 
47
 
 
48
 
 
49
  /*************************************************************************/
 
50
  /*                                                                       */
 
51
  /*               PLATFORM-SPECIFIC CONFIGURATION MACROS                  */
 
52
  /*                                                                       */
 
53
  /* These macros can be toggled to suit a specific system.  The current   */
 
54
  /* ones are defaults used to compile FreeType in an ANSI C environment   */
 
55
  /* (16bit compilers are also supported).  Copy this file to your own     */
 
56
  /* `freetype/builds/<system>' directory, and edit it to port the engine. */
 
57
  /*                                                                       */
 
58
  /*************************************************************************/
 
59
 
 
60
 
 
61
  /* There are systems (like the Texas Instruments 'C54x) where a `char' */
 
62
  /* has 16 bits.  ANSI C says that sizeof(char) is always 1.  Since an  */
 
63
  /* `int' has 16 bits also for this system, sizeof(int) gives 1 which   */
 
64
  /* is probably unexpected.                                             */
 
65
  /*                                                                     */
 
66
  /* `CHAR_BIT' (defined in limits.h) gives the number of bits in a      */
 
67
  /* `char' type.                                                        */
 
68
 
 
69
#ifndef FT_CHAR_BIT
 
70
#define FT_CHAR_BIT  CHAR_BIT
 
71
#endif
 
72
 
 
73
 
 
74
  /* The size of an `int' type.  */
 
75
#if   FT_UINT_MAX == 0xFFFFFFFFUL
 
76
#define FT_SIZEOF_INT  (32 / FT_CHAR_BIT)
 
77
#elif FT_UINT_MAX == 0xFFFFU
 
78
#define FT_SIZEOF_INT  (16 / FT_CHAR_BIT)
 
79
#elif FT_UINT_MAX > 0xFFFFFFFFU && FT_UINT_MAX == 0xFFFFFFFFFFFFFFFFU
 
80
#define FT_SIZEOF_INT  (64 / FT_CHAR_BIT)
 
81
#else
 
82
#error "Unsupported size of `int' type!"
 
83
#endif
 
84
 
 
85
  /* The size of a `long' type.  */
 
86
#if   FT_ULONG_MAX == 0xFFFFFFFFUL
 
87
#define FT_SIZEOF_LONG  (32 / FT_CHAR_BIT)
 
88
#elif FT_ULONG_MAX > 0xFFFFFFFFU && FT_ULONG_MAX == 0xFFFFFFFFFFFFFFFFU
 
89
#define FT_SIZEOF_LONG  (64 / FT_CHAR_BIT)
 
90
#else
 
91
#error "Unsupported size of `long' type!"
 
92
#endif
 
93
 
 
94
 
 
95
  /* Preferred alignment of data */
 
96
#define FT_ALIGNMENT  8
 
97
 
 
98
 
 
99
  /* FT_UNUSED is a macro used to indicate that a given parameter is not  */
 
100
  /* used -- this is only used to get rid of unpleasant compiler warnings */
 
101
#ifndef FT_UNUSED
 
102
#define FT_UNUSED( arg )  ( (arg) = (arg) )
 
103
#endif
 
104
 
 
105
 
 
106
  /*************************************************************************/
 
107
  /*                                                                       */
 
108
  /*                     AUTOMATIC CONFIGURATION MACROS                    */
 
109
  /*                                                                       */
 
110
  /* These macros are computed from the ones defined above.  Don't touch   */
 
111
  /* their definition, unless you know precisely what you are doing.  No   */
 
112
  /* porter should need to mess with them.                                 */
 
113
  /*                                                                       */
 
114
  /*************************************************************************/
 
115
 
 
116
 
 
117
  /*************************************************************************/
 
118
  /*                                                                       */
 
119
  /* Mac support                                                           */
 
120
  /*                                                                       */
 
121
  /*   This is the only necessary change, so it is defined here instead    */
 
122
  /*   providing a new configuration file.                                 */
 
123
  /*                                                                       */
 
124
#if ( defined( __APPLE__ ) && !defined( DARWIN_NO_CARBON ) ) || \
 
125
    ( defined( __MWERKS__ ) && defined( macintosh )        )
 
126
#define FT_MACINTOSH 1
 
127
#endif
 
128
 
 
129
 
 
130
  /*************************************************************************/
 
131
  /*                                                                       */
 
132
  /* IntN types                                                            */
 
133
  /*                                                                       */
 
134
  /*   Used to guarantee the size of some specific integers.               */
 
135
  /*                                                                       */
 
136
  typedef signed short    FT_Int16;
 
137
  typedef unsigned short  FT_UInt16;
 
138
 
 
139
#if FT_SIZEOF_INT == (32 / FT_CHAR_BIT)
 
140
 
 
141
  typedef signed int      FT_Int32;
 
142
  typedef unsigned int    FT_UInt32;
 
143
 
 
144
#elif FT_SIZEOF_LONG == (32 / FT_CHAR_BIT)
 
145
 
 
146
  typedef signed long     FT_Int32;
 
147
  typedef unsigned long   FT_UInt32;
 
148
 
 
149
#else
 
150
#error "no 32bit type found -- please check your configuration files"
 
151
#endif
 
152
 
 
153
  /* look up an integer type that is at least 32 bits */
 
154
#if FT_SIZEOF_INT >= (32 / FT_CHAR_BIT)
 
155
 
 
156
  typedef int            FT_Fast;
 
157
  typedef unsigned int   FT_UFast;
 
158
 
 
159
#elif FT_SIZEOF_LONG >= (32 / FT_CHAR_BIT)
 
160
 
 
161
  typedef long           FT_Fast;
 
162
  typedef unsigned long  FT_UFast;
 
163
 
 
164
#endif
 
165
 
 
166
 
 
167
  /* determine whether we have a 64-bit int type for platforms without */
 
168
  /* Autoconf                                                          */
 
169
#if FT_SIZEOF_LONG == (64 / FT_CHAR_BIT)
 
170
 
 
171
  /* FT_LONG64 must be defined if a 64-bit type is available */
 
172
#define FT_LONG64
 
173
#define FT_INT64  long
 
174
 
 
175
#elif defined( _MSC_VER ) && _MSC_VER >= 900  /* Visual C++ (and Intel C++) */
 
176
 
 
177
  /* this compiler provides the __int64 type */
 
178
#define FT_LONG64
 
179
#define FT_INT64  __int64
 
180
 
 
181
#elif defined( __BORLANDC__ )  /* Borland C++ */
 
182
 
 
183
  /* XXXX: We should probably check the value of __BORLANDC__ in order */
 
184
  /*       to test the compiler version.                               */
 
185
 
 
186
  /* this compiler provides the __int64 type */
 
187
#define FT_LONG64
 
188
#define FT_INT64  __int64
 
189
 
 
190
#elif defined( __WATCOMC__ )   /* Watcom C++ */
 
191
 
 
192
  /* Watcom doesn't provide 64-bit data types */
 
193
 
 
194
#elif defined( __MWERKS__ )    /* Metrowerks CodeWarrior */
 
195
 
 
196
#define FT_LONG64
 
197
#define FT_INT64  long long int
 
198
 
 
199
#elif defined( __GNUC__ )
 
200
 
 
201
  /* GCC provides the "long long" type */
 
202
#define FT_LONG64
 
203
#define FT_INT64  long long int
 
204
 
 
205
#endif /* FT_SIZEOF_LONG == (64 / FT_CHAR_BIT) */
 
206
 
 
207
 
 
208
#define FT_BEGIN_STMNT  do {
 
209
#define FT_END_STMNT    } while ( 0 )
 
210
#define FT_DUMMY_STMNT  FT_BEGIN_STMNT FT_END_STMNT
 
211
 
 
212
 
 
213
  /*************************************************************************/
 
214
  /*                                                                       */
 
215
  /* A 64-bit data type will create compilation problems if you compile    */
 
216
  /* in strict ANSI mode.  To avoid them, we disable their use if          */
 
217
  /* __STDC__ is defined.  You can however ignore this rule by             */
 
218
  /* defining the FT_CONFIG_OPTION_FORCE_INT64 configuration macro.        */
 
219
  /*                                                                       */
 
220
#if defined( FT_LONG64 ) && !defined( FT_CONFIG_OPTION_FORCE_INT64 )
 
221
 
 
222
#ifdef __STDC__
 
223
 
 
224
  /* undefine the 64-bit macros in strict ANSI compilation mode */
 
225
#undef FT_LONG64
 
226
#undef FT_INT64
 
227
 
 
228
#endif /* __STDC__ */
 
229
 
 
230
#endif /* FT_LONG64 && !FT_CONFIG_OPTION_FORCE_INT64 */
 
231
 
 
232
 
 
233
#ifdef FT_MAKE_OPTION_SINGLE_OBJECT
 
234
 
 
235
#define FT_LOCAL( x )      static  x
 
236
#define FT_LOCAL_DEF( x )  static  x
 
237
 
 
238
#else
 
239
 
 
240
#ifdef __cplusplus
 
241
#define FT_LOCAL( x )      extern "C"  x
 
242
#define FT_LOCAL_DEF( x )  extern "C"  x
 
243
#else
 
244
#define FT_LOCAL( x )      extern  x
 
245
#define FT_LOCAL_DEF( x )  x
 
246
#endif
 
247
 
 
248
#endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
 
249
 
 
250
 
 
251
#ifndef FT_BASE
 
252
 
 
253
#ifdef __cplusplus
 
254
#define FT_BASE( x )  extern "C"  x
 
255
#else
 
256
#define FT_BASE( x )  extern  x
 
257
#endif
 
258
 
 
259
#endif /* !FT_BASE */
 
260
 
 
261
 
 
262
#ifndef FT_BASE_DEF
 
263
 
 
264
#ifdef __cplusplus
 
265
#define FT_BASE_DEF( x )  extern "C"  x
 
266
#else
 
267
#define FT_BASE_DEF( x )  extern  x
 
268
#endif
 
269
 
 
270
#endif /* !FT_BASE_DEF */
 
271
 
 
272
 
 
273
#ifndef FT_EXPORT
 
274
 
 
275
#ifdef __cplusplus
 
276
#define FT_EXPORT( x )  extern "C"  x
 
277
#else
 
278
#define FT_EXPORT( x )  extern  x
 
279
#endif
 
280
 
 
281
#endif /* !FT_EXPORT */
 
282
 
 
283
 
 
284
#ifndef FT_EXPORT_DEF
 
285
 
 
286
#ifdef __cplusplus
 
287
#define FT_EXPORT_DEF( x )  extern "C"  x
 
288
#else
 
289
#define FT_EXPORT_DEF( x )  extern  x
 
290
#endif
 
291
 
 
292
#endif /* !FT_EXPORT_DEF */
 
293
 
 
294
 
 
295
#ifndef FT_EXPORT_VAR
 
296
 
 
297
#ifdef __cplusplus
 
298
#define FT_EXPORT_VAR( x )  extern "C"  x
 
299
#else
 
300
#define FT_EXPORT_VAR( x )  extern  x
 
301
#endif
 
302
 
 
303
#endif /* !FT_EXPORT_VAR */
 
304
 
 
305
  /* The following macros are needed to compile the library with a   */
 
306
  /* C++ compiler and with 16bit compilers.                          */
 
307
  /*                                                                 */
 
308
 
 
309
  /* This is special.  Within C++, you must specify `extern "C"' for */
 
310
  /* functions which are used via function pointers, and you also    */
 
311
  /* must do that for structures which contain function pointers to  */
 
312
  /* assure C linkage -- it's not possible to have (local) anonymous */
 
313
  /* functions which are accessed by (global) function pointers.     */
 
314
  /*                                                                 */
 
315
  /*                                                                 */
 
316
  /* FT_CALLBACK_DEF is used to _define_ a callback function.        */
 
317
  /*                                                                 */
 
318
  /* FT_CALLBACK_TABLE is used to _declare_ a constant variable that */
 
319
  /* contains pointers to callback functions.                        */
 
320
  /*                                                                 */
 
321
  /* FT_CALLBACK_TABLE_DEF is used to _define_ a constant variable   */
 
322
  /* that contains pointers to callback functions.                   */
 
323
  /*                                                                 */
 
324
  /*                                                                 */
 
325
  /* Some 16bit compilers have to redefine these macros to insert    */
 
326
  /* the infamous `_cdecl' or `__fastcall' declarations.             */
 
327
  /*                                                                 */
 
328
#ifndef FT_CALLBACK_DEF
 
329
#ifdef __cplusplus
 
330
#define FT_CALLBACK_DEF( x )  extern "C"  x
 
331
#else
 
332
#define FT_CALLBACK_DEF( x )  static  x
 
333
#endif
 
334
#endif /* FT_CALLBACK_DEF */
 
335
 
 
336
#ifndef FT_CALLBACK_TABLE
 
337
#ifdef __cplusplus
 
338
#define FT_CALLBACK_TABLE      extern "C"
 
339
#define FT_CALLBACK_TABLE_DEF  extern "C"
 
340
#else
 
341
#define FT_CALLBACK_TABLE      extern
 
342
#define FT_CALLBACK_TABLE_DEF  /* nothing */
 
343
#endif
 
344
#endif /* FT_CALLBACK_TABLE */
 
345
 
 
346
 
 
347
FT_END_HEADER
 
348
 
 
349
 
 
350
#endif /* __FTCONFIG_H__ */
 
351
 
 
352
 
 
353
/* END */