fix for always terminating intermediate UniChar String for 4 bytes wchar_t

[wxWidgets.git] / src / common / wxchar.cpp

diff --git a/src/common/wxchar.cpp b/src/common/wxchar.cpp
index 571d165d3d6c3b0ad445d53f23c48cec9915e2ef..655a9b58b216ec415e985194ee413274a4f517d7 100644 (file)
--- a/src/common/wxchar.cpp
+++ b/src/common/wxchar.cpp
@@ -2,14 +2,14 @@
 // Name:        wxchar.cpp
 // Purpose:     wxChar implementation
 // Author:      Ove Kåven
 // Name:        wxchar.cpp
 // Purpose:     wxChar implementation
 // Author:      Ove Kåven

-// Modified by:
+// Modified by: Ron Lee

 // Created:     09/04/99
 // RCS-ID:      $Id$
 // Copyright:   (c) wxWindows copyright
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Created:     09/04/99
 // RCS-ID:      $Id$
 // Copyright:   (c) wxWindows copyright
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

   #pragma implementation "wxchar.h"
 #endif
 
   #pragma implementation "wxchar.h"
 #endif
 


@@ -540,6 +540,23 @@ int WXDLLEXPORT wxSnprintf_(wxChar *buf, size_t len, const wxChar *format, ...)
 }
 #endif // wxSnprintf_
 
 }
 #endif // wxSnprintf_
 

+#if defined(__DMC__)
+    /* Digital Mars adds count to _stprintf (C99) so convert */
+    #if wxUSE_UNICODE
+        int wxSprintf (wchar_t * __RESTRICT s, const wchar_t * __RESTRICT format, ... )
+        {
+            va_list arglist;
+
+            va_start( arglist, format );
+            int iLen = swprintf ( s, -1, format, arglist );
+            va_end( arglist );
+            return iLen ;
+        }
+
+    #endif // wxUSE_UNICODE
+
+#endif //__DMC__
+

 // ----------------------------------------------------------------------------
 // implement the standard IO functions for wide char if libc doesn't have them
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // implement the standard IO functions for wide char if libc doesn't have them
 // ----------------------------------------------------------------------------


@@ -599,7 +616,7 @@ int vfwprintf(FILE *stream, const wxChar *format, va_list argptr)
     if ( rc != -1 )
     {
         // we can't do much better without Unicode support in libc...
     if ( rc != -1 )
     {
         // we can't do much better without Unicode support in libc...

-        if ( fprintf(stream, "%s", s.mb_str()) == -1 )
+        if ( fprintf(stream, "%s", (const char*)s.mb_str() ) == -1 )

             return -1;
     }
 
             return -1;
     }
 


@@ -752,7 +769,11 @@ wxFormatConverter::wxFormatConverter(const wxChar *format)
             // precision?
             if ( *format == _T('.') )
             {
             // precision?
             if ( *format == _T('.') )
             {

-                SkipDigits(&format);
+                CopyFmtChar(*format++);
+                if ( *format == _T('*') )
+                    CopyFmtChar(*format++);
+                else
+                    SkipDigits(&format);

             }
 
             // next we can have a size modifier
             }
 
             // next we can have a size modifier


@@ -799,23 +820,14 @@ wxFormatConverter::wxFormatConverter(const wxChar *format)
                 case _T('c'):
                 case _T('s'):
                     // %c -> %lc but %hc stays %hc and %lc is still %lc
                 case _T('c'):
                 case _T('s'):
                     // %c -> %lc but %hc stays %hc and %lc is still %lc

-                    switch ( size )
-                    {
-                        case Default:
-                            InsertFmtChar(_T('l'));
-                            break;
-
-                        case Short:
-                            CopyFmtChar(_T('h'));
-                            break;
-
-                        case Long:
-                            ;
-                    }
+                    if ( size == Default)
+                        InsertFmtChar(_T('l'));

                     // fall through
 
                 default:
                     // nothing special to do
                     // fall through
 
                 default:
                     // nothing special to do

+                    if ( size != Default )
+                        CopyFmtChar(*(format - 1));

                     CopyFmtChar(*format++);
             }
         }
                     CopyFmtChar(*format++);
             }
         }


