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