63e1921d0b
With this option _strdup() is not available, so update the code defining wxCRT_StrdupA() to check for __WX_STRICT_ANSI_GCC__. Also try to simplify it a bit and make it more clear. Closes #15011. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@73627 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
710 lines
22 KiB
C
710 lines
22 KiB
C
/*
|
|
* Name: wx/wxcrtbase.h
|
|
* Purpose: Type-safe ANSI and Unicode builds compatible wrappers for
|
|
* CRT functions
|
|
* Author: Joel Farley, Ove Kaaven
|
|
* 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_WXCRTBASE_H_
|
|
#define _WX_WXCRTBASE_H_
|
|
|
|
/* -------------------------------------------------------------------------
|
|
headers and missing declarations
|
|
------------------------------------------------------------------------- */
|
|
|
|
#include "wx/chartype.h"
|
|
|
|
/*
|
|
Standard headers we need here.
|
|
|
|
NB: don't include any wxWidgets headers here because almost all of them
|
|
include this one!
|
|
|
|
NB2: User code should include wx/crt.h instead of including this
|
|
header directly.
|
|
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <wctype.h>
|
|
#include <time.h>
|
|
|
|
#if defined(__WINDOWS__) && !defined(__WXWINCE__)
|
|
#include <io.h>
|
|
#endif
|
|
|
|
#if defined(HAVE_STRTOK_R) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
|
|
char *strtok_r(char *, const char *, char **);
|
|
#endif
|
|
|
|
/*
|
|
Using -std=c++{98,0x} option with mingw32 disables most of standard
|
|
library extensions, so we can't rely on the presence of common non-ANSI
|
|
functions, define a special symbol to test for this. Notice that this
|
|
doesn't need to be done for g++ under Linux where _GNU_SOURCE (which is
|
|
defined by default) still makes all common extensions available even in
|
|
ANSI mode.
|
|
*/
|
|
#if defined(__MINGW32__) && defined(__STRICT_ANSI__)
|
|
#define __WX_STRICT_ANSI_GCC__
|
|
#endif
|
|
|
|
/*
|
|
a few compilers don't have the (non standard but common) isascii function,
|
|
define it ourselves for them
|
|
*/
|
|
#ifndef isascii
|
|
#if defined(__WX_STRICT_ANSI_GCC__)
|
|
#define wxNEED_ISASCII
|
|
#elif defined(_WIN32_WCE)
|
|
#if _WIN32_WCE <= 211
|
|
#define wxNEED_ISASCII
|
|
#endif
|
|
#endif
|
|
#endif /* isascii */
|
|
|
|
#ifdef wxNEED_ISASCII
|
|
inline int isascii(int c) { return (unsigned)c < 0x80; }
|
|
#endif
|
|
|
|
#ifdef _WIN32_WCE
|
|
#if _WIN32_WCE <= 211
|
|
#define isspace(c) ((c) == wxT(' ') || (c) == wxT('\t'))
|
|
#endif
|
|
#endif /* _WIN32_WCE */
|
|
|
|
/* string.h functions */
|
|
#ifndef strdup
|
|
#if defined(__WXWINCE__)
|
|
#if _WIN32_WCE <= 211
|
|
#define wxNEED_STRDUP
|
|
#endif
|
|
#endif
|
|
#endif /* strdup */
|
|
|
|
#ifdef wxNEED_STRDUP
|
|
WXDLLIMPEXP_BASE char *strdup(const char* s);
|
|
#endif
|
|
|
|
/* missing functions in some WinCE versions */
|
|
#ifdef _WIN32_WCE
|
|
#if (_WIN32_WCE < 300)
|
|
WXDLLIMPEXP_BASE void *calloc( size_t num, size_t size );
|
|
#endif
|
|
#endif /* _WIN32_WCE */
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
UTF-8 locale handling
|
|
------------------------------------------------------------------------- */
|
|
|
|
#ifdef __cplusplus
|
|
#if wxUSE_UNICODE_UTF8
|
|
/* flag indicating whether the current locale uses UTF-8 or not; must be
|
|
updated every time the locale is changed! */
|
|
#if wxUSE_UTF8_LOCALE_ONLY
|
|
#define wxLocaleIsUtf8 true
|
|
#else
|
|
extern WXDLLIMPEXP_BASE bool wxLocaleIsUtf8;
|
|
#endif
|
|
/* function used to update the flag: */
|
|
extern WXDLLIMPEXP_BASE void wxUpdateLocaleIsUtf8();
|
|
#else /* !wxUSE_UNICODE_UTF8 */
|
|
inline void wxUpdateLocaleIsUtf8() {}
|
|
#endif /* wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8 */
|
|
#endif /* __cplusplus */
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
string.h
|
|
------------------------------------------------------------------------- */
|
|
|
|
#define wxCRT_StrcatA strcat
|
|
#define wxCRT_StrchrA strchr
|
|
#define wxCRT_StrcmpA strcmp
|
|
#define wxCRT_StrcpyA strcpy
|
|
#define wxCRT_StrcspnA strcspn
|
|
#define wxCRT_StrlenA strlen
|
|
#define wxCRT_StrncatA strncat
|
|
#define wxCRT_StrncmpA strncmp
|
|
#define wxCRT_StrncpyA strncpy
|
|
#define wxCRT_StrpbrkA strpbrk
|
|
#define wxCRT_StrrchrA strrchr
|
|
#define wxCRT_StrspnA strspn
|
|
#define wxCRT_StrstrA strstr
|
|
|
|
#define wxCRT_StrcatW wcscat
|
|
#define wxCRT_StrchrW wcschr
|
|
#define wxCRT_StrcmpW wcscmp
|
|
#define wxCRT_StrcpyW wcscpy
|
|
#define wxCRT_StrcspnW wcscspn
|
|
#define wxCRT_StrncatW wcsncat
|
|
#define wxCRT_StrncmpW wcsncmp
|
|
#define wxCRT_StrncpyW wcsncpy
|
|
#define wxCRT_StrpbrkW wcspbrk
|
|
#define wxCRT_StrrchrW wcsrchr
|
|
#define wxCRT_StrspnW wcsspn
|
|
#define wxCRT_StrstrW wcsstr
|
|
|
|
/* these functions are not defined under CE, at least in VC8 CRT */
|
|
#if !defined(__WXWINCE__)
|
|
#define wxCRT_StrcollA strcoll
|
|
#define wxCRT_StrxfrmA strxfrm
|
|
|
|
#define wxCRT_StrcollW wcscoll
|
|
#define wxCRT_StrxfrmW wcsxfrm
|
|
#endif /* __WXWINCE__ */
|
|
|
|
/* Almost all compilers have strdup(), but VC++ and MinGW call it _strdup().
|
|
And it's not available in MinGW strict ANSI mode nor under Windows CE. */
|
|
#if (defined(__VISUALC__) && __VISUALC__ >= 1400)
|
|
#define wxCRT_StrdupA _strdup
|
|
#elif defined(__MINGW32__)
|
|
#ifndef __WX_STRICT_ANSI_GCC__
|
|
#define wxCRT_StrdupA _strdup
|
|
#endif
|
|
#elif !defined(__WXWINCE__)
|
|
#define wxCRT_StrdupA strdup
|
|
#endif
|
|
|
|
/* most Windows compilers provide _wcsdup() */
|
|
#if defined(__WINDOWS__) && \
|
|
!(defined(__CYGWIN__) || defined(__WX_STRICT_ANSI_GCC__))
|
|
#define wxCRT_StrdupW _wcsdup
|
|
#elif defined(HAVE_WCSDUP)
|
|
#define wxCRT_StrdupW wcsdup
|
|
#endif
|
|
|
|
#ifdef wxHAVE_TCHAR_SUPPORT
|
|
/* we surely have wchar_t if we have TCHAR have wcslen() */
|
|
#ifndef HAVE_WCSLEN
|
|
#define HAVE_WCSLEN
|
|
#endif
|
|
#endif /* wxHAVE_TCHAR_SUPPORT */
|
|
|
|
#ifdef HAVE_WCSLEN
|
|
#define wxCRT_StrlenW wcslen
|
|
#endif
|
|
|
|
#define wxCRT_StrtodA strtod
|
|
#define wxCRT_StrtolA strtol
|
|
#define wxCRT_StrtoulA strtoul
|
|
#define wxCRT_StrtodW wcstod
|
|
#define wxCRT_StrtolW wcstol
|
|
#define wxCRT_StrtoulW wcstoul
|
|
|
|
#ifdef __VISUALC__
|
|
#if __VISUALC__ >= 1300 && !defined(__WXWINCE__)
|
|
#define wxCRT_StrtollA _strtoi64
|
|
#define wxCRT_StrtoullA _strtoui64
|
|
#define wxCRT_StrtollW _wcstoi64
|
|
#define wxCRT_StrtoullW _wcstoui64
|
|
#endif /* VC++ 7+ */
|
|
#else
|
|
#ifdef HAVE_STRTOULL
|
|
#define wxCRT_StrtollA strtoll
|
|
#define wxCRT_StrtoullA strtoull
|
|
#endif /* HAVE_STRTOULL */
|
|
#ifdef HAVE_WCSTOULL
|
|
/* assume that we have wcstoull(), which is also C99, too */
|
|
#define wxCRT_StrtollW wcstoll
|
|
#define wxCRT_StrtoullW wcstoull
|
|
#endif /* HAVE_WCSTOULL */
|
|
#endif
|
|
|
|
/*
|
|
Only VC8 and later provide strnlen() and wcsnlen() functions under Windows
|
|
and it's also only available starting from Windows CE 6.0 only in CE build.
|
|
*/
|
|
#if wxCHECK_VISUALC_VERSION(8) && (!defined(_WIN32_WCE) || (_WIN32_WCE >= 0x600))
|
|
#ifndef HAVE_STRNLEN
|
|
#define HAVE_STRNLEN
|
|
#endif
|
|
#ifndef HAVE_WCSNLEN
|
|
#define HAVE_WCSNLEN
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef HAVE_STRNLEN
|
|
#define wxCRT_StrnlenA strnlen
|
|
#endif
|
|
|
|
#ifdef HAVE_WCSNLEN
|
|
#define wxCRT_StrnlenW wcsnlen
|
|
#endif
|
|
|
|
/* define wxCRT_StricmpA/W and wxCRT_StrnicmpA/W for various compilers */
|
|
|
|
#if defined(__BORLANDC__) || defined(__WATCOMC__) || \
|
|
defined(__VISAGECPP__) || \
|
|
defined(__EMX__) || defined(__DJGPP__)
|
|
#define wxCRT_StricmpA stricmp
|
|
#define wxCRT_StrnicmpA strnicmp
|
|
#elif defined(__SYMANTEC__) || defined(__VISUALC__)
|
|
#define wxCRT_StricmpA _stricmp
|
|
#define wxCRT_StrnicmpA _strnicmp
|
|
#elif defined(__UNIX__) || (defined(__GNUWIN32__) && !defined(__WX_STRICT_ANSI_GCC__))
|
|
#define wxCRT_StricmpA strcasecmp
|
|
#define wxCRT_StrnicmpA strncasecmp
|
|
/* #else -- use wxWidgets implementation */
|
|
#endif
|
|
|
|
#ifdef __VISUALC__
|
|
#define wxCRT_StricmpW _wcsicmp
|
|
#define wxCRT_StrnicmpW _wcsnicmp
|
|
#elif defined(__UNIX__)
|
|
#ifdef HAVE_WCSCASECMP
|
|
#define wxCRT_StricmpW wcscasecmp
|
|
#endif
|
|
#ifdef HAVE_WCSNCASECMP
|
|
#define wxCRT_StrnicmpW wcsncasecmp
|
|
#endif
|
|
/* #else -- use wxWidgets implementation */
|
|
#endif
|
|
|
|
#ifdef HAVE_STRTOK_R
|
|
#define wxCRT_StrtokA(str, sep, last) strtok_r(str, sep, last)
|
|
#endif
|
|
/* FIXME-UTF8: detect and use wcstok() if available for wxCRT_StrtokW */
|
|
|
|
/* these are extern "C" because they are used by regex lib: */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrlenW
|
|
WXDLLIMPEXP_BASE size_t wxCRT_StrlenW(const wchar_t *s);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrncmpW
|
|
WXDLLIMPEXP_BASE int wxCRT_StrncmpW(const wchar_t *s1, const wchar_t *s2, size_t n);
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
/* FIXME-UTF8: remove this once we are Unicode only */
|
|
#if wxUSE_UNICODE
|
|
#define wxCRT_StrlenNative wxCRT_StrlenW
|
|
#define wxCRT_StrncmpNative wxCRT_StrncmpW
|
|
#define wxCRT_ToupperNative wxCRT_ToupperW
|
|
#define wxCRT_TolowerNative wxCRT_TolowerW
|
|
#else
|
|
#define wxCRT_StrlenNative wxCRT_StrlenA
|
|
#define wxCRT_StrncmpNative wxCRT_StrncmpA
|
|
#define wxCRT_ToupperNative toupper
|
|
#define wxCRT_TolowerNative tolower
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrcatW
|
|
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrcatW(wchar_t *dest, const wchar_t *src);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrchrW
|
|
WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrchrW(const wchar_t *s, wchar_t c);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrcmpW
|
|
WXDLLIMPEXP_BASE int wxCRT_StrcmpW(const wchar_t *s1, const wchar_t *s2);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrcollW
|
|
WXDLLIMPEXP_BASE int wxCRT_StrcollW(const wchar_t *s1, const wchar_t *s2);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrcpyW
|
|
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrcpyW(wchar_t *dest, const wchar_t *src);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrcspnW
|
|
WXDLLIMPEXP_BASE size_t wxCRT_StrcspnW(const wchar_t *s, const wchar_t *reject);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrncatW
|
|
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrncatW(wchar_t *dest, const wchar_t *src, size_t n);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrncpyW
|
|
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrncpyW(wchar_t *dest, const wchar_t *src, size_t n);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrpbrkW
|
|
WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrpbrkW(const wchar_t *s, const wchar_t *accept);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrrchrW
|
|
WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrrchrW(const wchar_t *s, wchar_t c);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrspnW
|
|
WXDLLIMPEXP_BASE size_t wxCRT_StrspnW(const wchar_t *s, const wchar_t *accept);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrstrW
|
|
WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrstrW(const wchar_t *haystack, const wchar_t *needle);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrtodW
|
|
WXDLLIMPEXP_BASE double wxCRT_StrtodW(const wchar_t *nptr, wchar_t **endptr);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrtolW
|
|
WXDLLIMPEXP_BASE long int wxCRT_StrtolW(const wchar_t *nptr, wchar_t **endptr, int base);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrtoulW
|
|
WXDLLIMPEXP_BASE unsigned long int wxCRT_StrtoulW(const wchar_t *nptr, wchar_t **endptr, int base);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrxfrmW
|
|
WXDLLIMPEXP_BASE size_t wxCRT_StrxfrmW(wchar_t *dest, const wchar_t *src, size_t n);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrdupA
|
|
WXDLLIMPEXP_BASE char *wxCRT_StrdupA(const char *psz);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrdupW
|
|
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrdupW(const wchar_t *pwz);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StricmpA
|
|
WXDLLIMPEXP_BASE int wxCRT_StricmpA(const char *psz1, const char *psz2);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StricmpW
|
|
WXDLLIMPEXP_BASE int wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrnicmpA
|
|
WXDLLIMPEXP_BASE int wxCRT_StrnicmpA(const char *psz1, const char *psz2, size_t len);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrnicmpW
|
|
WXDLLIMPEXP_BASE int wxCRT_StrnicmpW(const wchar_t *psz1, const wchar_t *psz2, size_t len);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrtokA
|
|
WXDLLIMPEXP_BASE char *wxCRT_StrtokA(char *psz, const char *delim, char **save_ptr);
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrtokW
|
|
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrtokW(wchar_t *psz, const wchar_t *delim, wchar_t **save_ptr);
|
|
#endif
|
|
|
|
/* supply strtoll and strtoull, if needed */
|
|
#ifdef wxLongLong_t
|
|
#ifndef wxCRT_StrtollA
|
|
WXDLLIMPEXP_BASE wxLongLong_t wxCRT_StrtollA(const char* nptr,
|
|
char** endptr,
|
|
int base);
|
|
WXDLLIMPEXP_BASE wxULongLong_t wxCRT_StrtoullA(const char* nptr,
|
|
char** endptr,
|
|
int base);
|
|
#endif
|
|
#ifndef wxCRT_StrtollW
|
|
WXDLLIMPEXP_BASE wxLongLong_t wxCRT_StrtollW(const wchar_t* nptr,
|
|
wchar_t** endptr,
|
|
int base);
|
|
WXDLLIMPEXP_BASE wxULongLong_t wxCRT_StrtoullW(const wchar_t* nptr,
|
|
wchar_t** endptr,
|
|
int base);
|
|
#endif
|
|
#endif /* wxLongLong_t */
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
stdio.h
|
|
------------------------------------------------------------------------- */
|
|
|
|
#if defined(__UNIX__) || defined(__WXMAC__)
|
|
#define wxMBFILES 1
|
|
#else
|
|
#define wxMBFILES 0
|
|
#endif
|
|
|
|
|
|
/* these functions are only needed in the form used for filenames (i.e. char*
|
|
on Unix, wchar_t* on Windows), so we don't need to use A/W suffix: */
|
|
#if wxMBFILES || !wxUSE_UNICODE /* ANSI filenames */
|
|
|
|
#define wxCRT_Fopen fopen
|
|
#define wxCRT_Freopen freopen
|
|
#define wxCRT_Remove remove
|
|
#define wxCRT_Rename rename
|
|
|
|
#else /* Unicode filenames */
|
|
/* special case: these functions are missing under Win9x with Unicows so we
|
|
have to implement them ourselves */
|
|
#if wxUSE_UNICODE_MSLU || defined(__WX_STRICT_ANSI_GCC__)
|
|
WXDLLIMPEXP_BASE FILE* wxMSLU__wfopen(const wchar_t *name, const wchar_t *mode);
|
|
WXDLLIMPEXP_BASE FILE* wxMSLU__wfreopen(const wchar_t *name, const wchar_t *mode, FILE *stream);
|
|
WXDLLIMPEXP_BASE int wxMSLU__wrename(const wchar_t *oldname, const wchar_t *newname);
|
|
WXDLLIMPEXP_BASE int wxMSLU__wremove(const wchar_t *name);
|
|
#define wxCRT_Fopen wxMSLU__wfopen
|
|
#define wxCRT_Freopen wxMSLU__wfreopen
|
|
#define wxCRT_Remove wxMSLU__wremove
|
|
#define wxCRT_Rename wxMSLU__wrename
|
|
#else
|
|
/* WinCE CRT doesn't provide these functions so use our own */
|
|
#ifdef __WXWINCE__
|
|
WXDLLIMPEXP_BASE int wxCRT_Rename(const wchar_t *src,
|
|
const wchar_t *dst);
|
|
WXDLLIMPEXP_BASE int wxCRT_Remove(const wchar_t *path);
|
|
#else
|
|
#define wxCRT_Rename _wrename
|
|
#define wxCRT_Remove _wremove
|
|
#endif
|
|
#define wxCRT_Fopen _wfopen
|
|
#define wxCRT_Freopen _wfreopen
|
|
#endif
|
|
|
|
#endif /* wxMBFILES/!wxMBFILES */
|
|
|
|
#define wxCRT_PutsA puts
|
|
#define wxCRT_FputsA fputs
|
|
#define wxCRT_FgetsA fgets
|
|
#define wxCRT_FputcA fputc
|
|
#define wxCRT_FgetcA fgetc
|
|
#define wxCRT_UngetcA ungetc
|
|
|
|
#ifdef wxHAVE_TCHAR_SUPPORT
|
|
#define wxCRT_PutsW _putws
|
|
#define wxCRT_FputsW fputws
|
|
#define wxCRT_FputcW fputwc
|
|
#endif
|
|
#ifdef HAVE_FPUTWS
|
|
#define wxCRT_FputsW fputws
|
|
#endif
|
|
#ifdef HAVE_PUTWS
|
|
#define wxCRT_PutsW putws
|
|
#endif
|
|
#ifdef HAVE_FPUTWC
|
|
#define wxCRT_FputcW fputwc
|
|
#endif
|
|
#define wxCRT_FgetsW fgetws
|
|
|
|
#ifndef wxCRT_PutsW
|
|
WXDLLIMPEXP_BASE int wxCRT_PutsW(const wchar_t *ws);
|
|
#endif
|
|
|
|
#ifndef wxCRT_FputsW
|
|
WXDLLIMPEXP_BASE int wxCRT_FputsW(const wchar_t *ch, FILE *stream);
|
|
#endif
|
|
|
|
#ifndef wxCRT_FputcW
|
|
WXDLLIMPEXP_BASE int wxCRT_FputcW(wchar_t wc, FILE *stream);
|
|
#endif
|
|
|
|
/*
|
|
NB: tmpnam() is unsafe and thus is not wrapped!
|
|
Use other wxWidgets facilities instead:
|
|
wxFileName::CreateTempFileName, wxTempFile, or wxTempFileOutputStream
|
|
*/
|
|
#define wxTmpnam(x) wxTmpnam_is_insecure_use_wxTempFile_instead
|
|
|
|
/* FIXME-CE: provide our own perror() using ::GetLastError() */
|
|
#ifndef __WXWINCE__
|
|
|
|
#define wxCRT_PerrorA perror
|
|
#ifdef wxHAVE_TCHAR_SUPPORT
|
|
#define wxCRT_PerrorW _wperror
|
|
#endif
|
|
|
|
#endif /* !__WXWINCE__ */
|
|
|
|
/* -------------------------------------------------------------------------
|
|
stdlib.h
|
|
------------------------------------------------------------------------- */
|
|
|
|
/* there are no env vars at all under CE, so no _tgetenv neither */
|
|
#ifdef __WXWINCE__
|
|
/* can't define as inline function as this is a C file... */
|
|
#define wxCRT_GetenvA(name) (name, NULL)
|
|
#define wxCRT_GetenvW(name) (name, NULL)
|
|
#else
|
|
#define wxCRT_GetenvA getenv
|
|
#ifdef _tgetenv
|
|
#define wxCRT_GetenvW _wgetenv
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef wxCRT_GetenvW
|
|
WXDLLIMPEXP_BASE wchar_t * wxCRT_GetenvW(const wchar_t *name);
|
|
#endif
|
|
|
|
|
|
#define wxCRT_SystemA system
|
|
/* mingw32 doesn't provide _tsystem() or _wsystem(): */
|
|
#if defined(_tsystem)
|
|
#define wxCRT_SystemW _wsystem
|
|
#endif
|
|
|
|
#define wxCRT_AtofA atof
|
|
#define wxCRT_AtoiA atoi
|
|
#define wxCRT_AtolA atol
|
|
|
|
#if defined(wxHAVE_TCHAR_SUPPORT) && !defined(__WX_STRICT_ANSI_GCC__)
|
|
#define wxCRT_AtoiW _wtoi
|
|
#define wxCRT_AtolW _wtol
|
|
/* _wtof doesn't exist */
|
|
#else
|
|
#ifndef __VMS
|
|
#define wxCRT_AtofW(s) wcstod(s, NULL)
|
|
#endif
|
|
#define wxCRT_AtolW(s) wcstol(s, NULL, 10)
|
|
/* wcstoi doesn't exist */
|
|
#endif
|
|
|
|
#ifdef __DARWIN__
|
|
#if !defined(__WXOSX_IPHONE__) && MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_2
|
|
#define wxNEED_WX_MBSTOWCS
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef wxNEED_WX_MBSTOWCS
|
|
/* even though they are defined and "implemented", they are bad and just
|
|
stubs so we need our own - we need these even in ANSI builds!! */
|
|
WXDLLIMPEXP_BASE size_t wxMbstowcs(wchar_t *, const char *, size_t);
|
|
WXDLLIMPEXP_BASE size_t wxWcstombs(char *, const wchar_t *, size_t);
|
|
#else
|
|
#define wxMbstowcs mbstowcs
|
|
#define wxWcstombs wcstombs
|
|
#endif
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
time.h
|
|
------------------------------------------------------------------------- */
|
|
|
|
#define wxCRT_StrftimeA strftime
|
|
#ifdef __SGI__
|
|
/*
|
|
IRIX provides not one but two versions of wcsftime(): XPG4 one which
|
|
uses "const char*" for the third parameter and so can't be used and the
|
|
correct, XPG5, one. Unfortunately we can't just define _XOPEN_SOURCE
|
|
high enough to get XPG5 version as this undefines other symbols which
|
|
make other functions we use unavailable (see <standards.h> for gory
|
|
details). So just declare the XPG5 version ourselves, we're extremely
|
|
unlikely to ever be compiled on a system without it. But if we ever do,
|
|
a configure test would need to be added for it (and _MIPS_SYMBOL_PRESENT
|
|
should be used to check for its presence during run-time, i.e. it would
|
|
probably be simpler to just always use our own wxCRT_StrftimeW() below
|
|
if it does ever become a problem).
|
|
*/
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
size_t
|
|
_xpg5_wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm * );
|
|
#define wxCRT_StrftimeW _xpg5_wcsftime
|
|
#else
|
|
/*
|
|
Assume it's always available under non-Unix systems as this does seem
|
|
to be the case for now. And under Unix we trust configure to detect it
|
|
(except for SGI special case above).
|
|
*/
|
|
#if defined(HAVE_WCSFTIME) || !defined(__UNIX__)
|
|
#define wxCRT_StrftimeW wcsftime
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef wxCRT_StrftimeW
|
|
WXDLLIMPEXP_BASE size_t wxCRT_StrftimeW(wchar_t *s, size_t max,
|
|
const wchar_t *fmt,
|
|
const struct tm *tm);
|
|
#endif
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
ctype.h
|
|
------------------------------------------------------------------------- */
|
|
|
|
#ifdef __WATCOMC__
|
|
#define WXWCHAR_T_CAST(c) (wint_t)(c)
|
|
#else
|
|
#define WXWCHAR_T_CAST(c) c
|
|
#endif
|
|
|
|
#define wxCRT_IsalnumW(c) iswalnum(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IsalphaW(c) iswalpha(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IscntrlW(c) iswcntrl(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IsdigitW(c) iswdigit(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IsgraphW(c) iswgraph(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IslowerW(c) iswlower(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IsprintW(c) iswprint(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IspunctW(c) iswpunct(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IsspaceW(c) iswspace(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IsupperW(c) iswupper(WXWCHAR_T_CAST(c))
|
|
#define wxCRT_IsxdigitW(c) iswxdigit(WXWCHAR_T_CAST(c))
|
|
|
|
#ifdef __GLIBC__
|
|
#if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
|
|
/* /usr/include/wctype.h incorrectly declares translations */
|
|
/* tables which provokes tons of compile-time warnings -- try */
|
|
/* to correct this */
|
|
#define wxCRT_TolowerW(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
|
|
#define wxCRT_ToupperW(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
|
|
#else /* !glibc 2.0 */
|
|
#define wxCRT_TolowerW towlower
|
|
#define wxCRT_ToupperW towupper
|
|
#endif
|
|
#else /* !__GLIBC__ */
|
|
/* There is a bug in VC6 C RTL: toxxx() functions dosn't do anything
|
|
with signed chars < 0, so "fix" it here. */
|
|
#define wxCRT_TolowerW(c) towlower((wxUChar)(wxChar)(c))
|
|
#define wxCRT_ToupperW(c) towupper((wxUChar)(wxChar)(c))
|
|
#endif /* __GLIBC__/!__GLIBC__ */
|
|
|
|
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------
|
|
wx wrappers for CRT functions in both char* and wchar_t* versions
|
|
------------------------------------------------------------------------- */
|
|
|
|
#ifdef __cplusplus
|
|
|
|
/* NB: this belongs to wxcrt.h and not this header, but it makes life easier
|
|
* for buffer.h and stringimpl.h (both of which must be included before
|
|
* string.h, which is required by wxcrt.h) to have them here: */
|
|
|
|
/* safe version of strlen() (returns 0 if passed NULL pointer) */
|
|
inline size_t wxStrlen(const char *s) { return s ? wxCRT_StrlenA(s) : 0; }
|
|
inline size_t wxStrlen(const wchar_t *s) { return s ? wxCRT_StrlenW(s) : 0; }
|
|
#ifndef wxWCHAR_T_IS_WXCHAR16
|
|
WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar16 *s );
|
|
#endif
|
|
#ifndef wxWCHAR_T_IS_WXCHAR32
|
|
WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar32 *s );
|
|
#endif
|
|
#define wxWcslen wxCRT_StrlenW
|
|
|
|
#define wxStrdupA wxCRT_StrdupA
|
|
#define wxStrdupW wxCRT_StrdupW
|
|
inline char* wxStrdup(const char *s) { return wxCRT_StrdupA(s); }
|
|
inline wchar_t* wxStrdup(const wchar_t *s) { return wxCRT_StrdupW(s); }
|
|
#ifndef wxWCHAR_T_IS_WXCHAR16
|
|
WXDLLIMPEXP_BASE wxChar16* wxStrdup(const wxChar16* s);
|
|
#endif
|
|
#ifndef wxWCHAR_T_IS_WXCHAR32
|
|
WXDLLIMPEXP_BASE wxChar32* wxStrdup(const wxChar32* s);
|
|
#endif
|
|
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* _WX_WXCRTBASE_H_ */
|