first attempt for full screen implementation

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

diff --git a/src/common/wxchar.cpp b/src/common/wxchar.cpp
index 65309fdef08964a9001c58af23d70d1fc86e0c76..b7e5c75272aad1993fade36f4a97c5e218e6a3a3 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$
 // Created:     09/04/99
 // RCS-ID:      $Id$

-// Copyright:   (c) wxWindows copyright
-// Licence:     wxWindows license
+// Copyright:   (c) wxWidgets copyright
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

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

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


@@ -30,8 +30,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

-#include <locale.h>
+
+#ifndef __WXWINCE__

 #include <time.h>
 #include <time.h>

+#include <locale.h>
+#else
+#include "wx/msw/wince/time.h"
+#endif

 
 #ifndef WX_PRECOMP
   #include "wx/defs.h"
 
 #ifndef WX_PRECOMP
   #include "wx/defs.h"


@@ -47,49 +52,73 @@
   #include <winnt.h>
 #endif
 
   #include <winnt.h>
 #endif
 

+#if defined(__MWERKS__) && __MSL__ >= 0x6000
+using namespace std ;
+#endif
+
+#ifdef __WXMAC__
+    #include "wx/mac/private.h"
+#endif
+

 #if wxUSE_WCHAR_T
 size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 {
 #if wxUSE_WCHAR_T
 size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 {

+  // assume that we have mbsrtowcs() too if we have wcsrtombs()
+#if HAVE_WCSRTOMBS
+  mbstate_t mbstate;
+  memset(&mbstate, 0, sizeof(mbstate_t));
+#endif
+

   if (buf) {
     if (!n || !*psz) {
       if (n) *buf = wxT('\0');
       return 0;
     }
   if (buf) {
     if (!n || !*psz) {
       if (n) *buf = wxT('\0');
       return 0;
     }

+#ifdef HAVE_WCSRTOMBS
+    return mbsrtowcs(buf, &psz, n, &mbstate);
+#else

     return mbstowcs(buf, psz, n);
     return mbstowcs(buf, psz, n);

+#endif

   }
 
   }
 

-  // assume that we have mbsrtowcs() too if we have wcsrtombs()

 #ifdef HAVE_WCSRTOMBS
 #ifdef HAVE_WCSRTOMBS

-  mbstate_t mbstate;

   return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
   return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);

-#else  // !GNU libc
+#else

   return mbstowcs((wchar_t *) NULL, psz, 0);
   return mbstowcs((wchar_t *) NULL, psz, 0);

-#endif // GNU
+#endif

 }
 
 size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 {
 }
 
 size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 {

+#if HAVE_WCSRTOMBS
+  mbstate_t mbstate;
+  memset(&mbstate, 0, sizeof(mbstate_t));
+#endif
+

   if (buf) {
     if (!n || !*pwz) {
       // glibc2.1 chokes on null input
       if (n) *buf = '\0';
       return 0;
     }
   if (buf) {
     if (!n || !*pwz) {
       // glibc2.1 chokes on null input
       if (n) *buf = '\0';
       return 0;
     }

+#if HAVE_WCSRTOMBS
+    return wcsrtombs(buf, &pwz, n, &mbstate);
+#else

     return wcstombs(buf, pwz, n);
     return wcstombs(buf, pwz, n);

+#endif

   }
 
 #if HAVE_WCSRTOMBS
   }
 
 #if HAVE_WCSRTOMBS

-  mbstate_t mbstate;

   return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
   return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);

-#else  // !GNU libc
+#else

   return wcstombs((char *) NULL, pwz, 0);
   return wcstombs((char *) NULL, pwz, 0);

-#endif // GNU
+#endif

 }
 #endif // wxUSE_WCHAR_T
 
 bool WXDLLEXPORT wxOKlibc()
 {
 }
 #endif // wxUSE_WCHAR_T
 
 bool WXDLLEXPORT wxOKlibc()
 {

-#if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__)
+#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) &&
   // glibc 2.0 uses UTF-8 even when it shouldn't
   wchar_t res = 0;
   if ((MB_CUR_MAX == 2) &&


@@ -108,19 +137,27 @@ bool WXDLLEXPORT wxOKlibc()
   return TRUE;
 }
 
   return TRUE;
 }
 

-#ifndef HAVE_WCSLEN
-size_t   WXDLLEXPORT wcslen(const wchar_t *s)
-{
-  size_t len = 0;
-  while (s[len]) len++;
-  return len;
-}
-#endif
-

 // ============================================================================
 // printf() functions business
 // ============================================================================
 
 // ============================================================================
 // printf() functions business
 // ============================================================================
 

