]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/wxcrt.cpp
add GetLo/Hi() test
[wxWidgets.git] / src / common / wxcrt.cpp
index a967694a346a659a6d675be44aa80570b174bdea..5d42579e942ec25ae602c90b80a3f6f4055e1925 100644 (file)
@@ -21,6 +21,7 @@
 #endif
 
 #include "wx/crt.h"
+#include "wx/strconv.h" // wxMBConv::cWC2MB()
 
 #define _ISOC9X_SOURCE 1 // to get vsscanf()
 #define _BSD_SOURCE    1 // to still get strdup()
 #include <stdlib.h>
 #include <string.h>
 
+#ifndef __WXPALMOS5__
 #ifndef __WXWINCE__
     #include <time.h>
     #include <locale.h>
 #else
     #include "wx/msw/wince/time.h"
 #endif
+#endif // !__WXPALMOS5__
 
 #ifndef WX_PRECOMP
     #include "wx/string.h"
     #include "wx/log.h"
 #endif
 
+#ifdef HAVE_LANGINFO_H
+    #include <langinfo.h>
+#endif
+
 #ifdef __WXWINCE__
     // there is no errno.h under CE apparently
     #define wxSET_ERRNO(value)
@@ -57,8 +64,15 @@ namespace std {}
 using namespace std ;
 #endif
 
+#if defined(__DARWIN__)
+       #include "wx/osx/core/cfref.h"
+       #include <CoreFoundation/CFLocale.h>
+       #include "wx/osx/core/cfstring.h"
+    #include <xlocale.h>
+#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
@@ -91,7 +105,7 @@ size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 #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;
@@ -119,36 +133,43 @@ size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 }
 #endif // wxUSE_WCHAR_T
 
-bool WXDLLEXPORT wxOKlibc()
-{
-#if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
-  // glibc 2.0 uses UTF-8 even when it shouldn't
-  wchar_t res = 0;
-  if ((MB_CUR_MAX == 2) &&
-      (wxMB2WC(&res, "\xdd\xa5", 1) == 1) &&
-      (res==0x765)) {
-    // this is UTF-8 allright, check whether that's what we want
-    char *cur_locale = setlocale(LC_CTYPE, NULL);
-    if ((strlen(cur_locale) < 4) ||
-            (strcasecmp(cur_locale + strlen(cur_locale) - 4, "utf8")) ||
-            (strcasecmp(cur_locale + strlen(cur_locale) - 5, "utf-8"))) {
-      // nope, don't use libc conversion
-      return false;
-    }
-  }
-#endif
-  return true;
-}
-
 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__
+#ifdef __WXMAC__
+    char *rv = NULL ;
+    if ( locale != NULL && locale[0] == 0 )
+    {
+        // the attempt to use newlocale(LC_ALL_MASK, "", NULL);
+        // here in order to deduce the language along the environment vars rules
+        // lead to strange crashes later...
+
+        // we have to emulate the behaviour under OS X
+        wxCFRef<CFLocaleRef> userLocaleRef(CFLocaleCopyCurrent());
+        wxCFStringRef str(wxCFRetain((CFStringRef)CFLocaleGetValue(userLocaleRef, kCFLocaleLanguageCode)));
+        wxString langFull = str.AsString()+"_";
+        str.reset(wxCFRetain((CFStringRef)CFLocaleGetValue(userLocaleRef, kCFLocaleCountryCode)));
+        langFull += str.AsString();
+        rv = setlocale(category, langFull.c_str());
+    }
+    else
+        rv = setlocale(category, locale);
+#else
     char *rv = setlocale(category, locale);
+#endif
     if ( locale != NULL /* setting locale, not querying */ &&
          rv /* call was successful */ )
     {
         wxUpdateLocaleIsUtf8();
     }
     return rv;
+#endif // __WXWINCE__/!__WXWINCE__
 }
 
 // ============================================================================
@@ -239,21 +260,6 @@ static int vwscanf(const wchar_t *format, va_list argptr)
     return -1;
 }
 
