Add wxNO_UNSAFE_WXSTRING_CONV2 macro

The macro disallows implicit conversions between wxString and const
char*

include/wx/any.h

@@ -504,8 +504,10 @@ extern WXDLLIMPEXP_BASE bool wxAnyConvertString(const wxString& value,
                                                 wxAnyValueBuffer& dst);
 
 WX_ANY_DEFINE_CONVERTIBLE_TYPE_BASE(wxString, wxString, wxAnyConvertString)
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 WX_ANY_DEFINE_CONVERTIBLE_TYPE(const char*, ConstCharPtr,
                                wxAnyConvertString, wxString)
+#endif
 WX_ANY_DEFINE_CONVERTIBLE_TYPE(const wchar_t*, ConstWchar_tPtr,
                                wxAnyConvertString, wxString)
 
@@ -757,11 +759,13 @@ public:
     }
 
     // These two constructors are needed to deal with string literals
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     wxAny(const char* value)
     {
         m_type = wxAnyValueTypeImpl<const char*>::sm_instance.get();
         wxAnyValueTypeImpl<const char*>::SetValue(value, m_buffer);
     }
+#endif
     wxAny(const wchar_t* value)
     {
         m_type = wxAnyValueTypeImpl<const wchar_t*>::sm_instance.get();
@@ -865,11 +869,13 @@ public:
 #endif
 
     // These two operators are needed to deal with string literals
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     wxAny& operator=(const char* value)
     {
         Assign(value);
         return *this;
     }
+#endif
     wxAny& operator=(const wchar_t* value)
     {
         Assign(value);
@@ -888,8 +894,10 @@ public:
         return value == value2;
     }
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     bool operator==(const char* value) const
         { return (*this) == wxString(value); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
     bool operator==(const wchar_t* value) const
         { return (*this) == wxString(value); }
 
@@ -1017,6 +1025,13 @@ public:
 #endif
 
 private:
+#ifdef wxNO_IMPLICIT_WXSTRING_ENCODING
+    wxAny(const char*);  // Disabled
+    wxAny& operator=(const char *&value); // Disabled
+    wxAny& operator=(const char value[]); // Disabled
+    wxAny& operator==(const char *value); // Disabled
+#endif
+
     // Assignment functions
     void AssignAny(const wxAny& any)
     {

include/wx/anystr.h

@@ -65,6 +65,7 @@ public:
     bool operator!() const { return !((bool)*this); }
 
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     // and these are the conversions operator which allow to assign the result
     // of FuncReturningAnyStrPtr() to either char* or wxChar* (i.e. wchar_t*)
     operator const char *() const
@@ -94,6 +95,7 @@ public:
 
         return p;
     }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
     operator const wchar_t *() const
     {

include/wx/artprov.h

@@ -27,8 +27,8 @@ class wxArtProviderModule;
 typedef wxString wxArtClient;
 typedef wxString wxArtID;
 
-#define wxART_MAKE_CLIENT_ID_FROM_STR(id)  ((id) + "_C")
+#define wxART_MAKE_CLIENT_ID_FROM_STR(id)  ((id) + wxASCII_STR("_C"))
-#define wxART_MAKE_CLIENT_ID(id)           (#id "_C")
+#define wxART_MAKE_CLIENT_ID(id)           wxASCII_STR(#id "_C")
 #define wxART_MAKE_ART_ID_FROM_STR(id)     (id)
 #define wxART_MAKE_ART_ID(id)              (#id)
 

include/wx/catch_cppunit.h

@@ -90,7 +90,7 @@ namespace Catch
             {
 #if wxUSE_UNICODE
                 if ( !iswprint(*i) )
-                    s += wxString::Format("\\u%04X", *i).ToStdString();
+                    s += wxString::Format(wxASCII_STR("\\u%04X"), *i).ToAscii();
                 else
 #endif // wxUSE_UNICODE
                     s += *i;
@@ -278,10 +278,10 @@ inline std::string wxGetCurrentTestName()
 // Use this macro to assert with the given formatted message (it should contain
 // the format string and arguments in a separate pair of parentheses)
 #define WX_ASSERT_MESSAGE(msg, cond) \
-    CPPUNIT_ASSERT_MESSAGE(std::string(wxString::Format msg .mb_str()), (cond))
+    CPPUNIT_ASSERT_MESSAGE(std::string(wxString::Format msg .mb_str(wxConvLibc)), (cond))
 
 #define WX_ASSERT_EQUAL_MESSAGE(msg, expected, actual) \
-    CPPUNIT_ASSERT_EQUAL_MESSAGE(std::string(wxString::Format msg .mb_str()), \
+    CPPUNIT_ASSERT_EQUAL_MESSAGE(std::string(wxString::Format msg .mb_str(wxConvLibc)), \
                                  (expected), (actual))
 
 #endif // _WX_CATCH_CPPUNIT_H_

include/wx/colour.h

@@ -20,6 +20,12 @@ class WXDLLIMPEXP_FWD_CORE wxColour;
 //
 // It avoids the need to repeat these lines across all colour.h files, since
 // Set() is a virtual function and thus cannot be called by wxColourBase ctors
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
+#define wxWXCOLOUR_CTOR_FROM_CHAR \
+    wxColour(const char *colourName) { Init(); Set(colourName); }
+#else // wxNO_IMPLICIT_WXSTRING_ENCODING
+#define wxWXCOLOUR_CTOR_FROM_CHAR
+#endif
 #define DEFINE_STD_WXCOLOUR_CONSTRUCTORS                                      \
     wxColour() { Init(); }                                                    \
     wxColour(ChannelType red,                                                 \
@@ -29,7 +35,7 @@ class WXDLLIMPEXP_FWD_CORE wxColour;
         { Init(); Set(red, green, blue, alpha); }                             \
     wxColour(unsigned long colRGB) { Init(); Set(colRGB    ); }               \
     wxColour(const wxString& colourName) { Init(); Set(colourName); }         \
-    wxColour(const char *colourName) { Init(); Set(colourName); }             \
+    wxWXCOLOUR_CTOR_FROM_CHAR                                                 \
     wxColour(const wchar_t *colourName) { Init(); Set(colourName); }
 
 

include/wx/confbase.h

@@ -225,8 +225,10 @@ public:
 
   // we have to provide a separate version for C strings as otherwise the
   // template Read() would be used
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
   wxString Read(const wxString& key, const char* defVal) const
     { return Read(key, wxString(defVal)); }
+#endif
   wxString Read(const wxString& key, const wchar_t* defVal) const
     { return Read(key, wxString(defVal)); }
 
@@ -268,10 +270,12 @@ public:
 
   // we have to provide a separate version for C strings as otherwise they
   // would be converted to bool and not to wxString as expected!
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
   bool Write(const wxString& key, const char *value)
     { return Write(key, wxString(value)); }
   bool Write(const wxString& key, const unsigned char *value)
     { return Write(key, wxString(value)); }
+#endif
   bool Write(const wxString& key, const wchar_t *value)
     { return Write(key, wxString(value)); }
 

include/wx/gtk/dataform.h

@@ -24,7 +24,9 @@ public:
     // we have to provide all the overloads to allow using strings instead of
     // data formats (as a lot of existing code does)
     wxDataFormat( const wxString& id ) { InitFromString(id); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     wxDataFormat( const char *id ) { InitFromString(id); }
+#endif
     wxDataFormat( const wchar_t *id ) { InitFromString(id); }
     wxDataFormat( const wxCStrData& id ) { InitFromString(id); }
 

include/wx/list.h

@@ -338,8 +338,10 @@ public:
         { m_key.integer = i; }
     wxListKey(const wxString& s) : m_keyType(wxKEY_STRING)
         { m_key.string = new wxString(s); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     wxListKey(const char *s) : m_keyType(wxKEY_STRING)
         { m_key.string = new wxString(s); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
     wxListKey(const wchar_t *s) : m_keyType(wxKEY_STRING)
         { m_key.string = new wxString(s); }
 

include/wx/mimetype.h

@@ -138,11 +138,15 @@ public:
     //     Do not use, it's used by the ctor only.
     struct CtorString
     {
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
         CtorString(const char *str) : m_str(str) {}
+#endif
         CtorString(const wchar_t *str) : m_str(str) {}
         CtorString(const wxString& str) : m_str(str) {}
         CtorString(const wxCStrData& str) : m_str(str) {}
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
         CtorString(const wxScopedCharBuffer& str) : m_str(str) {}
+#endif
         CtorString(const wxScopedWCharBuffer& str) : m_str(str) {}
 
         operator const wxString*() const { return &m_str; }

include/wx/msgdlg.h

@@ -45,10 +45,12 @@ public:
         {
         }
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
         ButtonLabel(const char *label)
             : m_label(label), m_stockId(wxID_NONE)
         {
         }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
         ButtonLabel(const wchar_t *label)
             : m_label(label), m_stockId(wxID_NONE)

include/wx/strconv.h

@@ -719,5 +719,19 @@ extern WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvUI;
     #define wxSafeConvertWX2MB(s) (s)
 #endif // Unicode/ANSI
 
+// Macro that indicates the default encoding for converting C strings
+// to wxString. It provides a default value for a const wxMBConv&
+// parameter (i.e. wxConvLibc) unless wxNO_IMPLICIT_WXSTRING_ENCODING
+// is defined.
+//
+// Intended use:
+// wxString(const char *data, ...,
+//          const wxMBConv &conv wxSTRING_DEFAULT_CONV_ARG);
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
+#define wxSTRING_DEFAULT_CONV_ARG = wxConvLibc
+#else
+#define wxSTRING_DEFAULT_CONV_ARG
+#endif
+
 #endif // _WX_STRCONV_H_
 

include/wx/strvararg.h

@@ -133,16 +133,20 @@ class WXDLLIMPEXP_FWD_BASE wxString;
 class WXDLLIMPEXP_BASE wxFormatString
 {
 public:
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     wxFormatString(const char *str)
         : m_char(wxScopedCharBuffer::CreateNonOwned(str)), m_str(NULL), m_cstr(NULL) {}
+#endif
     wxFormatString(const wchar_t *str)
         : m_wchar(wxScopedWCharBuffer::CreateNonOwned(str)), m_str(NULL), m_cstr(NULL) {}
     wxFormatString(const wxString& str)
         : m_str(&str), m_cstr(NULL) {}
     wxFormatString(const wxCStrData& str)
         : m_str(NULL), m_cstr(&str) {}
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     wxFormatString(const wxScopedCharBuffer& str)
         : m_char(str), m_str(NULL), m_cstr(NULL)  {}
+#endif
     wxFormatString(const wxScopedWCharBuffer& str)
         : m_wchar(str), m_str(NULL), m_cstr(NULL) {}
 
@@ -201,7 +205,7 @@ public:
     // to other InputAsXXX() methods
     wxString InputAsString() const;
 
-#if !wxUSE_UNICODE_WCHAR
+#if !wxUSE_UNICODE_WCHAR && !defined wxNO_IMPLICIT_WXSTRING_ENCODING
     operator const char*() const
         { return const_cast<wxFormatString*>(this)->AsChar(); }
 private:
@@ -212,7 +216,7 @@ private:
     const char* InputAsChar();
     const char* AsChar();
     wxScopedCharBuffer m_convertedChar;
-#endif // !wxUSE_UNICODE_WCHAR
+#endif // !wxUSE_UNICODE_WCHAR && !defined wx_NO_IMPLICIT_WXSTRING_ENCODING
 
 #if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
 public:
@@ -284,7 +288,12 @@ struct wxFormatStringArgumentFinder<wxString>
 
 template<>
 struct wxFormatStringArgumentFinder<wxScopedCharBuffer>
-    : public wxFormatStringArgumentFinder<const wxScopedCharBuffer&> {};
+    : public wxFormatStringArgumentFinder<const wxScopedCharBuffer&> {
+#ifdef wxNO_IMPLICIT_WXSTRING_ENCODING
+private:
+    wxFormatStringArgumentFinder<wxScopedCharBuffer>(); // Disabled
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
+};
 
 template<>
 struct wxFormatStringArgumentFinder<wxScopedWCharBuffer>
@@ -292,7 +301,12 @@ struct wxFormatStringArgumentFinder<wxScopedWCharBuffer>
 
 template<>
 struct wxFormatStringArgumentFinder<wxCharBuffer>
-    : public wxFormatStringArgumentFinder<const wxCharBuffer&> {};
+    : public wxFormatStringArgumentFinder<const wxCharBuffer&> {
+#ifdef wxNO_IMPLICIT_WXSTRING_ENCODING
+private:
+    wxFormatStringArgumentFinder<wxCharBuffer>(); // Disabled
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
+};
 
 template<>
 struct wxFormatStringArgumentFinder<wxWCharBuffer>
@@ -387,6 +401,13 @@ struct wxFormatStringSpecifier<const T*>
         enum { value = arg };                                               \
     };
 
+#define wxDISABLED_FORMAT_STRING_SPECIFIER(T)                               \
+    template<> struct wxFormatStringSpecifier<T>                            \
+    {                                                                       \
+    private:                                                                \
+        wxFormatStringSpecifier<T>(); /* Disabled */                        \
+    };
+
 wxFORMAT_STRING_SPECIFIER(bool, wxFormatString::Arg_Int)
 wxFORMAT_STRING_SPECIFIER(int, wxFormatString::Arg_Int)
 wxFORMAT_STRING_SPECIFIER(unsigned int, wxFormatString::Arg_Int)
@@ -406,18 +427,27 @@ wxFORMAT_STRING_SPECIFIER(long double, wxFormatString::Arg_LongDouble)
 wxFORMAT_STRING_SPECIFIER(wchar_t, wxFormatString::Arg_Char | wxFormatString::Arg_Int)
 #endif
 
-#if !wxUSE_UNICODE
+#if !wxUSE_UNICODE && !defined wxNO_IMPLICIT_WXSTRING_ENCODING
 wxFORMAT_STRING_SPECIFIER(char, wxFormatString::Arg_Char | wxFormatString::Arg_Int)
 wxFORMAT_STRING_SPECIFIER(signed char, wxFormatString::Arg_Char | wxFormatString::Arg_Int)
 wxFORMAT_STRING_SPECIFIER(unsigned char, wxFormatString::Arg_Char | wxFormatString::Arg_Int)
 #endif
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 wxFORMAT_STRING_SPECIFIER(char*, wxFormatString::Arg_String)
 wxFORMAT_STRING_SPECIFIER(unsigned char*, wxFormatString::Arg_String)
 wxFORMAT_STRING_SPECIFIER(signed char*, wxFormatString::Arg_String)
 wxFORMAT_STRING_SPECIFIER(const char*, wxFormatString::Arg_String)
 wxFORMAT_STRING_SPECIFIER(const unsigned char*, wxFormatString::Arg_String)
 wxFORMAT_STRING_SPECIFIER(const signed char*, wxFormatString::Arg_String)
+#else // wxNO_IMPLICIT_WXSTRING_ENCODING
+wxDISABLED_FORMAT_STRING_SPECIFIER(char*)
+wxDISABLED_FORMAT_STRING_SPECIFIER(unsigned char*)
+wxDISABLED_FORMAT_STRING_SPECIFIER(signed char*)
+wxDISABLED_FORMAT_STRING_SPECIFIER(const char*)
+wxDISABLED_FORMAT_STRING_SPECIFIER(const unsigned char*)
+wxDISABLED_FORMAT_STRING_SPECIFIER(const signed char*)
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 wxFORMAT_STRING_SPECIFIER(wchar_t*, wxFormatString::Arg_String)
 wxFORMAT_STRING_SPECIFIER(const wchar_t*, wxFormatString::Arg_String)
 
@@ -430,6 +460,7 @@ wxFORMAT_STRING_SPECIFIER(std::nullptr_t, wxFormatString::Arg_Pointer)
 #endif
 
 #undef wxFORMAT_STRING_SPECIFIER
+#undef wxDISABLED_FORMAT_STRING_SPECIFIER
 
 
 // Converts an argument passed to wxPrint etc. into standard form expected,
@@ -571,6 +602,7 @@ struct WXDLLIMPEXP_BASE wxArgNormalizerWchar<const wxCStrData&>
 // char* for wchar_t Unicode build or UTF8):
 #if wxUSE_UNICODE_WCHAR
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 template<>
 struct wxArgNormalizerWchar<const char*>
     : public wxArgNormalizerWithBuffer<wchar_t>
@@ -579,6 +611,7 @@ struct wxArgNormalizerWchar<const char*>
                          const wxFormatString *fmt, unsigned index)
         : wxArgNormalizerWithBuffer<wchar_t>(wxConvLibc.cMB2WC(s), fmt, index) {}
 };
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 #elif wxUSE_UNICODE_UTF8
 
@@ -591,6 +624,7 @@ struct wxArgNormalizerUtf8<const wchar_t*>
         : wxArgNormalizerWithBuffer<char>(wxConvUTF8.cWC2MB(s), fmt, index) {}
 };
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 template<>
 struct wxArgNormalizerUtf8<const char*>
     : public wxArgNormalizerWithBuffer<char>
@@ -616,9 +650,10 @@ struct wxArgNormalizerUtf8<const char*>
         }
     }
 };
+#endif
 
 // UTF-8 build needs conversion to wchar_t* too:
-#if !wxUSE_UTF8_LOCALE_ONLY
+#if !wxUSE_UTF8_LOCALE_ONLY && !defined wxNO_IMPLICIT_WXSTRING_ENCODING
 template<>
 struct wxArgNormalizerWchar<const char*>
     : public wxArgNormalizerWithBuffer<wchar_t>
@@ -627,10 +662,11 @@ struct wxArgNormalizerWchar<const char*>
                          const wxFormatString *fmt, unsigned index)
         : wxArgNormalizerWithBuffer<wchar_t>(wxConvLibc.cMB2WC(s), fmt, index) {}
 };
-#endif // !wxUSE_UTF8_LOCALE_ONLY
+#endif // !wxUSE_UTF8_LOCALE_ONLY && !defined wxNO_IMPLICIT_WXSTRING_ENCODING
 
 #else // ANSI - FIXME-UTF8
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 template<>
 struct wxArgNormalizerWchar<const wchar_t*>
     : public wxArgNormalizerWithBuffer<char>
@@ -639,10 +675,56 @@ struct wxArgNormalizerWchar<const wchar_t*>
                          const wxFormatString *fmt, unsigned index)
         : wxArgNormalizerWithBuffer<char>(wxConvLibc.cWC2MB(s), fmt, index) {}
 };
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 #endif // wxUSE_UNICODE_WCHAR/wxUSE_UNICODE_UTF8/ANSI
 
 
+#ifdef wxNO_IMPLICIT_WXSTRING_ENCODING
+// wxArgNormalizer specializations that cannot be instanced
+template<>
+struct wxArgNormalizer<const char*> {
+private:
+    wxArgNormalizer<const char*>(const char*, const wxFormatString *,
+                                 unsigned);
+    const char *get() const;
+};
+template<>
+struct wxArgNormalizer<char*> {
+private:
+    wxArgNormalizer<char*>(const char*, const wxFormatString *, unsigned);
+    char *get() const;
+};
+template<>
+struct wxArgNormalizer<const std::string> {
+private:
+    wxArgNormalizer<const std::string>(const std::string&,
+                                        const wxFormatString *, unsigned);
+    std::string get() const;
+};
+template<>
+struct wxArgNormalizer<std::string> {
+private:
+    wxArgNormalizer<std::string>(std::string&,
+                                 const wxFormatString *, unsigned);
+    std::string get() const;
+};
+template<>
+struct wxArgNormalizer<wxCharBuffer> {
+private:
+    wxArgNormalizer<wxCharBuffer>(wxCharBuffer&,
+                                  const wxFormatString *, unsigned);
+    std::string get() const;
+};
+template<>
+struct wxArgNormalizer<wxScopedCharBuffer> {
+private:
+    wxArgNormalizer<wxScopedCharBuffer>(wxScopedCharBuffer&,
+                                        const wxFormatString *, unsigned);
+    std::string get() const;
+};
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
+
 // this macro is used to implement specialization that are exactly same as
 // some other specialization, i.e. to "forward" the implementation (e.g. for
 // T=wxString and T=const wxString&). Note that the ctor takes BaseT argument,