@@ -827,6 +839,14 @@ wxFormatConverter::wxFormatConverter(const wxChar *format)
     #define wxFormatConverter(x) (x)
 #endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
 
     #define wxFormatConverter(x) (x)
 #endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
 

+#ifdef __WXDEBUG__
+// For testing the format converter
+wxString wxConvertFormat(const wxChar *format)
+{
+    return wxString(wxFormatConverter(format));
+}
+#endif
+

 // ----------------------------------------------------------------------------
 // wxPrintf(), wxScanf() and relatives
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxPrintf(), wxScanf() and relatives
 // ----------------------------------------------------------------------------


@@ -900,7 +920,18 @@ int wxSprintf( wxChar *str, const wxChar *format, ... )
     va_start(argptr, format);
 
     // callers of wxSprintf() deserve what they get
     va_start(argptr, format);
 
     // callers of wxSprintf() deserve what they get

-    int ret = vswprintf( str, UINT_MAX, wxFormatConverter(format), argptr );
+    //int ret = vswprintf( str, UINT_MAX, wxFormatConverter(format), argptr );
+
+    // ... true, but if we are going to implement it, they probably still
+    // deserve something a little better than absolutely guaranteed silent
+    // failure.  For some (very mysterious) reason, this call fails under glibc
+    // 2.3.2 if str was allocated on the heap and maxsize is larger than this.
+    // Even more mysterious is that it does still succeed if str was allocated
+    // on the stack.  This should still be plenty large enough for people who
+    // want to overflow a buffer.  The bug was first noticed in unicode builds
+    // of tex2rtf, but I'm going to fix that to not use this unsafe function
+    // instead of wasting time diagnosing this further right now.
+    int ret = vswprintf( str, INT_MAX / 4, wxFormatConverter(format), argptr );

 
     va_end(argptr);
 
 
     va_end(argptr);
 


@@ -944,7 +975,7 @@ int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list argptr
 int wxVsprintf( wxChar *str, const wxChar *format, va_list argptr )
 {
     // same as for wxSprintf()
 int wxVsprintf( wxChar *str, const wxChar *format, va_list argptr )
 {
     // same as for wxSprintf()

-    return vswprintf(str, UINT_MAX, wxFormatConverter(format), argptr);
+    return vswprintf(str, INT_MAX / 4, wxFormatConverter(format), argptr);

 }
 
 #endif // wxNEED_PRINTF_CONVERSION
 }
 
 #endif // wxNEED_PRINTF_CONVERSION


@@ -965,7 +996,7 @@ inline WORD wxMSW_ctype(wxChar ch)
 
 WXDLLEXPORT int wxIsalnum(wxChar ch) { return IsCharAlphaNumeric(ch); }
 WXDLLEXPORT int wxIsalpha(wxChar ch) { return IsCharAlpha(ch); }
 
 WXDLLEXPORT int wxIsalnum(wxChar ch) { return IsCharAlphaNumeric(ch); }
 WXDLLEXPORT int wxIsalpha(wxChar ch) { return IsCharAlpha(ch); }

-WXDLLEXPORT int wxIsctrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; }
+WXDLLEXPORT int wxIscntrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; }

 WXDLLEXPORT int wxIsdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_DIGIT; }
 WXDLLEXPORT int wxIsgraph(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); }
 WXDLLEXPORT int wxIslower(wxChar ch) { return IsCharLower(ch); }
 WXDLLEXPORT int wxIsdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_DIGIT; }
 WXDLLEXPORT int wxIsgraph(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); }
 WXDLLEXPORT int wxIslower(wxChar ch) { return IsCharLower(ch); }


@@ -1205,28 +1236,6 @@ WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base)
 }
 #endif // wxNEED_WX_STRING_H
 
 }
 #endif // wxNEED_WX_STRING_H
 

