[wxWidgets.git] / include / wx / chartype.h

/*
 * Name:        wx/chartype.h
 * Purpose:     Declarations of wxChar and related types
 * Author:      Joel Farley, Ove Kåven
 * Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
 * Created:     1998/06/12
 * RCS-ID:      $Id$
 * Copyright:   (c) 1998-2006 wxWidgets dev team
 * Licence:     wxWindows licence
 */

/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */

#ifndef _WX_WXCHARTYPE_H_
#define _WX_WXCHARTYPE_H_

/* defs.h indirectly includes this file, so don't include it here */
#include "wx/platform.h"

/* check whether we have wchar_t and which size it is if we do */
#if !defined(wxUSE_WCHAR_T)
    #if defined(__UNIX__)
        #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
            #define wxUSE_WCHAR_T 1
        #else
            #define wxUSE_WCHAR_T 0
        #endif
    #elif defined(__GNUWIN32__) && !defined(__MINGW32__)
        #define wxUSE_WCHAR_T 0
    #elif defined(__WATCOMC__)
        #define wxUSE_WCHAR_T 0
    #elif defined(__VISAGECPP__) && (__IBMCPP__ < 400)
        #define wxUSE_WCHAR_T 0
    #else
        /* add additional compiler checks if this fails */
        #define wxUSE_WCHAR_T 1
    #endif
#endif /* !defined(wxUSE_WCHAR_T) */

/* Unicode support requires wchar_t */
#if !wxUSE_WCHAR_T
    #error "wchar_t must be available"
#endif /* Unicode */

/*
   non Unix compilers which do have wchar.h (but not tchar.h which is included
   below and which includes wchar.h anyhow).

   Actually MinGW has tchar.h, but it does not include wchar.h
 */
#if defined(__MWERKS__) || defined(__VISAGECPP__) || defined(__MINGW32__) || defined(__WATCOMC__)
    #ifndef HAVE_WCHAR_H
        #define HAVE_WCHAR_H
    #endif
#endif
#if defined(__MWERKS__) && !defined(__MACH__)
    #ifndef HAVE_WCSLEN
        #define HAVE_WCSLEN
    #endif
#endif

#ifdef HAVE_WCHAR_H
    /* the current (as of Nov 2002) version of cygwin has a bug in its */
    /* wchar.h -- there is no extern "C" around the declarations in it */
    /* and this results in linking errors later; also, at least on some */
    /* Cygwin versions, wchar.h requires sys/types.h */
    #ifdef __CYGWIN__
        #include <sys/types.h>
        #ifdef __cplusplus
            extern "C" {
        #endif
    #endif /* Cygwin */

    #include <wchar.h>

    #if defined(__CYGWIN__) && defined(__cplusplus)
        }
    #endif /* Cygwin and C++ */

#elif defined(HAVE_WCSTR_H)
    /* old compilers have relevant declarations here */
    #include <wcstr.h>
#elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
    /* include stdlib.h for wchar_t */
    #include <stdlib.h>
#endif /* HAVE_WCHAR_H */

#ifdef HAVE_WIDEC_H
    #include <widec.h>
#endif

/* -------------------------------------------------------------------------- */
/* define wxHAVE_TCHAR_SUPPORT for the compilers which support the TCHAR type */
/* mapped to either char or wchar_t depending on the ASCII/Unicode mode and   */
/* have the function mapping _tfoo() -> foo() or wfoo()                       */
/* -------------------------------------------------------------------------- */

/* VC++ and BC++ starting with 5.2 have TCHAR support */
#ifdef __VISUALC__
    #define wxHAVE_TCHAR_SUPPORT
#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
    #define wxHAVE_TCHAR_SUPPORT
    #include <ctype.h>
#elif defined(__WATCOMC__)
    #define wxHAVE_TCHAR_SUPPORT
#elif defined(__DMC__)
    #define wxHAVE_TCHAR_SUPPORT
#elif defined(__WXPALMOS__)
    #include <stddef.h>
#elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
    #define wxHAVE_TCHAR_SUPPORT
    #include <stddef.h>
    #include <string.h>
    #include <ctype.h>
#elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
    /* VZ: the old VisualAge definitions were completely wrong and had no    */
    /*     chance at all to work in Unicode build anyhow so let's pretend    */
    /*     that VisualAge does _not_ support TCHAR for the moment (as        */
    /*     indicated by "0 &&" above) until someone really has time to delve */
    /*     into Unicode issues under OS/2 */

    /* VisualAge 4.0+ supports TCHAR */
    #define wxHAVE_TCHAR_SUPPORT
#endif /* compilers with (good) TCHAR support */

#ifdef wxHAVE_TCHAR_SUPPORT
    /* get TCHAR definition if we've got it */
    #include <tchar.h>

    /* we surely do have wchar_t if we have TCHAR */
    #ifndef wxUSE_WCHAR_T
        #define wxUSE_WCHAR_T 1
    #endif /* !defined(wxUSE_WCHAR_T) */
