wxchar.h

浙江大学的悟空嵌入式系统模拟器

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/wxchar.h
// Purpose:     Declarations common to wx char/wchar_t usage (wide chars)
// Author:      Joel Farley, Ove K鍁en
// Modified by: Vadim Zeitlin, Robert Roebling
// Created:     1998/06/12
// RCS-ID:      $Id: wxchar.h,v 1.1 2005/03/16 06:49:33 kehc Exp $
// Copyright:   (c) 1998-2002 wxWindows dev team
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_WXCHAR_H_
#define _WX_WXCHAR_H_

#if defined(__GNUG__) && !defined(__APPLE__)
    #pragma interface "wxchar.h"
#endif

// ----------------------------------------------------------------------------
// first deal with Unicode setting: wxUSE_UNICODE should be defined as 0 or 1
// and is used by wxWindows, _UNICODE and/or UNICODE may be defined or used by
// the system headers so bring these settings in sync
// ----------------------------------------------------------------------------

// set wxUSE_UNICODE to 1 if UNICODE or _UNICODE is defined
#if defined(_UNICODE) || defined(UNICODE)
    #undef wxUSE_UNICODE
    #define wxUSE_UNICODE 1
#else
    #ifndef wxUSE_UNICODE
        #define wxUSE_UNICODE 0
    #endif
#endif // Unicode

// and vice versa: define UNICODE and _UNICODE if wxUSE_UNICODE is 1...
#if wxUSE_UNICODE
    #ifndef _UNICODE
        #define _UNICODE
    #endif
    #ifndef UNICODE
        #define UNICODE
    #endif
#endif // Unicode

// check whether we have wchar_t
#if !defined(wxUSE_WCHAR_T)
    #if defined(__WIN16__)
        // no wchar_t under Win16 regadrless of compiler used
        #define wxUSE_WCHAR_T 0
    #elif 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_UNICODE && !wxUSE_WCHAR_T
    #error "wchar_t must be available in Unicode build"
#endif // Unicode

// ----------------------------------------------------------------------------
// standard headers we need here
//
// NB: don't include any wxWindows headers here because almost of them include
//     this one!
// ----------------------------------------------------------------------------

// Required for wxPrintf() etc
#include <stdarg.h>

// 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__)
    #ifndef HAVE_WCHAR_H
        #define HAVE_WCHAR_H
    #endif
#endif

#if wxUSE_WCHAR_T
    #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>
            extern "C" {
        #endif // Cygwin
                #include <wchar.h>
        #ifdef __CYGWIN__
            }
        #endif // Cygwin
    #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
#endif // wxUSE_WCHAR_T

// ----------------------------------------------------------------------------
// 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(__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)

    // and we also do have wcslen()
    #ifndef HAVE_WCSLEN
        #define HAVE_WCSLEN
    #endif
#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 // Unicode
    // 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

    // 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: wxWindows 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}Char, therefore we
        //     have to define wxChar conditionally depending on detected
        //     compiler & compiler version.
        //     with old definition of wxChar.
        typedef __WCHAR_TYPE__ wxChar;
        typedef __WCHAR_TYPE__ wxSChar;
        typedef __WCHAR_TYPE__ wxUChar;
    #endif // __WCHAR_TYPE__
#endif // ASCII/Unicode

// ----------------------------------------------------------------------------
// define _T() 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

// could already be defined by tchar.h (it's quasi standard)
#ifndef _T
    #if !wxUSE_UNICODE
        #define _T(x) x
    #else // Unicode
        #define _T(x) L ## x
    #endif // ASCII/Unicode
#endif // !defined(_T)

// although global macros with such names are normally bad, we want to have
// another name for _T() which should be used to avoid confusion between _T()
// and _() in wxWindows sources
#define wxT(x)       _T(x)

// Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs
#ifndef __TFILE__
    #define __XFILE__(x) wxT(x)
    #define __TFILE__ __XFILE__(__FILE__)
#endif

#ifndef __TDATE__
    #define __XDATE__(x) wxT(x)
    #define __TDATE__ __XDATE__(__DATE__)
#endif

#ifndef __TTIME__
    #define __XTIME__(x) wxT(x)
    #define __TTIME__ __XTIME__(__TIME__)
#endif

// ----------------------------------------------------------------------------
// define wxFoo() function for each standard foo() function whose signature
// (exceptionally including the return type) includes any mention of char:
// wxFoo() is going to be a Unicode-friendly version of foo(), i.e. will have
// the same signature but with char replaced by wxChar which allows us to use
// it in Unicode build as well
// ----------------------------------------------------------------------------

#ifdef wxHAVE_TCHAR_SUPPORT
    #include <ctype.h>

    // ctype.h functions
    #define  wxIsalnum   _istalnum
    #define  wxIsalpha   _istalpha
    #define  wxIsctrl    _istctrl
    #define  wxIsdigit   _istdigit
    #define  wxIsgraph   _istgraph
    #define  wxIslower   _istlower
    #define  wxIsprint   _istprint
    #define  wxIspunct   _istpunct
    #define  wxIsspace   _istspace
    #define  wxIsupper   _istupper
    #define  wxIsxdigit  _istxdigit
    #define  wxTolower   _totlower
    #define  wxToupper   _totupper

    // locale.h functons
    #define  wxSetlocale _tsetlocale

    // string.h functions
    #define  wxStrcat    _tcscat
    #define  wxStrchr    _tcschr
    #define  wxStrcmp    _tcscmp
    #define  wxStrcoll   _tcscoll
    #define  wxStrcpy    _tcscpy
    #define  wxStrcspn   _tcscspn
    #define  wxStrdup    _tcsdup
    #define  wxStrftime  _tcsftime
    #define  wxStricmp   _tcsicmp
    #define  wxStrnicmp  _tcsnicmp