gnu/usr.bin/grep/libgreputils/wchar.h

   1 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
   2 /* A substitute for ISO C99 <wchar.h>, for platforms that have issues.
   3
   4    Copyright (C) 2007-2015 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Written by Eric Blake.  */
  20
  21 /*
  22  * ISO C 99 <wchar.h> for platforms that have issues.
  23  * <http://www.opengroup.org/susv3xbd/wchar.h.html>
  24  *
  25  * For now, this just ensures proper prerequisite inclusion order and
  26  * the declaration of wcwidth().
  27  */
  28
  29 #if __GNUC__ >= 3
  30 #pragma GCC system_header
  31 #endif
  32
  33
  34 #if (((defined __need_mbstate_t || defined __need_wint_t)               \
  35       && !defined __MINGW32__)                                          \
  36      || (defined __hpux                                                 \
  37          && ((defined _INTTYPES_INCLUDED && !defined strtoimax)         \
  38              || defined _GL_JUST_INCLUDE_SYSTEM_WCHAR_H))               \
  39      || defined _GL_ALREADY_INCLUDING_WCHAR_H)
  40 /* Special invocation convention:
  41    - Inside glibc and uClibc header files, but not MinGW.
  42    - On HP-UX 11.00 we have a sequence of nested includes
  43      <wchar.h> -> <stdlib.h> -> <stdint.h>, and the latter includes <wchar.h>,
  44      once indirectly <stdint.h> -> <sys/types.h> -> <inttypes.h> -> <wchar.h>
  45      and once directly.  In both situations 'wint_t' is not yet defined,
  46      therefore we cannot provide the function overrides; instead include only
  47      the system's <wchar.h>.
  48    - On IRIX 6.5, similarly, we have an include <wchar.h> -> <wctype.h>, and
  49      the latter includes <wchar.h>.  But here, we have no way to detect whether
  50      <wctype.h> is completely included or is still being included.  */
  51
  52 #include_next <wchar.h>
  53
  54 #else
  55 /* Normal invocation convention.  */
  56
  57 #ifndef _GL_WCHAR_H
  58
  59 #define _GL_ALREADY_INCLUDING_WCHAR_H
  60
  61 #if 0
  62 # include <features.h> /* for __GLIBC__ */
  63 #endif
  64
  65 /* Tru64 with Desktop Toolkit C has a bug: <stdio.h> must be included before
  66    <wchar.h>.
  67    BSD/OS 4.0.1 has a bug: <stddef.h>, <stdio.h> and <time.h> must be
  68    included before <wchar.h>.
  69    In some builds of uClibc, <wchar.h> is nonexistent and wchar_t is defined
  70    by <stddef.h>.
  71    But avoid namespace pollution on glibc systems.  */
  72 #if !(defined __GLIBC__ && !defined __UCLIBC__)
  73 # include <stddef.h>
  74 #endif
  75 #ifndef __GLIBC__
  76 # include <stdio.h>
  77 # include <time.h>
  78 #endif
  79
  80 /* Include the original <wchar.h> if it exists.
  81    Some builds of uClibc lack it.  */
  82 /* The include_next requires a split double-inclusion guard.  */
  83 #if 1
  84 # include_next <wchar.h>
  85 #endif
  86
  87 #undef _GL_ALREADY_INCLUDING_WCHAR_H
  88
  89 #ifndef _GL_WCHAR_H
  90 #define _GL_WCHAR_H
  91
  92 /* The __attribute__ feature is available in gcc versions 2.5 and later.
  93    The attribute __pure__ was added in gcc 2.96.  */
  94 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
  95 # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
  96 #else
  97 # define _GL_ATTRIBUTE_PURE /* empty */
  98 #endif
  99
 100 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
 101 #ifndef _GL_CXXDEFS_H
 102 #define _GL_CXXDEFS_H
 103
 104 /* The three most frequent use cases of these macros are:
 105
 106    * For providing a substitute for a function that is missing on some
 107      platforms, but is declared and works fine on the platforms on which
 108      it exists:
 109
 110        #if @GNULIB_FOO@
 111        # if !@HAVE_FOO@
 112        _GL_FUNCDECL_SYS (foo, ...);
 113        # endif
 114        _GL_CXXALIAS_SYS (foo, ...);
 115        _GL_CXXALIASWARN (foo);
 116        #elif defined GNULIB_POSIXCHECK
 117        ...
 118        #endif
 119
 120    * For providing a replacement for a function that exists on all platforms,
 121      but is broken/insufficient and needs to be replaced on some platforms:
 122
 123        #if @GNULIB_FOO@
 124        # if @REPLACE_FOO@
 125        #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 126        #   undef foo
 127        #   define foo rpl_foo
 128        #  endif
 129        _GL_FUNCDECL_RPL (foo, ...);
 130        _GL_CXXALIAS_RPL (foo, ...);
 131        # else
 132        _GL_CXXALIAS_SYS (foo, ...);
 133        # endif
 134        _GL_CXXALIASWARN (foo);
 135        #elif defined GNULIB_POSIXCHECK
 136        ...
 137        #endif
 138
 139    * For providing a replacement for a function that exists on some platforms
 140      but is broken/insufficient and needs to be replaced on some of them and
 141      is additionally either missing or undeclared on some other platforms:
 142
 143        #if @GNULIB_FOO@
 144        # if @REPLACE_FOO@
 145        #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 146        #   undef foo
 147        #   define foo rpl_foo
 148        #  endif
 149        _GL_FUNCDECL_RPL (foo, ...);
 150        _GL_CXXALIAS_RPL (foo, ...);
 151        # else
 152        #  if !@HAVE_FOO@   or   if !@HAVE_DECL_FOO@
 153        _GL_FUNCDECL_SYS (foo, ...);
 154        #  endif
 155        _GL_CXXALIAS_SYS (foo, ...);
 156        # endif
 157        _GL_CXXALIASWARN (foo);
 158        #elif defined GNULIB_POSIXCHECK
 159        ...
 160        #endif
 161 */
 162
 163 /* _GL_EXTERN_C declaration;
 164    performs the declaration with C linkage.  */
 165 #if defined __cplusplus
 166 # define _GL_EXTERN_C extern "C"
 167 #else
 168 # define _GL_EXTERN_C extern
 169 #endif
 170
 171 /* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);
 172    declares a replacement function, named rpl_func, with the given prototype,
 173    consisting of return type, parameters, and attributes.
 174    Example:
 175      _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)
 176                                   _GL_ARG_NONNULL ((1)));
 177  */
 178 #define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \
 179   _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)
 180 #define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \
 181   _GL_EXTERN_C rettype rpl_func parameters_and_attributes
 182
 183 /* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);
 184    declares the system function, named func, with the given prototype,
 185    consisting of return type, parameters, and attributes.
 186    Example:
 187      _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)
 188                                   _GL_ARG_NONNULL ((1)));
 189  */
 190 #define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \
 191   _GL_EXTERN_C rettype func parameters_and_attributes
 192
 193 /* _GL_CXXALIAS_RPL (func, rettype, parameters);
 194    declares a C++ alias called GNULIB_NAMESPACE::func
 195    that redirects to rpl_func, if GNULIB_NAMESPACE is defined.
 196    Example:
 197      _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));
 198  */
 199 #define _GL_CXXALIAS_RPL(func,rettype,parameters) \
 200   _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)
 201 #if defined __cplusplus && defined GNULIB_NAMESPACE
 202 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
 203     namespace GNULIB_NAMESPACE                                \
 204     {                                                         \
 205       rettype (*const func) parameters = ::rpl_func;          \
 206     }                                                         \
 207     _GL_EXTERN_C int _gl_cxxalias_dummy
 208 #else
 209 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
 210     _GL_EXTERN_C int _gl_cxxalias_dummy
 211 #endif
 212
 213 /* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);
 214    is like  _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);
 215    except that the C function rpl_func may have a slightly different
 216    declaration.  A cast is used to silence the "invalid conversion" error
 217    that would otherwise occur.  */
 218 #if defined __cplusplus && defined GNULIB_NAMESPACE
 219 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
 220     namespace GNULIB_NAMESPACE                                     \
 221     {                                                              \
 222       rettype (*const func) parameters =                           \
 223         reinterpret_cast<rettype(*)parameters>(::rpl_func);        \
 224     }                                                              \
 225     _GL_EXTERN_C int _gl_cxxalias_dummy
 226 #else
 227 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
 228     _GL_EXTERN_C int _gl_cxxalias_dummy
 229 #endif
 230
 231 /* _GL_CXXALIAS_SYS (func, rettype, parameters);
 232    declares a C++ alias called GNULIB_NAMESPACE::func
 233    that redirects to the system provided function func, if GNULIB_NAMESPACE
 234    is defined.
 235    Example:
 236      _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));
 237  */
 238 #if defined __cplusplus && defined GNULIB_NAMESPACE
 239   /* If we were to write
 240        rettype (*const func) parameters = ::func;
 241      like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls
 242      better (remove an indirection through a 'static' pointer variable),
 243      but then the _GL_CXXALIASWARN macro below would cause a warning not only
 244      for uses of ::func but also for uses of GNULIB_NAMESPACE::func.  */
 245 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \
 246     namespace GNULIB_NAMESPACE                     \
 247     {                                              \
 248       static rettype (*func) parameters = ::func;  \
 249     }                                              \
 250     _GL_EXTERN_C int _gl_cxxalias_dummy
 251 #else
 252 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \
 253     _GL_EXTERN_C int _gl_cxxalias_dummy
 254 #endif
 255
 256 /* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);
 257    is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
 258    except that the C function func may have a slightly different declaration.
 259    A cast is used to silence the "invalid conversion" error that would
 260    otherwise occur.  */
 261 #if defined __cplusplus && defined GNULIB_NAMESPACE
 262 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
 263     namespace GNULIB_NAMESPACE                          \
 264     {                                                   \
 265       static rettype (*func) parameters =               \
 266         reinterpret_cast<rettype(*)parameters>(::func); \
 267     }                                                   \
 268     _GL_EXTERN_C int _gl_cxxalias_dummy
 269 #else
 270 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
 271     _GL_EXTERN_C int _gl_cxxalias_dummy
 272 #endif
 273
 274 /* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);
 275    is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
 276    except that the C function is picked among a set of overloaded functions,
 277    namely the one with rettype2 and parameters2.  Two consecutive casts
 278    are used to silence the "cannot find a match" and "invalid conversion"
 279    errors that would otherwise occur.  */
 280 #if defined __cplusplus && defined GNULIB_NAMESPACE
 281   /* The outer cast must be a reinterpret_cast.
 282      The inner cast: When the function is defined as a set of overloaded
 283      functions, it works as a static_cast<>, choosing the designated variant.
 284      When the function is defined as a single variant, it works as a
 285      reinterpret_cast<>. The parenthesized cast syntax works both ways.  */
 286 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
 287     namespace GNULIB_NAMESPACE                                                \
 288     {                                                                         \
 289       static rettype (*func) parameters =                                     \
 290         reinterpret_cast<rettype(*)parameters>(                               \
 291           (rettype2(*)parameters2)(::func));                                  \
 292     }                                                                         \
 293     _GL_EXTERN_C int _gl_cxxalias_dummy
 294 #else
 295 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
 296     _GL_EXTERN_C int _gl_cxxalias_dummy
 297 #endif
 298
 299 /* _GL_CXXALIASWARN (func);
 300    causes a warning to be emitted when ::func is used but not when
 301    GNULIB_NAMESPACE::func is used.  func must be defined without overloaded
 302    variants.  */
 303 #if defined __cplusplus && defined GNULIB_NAMESPACE
 304 # define _GL_CXXALIASWARN(func) \
 305    _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)
 306 # define _GL_CXXALIASWARN_1(func,namespace) \
 307    _GL_CXXALIASWARN_2 (func, namespace)
 308 /* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
 309    we enable the warning only when not optimizing.  */
 310 # if !__OPTIMIZE__
 311 #  define _GL_CXXALIASWARN_2(func,namespace) \
 312     _GL_WARN_ON_USE (func, \
 313                      "The symbol ::" #func " refers to the system function. " \
 314                      "Use " #namespace "::" #func " instead.")
 315 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
 316 #  define _GL_CXXALIASWARN_2(func,namespace) \
 317      extern __typeof__ (func) func
 318 # else
 319 #  define _GL_CXXALIASWARN_2(func,namespace) \
 320      _GL_EXTERN_C int _gl_cxxalias_dummy
 321 # endif
 322 #else
 323 # define _GL_CXXALIASWARN(func) \
 324     _GL_EXTERN_C int _gl_cxxalias_dummy
 325 #endif
 326
 327 /* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);
 328    causes a warning to be emitted when the given overloaded variant of ::func
 329    is used but not when GNULIB_NAMESPACE::func is used.  */
 330 #if defined __cplusplus && defined GNULIB_NAMESPACE
 331 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
 332    _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \
 333                         GNULIB_NAMESPACE)
 334 # define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \
 335    _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)
 336 /* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
 337    we enable the warning only when not optimizing.  */
 338 # if !__OPTIMIZE__
 339 #  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
 340     _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \
 341                          "The symbol ::" #func " refers to the system function. " \
 342                          "Use " #namespace "::" #func " instead.")
 343 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
 344 #  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
 345      extern __typeof__ (func) func
 346 # else
 347 #  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
 348      _GL_EXTERN_C int _gl_cxxalias_dummy
 349 # endif
 350 #else
 351 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
 352     _GL_EXTERN_C int _gl_cxxalias_dummy
 353 #endif
 354
 355 #endif /* _GL_CXXDEFS_H */
 356
 357 /* The definition of _GL_ARG_NONNULL is copied here.  */
 358 /* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
 359    that the values passed as arguments n, ..., m must be non-NULL pointers.
 360    n = 1 stands for the first argument, n = 2 for the second argument etc.  */
 361 #ifndef _GL_ARG_NONNULL
 362 # if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
 363 #  define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
 364 # else
 365 #  define _GL_ARG_NONNULL(params)
 366 # endif
 367 #endif
 368
 369 /* The definition of _GL_WARN_ON_USE is copied here.  */
 370 #ifndef _GL_WARN_ON_USE
 371
 372 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
 373 /* A compiler attribute is available in gcc versions 4.3.0 and later.  */
 374 #  define _GL_WARN_ON_USE(function, message) \
 375 extern __typeof__ (function) function __attribute__ ((__warning__ (message)))
 376 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
 377 /* Verify the existence of the function.  */
 378 #  define _GL_WARN_ON_USE(function, message) \
 379 extern __typeof__ (function) function
 380 # else /* Unsupported.  */
 381 #  define _GL_WARN_ON_USE(function, message) \
 382 _GL_WARN_EXTERN_C int _gl_warn_on_use
 383 # endif
 384 #endif
 385
 386 /* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")
 387    is like _GL_WARN_ON_USE (function, "string"), except that the function is
 388    declared with the given prototype, consisting of return type, parameters,
 389    and attributes.
 390    This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does
 391    not work in this case.  */
 392 #ifndef _GL_WARN_ON_USE_CXX
 393 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
 394 #  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
 395 extern rettype function parameters_and_attributes \
 396      __attribute__ ((__warning__ (msg)))
 397 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
 398 /* Verify the existence of the function.  */
 399 #  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
 400 extern rettype function parameters_and_attributes
 401 # else /* Unsupported.  */
 402 #  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
 403 _GL_WARN_EXTERN_C int _gl_warn_on_use
 404 # endif
 405 #endif
 406
 407 /* _GL_WARN_EXTERN_C declaration;
 408    performs the declaration with C linkage.  */
 409 #ifndef _GL_WARN_EXTERN_C
 410 # if defined __cplusplus
 411 #  define _GL_WARN_EXTERN_C extern "C"
 412 # else
 413 #  define _GL_WARN_EXTERN_C extern
 414 # endif
 415 #endif
 416
 417
 418 /* Define wint_t and WEOF.  (Also done in wctype.in.h.)  */
 419 #if !1 && !defined wint_t
 420 # define wint_t int
 421 # ifndef WEOF
 422 #  define WEOF -1
 423 # endif
 424 #else
 425 /* MSVC defines wint_t as 'unsigned short' in <crtdefs.h>.
 426    This is too small: ISO C 99 section 7.24.1.(2) says that wint_t must be
 427    "unchanged by default argument promotions".  Override it.  */
 428 # if defined _MSC_VER
 429 #  if !GNULIB_defined_wint_t
 430 #   include <crtdefs.h>
 431 typedef unsigned int rpl_wint_t;
 432 #   undef wint_t
 433 #   define wint_t rpl_wint_t
 434 #   define GNULIB_defined_wint_t 1
 435 #  endif
 436 # endif
 437 # ifndef WEOF
 438 #  define WEOF ((wint_t) -1)
 439 # endif
 440 #endif
 441
 442
 443 /* Override mbstate_t if it is too small.
 444    On IRIX 6.5, sizeof (mbstate_t) == 1, which is not sufficient for
 445    implementing mbrtowc for encodings like UTF-8.  */
 446 #if !(1 && 1) || 0
 447 # if !GNULIB_defined_mbstate_t
 448 typedef int rpl_mbstate_t;
 449 #  undef mbstate_t
 450 #  define mbstate_t rpl_mbstate_t
 451 #  define GNULIB_defined_mbstate_t 1
 452 # endif
 453 #endif
 454
 455
 456 /* Convert a single-byte character to a wide character.  */
 457 #if 1
 458 # if 0
 459 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 460 #   undef btowc
 461 #   define btowc rpl_btowc
 462 #  endif
 463 _GL_FUNCDECL_RPL (btowc, wint_t, (int c) _GL_ATTRIBUTE_PURE);
 464 _GL_CXXALIAS_RPL (btowc, wint_t, (int c));
 465 # else
 466 #  if !1
 467 _GL_FUNCDECL_SYS (btowc, wint_t, (int c) _GL_ATTRIBUTE_PURE);
 468 #  endif
 469 _GL_CXXALIAS_SYS (btowc, wint_t, (int c));
 470 # endif
 471 _GL_CXXALIASWARN (btowc);
 472 #elif defined GNULIB_POSIXCHECK
 473 # undef btowc
 474 # if HAVE_RAW_DECL_BTOWC
 475 _GL_WARN_ON_USE (btowc, "btowc is unportable - "
 476                  "use gnulib module btowc for portability");
 477 # endif
 478 #endif
 479
 480
 481 /* Convert a wide character to a single-byte character.  */
 482 #if 1
 483 # if 0
 484 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 485 #   undef wctob
 486 #   define wctob rpl_wctob
 487 #  endif
 488 _GL_FUNCDECL_RPL (wctob, int, (wint_t wc) _GL_ATTRIBUTE_PURE);
 489 _GL_CXXALIAS_RPL (wctob, int, (wint_t wc));
 490 # else
 491 #  if !defined wctob && !1
 492 /* wctob is provided by gnulib, or wctob exists but is not declared.  */
 493 _GL_FUNCDECL_SYS (wctob, int, (wint_t wc) _GL_ATTRIBUTE_PURE);
 494 #  endif
 495 _GL_CXXALIAS_SYS (wctob, int, (wint_t wc));
 496 # endif
 497 _GL_CXXALIASWARN (wctob);
 498 #elif defined GNULIB_POSIXCHECK
 499 # undef wctob
 500 # if HAVE_RAW_DECL_WCTOB
 501 _GL_WARN_ON_USE (wctob, "wctob is unportable - "
 502                  "use gnulib module wctob for portability");
 503 # endif
 504 #endif
 505
 506
 507 /* Test whether *PS is in the initial state.  */
 508 #if 1
 509 # if 0
 510 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 511 #   undef mbsinit
 512 #   define mbsinit rpl_mbsinit
 513 #  endif
 514 _GL_FUNCDECL_RPL (mbsinit, int, (const mbstate_t *ps));
 515 _GL_CXXALIAS_RPL (mbsinit, int, (const mbstate_t *ps));
 516 # else
 517 #  if !1
 518 _GL_FUNCDECL_SYS (mbsinit, int, (const mbstate_t *ps));
 519 #  endif
 520 _GL_CXXALIAS_SYS (mbsinit, int, (const mbstate_t *ps));
 521 # endif
 522 _GL_CXXALIASWARN (mbsinit);
 523 #elif defined GNULIB_POSIXCHECK
 524 # undef mbsinit
 525 # if HAVE_RAW_DECL_MBSINIT
 526 _GL_WARN_ON_USE (mbsinit, "mbsinit is unportable - "
 527                  "use gnulib module mbsinit for portability");
 528 # endif
 529 #endif
 530
 531
 532 /* Convert a multibyte character to a wide character.  */
 533 #if 1
 534 # if 0
 535 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 536 #   undef mbrtowc
 537 #   define mbrtowc rpl_mbrtowc
 538 #  endif
 539 _GL_FUNCDECL_RPL (mbrtowc, size_t,
 540                   (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps));
 541 _GL_CXXALIAS_RPL (mbrtowc, size_t,
 542                   (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps));
 543 # else
 544 #  if !1
 545 _GL_FUNCDECL_SYS (mbrtowc, size_t,
 546                   (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps));
 547 #  endif
 548 _GL_CXXALIAS_SYS (mbrtowc, size_t,
 549                   (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps));
 550 # endif
 551 _GL_CXXALIASWARN (mbrtowc);
 552 #elif defined GNULIB_POSIXCHECK
 553 # undef mbrtowc
 554 # if HAVE_RAW_DECL_MBRTOWC
 555 _GL_WARN_ON_USE (mbrtowc, "mbrtowc is unportable - "
 556                  "use gnulib module mbrtowc for portability");
 557 # endif
 558 #endif
 559
 560
 561 /* Recognize a multibyte character.  */
 562 #if 1
 563 # if 0
 564 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 565 #   undef mbrlen
 566 #   define mbrlen rpl_mbrlen
 567 #  endif
 568 _GL_FUNCDECL_RPL (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps));
 569 _GL_CXXALIAS_RPL (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps));
 570 # else
 571 #  if !1
 572 _GL_FUNCDECL_SYS (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps));
 573 #  endif
 574 _GL_CXXALIAS_SYS (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps));
 575 # endif
 576 _GL_CXXALIASWARN (mbrlen);
 577 #elif defined GNULIB_POSIXCHECK
 578 # undef mbrlen
 579 # if HAVE_RAW_DECL_MBRLEN
 580 _GL_WARN_ON_USE (mbrlen, "mbrlen is unportable - "
 581                  "use gnulib module mbrlen for portability");
 582 # endif
 583 #endif
 584
 585
 586 /* Convert a string to a wide string.  */
 587 #if 1
 588 # if 0
 589 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 590 #   undef mbsrtowcs
 591 #   define mbsrtowcs rpl_mbsrtowcs
 592 #  endif
 593 _GL_FUNCDECL_RPL (mbsrtowcs, size_t,
 594                   (wchar_t *dest, const char **srcp, size_t len, mbstate_t *ps)
 595                   _GL_ARG_NONNULL ((2)));
 596 _GL_CXXALIAS_RPL (mbsrtowcs, size_t,
 597                   (wchar_t *dest, const char **srcp, size_t len,
 598                    mbstate_t *ps));
 599 # else
 600 #  if !1
 601 _GL_FUNCDECL_SYS (mbsrtowcs, size_t,
 602                   (wchar_t *dest, const char **srcp, size_t len, mbstate_t *ps)
 603                   _GL_ARG_NONNULL ((2)));
 604 #  endif
 605 _GL_CXXALIAS_SYS (mbsrtowcs, size_t,
 606                   (wchar_t *dest, const char **srcp, size_t len,
 607                    mbstate_t *ps));
 608 # endif
 609 _GL_CXXALIASWARN (mbsrtowcs);
 610 #elif defined GNULIB_POSIXCHECK
 611 # undef mbsrtowcs
 612 # if HAVE_RAW_DECL_MBSRTOWCS
 613 _GL_WARN_ON_USE (mbsrtowcs, "mbsrtowcs is unportable - "
 614                  "use gnulib module mbsrtowcs for portability");
 615 # endif
 616 #endif
 617
 618
 619 /* Convert a string to a wide string.  */
 620 #if 0
 621 # if 0
 622 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 623 #   undef mbsnrtowcs
 624 #   define mbsnrtowcs rpl_mbsnrtowcs
 625 #  endif
 626 _GL_FUNCDECL_RPL (mbsnrtowcs, size_t,
 627                   (wchar_t *dest, const char **srcp, size_t srclen, size_t len,
 628                    mbstate_t *ps)
 629                   _GL_ARG_NONNULL ((2)));
 630 _GL_CXXALIAS_RPL (mbsnrtowcs, size_t,
 631                   (wchar_t *dest, const char **srcp, size_t srclen, size_t len,
 632                    mbstate_t *ps));
 633 # else
 634 #  if !1
 635 _GL_FUNCDECL_SYS (mbsnrtowcs, size_t,
 636                   (wchar_t *dest, const char **srcp, size_t srclen, size_t len,
 637                    mbstate_t *ps)
 638                   _GL_ARG_NONNULL ((2)));
 639 #  endif
 640 _GL_CXXALIAS_SYS (mbsnrtowcs, size_t,
 641                   (wchar_t *dest, const char **srcp, size_t srclen, size_t len,
 642                    mbstate_t *ps));
 643 # endif
 644 _GL_CXXALIASWARN (mbsnrtowcs);
 645 #elif defined GNULIB_POSIXCHECK
 646 # undef mbsnrtowcs
 647 # if HAVE_RAW_DECL_MBSNRTOWCS
 648 _GL_WARN_ON_USE (mbsnrtowcs, "mbsnrtowcs is unportable - "
 649                  "use gnulib module mbsnrtowcs for portability");
 650 # endif
 651 #endif
 652
 653
 654 /* Convert a wide character to a multibyte character.  */
 655 #if 1
 656 # if 0
 657 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 658 #   undef wcrtomb
 659 #   define wcrtomb rpl_wcrtomb
 660 #  endif
 661 _GL_FUNCDECL_RPL (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps));
 662 _GL_CXXALIAS_RPL (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps));
 663 # else
 664 #  if !1
 665 _GL_FUNCDECL_SYS (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps));
 666 #  endif
 667 _GL_CXXALIAS_SYS (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps));
 668 # endif
 669 _GL_CXXALIASWARN (wcrtomb);
 670 #elif defined GNULIB_POSIXCHECK
 671 # undef wcrtomb
 672 # if HAVE_RAW_DECL_WCRTOMB
 673 _GL_WARN_ON_USE (wcrtomb, "wcrtomb is unportable - "
 674                  "use gnulib module wcrtomb for portability");
 675 # endif
 676 #endif
 677
 678
 679 /* Convert a wide string to a string.  */
 680 #if 0
 681 # if 0
 682 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 683 #   undef wcsrtombs
 684 #   define wcsrtombs rpl_wcsrtombs
 685 #  endif
 686 _GL_FUNCDECL_RPL (wcsrtombs, size_t,
 687                   (char *dest, const wchar_t **srcp, size_t len, mbstate_t *ps)
 688                   _GL_ARG_NONNULL ((2)));
 689 _GL_CXXALIAS_RPL (wcsrtombs, size_t,
 690                   (char *dest, const wchar_t **srcp, size_t len,
 691                    mbstate_t *ps));
 692 # else
 693 #  if !1
 694 _GL_FUNCDECL_SYS (wcsrtombs, size_t,
 695                   (char *dest, const wchar_t **srcp, size_t len, mbstate_t *ps)
 696                   _GL_ARG_NONNULL ((2)));
 697 #  endif
 698 _GL_CXXALIAS_SYS (wcsrtombs, size_t,
 699                   (char *dest, const wchar_t **srcp, size_t len,
 700                    mbstate_t *ps));
 701 # endif
 702 _GL_CXXALIASWARN (wcsrtombs);
 703 #elif defined GNULIB_POSIXCHECK
 704 # undef wcsrtombs
 705 # if HAVE_RAW_DECL_WCSRTOMBS
 706 _GL_WARN_ON_USE (wcsrtombs, "wcsrtombs is unportable - "
 707                  "use gnulib module wcsrtombs for portability");
 708 # endif
 709 #endif
 710
 711
 712 /* Convert a wide string to a string.  */
 713 #if 0
 714 # if 0
 715 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 716 #   undef wcsnrtombs
 717 #   define wcsnrtombs rpl_wcsnrtombs
 718 #  endif
 719 _GL_FUNCDECL_RPL (wcsnrtombs, size_t,
 720                   (char *dest, const wchar_t **srcp, size_t srclen, size_t len,
 721                    mbstate_t *ps)
 722                   _GL_ARG_NONNULL ((2)));
 723 _GL_CXXALIAS_RPL (wcsnrtombs, size_t,
 724                   (char *dest, const wchar_t **srcp, size_t srclen, size_t len,
 725                    mbstate_t *ps));
 726 # else
 727 #  if !1
 728 _GL_FUNCDECL_SYS (wcsnrtombs, size_t,
 729                   (char *dest, const wchar_t **srcp, size_t srclen, size_t len,
 730                    mbstate_t *ps)
 731                   _GL_ARG_NONNULL ((2)));
 732 #  endif
 733 _GL_CXXALIAS_SYS (wcsnrtombs, size_t,
 734                   (char *dest, const wchar_t **srcp, size_t srclen, size_t len,
 735                    mbstate_t *ps));
 736 # endif
 737 _GL_CXXALIASWARN (wcsnrtombs);
 738 #elif defined GNULIB_POSIXCHECK
 739 # undef wcsnrtombs
 740 # if HAVE_RAW_DECL_WCSNRTOMBS
 741 _GL_WARN_ON_USE (wcsnrtombs, "wcsnrtombs is unportable - "
 742                  "use gnulib module wcsnrtombs for portability");
 743 # endif
 744 #endif
 745
 746
 747 /* Return the number of screen columns needed for WC.  */
 748 #if 1
 749 # if 0
 750 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 751 #   undef wcwidth
 752 #   define wcwidth rpl_wcwidth
 753 #  endif
 754 _GL_FUNCDECL_RPL (wcwidth, int, (wchar_t) _GL_ATTRIBUTE_PURE);
 755 _GL_CXXALIAS_RPL (wcwidth, int, (wchar_t));
 756 # else
 757 #  if !1
 758 /* wcwidth exists but is not declared.  */
 759 _GL_FUNCDECL_SYS (wcwidth, int, (wchar_t) _GL_ATTRIBUTE_PURE);
 760 #  endif
 761 _GL_CXXALIAS_SYS (wcwidth, int, (wchar_t));
 762 # endif
 763 _GL_CXXALIASWARN (wcwidth);
 764 #elif defined GNULIB_POSIXCHECK
 765 # undef wcwidth
 766 # if HAVE_RAW_DECL_WCWIDTH
 767 _GL_WARN_ON_USE (wcwidth, "wcwidth is unportable - "
 768                  "use gnulib module wcwidth for portability");
 769 # endif
 770 #endif
 771
 772
 773 /* Search N wide characters of S for C.  */
 774 #if 0
 775 # if !1
 776 _GL_FUNCDECL_SYS (wmemchr, wchar_t *, (const wchar_t *s, wchar_t c, size_t n)
 777                                       _GL_ATTRIBUTE_PURE);
 778 # endif
 779   /* On some systems, this function is defined as an overloaded function:
 780        extern "C++" {
 781          const wchar_t * std::wmemchr (const wchar_t *, wchar_t, size_t);
 782          wchar_t * std::wmemchr (wchar_t *, wchar_t, size_t);
 783        }  */
 784 _GL_CXXALIAS_SYS_CAST2 (wmemchr,
 785                         wchar_t *, (const wchar_t *, wchar_t, size_t),
 786                         const wchar_t *, (const wchar_t *, wchar_t, size_t));
 787 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 788      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
 789 _GL_CXXALIASWARN1 (wmemchr, wchar_t *, (wchar_t *s, wchar_t c, size_t n));
 790 _GL_CXXALIASWARN1 (wmemchr, const wchar_t *,
 791                    (const wchar_t *s, wchar_t c, size_t n));
 792 # else
 793 _GL_CXXALIASWARN (wmemchr);
 794 # endif
 795 #elif defined GNULIB_POSIXCHECK
 796 # undef wmemchr
 797 # if HAVE_RAW_DECL_WMEMCHR
 798 _GL_WARN_ON_USE (wmemchr, "wmemchr is unportable - "
 799                  "use gnulib module wmemchr for portability");
 800 # endif
 801 #endif
 802
 803
 804 /* Compare N wide characters of S1 and S2.  */
 805 #if 0
 806 # if !1
 807 _GL_FUNCDECL_SYS (wmemcmp, int,
 808                   (const wchar_t *s1, const wchar_t *s2, size_t n)
 809                   _GL_ATTRIBUTE_PURE);
 810 # endif
 811 _GL_CXXALIAS_SYS (wmemcmp, int,
 812                   (const wchar_t *s1, const wchar_t *s2, size_t n));
 813 _GL_CXXALIASWARN (wmemcmp);
 814 #elif defined GNULIB_POSIXCHECK
 815 # undef wmemcmp
 816 # if HAVE_RAW_DECL_WMEMCMP
 817 _GL_WARN_ON_USE (wmemcmp, "wmemcmp is unportable - "
 818                  "use gnulib module wmemcmp for portability");
 819 # endif
 820 #endif
 821
 822
 823 /* Copy N wide characters of SRC to DEST.  */
 824 #if 0
 825 # if !1
 826 _GL_FUNCDECL_SYS (wmemcpy, wchar_t *,
 827                   (wchar_t *dest, const wchar_t *src, size_t n));
 828 # endif
 829 _GL_CXXALIAS_SYS (wmemcpy, wchar_t *,
 830                   (wchar_t *dest, const wchar_t *src, size_t n));
 831 _GL_CXXALIASWARN (wmemcpy);
 832 #elif defined GNULIB_POSIXCHECK
 833 # undef wmemcpy
 834 # if HAVE_RAW_DECL_WMEMCPY
 835 _GL_WARN_ON_USE (wmemcpy, "wmemcpy is unportable - "
 836                  "use gnulib module wmemcpy for portability");
 837 # endif
 838 #endif
 839
 840
 841 /* Copy N wide characters of SRC to DEST, guaranteeing correct behavior for
 842    overlapping memory areas.  */
 843 #if 0
 844 # if !1
 845 _GL_FUNCDECL_SYS (wmemmove, wchar_t *,
 846                   (wchar_t *dest, const wchar_t *src, size_t n));
 847 # endif
 848 _GL_CXXALIAS_SYS (wmemmove, wchar_t *,
 849                   (wchar_t *dest, const wchar_t *src, size_t n));
 850 _GL_CXXALIASWARN (wmemmove);
 851 #elif defined GNULIB_POSIXCHECK
 852 # undef wmemmove
 853 # if HAVE_RAW_DECL_WMEMMOVE
 854 _GL_WARN_ON_USE (wmemmove, "wmemmove is unportable - "
 855                  "use gnulib module wmemmove for portability");
 856 # endif
 857 #endif
 858
 859
 860 /* Set N wide characters of S to C.  */
 861 #if 0
 862 # if !1
 863 _GL_FUNCDECL_SYS (wmemset, wchar_t *, (wchar_t *s, wchar_t c, size_t n));
 864 # endif
 865 _GL_CXXALIAS_SYS (wmemset, wchar_t *, (wchar_t *s, wchar_t c, size_t n));
 866 _GL_CXXALIASWARN (wmemset);
 867 #elif defined GNULIB_POSIXCHECK
 868 # undef wmemset
 869 # if HAVE_RAW_DECL_WMEMSET
 870 _GL_WARN_ON_USE (wmemset, "wmemset is unportable - "
 871                  "use gnulib module wmemset for portability");
 872 # endif
 873 #endif
 874
 875
 876 /* Return the number of wide characters in S.  */
 877 #if 0
 878 # if !1
 879 _GL_FUNCDECL_SYS (wcslen, size_t, (const wchar_t *s) _GL_ATTRIBUTE_PURE);
 880 # endif
 881 _GL_CXXALIAS_SYS (wcslen, size_t, (const wchar_t *s));
 882 _GL_CXXALIASWARN (wcslen);
 883 #elif defined GNULIB_POSIXCHECK
 884 # undef wcslen
 885 # if HAVE_RAW_DECL_WCSLEN
 886 _GL_WARN_ON_USE (wcslen, "wcslen is unportable - "
 887                  "use gnulib module wcslen for portability");
 888 # endif
 889 #endif
 890
 891
 892 /* Return the number of wide characters in S, but at most MAXLEN.  */
 893 #if 0
 894 # if !1
 895 _GL_FUNCDECL_SYS (wcsnlen, size_t, (const wchar_t *s, size_t maxlen)
 896                                    _GL_ATTRIBUTE_PURE);
 897 # endif
 898 _GL_CXXALIAS_SYS (wcsnlen, size_t, (const wchar_t *s, size_t maxlen));
 899 _GL_CXXALIASWARN (wcsnlen);
 900 #elif defined GNULIB_POSIXCHECK
 901 # undef wcsnlen
 902 # if HAVE_RAW_DECL_WCSNLEN
 903 _GL_WARN_ON_USE (wcsnlen, "wcsnlen is unportable - "
 904                  "use gnulib module wcsnlen for portability");
 905 # endif
 906 #endif
 907
 908
 909 /* Copy SRC to DEST.  */
 910 #if 0
 911 # if !1
 912 _GL_FUNCDECL_SYS (wcscpy, wchar_t *, (wchar_t *dest, const wchar_t *src));
 913 # endif
 914 _GL_CXXALIAS_SYS (wcscpy, wchar_t *, (wchar_t *dest, const wchar_t *src));
 915 _GL_CXXALIASWARN (wcscpy);
 916 #elif defined GNULIB_POSIXCHECK
 917 # undef wcscpy
 918 # if HAVE_RAW_DECL_WCSCPY
 919 _GL_WARN_ON_USE (wcscpy, "wcscpy is unportable - "
 920                  "use gnulib module wcscpy for portability");
 921 # endif
 922 #endif
 923
 924
 925 /* Copy SRC to DEST, returning the address of the terminating L'\0' in DEST.  */
 926 #if 0
 927 # if !1
 928 _GL_FUNCDECL_SYS (wcpcpy, wchar_t *, (wchar_t *dest, const wchar_t *src));
 929 # endif
 930 _GL_CXXALIAS_SYS (wcpcpy, wchar_t *, (wchar_t *dest, const wchar_t *src));
 931 _GL_CXXALIASWARN (wcpcpy);
 932 #elif defined GNULIB_POSIXCHECK
 933 # undef wcpcpy
 934 # if HAVE_RAW_DECL_WCPCPY
 935 _GL_WARN_ON_USE (wcpcpy, "wcpcpy is unportable - "
 936                  "use gnulib module wcpcpy for portability");
 937 # endif
 938 #endif
 939
 940
 941 /* Copy no more than N wide characters of SRC to DEST.  */
 942 #if 0
 943 # if !1
 944 _GL_FUNCDECL_SYS (wcsncpy, wchar_t *,
 945                   (wchar_t *dest, const wchar_t *src, size_t n));
 946 # endif
 947 _GL_CXXALIAS_SYS (wcsncpy, wchar_t *,
 948                   (wchar_t *dest, const wchar_t *src, size_t n));
 949 _GL_CXXALIASWARN (wcsncpy);
 950 #elif defined GNULIB_POSIXCHECK
 951 # undef wcsncpy
 952 # if HAVE_RAW_DECL_WCSNCPY
 953 _GL_WARN_ON_USE (wcsncpy, "wcsncpy is unportable - "
 954                  "use gnulib module wcsncpy for portability");
 955 # endif
 956 #endif
 957
 958
 959 /* Copy no more than N characters of SRC to DEST, returning the address of
 960    the last character written into DEST.  */
 961 #if 0
 962 # if !1
 963 _GL_FUNCDECL_SYS (wcpncpy, wchar_t *,
 964                   (wchar_t *dest, const wchar_t *src, size_t n));
 965 # endif
 966 _GL_CXXALIAS_SYS (wcpncpy, wchar_t *,
 967                   (wchar_t *dest, const wchar_t *src, size_t n));
 968 _GL_CXXALIASWARN (wcpncpy);
 969 #elif defined GNULIB_POSIXCHECK
 970 # undef wcpncpy
 971 # if HAVE_RAW_DECL_WCPNCPY
 972 _GL_WARN_ON_USE (wcpncpy, "wcpncpy is unportable - "
 973                  "use gnulib module wcpncpy for portability");
 974 # endif
 975 #endif
 976
 977
 978 /* Append SRC onto DEST.  */
 979 #if 0
 980 # if !1
 981 _GL_FUNCDECL_SYS (wcscat, wchar_t *, (wchar_t *dest, const wchar_t *src));
 982 # endif
 983 _GL_CXXALIAS_SYS (wcscat, wchar_t *, (wchar_t *dest, const wchar_t *src));
 984 _GL_CXXALIASWARN (wcscat);
 985 #elif defined GNULIB_POSIXCHECK
 986 # undef wcscat
 987 # if HAVE_RAW_DECL_WCSCAT
 988 _GL_WARN_ON_USE (wcscat, "wcscat is unportable - "
 989                  "use gnulib module wcscat for portability");
 990 # endif
 991 #endif
 992
 993
 994 /* Append no more than N wide characters of SRC onto DEST.  */
 995 #if 0
 996 # if !1
 997 _GL_FUNCDECL_SYS (wcsncat, wchar_t *,
 998                   (wchar_t *dest, const wchar_t *src, size_t n));
 999 # endif
