]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/chartype.h
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
No changes, just move time functions from wx/stopwatch.h to wx/time.h.
[wxWidgets.git] / include / wx / chartype.h
... / ...
CommitLineData
1/*
2 * Name: wx/chartype.h
3 * Purpose: Declarations of wxChar and related types
4 * Author: Joel Farley, Ove Kåven
5 * Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
6 * Created: 1998/06/12
7 * RCS-ID: $Id$
8 * Copyright: (c) 1998-2006 wxWidgets dev team
9 * Licence: wxWindows licence
10 */
11
12/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
13
14#ifndef _WX_WXCHARTYPE_H_
15#define _WX_WXCHARTYPE_H_
16
17/* defs.h indirectly includes this file, so don't include it here */
18#include "wx/platform.h"
19
20/* check whether we have wchar_t and which size it is if we do */
21#if !defined(wxUSE_WCHAR_T)
22 #if defined(__UNIX__)
23 #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
24 #define wxUSE_WCHAR_T 1
25 #else
26 #define wxUSE_WCHAR_T 0
27 #endif
28 #elif defined(__GNUWIN32__) && !defined(__MINGW32__)
29 #define wxUSE_WCHAR_T 0
30 #elif defined(__WATCOMC__)
31 #define wxUSE_WCHAR_T 0
32 #elif defined(__VISAGECPP__) && (__IBMCPP__ < 400)
33 #define wxUSE_WCHAR_T 0
34 #else
35 /* add additional compiler checks if this fails */
36 #define wxUSE_WCHAR_T 1
37 #endif
38#endif /* !defined(wxUSE_WCHAR_T) */
39
40/* Unicode support requires wchar_t */
41#if !wxUSE_WCHAR_T
42 #error "wchar_t must be available"
43#endif /* Unicode */
44
45/*
46 non Unix compilers which do have wchar.h (but not tchar.h which is included
47 below and which includes wchar.h anyhow).
48
49 Actually MinGW has tchar.h, but it does not include wchar.h
50 */
51#if defined(__MWERKS__) || defined(__VISAGECPP__) || defined(__MINGW32__) || defined(__WATCOMC__)
52 #ifndef HAVE_WCHAR_H
53 #define HAVE_WCHAR_H
54 #endif
55#endif
56#if defined(__MWERKS__) && !defined(__MACH__)
57 #ifndef HAVE_WCSLEN
58 #define HAVE_WCSLEN
59 #endif
60#endif
61
62#ifdef HAVE_WCHAR_H
63 /* the current (as of Nov 2002) version of cygwin has a bug in its */
64 /* wchar.h -- there is no extern "C" around the declarations in it */
65 /* and this results in linking errors later; also, at least on some */
66 /* Cygwin versions, wchar.h requires sys/types.h */
67 #ifdef __CYGWIN__
68 #include <sys/types.h>
69 #ifdef __cplusplus
70 extern "C" {
71 #endif
72 #endif /* Cygwin */
73
74 #include <wchar.h>
75
76 #if defined(__CYGWIN__) && defined(__cplusplus)
77 }
78 #endif /* Cygwin and C++ */
79
80#elif defined(HAVE_WCSTR_H)
81 /* old compilers have relevant declarations here */
82 #include <wcstr.h>
83#elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
84 /* include stdlib.h for wchar_t */
85 #include <stdlib.h>
86#endif /* HAVE_WCHAR_H */
87
88#ifdef HAVE_WIDEC_H
89 #include <widec.h>
90#endif
91
92/* -------------------------------------------------------------------------- */
93/* define wxHAVE_TCHAR_SUPPORT for the compilers which support the TCHAR type */
94/* mapped to either char or wchar_t depending on the ASCII/Unicode mode and */
95/* have the function mapping _tfoo() -> foo() or wfoo() */
96/* -------------------------------------------------------------------------- */
97
98/* VC++ and BC++ starting with 5.2 have TCHAR support */
99#ifdef __VISUALC__
100 #define wxHAVE_TCHAR_SUPPORT
101#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
102 #define wxHAVE_TCHAR_SUPPORT
103 #include <ctype.h>
104#elif defined(__WATCOMC__)
105 #define wxHAVE_TCHAR_SUPPORT
106#elif defined(__DMC__)
107 #define wxHAVE_TCHAR_SUPPORT
108#elif defined(__WXPALMOS__)
109 #include <stddef.h>
110#elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
111 #define wxHAVE_TCHAR_SUPPORT
112 #include <stddef.h>
113 #include <string.h>
114 #include <ctype.h>
115#elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
116 /* VZ: the old VisualAge definitions were completely wrong and had no */
117 /* chance at all to work in Unicode build anyhow so let's pretend */
118 /* that VisualAge does _not_ support TCHAR for the moment (as */
119 /* indicated by "0 &&" above) until someone really has time to delve */
120 /* into Unicode issues under OS/2 */
121
122 /* VisualAge 4.0+ supports TCHAR */
123 #define wxHAVE_TCHAR_SUPPORT
124#endif /* compilers with (good) TCHAR support */
125
126#ifdef wxHAVE_TCHAR_SUPPORT
127 /* get TCHAR definition if we've got it */
128 #include <tchar.h>
129
130 /* we surely do have wchar_t if we have TCHAR */
131 #ifndef wxUSE_WCHAR_T
132 #define wxUSE_WCHAR_T 1
133 #endif /* !defined(wxUSE_WCHAR_T) */
134#endif /* wxHAVE_TCHAR_SUPPORT */
135
136/* ------------------------------------------------------------------------- */
137/* define wxChar type */
138/* ------------------------------------------------------------------------- */
139
140/* TODO: define wxCharInt to be equal to either int or wint_t? */
141
142#if !wxUSE_UNICODE
143 typedef char wxChar;
144 typedef signed char wxSChar;
145 typedef unsigned char wxUChar;
146#else
147 /* VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as */
148 /* signed/unsigned version of it which (a) makes sense to me (unlike */
149 /* char wchar_t is always unsigned) and (b) was how the previous */
150 /* definitions worked so keep it like this */
151
152 /* Sun's SunPro compiler supports the wchar_t type and wide character */
153 /* functions, but does not define __WCHAR_TYPE__. Define it here to */
154 /* allow unicode enabled builds. */
155 #if (defined(__SUNPRO_CC) || defined(__SUNPRO_C)) && !defined(__WCHAR_TYPE__)
156 #define __WCHAR_TYPE__ wxchar_t
157 #endif
158
159 /* GNU libc has __WCHAR_TYPE__ which requires special treatment, see */
160 /* comment below */
161 #if !defined(__WCHAR_TYPE__) || \
162 (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))
163 /* standard case */
164 typedef wchar_t wxChar;
165 typedef wchar_t wxSChar;
166 typedef wchar_t wxUChar;
167 #else /* __WCHAR_TYPE__ and gcc < 2.96 */
168 /* VS: wxWidgets used to define wxChar as __WCHAR_TYPE__ here. */
169 /* However, this doesn't work with new GCC 3.x compilers because */
170 /* wchar_t is C++'s builtin type in the new standard. OTOH, old */
171 /* compilers (GCC 2.x) won't accept new definition of */
172 /* wx{S,U}CharType, so we have to define wxChar */
173 /* conditionally depending on detected compiler & compiler */
174 /* version. */
175
176 /* with old definition of wxChar. */
177 #define wchar_t __WCHAR_TYPE__
178 typedef __WCHAR_TYPE__ wxChar;
179 typedef __WCHAR_TYPE__ wxSChar;
180 typedef __WCHAR_TYPE__ wxUChar;
181 #endif /* __WCHAR_TYPE__ */
182#endif /* ASCII/Unicode */
183
184/* ------------------------------------------------------------------------- */
185/* define wxStringCharType */
186/* ------------------------------------------------------------------------- */
187
188/* depending on the platform, Unicode build can either store wxStrings as
189 wchar_t* or UTF-8 encoded char*: */
190#if wxUSE_UNICODE
191 /* FIXME-UTF8: what would be better place for this? */
192 #if defined(wxUSE_UTF8_LOCALE_ONLY) && !defined(wxUSE_UNICODE_UTF8)
193 #error "wxUSE_UTF8_LOCALE_ONLY only makes sense with wxUSE_UNICODE_UTF8"
194 #endif
195 #ifndef wxUSE_UTF8_LOCALE_ONLY
196 #define wxUSE_UTF8_LOCALE_ONLY 0
197 #endif
198
199 #ifndef wxUSE_UNICODE_UTF8
200 #define wxUSE_UNICODE_UTF8 0
201 #endif
202
203 #if wxUSE_UNICODE_UTF8
204 #define wxUSE_UNICODE_WCHAR 0
205 #else
206 #define wxUSE_UNICODE_WCHAR 1
207 #endif
208#else
209 #define wxUSE_UNICODE_WCHAR 0
210 #define wxUSE_UNICODE_UTF8 0
211 #define wxUSE_UTF8_LOCALE_ONLY 0
212#endif
213
214/* define char type used by wxString internal representation: */
215#if wxUSE_UNICODE_WCHAR
216 typedef wchar_t wxStringCharType;
217#else /* wxUSE_UNICODE_UTF8 || ANSI */
218 typedef char wxStringCharType;
219#endif
220
221
222/* ------------------------------------------------------------------------- */
223/* define wxT() and related macros */
224/* ------------------------------------------------------------------------- */
225
226/* BSD systems define _T() to be something different in ctype.h, override it */
227#if defined(__FreeBSD__) || defined(__DARWIN__)
228 #include <ctype.h>
229 #undef _T
230#endif
231
232/*
233 wxT ("wx text") macro turns a literal string constant into a wide char
234 constant. It is mostly unnecessary with wx 2.9 but defined for
235 compatibility.
236 */
237#ifndef wxT
238 #if !wxUSE_UNICODE
239 #define wxT(x) x
240 #else /* Unicode */
241 /*
242 Notice that we use an intermediate macro to allow x to be expanded
243 if it's a macro itself.
244 */
245 #ifndef wxCOMPILER_BROKEN_CONCAT_OPER
246 #define wxT(x) wxCONCAT_HELPER(L, x)
247 #else
248 #define wxT(x) wxPREPEND_L(x)
249 #endif
250 #endif /* ASCII/Unicode */
251#endif /* !defined(wxT) */
252
253/*
254 wxT_2 exists only for compatibility with wx 2.x and is the same as wxT() in
255 that version but nothing in the newer ones.
256 */
257#define wxT_2(x) x
258
259/*
260 wxS ("wx string") macro can be used to create literals using the same
261 representation as wxString does internally, i.e. wchar_t in Unicode build
262 under Windows or char in UTF-8-based Unicode builds and (deprecated) ANSI
263 builds everywhere (see wxStringCharType definition above).
264 */
265#if wxUSE_UNICODE_WCHAR
266 /*
267 As above with wxT(), wxS() argument is expanded if it's a macro.
268 */
269 #ifndef wxCOMPILER_BROKEN_CONCAT_OPER
270 #define wxS(x) wxCONCAT_HELPER(L, x)
271 #else
272 #define wxS(x) wxPREPEND_L(x)
273 #endif
274#else /* wxUSE_UNICODE_UTF8 || ANSI */
275 #define wxS(x) x
276#endif
277
278/*
279 _T() is a synonym for wxT() familiar to Windows programmers. As this macro
280 has even higher risk of conflicting with system headers, its use is
281 discouraged and you may predefine wxNO__T to disable it. Additionally, we
282 do it ourselves for Sun CC which is known to use it in its standard headers
283 (see #10660).
284 */
285#if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
286 #ifndef wxNO__T
287 #define wxNO__T
288 #endif
289#endif
290
291#if !defined(_T) && !defined(wxNO__T)
292 #define _T(x) wxT(x)
293#endif
294
295/* a helper macro allowing to make another macro Unicode-friendly, see below */
296#define wxAPPLY_T(x) wxT(x)
297
298/* Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs */
299#ifndef __TFILE__
300 #define __TFILE__ wxAPPLY_T(__FILE__)
301#endif
302
303#ifndef __TDATE__
304 #define __TDATE__ wxAPPLY_T(__DATE__)
305#endif
306
307#ifndef __TTIME__
308 #define __TTIME__ wxAPPLY_T(__TIME__)
309#endif
310
311#endif /* _WX_WXCHARTYPE_H_ */
312
wxWidgets (Impactor)