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