GDBserver
string.h
Go to the documentation of this file.
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) \
330 extern __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) \
334 extern __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) \
350 extern 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) \
355 extern 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)
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)
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 1
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)
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)
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)
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 0
530 # if ! 1
531 _GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in)
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 0
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 0
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)
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)
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 0
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 0
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 0
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)
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)
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)
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 1
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)
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)
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)
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 1
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)
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)
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)
1057  _GL_ARG_NONNULL ((1));
1058 #endif
1059 
1060 #if 0
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)
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)
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 0
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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 0
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
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 0
1273 # if 0
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 0
1324 # if !1
1325 _GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *)
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 */
#define _GL_CXXALIAS_SYS_CAST2(func, rettype, parameters, rettype2, parameters2)
Definition: string.h:250
#define _GL_ATTRIBUTE_PURE
Definition: string.h:45
#define _GL_CXXALIASWARN(func)
Definition: string.h:278
#define _GL_CXXALIAS_SYS(func, rettype, parameters)
Definition: string.h:207
#define _GL_CXXALIAS_SYS_CAST(func, rettype, parameters)
Definition: string.h:225
#define _GL_CXXALIAS_RPL(func, rettype, parameters)
Definition: string.h:154
#define _GL_ARG_NONNULL(params)
Definition: string.h:320
#define _GL_CXXALIASWARN1(func, rettype, parameters_and_attributes)
Definition: string.h:306
#define _GL_EXTERN_C
Definition: string.h:123
#define _GL_FUNCDECL_RPL(func, rettype, parameters_and_attributes)
Definition: string.h:133
#define _GL_WARN_ON_USE(function, message)
Definition: string.h:336
#define _GL_FUNCDECL_SYS(func, rettype, parameters_and_attributes)
Definition: string.h:145
#define restrict
Definition: config.h:1410
char * strerror(int)