+// special test mode: define all functions below even if we don't really need
+// them to be able to test them
+#ifdef wxTEST_PRINTF
+    #undef wxFprintf
+    #undef wxPrintf
+    #undef wxSprintf
+    #undef wxVfprintf
+    #undef wxVsprintf
+    #undef wxVprintf
+    #undef wxVsnprintf_
+    #undef wxSnprintf_
+
+    #define wxNEED_WPRINTF
+
+    int wxVfprintf( FILE *stream, const wxChar *format, va_list argptr );
+#endif
+

 // ----------------------------------------------------------------------------
 // implement [v]snprintf() if the system doesn't provide a safe one
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // implement [v]snprintf() if the system doesn't provide a safe one
 // ----------------------------------------------------------------------------


@@ -135,9 +172,12 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
     // number of characters in the buffer so far, must be less than lenMax
     size_t lenCur = 0;
 
     // number of characters in the buffer so far, must be less than lenMax
     size_t lenCur = 0;
 

-    for (size_t n = 0; format[n]; n++)
+    for ( size_t n = 0; ; n++ )

     {
     {

-        if (format[n] == wxT('%')) {
+        const wxChar chCur = format[n];
+
+        if ( chCur == wxT('%') )
+        {

             static char s_szFlags[256] = "%";
             size_t flagofs = 1;
             bool adj_left = FALSE,
             static char s_szFlags[256] = "%";
             size_t flagofs = 1;
             bool adj_left = FALSE,


@@ -147,7 +187,8 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
             int ilen = 0;
             size_t min_width = 0,
                    max_width = wxSTRING_MAXLEN;
             int ilen = 0;
             size_t min_width = 0,
                    max_width = wxSTRING_MAXLEN;

-            do {
+            do
+            {

 
 #define CHECK_PREC \
                 if (in_prec && !prec_dot) \
 
 #define CHECK_PREC \
                 if (in_prec && !prec_dot) \


@@ -157,10 +198,12 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                 }
 
 #define APPEND_CH(ch) \
                 }
 
 #define APPEND_CH(ch) \

-                if ( lenCur == lenMax ) \
-                    return -1; \
-                \
-                buf[lenCur++] = ch
+                { \
+                    if ( lenCur == lenMax ) \
+                        return -1; \
+                    \
+                    buf[lenCur++] = ch; \
+                }

 
 #define APPEND_STR(s) \
                 { \
 
 #define APPEND_STR(s) \
                 { \


@@ -170,7 +213,10 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                     } \
                 }
 
                     } \
                 }
 

-                switch (format[++n]) {
+                // what follows '%'?
+                const wxChar ch = format[++n];
+                switch ( ch )
+                {

                     case wxT('\0'):
                         APPEND_CH(_T('\0'));
 
                     case wxT('\0'):
                         APPEND_CH(_T('\0'));
 


@@ -188,57 +234,62 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                     case wxT('+'):
                     case wxT('\''):
                         CHECK_PREC
                     case wxT('+'):
                     case wxT('\''):
                         CHECK_PREC

-                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs++] = ch;

                         break;
 
                     case wxT('-'):
                         CHECK_PREC
                         adj_left = TRUE;
                         break;
 
                     case wxT('-'):
                         CHECK_PREC
                         adj_left = TRUE;

-                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs++] = ch;

                         break;
 
                     case wxT('.'):
                         CHECK_PREC
                         break;
 
                     case wxT('.'):
                         CHECK_PREC

-                            in_prec = TRUE;
+                        in_prec = TRUE;

                         prec_dot = FALSE;
                         max_width = 0;
                         prec_dot = FALSE;
                         max_width = 0;

-                        // dot will be auto-added to s_szFlags if non-negative number follows
+                        // dot will be auto-added to s_szFlags if non-negative
+                        // number follows

                         break;
 
                     case wxT('h'):
                         ilen = -1;
                         CHECK_PREC
                         break;
 
                     case wxT('h'):
                         ilen = -1;
                         CHECK_PREC

-                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs++] = ch;

                         break;
 
                     case wxT('l'):
                         ilen = 1;
                         CHECK_PREC
                         break;
 
                     case wxT('l'):
                         ilen = 1;
                         CHECK_PREC

-                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs++] = ch;

                         break;
 
                     case wxT('q'):
                     case wxT('L'):
                         ilen = 2;
                         CHECK_PREC
                         break;
 
                     case wxT('q'):
                     case wxT('L'):
                         ilen = 2;
                         CHECK_PREC

