// -*- C++ -*-
/***************************************************************************
 *
 * cwchar - C++ Standard library interface to the ANSI C header wchar.h
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 1998-2006 Rogue Wave Software.
 * 
 **************************************************************************/

#include <rw/_defs.h>

#ifndef _RWSTD_NO_PURE_C_HEADERS
#  include <ansi/_cwchar.h>
#else

#ifndef _RWSTD_NO_DEPRECATED_C_HEADERS

#ifndef _RWSTD_NAMESPACE_STD_OPEN
#define _RWSTD_NAMESPACE_STD_OPEN 17

_RWSTD_NAMESPACE (std) { 

#endif   // _RWSTD_NAMESPACE_STD_OPEN


#include _RWSTD_ANSI_C_WCHAR_H


#ifdef _RWSTD_STRICT_ANSI
// 17.4.1.2, p6 - masking macros are not allowed
#  undef getwc
#  undef putwc
#endif   // _RWSTD_STRICT_ANSI


#if _RWSTD_NAMESPACE_STD_OPEN == 17
#undef _RWSTD_NAMESPACE_STD_OPEN

}   // namespace std

#endif   // _RWSTD_NAMESPACE_STD_OPEN == 17

#else   // if defined (_RWSTD_NO_DEPRECATED_C_HEADERS)

#ifndef _RWSTD_CWCHAR_INCLUDED
#define _RWSTD_CWCHAR_INCLUDED

#include _RWSTD_ANSI_C_WCHAR_H
#include <rw/_mbstate.h>


// #define WEOF when not #defined (see also <cwctype>)
#if !defined WEOF
#  ifndef _RWSTD_NO_WINT_T
#    define WEOF _RWSTD_STATIC_CAST (_RWSTD_WINT_T, -1)
#  else
#    define WEOF (-1)
#  endif
#endif   // WEOF


#ifndef NULL
#  define NULL 0
#endif   // NULL


#if !defined (_RWSTD_NO_NAMESPACE) && !defined (_RWSTD_NO_HONOR_STD)


#ifndef WCHAR_MIN
#  define WCHAR_MIN   _RWSTD_WCHAR_MIN
#endif   // WCHAR_MIN

#ifndef WCHAR_MAX
#  define WCHAR_MAX   _RWSTD_WCHAR_MAX
#endif   // WCHAR_MAX


#if !defined (_RWSTD_NO_USING_LIBC_IN_STD)

namespace std {

#ifndef _RWSTD_NO_SIZE_T
using ::size_t;
#elif defined (_RWSTD_SIZE_T)
    typedef _RWSTD_SIZE_T size_t;
#endif   // _RWSTD_NO_SIZE_T

#ifdef _RWSTD_NO_STD_MBSTATE_T

using ::mbstate_t;

#endif   // _RWSTD_NO_STD_MBSTATE_T

#ifndef _RWSTD_NO_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;
#elif !defined (_RWSTD_NO_STRUCT_TM)

}   // namespace std

#include _RWSTD_ANSI_C_TIME_H

namespace std {

using ::tm;

#endif   // NO_STRUCT_TM

#ifndef _RWSTD_NO_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;
#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

#if _MSC_VER < 1310   // MSVC < 7.1 or (better yet) not MSVC

extern "C" {

_RWSTD_DLLIMPORT int
swprintf (wchar_t*, size_t, const wchar_t*, ...);

}   // extern "C"

#elif _MSC_VER == 1310   // MSVC 7.1

// MSVC 8.0 defines the C++ overload of swprintf() inline
/* extern "C++" */ _RWSTD_DLLIMPORT int
swprintf (wchar_t*, size_t, const wchar_t*, ...);

#else   // MSVC 8.0 and above

// MSVC 7.1 declares two overloads of swprintf()
/* extern "C++" */ int
swprintf (wchar_t*, size_t, const wchar_t*, ...);

#endif   // MSVC

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

#if _MSC_VER < 1310   // MSVC < 7.1 or (better yet) not MSVC

extern "C" {

_RWSTD_DLLIMPORT int
vswprintf (wchar_t*, size_t, const wchar_t*, _RWSTD_VA_LIST);

}   // extern "C"

#elif _MSC_VER == 1310   // MSVC 7.1

// MSVC 7.1 declares two overloads of swprintf()
/* extern "C++" */ _RWSTD_DLLIMPORT int
swprintf (wchar_t*, size_t, const wchar_t*, ...);

#else   // MSVC 8.0 and above

// MSVC 8.0 defines the C++ overload of vswprintf() inline
/* extern "C++" */ int
vswprintf (wchar_t*, size_t, const wchar_t*, _RWSTD_VA_LIST);

#endif   // MSVC

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, _RWSTD_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, _RWSTD_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 _RWSTD_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, _RWSTD_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, _RWSTD_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;
}

}   // extern "C"

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;
}

}   // extern "C"

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)

}   // namespace std

extern "C" wchar_t* wcsncpy (wchar_t*, const wchar_t*, size_t);

