do platform-specific checks after ensuring that the symbols we use are defined; extra...

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

diff --git a/include/wx/wxcrt.h b/include/wx/wxcrt.h
index 6d4abb3dbe9d47e87ac28a63b72623943e39dba8..0083ee158598cd98f8aaee34c82e9934b7cb621e 100644 (file)
--- a/include/wx/wxcrt.h
+++ b/include/wx/wxcrt.h
@@ -2,7 +2,7 @@
 // Name:        wx/wxcrt.h
 // Purpose:     Type-safe ANSI and Unicode builds compatible wrappers for
 //              CRT functions
 // Name:        wx/wxcrt.h
 // Purpose:     Type-safe ANSI and Unicode builds compatible wrappers for
 //              CRT functions

-// Author:      Joel Farley, Ove Kåven
+// Author:      Joel Farley, Ove K�ven

 // Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee, Vaclav Slavik
 // Created:     1998/06/12
 // RCS-ID:      $Id$
 // Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee, Vaclav Slavik
 // Created:     1998/06/12
 // RCS-ID:      $Id$


@@ -414,18 +414,37 @@ inline int wxStricmp_String(const wxString& s1, const T& s2)
     { return s1.CmpNoCase(s2); }
 WX_STRCMP_FUNC(wxStricmp, wxCRT_StricmpA, wxCRT_StricmpW, wxStricmp_String)
 
     { return s1.CmpNoCase(s2); }
 WX_STRCMP_FUNC(wxStricmp, wxCRT_StricmpA, wxCRT_StricmpW, wxStricmp_String)
 

+
+// GCC 3.3 and other compilers have a bug that causes it to fail compilation if
+// the template's implementation uses overloaded function declared later (see
+// the wxStrcoll() call in wxStrcoll_String<T>()), so we have to
+// forward-declare the template and implement it below WX_STRCMP_FUNC. OTOH,
+// this fails to compile with VC6, so don't do it for VC.
+#if !defined(__VISUALC__)
+template<typename T>
+inline int wxStrcoll_String(const wxString& s1, const T& s2);
+WX_STRCMP_FUNC(wxStrcoll, wxCRT_StrcollA, wxCRT_StrcollW, wxStrcoll_String)
+#endif // !__VISUALC__
+

 template<typename T>
 inline int wxStrcoll_String(const wxString& s1, const T& s2)
 {
 #if wxUSE_UNICODE
     // NB: strcoll() doesn't work correctly on UTF-8 strings, so we have to use
 template<typename T>
 inline int wxStrcoll_String(const wxString& s1, const T& s2)
 {
 #if wxUSE_UNICODE
     // NB: strcoll() doesn't work correctly on UTF-8 strings, so we have to use

-    //     wc_str() even if wxUSE_UNICODE_UTF8:
-    return wxStrcoll(s1.wc_str(), s2);
+    //     wc_str() even if wxUSE_UNICODE_UTF8; the (const wchar_t*) cast is
+    //     there just as optimization to avoid going through
+    //     wxStrcoll<wxWCharBuffer>:
+    return wxStrcoll((const wchar_t*)s1.wc_str(), s2);

 #else
 #else

-    return wxStrcoll(s1.mb_str(), s2);
+    return wxStrcoll((const char*)s1.mb_str(), s2);

 #endif
 }
 #endif
 }

+
+#if defined(__VISUALC__)
+// this is exactly the same WX_STRCMP_FUNC line as above wxStrcoll_String<>

 WX_STRCMP_FUNC(wxStrcoll, wxCRT_StrcollA, wxCRT_StrcollW, wxStrcoll_String)
 WX_STRCMP_FUNC(wxStrcoll, wxCRT_StrcollA, wxCRT_StrcollW, wxStrcoll_String)

+#endif
+

 
 template<typename T>
 inline int wxStrspn_String(const wxString& s1, const T& s2)
 
 template<typename T>
 inline int wxStrspn_String(const wxString& s1, const T& s2)