-                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs++] = ch;

                         break;
 
                     case wxT('Z'):
                         ilen = 3;
                         CHECK_PREC
                         break;
 
                     case wxT('Z'):
                         ilen = 3;
                         CHECK_PREC

-                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs++] = ch;

                         break;
 
                     case wxT('*'):
                         {
                             int len = va_arg(argptr, int);
                         break;
 
                     case wxT('*'):
                         {
                             int len = va_arg(argptr, int);

-                            if (in_prec) {
+                            if (in_prec)
+                            {

                                 if (len<0) break;
                                 CHECK_PREC
                                     max_width = len;
                                 if (len<0) break;
                                 CHECK_PREC
                                     max_width = len;

-                            } else {
-                                if (len<0) {
+                            }
+                            else
+                            {
+                                if (len<0)
+                                {

                                     adj_left = !adj_left;
                                     s_szFlags[flagofs++] = '-';
                                     len = -len;
                                     adj_left = !adj_left;
                                     s_szFlags[flagofs++] = '-';
                                     len = -len;


@@ -255,13 +306,19 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                         {
                             int len = 0;
                             CHECK_PREC
                         {
                             int len = 0;
                             CHECK_PREC

-                                while ((format[n]>=wxT('0')) && (format[n]<=wxT('9'))) {
-                                    s_szFlags[flagofs++] = format[n];
-                                    len = len*10 + (format[n] - wxT('0'));
-                                    n++;
-                                }
-                            if (in_prec) max_width = len;
-                            else min_width = len;
+                            while ( (format[n] >= wxT('0')) &&
+                                    (format[n] <= wxT('9')) )
+                            {
+                                s_szFlags[flagofs++] = format[n];
+                                len = len*10 + (format[n] - wxT('0'));
+                                n++;
+                            }
+
+                            if (in_prec)
+                                max_width = len;
+                            else
+                                min_width = len;
+

                             n--; // the main loop pre-increments n again
                         }
                         break;
                             n--; // the main loop pre-increments n again
                         }
                         break;


@@ -273,37 +330,45 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                     case wxT('x'):
                     case wxT('X'):
                         CHECK_PREC
                     case wxT('x'):
                     case wxT('X'):
                         CHECK_PREC

-                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs++] = ch;

                         s_szFlags[flagofs] = '\0';
                         s_szFlags[flagofs] = '\0';

-                        if (ilen == 0 ) {
+                        if (ilen == 0 )
+                        {

                             int val = va_arg(argptr, int);
                             ::sprintf(szScratch, s_szFlags, val);
                         }
                             int val = va_arg(argptr, int);
                             ::sprintf(szScratch, s_szFlags, val);
                         }

-                        else if (ilen == -1) {
+                        else if (ilen == -1)
+                        {

                             // NB: 'short int' value passed through '...'
                             // NB: 'short int' value passed through '...'

-                            //      is promoted to 'int'
+                            //      is promoted to 'int', so we have to get
+                            //      an int from stack even if we need a short

                             short int val = (short int) va_arg(argptr, int);
                             ::sprintf(szScratch, s_szFlags, val);
                         }
                             short int val = (short int) va_arg(argptr, int);
                             ::sprintf(szScratch, s_szFlags, val);
                         }

-                        else if (ilen == 1) {
+                        else if (ilen == 1)
+                        {

                             long int val = va_arg(argptr, long int);
                             ::sprintf(szScratch, s_szFlags, val);
                         }
                             long int val = va_arg(argptr, long int);
                             ::sprintf(szScratch, s_szFlags, val);
                         }

-                        else if (ilen == 2) {
+                        else if (ilen == 2)
+                        {

 #if SIZEOF_LONG_LONG
                             long long int val = va_arg(argptr, long long int);
                             ::sprintf(szScratch, s_szFlags, val);
 #if SIZEOF_LONG_LONG
                             long long int val = va_arg(argptr, long long int);
                             ::sprintf(szScratch, s_szFlags, val);

-#else
+#else // !long long

                             long int val = va_arg(argptr, long int);
                             ::sprintf(szScratch, s_szFlags, val);
                             long int val = va_arg(argptr, long int);
                             ::sprintf(szScratch, s_szFlags, val);

-#endif
+#endif // long long/!long long

                         }
                         }

-                        else if (ilen == 3) {
+                        else if (ilen == 3)
+                        {

                             size_t val = va_arg(argptr, size_t);
                             ::sprintf(szScratch, s_szFlags, val);
                         }
                             size_t val = va_arg(argptr, size_t);
                             ::sprintf(szScratch, s_szFlags, val);
                         }

+

                         {
                         {

-                            wxMB2WXbuf tmp = wxConvLibc.cMB2WX(szScratch);
+                            const wxMB2WXbuf tmp =
+                                wxConvLibc.cMB2WX(szScratch);

                             APPEND_STR(tmp);
                         }
 
                             APPEND_STR(tmp);
                         }
 


@@ -316,17 +381,22 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                     case wxT('g'):
                     case wxT('G'):
                         CHECK_PREC
                     case wxT('g'):
                     case wxT('G'):
                         CHECK_PREC

-                        s_szFlags[flagofs++] = format[n];
+                        s_szFlags[flagofs++] = ch;

                         s_szFlags[flagofs] = '\0';
                         s_szFlags[flagofs] = '\0';

-                        if (ilen == 2) {
+                        if (ilen == 2)
+                        {

                             long double val = va_arg(argptr, long double);
                             ::sprintf(szScratch, s_szFlags, val);
                             long double val = va_arg(argptr, long double);
                             ::sprintf(szScratch, s_szFlags, val);

-                        } else {
+                        }
+                        else
+                        {

                             double val = va_arg(argptr, double);
                             ::sprintf(szScratch, s_szFlags, val);
                         }
                             double val = va_arg(argptr, double);
                             ::sprintf(szScratch, s_szFlags, val);
                         }

+

                         {
                         {

-                            wxMB2WXbuf tmp = wxConvLibc.cMB2WX(szScratch);
+                            const wxMB2WXbuf tmp =
+                                wxConvLibc.cMB2WX(szScratch);

                             APPEND_STR(tmp);
                         }
 
                             APPEND_STR(tmp);
                         }
 


@@ -337,11 +407,12 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                         {
                             void *val = va_arg(argptr, void *);
                             CHECK_PREC
                         {
                             void *val = va_arg(argptr, void *);
                             CHECK_PREC

-                                s_szFlags[flagofs++] = format[n];
+                            s_szFlags[flagofs++] = ch;

                             s_szFlags[flagofs] = '\0';
                             ::sprintf(szScratch, s_szFlags, val);
 
                             s_szFlags[flagofs] = '\0';
                             ::sprintf(szScratch, s_szFlags, val);
 

-                            wxMB2WXbuf tmp = wxConvLibc.cMB2WX(szScratch);
+                            const wxMB2WXbuf tmp =
+                                wxConvLibc.cMB2WX(szScratch);

                             APPEND_STR(tmp);
 
                             done = TRUE;
                             APPEND_STR(tmp);
 
                             done = TRUE;


@@ -350,57 +421,119 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
 
                     case wxT('c'):
                         {
 
                     case wxT('c'):
                         {

-                            wxChar val = va_arg(argptr, int);
-                            // we don't need to honor padding here, do we?
+                            int val = va_arg(argptr, int);
+#if wxUSE_UNICODE
+                            if (ilen == -1)
+                            {
+                                const char buf[2] = { val, 0 };
+                                val = wxString(buf, wxConvLibc)[0u];
+                            }
+#elif wxUSE_WCHAR_T
+                            if (ilen == 1)
+                            {
+                                const wchar_t buf[2] = { val, 0 };
+                                val = wxString(buf, wxConvLibc)[0u];
+                            }
+#endif
+                            size_t i;
+
+                            if (!adj_left)
+                                for (i = 1; i < min_width; i++)
+                                    APPEND_CH(_T(' '));
+

                             APPEND_CH(val);
 
                             APPEND_CH(val);
 

+                            if (adj_left)
+                                for (i = 1; i < min_width; i++)
+                                    APPEND_CH(_T(' '));
+

                             done = TRUE;
                         }
                         break;
 
                     case wxT('s'):
                             done = TRUE;
                         }
                         break;
 
                     case wxT('s'):

-                        if (ilen == -1) {
-                            // wx extension: we'll let %hs mean non-Unicode strings
-                            char *val = va_arg(argptr, char *);
+                        {
+                            const wxChar *val = NULL;

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-                            // ASCII->Unicode constructor handles max_width right
-                            wxString s(val, wxConvLibc, max_width);
-#else
-                            size_t len = wxSTRING_MAXLEN;
-                            if (val) {
-                                for (len = 0; val[len] && (len<max_width); len++);
-                            } else val = wxT("(null)");
-                            wxString s(val, len);
+                            wxString s;
+
+                            if (ilen == -1)
+                            {
+                                // wx extension: we'll let %hs mean non-Unicode
+                                // strings
+                                char *v = va_arg(argptr, char *);
+
+                                if (v)
+                                    val = s = wxString(v, wxConvLibc);
+                            }
+                            else
+#elif wxUSE_WCHAR_T
+                            wxString s;
+
+                            if (ilen == 1)
+                            {
+                                // %ls means Unicode strings
+                                wchar_t *v = va_arg(argptr, wchar_t *);
+
+                                if (v)
+                                    val = s = wxString(v, wxConvLibc);
+                            }
+                            else

 #endif
 #endif

-                            if (s.Len() < min_width)
-                                s.Pad(min_width - s.Len(), wxT(' '), adj_left);
-
-                            APPEND_STR(s);
-                        } else {
-                            wxChar *val = va_arg(argptr, wxChar *);
-                            size_t len = wxSTRING_MAXLEN;
-                            if (val) {
-                                for (len = 0; val[len] && (len<max_width); len++);
-                            } else val = wxT("(null)");
-                            wxString s(val, len);
-                            if (s.Len() < min_width)
-                                s.Pad(min_width - s.Len(), wxT(' '), adj_left);
-
-                            APPEND_STR(s);
+                            {
+                                val = va_arg(argptr, wxChar *);
+                            }
+
+                            size_t len = 0;
+
+                            if (val)
+                            {
+                                for ( len = 0;
+                                      val[len] && (len < max_width);
+                                      len++ )
+                                    ;
+                            }
+                            else if (max_width >= 6)
+                            {
+                                val = wxT("(null)");
+                                len = 6;
+                            }
+                            else
+                            {
+                                val = wxT("");
+                                len = 0;
+                            }
+
+                            size_t i;
+
+                            if (!adj_left)
+                                for (i = len; i < min_width; i++)
+                                    APPEND_CH(_T(' '));
+
+                            for (i = 0; i < len; i++)
+                                APPEND_CH(val[i]);
+
+                            if (adj_left)
+                                for (i = len; i < min_width; i++)
+                                    APPEND_CH(_T(' '));
+
+                            done = TRUE;

                         }
                         }

-                        done = TRUE;

                         break;
 
                     case wxT('n'):
                         break;
 
                     case wxT('n'):

-                        if (ilen == 0) {
+                        if (ilen == 0)
+                        {

                             int *val = va_arg(argptr, int *);
                             *val = lenCur;
                         }
                             int *val = va_arg(argptr, int *);
                             *val = lenCur;
                         }

-                        else if (ilen == -1) {
+                        else if (ilen == -1)
+                        {

                             short int *val = va_arg(argptr, short int *);
                             *val = lenCur;
                         }
                             short int *val = va_arg(argptr, short int *);
                             *val = lenCur;
                         }

-                        else if (ilen >= 1) {
+                        else if (ilen >= 1)
+                        {

                             long int *val = va_arg(argptr, long int *);
                             *val = lenCur;
                         }
                             long int *val = va_arg(argptr, long int *);
                             *val = lenCur;
                         }


@@ -408,23 +541,23 @@ int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
                         break;
 
                     default:
                         break;
 
                     default:

-                        if (wxIsalpha(format[n]))
-                            // probably some flag not taken care of here yet
-                            s_szFlags[flagofs++] = format[n];
-                        else {
-                            // bad format
-                            APPEND_CH(_T('%')); // just to pass the glibc tst-printf.c
-                            n--;
-                            done = TRUE;
-                        }
+                        // bad format, leave unchanged
+                        APPEND_CH(_T('%'));
+                        APPEND_CH(ch);
+                        done = TRUE;

                         break;
                 }
                         break;
                 }

-            } while (!done);
+            }
+            while (!done);

         }
         else
         {
         }
         else
         {

-            APPEND_CH(format[n]);
+            APPEND_CH(chCur);

         }
         }

+
+        // terminating NUL?
+        if ( !chCur )
+            break;

     }
 
     return lenCur;
     }
 
     return lenCur;