-static int vswscanf(const wchar_t *ws, const wchar_t *format, va_list argptr)
-{
-    // The best we can do without proper Unicode support in glibc is to
-    // convert the strings into MB representation and run ANSI version
-    // of the function. This doesn't work with %c and %s because of difference
-    // in size of char and wchar_t, though.
-
-    wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1,
-                 _T("incomplete vswscanf implementation doesn't allow %s") );
-    wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
-                 _T("incomplete vswscanf implementation doesn't allow %c") );
-
-    return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argptr);
-}
-
 static int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
 {
     wxFAIL_MSG( _T("TODO") );
@@ -285,6 +291,24 @@ static int vwprintf(const wchar_t *format, va_list argptr)
 
 #endif // wxNEED_WPRINTF
 
+#ifdef wxNEED_VSWSCANF
+static int vswscanf(const wchar_t *ws, const wchar_t *format, va_list argptr)
+{
+    // The best we can do without proper Unicode support in glibc is to
+    // convert the strings into MB representation and run ANSI version
+    // of the function. This doesn't work with %c and %s because of difference
+    // in size of char and wchar_t, though.
+
+    wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1,
+                 _T("incomplete vswscanf implementation doesn't allow %s") );
+    wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
+                 _T("incomplete vswscanf implementation doesn't allow %c") );
+
+    return vsscanf(wx_static_cast(const char*, wxConvLibc.cWX2MB(ws)),
+        wxConvLibc.cWX2MB(format), argptr);
+}
+#endif
+
 // ----------------------------------------------------------------------------
 // wxPrintf(), wxScanf() and relatives
 // ----------------------------------------------------------------------------
@@ -359,7 +383,7 @@ int wxCRT_ScanfW(const wchar_t *format, ...)
 #else
    int ret = vwscanf(format, argptr);
 #endif
-   
+
     va_end(argptr);
 
     return ret;
@@ -548,8 +572,11 @@ int wxDoSnprintfUtf8(wchar_t *str, size_t size, const char *format, ...)
 
 #if wxUSE_UNICODE
 
