1/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
2/* A GNU-like <string.h>.
3
4   Copyright (C) 1995-1996, 2001-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#ifndef _GL_STRING_H
20
21#if __GNUC__ >= 3
22#pragma GCC system_header
23#endif
24
25
26/* The include_next requires a split double-inclusion guard.  */
27#include_next <string.h>
28
29#ifndef _GL_STRING_H
30#define _GL_STRING_H
31
32/* NetBSD 5.0 mis-defines NULL.  */
33#include <stddef.h>
34
35/* MirBSD defines mbslen as a macro.  */
36#if 0 && defined __MirBSD__
37# include <wchar.h>
38#endif
39
40/* The __attribute__ feature is available in gcc versions 2.5 and later.
41   The attribute __pure__ was added in gcc 2.96.  */
42#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
43# define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
44#else
45# define _GL_ATTRIBUTE_PURE /* empty */
46#endif
47
48/* NetBSD 5.0 declares strsignal in <unistd.h>, not in <string.h>.  */
49/* But in any case avoid namespace pollution on glibc systems.  */
50#if (0 || defined GNULIB_POSIXCHECK) && defined __NetBSD__ \
51    && ! defined __GLIBC__
52# include <unistd.h>
53#endif
54
55/* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
56#ifndef _GL_CXXDEFS_H
57#define _GL_CXXDEFS_H
58
59/* The three most frequent use cases of these macros are:
60
61   * For providing a substitute for a function that is missing on some
62     platforms, but is declared and works fine on the platforms on which
63     it exists:
64
65       #if @GNULIB_FOO@
66       # if !@HAVE_FOO@
67       _GL_FUNCDECL_SYS (foo, ...);
68       # endif
69       _GL_CXXALIAS_SYS (foo, ...);
70       _GL_CXXALIASWARN (foo);
71       #elif defined GNULIB_POSIXCHECK
72       ...
73       #endif
74
75   * For providing a replacement for a function that exists on all platforms,
76     but is broken/insufficient and needs to be replaced on some platforms:
77
78       #if @GNULIB_FOO@
79       # if @REPLACE_FOO@
80       #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
81       #   undef foo
82       #   define foo rpl_foo
83       #  endif
84       _GL_FUNCDECL_RPL (foo, ...);
85       _GL_CXXALIAS_RPL (foo, ...);
86       # else
87       _GL_CXXALIAS_SYS (foo, ...);
88       # endif
89       _GL_CXXALIASWARN (foo);
90       #elif defined GNULIB_POSIXCHECK
91       ...
92       #endif
93
94   * For providing a replacement for a function that exists on some platforms
95     but is broken/insufficient and needs to be replaced on some of them and
96     is additionally either missing or undeclared on some other platforms:
97
98       #if @GNULIB_FOO@
99       # if @REPLACE_FOO@
100       #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
101       #   undef foo
102       #   define foo rpl_foo
103       #  endif
104       _GL_FUNCDECL_RPL (foo, ...);
105       _GL_CXXALIAS_RPL (foo, ...);
106       # else
107       #  if !@HAVE_FOO@   or   if !@HAVE_DECL_FOO@
108       _GL_FUNCDECL_SYS (foo, ...);
109       #  endif
110       _GL_CXXALIAS_SYS (foo, ...);
111       # endif
112       _GL_CXXALIASWARN (foo);
113       #elif defined GNULIB_POSIXCHECK
114       ...
115       #endif
116*/
117
118/* _GL_EXTERN_C declaration;
119   performs the declaration with C linkage.  */
120#if defined __cplusplus
121# define _GL_EXTERN_C extern "C"
122#else
123# define _GL_EXTERN_C extern
124#endif
125
126/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);
127   declares a replacement function, named rpl_func, with the given prototype,
128   consisting of return type, parameters, and attributes.
129   Example:
130     _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)
131                                  _GL_ARG_NONNULL ((1)));
132 */
133#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \
134  _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)
135#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \
136  _GL_EXTERN_C rettype rpl_func parameters_and_attributes
137
138/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);
139   declares the system function, named func, with the given prototype,
140   consisting of return type, parameters, and attributes.
141   Example:
142     _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)
143                                  _GL_ARG_NONNULL ((1)));
144 */
145#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \
146  _GL_EXTERN_C rettype func parameters_and_attributes
147
148/* _GL_CXXALIAS_RPL (func, rettype, parameters);
149   declares a C++ alias called GNULIB_NAMESPACE::func
150   that redirects to rpl_func, if GNULIB_NAMESPACE is defined.
151   Example:
152     _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));
153 */
154#define _GL_CXXALIAS_RPL(func,rettype,parameters) \
155  _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)
156#if defined __cplusplus && defined GNULIB_NAMESPACE
157# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
158    namespace GNULIB_NAMESPACE                                \
159    {                                                         \
160      rettype (*const func) parameters = ::rpl_func;          \
161    }                                                         \
162    _GL_EXTERN_C int _gl_cxxalias_dummy
163#else
164# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
165    _GL_EXTERN_C int _gl_cxxalias_dummy
166#endif
167
168/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);
169   is like  _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);
170   except that the C function rpl_func may have a slightly different
171   declaration.  A cast is used to silence the "invalid conversion" error
172   that would otherwise occur.  */
173#if defined __cplusplus && defined GNULIB_NAMESPACE
174# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
175    namespace GNULIB_NAMESPACE                                     \
176    {                                                              \
177      rettype (*const func) parameters =                           \
178        reinterpret_cast<rettype(*)parameters>(::rpl_func);        \
179    }                                                              \
180    _GL_EXTERN_C int _gl_cxxalias_dummy
181#else
182# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
183    _GL_EXTERN_C int _gl_cxxalias_dummy
184#endif
185
186/* _GL_CXXALIAS_SYS (func, rettype, parameters);
187   declares a C++ alias called GNULIB_NAMESPACE::func
188   that redirects to the system provided function func, if GNULIB_NAMESPACE
189   is defined.
190   Example:
191     _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));
192 */
193#if defined __cplusplus && defined GNULIB_NAMESPACE
194  /* If we were to write
195       rettype (*const func) parameters = ::func;
196     like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls
197     better (remove an indirection through a 'static' pointer variable),
198     but then the _GL_CXXALIASWARN macro below would cause a warning not only
199     for uses of ::func but also for uses of GNULIB_NAMESPACE::func.  */
200# define _GL_CXXALIAS_SYS(func,rettype,parameters) \
201    namespace GNULIB_NAMESPACE                     \
202    {                                              \
203      static rettype (*func) parameters = ::func;  \
204    }                                              \
205    _GL_EXTERN_C int _gl_cxxalias_dummy
206#else
207# define _GL_CXXALIAS_SYS(func,rettype,parameters) \
208    _GL_EXTERN_C int _gl_cxxalias_dummy
209#endif
210
211/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);
212   is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
213   except that the C function func may have a slightly different declaration.
214   A cast is used to silence the "invalid conversion" error that would
215   otherwise occur.  */
216#if defined __cplusplus && defined GNULIB_NAMESPACE
217# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
218    namespace GNULIB_NAMESPACE                          \
219    {                                                   \
220      static rettype (*func) parameters =               \
221        reinterpret_cast<rettype(*)parameters>(::func); \
222    }                                                   \
223    _GL_EXTERN_C int _gl_cxxalias_dummy
224#else
225# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
226    _GL_EXTERN_C int _gl_cxxalias_dummy
227#endif
228
229/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);
230   is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
231   except that the C function is picked among a set of overloaded functions,
232   namely the one with rettype2 and parameters2.  Two consecutive casts
233   are used to silence the "cannot find a match" and "invalid conversion"
234   errors that would otherwise occur.  */
235#if defined __cplusplus && defined GNULIB_NAMESPACE
236  /* The outer cast must be a reinterpret_cast.
237     The inner cast: When the function is defined as a set of overloaded
238     functions, it works as a static_cast<>, choosing the designated variant.
239     When the function is defined as a single variant, it works as a
240     reinterpret_cast<>. The parenthesized cast syntax works both ways.  */
241# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
242    namespace GNULIB_NAMESPACE                                                \
243    {                                                                         \
244      static rettype (*func) parameters =                                     \
245        reinterpret_cast<rettype(*)parameters>(                               \
246          (rettype2(*)parameters2)(::func));                                  \
247    }                                                                         \
248    _GL_EXTERN_C int _gl_cxxalias_dummy
249#else
250# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
251    _GL_EXTERN_C int _gl_cxxalias_dummy
252#endif
253
254/* _GL_CXXALIASWARN (func);
255   causes a warning to be emitted when ::func is used but not when
256   GNULIB_NAMESPACE::func is used.  func must be defined without overloaded
257   variants.  */
258#if defined __cplusplus && defined GNULIB_NAMESPACE
259# define _GL_CXXALIASWARN(func) \
260   _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)
261# define _GL_CXXALIASWARN_1(func,namespace) \
262   _GL_CXXALIASWARN_2 (func, namespace)
263/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
264   we enable the warning only when not optimizing.  */
265# if !__OPTIMIZE__
266#  define _GL_CXXALIASWARN_2(func,namespace) \
267    _GL_WARN_ON_USE (func, \
268                     "The symbol ::" #func " refers to the system function. " \
269                     "Use " #namespace "::" #func " instead.")
270# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
271#  define _GL_CXXALIASWARN_2(func,namespace) \
272     extern __typeof__ (func) func
273# else
274#  define _GL_CXXALIASWARN_2(func,namespace) \
275     _GL_EXTERN_C int _gl_cxxalias_dummy
276# endif
277#else
278# define _GL_CXXALIASWARN(func) \
279    _GL_EXTERN_C int _gl_cxxalias_dummy
280#endif
281
282/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);
283   causes a warning to be emitted when the given overloaded variant of ::func
284   is used but not when GNULIB_NAMESPACE::func is used.  */
285#if defined __cplusplus && defined GNULIB_NAMESPACE
286# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
287   _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \
288                        GNULIB_NAMESPACE)
289# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \
290   _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)
291/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
292   we enable the warning only when not optimizing.  */
293# if !__OPTIMIZE__
294#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
295    _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \
296                         "The symbol ::" #func " refers to the system function. " \
297                         "Use " #namespace "::" #func " instead.")
298# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
299#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
300     extern __typeof__ (func) func
301# else
302#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
303     _GL_EXTERN_C int _gl_cxxalias_dummy
304# endif
305#else
306# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
307    _GL_EXTERN_C int _gl_cxxalias_dummy
308#endif
309
310#endif /* _GL_CXXDEFS_H */
311
312/* The definition of _GL_ARG_NONNULL is copied here.  */
313/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
314   that the values passed as arguments n, ..., m must be non-NULL pointers.
315   n = 1 stands for the first argument, n = 2 for the second argument etc.  */
316#ifndef _GL_ARG_NONNULL
317# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
318#  define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
319# else
320#  define _GL_ARG_NONNULL(params)
321# endif
322#endif
323
324/* The definition of _GL_WARN_ON_USE is copied here.  */
325#ifndef _GL_WARN_ON_USE
326
327# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
328/* A compiler attribute is available in gcc versions 4.3.0 and later.  */
329#  define _GL_WARN_ON_USE(function, message) \
330extern __typeof__ (function) function __attribute__ ((__warning__ (message)))
331# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
332/* Verify the existence of the function.  */
333#  define _GL_WARN_ON_USE(function, message) \
334extern __typeof__ (function) function
335# else /* Unsupported.  */
336#  define _GL_WARN_ON_USE(function, message) \
337_GL_WARN_EXTERN_C int _gl_warn_on_use
338# endif
339#endif
340
341/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")
342   is like _GL_WARN_ON_USE (function, "string"), except that the function is
343   declared with the given prototype, consisting of return type, parameters,
344   and attributes.
345   This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does
346   not work in this case.  */
347#ifndef _GL_WARN_ON_USE_CXX
348# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
349#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
350extern rettype function parameters_and_attributes \
351     __attribute__ ((__warning__ (msg)))
352# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
353/* Verify the existence of the function.  */
354#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
355extern rettype function parameters_and_attributes
356# else /* Unsupported.  */
357#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
358_GL_WARN_EXTERN_C int _gl_warn_on_use
359# endif
360#endif
361
362/* _GL_WARN_EXTERN_C declaration;
363   performs the declaration with C linkage.  */
364#ifndef _GL_WARN_EXTERN_C
365# if defined __cplusplus
366#  define _GL_WARN_EXTERN_C extern "C"
367# else
368#  define _GL_WARN_EXTERN_C extern
369# endif
370#endif
371
372
373/* Find the index of the least-significant set bit.  */
374#if 0
375# if !1
376_GL_FUNCDECL_SYS (ffsl, int, (long int i));
377# endif
378_GL_CXXALIAS_SYS (ffsl, int, (long int i));
379_GL_CXXALIASWARN (ffsl);
380#elif defined GNULIB_POSIXCHECK
381# undef ffsl
382# if HAVE_RAW_DECL_FFSL
383_GL_WARN_ON_USE (ffsl, "ffsl is not portable - use the ffsl module");
384# endif
385#endif
386
387
388/* Find the index of the least-significant set bit.  */
389#if 0
390# if !1
391_GL_FUNCDECL_SYS (ffsll, int, (long long int i));
392# endif
393_GL_CXXALIAS_SYS (ffsll, int, (long long int i));
394_GL_CXXALIASWARN (ffsll);
395#elif defined GNULIB_POSIXCHECK
396# undef ffsll
397# if HAVE_RAW_DECL_FFSLL
398_GL_WARN_ON_USE (ffsll, "ffsll is not portable - use the ffsll module");
399# endif
400#endif
401
402
403/* Return the first instance of C within N bytes of S, or NULL.  */
404#if 1
405# if 0
406#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
407#   define memchr rpl_memchr
408#  endif
409_GL_FUNCDECL_RPL (memchr, void *, (void const *__s, int __c, size_t __n)
410                                  _GL_ATTRIBUTE_PURE
411                                  _GL_ARG_NONNULL ((1)));
412_GL_CXXALIAS_RPL (memchr, void *, (void const *__s, int __c, size_t __n));
413# else
414#  if ! 1
415_GL_FUNCDECL_SYS (memchr, void *, (void const *__s, int __c, size_t __n)
416                                  _GL_ATTRIBUTE_PURE
417                                  _GL_ARG_NONNULL ((1)));
418#  endif
419  /* On some systems, this function is defined as an overloaded function:
420       extern "C" { const void * std::memchr (const void *, int, size_t); }
421       extern "C++" { void * std::memchr (void *, int, size_t); }  */
422_GL_CXXALIAS_SYS_CAST2 (memchr,
423                        void *, (void const *__s, int __c, size_t __n),
424                        void const *, (void const *__s, int __c, size_t __n));
425# endif
426# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
427     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
428_GL_CXXALIASWARN1 (memchr, void *, (void *__s, int __c, size_t __n));
429_GL_CXXALIASWARN1 (memchr, void const *,
430                   (void const *__s, int __c, size_t __n));
431# else
432_GL_CXXALIASWARN (memchr);
433# endif
434#elif defined GNULIB_POSIXCHECK
435# undef memchr
436/* Assume memchr is always declared.  */
437_GL_WARN_ON_USE (memchr, "memchr has platform-specific bugs - "
438                 "use gnulib module memchr for portability" );
439#endif
440
441/* Return the first occurrence of NEEDLE in HAYSTACK.  */
442#if 0
443# if 0
444#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
445#   define memmem rpl_memmem
446#  endif
447_GL_FUNCDECL_RPL (memmem, void *,
448                  (void const *__haystack, size_t __haystack_len,
449                   void const *__needle, size_t __needle_len)
450                  _GL_ATTRIBUTE_PURE
451                  _GL_ARG_NONNULL ((1, 3)));
452_GL_CXXALIAS_RPL (memmem, void *,
453                  (void const *__haystack, size_t __haystack_len,
454                   void const *__needle, size_t __needle_len));
455# else
456#  if ! 1
457_GL_FUNCDECL_SYS (memmem, void *,
458                  (void const *__haystack, size_t __haystack_len,
459                   void const *__needle, size_t __needle_len)
460                  _GL_ATTRIBUTE_PURE
461                  _GL_ARG_NONNULL ((1, 3)));
462#  endif
463_GL_CXXALIAS_SYS (memmem, void *,
464                  (void const *__haystack, size_t __haystack_len,
465                   void const *__needle, size_t __needle_len));
466# endif
467_GL_CXXALIASWARN (memmem);
468#elif defined GNULIB_POSIXCHECK
469# undef memmem
470# if HAVE_RAW_DECL_MEMMEM
471_GL_WARN_ON_USE (memmem, "memmem is unportable and often quadratic - "
472                 "use gnulib module memmem-simple for portability, "
473                 "and module memmem for speed" );
474# endif
475#endif
476
477/* Copy N bytes of SRC to DEST, return pointer to bytes after the
478   last written byte.  */
479#if 0
480# if ! 1
481_GL_FUNCDECL_SYS (mempcpy, void *,
482                  (void *restrict __dest, void const *restrict __src,
483                   size_t __n)
484                  _GL_ARG_NONNULL ((1, 2)));
485# endif
486_GL_CXXALIAS_SYS (mempcpy, void *,
487                  (void *restrict __dest, void const *restrict __src,
488                   size_t __n));
489_GL_CXXALIASWARN (mempcpy);
490#elif defined GNULIB_POSIXCHECK
491# undef mempcpy
492# if HAVE_RAW_DECL_MEMPCPY
493_GL_WARN_ON_USE (mempcpy, "mempcpy is unportable - "
494                 "use gnulib module mempcpy for portability");
495# endif
496#endif
497
498/* Search backwards through a block for a byte (specified as an int).  */
499#if 0
500# if ! 1
501_GL_FUNCDECL_SYS (memrchr, void *, (void const *, int, size_t)
502                                   _GL_ATTRIBUTE_PURE
503                                   _GL_ARG_NONNULL ((1)));
504# endif
505  /* On some systems, this function is defined as an overloaded function:
506       extern "C++" { const void * std::memrchr (const void *, int, size_t); }
507       extern "C++" { void * std::memrchr (void *, int, size_t); }  */
508_GL_CXXALIAS_SYS_CAST2 (memrchr,
509                        void *, (void const *, int, size_t),
510                        void const *, (void const *, int, size_t));
511# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
512     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
513_GL_CXXALIASWARN1 (memrchr, void *, (void *, int, size_t));
514_GL_CXXALIASWARN1 (memrchr, void const *, (void const *, int, size_t));
515# else
516_GL_CXXALIASWARN (memrchr);
517# endif
518#elif defined GNULIB_POSIXCHECK
519# undef memrchr
520# if HAVE_RAW_DECL_MEMRCHR
521_GL_WARN_ON_USE (memrchr, "memrchr is unportable - "
522                 "use gnulib module memrchr for portability");
523# endif
524#endif
525
526/* Find the first occurrence of C in S.  More efficient than
527   memchr(S,C,N), at the expense of undefined behavior if C does not
528   occur within N bytes.  */
529#if 1
530# if ! 1
531_GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in)
532                                     _GL_ATTRIBUTE_PURE
533                                     _GL_ARG_NONNULL ((1)));
534# endif
535  /* On some systems, this function is defined as an overloaded function:
536       extern "C++" { const void * std::rawmemchr (const void *, int); }
537       extern "C++" { void * std::rawmemchr (void *, int); }  */
538_GL_CXXALIAS_SYS_CAST2 (rawmemchr,
539                        void *, (void const *__s, int __c_in),
540                        void const *, (void const *__s, int __c_in));
541# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
542     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
543_GL_CXXALIASWARN1 (rawmemchr, void *, (void *__s, int __c_in));
544_GL_CXXALIASWARN1 (rawmemchr, void const *, (void const *__s, int __c_in));
545# else
546_GL_CXXALIASWARN (rawmemchr);
547# endif
548#elif defined GNULIB_POSIXCHECK
549# undef rawmemchr
550# if HAVE_RAW_DECL_RAWMEMCHR
551_GL_WARN_ON_USE (rawmemchr, "rawmemchr is unportable - "
552                 "use gnulib module rawmemchr for portability");
553# endif
554#endif
555
556/* Copy SRC to DST, returning the address of the terminating '\0' in DST.  */
557#if 1
558# if ! 1
559_GL_FUNCDECL_SYS (stpcpy, char *,
560                  (char *restrict __dst, char const *restrict __src)
561                  _GL_ARG_NONNULL ((1, 2)));
562# endif
563_GL_CXXALIAS_SYS (stpcpy, char *,
564                  (char *restrict __dst, char const *restrict __src));
565_GL_CXXALIASWARN (stpcpy);
566#elif defined GNULIB_POSIXCHECK
567# undef stpcpy
568# if HAVE_RAW_DECL_STPCPY
569_GL_WARN_ON_USE (stpcpy, "stpcpy is unportable - "
570                 "use gnulib module stpcpy for portability");
571# endif
572#endif
573
574/* Copy no more than N bytes of SRC to DST, returning a pointer past the
575   last non-NUL byte written into DST.  */
576#if 0
577# if 0
578#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
579#   undef stpncpy
580#   define stpncpy rpl_stpncpy
581#  endif
582_GL_FUNCDECL_RPL (stpncpy, char *,
583                  (char *restrict __dst, char const *restrict __src,
584                   size_t __n)
585                  _GL_ARG_NONNULL ((1, 2)));
586_GL_CXXALIAS_RPL (stpncpy, char *,
587                  (char *restrict __dst, char const *restrict __src,
588                   size_t __n));
589# else
590#  if ! 1
591_GL_FUNCDECL_SYS (stpncpy, char *,
592                  (char *restrict __dst, char const *restrict __src,
593                   size_t __n)
594                  _GL_ARG_NONNULL ((1, 2)));
595#  endif
596_GL_CXXALIAS_SYS (stpncpy, char *,
597                  (char *restrict __dst, char const *restrict __src,
598                   size_t __n));
599# endif
600_GL_CXXALIASWARN (stpncpy);
601#elif defined GNULIB_POSIXCHECK
602# undef stpncpy
603# if HAVE_RAW_DECL_STPNCPY
604_GL_WARN_ON_USE (stpncpy, "stpncpy is unportable - "
605                 "use gnulib module stpncpy for portability");
606# endif
607#endif
608
609#if defined GNULIB_POSIXCHECK
610/* strchr() does not work with multibyte strings if the locale encoding is
611   GB18030 and the character to be searched is a digit.  */
612# undef strchr
613/* Assume strchr is always declared.  */
614_GL_WARN_ON_USE (strchr, "strchr cannot work correctly on character strings "
615                 "in some multibyte locales - "
616                 "use mbschr if you care about internationalization");
617#endif
618
619/* Find the first occurrence of C in S or the final NUL byte.  */
620#if 1
621# if 0
622#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
623#   define strchrnul rpl_strchrnul
624#  endif
625_GL_FUNCDECL_RPL (strchrnul, char *, (const char *__s, int __c_in)
626                                     _GL_ATTRIBUTE_PURE
627                                     _GL_ARG_NONNULL ((1)));
628_GL_CXXALIAS_RPL (strchrnul, char *,
629                  (const char *str, int ch));
630# else
631#  if ! 1
632_GL_FUNCDECL_SYS (strchrnul, char *, (char const *__s, int __c_in)
633                                     _GL_ATTRIBUTE_PURE
634                                     _GL_ARG_NONNULL ((1)));
635#  endif
636  /* On some systems, this function is defined as an overloaded function:
637       extern "C++" { const char * std::strchrnul (const char *, int); }
638       extern "C++" { char * std::strchrnul (char *, int); }  */
639_GL_CXXALIAS_SYS_CAST2 (strchrnul,
640                        char *, (char const *__s, int __c_in),
641                        char const *, (char const *__s, int __c_in));
642# endif
643# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
644     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
645_GL_CXXALIASWARN1 (strchrnul, char *, (char *__s, int __c_in));
646_GL_CXXALIASWARN1 (strchrnul, char const *, (char const *__s, int __c_in));
647# else
648_GL_CXXALIASWARN (strchrnul);
649# endif
650#elif defined GNULIB_POSIXCHECK
651# undef strchrnul
652# if HAVE_RAW_DECL_STRCHRNUL
653_GL_WARN_ON_USE (strchrnul, "strchrnul is unportable - "
654                 "use gnulib module strchrnul for portability");
655# endif
656#endif
657
658/* Duplicate S, returning an identical malloc'd string.  */
659#if 1
660# if 0
661#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
662#   undef strdup
663#   define strdup rpl_strdup
664#  endif
665_GL_FUNCDECL_RPL (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));
666_GL_CXXALIAS_RPL (strdup, char *, (char const *__s));
667# else
668#  if defined __cplusplus && defined GNULIB_NAMESPACE && defined strdup
669    /* strdup exists as a function and as a macro.  Get rid of the macro.  */
670#   undef strdup
671#  endif
672#  if !(1 || defined strdup)
673_GL_FUNCDECL_SYS (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));
674#  endif
675_GL_CXXALIAS_SYS (strdup, char *, (char const *__s));
676# endif
677_GL_CXXALIASWARN (strdup);
678#elif defined GNULIB_POSIXCHECK
679# undef strdup
680# if HAVE_RAW_DECL_STRDUP
681_GL_WARN_ON_USE (strdup, "strdup is unportable - "
682                 "use gnulib module strdup for portability");
683# endif
684#endif
685
686/* Append no more than N characters from SRC onto DEST.  */
687#if 0
688# if 0
689#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
690#   undef strncat
691#   define strncat rpl_strncat
692#  endif
693_GL_FUNCDECL_RPL (strncat, char *, (char *dest, const char *src, size_t n)
694                                   _GL_ARG_NONNULL ((1, 2)));
695_GL_CXXALIAS_RPL (strncat, char *, (char *dest, const char *src, size_t n));
696# else
697_GL_CXXALIAS_SYS (strncat, char *, (char *dest, const char *src, size_t n));
698# endif
699_GL_CXXALIASWARN (strncat);
700#elif defined GNULIB_POSIXCHECK
701# undef strncat
702# if HAVE_RAW_DECL_STRNCAT
703_GL_WARN_ON_USE (strncat, "strncat is unportable - "
704                 "use gnulib module strncat for portability");
705# endif
706#endif
707
708/* Return a newly allocated copy of at most N bytes of STRING.  */
709#if 1
710# if 0
711#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
712#   undef strndup
713#   define strndup rpl_strndup
714#  endif
715_GL_FUNCDECL_RPL (strndup, char *, (char const *__string, size_t __n)
716                                   _GL_ARG_NONNULL ((1)));
717_GL_CXXALIAS_RPL (strndup, char *, (char const *__string, size_t __n));
718# else
719#  if ! 1
720_GL_FUNCDECL_SYS (strndup, char *, (char const *__string, size_t __n)
721                                   _GL_ARG_NONNULL ((1)));
722#  endif
723_GL_CXXALIAS_SYS (strndup, char *, (char const *__string, size_t __n));
724# endif
725_GL_CXXALIASWARN (strndup);
726#elif defined GNULIB_POSIXCHECK
727# undef strndup
728# if HAVE_RAW_DECL_STRNDUP
729_GL_WARN_ON_USE (strndup, "strndup is unportable - "
730                 "use gnulib module strndup for portability");
731# endif
732#endif
733
734/* Find the length (number of bytes) of STRING, but scan at most
735   MAXLEN bytes.  If no '\0' terminator is found in that many bytes,
736   return MAXLEN.  */
737#if 1
738# if 0
739#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
740#   undef strnlen
741#   define strnlen rpl_strnlen
742#  endif
743_GL_FUNCDECL_RPL (strnlen, size_t, (char const *__string, size_t __maxlen)
744                                   _GL_ATTRIBUTE_PURE
745                                   _GL_ARG_NONNULL ((1)));
746_GL_CXXALIAS_RPL (strnlen, size_t, (char const *__string, size_t __maxlen));
747# else
748#  if ! 1
749_GL_FUNCDECL_SYS (strnlen, size_t, (char const *__string, size_t __maxlen)
750                                   _GL_ATTRIBUTE_PURE
751                                   _GL_ARG_NONNULL ((1)));
752#  endif
753_GL_CXXALIAS_SYS (strnlen, size_t, (char const *__string, size_t __maxlen));
754# endif
755_GL_CXXALIASWARN (strnlen);
756#elif defined GNULIB_POSIXCHECK
757# undef strnlen
758# if HAVE_RAW_DECL_STRNLEN
759_GL_WARN_ON_USE (strnlen, "strnlen is unportable - "
760                 "use gnulib module strnlen for portability");
761# endif
762#endif
763
764#if defined GNULIB_POSIXCHECK
765/* strcspn() assumes the second argument is a list of single-byte characters.
766   Even in this simple case, it does not work with multibyte strings if the
767   locale encoding is GB18030 and one of the characters to be searched is a
768   digit.  */
769# undef strcspn
770/* Assume strcspn is always declared.  */
771_GL_WARN_ON_USE (strcspn, "strcspn cannot work correctly on character strings "
772                 "in multibyte locales - "
773                 "use mbscspn if you care about internationalization");
774#endif
775
776/* Find the first occurrence in S of any character in ACCEPT.  */
777#if 0
778# if ! 1
779_GL_FUNCDECL_SYS (strpbrk, char *, (char const *__s, char const *__accept)
780                                   _GL_ATTRIBUTE_PURE
781                                   _GL_ARG_NONNULL ((1, 2)));
782# endif
783  /* On some systems, this function is defined as an overloaded function:
784       extern "C" { const char * strpbrk (const char *, const char *); }
785       extern "C++" { char * strpbrk (char *, const char *); }  */
786_GL_CXXALIAS_SYS_CAST2 (strpbrk,
787                        char *, (char const *__s, char const *__accept),
788                        const char *, (char const *__s, char const *__accept));
789# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
790     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
791_GL_CXXALIASWARN1 (strpbrk, char *, (char *__s, char const *__accept));
792_GL_CXXALIASWARN1 (strpbrk, char const *,
793                   (char const *__s, char const *__accept));
794# else
795_GL_CXXALIASWARN (strpbrk);
796# endif
797# if defined GNULIB_POSIXCHECK
798/* strpbrk() assumes the second argument is a list of single-byte characters.
799   Even in this simple case, it does not work with multibyte strings if the
800   locale encoding is GB18030 and one of the characters to be searched is a
801   digit.  */
802#  undef strpbrk
803_GL_WARN_ON_USE (strpbrk, "strpbrk cannot work correctly on character strings "
804                 "in multibyte locales - "
805                 "use mbspbrk if you care about internationalization");
806# endif
807#elif defined GNULIB_POSIXCHECK
808# undef strpbrk
809# if HAVE_RAW_DECL_STRPBRK
810_GL_WARN_ON_USE (strpbrk, "strpbrk is unportable - "
811                 "use gnulib module strpbrk for portability");
812# endif
813#endif
814
815#if defined GNULIB_POSIXCHECK
816/* strspn() assumes the second argument is a list of single-byte characters.
817   Even in this simple case, it cannot work with multibyte strings.  */
818# undef strspn
819/* Assume strspn is always declared.  */
820_GL_WARN_ON_USE (strspn, "strspn cannot work correctly on character strings "
821                 "in multibyte locales - "
822                 "use mbsspn if you care about internationalization");
823#endif
824
825#if defined GNULIB_POSIXCHECK
826/* strrchr() does not work with multibyte strings if the locale encoding is
827   GB18030 and the character to be searched is a digit.  */
828# undef strrchr
829/* Assume strrchr is always declared.  */
830_GL_WARN_ON_USE (strrchr, "strrchr cannot work correctly on character strings "
831                 "in some multibyte locales - "
832                 "use mbsrchr if you care about internationalization");
833#endif
834
835/* Search the next delimiter (char listed in DELIM) starting at *STRINGP.
836   If one is found, overwrite it with a NUL, and advance *STRINGP
837   to point to the next char after it.  Otherwise, set *STRINGP to NULL.
838   If *STRINGP was already NULL, nothing happens.
839   Return the old value of *STRINGP.
840
841   This is a variant of strtok() that is multithread-safe and supports
842   empty fields.
843
844   Caveat: It modifies the original string.
845   Caveat: These functions cannot be used on constant strings.
846   Caveat: The identity of the delimiting character is lost.
847   Caveat: It doesn't work with multibyte strings unless all of the delimiter
848           characters are ASCII characters < 0x30.
849
850   See also strtok_r().  */
851#if 0
852# if ! 1
853_GL_FUNCDECL_SYS (strsep, char *,
854                  (char **restrict __stringp, char const *restrict __delim)
855                  _GL_ARG_NONNULL ((1, 2)));
856# endif
857_GL_CXXALIAS_SYS (strsep, char *,
858                  (char **restrict __stringp, char const *restrict __delim));
859_GL_CXXALIASWARN (strsep);
860# if defined GNULIB_POSIXCHECK
861#  undef strsep
862_GL_WARN_ON_USE (strsep, "strsep cannot work correctly on character strings "
863                 "in multibyte locales - "
864                 "use mbssep if you care about internationalization");
865# endif
866#elif defined GNULIB_POSIXCHECK
867# undef strsep
868# if HAVE_RAW_DECL_STRSEP
869_GL_WARN_ON_USE (strsep, "strsep is unportable - "
870                 "use gnulib module strsep for portability");
871# endif
872#endif
873
874#if 0
875# if 0
876#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
877#   define strstr rpl_strstr
878#  endif
879_GL_FUNCDECL_RPL (strstr, char *, (const char *haystack, const char *needle)
880                                  _GL_ATTRIBUTE_PURE
881                                  _GL_ARG_NONNULL ((1, 2)));
882_GL_CXXALIAS_RPL (strstr, char *, (const char *haystack, const char *needle));
883# else
884  /* On some systems, this function is defined as an overloaded function:
885       extern "C++" { const char * strstr (const char *, const char *); }
886       extern "C++" { char * strstr (char *, const char *); }  */
887_GL_CXXALIAS_SYS_CAST2 (strstr,
888                        char *, (const char *haystack, const char *needle),
889                        const char *, (const char *haystack, const char *needle));
890# endif
891# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
892     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
893_GL_CXXALIASWARN1 (strstr, char *, (char *haystack, const char *needle));
894_GL_CXXALIASWARN1 (strstr, const char *,
895                   (const char *haystack, const char *needle));
896# else
897_GL_CXXALIASWARN (strstr);
898# endif
899#elif defined GNULIB_POSIXCHECK
900/* strstr() does not work with multibyte strings if the locale encoding is
901   different from UTF-8:
902   POSIX says that it operates on "strings", and "string" in POSIX is defined
903   as a sequence of bytes, not of characters.  */
904# undef strstr
905/* Assume strstr is always declared.  */
906_GL_WARN_ON_USE (strstr, "strstr is quadratic on many systems, and cannot "
907                 "work correctly on character strings in most "
908                 "multibyte locales - "
909                 "use mbsstr if you care about internationalization, "
910                 "or use strstr if you care about speed");
911#endif
912
913/* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive
914   comparison.  */
915#if 0
916# if 0
917#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
918#   define strcasestr rpl_strcasestr
919#  endif
920_GL_FUNCDECL_RPL (strcasestr, char *,
921                  (const char *haystack, const char *needle)
922                  _GL_ATTRIBUTE_PURE
923                  _GL_ARG_NONNULL ((1, 2)));
924_GL_CXXALIAS_RPL (strcasestr, char *,
925                  (const char *haystack, const char *needle));
926# else
927#  if ! 1
928_GL_FUNCDECL_SYS (strcasestr, char *,
929                  (const char *haystack, const char *needle)
930                  _GL_ATTRIBUTE_PURE
931                  _GL_ARG_NONNULL ((1, 2)));
932#  endif
933  /* On some systems, this function is defined as an overloaded function:
934       extern "C++" { const char * strcasestr (const char *, const char *); }
935       extern "C++" { char * strcasestr (char *, const char *); }  */
936_GL_CXXALIAS_SYS_CAST2 (strcasestr,
937                        char *, (const char *haystack, const char *needle),
938                        const char *, (const char *haystack, const char *needle));
939# endif
940# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
941     && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
942_GL_CXXALIASWARN1 (strcasestr, char *, (char *haystack, const char *needle));
943_GL_CXXALIASWARN1 (strcasestr, const char *,
944                   (const char *haystack, const char *needle));
945# else
946_GL_CXXALIASWARN (strcasestr);
947# endif
948#elif defined GNULIB_POSIXCHECK
949/* strcasestr() does not work with multibyte strings:
950   It is a glibc extension, and glibc implements it only for unibyte
951   locales.  */
952# undef strcasestr
953# if HAVE_RAW_DECL_STRCASESTR
954_GL_WARN_ON_USE (strcasestr, "strcasestr does work correctly on character "
955                 "strings in multibyte locales - "
956                 "use mbscasestr if you care about "
957                 "internationalization, or use c-strcasestr if you want "
958                 "a locale independent function");
959# endif
960#endif
961
962/* Parse S into tokens separated by characters in DELIM.
963   If S is NULL, the saved pointer in SAVE_PTR is used as
964   the next starting point.  For example:
965        char s[] = "-abc-=-def";
966        char *sp;
967        x = strtok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
968        x = strtok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
969        x = strtok_r(NULL, "=", &sp);   // x = NULL
970                // s = "abc\0-def\0"
971
972   This is a variant of strtok() that is multithread-safe.
973
974   For the POSIX documentation for this function, see:
975   http://www.opengroup.org/susv3xsh/strtok.html
976
977   Caveat: It modifies the original string.
978   Caveat: These functions cannot be used on constant strings.
979   Caveat: The identity of the delimiting character is lost.
980   Caveat: It doesn't work with multibyte strings unless all of the delimiter
981           characters are ASCII characters < 0x30.
982
983   See also strsep().  */
984#if 0
985# if 0
986#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
987#   undef strtok_r
988#   define strtok_r rpl_strtok_r
989#  endif
990_GL_FUNCDECL_RPL (strtok_r, char *,
991                  (char *restrict s, char const *restrict delim,
992                   char **restrict save_ptr)
993                  _GL_ARG_NONNULL ((2, 3)));
994_GL_CXXALIAS_RPL (strtok_r, char *,
995                  (char *restrict s, char const *restrict delim,
996                   char **restrict save_ptr));
997# else
998#  if 0 || defined GNULIB_POSIXCHECK
999#   undef strtok_r
1000#  endif
1001#  if ! 1
1002_GL_FUNCDECL_SYS (strtok_r, char *,
1003                  (char *restrict s, char const *restrict delim,
1004                   char **restrict save_ptr)
1005                  _GL_ARG_NONNULL ((2, 3)));
1006#  endif
1007_GL_CXXALIAS_SYS (strtok_r, char *,
1008                  (char *restrict s, char const *restrict delim,
1009                   char **restrict save_ptr));
1010# endif
1011_GL_CXXALIASWARN (strtok_r);
1012# if defined GNULIB_POSIXCHECK
1013_GL_WARN_ON_USE (strtok_r, "strtok_r cannot work correctly on character "
1014                 "strings in multibyte locales - "
1015                 "use mbstok_r if you care about internationalization");
1016# endif
1017#elif defined GNULIB_POSIXCHECK
1018# undef strtok_r
1019# if HAVE_RAW_DECL_STRTOK_R
1020_GL_WARN_ON_USE (strtok_r, "strtok_r is unportable - "
1021                 "use gnulib module strtok_r for portability");
1022# endif
1023#endif
1024
1025
1026/* The following functions are not specified by POSIX.  They are gnulib
1027   extensions.  */
1028
1029#if 0
1030/* Return the number of multibyte characters in the character string STRING.
1031   This considers multibyte characters, unlike strlen, which counts bytes.  */
1032# ifdef __MirBSD__  /* MirBSD defines mbslen as a macro.  Override it.  */
1033#  undef mbslen
1034# endif
1035# if 0  /* AIX, OSF/1, MirBSD define mbslen already in libc.  */
1036#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1037#   define mbslen rpl_mbslen
1038#  endif
1039_GL_FUNCDECL_RPL (mbslen, size_t, (const char *string)
1040                                  _GL_ATTRIBUTE_PURE
1041                                  _GL_ARG_NONNULL ((1)));
1042_GL_CXXALIAS_RPL (mbslen, size_t, (const char *string));
1043# else
1044_GL_FUNCDECL_SYS (mbslen, size_t, (const char *string)
1045                                  _GL_ATTRIBUTE_PURE
1046                                  _GL_ARG_NONNULL ((1)));
1047_GL_CXXALIAS_SYS (mbslen, size_t, (const char *string));
1048# endif
1049_GL_CXXALIASWARN (mbslen);
1050#endif
1051
1052#if 0
1053/* Return the number of multibyte characters in the character string starting
1054   at STRING and ending at STRING + LEN.  */
1055_GL_EXTERN_C size_t mbsnlen (const char *string, size_t len)
1056     _GL_ATTRIBUTE_PURE
1057     _GL_ARG_NONNULL ((1));
1058#endif
1059
1060#if 1
1061/* Locate the first single-byte character C in the character string STRING,
1062   and return a pointer to it.  Return NULL if C is not found in STRING.
1063   Unlike strchr(), this function works correctly in multibyte locales with
1064   encodings such as GB18030.  */
1065# if defined __hpux
1066#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1067#   define mbschr rpl_mbschr /* avoid collision with HP-UX function */
1068#  endif
1069_GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c)
1070                                  _GL_ATTRIBUTE_PURE
1071                                  _GL_ARG_NONNULL ((1)));
1072_GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c));
1073# else
1074_GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c)
1075                                  _GL_ATTRIBUTE_PURE
1076                                  _GL_ARG_NONNULL ((1)));
1077_GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c));
1078# endif
1079_GL_CXXALIASWARN (mbschr);
1080#endif
1081
1082#if 1
1083/* Locate the last single-byte character C in the character string STRING,
1084   and return a pointer to it.  Return NULL if C is not found in STRING.
1085   Unlike strrchr(), this function works correctly in multibyte locales with
1086   encodings such as GB18030.  */
1087# if defined __hpux || defined __INTERIX
1088#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1089#   define mbsrchr rpl_mbsrchr /* avoid collision with system function */
1090#  endif
1091_GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c)
1092                                   _GL_ATTRIBUTE_PURE
1093                                   _GL_ARG_NONNULL ((1)));
1094_GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c));
1095# else
1096_GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c)
1097                                   _GL_ATTRIBUTE_PURE
1098                                   _GL_ARG_NONNULL ((1)));
1099_GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c));
1100# endif
1101_GL_CXXALIASWARN (mbsrchr);
1102#endif
1103
1104#if 0
1105/* Find the first occurrence of the character string NEEDLE in the character
1106   string HAYSTACK.  Return NULL if NEEDLE is not found in HAYSTACK.
1107   Unlike strstr(), this function works correctly in multibyte locales with
1108   encodings different from UTF-8.  */
1109_GL_EXTERN_C char * mbsstr (const char *haystack, const char *needle)
1110     _GL_ATTRIBUTE_PURE
1111     _GL_ARG_NONNULL ((1, 2));
1112#endif
1113
1114#if 0
1115/* Compare the character strings S1 and S2, ignoring case, returning less than,
1116   equal to or greater than zero if S1 is lexicographically less than, equal to
1117   or greater than S2.
1118   Note: This function may, in multibyte locales, return 0 for strings of
1119   different lengths!
1120   Unlike strcasecmp(), this function works correctly in multibyte locales.  */
1121_GL_EXTERN_C int mbscasecmp (const char *s1, const char *s2)
1122     _GL_ATTRIBUTE_PURE
1123     _GL_ARG_NONNULL ((1, 2));
1124#endif
1125
1126#if 0
1127/* Compare the initial segment of the character string S1 consisting of at most
1128   N characters with the initial segment of the character string S2 consisting
1129   of at most N characters, ignoring case, returning less than, equal to or
1130   greater than zero if the initial segment of S1 is lexicographically less
1131   than, equal to or greater than the initial segment of S2.
1132   Note: This function may, in multibyte locales, return 0 for initial segments
1133   of different lengths!
1134   Unlike strncasecmp(), this function works correctly in multibyte locales.
1135   But beware that N is not a byte count but a character count!  */
1136_GL_EXTERN_C int mbsncasecmp (const char *s1, const char *s2, size_t n)
1137     _GL_ATTRIBUTE_PURE
1138     _GL_ARG_NONNULL ((1, 2));
1139#endif
1140
1141#if 0
1142/* Compare the initial segment of the character string STRING consisting of
1143   at most mbslen (PREFIX) characters with the character string PREFIX,
1144   ignoring case.  If the two match, return a pointer to the first byte
1145   after this prefix in STRING.  Otherwise, return NULL.
1146   Note: This function may, in multibyte locales, return non-NULL if STRING
1147   is of smaller length than PREFIX!
1148   Unlike strncasecmp(), this function works correctly in multibyte
1149   locales.  */
1150_GL_EXTERN_C char * mbspcasecmp (const char *string, const char *prefix)
1151     _GL_ATTRIBUTE_PURE
1152     _GL_ARG_NONNULL ((1, 2));
1153#endif
1154
1155#if 0
1156/* Find the first occurrence of the character string NEEDLE in the character
1157   string HAYSTACK, using case-insensitive comparison.
1158   Note: This function may, in multibyte locales, return success even if
1159   strlen (haystack) < strlen (needle) !
1160   Unlike strcasestr(), this function works correctly in multibyte locales.  */
1161_GL_EXTERN_C char * mbscasestr (const char *haystack, const char *needle)
1162     _GL_ATTRIBUTE_PURE
1163     _GL_ARG_NONNULL ((1, 2));
1164#endif
1165
1166#if 0
1167/* Find the first occurrence in the character string STRING of any character
1168   in the character string ACCEPT.  Return the number of bytes from the
1169   beginning of the string to this occurrence, or to the end of the string
1170   if none exists.
1171   Unlike strcspn(), this function works correctly in multibyte locales.  */
1172_GL_EXTERN_C size_t mbscspn (const char *string, const char *accept)
1173     _GL_ATTRIBUTE_PURE
1174     _GL_ARG_NONNULL ((1, 2));
1175#endif
1176
1177#if 0
1178/* Find the first occurrence in the character string STRING of any character
1179   in the character string ACCEPT.  Return the pointer to it, or NULL if none
1180   exists.
1181   Unlike strpbrk(), this function works correctly in multibyte locales.  */
1182# if defined __hpux
1183#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1184#   define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */
1185#  endif
1186_GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept)
1187                                   _GL_ATTRIBUTE_PURE
1188                                   _GL_ARG_NONNULL ((1, 2)));
1189_GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept));
1190# else
1191_GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept)
1192                                   _GL_ATTRIBUTE_PURE
1193                                   _GL_ARG_NONNULL ((1, 2)));
1194_GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept));
1195# endif
1196_GL_CXXALIASWARN (mbspbrk);
1197#endif
1198
1199#if 0
1200/* Find the first occurrence in the character string STRING of any character
1201   not in the character string REJECT.  Return the number of bytes from the
1202   beginning of the string to this occurrence, or to the end of the string
1203   if none exists.
1204   Unlike strspn(), this function works correctly in multibyte locales.  */
1205_GL_EXTERN_C size_t mbsspn (const char *string, const char *reject)
1206     _GL_ATTRIBUTE_PURE
1207     _GL_ARG_NONNULL ((1, 2));
1208#endif
1209
1210#if 0
1211/* Search the next delimiter (multibyte character listed in the character
1212   string DELIM) starting at the character string *STRINGP.
1213   If one is found, overwrite it with a NUL, and advance *STRINGP to point
1214   to the next multibyte character after it.  Otherwise, set *STRINGP to NULL.
1215   If *STRINGP was already NULL, nothing happens.
1216   Return the old value of *STRINGP.
1217
1218   This is a variant of mbstok_r() that supports empty fields.
1219
1220   Caveat: It modifies the original string.
1221   Caveat: These functions cannot be used on constant strings.
1222   Caveat: The identity of the delimiting character is lost.
1223
1224   See also mbstok_r().  */
1225_GL_EXTERN_C char * mbssep (char **stringp, const char *delim)
1226     _GL_ARG_NONNULL ((1, 2));
1227#endif
1228
1229#if 0
1230/* Parse the character string STRING into tokens separated by characters in
1231   the character string DELIM.
1232   If STRING is NULL, the saved pointer in SAVE_PTR is used as
1233   the next starting point.  For example:
1234        char s[] = "-abc-=-def";
1235        char *sp;
1236        x = mbstok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
1237        x = mbstok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
1238        x = mbstok_r(NULL, "=", &sp);   // x = NULL
1239                // s = "abc\0-def\0"
1240
1241   Caveat: It modifies the original string.
1242   Caveat: These functions cannot be used on constant strings.
1243   Caveat: The identity of the delimiting character is lost.
1244
1245   See also mbssep().  */
1246_GL_EXTERN_C char * mbstok_r (char *string, const char *delim, char **save_ptr)
1247     _GL_ARG_NONNULL ((2, 3));
1248#endif
1249
1250/* Map any int, typically from errno, into an error message.  */
1251#if 1
1252# if 0
1253#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1254#   undef strerror
1255#   define strerror rpl_strerror
1256#  endif
1257_GL_FUNCDECL_RPL (strerror, char *, (int));
1258_GL_CXXALIAS_RPL (strerror, char *, (int));
1259# else
1260_GL_CXXALIAS_SYS (strerror, char *, (int));
1261# endif
1262_GL_CXXALIASWARN (strerror);
1263#elif defined GNULIB_POSIXCHECK
1264# undef strerror
1265/* Assume strerror is always declared.  */
1266_GL_WARN_ON_USE (strerror, "strerror is unportable - "
1267                 "use gnulib module strerror to guarantee non-NULL result");
1268#endif
1269
1270/* Map any int, typically from errno, into an error message.  Multithread-safe.
1271   Uses the POSIX declaration, not the glibc declaration.  */
1272#if 1
1273# if 1
1274#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1275#   undef strerror_r
1276#   define strerror_r rpl_strerror_r
1277#  endif
1278_GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen)
1279                                   _GL_ARG_NONNULL ((2)));
1280_GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen));
1281# else
1282#  if !1
1283_GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen)
1284                                   _GL_ARG_NONNULL ((2)));
1285#  endif
1286_GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen));
1287# endif
1288# if 1
1289_GL_CXXALIASWARN (strerror_r);
1290# endif
1291#elif defined GNULIB_POSIXCHECK
1292# undef strerror_r
1293# if HAVE_RAW_DECL_STRERROR_R
1294_GL_WARN_ON_USE (strerror_r, "strerror_r is unportable - "
1295                 "use gnulib module strerror_r-posix for portability");
1296# endif
1297#endif
1298
1299#if 0
1300# if 0
1301#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1302#   define strsignal rpl_strsignal
1303#  endif
1304_GL_FUNCDECL_RPL (strsignal, char *, (int __sig));
1305_GL_CXXALIAS_RPL (strsignal, char *, (int __sig));
1306# else
1307#  if ! 1
1308_GL_FUNCDECL_SYS (strsignal, char *, (int __sig));
1309#  endif
1310/* Need to cast, because on Cygwin 1.5.x systems, the return type is
1311   'const char *'.  */
1312_GL_CXXALIAS_SYS_CAST (strsignal, char *, (int __sig));
1313# endif
1314_GL_CXXALIASWARN (strsignal);
1315#elif defined GNULIB_POSIXCHECK
1316# undef strsignal
1317# if HAVE_RAW_DECL_STRSIGNAL
1318_GL_WARN_ON_USE (strsignal, "strsignal is unportable - "
1319                 "use gnulib module strsignal for portability");
1320# endif
1321#endif
1322
1323#if 1
1324# if !1
1325_GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *)
1326                                   _GL_ATTRIBUTE_PURE
1327                                   _GL_ARG_NONNULL ((1, 2)));
1328# endif
1329_GL_CXXALIAS_SYS (strverscmp, int, (const char *, const char *));
1330_GL_CXXALIASWARN (strverscmp);
1331#elif defined GNULIB_POSIXCHECK
1332# undef strverscmp
1333# if HAVE_RAW_DECL_STRVERSCMP
1334_GL_WARN_ON_USE (strverscmp, "strverscmp is unportable - "
1335                 "use gnulib module strverscmp for portability");
1336# endif
1337#endif
1338
1339
1340#endif /* _GL_STRING_H */
1341#endif /* _GL_STRING_H */
1342