@@ -450,27 +583,44 @@ 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
 // ----------------------------------------------------------------------------
 

-#ifdef wxNEED_FPUTWC
-
+#ifdef wxNEED_FPUTS

 int wxFputs(const wchar_t *ws, FILE *stream)
 {
     // counting the number of wide characters written isn't worth the trouble,
     // simply distinguish between ok and error
     return fputs(wxConvLibc.cWC2MB(ws), stream) == -1 ? -1 : 0;
 }
 int wxFputs(const wchar_t *ws, FILE *stream)
 {
     // counting the number of wide characters written isn't worth the trouble,
     // simply distinguish between ok and error
     return fputs(wxConvLibc.cWC2MB(ws), stream) == -1 ? -1 : 0;
 }

+#endif // wxNEED_FPUTS

 
 

+#ifdef wxNEED_PUTC

 int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream)
 {
     wchar_t ws[2] = { wc, L'\0' };
 
     return wxFputs(ws, stream);
 }
 int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream)
 {
     wchar_t ws[2] = { wc, L'\0' };
 
     return wxFputs(ws, stream);
 }

-
-#endif // wxNEED_FPUTWC
+#endif // wxNEED_PUTC

 
 // NB: we only implement va_list functions here, the ones taking ... are
 //     defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse
 
 // NB: we only implement va_list functions here, the ones taking ... are
 //     defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse


@@ -478,21 +628,21 @@ int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream)
 #ifdef wxNEED_WPRINTF
 
 // TODO: implement the scanf() functions
 #ifdef wxNEED_WPRINTF
 
 // TODO: implement the scanf() functions

-int vwscanf(const wchar_t *format, va_list argptr)
+int vwscanf(const wxChar *format, va_list argptr)

 {
     wxFAIL_MSG( _T("TODO") );
 
     return -1;
 }
 
 {
     wxFAIL_MSG( _T("TODO") );
 
     return -1;
 }
 

-int vswscanf(const wchar_t *ws, const wchar_t *format, va_list argptr)
+int vswscanf(const wxChar *ws, const wxChar *format, va_list argptr)

 {
     wxFAIL_MSG( _T("TODO") );
 
     return -1;
 }
 
 {
     wxFAIL_MSG( _T("TODO") );
 
     return -1;
 }
 

-int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
+int vfwscanf(FILE *stream, const wxChar *format, va_list argptr)

 {
     wxFAIL_MSG( _T("TODO") );
 
 {
     wxFAIL_MSG( _T("TODO") );
 


@@ -501,7 +651,7 @@ int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
 
 #define vswprintf wxVsnprintf_
 
 
 #define vswprintf wxVsnprintf_
 

-int vfwprintf(FILE *stream, const wchar_t *format, va_list argptr)
+int vfwprintf(FILE *stream, const wxChar *format, va_list argptr)

 {
     wxString s;
     int rc = s.PrintfV(format, argptr);
 {
     wxString s;
     int rc = s.PrintfV(format, argptr);


@@ -509,14 +659,14 @@ int vfwprintf(FILE *stream, const wchar_t *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.mb_str()) == -1 )
+        if ( fprintf(stream, "%s", (const char*)s.mb_str() ) == -1 )

             return -1;
     }
 
     return rc;
 }
 
             return -1;
     }
 
     return rc;
 }
 

