stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r374551 - /incubator/stdcxx/trunk/include/ansi/cwchar
Date Fri, 03 Feb 2006 00:42:01 GMT
Author: sebor
Date: Thu Feb  2 16:41:58 2006
New Revision: 374551

URL: http://svn.apache.org/viewcvs?rev=374551&view=rev
Log:
2006-02-02  Martin Sebor  <sebor@roguewave.com>

	STDCXX-129
	* cwchar: Consistently introduced all function declarations into
	the global scope first, before injecting each into namespace std
	via a using declaration.

Modified:
    incubator/stdcxx/trunk/include/ansi/cwchar

Modified: incubator/stdcxx/trunk/include/ansi/cwchar
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/include/ansi/cwchar?rev=374551&r1=374550&r2=374551&view=diff
==============================================================================
--- incubator/stdcxx/trunk/include/ansi/cwchar (original)
+++ incubator/stdcxx/trunk/include/ansi/cwchar Thu Feb  2 16:41:58 2006
@@ -84,18 +84,10 @@
 
 #if !defined (_RWSTD_NO_USING_LIBC_IN_STD)
 
-// FIXME: when NOT introducing names into namespace std via using
-// declarations but instead by declaring or defining them, all such
-// names should be declared in the global namespace and only then
-// introduced into namespace std by a using declaration for
-// consistency with the others; otherwise #include <wchar.h> will
-// bring in a mix of names, some in namespace std and others in
-// the global namespace
-
 namespace std {
 
 #ifndef _RWSTD_NO_SIZE_T
-    using ::size_t;
+using ::size_t;
 #elif defined (_RWSTD_SIZE_T)
     typedef _RWSTD_SIZE_T size_t;
 #endif   // _RWSTD_NO_SIZE_T
@@ -107,13 +99,13 @@
 #endif   // _RWSTD_NO_STD_MBSTATE_T
 
 #ifndef _RWSTD_NO_WINT_T
-    using ::wint_t;
+using ::wint_t;
 #elif defined (_RWSTD_WINT_T)
     typedef _RWSTD_WINT_T wint_t;
 #endif   // _RWSTD_NO_WINT_T
 
 #ifndef _RWSTD_NO_STRUCT_TM_IN_WCHAR_H
-    using ::tm;
+using ::tm;
 #elif !defined (_RWSTD_NO_TM)
 
 }   // namespace std
@@ -125,428 +117,976 @@
 #endif   // NO_STRUCT_TM
 
 #ifndef _RWSTD_NO_BTOWC