namespace std {

using ::wcsncpy;

#  undef _RWSTD_NO_WCSNCPY
#else   // if defined (_RWSTD_NO_WCSNCPY)

}   // namespace std

extern "C" {

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;
}

}   // extern "C"

namespace std {

using ::wcsncpy;

#  undef _RWSTD_NO_WCSNCPY
#endif   // _RWSTD_NO_WCSNCPY


#ifndef _RWSTD_NO_WCSPBRK
using ::wcspbrk;
#elif !defined (_RWSTD_NO_WCSPBRK_IN_LIBC)

}   // namespace std

extern "C" wchar_t* wcspbrk (wchar_t*, const wchar_t*);

inline const wchar_t* wcspbrk (const wchar_t *__s1, const wchar_t *__s2)
{
    return wcspbrk (_RWSTD_CONST_CAST (wchar_t*, __s1), __s2);
}

namespace std {

using ::wcspbrk;

#  undef _RWSTD_NO_WCSPBRK
#endif   // _RWSTD_NO_WCSPBRK


#ifndef _RWSTD_NO_WCSRCHR
using ::wcsrchr;
#elif !defined (_RWSTD_NO_WCSRCHR_IN_LIBC)

}   // namespace std

extern "C" const wchar_t* wcsrchr (const wchar_t*, wchar_t);

wchar_t* wcsrchr (wchar_t *__s, wchar_t __c)
{
    return wcsrchr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);
}

namespace std {

using ::wcsrchr;

#  undef _RWSTD_NO_WCSRCHR
#else   // if defined (_RWSTD_NO_WCSRCHR)

}   // namespace std

extern "C" {

inline wchar_t* wcsrchr (wchar_t *__s, wchar_t __c)
{
    wchar_t *__ss = __s;
    while (*__ss++);
    while (--__ss != __s && *__ss != __c);
    return *__ss == __c ? __ss : 0;
}

}   // extern "C"

inline const wchar_t* wcsrchr (const wchar_t *__s, wchar_t __c)
{
    return wcsrchr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);
}

namespace std {

using ::wcsrchr;

#  undef _RWSTD_NO_WCSRCHR
#endif   // _RWSTD_NO_WCSRCHR


#ifndef _RWSTD_NO_WCSRTOMBS
using ::wcsrtombs;
#elif !defined (_RWSTD_NO_WCSRTOMBS_IN_LIBC)

}   // namespace std

extern "C" size_t wcsrtombs (char*, const wchar_t**, size_t, _RWSTD_MBSTATE_T*);

namespace std {

using ::wcsrtombs;

#  undef _RWSTD_NO_WCSRTOMBS
#endif   // _RWSTD_NO_WCSRTOMBS

#ifndef _RWSTD_NO_WCSSPN
using ::wcsspn;
#else

}   // namespace std

extern "C" {

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"

namespace std {

using ::wcsspn;

#  undef _RWSTD_NO_WCSSPN
#endif   // _RWSTD_NO_WCSSPN

#ifndef _RWSTD_NO_WCSSTR
using ::wcsstr;
#elif !defined (_RWSTD_NO_WCSSTR_IN_LIBC)

}   // namespace std

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);
}

namespace std {

using ::wcsstr;

#  undef _RWSTD_NO_WCSSTR
#else

#  ifdef _RWSTD_OS_HPUX

}   // namespace std

extern "C" {

inline wchar_t* wcsstr (wchar_t *__s1, const wchar_t *__s2)
{
    return wcswcs (__s1, __s2);
}

}   // extern "C"

inline wchar_t* wcsstr (wchar_t *__s1, const wchar_t *__s2)
{
    return wcswcs (__s1, __s2);
}

namespace std {

using ::wcsstr;

#    undef _RWSTD_NO_WCSSTR
#  endif   // _RWSTD_OS_HPUX

#endif   // _RWSTD_NO_WCSSTR

#ifndef _RWSTD_NO_WCSTOD
using ::wcstod;
#elif !defined (_RWSTD_NO_WCSTOD_IN_LIBC)

}   // namespace std

extern "C" double wcstod (const wchar_t*, wchar_t**);

namespace std {

using ::wcstod;

#  undef _RWSTD_NO_WCSTOD
#endif   // _RWSTD_NO_WCSTOD[_IN_LIBC]

#ifndef _RWSTD_NO_WCSTOK
using ::wcstok;
#elif !defined (_RWSTD_NO_WCSTOK_IN_LIBC)

}   // namespace std

extern "C" wchar_t* wcstok (wchar_t*, const wchar_t*, wchar_t**);

namespace std {

using ::wcstok;

#  undef _RWSTD_NO_WCSTOK
#elif defined (_MSC_VER) && 1400 <= _MSC_VER

}   // namespace std

/* extern "C++" */ inline wchar_t*
wcstok (wchar_t* __s1, const wchar_t* __s2, wchar_t** __ptr)
{
    return wcstok_s (__s1, __s2, __ptr);
}

