#endif
#if wxUSE_WCHAR_T
-size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
+WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n)
{
// assume that we have mbsrtowcs() too if we have wcsrtombs()
#ifdef HAVE_WCSRTOMBS
#endif
}
-size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
+WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
{
#ifdef HAVE_WCSRTOMBS
mbstate_t mbstate;
}
#endif // wxUSE_WCHAR_T
-bool WXDLLEXPORT wxOKlibc()
+WXDLLIMPEXP_BASE bool wxOKlibc()
{
#if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
// glibc 2.0 uses UTF-8 even when it shouldn't
char* wxSetlocale(int category, const char *locale)
{
+#ifdef __WXWINCE__
+ // FIXME-CE: there is no setlocale() in CE CRT, use SetThreadLocale()?
+ wxUnusedVar(category);
+ wxUnusedVar(locale);
+
+ return NULL;
+#else // !__WXWINCE__
char *rv = setlocale(category, locale);
if ( locale != NULL /* setting locale, not querying */ &&
rv /* call was successful */ )
wxUpdateLocaleIsUtf8();
}
return rv;
+#endif // __WXWINCE__/!__WXWINCE__
}
// ============================================================================
return -1;
}
-#define vswprintf wxCRT_VsnprintfW_
+#define vswprintf wxCRT_VsnprintfW
static int vfwprintf(FILE *stream, const wchar_t *format, va_list argptr)
{
#endif // wxNEED_WPRINTF
-#ifdef wxNEED_PRINTF_CONVERSION
-
-// ----------------------------------------------------------------------------
-// wxFormatConverter: class doing the "%s" -> "%ls" conversion
-// ----------------------------------------------------------------------------
-
-/*
- Here are the gory details. We want to follow the Windows/MS conventions,
- that is to have
-
- In ANSI mode:
-
- format specifier results in
- -----------------------------------
- %c, %hc, %hC char
- %lc, %C, %lC wchar_t
-
- In Unicode mode:
-
- format specifier results in
- -----------------------------------
- %hc, %C, %hC char
- %c, %lc, %lC wchar_t
-
-
- while on POSIX systems we have %C identical to %lc and %c always means char
- (in any mode) while %lc always means wchar_t,
-
- So to use native functions in order to get our semantics we must do the
- following translations in Unicode mode (nothing to do in ANSI mode):
-
- wxWidgets specifier POSIX specifier
- ----------------------------------------
-
- %hc, %C, %hC %c
- %c %lc
-
-
- And, of course, the same should be done for %s as well.
-*/
-
-class wxFormatConverter
-{
-public:
- wxFormatConverter(const wchar_t *format);
-
- // notice that we only translated the string if m_fmtOrig == NULL (as set
- // by CopyAllBefore()), otherwise we should simply use the original format
- operator const wchar_t *() const
- { return m_fmtOrig ? m_fmtOrig : m_fmt.c_str(); }
-
-private:
- // copy another character to the translated format: this function does the
- // copy if we are translating but doesn't do anything at all if we don't,
- // so we don't create the translated format string at all unless we really
- // need to (i.e. InsertFmtChar() is called)
- wchar_t CopyFmtChar(wchar_t ch)
- {
- if ( !m_fmtOrig )
- {
- // we're translating, do copy
- m_fmt += ch;
- }
- else
- {
- // simply increase the count which should be copied by
- // CopyAllBefore() later if needed
- m_nCopied++;
- }
-
- return ch;
- }
-
- // insert an extra character
- void InsertFmtChar(wchar_t ch)
- {
- if ( m_fmtOrig )
- {
- // so far we haven't translated anything yet
- CopyAllBefore();
- }
-
- m_fmt += ch;
- }
-
- void CopyAllBefore()
- {
- wxASSERT_MSG( m_fmtOrig && m_fmt.empty(), _T("logic error") );
-
- m_fmt = wxString(m_fmtOrig, m_nCopied);
-
- // we won't need it any longer
- m_fmtOrig = NULL;
- }
-
- static bool IsFlagChar(wchar_t ch)
- {
- return ch == _T('-') || ch == _T('+') ||
- ch == _T('0') || ch == _T(' ') || ch == _T('#');
- }
-
- void SkipDigits(const wchar_t **ptpc)
- {
- while ( **ptpc >= _T('0') && **ptpc <= _T('9') )
- CopyFmtChar(*(*ptpc)++);
- }
-
- // the translated format
- wxString m_fmt;
-
- // the original format
- const wchar_t *m_fmtOrig;
-
- // the number of characters already copied
- size_t m_nCopied;
-};
-
-wxFormatConverter::wxFormatConverter(const wchar_t *format)
-{
- m_fmtOrig = format;
- m_nCopied = 0;
-
- while ( *format )
- {
- if ( CopyFmtChar(*format++) == _T('%') )
- {
- // skip any flags
- while ( IsFlagChar(*format) )
- CopyFmtChar(*format++);
-
- // and possible width
- if ( *format == _T('*') )
- CopyFmtChar(*format++);
- else
- SkipDigits(&format);
-
- // precision?
- if ( *format == _T('.') )
- {
- CopyFmtChar(*format++);
- if ( *format == _T('*') )
- CopyFmtChar(*format++);
- else
- SkipDigits(&format);
- }
-
- // next we can have a size modifier
- enum
- {
- Default,
- Short,
- Long
- } size;
-
- switch ( *format )
- {
- case _T('h'):
- size = Short;
- format++;
- break;
-
- case _T('l'):
- // "ll" has a different meaning!
- if ( format[1] != _T('l') )
- {
- size = Long;
- format++;
- break;
- }
- //else: fall through
-
- default:
- size = Default;
- }
-
- // and finally we should have the type
- switch ( *format )
- {
- case _T('C'):
- case _T('S'):
- // %C and %hC -> %c and %lC -> %lc
- if ( size == Long )
- CopyFmtChar(_T('l'));
-
- InsertFmtChar(*format++ == _T('C') ? _T('c') : _T('s'));
- break;
-
- case _T('c'):
- case _T('s'):
- // %c -> %lc but %hc stays %hc and %lc is still %lc
- if ( size == Default)
- InsertFmtChar(_T('l'));
- // fall through
-
- default:
- // nothing special to do
- if ( size != Default )
- CopyFmtChar(*(format - 1));
- CopyFmtChar(*format++);
- }
- }
- }
-}
-
-#else // !wxNEED_PRINTF_CONVERSION
- // no conversion necessary
- #define wxFormatConverter(x) (x)
-#endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
-
-#ifdef __WXDEBUG__
-// For testing the format converter
-wxString wxConvertFormat(const wchar_t *format)
-{
- return wxString(wxFormatConverter(format));
-}
-#endif
-
// ----------------------------------------------------------------------------
// wxPrintf(), wxScanf() and relatives
// ----------------------------------------------------------------------------
va_list argptr;
va_start(argptr, format);
- int ret = vwprintf( wxFormatConverter(format), argptr );
+ int ret = vwprintf( format, argptr );
va_end(argptr);
va_list argptr;
va_start( argptr, format );
- int ret = vfwprintf( stream, wxFormatConverter(format), argptr );
+ int ret = vfwprintf( stream, format, argptr );
va_end(argptr);
#ifndef wxCRT_VfprintfW
int wxCRT_VfprintfW( FILE *stream, const wchar_t *format, va_list argptr )
{
- return vfwprintf( stream, wxFormatConverter(format), argptr );
+ return vfwprintf( stream, format, argptr );
}
#endif
#ifndef wxCRT_VprintfW
int wxCRT_VprintfW( const wchar_t *format, va_list argptr )
{
- return vwprintf( wxFormatConverter(format), argptr );
+ return vwprintf( format, argptr );
}
#endif
-#ifndef wxCRT_VsnprintfW
-int wxCRT_VsnprintfW(wchar_t *str, size_t size, const wchar_t *format, va_list argptr )
-{
- return vswprintf( str, size, wxFormatConverter(format), argptr );
-}
-#endif // !wxCRT_VsnprintfW
-
#ifndef wxCRT_VsprintfW
int wxCRT_VsprintfW( wchar_t *str, const wchar_t *format, va_list argptr )
{
// same as for wxSprintf()
- return vswprintf(str, INT_MAX / 4, wxFormatConverter(format), argptr);
+ return vswprintf(str, INT_MAX / 4, format, argptr);
}
#endif
#ifdef __VMS
#if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
- int ret = std::vwscanf(wxFormatConverter(format), argptr);
+ int ret = std::vwscanf(format, argptr);
#else
- int ret = vwscanf(wxFormatConverter(format), argptr);
+ int ret = vwscanf(format, argptr);
#endif
#else
- int ret = vwscanf(wxFormatConverter(format), argptr);
+ int ret = vwscanf(format, argptr);
#endif
-
+
va_end(argptr);
return ret;
#ifdef __VMS
#if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
- int ret = std::vswscanf(str, wxFormatConverter(format), argptr);
+ int ret = std::vswscanf(str, format, argptr);
#else
- int ret = vswscanf(str, wxFormatConverter(format), argptr);
+ int ret = vswscanf(str, format, argptr);
#endif
#else
- int ret = vswscanf(str, wxFormatConverter(format), argptr);
+ int ret = vswscanf(str, format, argptr);
#endif
va_end(argptr);
va_start(argptr, format);
#ifdef __VMS
#if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
- int ret = std::vfwscanf(stream, wxFormatConverter(format), argptr);
+ int ret = std::vfwscanf(stream, format, argptr);
#else
- int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
+ int ret = vfwscanf(stream, format, argptr);
#endif
#else
- int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
+ int ret = vfwscanf(stream, format, argptr);
#endif
va_end(argptr);
{
#ifdef __VMS
#if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
- return std::vswscanf(str, wxFormatConverter(format), argptr);
+ return std::vswscanf(str, format, argptr);
#else
- return vswscanf(str, wxFormatConverter(format), argptr);
+ return vswscanf(str, format, argptr);
#endif
#else
- return vswscanf(str, wxFormatConverter(format), argptr);
+ return vswscanf(str, format, argptr);
#endif
}
#endif
#if wxUSE_UNICODE
+namespace
+{
+
#if !wxUSE_UTF8_LOCALE_ONLY
-static int ConvertStringToBuf(const wxString& s, char *out, size_t outsize)
+int ConvertStringToBuf(const wxString& s, char *out, size_t outsize)
{
const wxWX2WCbuf buf = s.wc_str();
#endif // !wxUSE_UTF8_LOCALE_ONLY
#if wxUSE_UNICODE_UTF8
-static int ConvertStringToBuf(const wxString& s, wchar_t *out, size_t outsize)
+int ConvertStringToBuf(const wxString& s, wchar_t *out, size_t outsize)
{
const wxWX2WCbuf buf(s.wc_str());
- size_t len = wxWcslen(buf);
+ size_t len = s.length(); // same as buf length for wchar_t*
if ( outsize > len )
+ {
memcpy(out, buf, (len+1) * sizeof(wchar_t));
- // else: not enough space
+ }
+ else // not enough space
+ {
+ memcpy(out, buf, (outsize-1) * sizeof(wchar_t));
+ out[outsize-1] = 0;
+ }
return len;
}
#endif // wxUSE_UNICODE_UTF8
+} // anonymous namespace
+
template<typename T>
static size_t PrintfViaString(T *out, size_t outsize,
const wxString& format, va_list argptr)
int wxVsprintf(char *str, const wxString& format, va_list argptr)
{
#if wxUSE_UTF8_LOCALE_ONLY
- return vsprintf(str, format.wx_str(), argptr);
+ return wxCRT_VsprintfA(str, format.wx_str(), argptr);
#else
#if wxUSE_UNICODE_UTF8
if ( wxLocaleIsUtf8 )
- return vsprintf(str, format.wx_str(), argptr);
+ return wxCRT_VsprintfA(str, format.wx_str(), argptr);
else
#endif
#if wxUSE_UNICODE
#ifdef wxNEED_WX_MBSTOWCS
-WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
+WXDLLIMPEXP_BASE size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
{
if (!out)
{
return in - origin;
}
-WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
+WXDLLIMPEXP_BASE size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
{
if (!out)
{
#endif // wxNEED_WX_MBSTOWCS
#ifndef wxCRT_StrdupA
-WXDLLEXPORT char *wxCRT_StrdupA(const char *s)
+WXDLLIMPEXP_BASE char *wxCRT_StrdupA(const char *s)
{
return strcpy((char *)malloc(strlen(s) + 1), s);
}
#endif // wxCRT_StrdupA
#ifndef wxCRT_StrdupW
-WXDLLEXPORT wchar_t * wxCRT_StrdupW(const wchar_t *pwz)
+WXDLLIMPEXP_BASE wchar_t * wxCRT_StrdupW(const wchar_t *pwz)
{
size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
wchar_t *ret = (wchar_t *) malloc(size);
#endif // wxCRT_StrdupW
#ifndef wxCRT_StricmpA
-int WXDLLEXPORT wxCRT_StricmpA(const char *psz1, const char *psz2)
+WXDLLIMPEXP_BASE int wxCRT_StricmpA(const char *psz1, const char *psz2)
{
register char c1, c2;
do {
#endif // !defined(wxCRT_StricmpA)
#ifndef wxCRT_StricmpW
-int WXDLLEXPORT wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2)
+WXDLLIMPEXP_BASE int wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2)
{
register wchar_t c1, c2;
do {
#endif // !defined(wxCRT_StricmpW)
#ifndef wxCRT_StrnicmpA
-int WXDLLEXPORT wxCRT_StrnicmpA(const char *s1, const char *s2, size_t n)
+WXDLLIMPEXP_BASE int wxCRT_StrnicmpA(const char *s1, const char *s2, size_t n)
{
// initialize the variables just to suppress stupid gcc warning
register char c1 = 0, c2 = 0;
#endif // !defined(wxCRT_StrnicmpA)
#ifndef wxCRT_StrnicmpW
-int WXDLLEXPORT wxCRT_StrnicmpW(const wchar_t *s1, const wchar_t *s2, size_t n)
+WXDLLIMPEXP_BASE int wxCRT_StrnicmpW(const wchar_t *s1, const wchar_t *s2, size_t n)
{
// initialize the variables just to suppress stupid gcc warning
register wchar_t c1 = 0, c2 = 0;
// this (and wxCRT_StrncmpW below) are extern "C" because they are needed
// by regex code, the rest isn't needed, so it's not declared as extern "C"
#ifndef wxCRT_StrlenW
-extern "C" WXDLLEXPORT size_t wxCRT_StrlenW(const wchar_t *s)
+extern "C" WXDLLIMPEXP_BASE size_t wxCRT_StrlenW(const wchar_t *s)
{
size_t n = 0;
while ( *s++ )
// ----------------------------------------------------------------------------
#ifndef wxCRT_GetenvW
-wchar_t* WXDLLEXPORT wxCRT_GetenvW(const wchar_t *name)
+WXDLLIMPEXP_BASE wchar_t* wxCRT_GetenvW(const wchar_t *name)
{
// NB: buffer returned by getenv() is allowed to be overwritten next
// time getenv() is called, so it is OK to use static string
#endif // !wxCRT_GetenvW
#ifndef wxCRT_StrftimeW
-WXDLLEXPORT size_t
+WXDLLIMPEXP_BASE size_t
wxCRT_StrftimeW(wchar_t *s, size_t maxsize, const wchar_t *fmt, const struct tm *tm)
{
if ( !maxsize )
#endif // wxUSE_WCHAR_T
+#ifdef wxLongLong_t
template<typename T>
static wxULongLong_t
wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
wxString::const_iterator end = wxstr.end();
// Skip spaces
- while ( i != end && wxIsspace(*i) ) i++;
+ while ( i != end && wxIsspace(*i) ) ++i;
// Starts with sign?
*sign = wxT(' ');
if ( c == wxT('+') || c == wxT('-') )
{
*sign = c;
- i++;
+ ++i;
}
}
// Starts with 0x?
if ( i != end && *i == wxT('0') )
{
- i++;
+ ++i;
if ( i != end )
{
if ( *i == wxT('x') && (base == 16 || base == 0) )
{
base = 16;
- i++;
+ ++i;
}
else
{
}
}
else
- i--;
+ --i;
}
if ( base == 0 )
base = 10;
- for ( ; i != end; i++ )
+ for ( ; i != end; ++i )
{
unsigned int n;
T c = *i;
- if ( c >= wxT('0') )
+ if ( c >= '0' )
{
- if ( c <= wxT('9') )
+ if ( c <= '9' )
n = c - wxT('0');
else
n = wxTolower(c) - wxT('a') + 10;
static wxULongLong_t wxCRT_DoStrtoull(const T* nptr, T** endptr, int base)
{
T sign;
- wxULongLong_t uval = wxCRT_StrtoullBase(nptr, endptr, base, &sign);
+ wxULongLong_t uval = ::wxCRT_StrtoullBase(nptr, endptr, base, &sign);
if ( sign == wxT('-') )
{
static wxLongLong_t wxCRT_DoStrtoll(const T* nptr, T** endptr, int base)
{
T sign;
- wxULongLong_t uval = wxCRT_StrtoullBase(nptr, endptr, base, &sign);
+ wxULongLong_t uval = ::wxCRT_StrtoullBase(nptr, endptr, base, &sign);
wxLongLong_t val = 0;
if ( sign == wxT('-') )
{ return wxCRT_DoStrtoull(nptr, endptr, base); }
#endif
+#endif // wxLongLong_t
+
// ----------------------------------------------------------------------------
// functions which we may need even if !wxUSE_WCHAR_T
// ----------------------------------------------------------------------------
#endif // __WXWINCE__ <= 211
-#ifdef __WXWINCE__
-int wxCRT_RemoveW(const wchar_t *path)
-{
- return ::DeleteFile(path) == 0;
-}
-#endif
-
-#ifndef wxCRT_TmpnamW
-wchar_t *wxCRT_TmpnamW(wchar_t *s)
-{
- // tmpnam_r() returns NULL if s=NULL, do the same
- wxCHECK_MSG( s, NULL, "wxTmpnam must be called with a buffer" );
-
-#ifndef L_tmpnam
- #define L_tmpnam 1024
-#endif
- wxCharBuffer buf(L_tmpnam);
- tmpnam(buf.data());
-
- wxConvLibc.ToWChar(s, L_tmpnam+1, buf.data());
- return s;
-}
-#endif // !wxCRT_TmpnamW
-
-
// ============================================================================
// wxLocaleIsUtf8
// ============================================================================
#endif
}
+#ifdef wxCRT_PerrorA
+
void wxPerror(const wxString& s)
{
#ifdef wxCRT_PerrorW
#endif
}
+#endif // wxCRT_PerrorA
+
wchar_t *wxFgets(wchar_t *s, int size, FILE *stream)
{
wxCHECK_MSG( s, NULL, "empty buffer passed to wxFgets()" );
projects / wxWidgets.git / blobdiff