1000 _GL_CXXALIAS_SYS (wcsncat, wchar_t *,
1001                   (wchar_t *dest, const wchar_t *src, size_t n));
1002 _GL_CXXALIASWARN (wcsncat);
1003 #elif defined GNULIB_POSIXCHECK
1004 # undef wcsncat
1005 # if HAVE_RAW_DECL_WCSNCAT
1006 _GL_WARN_ON_USE (wcsncat, "wcsncat is unportable - "
1007                  "use gnulib module wcsncat for portability");
1008 # endif
1009 #endif
1010
1011
1012 /* Compare S1 and S2.  */
1013 #if 0
1014 # if !1
1015 _GL_FUNCDECL_SYS (wcscmp, int, (const wchar_t *s1, const wchar_t *s2)
1016                                _GL_ATTRIBUTE_PURE);
1017 # endif
1018 _GL_CXXALIAS_SYS (wcscmp, int, (const wchar_t *s1, const wchar_t *s2));
1019 _GL_CXXALIASWARN (wcscmp);
1020 #elif defined GNULIB_POSIXCHECK
1021 # undef wcscmp
1022 # if HAVE_RAW_DECL_WCSCMP
1023 _GL_WARN_ON_USE (wcscmp, "wcscmp is unportable - "
1024                  "use gnulib module wcscmp for portability");
1025 # endif
1026 #endif
1027
1028
1029 /* Compare no more than N wide characters of S1 and S2.  */
1030 #if 0
1031 # if !1
1032 _GL_FUNCDECL_SYS (wcsncmp, int,
1033                   (const wchar_t *s1, const wchar_t *s2, size_t n)
1034                   _GL_ATTRIBUTE_PURE);
1035 # endif
1036 _GL_CXXALIAS_SYS (wcsncmp, int,
1037                   (const wchar_t *s1, const wchar_t *s2, size_t n));
1038 _GL_CXXALIASWARN (wcsncmp);
1039 #elif defined GNULIB_POSIXCHECK
1040 # undef wcsncmp
1041 # if HAVE_RAW_DECL_WCSNCMP
1042 _GL_WARN_ON_USE (wcsncmp, "wcsncmp is unportable - "
1043                  "use gnulib module wcsncmp for portability");
1044 # endif
1045 #endif
1046
1047
1048 /* Compare S1 and S2, ignoring case.  */
1049 #if 0
1050 # if !1
1051 _GL_FUNCDECL_SYS (wcscasecmp, int, (const wchar_t *s1, const wchar_t *s2)
1052                                    _GL_ATTRIBUTE_PURE);
1053 # endif
1054 _GL_CXXALIAS_SYS (wcscasecmp, int, (const wchar_t *s1, const wchar_t *s2));
1055 _GL_CXXALIASWARN (wcscasecmp);
1056 #elif defined GNULIB_POSIXCHECK
1057 # undef wcscasecmp
1058 # if HAVE_RAW_DECL_WCSCASECMP
1059 _GL_WARN_ON_USE (wcscasecmp, "wcscasecmp is unportable - "
1060                  "use gnulib module wcscasecmp for portability");
1061 # endif
1062 #endif
1063
1064
1065 /* Compare no more than N chars of S1 and S2, ignoring case.  */
1066 #if 0
1067 # if !1
1068 _GL_FUNCDECL_SYS (wcsncasecmp, int,
1069                   (const wchar_t *s1, const wchar_t *s2, size_t n)
1070                   _GL_ATTRIBUTE_PURE);
1071 # endif
1072 _GL_CXXALIAS_SYS (wcsncasecmp, int,
1073                   (const wchar_t *s1, const wchar_t *s2, size_t n));
1074 _GL_CXXALIASWARN (wcsncasecmp);
1075 #elif defined GNULIB_POSIXCHECK
1076 # undef wcsncasecmp
1077 # if HAVE_RAW_DECL_WCSNCASECMP
1078 _GL_WARN_ON_USE (wcsncasecmp, "wcsncasecmp is unportable - "
1079                  "use gnulib module wcsncasecmp for portability");
1080 # endif
1081 #endif
1082
1083
1084 /* Compare S1 and S2, both interpreted as appropriate to the LC_COLLATE
1085    category of the current locale.  */
1086 #if 0
1087 # if !1
1088 _GL_FUNCDECL_SYS (wcscoll, int, (const wchar_t *s1, const wchar_t *s2));
1089 # endif
1090 _GL_CXXALIAS_SYS (wcscoll, int, (const wchar_t *s1, const wchar_t *s2));
1091 _GL_CXXALIASWARN (wcscoll);
1092 #elif defined GNULIB_POSIXCHECK
1093 # undef wcscoll
1094 # if HAVE_RAW_DECL_WCSCOLL
1095 _GL_WARN_ON_USE (wcscoll, "wcscoll is unportable - "
1096                  "use gnulib module wcscoll for portability");
1097 # endif
1098 #endif
1099
1100
1101 /* Transform S2 into array pointed to by S1 such that if wcscmp is applied
1102    to two transformed strings the result is the as applying 'wcscoll' to the
1103    original strings.  */
1104 #if 0
1105 # if !1
1106 _GL_FUNCDECL_SYS (wcsxfrm, size_t, (wchar_t *s1, const wchar_t *s2, size_t n));
1107 # endif
1108 _GL_CXXALIAS_SYS (wcsxfrm, size_t, (wchar_t *s1, const wchar_t *s2, size_t n));
1109 _GL_CXXALIASWARN (wcsxfrm);
1110 #elif defined GNULIB_POSIXCHECK
1111 # undef wcsxfrm
1112 # if HAVE_RAW_DECL_WCSXFRM
1113 _GL_WARN_ON_USE (wcsxfrm, "wcsxfrm is unportable - "
1114                  "use gnulib module wcsxfrm for portability");
1115 # endif
1116 #endif
1117
1118
1119 /* Duplicate S, returning an identical malloc'd string.  */
1120 #if 0
1121 # if !1
1122 _GL_FUNCDECL_SYS (wcsdup, wchar_t *, (const wchar_t *s));
1123 # endif
1124 _GL_CXXALIAS_SYS (wcsdup, wchar_t *, (const wchar_t *s));
1125 _GL_CXXALIASWARN (wcsdup);
1126 #elif defined GNULIB_POSIXCHECK
1127 # undef wcsdup
1128 # if HAVE_RAW_DECL_WCSDUP
1129 _GL_WARN_ON_USE (wcsdup, "wcsdup is unportable - "
1130                  "use gnulib module wcsdup for portability");
1131 # endif
1132 #endif
1133
1134
1135 /* Find the first occurrence of WC in WCS.  */
1136 #if 0
1137 # if !1
1138 _GL_FUNCDECL_SYS (wcschr, wchar_t *, (const wchar_t *wcs, wchar_t wc)
1139                                      _GL_ATTRIBUTE_PURE);
1140 # endif
1141   /* On some systems, this function is defined as an overloaded function:
1142        extern "C++" {
1143          const wchar_t * std::wcschr (const wchar_t *, wchar_t);
1144          wchar_t * std::wcschr (wchar_t *, wchar_t);
1145        }  */
1146 _GL_CXXALIAS_SYS_CAST2 (wcschr,
1147                         wchar_t *, (const wchar_t *, wchar_t),
1148                         const wchar_t *, (const wchar_t *, wchar_t));
1149 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
1150      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
1151 _GL_CXXALIASWARN1 (wcschr, wchar_t *, (wchar_t *wcs, wchar_t wc));
1152 _GL_CXXALIASWARN1 (wcschr, const wchar_t *, (const wchar_t *wcs, wchar_t wc));
1153 # else
1154 _GL_CXXALIASWARN (wcschr);
1155 # endif
1156 #elif defined GNULIB_POSIXCHECK
1157 # undef wcschr
1158 # if HAVE_RAW_DECL_WCSCHR
1159 _GL_WARN_ON_USE (wcschr, "wcschr is unportable - "
1160                  "use gnulib module wcschr for portability");
1161 # endif
1162 #endif
1163
1164
1165 /* Find the last occurrence of WC in WCS.  */
1166 #if 0
1167 # if !1
1168 _GL_FUNCDECL_SYS (wcsrchr, wchar_t *, (const wchar_t *wcs, wchar_t wc)
1169                                       _GL_ATTRIBUTE_PURE);
1170 # endif
1171   /* On some systems, this function is defined as an overloaded function:
1172        extern "C++" {
1173          const wchar_t * std::wcsrchr (const wchar_t *, wchar_t);
1174          wchar_t * std::wcsrchr (wchar_t *, wchar_t);
1175        }  */
1176 _GL_CXXALIAS_SYS_CAST2 (wcsrchr,
1177                         wchar_t *, (const wchar_t *, wchar_t),
1178                         const wchar_t *, (const wchar_t *, wchar_t));
1179 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
1180      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
1181 _GL_CXXALIASWARN1 (wcsrchr, wchar_t *, (wchar_t *wcs, wchar_t wc));
1182 _GL_CXXALIASWARN1 (wcsrchr, const wchar_t *, (const wchar_t *wcs, wchar_t wc));
1183 # else
1184 _GL_CXXALIASWARN (wcsrchr);
1185 # endif
1186 #elif defined GNULIB_POSIXCHECK
1187 # undef wcsrchr
1188 # if HAVE_RAW_DECL_WCSRCHR
1189 _GL_WARN_ON_USE (wcsrchr, "wcsrchr is unportable - "
1190                  "use gnulib module wcsrchr for portability");
1191 # endif
1192 #endif
1193
1194
1195 /* Return the length of the initial segmet of WCS which consists entirely
1196    of wide characters not in REJECT.  */
1197 #if 0
1198 # if !1
1199 _GL_FUNCDECL_SYS (wcscspn, size_t, (const wchar_t *wcs, const wchar_t *reject)
1200                                    _GL_ATTRIBUTE_PURE);
1201 # endif
1202 _GL_CXXALIAS_SYS (wcscspn, size_t, (const wchar_t *wcs, const wchar_t *reject));
1203 _GL_CXXALIASWARN (wcscspn);
1204 #elif defined GNULIB_POSIXCHECK
1205 # undef wcscspn
1206 # if HAVE_RAW_DECL_WCSCSPN
1207 _GL_WARN_ON_USE (wcscspn, "wcscspn is unportable - "
1208                  "use gnulib module wcscspn for portability");
1209 # endif
1210 #endif
1211
1212
1213 /* Return the length of the initial segmet of WCS which consists entirely
1214    of wide characters in ACCEPT.  */
1215 #if 0
1216 # if !1
1217 _GL_FUNCDECL_SYS (wcsspn, size_t, (const wchar_t *wcs, const wchar_t *accept)
1218                                   _GL_ATTRIBUTE_PURE);
1219 # endif
1220 _GL_CXXALIAS_SYS (wcsspn, size_t, (const wchar_t *wcs, const wchar_t *accept));
1221 _GL_CXXALIASWARN (wcsspn);
1222 #elif defined GNULIB_POSIXCHECK
1223 # undef wcsspn
1224 # if HAVE_RAW_DECL_WCSSPN
1225 _GL_WARN_ON_USE (wcsspn, "wcsspn is unportable - "
1226                  "use gnulib module wcsspn for portability");
1227 # endif
1228 #endif
1229
1230
1231 /* Find the first occurrence in WCS of any character in ACCEPT.  */
1232 #if 0
1233 # if !1
1234 _GL_FUNCDECL_SYS (wcspbrk, wchar_t *,
1235                   (const wchar_t *wcs, const wchar_t *accept)
1236                   _GL_ATTRIBUTE_PURE);
1237 # endif
1238   /* On some systems, this function is defined as an overloaded function:
1239        extern "C++" {
1240          const wchar_t * std::wcspbrk (const wchar_t *, const wchar_t *);
1241          wchar_t * std::wcspbrk (wchar_t *, const wchar_t *);
1242        }  */
1243 _GL_CXXALIAS_SYS_CAST2 (wcspbrk,
1244                         wchar_t *, (const wchar_t *, const wchar_t *),
1245                         const wchar_t *, (const wchar_t *, const wchar_t *));
1246 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
1247      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
1248 _GL_CXXALIASWARN1 (wcspbrk, wchar_t *,
1249                    (wchar_t *wcs, const wchar_t *accept));
1250 _GL_CXXALIASWARN1 (wcspbrk, const wchar_t *,
1251                    (const wchar_t *wcs, const wchar_t *accept));
1252 # else
1253 _GL_CXXALIASWARN (wcspbrk);
1254 # endif
1255 #elif defined GNULIB_POSIXCHECK
1256 # undef wcspbrk
1257 # if HAVE_RAW_DECL_WCSPBRK
1258 _GL_WARN_ON_USE (wcspbrk, "wcspbrk is unportable - "
1259                  "use gnulib module wcspbrk for portability");
1260 # endif
1261 #endif
1262
1263
1264 /* Find the first occurrence of NEEDLE in HAYSTACK.  */
1265 #if 0
1266 # if !1
1267 _GL_FUNCDECL_SYS (wcsstr, wchar_t *,
1268                   (const wchar_t *haystack, const wchar_t *needle)
1269                   _GL_ATTRIBUTE_PURE);
1270 # endif
1271   /* On some systems, this function is defined as an overloaded function:
1272        extern "C++" {
1273          const wchar_t * std::wcsstr (const wchar_t *, const wchar_t *);
1274          wchar_t * std::wcsstr (wchar_t *, const wchar_t *);
1275        }  */
1276 _GL_CXXALIAS_SYS_CAST2 (wcsstr,
1277                         wchar_t *, (const wchar_t *, const wchar_t *),
1278                         const wchar_t *, (const wchar_t *, const wchar_t *));
1279 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
1280      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
1281 _GL_CXXALIASWARN1 (wcsstr, wchar_t *,
1282                    (wchar_t *haystack, const wchar_t *needle));
1283 _GL_CXXALIASWARN1 (wcsstr, const wchar_t *,
1284                    (const wchar_t *haystack, const wchar_t *needle));
1285 # else
1286 _GL_CXXALIASWARN (wcsstr);
1287 # endif
1288 #elif defined GNULIB_POSIXCHECK
1289 # undef wcsstr
1290 # if HAVE_RAW_DECL_WCSSTR
1291 _GL_WARN_ON_USE (wcsstr, "wcsstr is unportable - "
1292                  "use gnulib module wcsstr for portability");
1293 # endif
1294 #endif
1295
1296
1297 /* Divide WCS into tokens separated by characters in DELIM.  */
1298 #if 0
1299 # if !1
1300 _GL_FUNCDECL_SYS (wcstok, wchar_t *,
1301                   (wchar_t *wcs, const wchar_t *delim, wchar_t **ptr));
1302 # endif
1303 _GL_CXXALIAS_SYS (wcstok, wchar_t *,
1304                   (wchar_t *wcs, const wchar_t *delim, wchar_t **ptr));
1305 _GL_CXXALIASWARN (wcstok);
1306 #elif defined GNULIB_POSIXCHECK
1307 # undef wcstok
1308 # if HAVE_RAW_DECL_WCSTOK
1309 _GL_WARN_ON_USE (wcstok, "wcstok is unportable - "
1310                  "use gnulib module wcstok for portability");
1311 # endif
1312 #endif
1313
1314
1315 /* Determine number of column positions required for first N wide
1316    characters (or fewer if S ends before this) in S.  */
1317 #if 0
1318 # if 0
1319 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1320 #   undef wcswidth
1321 #   define wcswidth rpl_wcswidth
1322 #  endif
1323 _GL_FUNCDECL_RPL (wcswidth, int, (const wchar_t *s, size_t n)
1324                                  _GL_ATTRIBUTE_PURE);
1325 _GL_CXXALIAS_RPL (wcswidth, int, (const wchar_t *s, size_t n));
1326 # else
1327 #  if !1
1328 _GL_FUNCDECL_SYS (wcswidth, int, (const wchar_t *s, size_t n)
1329                                  _GL_ATTRIBUTE_PURE);
1330 #  endif
1331 _GL_CXXALIAS_SYS (wcswidth, int, (const wchar_t *s, size_t n));
1332 # endif
1333 _GL_CXXALIASWARN (wcswidth);
1334 #elif defined GNULIB_POSIXCHECK
1335 # undef wcswidth
1336 # if HAVE_RAW_DECL_WCSWIDTH
1337 _GL_WARN_ON_USE (wcswidth, "wcswidth is unportable - "
1338                  "use gnulib module wcswidth for portability");
1339 # endif
1340 #endif
1341
1342
1343 #endif /* _GL_WCHAR_H */
1344 #endif /* _GL_WCHAR_H */
1345 #endif