-    using ::btowc;
+using ::btowc;
+#elif !defined (_RWSTD_NO_BTOWC_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wint_t btowc (int);
+
+namespace std {
+
+using ::btowc;
+
+#  undef _RWSTD_NO_BTOWC
 #endif   // _RWSTD_NO_BTOWC
 
 #ifndef _RWSTD_NO_FGETWC
-    using ::fgetwc;
-#endif   // _RWSTD_NO_FGETWC
+using ::fgetwc;
+#elif !defined (_RWSTD_NO_FGETWC_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wint_t fgetwc (FILE*);
+
+namespace std {
+
+using ::fgetwc;
+
+#  undef _RWSTD_NO_FGETWC
+#endif   // _RWSTD_NO_FGETWC[_IN_LIBC]
+
+#ifndef _RWSTD_NO_FGETWS
+using ::fgetws;
+#elif !defined (_RWSTD_NO_FGETWS_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wchar_t fgetws (wchar_t*, int, FILE*);
+
+namespace std {
+
+using ::fgetws;
+
+#  undef _RWSTD_NO_FGETWS
+#endif   // _RWSTD_NO_FGETWS[_IN_LIBC]
+
+#ifndef _RWSTD_NO_FPUTWC
+using ::fputwc;
+#elif !defined (_RWSTD_NO_FPUTWC_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wint_t fputwc (wint_t, FILE*);
+
+namespace std {
+
+using ::fputwc;
+
+#  undef _RWSTD_NO_FPUTWC
+#endif   // _RWSTD_NO_FPUTWC[_IN_LIBC]
+
+#ifndef _RWSTD_NO_FPUTWS
+using ::fputws;
+#elif !defined (_RWSTD_NO_FPUTWS_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int fputws (const wchar_t*, FILE*);
+
+namespace std {
+
+using ::fputws;
+
+#  undef _RWSTD_NO_FPUTWS
+#endif   // _RWSTD_NO_FPUTWS[_IN_LIBC]
+
+#ifndef _RWSTD_NO_FWIDE
+using ::fwide;
+#elif !defined (_RWSTD_NO_FWIDE_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int fwide (FILE*, int);
+
+namespace std {
+
+using ::fwide;
+
+#  undef _RWSTD_NO_FWIDE
+#endif   // _RWSTD_NO_FWIDE[_IN_LIBC]
+
+#ifndef _RWSTD_NO_FWPRINTF
+using ::fwprintf;
+#elif !defined (_RWSTD_NO_FWPRINTF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int fwprintf (FILE*, const wchar_t*, ...);
+
+namespace std {
+
+using ::fwprintf;
+
+#  undef _RWSTD_NO_FWPRINTF
+#endif   // _RWSTD_NO_FWPRINTF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_FWSCANF
+using ::fwscanf;
+#elif !defined (_RWSTD_NO_FWSCANF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int fwscanf (FILE*, const wchar_t*, ...);
+
+namespace std {
+
+using ::fwscanf;
+
+#  undef _RWSTD_NO_FWSCANF
+#endif   // _RWSTD_NO_FWSCANF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_GETWC
+using ::getwc;
+#elif !defined (_RWSTD_NO_GETWC_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wint_t getwc (FILE*);
+
+namespace std {
+
+using ::getwc;
+
+#  undef _RWSTD_NO_GETWC
+#endif   // _RWSTD_NO_GETWC[_IN_LIBC]
+
+#ifndef _RWSTD_NO_PUTWC
+using ::putwc;
+#elif !defined (_RWSTD_NO_PUTWC_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wint_t putwc (wint_t, FILE*);
+
+namespace std {
+
+using ::putwc;
+
+#  undef _RWSTD_NO_PUTWC
+#endif   // _RWSTD_NO_PUTWC[_IN_LIBC]
+
+#ifndef _RWSTD_NO_GETWCHAR
+using ::getwchar;
+#elif !defined (_RWSTD_NO_GETWCHAR_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wint_t getwchar ();
+
+namespace std {
+
+using ::getwchar;
+
+#  undef _RWSTD_NO_GETWCHAR
+#endif   // _RWSTD_NO_GETWCHAR[_IN_LIBC]
+
+#ifndef _RWSTD_NO_PUTWCHAR
+using ::putwchar;
+#elif !defined (_RWSTD_NO_PUTWCHAR_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wint_t putwchar (wint_t);
+
+namespace std {
+
+using ::putwchar;
+
+#  undef _RWSTD_NO_PUTWCHAR
+#endif   // _RWSTD_NO_PUTWCHAR[_IN_LIBC]
+
+#ifndef _RWSTD_NO_SWPRINTF
+using ::swprintf;
+#elif !defined (_RWSTD_NO_SWPRINTF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int swprintf (wchar_t*, size_t, const wchar_t*, ...);
+
+namespace std {
+
+using ::swprintf;
+
+#  undef _RWSTD_NO_SWPRINTF
+#endif   // _RWSTD_NO_SWPRINTF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_SWSCANF
+using ::swscanf;
+#elif !defined (_RWSTD_NO_SWSCANF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int swscanf (const wchar_t*, const wchar_t*, ...);
+
+namespace std {
+
+using ::swscanf;
+
+#  undef _RWSTD_NO_SWSCANF
+#endif   // _RWSTD_NO_SWSCANF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_UNGETWC
+using ::ungetwc;
+#elif !defined (_RWSTD_NO_UNGETWC_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wint_t ungetwc (wint_t, FILE*);
+
+namespace std {
+
+using ::ungetwc;
+
+#  undef _RWSTD_NO_UNGETWC
+#endif   // _RWSTD_NO_UNGETWC[_IN_LIBC]
+
+#ifndef _RWSTD_NO_VFWPRINTF
+using ::vfwprintf;
+#elif !defined (_RWSTD_NO_VFWPRINTF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int vfwprintf (FILE*, const wchar_t *format, _RWSTD_VA_LIST);
+
+namespace std {
+
+using ::vfwprintf;
+
+#  undef _RWSTD_NO_VFWPRINTF
+#endif   // _RWSTD_NO_VFWPRINTF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_VSWPRINTF
+using ::vswprintf;
+#elif !defined (_RWSTD_NO_VSWPRINTF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int vswprintf (wchar_t*, size_t, const wchar_t*, _RWSTD_VA_LIST);
+
+namespace std {
+
+using ::vswprintf;
+
+#  undef _RWSTD_NO_VSWPRINTF
+#endif   // _RWSTD_NO_VSWPRINTF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_VWPRINTF
+using ::vwprintf;
+#elif !defined (_RWSTD_NO_VWPRINTF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int vwprintf (const wchar_t*, _RWSTD_VA_LIST);
+
+namespace std {
+
+using ::vwprintf;
+
+#  undef _RWSTD_NO_VWPRINTF
+#endif   // _RWSTD_NO_VWPRINTF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_WPRINTF
+using ::wprintf;
+#elif !defined (_RWSTD_NO_WPRINTF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int wprintf (const wchar_t*, ...);
+
+namespace std {
+
+using ::wprintf;
+
+#  undef _RWSTD_NO_WPRINTF
+#endif   // _RWSTD_NO_WPRINTF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_WSCANF
+using ::wscanf;
+#elif !defined (_RWSTD_NO_WSCANF_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int wscanf (const wchar_t*, ...);
+
+namespace std {
+
+using ::wscanf;
+
+#  undef _RWSTD_NO_WSCANF
+#endif   // _RWSTD_NO_WSCANF[_IN_LIBC]
+
+#ifndef _RWSTD_NO_MBRLEN
+using ::mbrlen;
+#elif !defined (_RWSTD_NO_MBRLEN_IN_LIBC)
+
+}   // namespace std
+
+extern "C" size_t mbrlen (const char*, size_t, mbstate_t*);
+
+namespace std {
+
+using ::mbrlen;
+
+#  undef _RWSTD_NO_MBRLEN
+#endif   // _RWSTD_NO_MBRLEN
+
+#ifndef _RWSTD_NO_MBRTOWC
+using ::mbrtowc;
+#elif !defined (_RWSTD_NO_MBRTOWC_IN_LIBC)
+
+}   // namespace std
+
+extern "C" size_t mbrtowc (wchar_t*, const char*, size_t, mbstate_t*);
+
+namespace std {
+
+using ::mbrtowc;
+
+#  undef _RWSTD_MBRTOWC
+#endif   // _RWSTD_MBRTOWC[_IN_LIBC]
+
+#ifndef _RWSTD_NO_MBSINIT
+using ::mbsinit;
+#elif !defined (_RWSTD_NO_MBSINIT_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int mbsinit (const mbstate_t*);
+
+namespace std {
+
+using ::mbsinit;
+
+#  undef _RWSTD_NO_MBSINIT
+#endif   // !_RWSTD_NO_MBSINIT_IN_LIBC
+
+#ifndef _RWSTD_NO_MBSRTOWCS
+using ::mbsrtowcs;
+#elif !defined (_RWSTD_NO_MBSRTOWCS_IN_LIBC)
+
+}   // namespace std
+
+extern "C" size_t mbsrtowcs (wchar_t*, const char**, size_t, mbstate_t*);
+
+namespace std {
+
+using ::mbsrtowcs;
+
+#  undef _RWSTD_NO_MBSRTOWCS
+#endif    // _RWSTD_NO_MBSRTOWCS
+
+#ifndef _RWSTD_NO_WCRTOMB
+using ::wcrtomb;
+#elif !defined (_RWSTD_NO_WCRTOMB_IN_LIBC)
+
+}   // namespace std
+
+extern "C" size_t wcrtomb (char*, wchar_t, mbstate_t*);
+
+namespace std {
+
+using ::wcrtomb;
+
+#  undef _RWSTD_NO_WCRTOMB
+#endif   // _RWSTD_NO_WCRTOMB
+
+#ifndef _RWSTD_NO_WCSCAT
+using ::wcscat;
+#elif !defined (_RWSTD_NO_WCSCAT_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wchar_t* wcscat (wchar_t*, const wchar_t*);
+
+namespace std {
+
+using ::wcscat;
+
+#else   // if defined (_RWSTD_NO_WCSCAT)
+
+}   // namespace std
+
+extern "C" inline wchar_t* wcscat (wchar_t *__dst, const wchar_t *__src)
+{
+    wchar_t *__s = __dst;
+    for (; *__s; ++__s);
+    while ((*__s++ = *__src++));
+    return __dst;
+}
+
+namespace std {
+
+using ::wcscat;
+
+#endif   // _RWSTD_NO_WCSCAT
+
+#undef _RWSTD_NO_WCSCAT
+
+
+#ifndef _RWSTD_NO_WCSCHR
+using ::wcschr;
+#elif !defined (_RWSTD_NO_WCSCHR_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wchar_t* wcschr (wchar_t*, wchar_t);
+
+inline const wchar_t* wcschr (const wchar_t *__s, wchar_t __c)
+{
+    return wcschr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);
+}
+
+namespace std {
+
+using ::wcschr;
+
+#else   // if defined (_RWSTD_NO_WCSCHR)
+
+}   // namespace std
+
+extern "C" {
+
+inline wchar_t* wcschr (wchar_t *__s, wchar_t __c)
+{
+    do {
+        if (*__s == __c)
+            return __s;
+    } while (*__s);
+    return 0;
+}
+
+}   // extern "C"
+
+inline const wchar_t* wcschr (const wchar_t *__s, wchar_t __c)
+{
+    return wcschr (_RWSTD_CONST_CAST (wchar_t*, __s, __c);
+}
+
+namespace std {
+
+using ::wcschr;
+
+#endif   // _RWSTD_NO_WCSCHR
+
+#undef _RWSTD_NO_WCSCHR
+
+
+#ifndef _RWSTD_NO_WCSCMP
+using ::wcscmp;
+#elif !defined (_RWSTD_NO_WCSCMP_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int wcscmp (const wchar_t*, const wchar_t*);
+
+namespace std {
+
+using ::wcscmp;
+
+#  undef _RWSTD_NO_WCSCMP
+#endif   // _RWSTD_NO_WCSCMP
+
+#ifndef _RWSTD_NO_WCSCOLL
+using ::wcscoll;
+#elif !defined (_RWSTD_NO_WCSCOLL_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int wcscoll (const wchar_t*, const wchar_t*);
+
+namespace std {
+
+using ::wcscoll;
+
+#  undef _RWSTD_NO_WCSCOLL
+#endif   // _RWSTD_NO_WCSCOLL
+
+#ifndef _RWSTD_NO_WCSCPY
+using ::wcscpy;
+#else   // if defined (_RWSTD_NO_WCSCPY)
+
+}   // namespace std
+
+extern "C" inline wchar_t* wcscpy (wchar_t *__dst, const wchar_t *__src)
+{
+    for (wchar_t *__s = __dst; (*__s++ = *__src++); );
+    return __dst;
+}
+
+namespace std {
+
+using ::wcscpy
+
+#  undef _RWSTD_NO_WCSCPY
+#endif   // _RWSTD_NO_WCSCPY
+
+
+#ifndef _RWSTD_NO_WCSCSPN
+using ::wcscspn;
+#elif !defined (_RWSTD_NO_WCSCSPN_IN_LIBC)
+
+}   // namespace std
+
+extern "C" size_t wcscspn (const wchar_t*, const wchar_t*);
+
+namespace std {
+
+using ::wcscspn;
+
+#  undef _RWSTD_NO_WCSCSPN
+#else
+
+}   // namespace std
+
+extern "C" {
+
+inline size_t wcscspn (const wchar_t *__s1, const wchar_t *__s2)
+{
+    const wchar_t *__s = __s1;
+    for (; *__s; ++__s) {
+        for (const wchar_t *__ss = __s2; *__ss; ++__ss)
+            if (*__ss == *__s)
+                return __s - __s1;
+    }
+    return __s - __s1;
+}
+
+}   // extern "C"
+
+namespace std {
+
+using wcscspn;
+
+#  undef _RWSTD_NO_WCSCSPN
+#endif   // _RWSTD_NO_WCSCSPN
+
+#ifndef _RWSTD_NO_WCSFTIME
+using ::wcsftime;
+#elif !defined (_RWSTD_NO_WCSFTIME_IN_LIBC)
+
+}   // namespace std
+
+extern "C" size_t wcsftime (wchar_t*, size_t, const wchar_t*, const struct tm*);
+
+namespace std {
+
+using ::wcsftime
+
+#endif   // _RWSTD_NO_WCSFTIME
+
+
+#ifndef _RWSTD_NO_WCSLEN
+using ::wcslen;
+#elif !defined (_RWSTD_NO_WCSLEN_IN_LIBC)
+
+}   // namespace std
+
+extern "C" size_t wcslen (const wchar_t*);
+
+namespace std {
+
+using ::wcslen;
+
+#  undef _RWSTD_NO_WCSLEN
+#else   // defined (_RWSTD_NO_WCSLEN)
+
+}   // namespace std
+
+extern "C" {
+
+inline size_t wcslen (const wchar_t* __s)
+{
+    const wchar_t *__begin = __s;
+    while (*__s)
+        ++__s;
+    return __s - __begin;
+}
+
+}   // extern "C"
+
+namespace std {
+
+using ::wcslen;
+
+#  undef _RWSTD_NO_WCSLEN
+#endif   // _RWSTD_NO_WCSLEN
+
+
+#ifndef _RWSTD_NO_WCSNCAT
+using ::wcsncat;
+#elif !defined (_RWSTD_NO_WCSNCAT_IN_LIBC)
+
+}   // namespace std
+
+extern "C" wchar_t* wcsncat (wchar_t*, const wchar_t*, size_t);
+
+namespace std {
+
+using ::wcsncat;
+
+#  undef _RWSTD_NO_WCSNCAT
+#else
+
+}   // namespace std
+
+extern "C" {
+
+inline wchar_t* wcsncat (wchar_t *__dst, const wchar_t *__src, size_t __n)
+{
+    wchar_t *__s = __dst;
+    for (; *__s; ++__s);
+    while (__n--)
+        if (!(*__s++ = *__src++))
+            return __dst;
+    *__s = 0;
+    return __dst;
+}
+
+}   // extern "C"
+
+namespace std {
+
+using ::wcsncat;
+
+#  undef _RWSTD_NO_WCSNCAT
+#endif   // _RWSTD_NO_WCSNCAT
+
+#ifndef _RWSTD_NO_WCSNCMP
+using ::wcsncmp;
+#elif !defined (_RWSTD_NO_WCSNCMP_IN_LIBC)
+
+}   // namespace std
+
+extern "C" int wcsncmp (const wchar_t*, const wchar_t*, size_t);
+
+namespace std {
+
+using ::wcsncmp;
+
+#  undef _RWSTD_NO_WCSNCMP
+#else
+
+}   // namespace std
+
+extern "C" {
+
+inline int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+{
+    if (!__n)
+        return 0;
+    for (; --__n && *__s1 && *__s1 == *__s2; ++__s1, ++__s2);
+    return int (*__s1 - *__s2);
+}
+
+}   // extern "C"
+
+namespace std {
+
+using ::wcsncmp;
+
+#  undef _RWSTD_NO_WCSNCMP
+#endif   // _RWSTD_NO_WCSNCMP
+
+
+#ifndef _RWSTD_NO_WCSNCPY
+using ::wcsncpy;
+#elif !defined (_RWSTD_NO_WCSNCPY_IN_LIBC)
 
-#ifndef _RWSTD_NO_FGETWS
-    using ::fgetws;
-#endif   // _RWSTD_NO_FGETWS
+}   // namespace std
 
-#ifndef _RWSTD_NO_FPUTWC
-    using ::fputwc;
-#endif   // _RWSTD_NO_FPUTWC
+extern "C" wchar_t* wcsncpy (wchar_t*, const wchar_t*, size_t);
 
-#ifndef _RWSTD_NO_FPUTWS
-    using ::fputws;
-#endif   // _RWSTD_NO_FPUTWS
+namespace std {
 
-#ifndef _RWSTD_NO_FWIDE
-    using ::fwide;
-#endif   // _RWSTD_NO_FWIDE
+using ::wcsncpy;
 
-#ifndef _RWSTD_NO_FWPRINTF
-    using ::fwprintf;
-#endif   // _RWSTD_NO_FWPRINTF
+#  undef _RWSTD_NO_WCSNCPY
+#else   // if defined (_RWSTD_NO_WCSNCPY)
 
-#ifndef _RWSTD_NO_FWSCANF
-    using ::fwscanf;
-#endif   // _RWSTD_NO_FWSCANF
+}   // namespace std
 
-#ifndef _RWSTD_NO_GETWC
-    using ::getwc;
-#endif   // _RWSTD_NO_GETWC
+extern "C" {
 
-#ifndef _RWSTD_NO_PUTWC
-    using ::putwc;
-#endif   // _RWSTD_NO_PUTWC
+inline wchar_t* wcsncpy (wchar_t *__dst, const wchar_t *__src, size_t __n)
+{
+    wchar_t *__s = __dst;
+    for (; __n && (*__s++ = *__src++); --__n);
+    while (__n--)
+        *__s = 0;
+    return __dst;
+}
 
-#ifndef _RWSTD_NO_GETWCHAR
-    using ::getwchar;
-#endif   // _RWSTD_NO_GETWCHAR
+}   // extern "C"
 
-#ifndef _RWSTD_NO_PUTWCHAR
-    using ::putwchar;
-#endif   // _RWSTD_NO_PUTWCHAR
+namespace std {
 
-#ifndef _RWSTD_NO_SWPRINTF
-    using ::swprintf;
-#endif   // _RWSTD_NO_SWPRINTF
+using ::wcsncpy;
 
-#ifndef _RWSTD_NO_SWSCANF
-    using ::swscanf;
-#endif   // _RWSTD_NO_SWSCANF
+#  undef _RWSTD_NO_WCSNCPY
+#endif   // _RWSTD_NO_WCSNCPY
 
-#ifndef _RWSTD_NO_UNGETWC
-    using ::ungetwc;
-#endif   // _RWSTD_NO_UNGETWC
 
-#ifndef _RWSTD_NO_VFWPRINTF
-    using ::vfwprintf;
-#endif   // _RWSTD_NO_VFWPRINTF
+#ifndef _RWSTD_NO_WCSPBRK
+using ::wcspbrk;
+#elif !defined (_RWSTD_NO_WCSPBRK_IN_LIBC)
 
-#ifndef _RWSTD_NO_VSWPRINTF
-    using ::vswprintf;
-#endif   // _RWSTD_NO_VSWPRINTF
+}   // namespace std
 
-#ifndef _RWSTD_NO_VWPRINTF
-    using ::vwprintf;
-#endif   // _RWSTD_NO_VWPRINTF
+extern "C" wchar_t* wcspbrk (wchar_t*, const wchar_t*);
 
-#ifndef _RWSTD_NO_WPRINTF
-    using ::wprintf;
-#endif   // _RWSTD_NO_WPRINTF
+inline const wchar_t* wcspbrk (const wchar_t *__s1, const wchar_t *__s2)
+{
+    return wcspbrk (_RWSTD_CONST_CAST (wchar_t*, __s1), __s2);
+}
 
-#ifndef _RWSTD_NO_WSCANF
-    using ::wscanf;
-#endif   // _RWSTD_NO_WSCANF
+namespace std {
 
-#ifndef _RWSTD_NO_MBRLEN
-    using ::mbrlen;
-#else // defined _RWSTD_NO_MBRLEN 
-#  ifndef _RWSTD_NO_MBRLEN_IN_LIBC
-    extern "C" size_t mbrlen (const char*, size_t, mbstate_t*);
-#  endif // _RWSTD_NO_MBRLEN_IN_LIBC
-#endif   // _RWSTD_NO_MBRLEN
+using ::wcspbrk;
 
-#ifndef _RWSTD_NO_MBRTOWC
-    using ::mbrtowc;
-#else // defined _RWSTD_NO_MBRTOWC
-#  ifndef _RWSTD_NO_MBRTOWC_IN_LIBC
-    extern "C" size_t mbrtowc (wchar_t*, const char*, size_t, mbstate_t*);
-#  endif // _RWSTD_NO_MBRTOWC_IN_LIBC
-#endif   // _RWSTD_MBRTOWC
+#  undef _RWSTD_NO_WCSPBRK
+#endif   // _RWSTD_NO_WCSPBRK
 
-#ifndef _RWSTD_NO_MBSINIT
-    using ::mbsinit;
-#elif !defined (_RWSTD_NO_MBSINIT_IN_LIBC)
-    extern "C" int mbsinit (const mbstate_t*);
-#endif   // !_RWSTD_NO_MBSINIT_IN_LIBC
 
-#ifndef _RWSTD_NO_MBSRTOWCS
-    using ::mbsrtowcs;
-#else // defined _RWSTD_NO_MBSRTOWCS
-#  ifndef _RWSTD_NO_MBSRTOWCS_IN_LIBC
-    extern "C" size_t mbsrtowcs (wchar_t*, const char**, size_t, mbstate_t*);
-#  endif  // _RWSTD_NO_MBSRTOWCS_IN_LIBC
-#endif    // _RWSTD_NO_MBSRTOWCS
+#ifndef _RWSTD_NO_WCSRCHR
+using ::wcsrchr;
+#elif !defined (_RWSTD_NO_WCSRCHR_IN_LIBC)
 
-#ifndef _RWSTD_NO_WCRTOMB
-    using ::wcrtomb;
-#else // defined _RWSTD_NO_WCRTOMB
-#  ifndef _RWSTD_NO_WCRTOMB_IN_LIBC
-    extern "C" size_t wcrtomb (char*, wchar_t, mbstate_t*);
-#  endif // _RWSTD_NO_WCRTOMB_IN_LIBC
-#endif   // _RWSTD_NO_WCRTOMB
+}   // namespace std
 
-#ifndef _RWSTD_NO_WCSCAT
-    using ::wcscat;
-#elif !defined (_RWSTD_NO_WCSCAT_IN_LIBC)
-    extern "C" wchar_t* wcscat (wchar_t*, const wchar_t*);
-#else   // if defined (_RWSTD_NO_WCSCAT)
+extern "C" const wchar_t* wcsrchr (const wchar_t*, wchar_t);
 
-    inline wchar_t* wcscat (wchar_t *__dst, const wchar_t *__src)
-    {
-        wchar_t *__s = __dst;
-        for (; *__s; ++__s);
-        while ((*__s++ = *__src++));
-        return __dst;
-    }
+wchar_t* wcsrchr (wchar_t *__s, wchar_t __c)
+{
+    return wcsrchr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);
+}
 
-#endif   // _RWSTD_NO_WCSCAT
+namespace std {
 
-#undef _RWSTD_NO_WCSCAT
+using ::wcsrchr;
 
+#  undef _RWSTD_NO_WCSRCHR
+#else   // if defined (_RWSTD_NO_WCSRCHR)
 
-#ifndef _RWSTD_NO_WCSCHR
-    using ::wcschr;
-#elif !defined (_RWSTD_NO_WCSCHR_IN_LIBC)
+}   // namespace std
 
-    extern "C" wchar_t* wcschr (wchar_t*, wchar_t);
+extern "C" {
 
+inline wchar_t* wcsrchr (wchar_t *__s, wchar_t __c)
+{
+    const wchar_t *__ss = __s;
+    while (*__ss++);
+    while (--__ss != __s && *__ss != __c);
+    return *__ss == __c ? __ss : 0;
+}
 
-    inline const wchar_t* wcschr (const wchar_t *__s, wchar_t __c)
-    {
-        return wcschr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);
-    }
-    
-#else   // if defined (_RWSTD_NO_WCSCHR)
+}   // extern "C"
 
-    inline const wchar_t* wcschr (const wchar_t *__s, wchar_t __c)
-    {
-        do {
-            if (*__s == __c)
-                return __s;
-        } while (*__s);
-        return 0;
-    }
+inline const wchar_t* wcsrchr (const wchar_t *__s, wchar_t __c)
+{
+    return wcsrchr (_WRSTD_CONST_CAST (wchar_t*, __s), __c);
+}
 
-    inline wchar_t* wcschr (wchar_t *__s, wchar_t __c)
-    {
-        return _RWSTD_CONST_CAST (wchar_t*,
-                                  (wcschr ((const wchar_t*)__s, __c)));
-    }
+}   // extern "C"
 
-#endif   // _RWSTD_NO_WCSCHR
+namespace std {
 
-#undef _RWSTD_NO_WCSCHR
+using ::wcsrchr;
 
+#  undef _RWSTD_NO_WCSRCHR
+#endif   // _RWSTD_NO_WCSRCHR
 
-#ifndef _RWSTD_NO_WCSCMP
-    using ::wcscmp;
-#else   // if defined (_RWSTD_NO_WCSCMP)
-#endif   // _RWSTD_NO_WCSCMP
 
-#ifndef _RWSTD_NO_WCSCOLL
-    using ::wcscoll;
-#else   // if defined (_RWSTD_NO_WCSCOLL)
-#endif   // _RWSTD_NO_WCSCOLL
+#ifndef _RWSTD_NO_WCSRTOMBS
+using ::wcsrtombs;
+#elif !defined (_RWSTD_NO_WCSRTOMBS_IN_LIBC)
 
-#ifndef _RWSTD_NO_WCSCPY
-    using ::wcscpy;
-#else   // if defined (_RWSTD_NO_WCSCPY)
+}   // namespace std
 
-    inline wchar_t* wcscpy (wchar_t *__dst, const wchar_t *__src)
-    {
-        for (wchar_t *__s = __dst; (*__s++ = *__src++); );
-        return __dst;
-    }
+extern "C" size_t wcsrtombs (char*, const wchar_t**, size_t, mbstate_t*);
 
-#endif   // _RWSTD_NO_WCSCPY
+namespace std {
 
-#undef _RWSTD_NO_WCSCPY
+using ::wcsrtombs;
 
+#  undef _RWSTD_NO_WCSRTOMBS
+#endif   // _RWSTD_NO_WCSRTOMBS
 
-#ifndef _RWSTD_NO_WCSCSPN
-    using ::wcscspn;
-#else   // if defined (_RWSTD_NO_WCSCSPN)
+#ifndef _RWSTD_NO_WCSSPN
+using ::wcsspn;
+#else
 
-    inline size_t wcscspn (const wchar_t *__s1, const wchar_t *__s2)
-    {
-        const wchar_t *__s = __s1;
-        for (; *__s; ++__s) {
-            for (const wchar_t *__ss = __s2; *__ss; ++__ss)
-                if (*__ss == *__s)
-                    return __s - __s1;
-        }
-        return __s - __s1;
-    }
+}   // namespace std
 
-#endif   // _RWSTD_NO_WCSCSPN
+extern "C" {
 
-#ifndef _RWSTD_NO_WCSFTIME
-    using ::wcsftime;
-#endif   // _RWSTD_NO_WCSFTIME
+inline size_t wcsspn (const wchar_t *__s1, const wchar_t *__s2)
+{
+    const wchar_t *__s = __s1;
+    for (; *__s; ++__s) {
+        for (const wchar_t *__ss = __s2; *__ss != *__s; ++__ss)
+            if (!*__ss)
+                return __s - __s1;
+    }
+    return __s - __s1;
+}
 
+}   // extern "C"
 
-#ifndef _RWSTD_NO_WCSLEN
-    using ::wcslen;
-#elif !defined (_RWSTD_NO_WCSLEN_IN_LIBC)
-    extern "C" size_t wcslen (const wchar_t*);
-#else   // defined (_RWSTD_NO_WCSLEN)
+namespace std {
 
-    extern "C" {
+using ::wcsspn;
 
-    inline size_t wcslen (const wchar_t* __s)
-    {
-        const wchar_t *__begin = __s;
-        while (*__s)
-            ++__s;
-        return __s - __begin;
-    }
+#  undef _RWSTD_NO_WCSSPN
+#endif   // _RWSTD_NO_WCSSPN
 
-    }
+#ifndef _RWSTD_NO_WCSSTR
+using ::wcsstr;
+#elif !defined (_RWSTD_NO_WCSSTR_IN_LIBC)
 
-#endif   // _RWSTD_NO_WCSLEN
+}   // namespace std
 
-#undef _RWSTD_NO_WCSLEN
+extern "C" wchar_t* wcsstr (wchar_t*, const wchar_t*);
 
+inline const wchar_t* wcsstr (const wchar_t *__s1, const wchar_t *__s2)
+{
+    return wcsstr (_RWSTD_CONST_CAST (wchar_t*, __s1), __s2);
+}
 
-#ifndef _RWSTD_NO_WCSNCAT
-    using ::wcsncat;
-#else   // if defined (_RWSTD_NO_WCSNCAT)
+namespace std {
 
-    inline wchar_t* wcsncat (wchar_t *__dst, const wchar_t *__src, size_t __n)
-    {
-        wchar_t *__s = __dst;
-        for (; *__s; ++__s);
-        while (__n--)
-            if (!(*__s++ = *__src++))
-                return __dst;
-        *__s = 0;
-        return __dst;
-    }
+using ::wcsstr;
 
-#endif   // _RWSTD_NO_WCSNCAT
+#  undef _RWSTD_NO_WCSSTR
+#else
 
-#ifndef _RWSTD_NO_WCSNCMP
-    using ::wcsncmp;
-#elif !defined (_RWSTD_NO_WCSNCMP_IN_LIBC)
-    extern "C" int wcsncmp (const wchar_t*, const wchar_t*, size_t);
-#else   // if defined (_RWSTD_NO_WCSNCMP)
+#  ifdef _RWSTD_OS_HPUX
 
-    inline int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
-    {
-        if (!__n)
-            return 0;
-        for (; --__n && *__s1 && *__s1 == *__s2; ++__s1, ++__s2);
-        return int (*__s1 - *__s2);
-    }
+}   // namespace std
 
-#endif   // _RWSTD_NO_WCSNCMP
+extern "C" {
 
-#undef _RWSTD_NO_WCSNCMP
+inline wchar_t* wcsstr (wchar_t *__s1, const wchar_t *__s2)
+{
+    return wcswcs (__s1, __s2);
+}
 
+}   // extern "C"
 
-#ifndef _RWSTD_NO_WCSNCPY
-    using ::wcsncpy;
-#elif !defined (_RWSTD_NO_WCSNCPY_IN_LIBC)
+inline wchar_t* wcsstr (wchar_t *__s1, const wchar_t *__s2)
+{
+    return wcswcs (__s1, __s2);
+}
 
-    extern "C" wchar_t* wcsncpy (wchar_t*, const wchar_t*, size_t);
+namespace std {
 
-#else   // if defined (_RWSTD_NO_WCSNCPY)
+using ::wcsstr;
 
-    inline wchar_t* wcsncpy (wchar_t *__dst, const wchar_t *__src, size_t __n)
-    {
-        wchar_t *__s = __dst;
-        for (; __n && (*__s++ = *__src++); --__n);
-        while (__n--)
-            *__s = 0;
-        return __dst;
-    }
+#    undef _RWSTD_NO_WCSSTR
+#  endif   // _RWSTD_OS_HPUX
 
-#endif   // _RWSTD_NO_WCSNCPY
+#endif   // _RWSTD_NO_WCSSTR
 
-#undef _RWSTD_NO_WCSNCPY
+#ifndef _RWSTD_NO_WCSTOD
+using ::wcstod;
+#elif !defined (_RWSTD_NO_WCSTOD_IN_LIBC)
 
+}   // namespace std
 
-#ifndef _RWSTD_NO_WCSPBRK
-    using ::wcspbrk;
-#elif !defined (_RWSTD_NO_WCSPBRK_IN_LIBC)
+extern "C" double wcstod (const wchar_t*, wchar_t**);
 
-    extern "C" wchar_t* wcspbrk (wchar_t*, const wchar_t*);
+namespace std {
 
-    inline const wchar_t* wcspbrk (const wchar_t *__s1, const wchar_t *__s2)
-    {
-        return wcspbrk (_RWSTD_CONST_CAST (wchar_t*, __s1), __s2);
-    }
+using ::wcstod;
 
-#endif   // _RWSTD_NO_WCSPBRK
+#  undef _RWSTD_NO_WCSTOD
+#endif   // _RWSTD_NO_WCSTOD[_IN_LIBC]
 
-#undef _RWSTD_NO_WCSPBRK
+#ifndef _RWSTD_NO_WCSTOK
+using ::wcstok;
+#elif !defined (_RWSTD_NO_WCSTOK_IN_LIBC)
 
+}   // namespace std
 
-#ifndef _RWSTD_NO_WCSRCHR
-    using ::wcsrchr;
-#elif !defined (_RWSTD_NO_WCSRCHR_IN_LIBC)
+extern "C" wchar_t* wcstok (wchar_t*, const wchar_t*, wchar_t**);
 
-    extern "C" const wchar_t* wcsrchr (const wchar_t*, wchar_t);
+namespace std {
 
-#else   // if defined (_RWSTD_NO_WCSRCHR)
+using ::wcstok;
 
-    inline const wchar_t* wcsrchr (const wchar_t *__s, wchar_t __c)
-    {
-        const wchar_t *__ss = __s;
-        while (*__ss++);
-        while (--__ss != __s && *__ss != __c);
-        return *__ss == __c ? __ss : 0;
-    }
+#  undef _RWSTD_NO_WCSTOK
+#endif   // _RWSTD_NO_WCSTOK[_IN_LIBC]
 
-    inline wchar_t* wcsrchr (wchar_t *__s, wchar_t __c)
-    {
-        return _RWSTD_CONST_CAST (wchar_t*,
-                                  (wcsrchr ((const wchar_t*)__s, __c)));
-    }
+#ifndef _RWSTD_NO_WCSTOL
+using ::wcstol;
+#elif !defined (_RWSTD_NO_WCSTOL_IN_LIBC)
 
-#endif   // _RWSTD_NO_WCSRCHR
+}   // namespace std
 
-#undef _RWSTD_NO_WCSRCHR
+extern "C" long wcstol (const wchar_t*, wchar_t**, int);
 
+namespace std {
 
-#ifndef _RWSTD_NO_WCSRTOMBS
-    using ::wcsrtombs;
-#else // defined _RWSTD_NO_WCSRTOMBS
-#  ifndef _RWSTD_NO_WCSRTOMBS_IN_LIBC
-    extern "C" size_t wcsrtombs (char*, const wchar_t**, size_t, mbstate_t*);
-#  endif
-#endif   // _RWSTD_NO_WCSRTOMBS
+using ::wcstol;
 
-#ifndef _RWSTD_NO_WCSSPN
-    using ::wcsspn;
-#else
-    
-    inline size_t wcsspn (const wchar_t *__s1, const wchar_t *__s2)
-    {
-        const wchar_t *__s = __s1;
-        for (; *__s; ++__s) {
-            for (const wchar_t *__ss = __s2; *__ss != *__s; ++__ss)
-                if (!*__ss)
-                    return __s - __s1;
-        }
-        return __s - __s1;
-    }
+#  undef _RWSTD_NO_WCSTOL
+#endif   // _RWSTD_NO_WCSTOL[_IN_LIBC]
 
-#endif   // _RWSTD_NO_WCSSPN
+#ifndef _RWSTD_NO_WCSTOUL
+using ::wcstoul;
+#elif !defined (_RWSTD_NO_WCSTOUL_IN_LIBC)
 
-#ifndef _RWSTD_NO_WCSSTR
-    using ::wcsstr;
-#else   // if defined (_RWSTD_NO_WCSSTR)
+}   // namespace std
 
-#  ifdef __hpux
+extern "C" unsigned long wcstoul (const wchar_t*, wchar_t**, int);
 
-    inline const wchar_t* wcsstr (const wchar_t *__s1, const wchar_t *__s2)
-    {
-        return wcswcs (__s1, __s2);
-    }
+namespace std {
 
-    inline wchar_t* wcsstr (wchar_t *__s1, const wchar_t *__s2)
-    {
-        return wcswcs (__s1, __s2);
-    }
+using ::wcstoul;
 
-#  endif   // __hpux
+#  undef _RWSTD_NO_WCSTOUL
+#endif   // _RWSTD_NO_WCSTOUL[_IN_LIBC]
 
-#endif   // _RWSTD_NO_WCSSTR
+#ifndef _RWSTD_NO_WCSXFRM
+using ::wcsxfrm;
+#elif !defined (_RWSTD_NO_WCSXFRM_IN_LIBC)
 
-#ifndef _RWSTD_NO_WCSTOD
-    using ::wcstod;
-#endif   // _RWSTD_NO_WCSTOD
+}   // namespace std
 
-#ifndef _RWSTD_NO_WCSTOK
-    using ::wcstok;
-#endif   // _RWSTD_NO_WCSTOK
+extern "C" size_t wcsxfrm (wchar_t*, const wchar_t*, size_t);
 
-#ifndef _RWSTD_NO_WCSTOL
-    using ::wcstol;
-#endif   // _RWSTD_NO_WCSTOL
+namespace std {
 
-#ifndef _RWSTD_NO_WCSTOUL
-    using ::wcstoul;
-#endif   // _RWSTD_NO_WCSTOUL
+using ::wcsxfrm;
 
-#ifndef _RWSTD_NO_WCSXFRM
-    using ::wcsxfrm;
-#endif   // _RWSTD_NO_WCSXFRM
+#  undef _RWSTD_NO_WCSXFRM
+#endif   // _RWSTD_NO_WCSXFRM[_IN_LIBC]
 
 #ifndef _RWSTD_NO_WCTOB
-    using ::wctob;
+using ::wctob;
 #elif !defined (_RWSTD_NO_WCTOB_IN_LIBC)
-    extern "C" int wctob (wint_t);
+
+}   // namespace std
+
+extern "C" int wctob (wint_t);
+
+namespace std {
+
+using ::wctob;
 
 #  undef _RWSTD_NO_WCTOB
 #endif   // _RWSTD_NO_WCTOB
 
 
 #ifndef _RWSTD_NO_WMEMCHR
-    using ::wmemchr;
+using ::wmemchr;
 #else
 
 }   // namespace std
 
-inline const wchar_t* wmemchr (const wchar_t* __s, wchar_t __c, size_t __n)
+extern "C" {
+
+inline wchar_t* wmemchr (wchar_t* __s, wchar_t __c, size_t __n)
 {
     for (; __n ; --__n, ++__s)
         if (*__s == __c)
@@ -554,55 +1094,57 @@
     return 0;
 }
 
-inline wchar_t* wmemchr (wchar_t* __s, wchar_t __c, size_t __n)
+}   // extern "C"
+
+inline const wchar_t* wmemchr (const wchar_t* __s, wchar_t __c, size_t __n)
 {
-    return _RWSTD_CONST_CAST (wchar_t*,
-                              wmemchr ((const wchar_t*)__s, __c, __n));
+    return wmemchr (_RWSTD_CONST_CAST (wchar_t*, __s), __c, __n);
 }
 
 namespace std {
 
-    using ::wmemchr;
+using ::wmemchr;
 
+#  undef _RWSTD_NO_WMEMCHR
 #endif   // _RWSTD_NO_WMEMCHR
 
-#undef _RWSTD_NO_WMEMCHR
-
 
 #ifndef _RWSTD_NO_WMEMCMP
-    using ::wmemcmp;
+using ::wmemcmp;
 #elif !defined (_RWSTD_NO_WMEMCMP_IN_LIBC)
 
 }   // namespace std
 
-extern "C" int wmemcmp (const void*, const void*, size_t);
+extern "C" int wmemcmp (const wchar_t*, const wchar_t*, size_t);
 
 namespace std {
 
-    using ::wmemcmp;
+using ::wmemcmp;
 
 #else   // if _RWSTD_NO_WMEMCMP && _RWSTD_NO_WMEMCMP_IN_LIBC
 
 }   // namespace std
 
-extern "C" {
+namespace __rw {
 
-    inline int wmemcmp (const void *__s1, const void *__s2, size_t __n)
-    {
-        const wchar_t *__ss1 = _RWSTD_REINTERPRET_CAST (const wchar_t*, __s1);
-        const wchar_t *__ss2 = _RWSTD_REINTERPRET_CAST (const wchar_t*, __s2);
-
-        for (; __n; --__n, ++__ss1, ++__ss2)
-            if (*__ss1 != *__ss2)
-                return *__ss1 - *__ss2;
-        return 0;
-    }
+_RWSTD_EXPORT int
+__rw_wmemcmp (const wchar_t*, const wchar_t*, size_t);
+
+}   // namespace __rw
 
+extern "C" {
+
+inline int
+wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+{
+    return _RW::__rw_memcmp (__s1, __s2, __n);
 }
 
+}   // extern "C"
+
 namespace std {
 
-    using ::wmemcmp;
+using ::wmemcmp;
 
 #endif   // _RWSTD_NO_WMEMCMP
 
@@ -610,22 +1152,42 @@
 
 
 #ifndef _RWSTD_NO_WMEMCPY
-    using ::wmemcpy;
+using ::wmemcpy;
 #elif !defined (_RWSTD_NO_WMEMCPY_IN_LIBC)
-    extern "C" wchar_t* wmemcpy (wchar_t*, const wchar_t*, size_t);
+
+}   // namespace std
+
+extern "C" wchar_t* wmemcpy (wchar_t*, const wchar_t*, size_t);
+
+namespace std {
+
+using ::wmemcpy;
+
 #else   // if _RWSTD_NO_WMEMCPY && _RWSTD_NO_WMEMCPY_IN_LIBC
 
-    extern "C" {
+}   // namespace std
+
+namespace __rw {
 
-    inline wchar_t* wmemcpy (wchar_t *__dst, const wchar_t *__src, size_t __n)
-    {
-        for (wchar_t *__d = __dst; __n--; ++__d, ++__src)
-            *__d = *__src;
+_RWSTD_EXPORT wchar_t*
+__rw_wmemcpy (wchar_t*, const wchar_t*, size_t);
 
-        return __dst;
-    }
+}   // namespace __rw
 
-    }
+
+extern "C" {
+
+inline wchar_t*
+wmemcpy (wchar_t *__dst, const wchar_t *__src, size_t __n)
+{
+    return _RW::__rw_memcpy (__dst, __src, __n);
+}
+
+}   // extern "C"
+
+namespace std {
+
+using ::wmemcpy;
 
 #endif   // _RWSTD_NO_WMEMCPY
 
@@ -633,29 +1195,41 @@
 
 
 #ifndef _RWSTD_NO_WMEMMOVE
-    using ::wmemmove;
+using ::wmemmove;
 #elif !defined (_RWSTD_NO_WMEMMOVE_IN_LIBC)
-    extern "C" wchar_t* wmemmove (wchar_t*, const wchar_t*, size_t);
+
+}   // namespace std
+
+extern "C" wchar_t* wmemmove (wchar_t*, const wchar_t*, size_t);
+
+namespace std {
+
+using ::wmemmove;
+
 #else   // if _RWSTD_NO_WMEMMOVE && _RWSTD_NO_WMEMMOVE_IN_LIBC
 
-    extern "C" {
+}   // namespace std
+
+namespace __rw {
 
-    inline wchar_t*
-    wmemmove (wchar_t *__dst, const wchar_t *__src, size_t __n)
-    {
-        if (__dst < __src || __dst >= __src + __n)
-            wmemcpy (__dst, __src, __n);
-        else {
-            // regions overlap
-            __dst += __n;
-            __src += __n;
-            while (__n--)
-                *--__dst = *--__src;
-        }
-        return __dst;
-    }
+_RWSTD_EXPORT wchar_t*
+__rw_wmemmove (wchar_t*, const wchar_t*, size_t);
 
-    }
+}   // namespace __rw
+
+extern "C" {
+
+inline wchar_t*
+wmemmove (wchar_t *__dst, const wchar_t *__src, size_t __n)
+{
+    return _RW::__rw_memmove (__dst, __src, __n);
+}
+
+}   // extern "C"
+
+namespace std {
+
+using ::wmemmove
 
 #endif   // _RWSTD_NO_WMEMMOVE
 
@@ -663,21 +1237,41 @@
 
 
 #ifndef _RWSTD_NO_WMEMSET
-    using ::wmemset;
+using ::wmemset;
 #elif !defined (_RWSTD_NO_WMEMSET_IN_LIBC)
-    extern "C" wchar_t* wmemset (wchar_t*, wchar_t, size_t);
+
+}   // namespace std
+
+extern "C" wchar_t* wmemset (wchar_t*, wchar_t, size_t);
+
+namespace std {
+
+using ::wmemset;
+
 #else   // if _RWSTD_NO_WMEMSET && _RWSTD_NO_WMEMSET_IN_LIBC
 
-    extern "C" {
+}   // namespace std
+
+namespace __rw {
 
-    inline wchar_t* wmemset (wchar_t* __s, wchar_t __c, size_t __n)
-    {
-        while (__n)
-            __s [--__n] = __c;
-        return __s;
-    }
+_RWSTD_EXPORT wchar_t*
+__rw_wmemset (wchar_t*, wchar_t, size_t);
 
-    }
+}   // namespace __rw
+
+extern "C" {
+
+inline wchar_t*
+wmemset (wchar_t* __s, wchar_t __c, size_t __n)
+{
+    return _RW::__rw_wmemset (__s, __c, __n);
+}
+
+}   // extern "C"
+
+namespace std {
+
+using ::wmemmove
 
 #endif   // _RWSTD_NO_WMEMSET
 



Mime
View raw message