@@ -530,43 +549,114 @@ inline const char *wxStrrchr(const char *s, char c)
     { return wxCRT_StrrchrA(s, c); }
 inline const wchar_t *wxStrrchr(const wchar_t *s, wchar_t c)
     { return wxCRT_StrrchrW(s, c); }
     { return wxCRT_StrrchrA(s, c); }
 inline const wchar_t *wxStrrchr(const wchar_t *s, wchar_t c)
     { return wxCRT_StrrchrW(s, c); }

+inline const char *wxStrchr(const char *s, const wxUniChar& c)
+    { return wxCRT_StrchrA(s, (char)c); }
+inline const wchar_t *wxStrchr(const wchar_t *s, const wxUniChar& c)
+    { return wxCRT_StrchrW(s, (wchar_t)c); }
+inline const char *wxStrrchr(const char *s, const wxUniChar& c)
+    { return wxCRT_StrrchrA(s, (char)c); }
+inline const wchar_t *wxStrrchr(const wchar_t *s, const wxUniChar& c)
+    { return wxCRT_StrrchrW(s, (wchar_t)c); }
+inline const char *wxStrchr(const char *s, const wxUniCharRef& c)
+    { return wxCRT_StrchrA(s, (char)c); }
+inline const wchar_t *wxStrchr(const wchar_t *s, const wxUniCharRef& c)
+    { return wxCRT_StrchrW(s, (wchar_t)c); }
+inline const char *wxStrrchr(const char *s, const wxUniCharRef& c)
+    { return wxCRT_StrrchrA(s, (char)c); }
+inline const wchar_t *wxStrrchr(const wchar_t *s, const wxUniCharRef& c)
+    { return wxCRT_StrrchrW(s, (wchar_t)c); }

 template<typename T>
 inline const T* wxStrchr(const wxCharTypeBuffer<T>& s, T c)
     { return wxStrchr(s.data(), c); }
 template<typename T>
 inline const T* wxStrrchr(const wxCharTypeBuffer<T>& s, T c)
     { return wxStrrchr(s.data(), c); }
 template<typename T>
 inline const T* wxStrchr(const wxCharTypeBuffer<T>& s, T c)
     { return wxStrchr(s.data(), c); }
 template<typename T>
 inline const T* wxStrrchr(const wxCharTypeBuffer<T>& s, T c)
     { return wxStrrchr(s.data(), c); }

+template<typename T>
+inline const T* wxStrchr(const wxCharTypeBuffer<T>& s, const wxUniChar& c)
+    { return wxStrchr(s.data(), (T)c); }
+template<typename T>
+inline const T* wxStrrchr(const wxCharTypeBuffer<T>& s, const wxUniChar& c)
+    { return wxStrrchr(s.data(), (T)c); }
+template<typename T>
+inline const T* wxStrchr(const wxCharTypeBuffer<T>& s, const wxUniCharRef& c)
+    { return wxStrchr(s.data(), (T)c); }
+template<typename T>
+inline const T* wxStrrchr(const wxCharTypeBuffer<T>& s, const wxUniCharRef& c)
+    { return wxStrrchr(s.data(), (T)c); }

 // these functions return char* pointer into the non-temporary conversion buffer
 // used by c_str()'s implicit conversion to char*, for ANSI build compatibility
 inline const char* wxStrchr(const wxString& s, char c)
     { return wxCRT_StrchrA((const char*)s.c_str(), c); }
 inline const char* wxStrrchr(const wxString& s, char c)
     { return wxCRT_StrrchrA((const char*)s.c_str(), c); }
 // these functions return char* pointer into the non-temporary conversion buffer
 // used by c_str()'s implicit conversion to char*, for ANSI build compatibility
 inline const char* wxStrchr(const wxString& s, char c)
     { return wxCRT_StrchrA((const char*)s.c_str(), c); }
 inline const char* wxStrrchr(const wxString& s, char c)
     { return wxCRT_StrrchrA((const char*)s.c_str(), c); }