namespace std {

using ::wcstok;

#  undef _RWSTD_NO_WCSTOK
#  undef _RWSTD_NO_WCSTOK_IN_LIBC
#endif   // _RWSTD_NO_WCSTOK[_IN_LIBC]

#ifndef _RWSTD_NO_WCSTOL
using ::wcstol;
#elif !defined (_RWSTD_NO_WCSTOL_IN_LIBC)

}   // namespace std

extern "C" long wcstol (const wchar_t*, wchar_t**, int);

namespace std {

using ::wcstol;

#  undef _RWSTD_NO_WCSTOL
#endif   // _RWSTD_NO_WCSTOL[_IN_LIBC]

#ifndef _RWSTD_NO_WCSTOUL
using ::wcstoul;
#elif !defined (_RWSTD_NO_WCSTOUL_IN_LIBC)

}   // namespace std

extern "C" unsigned long wcstoul (const wchar_t*, wchar_t**, int);

namespace std {

using ::wcstoul;

#  undef _RWSTD_NO_WCSTOUL
#endif   // _RWSTD_NO_WCSTOUL[_IN_LIBC]

#ifndef _RWSTD_NO_WCSXFRM
using ::wcsxfrm;
#elif !defined (_RWSTD_NO_WCSXFRM_IN_LIBC)

}   // namespace std

extern "C" size_t wcsxfrm (wchar_t*, const wchar_t*, size_t);

namespace std {

using ::wcsxfrm;

#  undef _RWSTD_NO_WCSXFRM
#endif   // _RWSTD_NO_WCSXFRM[_IN_LIBC]

#ifndef _RWSTD_NO_WCTOB
using ::wctob;
#elif !defined (_RWSTD_NO_WCTOB_IN_LIBC)

}   // 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;
#else

}   // namespace std

extern "C" {

inline wchar_t* wmemchr (wchar_t* __s, wchar_t __c, size_t __n)
{
    for (; __n ; --__n, ++__s)
        if (*__s == __c)
            return __s;
    return 0;
}

}   // extern "C"

inline const wchar_t* wmemchr (const wchar_t* __s, wchar_t __c, size_t __n)
{
    return wmemchr (_RWSTD_CONST_CAST (wchar_t*, __s), __c, __n);
}

namespace std {

using ::wmemchr;

#  undef _RWSTD_NO_WMEMCHR
#endif   // _RWSTD_NO_WMEMCHR


#ifndef _RWSTD_NO_WMEMCMP
using ::wmemcmp;
#elif !defined (_RWSTD_NO_WMEMCMP_IN_LIBC)

}   // namespace std

extern "C" int wmemcmp (const wchar_t*, const wchar_t*, size_t);

namespace std {

using ::wmemcmp;

#else   // if _RWSTD_NO_WMEMCMP && _RWSTD_NO_WMEMCMP_IN_LIBC

}   // namespace std

namespace __rw {

_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_wmemcmp (__s1, __s2, __n);
}

}   // extern "C"

namespace std {

using ::wmemcmp;

#endif   // _RWSTD_NO_WMEMCMP

#undef _RWSTD_NO_WMEMCMP


#ifndef _RWSTD_NO_WMEMCPY
using ::wmemcpy;
#elif !defined (_RWSTD_NO_WMEMCPY_IN_LIBC)

}   // 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

}   // namespace std

namespace __rw {

_RWSTD_EXPORT wchar_t*
__rw_wmemcpy (wchar_t*, const wchar_t*, size_t);

}   // namespace __rw


extern "C" {

inline wchar_t*
wmemcpy (wchar_t *__dst, const wchar_t *__src, size_t __n)
{
    return _RW::__rw_wmemcpy (__dst, __src, __n);
}

}   // extern "C"

namespace std {

using ::wmemcpy;

#endif   // _RWSTD_NO_WMEMCPY

#undef _RWSTD_NO_WMEMCPY


#ifndef _RWSTD_NO_WMEMMOVE
using ::wmemmove;
#elif !defined (_RWSTD_NO_WMEMMOVE_IN_LIBC)

}   // 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

}   // namespace std

namespace __rw {

_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_wmemmove (__dst, __src, __n);
}

}   // extern "C"

namespace std {

using ::wmemmove;

#endif   // _RWSTD_NO_WMEMMOVE

#undef _RWSTD_NO_WMEMMOVE


#ifndef _RWSTD_NO_WMEMSET
using ::wmemset;
#elif !defined (_RWSTD_NO_WMEMSET_IN_LIBC)

}   // 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

}   // namespace std

namespace __rw {

_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 ::wmemset;

#endif   // _RWSTD_NO_WMEMSET

#undef _RWSTD_NO_WMEMSET

}   // std

#endif   // !_RWSTD_NO_USING_LIBC_IN_STD

#endif   // !_RWSTD_NO_NAMESPACE && !_RWSTD_NO_HONOR_STD

#endif   // _RWSTD_CWCHAR_INCLUDED

#endif   // _RWSTD_NO_DEPRECATED_C_HEADERS

#endif   // _RWSTD_NO_PURE_C_HEADERS