1 --- stdcxx-4.2.1/include/ansi/cwchar	2008-04-24 20:23:56.000000000 -0400

     2 +++ stdcxx-4.2.1/include/ansi/cwchar	2009-03-12 16:35:36.000000000 -0400

     3 @@ -1,1372 +1,34 @@

     4  // -*- C++ -*-

     5 -/***************************************************************************

     6 +/**

     7 + * CDDL HEADER START

     8   *

     9 - * cwchar - C++ Standard library interface to the ANSI C header wchar.h

    10 + * The contents of this file are subject to the terms of the

    11 + * Common Development and Distribution License (the "License").

    12 + * You may not use this file except in compliance with the License.

    13   *

    14 - * $Id: cwchar 597425 2007-11-22 15:20:29Z faridz $

    15 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

    16 + * or http://www.opensolaris.org/os/licensing.

    17 + * See the License for the specific language governing permissions

    18 + * and limitations under the License.

    19   *

    20 - ***************************************************************************

    21 + * When distributing Covered Code, include this CDDL HEADER in each

    22 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

    23 + * If applicable, add the following below this CDDL HEADER, with the

    24 + * fields enclosed by brackets "[]" replaced with your own identifying

    25 + * information: Portions Copyright [yyyy] [name of copyright owner]

    26   *

    27 - * Licensed to the Apache Software  Foundation (ASF) under one or more

    28 - * contributor  license agreements.  See  the NOTICE  file distributed

    29 - * with  this  work  for  additional information  regarding  copyright

    30 - * ownership.   The ASF  licenses this  file to  you under  the Apache

    31 - * License, Version  2.0 (the  "License"); you may  not use  this file

    32 - * except in  compliance with the License.   You may obtain  a copy of

    33 - * the License at

    34 + * CDDL HEADER END

    35   *

    36 - * http://www.apache.org/licenses/LICENSE-2.0

    37   *

    38 - * Unless required by applicable law or agreed to in writing, software

    39 - * distributed under the  License is distributed on an  "AS IS" BASIS,

    40 - * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or

    41 - * implied.   See  the License  for  the  specific language  governing

    42 - * permissions and limitations under the License.

    43 + * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

    44 + * Use is subject to license terms.

    45   *

    46 - * Copyright 1998-2006 Rogue Wave Software.

    47 - * 

    48 - **************************************************************************/

    49 -

    50 -#include <rw/_defs.h>

    51 -

    52 -#ifndef _RWSTD_NO_PURE_C_HEADERS

    53 -#  include <ansi/_cwchar.h>

    54 -#else

    55 -

    56 -#ifndef _RWSTD_NO_DEPRECATED_C_HEADERS

    57 -

    58 -#ifndef _RWSTD_NAMESPACE_STD_OPEN

    59 -#define _RWSTD_NAMESPACE_STD_OPEN 17

    60 -

    61 -_RWSTD_NAMESPACE (std) { 

    62 -

    63 -#endif   // _RWSTD_NAMESPACE_STD_OPEN

    64 -

    65 -

    66 -#include _RWSTD_ANSI_C_WCHAR_H

    67 -

    68 -

    69 -#ifdef _RWSTD_STRICT_ANSI

    70 -// 17.4.1.2, p6 - masking macros are not allowed

    71 -#  undef getwc

    72 -#  undef putwc

    73 -#endif   // _RWSTD_STRICT_ANSI

    74 -

    75 -

    76 -#if _RWSTD_NAMESPACE_STD_OPEN == 17

    77 -#undef _RWSTD_NAMESPACE_STD_OPEN

    78 -

    79 -}   // namespace std

    80 -

    81 -#endif   // _RWSTD_NAMESPACE_STD_OPEN == 17

    82 -

    83 -#else   // if defined (_RWSTD_NO_DEPRECATED_C_HEADERS)

    84 -

    85 -#ifndef _RWSTD_CWCHAR_INCLUDED

    86 -#define _RWSTD_CWCHAR_INCLUDED

    87 -

    88 -#include _RWSTD_ANSI_C_WCHAR_H

    89 -#include <rw/_mbstate.h>

    90 -

    91 -

    92 -// #define WEOF when not #defined (see also <cwctype>)

    93 -#if !defined WEOF

    94 -#  ifndef _RWSTD_NO_WINT_T

    95 -#    define WEOF _RWSTD_STATIC_CAST (_RWSTD_WINT_T, -1)

    96 -#  else

    97 -#    define WEOF (-1)

    98 -#  endif

    99 -#endif   // WEOF

   100 -

   101 -

   102 -#ifndef NULL

   103 -#  define NULL 0

   104 -#endif   // NULL

   105 -

   106 -

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

   108 -

   109 -

   110 -#ifndef WCHAR_MIN

   111 -#  define WCHAR_MIN   _RWSTD_WCHAR_MIN

   112 -#endif   // WCHAR_MIN

   113 -

   114 -#ifndef WCHAR_MAX

   115 -#  define WCHAR_MAX   _RWSTD_WCHAR_MAX

   116 -#endif   // WCHAR_MAX

   117 -

   118 -

   119 -#if !defined (_RWSTD_NO_USING_LIBC_IN_STD)

   120 -

   121 -namespace std {

   122 -

   123 -#ifndef _RWSTD_NO_SIZE_T

   124 -using ::size_t;

   125 -#elif defined (_RWSTD_SIZE_T)

   126 -    typedef _RWSTD_SIZE_T size_t;

   127 -#endif   // _RWSTD_NO_SIZE_T

   128 -

   129 -#ifdef _RWSTD_NO_STD_MBSTATE_T

   130 -

   131 -using ::mbstate_t;

   132 -

   133 -#endif   // _RWSTD_NO_STD_MBSTATE_T

   134 -

   135 -#ifndef _RWSTD_NO_WINT_T

   136 -using ::wint_t;

   137 -#elif defined (_RWSTD_WINT_T)

   138 -    typedef _RWSTD_WINT_T wint_t;

   139 -#endif   // _RWSTD_NO_WINT_T

   140 -

   141 -#ifndef _RWSTD_NO_STRUCT_TM_IN_WCHAR_H

   142 -using ::tm;

   143 -#elif !defined (_RWSTD_NO_STRUCT_TM)

   144 -

   145 -}   // namespace std

   146 -

   147 -#include _RWSTD_ANSI_C_TIME_H

   148 -

   149 -namespace std {

   150 -

   151 -using ::tm;

   152 -

   153 -#endif   // NO_STRUCT_TM

   154 -

   155 -#ifndef _RWSTD_NO_BTOWC

   156 -using ::btowc;

   157 -#elif !defined (_RWSTD_NO_BTOWC_IN_LIBC)

   158 -

   159 -}   // namespace std

   160 -

   161 -extern "C" wint_t btowc (int);

   162 -

   163 -namespace std {

   164 -

   165 -using ::btowc;

   166 -

   167 -#  undef _RWSTD_NO_BTOWC

   168 -#endif   // _RWSTD_NO_BTOWC

   169 -

   170 -#ifndef _RWSTD_NO_FGETWC

   171 -using ::fgetwc;

   172 -#elif !defined (_RWSTD_NO_FGETWC_IN_LIBC)

   173 -

   174 -}   // namespace std

   175 -

   176 -extern "C" wint_t fgetwc (FILE*);

   177 -

   178 -namespace std {

   179 -

   180 -using ::fgetwc;

   181 -

   182 -#  undef _RWSTD_NO_FGETWC

   183 -#endif   // _RWSTD_NO_FGETWC[_IN_LIBC]

   184 -

   185 -#ifndef _RWSTD_NO_FGETWS

   186 -using ::fgetws;

   187 -#elif !defined (_RWSTD_NO_FGETWS_IN_LIBC)

   188 -

   189 -}   // namespace std

   190 -

   191 -extern "C" wchar_t fgetws (wchar_t*, int, FILE*);

   192 -

   193 -namespace std {

   194 -

   195 -using ::fgetws;

   196 -

   197 -#  undef _RWSTD_NO_FGETWS

   198 -#endif   // _RWSTD_NO_FGETWS[_IN_LIBC]

   199 -

   200 -#ifndef _RWSTD_NO_FPUTWC

   201 -using ::fputwc;

   202 -#elif !defined (_RWSTD_NO_FPUTWC_IN_LIBC)

   203 -

   204 -}   // namespace std

   205 -

   206 -extern "C" wint_t fputwc (wint_t, FILE*);

   207 -

   208 -namespace std {

   209 -

   210 -using ::fputwc;

   211 -

   212 -#  undef _RWSTD_NO_FPUTWC

   213 -#endif   // _RWSTD_NO_FPUTWC[_IN_LIBC]

   214 -

   215 -#ifndef _RWSTD_NO_FPUTWS

   216 -using ::fputws;

   217 -#elif !defined (_RWSTD_NO_FPUTWS_IN_LIBC)

   218 -

   219 -}   // namespace std

   220 -

   221 -extern "C" int fputws (const wchar_t*, FILE*);

   222 -

   223 -namespace std {

   224 -

   225 -using ::fputws;

   226 -

   227 -#  undef _RWSTD_NO_FPUTWS

   228 -#endif   // _RWSTD_NO_FPUTWS[_IN_LIBC]

   229 -

   230 -#ifndef _RWSTD_NO_FWIDE

   231 -using ::fwide;

   232 -#elif !defined (_RWSTD_NO_FWIDE_IN_LIBC)

   233 -

   234 -}   // namespace std

   235 -

   236 -extern "C" int fwide (FILE*, int);

   237 -

   238 -namespace std {

   239 -

   240 -using ::fwide;

   241 -

   242 -#  undef _RWSTD_NO_FWIDE

   243 -#endif   // _RWSTD_NO_FWIDE[_IN_LIBC]

   244 -

   245 -#ifndef _RWSTD_NO_FWPRINTF

   246 -using ::fwprintf;

   247 -#elif !defined (_RWSTD_NO_FWPRINTF_IN_LIBC)

   248 -

   249 -}   // namespace std

   250 -

   251 -extern "C" int fwprintf (FILE*, const wchar_t*, ...);

   252 -

   253 -namespace std {

   254 -

   255 -using ::fwprintf;

   256 -

   257 -#  undef _RWSTD_NO_FWPRINTF

   258 -#endif   // _RWSTD_NO_FWPRINTF[_IN_LIBC]

   259 -

   260 -#ifndef _RWSTD_NO_FWSCANF

   261 -using ::fwscanf;

   262 -#elif !defined (_RWSTD_NO_FWSCANF_IN_LIBC)

   263 -

   264 -}   // namespace std

   265 -

   266 -extern "C" int fwscanf (FILE*, const wchar_t*, ...);

   267 -

   268 -namespace std {

   269 -

   270 -using ::fwscanf;

   271 -

   272 -#  undef _RWSTD_NO_FWSCANF

   273 -#endif   // _RWSTD_NO_FWSCANF[_IN_LIBC]

   274 -

   275 -#ifndef _RWSTD_NO_GETWC

   276 -using ::getwc;

   277 -#elif !defined (_RWSTD_NO_GETWC_IN_LIBC)

   278 -

   279 -}   // namespace std

   280 -

   281 -extern "C" wint_t getwc (FILE*);

   282 -

   283 -namespace std {

   284 -

   285 -using ::getwc;

   286 -

   287 -#  undef _RWSTD_NO_GETWC

   288 -#endif   // _RWSTD_NO_GETWC[_IN_LIBC]

   289 -

   290 -#ifndef _RWSTD_NO_PUTWC

   291 -using ::putwc;

   292 -#elif !defined (_RWSTD_NO_PUTWC_IN_LIBC)

   293 -

   294 -}   // namespace std

   295 -

   296 -extern "C" wint_t putwc (wint_t, FILE*);

   297 -

   298 -namespace std {

   299 -

   300 -using ::putwc;

   301 -

   302 -#  undef _RWSTD_NO_PUTWC

   303 -#endif   // _RWSTD_NO_PUTWC[_IN_LIBC]

   304 -

   305 -#ifndef _RWSTD_NO_GETWCHAR

   306 -using ::getwchar;

   307 -#elif !defined (_RWSTD_NO_GETWCHAR_IN_LIBC)

   308 -

   309 -}   // namespace std

   310 -

   311 -extern "C" wint_t getwchar ();

   312 -

   313 -namespace std {

   314 -

   315 -using ::getwchar;

   316 -

   317 -#  undef _RWSTD_NO_GETWCHAR

   318 -#endif   // _RWSTD_NO_GETWCHAR[_IN_LIBC]

   319 -

   320 -#ifndef _RWSTD_NO_PUTWCHAR

   321 -using ::putwchar;

   322 -#elif !defined (_RWSTD_NO_PUTWCHAR_IN_LIBC)

   323 -

   324 -}   // namespace std

   325 -

   326 -extern "C" wint_t putwchar (wint_t);

   327 -

   328 -namespace std {

   329 -

   330 -using ::putwchar;

   331 -

   332 -#  undef _RWSTD_NO_PUTWCHAR

   333 -#endif   // _RWSTD_NO_PUTWCHAR[_IN_LIBC]

   334 -

   335 -#ifndef _RWSTD_NO_SWPRINTF

   336 -using ::swprintf;

   337 -#elif !defined (_RWSTD_NO_SWPRINTF_IN_LIBC)

   338 -

   339 -}   // namespace std

   340 -

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

   342 -

   343 -extern "C" {

   344 -

   345 -_RWSTD_DLLIMPORT int

   346 -swprintf (wchar_t*, size_t, const wchar_t*, ...);

   347 -

   348 -}   // extern "C"

   349 -

   350 -#elif _MSC_VER == 1310   // MSVC 7.1

   351 -

   352 -// MSVC 8.0 defines the C++ overload of swprintf() inline

   353 -/* extern "C++" */ _RWSTD_DLLIMPORT int

   354 -swprintf (wchar_t*, size_t, const wchar_t*, ...);

   355 -

   356 -#else   // MSVC 8.0 and above

   357 -

   358 -// MSVC 7.1 declares two overloads of swprintf()

   359 -/* extern "C++" */ int

   360 -swprintf (wchar_t*, size_t, const wchar_t*, ...);

   361 -

   362 -#endif   // MSVC

   363 -

   364 -namespace std {

   365 -

   366 -using ::swprintf;

   367 -

   368 -#  undef _RWSTD_NO_SWPRINTF

   369 -#endif   // _RWSTD_NO_SWPRINTF[_IN_LIBC]

   370 -

   371 -#ifndef _RWSTD_NO_SWSCANF

   372 -using ::swscanf;

   373 -#elif !defined (_RWSTD_NO_SWSCANF_IN_LIBC)

   374 -

   375 -}   // namespace std

   376 -

   377 -extern "C" int swscanf (const wchar_t*, const wchar_t*, ...);

   378 -

   379 -namespace std {

   380 -

   381 -using ::swscanf;

   382 -

   383 -#  undef _RWSTD_NO_SWSCANF

   384 -#endif   // _RWSTD_NO_SWSCANF[_IN_LIBC]

   385 -

   386 -#ifndef _RWSTD_NO_UNGETWC

   387 -using ::ungetwc;

   388 -#elif !defined (_RWSTD_NO_UNGETWC_IN_LIBC)

   389 -

   390 -}   // namespace std

   391 -

   392 -extern "C" wint_t ungetwc (wint_t, FILE*);

   393 -

   394 -namespace std {

   395 -

   396 -using ::ungetwc;

   397 -

   398 -#  undef _RWSTD_NO_UNGETWC

   399 -#endif   // _RWSTD_NO_UNGETWC[_IN_LIBC]

   400 -

   401 -#ifndef _RWSTD_NO_VFWPRINTF

   402 -using ::vfwprintf;

   403 -#elif !defined (_RWSTD_NO_VFWPRINTF_IN_LIBC)

   404 -

   405 -}   // namespace std

   406 -

   407 -extern "C" int vfwprintf (FILE*, const wchar_t *format, _RWSTD_VA_LIST);

   408 -

   409 -namespace std {

   410 -

   411 -using ::vfwprintf;

   412 -

   413 -#  undef _RWSTD_NO_VFWPRINTF

   414 -#endif   // _RWSTD_NO_VFWPRINTF[_IN_LIBC]

   415 -

   416 -#ifndef _RWSTD_NO_VSWPRINTF

   417 -using ::vswprintf;

   418 -#elif !defined (_RWSTD_NO_VSWPRINTF_IN_LIBC)

   419 -

   420 -}   // namespace std

   421 -

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

   423 -

   424 -extern "C" {

   425 -

   426 -_RWSTD_DLLIMPORT int

   427 -vswprintf (wchar_t*, size_t, const wchar_t*, _RWSTD_VA_LIST);

   428 -

   429 -}   // extern "C"

   430 -

   431 -#elif _MSC_VER == 1310   // MSVC 7.1

   432 -

   433 -// MSVC 7.1 declares two overloads of swprintf()

   434 -/* extern "C++" */ _RWSTD_DLLIMPORT int

   435 -swprintf (wchar_t*, size_t, const wchar_t*, ...);

   436 -

   437 -#else   // MSVC 8.0 and above

   438 -

   439 -// MSVC 8.0 defines the C++ overload of vswprintf() inline

   440 -/* extern "C++" */ int

   441 -vswprintf (wchar_t*, size_t, const wchar_t*, _RWSTD_VA_LIST);

   442 -

   443 -#endif   // MSVC

   444 -

   445 -namespace std {

   446 -

   447 -using ::vswprintf;

   448 -

   449 -#  undef _RWSTD_NO_VSWPRINTF

   450 -#endif   // _RWSTD_NO_VSWPRINTF[_IN_LIBC]

   451 -

   452 -#ifndef _RWSTD_NO_VWPRINTF

   453 -using ::vwprintf;

   454 -#elif !defined (_RWSTD_NO_VWPRINTF_IN_LIBC)

   455 -

   456 -}   // namespace std

   457 -

   458 -extern "C" int vwprintf (const wchar_t*, _RWSTD_VA_LIST);

   459 -

   460 -namespace std {

   461 -

   462 -using ::vwprintf;

   463 -

   464 -#  undef _RWSTD_NO_VWPRINTF

   465 -#endif   // _RWSTD_NO_VWPRINTF[_IN_LIBC]

   466 -

   467 -#ifndef _RWSTD_NO_WPRINTF

   468 -using ::wprintf;

   469 -#elif !defined (_RWSTD_NO_WPRINTF_IN_LIBC)

   470 -

   471 -}   // namespace std

   472 -

   473 -extern "C" int wprintf (const wchar_t*, ...);

   474 -

   475 -namespace std {

   476 -

   477 -using ::wprintf;

   478 -

   479 -#  undef _RWSTD_NO_WPRINTF

   480 -#endif   // _RWSTD_NO_WPRINTF[_IN_LIBC]

   481 -

   482 -#ifndef _RWSTD_NO_WSCANF

   483 -using ::wscanf;

   484 -#elif !defined (_RWSTD_NO_WSCANF_IN_LIBC)

   485 -

   486 -}   // namespace std

   487 -

   488 -extern "C" int wscanf (const wchar_t*, ...);

   489 -

   490 -namespace std {

   491 -

   492 -using ::wscanf;

   493 -

   494 -#  undef _RWSTD_NO_WSCANF

   495 -#endif   // _RWSTD_NO_WSCANF[_IN_LIBC]

   496 -

   497 -#ifndef _RWSTD_NO_MBRLEN

   498 -using ::mbrlen;

   499 -#elif !defined (_RWSTD_NO_MBRLEN_IN_LIBC)

   500 -

   501 -}   // namespace std

   502 -

   503 -extern "C" size_t mbrlen (const char*, size_t, _RWSTD_MBSTATE_T*);

   504 -

   505 -namespace std {

   506 -

   507 -using ::mbrlen;

   508 -

   509 -#  undef _RWSTD_NO_MBRLEN

   510 -#endif   // _RWSTD_NO_MBRLEN

   511 -

   512 -#ifndef _RWSTD_NO_MBRTOWC

   513 -using ::mbrtowc;

   514 -#elif !defined (_RWSTD_NO_MBRTOWC_IN_LIBC)

   515 -

   516 -}   // namespace std

   517 -

   518 -extern "C" size_t mbrtowc (wchar_t*, const char*, size_t, _RWSTD_MBSTATE_T*);

   519 -

   520 -namespace std {

   521 -

   522 -using ::mbrtowc;

   523 -

   524 -#  undef _RWSTD_MBRTOWC

   525 -#endif   // _RWSTD_MBRTOWC[_IN_LIBC]

   526 -

   527 -#ifndef _RWSTD_NO_MBSINIT

   528 -using ::mbsinit;

   529 -#elif !defined (_RWSTD_NO_MBSINIT_IN_LIBC)

   530 -

   531 -}   // namespace std

   532 -

   533 -extern "C" int mbsinit (const _RWSTD_MBSTATE_T*);

   534 -

   535 -namespace std {

   536 -

   537 -using ::mbsinit;

   538 -

   539 -#  undef _RWSTD_NO_MBSINIT

   540 -#endif   // !_RWSTD_NO_MBSINIT_IN_LIBC

   541 -

   542 -#ifndef _RWSTD_NO_MBSRTOWCS

   543 -using ::mbsrtowcs;

   544 -#elif !defined (_RWSTD_NO_MBSRTOWCS_IN_LIBC)

   545 -

   546 -}   // namespace std

   547 -

   548 -extern "C" size_t mbsrtowcs (wchar_t*, const char**, size_t, _RWSTD_MBSTATE_T*);

   549 -

   550 -namespace std {

   551 -

   552 -using ::mbsrtowcs;

   553 -

   554 -#  undef _RWSTD_NO_MBSRTOWCS

   555 -#endif    // _RWSTD_NO_MBSRTOWCS

   556 -

   557 -#ifndef _RWSTD_NO_WCRTOMB

   558 -using ::wcrtomb;

   559 -#elif !defined (_RWSTD_NO_WCRTOMB_IN_LIBC)

   560 -

   561 -}   // namespace std

   562 -

   563 -extern "C" size_t wcrtomb (char*, wchar_t, _RWSTD_MBSTATE_T*);

   564 -

   565 -namespace std {

   566 -

   567 -using ::wcrtomb;

   568 -

   569 -#  undef _RWSTD_NO_WCRTOMB

   570 -#endif   // _RWSTD_NO_WCRTOMB

   571 -

   572 -#ifndef _RWSTD_NO_WCSCAT

   573 -using ::wcscat;

   574 -#elif !defined (_RWSTD_NO_WCSCAT_IN_LIBC)

   575 -

   576 -}   // namespace std

   577 -

   578 -extern "C" wchar_t* wcscat (wchar_t*, const wchar_t*);

   579 -

   580 -namespace std {

   581 -

   582 -using ::wcscat;

   583 -

   584 -#else   // if defined (_RWSTD_NO_WCSCAT)

   585 -

   586 -}   // namespace std

   587 -

   588 -extern "C" {

   589 -

   590 -inline wchar_t* wcscat (wchar_t *__dst, const wchar_t *__src)

   591 -{

   592 -    wchar_t *__s = __dst;

   593 -    for (; *__s; ++__s);

   594 -    while ((*__s++ = *__src++));

   595 -    return __dst;

   596 -}

   597 -

   598 -}   // extern "C"

   599 -

   600 -namespace std {

   601 -

   602 -using ::wcscat;

   603 -

   604 -#endif   // _RWSTD_NO_WCSCAT

   605 -

   606 -#undef _RWSTD_NO_WCSCAT

   607 -

   608 -

   609 -#ifndef _RWSTD_NO_WCSCHR

   610 -using ::wcschr;

   611 -#elif !defined (_RWSTD_NO_WCSCHR_IN_LIBC)

   612 -

   613 -}   // namespace std

   614 -

   615 -extern "C" wchar_t* wcschr (wchar_t*, wchar_t);

   616 -

   617 -inline const wchar_t* wcschr (const wchar_t *__s, wchar_t __c)

   618 -{

   619 -    return wcschr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);

   620 -}

   621 -

   622 -namespace std {

   623 -

   624 -using ::wcschr;

   625 -

   626 -#else   // if defined (_RWSTD_NO_WCSCHR)

   627 -

   628 -}   // namespace std

   629 -

   630 -extern "C" {

   631 -

   632 -inline wchar_t* wcschr (wchar_t *__s, wchar_t __c)

   633 -{

   634 -    do {

   635 -        if (*__s == __c)

   636 -            return __s;

   637 -    } while (*__s);

   638 -    return 0;

   639 -}

   640 -

   641 -}   // extern "C"

   642 -

   643 -inline const wchar_t* wcschr (const wchar_t *__s, wchar_t __c)

   644 -{

   645 -    return wcschr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);

   646 -}

   647 -

   648 -namespace std {

   649 -

   650 -using ::wcschr;

   651 -

   652 -#endif   // _RWSTD_NO_WCSCHR

   653 -

   654 -#undef _RWSTD_NO_WCSCHR

   655 -

   656 -

   657 -#ifndef _RWSTD_NO_WCSCMP

   658 -using ::wcscmp;

   659 -#elif !defined (_RWSTD_NO_WCSCMP_IN_LIBC)

   660 -

   661 -}   // namespace std

   662 -

   663 -extern "C" int wcscmp (const wchar_t*, const wchar_t*);

   664 -

   665 -namespace std {

   666 -

   667 -using ::wcscmp;

   668 -

   669 -#  undef _RWSTD_NO_WCSCMP

   670 -#endif   // _RWSTD_NO_WCSCMP

   671 -

   672 -#ifndef _RWSTD_NO_WCSCOLL

   673 -using ::wcscoll;

   674 -#elif !defined (_RWSTD_NO_WCSCOLL_IN_LIBC)

   675 -

   676 -}   // namespace std

   677 -

   678 -extern "C" int wcscoll (const wchar_t*, const wchar_t*);

   679 -

   680 -namespace std {

   681 -

   682 -using ::wcscoll;

   683 -

   684 -#  undef _RWSTD_NO_WCSCOLL

   685 -#endif   // _RWSTD_NO_WCSCOLL

   686 -

   687 -#ifndef _RWSTD_NO_WCSCPY

   688 -using ::wcscpy;

   689 -#else   // if defined (_RWSTD_NO_WCSCPY)

   690 -

   691 -}   // namespace std

   692 -

   693 -extern "C" {

   694 -

   695 -inline wchar_t* wcscpy (wchar_t *__dst, const wchar_t *__src)

   696 -{

   697 -    for (wchar_t *__s = __dst; (*__s++ = *__src++); );

   698 -    return __dst;

   699 -}

   700 -

   701 -}   // extern "C"

   702 -

   703 -namespace std {

   704 -

   705 -using ::wcscpy;

   706 -

   707 -#  undef _RWSTD_NO_WCSCPY

   708 -#endif   // _RWSTD_NO_WCSCPY

   709 -

   710 -

   711 -#ifndef _RWSTD_NO_WCSCSPN

   712 -using ::wcscspn;

   713 -#elif !defined (_RWSTD_NO_WCSCSPN_IN_LIBC)

   714 -

   715 -}   // namespace std

   716 -

   717 -extern "C" size_t wcscspn (const wchar_t*, const wchar_t*);

   718 -

   719 -namespace std {

   720 -

   721 -using ::wcscspn;

   722 -

   723 -#  undef _RWSTD_NO_WCSCSPN

   724 -#else

   725 -

   726 -}   // namespace std

   727 -

   728 -extern "C" {

   729 -

   730 -inline size_t wcscspn (const wchar_t *__s1, const wchar_t *__s2)

   731 -{

   732 -    const wchar_t *__s = __s1;

   733 -    for (; *__s; ++__s) {

   734 -        for (const wchar_t *__ss = __s2; *__ss; ++__ss)

   735 -            if (*__ss == *__s)

   736 -                return __s - __s1;

   737 -    }

   738 -    return __s - __s1;

   739 -}

   740 -

   741 -}   // extern "C"

   742 -

   743 -namespace std {

   744 -

   745 -using wcscspn;

   746 -

   747 -#  undef _RWSTD_NO_WCSCSPN

   748 -#endif   // _RWSTD_NO_WCSCSPN

   749 -

   750 -#ifndef _RWSTD_NO_WCSFTIME

   751 -using ::wcsftime;

   752 -#elif !defined (_RWSTD_NO_WCSFTIME_IN_LIBC)

   753 -

   754 -}   // namespace std

   755 -

   756 -extern "C" size_t wcsftime (wchar_t*, size_t, const wchar_t*, const struct tm*);

   757 -

   758 -namespace std {

   759 -

   760 -using ::wcsftime;

   761 -

   762 -#endif   // _RWSTD_NO_WCSFTIME

   763 -

   764 -

   765 -#ifndef _RWSTD_NO_WCSLEN

   766 -using ::wcslen;

   767 -#elif !defined (_RWSTD_NO_WCSLEN_IN_LIBC)

   768 -

   769 -}   // namespace std

   770 -

   771 -extern "C" size_t wcslen (const wchar_t*);

   772 -

   773 -namespace std {

   774 -

   775 -using ::wcslen;

   776 -

   777 -#  undef _RWSTD_NO_WCSLEN

   778 -#else   // defined (_RWSTD_NO_WCSLEN)

   779 -

   780 -}   // namespace std

   781 -

   782 -extern "C" {

   783 -

   784 -inline size_t wcslen (const wchar_t* __s)

   785 -{

   786 -    const wchar_t *__begin = __s;

   787 -    while (*__s)

   788 -        ++__s;

   789 -    return __s - __begin;

   790 -}

   791 -

   792 -}   // extern "C"

   793 -

   794 -namespace std {

   795 -

   796 -using ::wcslen;

   797 -

   798 -#  undef _RWSTD_NO_WCSLEN

   799 -#endif   // _RWSTD_NO_WCSLEN

   800 -

   801 -

   802 -#ifndef _RWSTD_NO_WCSNCAT

   803 -using ::wcsncat;

   804 -#elif !defined (_RWSTD_NO_WCSNCAT_IN_LIBC)

   805 -

   806 -}   // namespace std

   807 -

   808 -extern "C" wchar_t* wcsncat (wchar_t*, const wchar_t*, size_t);

   809 -

   810 -namespace std {

   811 -

   812 -using ::wcsncat;

   813 -

   814 -#  undef _RWSTD_NO_WCSNCAT

   815 -#else

   816 -

   817 -}   // namespace std

   818 -

   819 -extern "C" {

   820 -

   821 -inline wchar_t* wcsncat (wchar_t *__dst, const wchar_t *__src, size_t __n)

   822 -{

   823 -    wchar_t *__s = __dst;

   824 -    for (; *__s; ++__s);

   825 -    while (__n--)

   826 -        if (!(*__s++ = *__src++))

   827 -            return __dst;

   828 -    *__s = 0;

   829 -    return __dst;

   830 -}

   831 -

   832 -}   // extern "C"

   833 -

   834 -namespace std {

   835 -

   836 -using ::wcsncat;

   837 -

   838 -#  undef _RWSTD_NO_WCSNCAT

   839 -#endif   // _RWSTD_NO_WCSNCAT

   840 -

   841 -#ifndef _RWSTD_NO_WCSNCMP

   842 -using ::wcsncmp;

   843 -#elif !defined (_RWSTD_NO_WCSNCMP_IN_LIBC)

   844 -

   845 -}   // namespace std

   846 -

   847 -extern "C" int wcsncmp (const wchar_t*, const wchar_t*, size_t);

   848 -

   849 -namespace std {

   850 -

   851 -using ::wcsncmp;

   852 -

   853 -#  undef _RWSTD_NO_WCSNCMP

   854 -#else

   855 -

   856 -}   // namespace std

   857 -

   858 -extern "C" {

   859 -

   860 -inline int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)

   861 -{

   862 -    if (!__n)

   863 -        return 0;

   864 -    for (; --__n && *__s1 && *__s1 == *__s2; ++__s1, ++__s2);

   865 -    return int (*__s1 - *__s2);

   866 -}

   867 -

   868 -}   // extern "C"

   869 -

   870 -namespace std {

   871 -

   872 -using ::wcsncmp;

   873 -

   874 -#  undef _RWSTD_NO_WCSNCMP

   875 -#endif   // _RWSTD_NO_WCSNCMP

   876 -

   877 -

   878 -#ifndef _RWSTD_NO_WCSNCPY

   879 -using ::wcsncpy;

   880 -#elif !defined (_RWSTD_NO_WCSNCPY_IN_LIBC)

   881 -

   882 -}   // namespace std

   883 -

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

   885 -

   886 -namespace std {

   887 -

   888 -using ::wcsncpy;

   889 -

   890 -#  undef _RWSTD_NO_WCSNCPY

   891 -#else   // if defined (_RWSTD_NO_WCSNCPY)

   892 -

   893 -}   // namespace std

   894 -

   895 -extern "C" {

   896 -

   897 -inline wchar_t* wcsncpy (wchar_t *__dst, const wchar_t *__src, size_t __n)

   898 -{

   899 -    wchar_t *__s = __dst;

   900 -    for (; __n && (*__s++ = *__src++); --__n);

   901 -    while (__n--)

   902 -        *__s = 0;

   903 -    return __dst;

   904 -}

   905 -

   906 -}   // extern "C"

   907 -

   908 -namespace std {

   909 -

   910 -using ::wcsncpy;

   911 -

   912 -#  undef _RWSTD_NO_WCSNCPY

   913 -#endif   // _RWSTD_NO_WCSNCPY

   914 -

   915 -

   916 -#ifndef _RWSTD_NO_WCSPBRK

   917 -using ::wcspbrk;

   918 -#elif !defined (_RWSTD_NO_WCSPBRK_IN_LIBC)

   919 -

   920 -}   // namespace std

   921 -

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

   923 -

   924 -inline const wchar_t* wcspbrk (const wchar_t *__s1, const wchar_t *__s2)

   925 -{

   926 -    return wcspbrk (_RWSTD_CONST_CAST (wchar_t*, __s1), __s2);

   927 -}

   928 -

   929 -namespace std {

   930 -

   931 -using ::wcspbrk;

   932 -

   933 -#  undef _RWSTD_NO_WCSPBRK

   934 -#endif   // _RWSTD_NO_WCSPBRK

   935 -

   936 -

   937 -#ifndef _RWSTD_NO_WCSRCHR

   938 -using ::wcsrchr;

   939 -#elif !defined (_RWSTD_NO_WCSRCHR_IN_LIBC)

   940 -

   941 -}   // namespace std

   942 -

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

   944 -

   945 -wchar_t* wcsrchr (wchar_t *__s, wchar_t __c)

   946 -{

   947 -    return wcsrchr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);

   948 -}

   949 -

   950 -namespace std {

   951 -

   952 -using ::wcsrchr;

   953 -

   954 -#  undef _RWSTD_NO_WCSRCHR

   955 -#else   // if defined (_RWSTD_NO_WCSRCHR)

   956 -

   957 -}   // namespace std

   958 -

   959 -extern "C" {

   960 -

   961 -inline wchar_t* wcsrchr (wchar_t *__s, wchar_t __c)

   962 -{

   963 -    const wchar_t *__ss = __s;

   964 -    while (*__ss++);

   965 -    while (--__ss != __s && *__ss != __c);

   966 -    return *__ss == __c ? __ss : 0;

   967 -}

   968 -

   969 -}   // extern "C"

   970 -

   971 -inline const wchar_t* wcsrchr (const wchar_t *__s, wchar_t __c)

   972 -{

   973 -    return wcsrchr (_RWSTD_CONST_CAST (wchar_t*, __s), __c);

   974 -}

   975 -

   976 -}   // extern "C"

   977 -

   978 -namespace std {

   979 -

   980 -using ::wcsrchr;

   981 -

   982 -#  undef _RWSTD_NO_WCSRCHR

   983 -#endif   // _RWSTD_NO_WCSRCHR

   984 -

   985 -

   986 -#ifndef _RWSTD_NO_WCSRTOMBS

   987 -using ::wcsrtombs;

   988 -#elif !defined (_RWSTD_NO_WCSRTOMBS_IN_LIBC)

   989 -

   990 -}   // namespace std

   991 -

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

   993 -

   994 -namespace std {

   995 -

   996 -using ::wcsrtombs;

   997 -

   998 -#  undef _RWSTD_NO_WCSRTOMBS

   999 -#endif   // _RWSTD_NO_WCSRTOMBS

  1000 -

  1001 -#ifndef _RWSTD_NO_WCSSPN

  1002 -using ::wcsspn;

  1003 -#else

  1004 -

  1005 -}   // namespace std

  1006 -

  1007 -extern "C" {

  1008 -

  1009 -inline size_t wcsspn (const wchar_t *__s1, const wchar_t *__s2)

  1010 -{

  1011 -    const wchar_t *__s = __s1;

  1012 -    for (; *__s; ++__s) {

  1013 -        for (const wchar_t *__ss = __s2; *__ss != *__s; ++__ss)

  1014 -            if (!*__ss)

  1015 -                return __s - __s1;

  1016 -    }

  1017 -    return __s - __s1;

  1018 -}

  1019 -

  1020 -}   // extern "C"

  1021 -

  1022 -namespace std {

  1023 -

  1024 -using ::wcsspn;

  1025 -

  1026 -#  undef _RWSTD_NO_WCSSPN

  1027 -#endif   // _RWSTD_NO_WCSSPN

  1028 -

  1029 -#ifndef _RWSTD_NO_WCSSTR

  1030 -using ::wcsstr;

  1031 -#elif !defined (_RWSTD_NO_WCSSTR_IN_LIBC)

  1032 -

  1033 -}   // namespace std

  1034 -

  1035 -extern "C" wchar_t* wcsstr (wchar_t*, const wchar_t*);

  1036 -

  1037 -inline const wchar_t* wcsstr (const wchar_t *__s1, const wchar_t *__s2)

  1038 -{

  1039 -    return wcsstr (_RWSTD_CONST_CAST (wchar_t*, __s1), __s2);

  1040 -}

  1041 -

  1042 -namespace std {

  1043 -

  1044 -using ::wcsstr;

  1045 -

  1046 -#  undef _RWSTD_NO_WCSSTR

  1047 -#else

  1048 -

  1049 -#  ifdef _RWSTD_OS_HPUX

  1050 -

  1051 -}   // namespace std

  1052 -

  1053 -extern "C" {

  1054 -

  1055 -inline wchar_t* wcsstr (wchar_t *__s1, const wchar_t *__s2)

  1056 -{

  1057 -    return wcswcs (__s1, __s2);

  1058 -}

  1059 -

  1060 -}   // extern "C"

  1061 -

  1062 -inline wchar_t* wcsstr (wchar_t *__s1, const wchar_t *__s2)

  1063 -{

  1064 -    return wcswcs (__s1, __s2);

  1065 -}

  1066 -

  1067 -namespace std {

  1068 -

  1069 -using ::wcsstr;

  1070 -

  1071 -#    undef _RWSTD_NO_WCSSTR

  1072 -#  endif   // _RWSTD_OS_HPUX

  1073 -

  1074 -#endif   // _RWSTD_NO_WCSSTR

  1075 -

  1076 -#ifndef _RWSTD_NO_WCSTOD

  1077 -using ::wcstod;

  1078 -#elif !defined (_RWSTD_NO_WCSTOD_IN_LIBC)

  1079 -

  1080 -}   // namespace std

  1081 -

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

  1083 -

  1084 -namespace std {

  1085 -

  1086 -using ::wcstod;

  1087 -

  1088 -#  undef _RWSTD_NO_WCSTOD

  1089 -#endif   // _RWSTD_NO_WCSTOD[_IN_LIBC]

  1090 -

  1091 -#ifndef _RWSTD_NO_WCSTOK

  1092 -using ::wcstok;

  1093 -#elif !defined (_RWSTD_NO_WCSTOK_IN_LIBC)

  1094 -

  1095 -}   // namespace std

  1096 -

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

  1098 -

  1099 -namespace std {

  1100 -

  1101 -using ::wcstok;

  1102 -

  1103 -#  undef _RWSTD_NO_WCSTOK

  1104 -#elif defined (_MSC_VER) && 1400 <= _MSC_VER

  1105 -

  1106 -}   // namespace std

  1107 -

  1108 -/* extern "C++" */ inline wchar_t*

  1109 -wcstok (wchar_t* __s1, const wchar_t* __s2, wchar_t** __ptr)

  1110 -{

  1111 -    return wcstok_s (__s1, __s2, __ptr);

  1112 -}

  1113 -

  1114 -namespace std {

  1115 -

  1116 -using ::wcstok;

  1117 -

  1118 -#  undef _RWSTD_NO_WCSTOK

  1119 -#  undef _RWSTD_NO_WCSTOK_IN_LIBC

  1120 -#endif   // _RWSTD_NO_WCSTOK[_IN_LIBC]

  1121 -

  1122 -#ifndef _RWSTD_NO_WCSTOL

  1123 -using ::wcstol;

  1124 -#elif !defined (_RWSTD_NO_WCSTOL_IN_LIBC)

  1125 -

  1126 -}   // namespace std

  1127 -

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

  1129 -

  1130 -namespace std {

  1131 -

  1132 -using ::wcstol;

  1133 -

  1134 -#  undef _RWSTD_NO_WCSTOL

  1135 -#endif   // _RWSTD_NO_WCSTOL[_IN_LIBC]