+inline const char* wxStrchr(const wxString& s, int c)
+    { return wxCRT_StrchrA((const char*)s.c_str(), c); }
+inline const char* wxStrrchr(const wxString& s, int c)
+    { return wxCRT_StrrchrA((const char*)s.c_str(), c); }
+inline const char* wxStrchr(const wxString& s, const wxUniChar& c)
+    { return wxCRT_StrchrA((const char*)s.c_str(), (char)c); }
+inline const char* wxStrrchr(const wxString& s, const wxUniChar& c)
+    { return wxCRT_StrrchrA((const char*)s.c_str(), (char)c); }
+inline const char* wxStrchr(const wxString& s, const wxUniCharRef& c)
+    { return wxCRT_StrchrA((const char*)s.c_str(), (char)c); }
+inline const char* wxStrrchr(const wxString& s, const wxUniCharRef& c)
+    { return wxCRT_StrrchrA((const char*)s.c_str(), (char)c); }
+inline const wchar_t* wxStrchr(const wxString& s, wchar_t c)
+    { return wxCRT_StrchrW((const wchar_t*)s.c_str(), c); }
+inline const wchar_t* wxStrrchr(const wxString& s, wchar_t c)
+    { return wxCRT_StrrchrW((const wchar_t*)s.c_str(), c); }

 inline const char* wxStrchr(const wxCStrData& s, char c)
 inline const char* wxStrchr(const wxCStrData& s, char c)

-    { return wxCRT_StrchrA((const char*)s.AsCharBuf(), c); }
+    { return wxCRT_StrchrA(s.AsChar(), c); }

 inline const char* wxStrrchr(const wxCStrData& s, char c)
 inline const char* wxStrrchr(const wxCStrData& s, char c)

-    { return wxCRT_StrrchrA((const char*)s.AsCharBuf(), c); }
+    { return wxCRT_StrrchrA(s.AsChar(), c); }
+inline const char* wxStrchr(const wxCStrData& s, int c)
+    { return wxCRT_StrchrA(s.AsChar(), c); }
+inline const char* wxStrrchr(const wxCStrData& s, int c)
+    { return wxCRT_StrrchrA(s.AsChar(), c); }
+inline const char* wxStrchr(const wxCStrData& s, const wxUniChar& c)
+    { return wxCRT_StrchrA(s.AsChar(), (char)c); }
+inline const char* wxStrrchr(const wxCStrData& s, const wxUniChar& c)
+    { return wxCRT_StrrchrA(s.AsChar(), (char)c); }
+inline const char* wxStrchr(const wxCStrData& s, const wxUniCharRef& c)
+    { return wxCRT_StrchrA(s.AsChar(), (char)c); }
+inline const char* wxStrrchr(const wxCStrData& s, const wxUniCharRef& c)
+    { return wxCRT_StrrchrA(s.AsChar(), (char)c); }
+inline const wchar_t* wxStrchr(const wxCStrData& s, wchar_t c)
+    { return wxCRT_StrchrW(s.AsWChar(), c); }
+inline const wchar_t* wxStrrchr(const wxCStrData& s, wchar_t c)
+    { return wxCRT_StrrchrW(s.AsWChar(), c); }

 
 inline const char *wxStrpbrk(const char *s, const char *accept)
     { return wxCRT_StrpbrkA(s, accept); }
 inline const wchar_t *wxStrpbrk(const wchar_t *s, const wchar_t *accept)
     { return wxCRT_StrpbrkW(s, accept); }
 
 inline const char *wxStrpbrk(const char *s, const char *accept)
     { return wxCRT_StrpbrkA(s, accept); }
 inline const wchar_t *wxStrpbrk(const wchar_t *s, const wchar_t *accept)
     { return wxCRT_StrpbrkW(s, accept); }

-inline const char *wxStrpbrk(const char *s, const wxCharBuffer& accept)
-    { return wxCRT_StrpbrkA(s, accept.data()); }

 inline const char *wxStrpbrk(const char *s, const wxString& accept)
     { return wxCRT_StrpbrkA(s, accept.mb_str()); }
 inline const char *wxStrpbrk(const char *s, const wxCStrData& accept)
     { return wxCRT_StrpbrkA(s, accept.AsCharBuf()); }
 inline const char *wxStrpbrk(const char *s, const wxString& accept)
     { return wxCRT_StrpbrkA(s, accept.mb_str()); }
 inline const char *wxStrpbrk(const char *s, const wxCStrData& accept)
     { return wxCRT_StrpbrkA(s, accept.AsCharBuf()); }