#endif /* wxHAVE_TCHAR_SUPPORT */

/* ------------------------------------------------------------------------- */
/* define wxChar type                                                        */
/* ------------------------------------------------------------------------- */

/* TODO: define wxCharInt to be equal to either int or wint_t? */

#if !wxUSE_UNICODE
    typedef char wxChar;
    typedef signed char wxSChar;
    typedef unsigned char wxUChar;
#else
    /* VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as    */
    /*     signed/unsigned version of it which (a) makes sense to me (unlike */
    /*     char wchar_t is always unsigned) and (b) was how the previous     */
    /*     definitions worked so keep it like this                           */

    /* Sun's SunPro compiler supports the wchar_t type and wide character    */
    /* functions, but does not define __WCHAR_TYPE__. Define it here to      */
    /* allow unicode enabled builds.                                         */
    #if (defined(__SUNPRO_CC) || defined(__SUNPRO_C)) && !defined(__WCHAR_TYPE__)
        #define __WCHAR_TYPE__ wxchar_t
    #endif

    /* GNU libc has __WCHAR_TYPE__ which requires special treatment, see */
    /* comment below */
    #if !defined(__WCHAR_TYPE__) || \
        (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))
        /* standard case */
        typedef wchar_t wxChar;
        typedef wchar_t wxSChar;
        typedef wchar_t wxUChar;
    #else /* __WCHAR_TYPE__ and gcc < 2.96 */
        /* VS: wxWidgets used to define wxChar as __WCHAR_TYPE__ here.       */
        /*     However, this doesn't work with new GCC 3.x compilers because */
        /*     wchar_t is C++'s builtin type in the new standard. OTOH, old  */
        /*     compilers (GCC 2.x) won't accept new definition of            */
        /*     wx{S,U}CharType, so we have to define wxChar                  */
        /*     conditionally depending on detected compiler & compiler       */
        /*     version.                                                      */

        /*     with old definition of wxChar. */
        #define wchar_t __WCHAR_TYPE__
        typedef __WCHAR_TYPE__ wxChar;
        typedef __WCHAR_TYPE__ wxSChar;
        typedef __WCHAR_TYPE__ wxUChar;
    #endif /* __WCHAR_TYPE__ */
#endif /* ASCII/Unicode */

/* ------------------------------------------------------------------------- */
/* define wxStringCharType                                                   */
/* ------------------------------------------------------------------------- */

/* depending on the platform, Unicode build can either store wxStrings as
   wchar_t* or UTF-8 encoded char*: */
#if wxUSE_UNICODE
    /* FIXME-UTF8: what would be better place for this? */
    #if defined(wxUSE_UTF8_LOCALE_ONLY) && !defined(wxUSE_UNICODE_UTF8)
        #error "wxUSE_UTF8_LOCALE_ONLY only makes sense with wxUSE_UNICODE_UTF8"
    #endif
    #ifndef wxUSE_UTF8_LOCALE_ONLY
        #define wxUSE_UTF8_LOCALE_ONLY 0
    #endif

    #ifndef wxUSE_UNICODE_UTF8
        #define wxUSE_UNICODE_UTF8 0
    #endif

    #if wxUSE_UNICODE_UTF8
        #define wxUSE_UNICODE_WCHAR 0
    #else
        #define wxUSE_UNICODE_WCHAR 1
    #endif
#else
    #define wxUSE_UNICODE_WCHAR 0
    #define wxUSE_UNICODE_UTF8  0
    #define wxUSE_UTF8_LOCALE_ONLY 0
#endif

/* define char type used by wxString internal representation: */
#if wxUSE_UNICODE_WCHAR
    typedef wchar_t wxStringCharType;
#else /* wxUSE_UNICODE_UTF8 || ANSI */
    typedef char wxStringCharType;
#endif


/* ------------------------------------------------------------------------- */
/* define wxT() and related macros                                           */
/* ------------------------------------------------------------------------- */

/* BSD systems define _T() to be something different in ctype.h, override it */
#if defined(__FreeBSD__) || defined(__DARWIN__)
    #include <ctype.h>
    #undef _T
#endif

/*
   wxT ("wx text") macro turns a literal string constant into a wide char
   constant. It is mostly unnecessary with wx 2.9 but defined for
   compatibility.
 */
#ifndef wxT
    #if !wxUSE_UNICODE
        #define wxT(x) x
    #else /* Unicode */
        /*
            Notice that we use an intermediate macro to allow x to be expanded
            if it's a macro itself.
         */
        #ifndef wxCOMPILER_BROKEN_CONCAT_OPER
            #define wxT(x) wxCONCAT_HELPER(L, x)
        #else
            #define wxT(x) wxPREPEND_L(x)
        #endif
    #endif /* ASCII/Unicode */
#endif /* !defined(wxT) */

/*
    wxT_2 exists only for compatibility with wx 2.x and is the same as wxT() in
    that version but nothing in the newer ones.
 */