@@ -675,16 +757,22 @@ WX_ARG_NORMALIZER_FORWARD(wxString, const wxString&);
 WX_ARG_NORMALIZER_FORWARD(wxCStrData, const wxCStrData&);
 
 // versions for passing non-const pointers:
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 WX_ARG_NORMALIZER_FORWARD(char*, const char*);
+#endif
 WX_ARG_NORMALIZER_FORWARD(wchar_t*, const wchar_t*);
 
 // versions for passing wx[W]CharBuffer:
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 WX_ARG_NORMALIZER_FORWARD(wxScopedCharBuffer, const char*);
 WX_ARG_NORMALIZER_FORWARD(const wxScopedCharBuffer&, const char*);
+#endif
 WX_ARG_NORMALIZER_FORWARD(wxScopedWCharBuffer, const wchar_t*);
 WX_ARG_NORMALIZER_FORWARD(const wxScopedWCharBuffer&, const wchar_t*);
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 WX_ARG_NORMALIZER_FORWARD(wxCharBuffer, const char*);
 WX_ARG_NORMALIZER_FORWARD(const wxCharBuffer&, const char*);
+#endif
 WX_ARG_NORMALIZER_FORWARD(wxWCharBuffer, const wchar_t*);
 WX_ARG_NORMALIZER_FORWARD(const wxWCharBuffer&, const wchar_t*);
 