-inline const wchar_t *wxStrpbrk(const wchar_t *s, const wxWCharBuffer& accept)
-    { return wxCRT_StrpbrkW(s, accept.data()); }

 inline const wchar_t *wxStrpbrk(const wchar_t *s, const wxString& accept)
     { return wxCRT_StrpbrkW(s, accept.wc_str()); }
 inline const wchar_t *wxStrpbrk(const wchar_t *s, const wxCStrData& accept)
     { return wxCRT_StrpbrkW(s, accept.AsWCharBuf()); }
 inline const char *wxStrpbrk(const wxString& s, const wxString& accept)
     { return wxCRT_StrpbrkA(s.c_str(), accept.mb_str()); }
 inline const wchar_t *wxStrpbrk(const wchar_t *s, const wxString& accept)
     { return wxCRT_StrpbrkW(s, accept.wc_str()); }
 inline const wchar_t *wxStrpbrk(const wchar_t *s, const wxCStrData& accept)
     { return wxCRT_StrpbrkW(s, accept.AsWCharBuf()); }
 inline const char *wxStrpbrk(const wxString& s, const wxString& accept)
     { return wxCRT_StrpbrkA(s.c_str(), accept.mb_str()); }

+inline const char *wxStrpbrk(const wxString& s, const char *accept)
+    { return wxCRT_StrpbrkA(s.c_str(), accept); }
+inline const wchar_t *wxStrpbrk(const wxString& s, const wchar_t *accept)
+    { return wxCRT_StrpbrkW(s.wc_str(), accept); }
+inline const char *wxStrpbrk(const wxString& s, const wxCStrData& accept)
+    { return wxCRT_StrpbrkA(s.c_str(), accept.AsCharBuf()); }

 inline const char *wxStrpbrk(const wxCStrData& s, const wxString& accept)
     { return wxCRT_StrpbrkA(s.AsChar(), accept.mb_str()); }
 inline const char *wxStrpbrk(const wxCStrData& s, const wxString& accept)
     { return wxCRT_StrpbrkA(s.AsChar(), accept.mb_str()); }

+inline const char *wxStrpbrk(const wxCStrData& s, const char *accept)
+    { return wxCRT_StrpbrkA(s.AsChar(), accept); }
+inline const wchar_t *wxStrpbrk(const wxCStrData& s, const wchar_t *accept)
+    { return wxCRT_StrpbrkW(s.AsWChar(), accept); }
+inline const char *wxStrpbrk(const wxCStrData& s, const wxCStrData& accept)
+    { return wxCRT_StrpbrkA(s.AsChar(), accept.AsCharBuf()); }
+template <typename S, typename T>
+inline const T *wxStrpbrk(const S& s, const wxCharTypeBuffer<T>& accept)
+    { return wxStrpbrk(s, accept.data()); }

 
 
 /* inlined non-const versions */
 
 
 /* inlined non-const versions */


@@ -613,13 +703,6 @@ inline int wxRemove(const wxString& path)
 inline int wxRename(const wxString& oldpath, const wxString& newpath)
     { return wxCRT_Rename(oldpath.fn_str(), newpath.fn_str()); }
 
 inline int wxRename(const wxString& oldpath, const wxString& newpath)
     { return wxCRT_Rename(oldpath.fn_str(), newpath.fn_str()); }
 

-// NB: we don't provide wxString/wxCStrData versions of wxTmpnam, because 's'
-//     is writable
-inline char *wxTmpnam(char *s)
-    { return wxCRT_TmpnamA(s); }
-inline wchar_t *wxTmpnam(wchar_t *s)
-    { return wxCRT_TmpnamW(s); }
-

 extern WXDLLIMPEXP_BASE int wxPuts(const wxString& s);
 extern WXDLLIMPEXP_BASE int wxFputs(const wxString& s, FILE *stream);
 extern WXDLLIMPEXP_BASE void wxPerror(const wxString& s);
 extern WXDLLIMPEXP_BASE int wxPuts(const wxString& s);
 extern WXDLLIMPEXP_BASE int wxFputs(const wxString& s, FILE *stream);
 extern WXDLLIMPEXP_BASE void wxPerror(const wxString& s);