+namespace
+{
+
 #if !wxUSE_UTF8_LOCALE_ONLY
-int wxInternalConvertStringToBuf(const wxString& s, char *out, size_t outsize)
+int ConvertStringToBuf(const wxString& s, char *out, size_t outsize)
 {
     const wxWX2WCbuf buf = s.wc_str();
 
@@ -562,17 +589,25 @@ int wxInternalConvertStringToBuf(const wxString& s, char *out, size_t outsize)
 #endif // !wxUSE_UTF8_LOCALE_ONLY
 
 #if wxUSE_UNICODE_UTF8
-int wxInternalConvertStringToBuf(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)
@@ -580,18 +615,18 @@ static size_t PrintfViaString(T *out, size_t outsize,
     wxString s;
     s.PrintfV(format, argptr);
 
-    return wxInternalConvertStringToBuf(s, out, outsize);
+    return ConvertStringToBuf(s, out, outsize);
 }
 #endif // wxUSE_UNICODE
 
 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
@@ -606,7 +641,20 @@ int wxVsprintf(char *str, const wxString& format, va_list argptr)
 int wxVsprintf(wchar_t *str, const wxString& format, va_list argptr)
 {
 #if wxUSE_UNICODE_WCHAR
+#ifdef __DMC__
+/*
+This fails with a bug similar to 
+http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=c++.beta&artnum=680
+in DMC 8.49 and 8.50
+I don't see it being used in the wxWidgets sources at present (oct 2007) CE
+*/
+#pragma message ( "warning ::::: wxVsprintf(wchar_t *str, const wxString& format, va_list argptr) not yet implemented" )
+    wxFAIL_MSG( _T("TODO") );
+
+    return -1;
+#else
     return wxCRT_VsprintfW(str, format.wc_str(), argptr);
+#endif //DMC
 #else // wxUSE_UNICODE_UTF8
     #if !wxUSE_UTF8_LOCALE_ONLY
     if ( !wxLocaleIsUtf8 )
@@ -685,7 +733,7 @@ int wxVsnprintf(wchar_t *str, size_t size, const wxString& format, va_list argpt
 
 #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)
     {
@@ -707,7 +755,7 @@ WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
     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)
     {
@@ -732,14 +780,14 @@ WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
 #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);
@@ -749,7 +797,7 @@ WXDLLEXPORT wchar_t * wxCRT_StrdupW(const wchar_t *pwz)
 #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 {
@@ -761,7 +809,7 @@ int WXDLLEXPORT wxCRT_StricmpA(const char *psz1, const char *psz2)
 #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 {
@@ -773,7 +821,7 @@ int WXDLLEXPORT wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2)
 #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;
@@ -787,7 +835,7 @@ int WXDLLEXPORT wxCRT_StrnicmpA(const char *s1, const char *s2, size_t n)
 #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;
@@ -807,7 +855,7 @@ int WXDLLEXPORT wxCRT_StrnicmpW(const wchar_t *s1, const wchar_t *s2, size_t n)
 // 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++ )
@@ -822,7 +870,7 @@ extern "C" WXDLLEXPORT size_t wxCRT_StrlenW(const wchar_t *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
@@ -834,7 +882,7 @@ wchar_t* WXDLLEXPORT wxCRT_GetenvW(const wchar_t *name)
 #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 )
@@ -861,6 +909,7 @@ wxCRT_StrftimeW(wchar_t *s, size_t maxsize, const wchar_t *fmt, const struct tm
 
 #endif // wxUSE_WCHAR_T
 
+#ifdef wxLongLong_t
 template<typename T>
 static wxULongLong_t
 wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
@@ -871,7 +920,7 @@ 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(' ');
@@ -881,20 +930,20 @@ wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
         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
             {
@@ -905,20 +954,20 @@ wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
             }
         }
         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;
@@ -952,7 +1001,7 @@ template<typename T>
 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('-') )
     {
@@ -967,17 +1016,14 @@ template<typename T>
 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('-') )
     {
-        if ( uval <= wxULL(wxINT64_MAX+1) )
+        if (uval <= (wxULongLong_t)wxINT64_MAX + 1)
         {
-            if ( uval == wxULL(wxINT64_MAX+1))
-                val = -((wxLongLong_t)wxINT64_MAX) - 1;
-            else
-                val = -((wxLongLong_t)uval);
+            val = -(wxLongLong_t)uval;
         }
         else
         {
@@ -1014,6 +1060,8 @@ wxULongLong_t wxCRT_StrtoullW(const wchar_t* nptr, wchar_t** endptr, int base)
     { return wxCRT_DoStrtoull(nptr, endptr, base); }
 #endif
 
+#endif // wxLongLong_t
+
 // ----------------------------------------------------------------------------
 // functions which we may need even if !wxUSE_WCHAR_T
 // ----------------------------------------------------------------------------
@@ -1085,31 +1133,6 @@ void *calloc( size_t num, size_t size )
 
 #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
 // ============================================================================
@@ -1142,7 +1165,7 @@ static bool wxIsLocaleUtf8()
             return true;
         }
     }
-#endif
+#endif // HAVE_LANGINFO_H
 
     // check if we're running under the "C" locale: it is 7bit subset
     // of UTF-8, so it can be safely used with the UTF-8 build:
@@ -1210,6 +1233,8 @@ int wxFputc(const wxUniChar& c, FILE *stream)
 #endif
 }
 
+#ifdef wxCRT_PerrorA
+
 void wxPerror(const wxString& s)
 {
 #ifdef wxCRT_PerrorW
@@ -1221,6 +1246,8 @@ void wxPerror(const wxString& s)
 #endif
 }
 
+#endif // wxCRT_PerrorA
+
 wchar_t *wxFgets(wchar_t *s, int size, FILE *stream)
 {
     wxCHECK_MSG( s, NULL, "empty buffer passed to wxFgets()" );
@@ -1242,21 +1269,21 @@ wchar_t *wxFgets(wchar_t *s, int size, FILE *stream)
 // wxScanf() and friends
 // ----------------------------------------------------------------------------
 
-#ifndef __VISUALC__
+#ifdef HAVE_VSSCANF // __VISUALC__ and __DMC__ see wx/crt.h
 int wxVsscanf(const char *str, const char *format, va_list ap)
     { return wxCRT_VsscanfA(str, format, ap); }
 int wxVsscanf(const wchar_t *str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str, format, ap); }
 int wxVsscanf(const wxCharBuffer& str, const char *format, va_list ap)
-    { return wxCRT_VsscanfA(str, format, ap); }
+    { return wxCRT_VsscanfA(wx_static_cast(const char*, str), format, ap); }
 int wxVsscanf(const wxWCharBuffer& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str, format, ap); }
 int wxVsscanf(const wxString& str, const char *format, va_list ap)
-    { return wxCRT_VsscanfA(str.mb_str(), format, ap); }
+    { return wxCRT_VsscanfA(wx_static_cast(const char*, str.mb_str()), format, ap); }
 int wxVsscanf(const wxString& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str.wc_str(), format, ap); }
 int wxVsscanf(const wxCStrData& str, const char *format, va_list ap)
-    { return wxCRT_VsscanfA(str.AsCharBuf(), format, ap); }
+    { return wxCRT_VsscanfA(wx_static_cast(const char*, str.AsCharBuf()), format, ap); }
 int wxVsscanf(const wxCStrData& str, const wchar_t *format, va_list ap)
     { return wxCRT_VsscanfW(str.AsWCharBuf(), format, ap); }
-#endif // !__VISUALC__
+#endif // HAVE_NO_VSSCANF