-int vwprintf(const wchar_t *format, va_list argptr)
+int vwprintf(const wxChar *format, va_list argptr)

 {
     return wxVfprintf(stdout, format, argptr);
 }
 {
     return wxVfprintf(stdout, format, argptr);
 }


@@ -554,7 +704,7 @@ int vwprintf(const wchar_t *format, va_list argptr)
    So to use native functions in order to get our semantics we must do the
    following translations in Unicode mode (nothing to do in ANSI mode):
 
    So to use native functions in order to get our semantics we must do the
    following translations in Unicode mode (nothing to do in ANSI mode):
 

-   wxWindows specifier      POSIX specifier
+   wxWidgets specifier      POSIX specifier

    ----------------------------------------
 
    %hc, %C, %hC             %c
    ----------------------------------------
 
    %hc, %C, %hC             %c


@@ -624,10 +774,10 @@ private:
                ch == _T('0') || ch == _T(' ') || ch == _T('#');
     }
 
                ch == _T('0') || ch == _T(' ') || ch == _T('#');
     }
 

-    void SkipDigits(const wxChar **ppc)
+    void SkipDigits(const wxChar **ptpc)

     {
     {

-        while ( **ppc >= _T('0') && **ppc <= _T('9') )
-            CopyFmtChar(*(*ppc)++);
+        while ( **ptpc >= _T('0') && **ptpc <= _T('9') )
+            CopyFmtChar(*(*ptpc)++);

     }
 
     // the translated format
     }
 
     // the translated format


@@ -662,7 +812,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


@@ -709,23 +863,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++);
             }
         }


@@ -737,13 +882,21 @@ 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
 // ----------------------------------------------------------------------------
 
 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
 
 // ----------------------------------------------------------------------------
 // wxPrintf(), wxScanf() and relatives
 // ----------------------------------------------------------------------------
 
 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
 