@@ -688,11 +771,24 @@ inline double wxStrtod(const wxCharTypeBuffer<T>& nptr, T **endptr)
 // to be ever used, but it still has to compile).
 template<typename T> struct wxStrtoxCharType {};
 template<> struct wxStrtoxCharType<char**>
 // to be ever used, but it still has to compile).
 template<typename T> struct wxStrtoxCharType {};
 template<> struct wxStrtoxCharType<char**>

-    { typedef const char* Type; };
+{
+    typedef const char* Type;
+    static char** AsPointer(char **p) { return p; }
+};

 template<> struct wxStrtoxCharType<wchar_t**>
 template<> struct wxStrtoxCharType<wchar_t**>

-    { typedef const wchar_t* Type; };
+{
+    typedef const wchar_t* Type;
+    static wchar_t** AsPointer(wchar_t **p) { return p; }
+};

 template<> struct wxStrtoxCharType<int>
 template<> struct wxStrtoxCharType<int>

-    { typedef const char* Type; /* this one is never used */ };
+{
+    typedef const char* Type; /* this one is never used */
+    static char** AsPointer(int WXUNUSED_UNLESS_DEBUG(p))
+    {
+        wxASSERT_MSG( p == 0, "passing non-NULL int is invalid" );
+        return NULL;
+    }
+};

 
 template<typename T>
 inline double wxStrtod(const wxString& nptr, T endptr)
 
 template<typename T>
 inline double wxStrtod(const wxString& nptr, T endptr)


@@ -709,7 +805,9 @@ inline double wxStrtod(const wxString& nptr, T endptr)
         // note that it is important to use c_str() here and not mb_str() or
         // wc_str(), because we store the pointer into (possibly converted)
         // buffer in endptr and so it must be valid even when wxStrtod() returns
         // note that it is important to use c_str() here and not mb_str() or
         // wc_str(), because we store the pointer into (possibly converted)
         // buffer in endptr and so it must be valid even when wxStrtod() returns

-        return wxStrtod((typename wxStrtoxCharType<T>::Type)nptr.c_str(), endptr);
+        typedef typename wxStrtoxCharType<T>::Type CharType;
+        return wxStrtod((CharType)nptr.c_str(),
+                        wxStrtoxCharType<T>::AsPointer(endptr));

     }
 }
 template<typename T>
     }
 }
 template<typename T>


@@ -732,8 +830,12 @@ inline double wxStrtod(const wxCStrData& nptr, T endptr)
         if ( endptr == 0 )                                                    \
             return name(nptr.wx_str(), (wxStringCharType**)NULL, base);       \
         else                                                                  \
         if ( endptr == 0 )                                                    \
             return name(nptr.wx_str(), (wxStringCharType**)NULL, base);       \
         else                                                                  \

-            return name((typename wxStrtoxCharType<T>::Type)nptr.c_str(),     \
-                        endptr, base);                                        \
+        {                                                                     \
+            typedef typename wxStrtoxCharType<T>::Type CharType;              \
+            return name((CharType)nptr.c_str(),                               \
+                        wxStrtoxCharType<T>::AsPointer(endptr),               \
+                        base);                                                \
+        }                                                                     \

     }                                                                         \
     template<typename T>                                                      \
     inline rettype name(const wxCStrData& nptr, T endptr, int base)           \
     }                                                                         \
     template<typename T>                                                      \
     inline rettype name(const wxCStrData& nptr, T endptr, int base)           \


@@ -741,8 +843,10 @@ inline double wxStrtod(const wxCStrData& nptr, T endptr)
 
 WX_STRTOX_FUNC(long, wxStrtol, wxCRT_StrtolA, wxCRT_StrtolW)
 WX_STRTOX_FUNC(unsigned long, wxStrtoul, wxCRT_StrtoulA, wxCRT_StrtoulW)
 
 WX_STRTOX_FUNC(long, wxStrtol, wxCRT_StrtolA, wxCRT_StrtolW)
 WX_STRTOX_FUNC(unsigned long, wxStrtoul, wxCRT_StrtoulA, wxCRT_StrtoulW)