#define wxT_2(x) x

/*
   wxS ("wx string") macro can be used to create literals using the same
   representation as wxString does internally, i.e. wchar_t in Unicode build
   under Windows or char in UTF-8-based Unicode builds and (deprecated) ANSI
   builds everywhere (see wxStringCharType definition above).
 */
#if wxUSE_UNICODE_WCHAR
    /*
        As above with wxT(), wxS() argument is expanded if it's a macro.
     */
    #ifndef wxCOMPILER_BROKEN_CONCAT_OPER
        #define wxS(x) wxCONCAT_HELPER(L, x)
    #else
        #define wxS(x) wxPREPEND_L(x)
    #endif
#else /* wxUSE_UNICODE_UTF8 || ANSI */
    #define wxS(x) x
#endif

/*
    _T() is a synonym for wxT() familiar to Windows programmers. As this macro
    has even higher risk of conflicting with system headers, its use is
    discouraged and you may predefine wxNO__T to disable it. Additionally, we
    do it ourselves for Sun CC which is known to use it in its standard headers
    (see #10660).
 */
#if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
    #ifndef wxNO__T
        #define wxNO__T
    #endif
#endif

#if !defined(_T) && !defined(wxNO__T)
    #define _T(x) wxT(x)
#endif

/* a helper macro allowing to make another macro Unicode-friendly, see below */
#define wxAPPLY_T(x) wxT(x)

/* Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs */
#ifndef __TFILE__
    #define __TFILE__ wxAPPLY_T(__FILE__)
#endif

#ifndef __TDATE__
    #define __TDATE__ wxAPPLY_T(__DATE__)
#endif

#ifndef __TTIME__
    #define __TTIME__ wxAPPLY_T(__TIME__)
#endif

#endif /* _WX_WXCHARTYPE_H_ */
Commit	Line	Data
e3f6cbd9 VS	1	/*
	2	* Name: wx/chartype.h
	3	* Purpose: Declarations of wxChar and related types
e9670814	4	* Author: Joel Farley, Ove Kåven
e3f6cbd9 VS	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 */
93928d51 VS	41	#if !wxUSE_WCHAR_T
93928d51 VS	42	#error "wchar_t must be available"
e3f6cbd9 VS	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
8d94819c VS	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 */
e3f6cbd9	73
8d94819c	74	#include <wchar.h>
e3f6cbd9	75
8d94819c VS	76	#if defined(__CYGWIN__) && defined(__cplusplus)
	77	}
	78	#endif /* Cygwin and C++ */
e3f6cbd9	79
8d94819c VS	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 */
e3f6cbd9	87
8d94819c VS	88	#ifdef HAVE_WIDEC_H
	89	#include <widec.h>
	90	#endif
e3f6cbd9 VS	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;
9a6d1438	146	#else
e3f6cbd9 VS	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. */
b69ae27a VZ	155	#if (defined(__SUNPRO_CC) \|\| defined(__SUNPRO_C)) && !defined(__WCHAR_TYPE__)
b69ae27a VZ	156	#define __WCHAR_TYPE__ wxchar_t
e3f6cbd9 VS	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
8f93a29f VS	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
28efe654	191	/* FIXME-UTF8: what would be better place for this? */
cb352236 VS	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
81727065 VS	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
8f93a29f VS	208	#else
	209	#define wxUSE_UNICODE_WCHAR 0
	210	#define wxUSE_UNICODE_UTF8 0
5becc841	211	#define wxUSE_UTF8_LOCALE_ONLY 0
8f93a29f VS	212	#endif
	213
	214	/* define char type used by wxString internal representation: */
a0516656	215	#if wxUSE_UNICODE_WCHAR
8f93a29f	216	typedef wchar_t wxStringCharType;
a0516656	217	#else /* wxUSE_UNICODE_UTF8 \|\| ANSI */
8f93a29f VS	218	typedef char wxStringCharType;
	219	#endif
	220
	221
e3f6cbd9	222	/* ------------------------------------------------------------------------- */
9a83f860	223	/* define wxT() and related macros */
e3f6cbd9 VS	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
9a83f860 VZ	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
e3f6cbd9	238	#if !wxUSE_UNICODE
9a83f860	239	#define wxT(x) x
e3f6cbd9	240	#else /* Unicode */
25859335 VZ	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
e3f6cbd9	250	#endif /* ASCII/Unicode */
9a83f860	251	#endif /* !defined(wxT) */
e3f6cbd9	252
9204fde6 VZ	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
a0516656 VZ	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
25859335 VZ	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
a0516656 VZ	274	#else /* wxUSE_UNICODE_UTF8 \|\| ANSI */
	275	#define wxS(x) x
	276	#endif
	277
9a83f860 VZ	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
e3f6cbd9 VS	294
e3f6cbd9 VS	295	/* a helper macro allowing to make another macro Unicode-friendly, see below */
9a83f860	296	#define wxAPPLY_T(x) wxT(x)
e3f6cbd9 VS	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