-int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2
+int wxScanf( const wxChar *format, ... )

 {
     va_list argptr;
     va_start(argptr, format);
 {
     va_list argptr;
     va_start(argptr, format);


@@ -755,7 +908,7 @@ int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2
     return ret;
 }
 
     return ret;
 }
 

-int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
+int wxSscanf( const wxChar *str, const wxChar *format, ... )

 {
     va_list argptr;
     va_start(argptr, format);
 {
     va_list argptr;
     va_start(argptr, format);


@@ -767,11 +920,10 @@ int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
     return ret;
 }
 
     return ret;
 }
 

-int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
+int wxFscanf( FILE *stream, const wxChar *format, ... )

 {
     va_list argptr;
     va_start(argptr, format);
 {
     va_list argptr;
     va_start(argptr, format);

-

     int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
 
     va_end(argptr);
     int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
 
     va_end(argptr);


@@ -779,11 +931,11 @@ int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
     return ret;
 }
 
     return ret;
 }
 

-int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2
+int wxPrintf( const wxChar *format, ... )

 {
     va_list argptr;
     va_start(argptr, format);
 {
     va_list argptr;
     va_start(argptr, format);

-    
+

     int ret = vwprintf( wxFormatConverter(format), argptr );
 
     va_end(argptr);
     int ret = vwprintf( wxFormatConverter(format), argptr );
 
     va_end(argptr);


@@ -792,7 +944,7 @@ int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_2
 }
 
 #ifndef wxSnprintf
 }
 
 #ifndef wxSnprintf

-int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_4
+int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... )

 {
     va_list argptr;
     va_start(argptr, format);
 {
     va_list argptr;
     va_start(argptr, format);


@@ -805,20 +957,22 @@ int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_
 }
 #endif // wxSnprintf
 
 }
 #endif // wxSnprintf
 

-int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
+int wxSprintf( wxChar *str, const wxChar *format, ... )

 {
     va_list argptr;
     va_start(argptr, format);
 
 {
     va_list argptr;
     va_start(argptr, format);
 

-    // callers of wxSprintf() deserve what they get
-    int ret = vswprintf( str, UINT_MAX, wxFormatConverter(format), argptr );
+    // note that wxString::FormatV() uses wxVsnprintf(), not wxSprintf(), so
+    // it's safe to implement this one in terms of it
+    wxString s(wxString::FormatV(format, argptr));
+    wxStrcpy(str, s);

 
     va_end(argptr);
 
 
     va_end(argptr);
 

-    return ret;
+    return s.length();

 }
 
 }
 

-int wxFprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3
+int wxFprintf( FILE *stream, const wxChar *format, ... )

 {
     va_list argptr;
     va_start( argptr, format );
 {
     va_list argptr;
     va_start( argptr, format );


@@ -855,11 +1009,13 @@ 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
 

+#if wxUSE_WCHAR_T
+

 // ----------------------------------------------------------------------------
 // ctype.h stuff (currently unused)
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // ctype.h stuff (currently unused)
 // ----------------------------------------------------------------------------


@@ -874,7 +1030,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); }


@@ -887,15 +1043,26 @@ WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); }
 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
 #endif
 
 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
 #endif
 

-#ifndef wxStrdup
-WXDLLEXPORT wxChar * wxStrdup(const wxChar *psz)
+#ifndef wxStrdupA
+
+WXDLLEXPORT char *wxStrdupA(const char *s)
+{
+    return strcpy((char *)malloc(strlen(s) + 1), s);
+}
+
+#endif // wxStrdupA
+
+#ifndef wxStrdupW
+
+WXDLLEXPORT wchar_t * wxStrdupW(const wchar_t *pwz)

 {
 {

-  size_t size = (wxStrlen(psz) + 1) * sizeof(wxChar);
-  wxChar *ret = (wxChar *) malloc(size);
-  memcpy(ret, psz, size);
+  size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
+  wchar_t *ret = (wchar_t *) malloc(size);
+  memcpy(ret, pwz, size);

   return ret;
 }
   return ret;
 }

-#endif
+
+#endif // wxStrdupW

 
 #ifndef wxStricmp
 int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)
 
 #ifndef wxStricmp
 int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)