+#ifdef wxLongLong_t

 WX_STRTOX_FUNC(wxLongLong_t, wxStrtoll, wxCRT_StrtollA, wxCRT_StrtollW)
 WX_STRTOX_FUNC(wxULongLong_t, wxStrtoull, wxCRT_StrtoullA, wxCRT_StrtoullW)
 WX_STRTOX_FUNC(wxLongLong_t, wxStrtoll, wxCRT_StrtollA, wxCRT_StrtollW)
 WX_STRTOX_FUNC(wxULongLong_t, wxStrtoull, wxCRT_StrtoullA, wxCRT_StrtoullW)

+#endif // wxLongLong_t

 
 #undef WX_STRTOX_FUNC
 
 
 #undef WX_STRTOX_FUNC
 


@@ -790,21 +894,20 @@ inline size_t wxStrftime(wchar_t *s, size_t max,
 
 // FIXME-UTF8: we'd be better off implementing these ourselves, as the CRT
 //             version is locale-dependent
 
 // FIXME-UTF8: we'd be better off implementing these ourselves, as the CRT
 //             version is locale-dependent

-// FIXME-UTF8: should we return bool from these instead of int?

 // FIXME-UTF8: these don't work when EOF is passed in because of wxUniChar,
 //             is this OK or not?
 
 // FIXME-UTF8: these don't work when EOF is passed in because of wxUniChar,
 //             is this OK or not?
 

-inline int wxIsalnum(const wxUniChar& c)  { return wxCRT_IsalnumW(c); }
-inline int wxIsalpha(const wxUniChar& c)  { return wxCRT_IsalphaW(c); }
-inline int wxIscntrl(const wxUniChar& c)  { return wxCRT_IscntrlW(c); }
-inline int wxIsdigit(const wxUniChar& c)  { return wxCRT_IsdigitW(c); }
-inline int wxIsgraph(const wxUniChar& c)  { return wxCRT_IsgraphW(c); }
-inline int wxIslower(const wxUniChar& c)  { return wxCRT_IslowerW(c); }
-inline int wxIsprint(const wxUniChar& c)  { return wxCRT_IsprintW(c); }
-inline int wxIspunct(const wxUniChar& c)  { return wxCRT_IspunctW(c); }
-inline int wxIsspace(const wxUniChar& c)  { return wxCRT_IsspaceW(c); }
-inline int wxIsupper(const wxUniChar& c)  { return wxCRT_IsupperW(c); }
-inline int wxIsxdigit(const wxUniChar& c) { return wxCRT_IsxdigitW(c); }
+inline bool wxIsalnum(const wxUniChar& c)  { return wxCRT_IsalnumW(c) != 0; }
+inline bool wxIsalpha(const wxUniChar& c)  { return wxCRT_IsalphaW(c) != 0; }
+inline bool wxIscntrl(const wxUniChar& c)  { return wxCRT_IscntrlW(c) != 0; }
+inline bool wxIsdigit(const wxUniChar& c)  { return wxCRT_IsdigitW(c) != 0; }
+inline bool wxIsgraph(const wxUniChar& c)  { return wxCRT_IsgraphW(c) != 0; }
+inline bool wxIslower(const wxUniChar& c)  { return wxCRT_IslowerW(c) != 0; }
+inline bool wxIsprint(const wxUniChar& c)  { return wxCRT_IsprintW(c) != 0; }
+inline bool wxIspunct(const wxUniChar& c)  { return wxCRT_IspunctW(c) != 0; }
+inline bool wxIsspace(const wxUniChar& c)  { return wxCRT_IsspaceW(c) != 0; }
+inline bool wxIsupper(const wxUniChar& c)  { return wxCRT_IsupperW(c) != 0; }
+inline bool wxIsxdigit(const wxUniChar& c) { return wxCRT_IsxdigitW(c) != 0; }

 
 inline wxUniChar wxTolower(const wxUniChar& c) { return wxCRT_TolowerW(c); }
 inline wxUniChar wxToupper(const wxUniChar& c) { return wxCRT_ToupperW(c); }
 
 inline wxUniChar wxTolower(const wxUniChar& c) { return wxCRT_TolowerW(c); }
 inline wxUniChar wxToupper(const wxUniChar& c) { return wxCRT_ToupperW(c); }