@@ -694,6 +782,7 @@ WX_ARG_NORMALIZER_FORWARD(const wxWCharBuffer&, const wchar_t*);
 #include "wx/stringimpl.h"
 
 #if !wxUSE_UTF8_LOCALE_ONLY
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 template<>
 struct wxArgNormalizerWchar<const std::string&>
     : public wxArgNormalizerWchar<const char*>
@@ -702,6 +791,7 @@ struct wxArgNormalizerWchar<const std::string&>
                          const wxFormatString *fmt, unsigned index)
         : wxArgNormalizerWchar<const char*>(s.c_str(), fmt, index) {}
 };
+#endif // NO_IMPLICIT_WXSTRING_ENCODING
 
 template<>
 struct wxArgNormalizerWchar<const wxStdWideString&>
@@ -714,6 +804,7 @@ struct wxArgNormalizerWchar<const wxStdWideString&>
 #endif // !wxUSE_UTF8_LOCALE_ONLY
 
 #if wxUSE_UNICODE_UTF8
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 template<>
 struct wxArgNormalizerUtf8<const std::string&>
     : public wxArgNormalizerUtf8<const char*>
@@ -722,6 +813,7 @@ struct wxArgNormalizerUtf8<const std::string&>
                         const wxFormatString *fmt, unsigned index)
         : wxArgNormalizerUtf8<const char*>(s.c_str(), fmt, index) {}
 };
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 template<>
 struct wxArgNormalizerUtf8<const wxStdWideString&>