@@ -912,7 +1079,8 @@ int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)
 #ifndef wxStricmp
 int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
 {
 #ifndef wxStricmp
 int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
 {

-  register wxChar c1, c2;
+  // initialize the variables just to suppress stupid gcc warning
+  register wxChar c1 = 0, c2 = 0;

   while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
   if (n) {
     if (c1 < c2) return -1;
   while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
   if (n) {
     if (c1 < c2) return -1;


@@ -922,39 +1090,6 @@ int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
 }
 #endif
 
 }
 #endif
 

-#ifndef wxStrtok
-WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr)
-{
-    if (!psz)
-    {
-        psz = *save_ptr;
-        if ( !psz )
-            return NULL;
-    }
-
-    psz += wxStrspn(psz, delim);
-    if (!*psz)
-    {
-        *save_ptr = (wxChar *)NULL;
-        return (wxChar *)NULL;
-    }
-
-    wxChar *ret = psz;
-    psz = wxStrpbrk(psz, delim);
-    if (!psz)
-    {
-        *save_ptr = (wxChar*)NULL;
-    }
-    else
-    {
-        *psz = wxT('\0');
-        *save_ptr = psz + 1;
-    }
-
-    return ret;
-}
-#endif // wxStrtok
-

 #ifndef wxSetlocale
 WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
 {
 #ifndef wxSetlocale
 WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
 {


@@ -1168,7 +1303,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
 


@@ -1185,36 +1329,16 @@ long     WXDLLEXPORT wxAtol(const wxChar *psz)
 
 wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
 {
 
 wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
 {

-  static wxHashTable env;
-
-  // check if we already have stored the converted env var
-  wxObject *data = env.Get(name);
-  if (!data)
-  {
-    // nope, retrieve it,

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-    wxCharBuffer buffer = wxConvLocal.cWX2MB(name);
-    // printf( "buffer %s\n", (const char*) buffer );
-    const char *val = getenv( (const char *)buffer );
-#else
-    const char *val = getenv( name );
-#endif
-
-    if (!val) return (wxChar *)NULL;
-    // printf( "home %s\n", val );
-
-    // convert it,
-#ifdef wxUSE_UNICODE
-    data = (wxObject *)new wxString(val, wxConvLocal);
+    // NB: buffer returned by getenv() is allowed to be overwritten next
+    //     time getenv() is called, so it is OK to use static string
+    //     buffer to hold the data.
+    static wxWCharBuffer value((wxChar*)NULL);
+    value = wxConvLocal.cMB2WX(getenv(wxConvLocal.cWX2MB(name)));
+    return value.data();

 #else
 #else

-    data = (wxObject *)new wxString(val);
+    return getenv(name);

 #endif
 #endif

-
-    // and store it
-    env.Put(name, data);
-  }
-  // return converted env var
-  return (wxChar *)((wxString *)data)->c_str();

 }
 
 int WXDLLEXPORT wxSystem(const wxChar *psz)
 }
 
 int WXDLLEXPORT wxSystem(const wxChar *psz)


@@ -1222,7 +1346,7 @@ int WXDLLEXPORT wxSystem(const wxChar *psz)
     return system(wxConvLocal.cWX2MB(psz));
 }
 
     return system(wxConvLocal.cWX2MB(psz));
 }
 

-#endif
+#endif // wxNEED_WX_STDLIB_H

 
 #ifdef wxNEED_WX_TIME_H
 WXDLLEXPORT size_t   wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const struct tm *tm)
 
 #ifdef wxNEED_WX_TIME_H
 WXDLLEXPORT size_t   wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const struct tm *tm)


@@ -1244,4 +1368,98 @@ WXDLLEXPORT size_t   wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const
         return 0;
   }
 }
         return 0;
   }
 }

+#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
+
+// ----------------------------------------------------------------------------
+// functions which we may need even if !wxUSE_WCHAR_T
+// ----------------------------------------------------------------------------
+
+#ifndef wxStrtok
+
+WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr)
+{
+    if (!psz)
+    {
+        psz = *save_ptr;
+        if ( !psz )
+            return NULL;
+    }
+
+    psz += wxStrspn(psz, delim);
+    if (!*psz)
+    {
+        *save_ptr = (wxChar *)NULL;
+        return (wxChar *)NULL;
+    }
+
+    wxChar *ret = psz;
+    psz = wxStrpbrk(psz, delim);
+    if (!psz)
+    {
+        *save_ptr = (wxChar*)NULL;
+    }
+    else
+    {
+        *psz = wxT('\0');
+        *save_ptr = psz + 1;
+    }
+
+    return ret;
+}
+
+#endif // wxStrtok
+
+// ----------------------------------------------------------------------------
+// missing C RTL functions
+// ----------------------------------------------------------------------------
+
+#if (defined(__MWERKS__) && !defined(__MACH__) && (__MSL__ < 0x00008000)) || \
+     defined(__WXWINCE__)
+char *strdup(const char *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 )
+{
+    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
+
+int isspace(int c)
+{
+    return (c == ' ');
+}
+
+#endif
+