-#if defined(__WXMAC__) && !defined(__DARWIN__)
-WXDLLEXPORT FILE * wxFopen(const wxChar *path, const wxChar *mode)
-{
-    return fopen( wxMacStringToCString(path), mode );
-}
-
-WXDLLEXPORT FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream)
-{
-    return freopen( wxMacStringToCString(path), mode, stream );
-}
-
-WXDLLEXPORT int wxRemove(const wxChar *path)
-{
-    return remove( wxMacStringToCString(path) );
-}
-
-WXDLLEXPORT int wxRename(const wxChar *oldpath, const wxChar *newpath)
-{
-    return rename( wxMacStringToCString(oldpath), wxMacStringToCString(newpath) );
-}
-#endif
-

 #ifdef wxNEED_WX_STDIO_H
 WXDLLEXPORT FILE * wxFopen(const wxChar *path, const wxChar *mode)
 {
 #ifdef wxNEED_WX_STDIO_H
 WXDLLEXPORT FILE * wxFopen(const wxChar *path, const wxChar *mode)
 {


@@ -1260,7 +1269,16 @@ WXDLLEXPORT int wxRename(const wxChar *oldpath, const wxChar *newpath)
 #ifndef wxAtof
 double   WXDLLEXPORT wxAtof(const wxChar *psz)
 {
 #ifndef wxAtof
 double   WXDLLEXPORT wxAtof(const wxChar *psz)
 {

-  return atof(wxConvLocal.cWX2MB(psz));
+#ifdef __WXWINCE__
+    double d;
+    wxString str(psz);
+    if (str.ToDouble(& d))
+        return d;
+    else
+        return 0.0;
+#else
+    return atof(wxConvLocal.cWX2MB(psz));
+#endif

 }
 #endif
 
 }
 #endif
 


@@ -1296,7 +1314,7 @@ wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
     // printf( "home %s\n", val );
 
     // convert it,
     // printf( "home %s\n", val );
 
     // convert it,

-#ifdef wxUSE_UNICODE
+#if wxUSE_UNICODE

     data = (wxObject *)new wxString(val, wxConvLocal);
 #else
     data = (wxObject *)new wxString(val);
     data = (wxObject *)new wxString(val, wxConvLocal);
 #else
     data = (wxObject *)new wxString(val);


@@ -1338,6 +1356,18 @@ WXDLLEXPORT size_t   wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const
 }
 #endif // wxNEED_WX_TIME_H
 
 }
 #endif // wxNEED_WX_TIME_H
 

+#ifndef wxCtime
+WXDLLEXPORT wxChar *wxCtime(const time_t *timep)
+{
+    static wxChar   buf[128];
+
+    wxStrncpy( buf, wxConvertMB2WX( ctime( timep ) ), sizeof( buf ) );
+    buf[ sizeof( buf ) - 1 ] = _T('\0');
+
+    return buf;
+}
+#endif // wxCtime
+

 #endif // wxUSE_WCHAR_T
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_WCHAR_T
 
 // ----------------------------------------------------------------------------


@@ -1383,16 +1413,39 @@ WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_pt
 // missing C RTL functions
 // ----------------------------------------------------------------------------
 
 // missing C RTL functions
 // ----------------------------------------------------------------------------
 

-#if defined( __MWERKS__ ) && !defined(__MACH__)
-#if __MSL__ < 0x00008000
+#if (defined(__MWERKS__) && !defined(__MACH__) && (__MSL__ < 0x00008000)) || \
+     defined(__WXWINCE__)

 char *strdup(const char *s)
 {
 char *strdup(const char *s)
 {

-        return strcpy( (char*) malloc( strlen( s ) + 1 ) , s ) ;
+    char *dest = (char*) malloc( strlen( s ) + 1 ) ;
+    if ( dest )
+        strcpy( dest , s ) ;
+    return dest ;

 }
 #endif
 }
 #endif

+
+#if (defined(__MWERKS__) && !defined(__MACH__)) || (defined(__WXWINCE__) && _WIN32_WCE <= 211)
+

 int isascii( int c )
 {
 int isascii( int c )
 {

-        return ( c >= 0 && c < 128 ) ;
+    return ( c >= 0 && c < 128 );
+}
+#endif
+
+#if defined(__WXWINCE__) && (_WIN32_WCE <= 211)
+#if (_WIN32_WCE < 300)
+void *calloc( size_t num, size_t size )
+{
+    void** ptr = (void **)malloc(num * size);
+    memset( ptr, 0, num * size);
+    return ptr;

 }
 }

-#endif // __MWERKS__
+#endif
+
+int isspace(int c)
+{
+    return (c == ' ');
+}
+
+#endif