@@ -733,7 +825,9 @@ struct wxArgNormalizerUtf8<const wxStdWideString&>
 };
 #endif // wxUSE_UNICODE_UTF8
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 WX_ARG_NORMALIZER_FORWARD(std::string, const std::string&);
+#endif
 WX_ARG_NORMALIZER_FORWARD(wxStdWideString, const wxStdWideString&);
 
 #endif // wxUSE_STD_STRING

include/wx/variant.h

@@ -216,8 +216,10 @@ public:
     wxVariant& operator=(const wxString& value);
     // these overloads are necessary to prevent the compiler from using bool
     // version instead of wxString one:
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     wxVariant& operator=(const char* value)
         { return *this = wxString(value); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
     wxVariant& operator=(const wchar_t* value)
         { return *this = wxString(value); }
     wxVariant& operator=(const wxCStrData& value)
@@ -230,6 +232,7 @@ public:
     wxString GetString() const;
 
 #if wxUSE_STD_STRING
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
     wxVariant(const std::string& val, const wxString& name = wxEmptyString);
     bool operator==(const std::string& value) const
         { return operator==(wxString(value)); }
@@ -238,6 +241,7 @@ public:
     wxVariant& operator=(const std::string& value)
         { return operator=(wxString(value)); }
     operator std::string() const { return (operator wxString()).ToStdString(); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
     wxVariant(const wxStdWideString& val, const wxString& name = wxEmptyString);
     bool operator==(const wxStdWideString& value) const

include/wx/wxcrt.h

@@ -149,10 +149,12 @@ inline char* wxTmemset(char* szOut, char cIn, size_t len)
 WXDLLIMPEXP_BASE char* wxSetlocale(int category, const char *locale);
 inline char* wxSetlocale(int category, const wxScopedCharBuffer& locale)
     { return wxSetlocale(category, locale.data()); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char* wxSetlocale(int category, const wxString& locale)
     { return wxSetlocale(category, locale.mb_str()); }
 inline char* wxSetlocale(int category, const wxCStrData& locale)
     { return wxSetlocale(category, locale.AsCharBuf()); }
+#endif
 
 // ----------------------------------------------------------------------------
 //                              string functions
@@ -202,17 +204,21 @@ inline size_t wxStrnlen(const wchar_t *str, size_t maxlen)
 // inline wchar_t* wxStrdup(const wchar_t *s) { return wxStrdupW(s); }
 inline char* wxStrdup(const wxScopedCharBuffer& s) { return wxStrdup(s.data()); }
 inline wchar_t* wxStrdup(const wxScopedWCharBuffer& s) { return wxStrdup(s.data()); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char* wxStrdup(const wxString& s) { return wxStrdup(s.mb_str()); }
 inline char* wxStrdup(const wxCStrData& s) { return wxStrdup(s.AsCharBuf()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 inline char *wxStrcpy(char *dest, const char *src)
     { return wxCRT_StrcpyA(dest, src); }
 inline wchar_t *wxStrcpy(wchar_t *dest, const wchar_t *src)
     { return wxCRT_StrcpyW(dest, src); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrcpy(char *dest, const wxString& src)
     { return wxCRT_StrcpyA(dest, src.mb_str()); }
 inline char *wxStrcpy(char *dest, const wxCStrData& src)
     { return wxCRT_StrcpyA(dest, src.AsCharBuf()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrcpy(char *dest, const wxScopedCharBuffer& src)
     { return wxCRT_StrcpyA(dest, src.data()); }
 inline wchar_t *wxStrcpy(wchar_t *dest, const wxString& src)
@@ -221,19 +227,23 @@ inline wchar_t *wxStrcpy(wchar_t *dest, const wxCStrData& src)
     { return wxCRT_StrcpyW(dest, src.AsWCharBuf()); }
 inline wchar_t *wxStrcpy(wchar_t *dest, const wxScopedWCharBuffer& src)
     { return wxCRT_StrcpyW(dest, src.data()); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrcpy(char *dest, const wchar_t *src)
     { return wxCRT_StrcpyA(dest, wxConvLibc.cWC2MB(src)); }
 inline wchar_t *wxStrcpy(wchar_t *dest, const char *src)
     { return wxCRT_StrcpyW(dest, wxConvLibc.cMB2WC(src)); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 inline char *wxStrncpy(char *dest, const char *src, size_t n)
     { return wxCRT_StrncpyA(dest, src, n); }
 inline wchar_t *wxStrncpy(wchar_t *dest, const wchar_t *src, size_t n)
     { return wxCRT_StrncpyW(dest, src, n); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrncpy(char *dest, const wxString& src, size_t n)
     { return wxCRT_StrncpyA(dest, src.mb_str(), n); }
 inline char *wxStrncpy(char *dest, const wxCStrData& src, size_t n)
     { return wxCRT_StrncpyA(dest, src.AsCharBuf(), n); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrncpy(char *dest, const wxScopedCharBuffer& src, size_t n)
     { return wxCRT_StrncpyA(dest, src.data(), n); }
 inline wchar_t *wxStrncpy(wchar_t *dest, const wxString& src, size_t n)
@@ -242,10 +252,12 @@ inline wchar_t *wxStrncpy(wchar_t *dest, const wxCStrData& src, size_t n)
     { return wxCRT_StrncpyW(dest, src.AsWCharBuf(), n); }
 inline wchar_t *wxStrncpy(wchar_t *dest, const wxScopedWCharBuffer& src, size_t n)
     { return wxCRT_StrncpyW(dest, src.data(), n); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrncpy(char *dest, const wchar_t *src, size_t n)
     { return wxCRT_StrncpyA(dest, wxConvLibc.cWC2MB(src), n); }
 inline wchar_t *wxStrncpy(wchar_t *dest, const char *src, size_t n)
     { return wxCRT_StrncpyW(dest, wxConvLibc.cMB2WC(src), n); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 // this is a function new in 2.9 so we don't care about backwards compatibility and
 // so don't need to support wchar_t/char overloads
@@ -281,10 +293,12 @@ inline char *wxStrcat(char *dest, const char *src)
     { return wxCRT_StrcatA(dest, src); }
 inline wchar_t *wxStrcat(wchar_t *dest, const wchar_t *src)
     { return wxCRT_StrcatW(dest, src); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrcat(char *dest, const wxString& src)
     { return wxCRT_StrcatA(dest, src.mb_str()); }
 inline char *wxStrcat(char *dest, const wxCStrData& src)
     { return wxCRT_StrcatA(dest, src.AsCharBuf()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrcat(char *dest, const wxScopedCharBuffer& src)
     { return wxCRT_StrcatA(dest, src.data()); }
 inline wchar_t *wxStrcat(wchar_t *dest, const wxString& src)
@@ -293,19 +307,23 @@ inline wchar_t *wxStrcat(wchar_t *dest, const wxCStrData& src)
     { return wxCRT_StrcatW(dest, src.AsWCharBuf()); }
 inline wchar_t *wxStrcat(wchar_t *dest, const wxScopedWCharBuffer& src)
     { return wxCRT_StrcatW(dest, src.data()); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrcat(char *dest, const wchar_t *src)
     { return wxCRT_StrcatA(dest, wxConvLibc.cWC2MB(src)); }
 inline wchar_t *wxStrcat(wchar_t *dest, const char *src)
     { return wxCRT_StrcatW(dest, wxConvLibc.cMB2WC(src)); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 inline char *wxStrncat(char *dest, const char *src, size_t n)
     { return wxCRT_StrncatA(dest, src, n); }
 inline wchar_t *wxStrncat(wchar_t *dest, const wchar_t *src, size_t n)
     { return wxCRT_StrncatW(dest, src, n); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrncat(char *dest, const wxString& src, size_t n)
     { return wxCRT_StrncatA(dest, src.mb_str(), n); }
 inline char *wxStrncat(char *dest, const wxCStrData& src, size_t n)
     { return wxCRT_StrncatA(dest, src.AsCharBuf(), n); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrncat(char *dest, const wxScopedCharBuffer& src, size_t n)
     { return wxCRT_StrncatA(dest, src.data(), n); }
 inline wchar_t *wxStrncat(wchar_t *dest, const wxString& src, size_t n)
@@ -314,10 +332,12 @@ inline wchar_t *wxStrncat(wchar_t *dest, const wxCStrData& src, size_t n)
     { return wxCRT_StrncatW(dest, src.AsWCharBuf(), n); }
 inline wchar_t *wxStrncat(wchar_t *dest, const wxScopedWCharBuffer& src, size_t n)
     { return wxCRT_StrncatW(dest, src.data(), n); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrncat(char *dest, const wchar_t *src, size_t n)
     { return wxCRT_StrncatA(dest, wxConvLibc.cWC2MB(src), n); }
 inline wchar_t *wxStrncat(wchar_t *dest, const char *src, size_t n)
     { return wxCRT_StrncatW(dest, wxConvLibc.cMB2WC(src), n); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 
 #define WX_STR_DECL(name, T1, T2)  name(T1 s1, T2 s2)
@@ -333,6 +353,7 @@ inline wchar_t *wxStrncat(wchar_t *dest, const char *src, size_t n)
 //   forString - function to call when the *first* argument is wxString;
 //               the second argument can be any string type, so this is
 //               typically a template
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 #define WX_STR_FUNC_NO_INVERT(rettype, name, crtA, crtW, forString)           \
     inline rettype WX_STR_DECL(name, const char *, const char *)              \
         { return WX_STR_CALL(crtA, s1, s2); }                                 \
@@ -395,9 +416,48 @@ inline wchar_t *wxStrncat(wchar_t *dest, const char *src, size_t n)
         { return WX_STR_CALL(forString, s1.AsString(), s2); }                 \
     inline rettype WX_STR_DECL(name, const wxCStrData&, const wxCStrData&)    \
         { return WX_STR_CALL(forString, s1.AsString(), s2); }
+#else // wxNO_IMPLICIT_WXSTRING_ENCODING
+#define WX_STR_FUNC_NO_INVERT(rettype, name, crtA, crtW, forString)           \
+    inline rettype WX_STR_DECL(name, const char *, const char *)              \
+        { return WX_STR_CALL(crtA, s1, s2); }                                 \
+                                                                              \
+    inline rettype WX_STR_DECL(name, const wchar_t *, const wchar_t *)        \
+        { return WX_STR_CALL(crtW, s1, s2); }                                 \
+    inline rettype WX_STR_DECL(name, const wchar_t *, const wxScopedWCharBuffer&)   \
+        { return WX_STR_CALL(crtW, s1, s2.data()); }                          \
+                                                                              \
+    inline rettype WX_STR_DECL(name, const wxScopedCharBuffer&, const char *)       \
+        { return WX_STR_CALL(crtA, s1.data(), s2); }                          \
+    inline rettype WX_STR_DECL(name, const wxScopedCharBuffer&, const wxScopedCharBuffer&)\
+        { return WX_STR_CALL(crtA, s1.data(), s2.data()); }                   \
+                                                                              \
+    inline rettype WX_STR_DECL(name, const wxScopedWCharBuffer&, const wchar_t *)   \
+        { return WX_STR_CALL(crtW, s1.data(), s2); }                          \
+    inline rettype WX_STR_DECL(name, const wxScopedWCharBuffer&, const wxScopedWCharBuffer&)  \
+        { return WX_STR_CALL(crtW, s1.data(), s2.data()); }                   \
+                                                                              \
+    inline rettype WX_STR_DECL(name, const wxString&, const wchar_t*)         \
+        { return WX_STR_CALL(forString, s1, s2); }                            \
+    inline rettype WX_STR_DECL(name, const wxString&, const wxScopedWCharBuffer&)   \
+        { return WX_STR_CALL(forString, s1, s2); }                            \
+    inline rettype WX_STR_DECL(name, const wxString&, const wxString&)        \
+        { return WX_STR_CALL(forString, s1, s2); }                            \
+    inline rettype WX_STR_DECL(name, const wxString&, const wxCStrData&)      \
+        { return WX_STR_CALL(forString, s1, s2); }                            \
+                                                                              \
+    inline rettype WX_STR_DECL(name, const wxCStrData&, const wchar_t*)       \
+        { return WX_STR_CALL(forString, s1.AsString(), s2); }                 \
+    inline rettype WX_STR_DECL(name, const wxCStrData&, const wxScopedWCharBuffer&) \
+        { return WX_STR_CALL(forString, s1.AsString(), s2); }                 \
+    inline rettype WX_STR_DECL(name, const wxCStrData&, const wxString&)      \
+        { return WX_STR_CALL(forString, s1.AsString(), s2); }                 \
+    inline rettype WX_STR_DECL(name, const wxCStrData&, const wxCStrData&)    \
+        { return WX_STR_CALL(forString, s1.AsString(), s2); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 // This defines strcmp-like function, i.e. one returning the result of
 // comparison; see WX_STR_FUNC_NO_INVERT for explanation of the arguments
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 #define WX_STRCMP_FUNC(name, crtA, crtW, forString)                           \
     WX_STR_FUNC_NO_INVERT(int, name, crtA, crtW, forString)                   \
                                                                               \
@@ -420,11 +480,26 @@ inline wchar_t *wxStrncat(wchar_t *dest, const char *src, size_t n)
         { return -WX_STR_CALL(forString, s2.AsString(), s1.data()); }         \
     inline int WX_STR_DECL(name, const wxScopedWCharBuffer&, const wxString&)       \
         { return -WX_STR_CALL(forString, s2, s1.data()); }
+#else // wxNO_IMPLICIT_WXSTRING_ENCODING
+#define WX_STRCMP_FUNC(name, crtA, crtW, forString)                     \
+    WX_STR_FUNC_NO_INVERT(int, name, crtA, crtW, forString)                   \
+                                                                              \
+    inline int WX_STR_DECL(name, const wchar_t *, const wxCStrData&)          \
+        { return -WX_STR_CALL(forString, s2.AsString(), s1); }                \
+    inline int WX_STR_DECL(name, const wchar_t *, const wxString&)            \
+        { return -WX_STR_CALL(forString, s2, s1); }                           \
+                                                                              \
+    inline int WX_STR_DECL(name, const wxScopedWCharBuffer&, const wxCStrData&)     \
+        { return -WX_STR_CALL(forString, s2.AsString(), s1.data()); }         \
+    inline int WX_STR_DECL(name, const wxScopedWCharBuffer&, const wxString&)       \
+        { return -WX_STR_CALL(forString, s2, s1.data()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 
 // This defines a string function that is *not* strcmp-like, i.e. doesn't
 // return the result of comparison and so if the second argument is a string,
 // it has to be converted to char* or wchar_t*
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 #define WX_STR_FUNC(rettype, name, crtA, crtW, forString)                     \
     WX_STR_FUNC_NO_INVERT(rettype, name, crtA, crtW, forString)               \
                                                                               \
@@ -447,6 +522,20 @@ inline wchar_t *wxStrncat(wchar_t *dest, const char *src, size_t n)
         { return WX_STR_CALL(crtW, s1.data(), s2.AsWCharBuf()); }             \
     inline rettype WX_STR_DECL(name, const wxScopedWCharBuffer&, const wxString&)   \
         { return WX_STR_CALL(crtW, s1.data(), s2.wc_str()); }
+#else // wxNO_IMPLICIT_WXSTRING_ENCODING
+#define WX_STR_FUNC(rettype, name, crtA, crtW, forString)                     \
+    WX_STR_FUNC_NO_INVERT(rettype, name, crtA, crtW, forString)               \
+                                                                              \
+    inline rettype WX_STR_DECL(name, const wchar_t *, const wxCStrData&)      \
+        { return WX_STR_CALL(crtW, s1, s2.AsWCharBuf()); }                    \
+    inline rettype WX_STR_DECL(name, const wchar_t *, const wxString&)        \
+        { return WX_STR_CALL(crtW, s1, s2.wc_str()); }                        \
+                                                                              \
+    inline rettype WX_STR_DECL(name, const wxScopedWCharBuffer&, const wxCStrData&) \
+        { return WX_STR_CALL(crtW, s1.data(), s2.AsWCharBuf()); }             \
+    inline rettype WX_STR_DECL(name, const wxScopedWCharBuffer&, const wxString&)   \
+        { return WX_STR_CALL(crtW, s1.data(), s2.wc_str()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 template<typename T>
 inline int wxStrcmp_String(const wxString& s1, const T& s2)
@@ -526,12 +615,16 @@ inline size_t wxStrxfrm(wchar_t *dest, const wchar_t *src, size_t n)
 template<typename T>
 inline size_t wxStrxfrm(T *dest, const wxScopedCharTypeBuffer<T>& src, size_t n)
     { return wxStrxfrm(dest, src.data(), n); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline size_t wxStrxfrm(char *dest, const wxString& src, size_t n)
     { return wxCRT_StrxfrmA(dest, src.mb_str(), n); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline size_t wxStrxfrm(wchar_t *dest, const wxString& src, size_t n)
     { return wxCRT_StrxfrmW(dest, src.wc_str(), n); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline size_t wxStrxfrm(char *dest, const wxCStrData& src, size_t n)
     { return wxCRT_StrxfrmA(dest, src.AsCharBuf(), n); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline size_t wxStrxfrm(wchar_t *dest, const wxCStrData& src, size_t n)
     { return wxCRT_StrxfrmW(dest, src.AsWCharBuf(), n); }
 
@@ -544,12 +637,16 @@ inline wchar_t *wxStrtok(wchar_t *str, const wchar_t *delim, wchar_t **saveptr)
 template<typename T>
 inline T *wxStrtok(T *str, const wxScopedCharTypeBuffer<T>& delim, T **saveptr)
     { return wxStrtok(str, delim.data(), saveptr); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrtok(char *str, const wxCStrData& delim, char **saveptr)
     { return wxCRT_StrtokA(str, delim.AsCharBuf(), saveptr); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline wchar_t *wxStrtok(wchar_t *str, const wxCStrData& delim, wchar_t **saveptr)
     { return wxCRT_StrtokW(str, delim.AsWCharBuf(), saveptr); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char *wxStrtok(char *str, const wxString& delim, char **saveptr)
     { return wxCRT_StrtokA(str, delim.mb_str(), saveptr); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline wchar_t *wxStrtok(wchar_t *str, const wxString& delim, wchar_t **saveptr)
     { return wxCRT_StrtokW(str, delim.wc_str(), saveptr); }
 
@@ -557,23 +654,29 @@ inline const char *wxStrstr(const char *haystack, const char *needle)
     { return wxCRT_StrstrA(haystack, needle); }
 inline const wchar_t *wxStrstr(const wchar_t *haystack, const wchar_t *needle)
     { return wxCRT_StrstrW(haystack, needle); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const char *wxStrstr(const char *haystack, const wxString& needle)
     { return wxCRT_StrstrA(haystack, needle.mb_str()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const wchar_t *wxStrstr(const wchar_t *haystack, const wxString& needle)
     { return wxCRT_StrstrW(haystack, needle.wc_str()); }
 // these functions return char* pointer into the non-temporary conversion buffer
 // used by c_str()'s implicit conversion to char*, for ANSI build compatibility
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const char *wxStrstr(const wxString& haystack, const wxString& needle)
     { return wxCRT_StrstrA(haystack.c_str(), needle.mb_str()); }
 inline const char *wxStrstr(const wxCStrData& haystack, const wxString& needle)
     { return wxCRT_StrstrA(haystack, needle.mb_str()); }
 inline const char *wxStrstr(const wxCStrData& haystack, const wxCStrData& needle)
     { return wxCRT_StrstrA(haystack, needle.AsCharBuf()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 // if 'needle' is char/wchar_t, then the same is probably wanted as return value
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const char *wxStrstr(const wxString& haystack, const char *needle)
     { return wxCRT_StrstrA(haystack.c_str(), needle); }
 inline const char *wxStrstr(const wxCStrData& haystack, const char *needle)
     { return wxCRT_StrstrA(haystack, needle); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const wchar_t *wxStrstr(const wxString& haystack, const wchar_t *needle)
     { return wxCRT_StrstrW(haystack.c_str(), needle); }
 inline const wchar_t *wxStrstr(const wxCStrData& haystack, const wchar_t *needle)
@@ -623,6 +726,7 @@ inline const T* wxStrrchr(const wxScopedCharTypeBuffer<T>& s, const wxUniCharRef
     { 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
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 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)
@@ -639,10 +743,12 @@ inline const char* wxStrchr(const wxString& s, const wxUniCharRef& uc)
     { char c; return uc.GetAsChar(&c) ? wxCRT_StrchrA(s.c_str(), c) : NULL; }
 inline const char* wxStrrchr(const wxString& s, const wxUniCharRef& uc)
     { char c; return uc.GetAsChar(&c) ? wxCRT_StrrchrA(s.c_str(), c) : NULL; }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 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); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const char* wxStrchr(const wxCStrData& s, char c)
     { return wxCRT_StrchrA(s.AsChar(), c); }
 inline const char* wxStrrchr(const wxCStrData& s, char c)
@@ -659,6 +765,7 @@ inline const char* wxStrchr(const wxCStrData& s, const wxUniCharRef& uc)
     { char c; return uc.GetAsChar(&c) ? wxCRT_StrchrA(s, c) : NULL; }
 inline const char* wxStrrchr(const wxCStrData& s, const wxUniCharRef& uc)
     { char c; return uc.GetAsChar(&c) ? wxCRT_StrrchrA(s, c) : NULL; }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 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)
@@ -668,30 +775,38 @@ 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); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 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()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 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()); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 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); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const wchar_t *wxStrpbrk(const wxString& s, const wchar_t *accept)
     { return wxCRT_StrpbrkW(s.wc_str(), accept); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 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 char *accept)
     { return wxCRT_StrpbrkA(s.AsChar(), accept); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const wchar_t *wxStrpbrk(const wxCStrData& s, const wchar_t *accept)
     { return wxCRT_StrpbrkW(s.AsWChar(), accept); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline const char *wxStrpbrk(const wxCStrData& s, const wxCStrData& accept)
     { return wxCRT_StrpbrkA(s.AsChar(), accept.AsCharBuf()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 template <typename S, typename T>
 inline const T *wxStrpbrk(const S& s, const wxScopedCharTypeBuffer<T>& accept)
     { return wxStrpbrk(s, accept.data()); }
@@ -771,24 +886,29 @@ inline int wxUngetc(int c, FILE *stream) { return wxCRT_UngetcA(c, stream); }
 
 // ----------------------------------------------------------------------------
 //                             stdlib.h functions
+//
+// We only use wxConvLibc here because if the string is non-ASCII,
+// then it's fine for the conversion to yield empty string, as atoi()
+// will return 0 for it, which is the correct thing to do in this
+// case.
 // ----------------------------------------------------------------------------
 
 #ifdef wxCRT_AtoiW
 inline int wxAtoi(const wxString& str) { return wxCRT_AtoiW(str.wc_str()); }
 #else
-inline int wxAtoi(const wxString& str) { return wxCRT_AtoiA(str.mb_str()); }
+inline int wxAtoi(const wxString& str) { return wxCRT_AtoiA(str.mb_str(wxConvLibc)); }
 #endif
 
 #ifdef wxCRT_AtolW
 inline long wxAtol(const wxString& str) { return wxCRT_AtolW(str.wc_str()); }
 #else
-inline long wxAtol(const wxString& str) { return wxCRT_AtolA(str.mb_str()); }
+inline long wxAtol(const wxString& str) { return wxCRT_AtolA(str.mb_str(wxConvLibc)); }
 #endif
 
 #ifdef wxCRT_AtofW
 inline double wxAtof(const wxString& str) { return wxCRT_AtofW(str.wc_str()); }
 #else
-inline double wxAtof(const wxString& str) { return wxCRT_AtofA(str.mb_str()); }
+inline double wxAtof(const wxString& str) { return wxCRT_AtofA(str.mb_str(wxConvLibc)); }
 #endif
 
 inline double wxStrtod(const char *nptr, char **endptr)
@@ -913,15 +1033,17 @@ WX_STRTOX_FUNC(wxULongLong_t, wxStrtoull, wxCRT_StrtoullA, wxCRT_StrtoullW)
 // functions in their wide versions
 #ifdef wxCRT_SystemW
 inline int wxSystem(const wxString& str) { return wxCRT_SystemW(str.wc_str()); }
-#else
+#elif !defined wxNO_IMPLICIT_WXSTRING_ENCODING
 inline int wxSystem(const wxString& str) { return wxCRT_SystemA(str.mb_str()); }
 #endif
 #endif
 
 inline char* wxGetenv(const char *name) { return wxCRT_GetenvA(name); }
 inline wchar_t* wxGetenv(const wchar_t *name) { return wxCRT_GetenvW(name); }
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char* wxGetenv(const wxString& name) { return wxCRT_GetenvA(name.mb_str()); }
 inline char* wxGetenv(const wxCStrData& name) { return wxCRT_GetenvA(name.AsCharBuf()); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 inline char* wxGetenv(const wxScopedCharBuffer& name) { return wxCRT_GetenvA(name.data()); }
 inline wchar_t* wxGetenv(const wxScopedWCharBuffer& name) { return wxCRT_GetenvW(name.data()); }
 
@@ -929,9 +1051,11 @@ inline wchar_t* wxGetenv(const wxScopedWCharBuffer& name) { return wxCRT_GetenvW
 //                            time.h functions
 // ----------------------------------------------------------------------------
 
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 inline size_t wxStrftime(char *s, size_t max,
                          const wxString& format, const struct tm *tm)
     { return wxCRT_StrftimeA(s, max, format.mb_str(), tm); }
+#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
 
 inline size_t wxStrftime(wchar_t *s, size_t max,
                          const wxString& format, const struct tm *tm)

include/wx/wxcrtvararg.h

@@ -280,14 +280,14 @@ WX_DEFINE_VARARG_FUNC_SANS_N0(int, wxPrintf, 1, (const wxFormatString&),
                               wxCRT_PrintfNative, wxCRT_PrintfA)
 inline int wxPrintf(const wxFormatString& s)
 {
-    return wxPrintf("%s", s.InputAsString());
+    return wxPrintf(wxASCII_STR("%s"), s.InputAsString());
 }
 
 WX_DEFINE_VARARG_FUNC_SANS_N0(int, wxFprintf, 2, (FILE*, const wxFormatString&),
                               wxCRT_FprintfNative, wxCRT_FprintfA)
 inline int wxFprintf(FILE *f, const wxFormatString& s)
 {
-    return wxFprintf(f, "%s", s.InputAsString());
+    return wxFprintf(f, wxASCII_STR("%s"), s.InputAsString());
 }
 
 // va_list versions of printf functions simply forward to the respective
@@ -440,12 +440,16 @@ WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxScopedCharBuffer& str, const char *form
                    wxCRT_SscanfA, (str.data(), format))
 WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxScopedWCharBuffer& str, const wchar_t *format),
                    wxCRT_SscanfW, (str.data(), wxScanfConvertFormatW(format)))
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxString& str, const char *format),
                    wxCRT_SscanfA, (str.mb_str(), format))
+#endif
 WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxString& str, const wchar_t *format),
                    wxCRT_SscanfW, (str.wc_str(), wxScanfConvertFormatW(format)))
+#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
 WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxCStrData& str, const char *format),
                    wxCRT_SscanfA, (str.AsCharBuf(), format))
+#endif
 WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxCStrData& str, const wchar_t *format),
                    wxCRT_SscanfW, (str.AsWCharBuf(), wxScanfConvertFormatW(format)))