• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* A GNU-like <string.h>.
2 
3    Copyright (C) 1995-1996, 2001-2012 Free Software Foundation, Inc.
4 
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 3, or (at your option)
8    any later version.
9 
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14 
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, see <http://www.gnu.org/licenses/>.  */
17 
18 #ifndef _@GUARD_PREFIX@_STRING_H
19 
20 #if __GNUC__ >= 3
21 @PRAGMA_SYSTEM_HEADER@
22 #endif
23 @PRAGMA_COLUMNS@
24 
25 /* The include_next requires a split double-inclusion guard.  */
26 #@INCLUDE_NEXT@ @NEXT_STRING_H@
27 
28 #ifndef _@GUARD_PREFIX@_STRING_H
29 #define _@GUARD_PREFIX@_STRING_H
30 
31 /* NetBSD 5.0 mis-defines NULL.  */
32 #include <stddef.h>
33 
34 /* MirBSD defines mbslen as a macro.  */
35 #if @GNULIB_MBSLEN@ && defined __MirBSD__
36 # include <wchar.h>
37 #endif
38 
39 /* The __attribute__ feature is available in gcc versions 2.5 and later.
40    The attribute __pure__ was added in gcc 2.96.  */
41 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
42 # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
43 #else
44 # define _GL_ATTRIBUTE_PURE /* empty */
45 #endif
46 
47 /* NetBSD 5.0 declares strsignal in <unistd.h>, not in <string.h>.  */
48 /* But in any case avoid namespace pollution on glibc systems.  */
49 #if (@GNULIB_STRSIGNAL@ || defined GNULIB_POSIXCHECK) && defined __NetBSD__ \
50     && ! defined __GLIBC__
51 # include <unistd.h>
52 #endif
53 
54 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
55 
56 /* The definition of _GL_ARG_NONNULL is copied here.  */
57 
58 /* The definition of _GL_WARN_ON_USE is copied here.  */
59 
60 
61 /* Find the index of the least-significant set bit.  */
62 #if @GNULIB_FFSL@
63 # if !@HAVE_FFSL@
64 _GL_FUNCDECL_SYS (ffsl, int, (long int i));
65 # endif
66 _GL_CXXALIAS_SYS (ffsl, int, (long int i));
67 _GL_CXXALIASWARN (ffsl);
68 #elif defined GNULIB_POSIXCHECK
69 # undef ffsl
70 # if HAVE_RAW_DECL_FFSL
71 _GL_WARN_ON_USE (ffsl, "ffsl is not portable - use the ffsl module");
72 # endif
73 #endif
74 
75 
76 /* Find the index of the least-significant set bit.  */
77 #if @GNULIB_FFSLL@
78 # if !@HAVE_FFSLL@
79 _GL_FUNCDECL_SYS (ffsll, int, (long long int i));
80 # endif
81 _GL_CXXALIAS_SYS (ffsll, int, (long long int i));
82 _GL_CXXALIASWARN (ffsll);
83 #elif defined GNULIB_POSIXCHECK
84 # undef ffsll
85 # if HAVE_RAW_DECL_FFSLL
86 _GL_WARN_ON_USE (ffsll, "ffsll is not portable - use the ffsll module");
87 # endif
88 #endif
89 
90 
91 /* Return the first instance of C within N bytes of S, or NULL.  */
92 #if @GNULIB_MEMCHR@
93 # if @REPLACE_MEMCHR@
94 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
95 #   define memchr rpl_memchr
96 #  endif
97 _GL_FUNCDECL_RPL (memchr, void *, (void const *__s, int __c, size_t __n)
98                                   _GL_ATTRIBUTE_PURE
99                                   _GL_ARG_NONNULL ((1)));
100 _GL_CXXALIAS_RPL (memchr, void *, (void const *__s, int __c, size_t __n));
101 # else
102 #  if ! @HAVE_MEMCHR@
103 _GL_FUNCDECL_SYS (memchr, void *, (void const *__s, int __c, size_t __n)
104                                   _GL_ATTRIBUTE_PURE
105                                   _GL_ARG_NONNULL ((1)));
106 #  endif
107   /* On some systems, this function is defined as an overloaded function:
108        extern "C" { const void * std::memchr (const void *, int, size_t); }
109        extern "C++" { void * std::memchr (void *, int, size_t); }  */
110 _GL_CXXALIAS_SYS_CAST2 (memchr,
111                         void *, (void const *__s, int __c, size_t __n),
112                         void const *, (void const *__s, int __c, size_t __n));
113 # endif
114 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
115      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
116 _GL_CXXALIASWARN1 (memchr, void *, (void *__s, int __c, size_t __n));
117 _GL_CXXALIASWARN1 (memchr, void const *,
118                    (void const *__s, int __c, size_t __n));
119 # else
120 _GL_CXXALIASWARN (memchr);
121 # endif
122 #elif defined GNULIB_POSIXCHECK
123 # undef memchr
124 /* Assume memchr is always declared.  */
125 _GL_WARN_ON_USE (memchr, "memchr has platform-specific bugs - "
126                  "use gnulib module memchr for portability" );
127 #endif
128 
129 /* Return the first occurrence of NEEDLE in HAYSTACK.  */
130 #if @GNULIB_MEMMEM@
131 # if @REPLACE_MEMMEM@
132 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
133 #   define memmem rpl_memmem
134 #  endif
135 _GL_FUNCDECL_RPL (memmem, void *,
136                   (void const *__haystack, size_t __haystack_len,
137                    void const *__needle, size_t __needle_len)
138                   _GL_ATTRIBUTE_PURE
139                   _GL_ARG_NONNULL ((1, 3)));
140 _GL_CXXALIAS_RPL (memmem, void *,
141                   (void const *__haystack, size_t __haystack_len,
142                    void const *__needle, size_t __needle_len));
143 # else
144 #  if ! @HAVE_DECL_MEMMEM@
145 _GL_FUNCDECL_SYS (memmem, void *,
146                   (void const *__haystack, size_t __haystack_len,
147                    void const *__needle, size_t __needle_len)
148                   _GL_ATTRIBUTE_PURE
149                   _GL_ARG_NONNULL ((1, 3)));
150 #  endif
151 _GL_CXXALIAS_SYS (memmem, void *,
152                   (void const *__haystack, size_t __haystack_len,
153                    void const *__needle, size_t __needle_len));
154 # endif
155 _GL_CXXALIASWARN (memmem);
156 #elif defined GNULIB_POSIXCHECK
157 # undef memmem
158 # if HAVE_RAW_DECL_MEMMEM
159 _GL_WARN_ON_USE (memmem, "memmem is unportable and often quadratic - "
160                  "use gnulib module memmem-simple for portability, "
161                  "and module memmem for speed" );
162 # endif
163 #endif
164 
165 /* Copy N bytes of SRC to DEST, return pointer to bytes after the
166    last written byte.  */
167 #if @GNULIB_MEMPCPY@
168 # if ! @HAVE_MEMPCPY@
169 _GL_FUNCDECL_SYS (mempcpy, void *,
170                   (void *restrict __dest, void const *restrict __src,
171                    size_t __n)
172                   _GL_ARG_NONNULL ((1, 2)));
173 # endif
174 _GL_CXXALIAS_SYS (mempcpy, void *,
175                   (void *restrict __dest, void const *restrict __src,
176                    size_t __n));
177 _GL_CXXALIASWARN (mempcpy);
178 #elif defined GNULIB_POSIXCHECK
179 # undef mempcpy
180 # if HAVE_RAW_DECL_MEMPCPY
181 _GL_WARN_ON_USE (mempcpy, "mempcpy is unportable - "
182                  "use gnulib module mempcpy for portability");
183 # endif
184 #endif
185 
186 /* Search backwards through a block for a byte (specified as an int).  */
187 #if @GNULIB_MEMRCHR@
188 # if ! @HAVE_DECL_MEMRCHR@
189 _GL_FUNCDECL_SYS (memrchr, void *, (void const *, int, size_t)
190                                    _GL_ATTRIBUTE_PURE
191                                    _GL_ARG_NONNULL ((1)));
192 # endif
193   /* On some systems, this function is defined as an overloaded function:
194        extern "C++" { const void * std::memrchr (const void *, int, size_t); }
195        extern "C++" { void * std::memrchr (void *, int, size_t); }  */
196 _GL_CXXALIAS_SYS_CAST2 (memrchr,
197                         void *, (void const *, int, size_t),
198                         void const *, (void const *, int, size_t));
199 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
200      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
201 _GL_CXXALIASWARN1 (memrchr, void *, (void *, int, size_t));
202 _GL_CXXALIASWARN1 (memrchr, void const *, (void const *, int, size_t));
203 # else
204 _GL_CXXALIASWARN (memrchr);
205 # endif
206 #elif defined GNULIB_POSIXCHECK
207 # undef memrchr
208 # if HAVE_RAW_DECL_MEMRCHR
209 _GL_WARN_ON_USE (memrchr, "memrchr is unportable - "
210                  "use gnulib module memrchr for portability");
211 # endif
212 #endif
213 
214 /* Find the first occurrence of C in S.  More efficient than
215    memchr(S,C,N), at the expense of undefined behavior if C does not
216    occur within N bytes.  */
217 #if @GNULIB_RAWMEMCHR@
218 # if ! @HAVE_RAWMEMCHR@
219 _GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in)
220                                      _GL_ATTRIBUTE_PURE
221                                      _GL_ARG_NONNULL ((1)));
222 # endif
223   /* On some systems, this function is defined as an overloaded function:
224        extern "C++" { const void * std::rawmemchr (const void *, int); }
225        extern "C++" { void * std::rawmemchr (void *, int); }  */
226 _GL_CXXALIAS_SYS_CAST2 (rawmemchr,
227                         void *, (void const *__s, int __c_in),
228                         void const *, (void const *__s, int __c_in));
229 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
230      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
231 _GL_CXXALIASWARN1 (rawmemchr, void *, (void *__s, int __c_in));
232 _GL_CXXALIASWARN1 (rawmemchr, void const *, (void const *__s, int __c_in));
233 # else
234 _GL_CXXALIASWARN (rawmemchr);
235 # endif
236 #elif defined GNULIB_POSIXCHECK
237 # undef rawmemchr
238 # if HAVE_RAW_DECL_RAWMEMCHR
239 _GL_WARN_ON_USE (rawmemchr, "rawmemchr is unportable - "
240                  "use gnulib module rawmemchr for portability");
241 # endif
242 #endif
243 
244 /* Copy SRC to DST, returning the address of the terminating '\0' in DST.  */
245 #if @GNULIB_STPCPY@
246 # if ! @HAVE_STPCPY@
247 _GL_FUNCDECL_SYS (stpcpy, char *,
248                   (char *restrict __dst, char const *restrict __src)
249                   _GL_ARG_NONNULL ((1, 2)));
250 # endif
251 _GL_CXXALIAS_SYS (stpcpy, char *,
252                   (char *restrict __dst, char const *restrict __src));
253 _GL_CXXALIASWARN (stpcpy);
254 #elif defined GNULIB_POSIXCHECK
255 # undef stpcpy
256 # if HAVE_RAW_DECL_STPCPY
257 _GL_WARN_ON_USE (stpcpy, "stpcpy is unportable - "
258                  "use gnulib module stpcpy for portability");
259 # endif
260 #endif
261 
262 /* Copy no more than N bytes of SRC to DST, returning a pointer past the
263    last non-NUL byte written into DST.  */
264 #if @GNULIB_STPNCPY@
265 # if @REPLACE_STPNCPY@
266 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
267 #   undef stpncpy
268 #   define stpncpy rpl_stpncpy
269 #  endif
270 _GL_FUNCDECL_RPL (stpncpy, char *,
271                   (char *restrict __dst, char const *restrict __src,
272                    size_t __n)
273                   _GL_ARG_NONNULL ((1, 2)));
274 _GL_CXXALIAS_RPL (stpncpy, char *,
275                   (char *restrict __dst, char const *restrict __src,
276                    size_t __n));
277 # else
278 #  if ! @HAVE_STPNCPY@
279 _GL_FUNCDECL_SYS (stpncpy, char *,
280                   (char *restrict __dst, char const *restrict __src,
281                    size_t __n)
282                   _GL_ARG_NONNULL ((1, 2)));
283 #  endif
284 _GL_CXXALIAS_SYS (stpncpy, char *,
285                   (char *restrict __dst, char const *restrict __src,
286                    size_t __n));
287 # endif
288 _GL_CXXALIASWARN (stpncpy);
289 #elif defined GNULIB_POSIXCHECK
290 # undef stpncpy
291 # if HAVE_RAW_DECL_STPNCPY
292 _GL_WARN_ON_USE (stpncpy, "stpncpy is unportable - "
293                  "use gnulib module stpncpy for portability");
294 # endif
295 #endif
296 
297 #if defined GNULIB_POSIXCHECK
298 /* strchr() does not work with multibyte strings if the locale encoding is
299    GB18030 and the character to be searched is a digit.  */
300 # undef strchr
301 /* Assume strchr is always declared.  */
302 _GL_WARN_ON_USE (strchr, "strchr cannot work correctly on character strings "
303                  "in some multibyte locales - "
304                  "use mbschr if you care about internationalization");
305 #endif
306 
307 /* Find the first occurrence of C in S or the final NUL byte.  */
308 #if @GNULIB_STRCHRNUL@
309 # if @REPLACE_STRCHRNUL@
310 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
311 #   define strchrnul rpl_strchrnul
312 #  endif
313 _GL_FUNCDECL_RPL (strchrnul, char *, (const char *__s, int __c_in)
314                                      _GL_ATTRIBUTE_PURE
315                                      _GL_ARG_NONNULL ((1)));
316 _GL_CXXALIAS_RPL (strchrnul, char *,
317                   (const char *str, int ch));
318 # else
319 #  if ! @HAVE_STRCHRNUL@
320 _GL_FUNCDECL_SYS (strchrnul, char *, (char const *__s, int __c_in)
321                                      _GL_ATTRIBUTE_PURE
322                                      _GL_ARG_NONNULL ((1)));
323 #  endif
324   /* On some systems, this function is defined as an overloaded function:
325        extern "C++" { const char * std::strchrnul (const char *, int); }
326        extern "C++" { char * std::strchrnul (char *, int); }  */
327 _GL_CXXALIAS_SYS_CAST2 (strchrnul,
328                         char *, (char const *__s, int __c_in),
329                         char const *, (char const *__s, int __c_in));
330 # endif
331 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
332      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
333 _GL_CXXALIASWARN1 (strchrnul, char *, (char *__s, int __c_in));
334 _GL_CXXALIASWARN1 (strchrnul, char const *, (char const *__s, int __c_in));
335 # else
336 _GL_CXXALIASWARN (strchrnul);
337 # endif
338 #elif defined GNULIB_POSIXCHECK
339 # undef strchrnul
340 # if HAVE_RAW_DECL_STRCHRNUL
341 _GL_WARN_ON_USE (strchrnul, "strchrnul is unportable - "
342                  "use gnulib module strchrnul for portability");
343 # endif
344 #endif
345 
346 /* Duplicate S, returning an identical malloc'd string.  */
347 #if @GNULIB_STRDUP@
348 # if @REPLACE_STRDUP@
349 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
350 #   undef strdup
351 #   define strdup rpl_strdup
352 #  endif
353 _GL_FUNCDECL_RPL (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));
354 _GL_CXXALIAS_RPL (strdup, char *, (char const *__s));
355 # else
356 #  if defined __cplusplus && defined GNULIB_NAMESPACE && defined strdup
357     /* strdup exists as a function and as a macro.  Get rid of the macro.  */
358 #   undef strdup
359 #  endif
360 #  if !(@HAVE_DECL_STRDUP@ || defined strdup)
361 _GL_FUNCDECL_SYS (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));
362 #  endif
363 _GL_CXXALIAS_SYS (strdup, char *, (char const *__s));
364 # endif
365 _GL_CXXALIASWARN (strdup);
366 #elif defined GNULIB_POSIXCHECK
367 # undef strdup
368 # if HAVE_RAW_DECL_STRDUP
369 _GL_WARN_ON_USE (strdup, "strdup is unportable - "
370                  "use gnulib module strdup for portability");
371 # endif
372 #endif
373 
374 /* Append no more than N characters from SRC onto DEST.  */
375 #if @GNULIB_STRNCAT@
376 # if @REPLACE_STRNCAT@
377 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
378 #   undef strncat
379 #   define strncat rpl_strncat
380 #  endif
381 _GL_FUNCDECL_RPL (strncat, char *, (char *dest, const char *src, size_t n)
382                                    _GL_ARG_NONNULL ((1, 2)));
383 _GL_CXXALIAS_RPL (strncat, char *, (char *dest, const char *src, size_t n));
384 # else
385 _GL_CXXALIAS_SYS (strncat, char *, (char *dest, const char *src, size_t n));
386 # endif
387 _GL_CXXALIASWARN (strncat);
388 #elif defined GNULIB_POSIXCHECK
389 # undef strncat
390 # if HAVE_RAW_DECL_STRNCAT
391 _GL_WARN_ON_USE (strncat, "strncat is unportable - "
392                  "use gnulib module strncat for portability");
393 # endif
394 #endif
395 
396 /* Return a newly allocated copy of at most N bytes of STRING.  */
397 #if @GNULIB_STRNDUP@
398 # if @REPLACE_STRNDUP@
399 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
400 #   undef strndup
401 #   define strndup rpl_strndup
402 #  endif
403 _GL_FUNCDECL_RPL (strndup, char *, (char const *__string, size_t __n)
404                                    _GL_ARG_NONNULL ((1)));
405 _GL_CXXALIAS_RPL (strndup, char *, (char const *__string, size_t __n));
406 # else
407 #  if ! @HAVE_DECL_STRNDUP@
408 _GL_FUNCDECL_SYS (strndup, char *, (char const *__string, size_t __n)
409                                    _GL_ARG_NONNULL ((1)));
410 #  endif
411 _GL_CXXALIAS_SYS (strndup, char *, (char const *__string, size_t __n));
412 # endif
413 _GL_CXXALIASWARN (strndup);
414 #elif defined GNULIB_POSIXCHECK
415 # undef strndup
416 # if HAVE_RAW_DECL_STRNDUP
417 _GL_WARN_ON_USE (strndup, "strndup is unportable - "
418                  "use gnulib module strndup for portability");
419 # endif
420 #endif
421 
422 /* Find the length (number of bytes) of STRING, but scan at most
423    MAXLEN bytes.  If no '\0' terminator is found in that many bytes,
424    return MAXLEN.  */
425 #if @GNULIB_STRNLEN@
426 # if @REPLACE_STRNLEN@
427 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
428 #   undef strnlen
429 #   define strnlen rpl_strnlen
430 #  endif
431 _GL_FUNCDECL_RPL (strnlen, size_t, (char const *__string, size_t __maxlen)
432                                    _GL_ATTRIBUTE_PURE
433                                    _GL_ARG_NONNULL ((1)));
434 _GL_CXXALIAS_RPL (strnlen, size_t, (char const *__string, size_t __maxlen));
435 # else
436 #  if ! @HAVE_DECL_STRNLEN@
437 _GL_FUNCDECL_SYS (strnlen, size_t, (char const *__string, size_t __maxlen)
438                                    _GL_ATTRIBUTE_PURE
439                                    _GL_ARG_NONNULL ((1)));
440 #  endif
441 _GL_CXXALIAS_SYS (strnlen, size_t, (char const *__string, size_t __maxlen));
442 # endif
443 _GL_CXXALIASWARN (strnlen);
444 #elif defined GNULIB_POSIXCHECK
445 # undef strnlen
446 # if HAVE_RAW_DECL_STRNLEN
447 _GL_WARN_ON_USE (strnlen, "strnlen is unportable - "
448                  "use gnulib module strnlen for portability");
449 # endif
450 #endif
451 
452 #if defined GNULIB_POSIXCHECK
453 /* strcspn() assumes the second argument is a list of single-byte characters.
454    Even in this simple case, it does not work with multibyte strings if the
455    locale encoding is GB18030 and one of the characters to be searched is a
456    digit.  */
457 # undef strcspn
458 /* Assume strcspn is always declared.  */
459 _GL_WARN_ON_USE (strcspn, "strcspn cannot work correctly on character strings "
460                  "in multibyte locales - "
461                  "use mbscspn if you care about internationalization");
462 #endif
463 
464 /* Find the first occurrence in S of any character in ACCEPT.  */
465 #if @GNULIB_STRPBRK@
466 # if ! @HAVE_STRPBRK@
467 _GL_FUNCDECL_SYS (strpbrk, char *, (char const *__s, char const *__accept)
468                                    _GL_ATTRIBUTE_PURE
469                                    _GL_ARG_NONNULL ((1, 2)));
470 # endif
471   /* On some systems, this function is defined as an overloaded function:
472        extern "C" { const char * strpbrk (const char *, const char *); }
473        extern "C++" { char * strpbrk (char *, const char *); }  */
474 _GL_CXXALIAS_SYS_CAST2 (strpbrk,
475                         char *, (char const *__s, char const *__accept),
476                         const char *, (char const *__s, char const *__accept));
477 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
478      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
479 _GL_CXXALIASWARN1 (strpbrk, char *, (char *__s, char const *__accept));
480 _GL_CXXALIASWARN1 (strpbrk, char const *,
481                    (char const *__s, char const *__accept));
482 # else
483 _GL_CXXALIASWARN (strpbrk);
484 # endif
485 # if defined GNULIB_POSIXCHECK
486 /* strpbrk() assumes the second argument is a list of single-byte characters.
487    Even in this simple case, it does not work with multibyte strings if the
488    locale encoding is GB18030 and one of the characters to be searched is a
489    digit.  */
490 #  undef strpbrk
491 _GL_WARN_ON_USE (strpbrk, "strpbrk cannot work correctly on character strings "
492                  "in multibyte locales - "
493                  "use mbspbrk if you care about internationalization");
494 # endif
495 #elif defined GNULIB_POSIXCHECK
496 # undef strpbrk
497 # if HAVE_RAW_DECL_STRPBRK
498 _GL_WARN_ON_USE (strpbrk, "strpbrk is unportable - "
499                  "use gnulib module strpbrk for portability");
500 # endif
501 #endif
502 
503 #if defined GNULIB_POSIXCHECK
504 /* strspn() assumes the second argument is a list of single-byte characters.
505    Even in this simple case, it cannot work with multibyte strings.  */
506 # undef strspn
507 /* Assume strspn is always declared.  */
508 _GL_WARN_ON_USE (strspn, "strspn cannot work correctly on character strings "
509                  "in multibyte locales - "
510                  "use mbsspn if you care about internationalization");
511 #endif
512 
513 #if defined GNULIB_POSIXCHECK
514 /* strrchr() does not work with multibyte strings if the locale encoding is
515    GB18030 and the character to be searched is a digit.  */
516 # undef strrchr
517 /* Assume strrchr is always declared.  */
518 _GL_WARN_ON_USE (strrchr, "strrchr cannot work correctly on character strings "
519                  "in some multibyte locales - "
520                  "use mbsrchr if you care about internationalization");
521 #endif
522 
523 /* Search the next delimiter (char listed in DELIM) starting at *STRINGP.
524    If one is found, overwrite it with a NUL, and advance *STRINGP
525    to point to the next char after it.  Otherwise, set *STRINGP to NULL.
526    If *STRINGP was already NULL, nothing happens.
527    Return the old value of *STRINGP.
528 
529    This is a variant of strtok() that is multithread-safe and supports
530    empty fields.
531 
532    Caveat: It modifies the original string.
533    Caveat: These functions cannot be used on constant strings.
534    Caveat: The identity of the delimiting character is lost.
535    Caveat: It doesn't work with multibyte strings unless all of the delimiter
536            characters are ASCII characters < 0x30.
537 
538    See also strtok_r().  */
539 #if @GNULIB_STRSEP@
540 # if ! @HAVE_STRSEP@
541 _GL_FUNCDECL_SYS (strsep, char *,
542                   (char **restrict __stringp, char const *restrict __delim)
543                   _GL_ARG_NONNULL ((1, 2)));
544 # endif
545 _GL_CXXALIAS_SYS (strsep, char *,
546                   (char **restrict __stringp, char const *restrict __delim));
547 _GL_CXXALIASWARN (strsep);
548 # if defined GNULIB_POSIXCHECK
549 #  undef strsep
550 _GL_WARN_ON_USE (strsep, "strsep cannot work correctly on character strings "
551                  "in multibyte locales - "
552                  "use mbssep if you care about internationalization");
553 # endif
554 #elif defined GNULIB_POSIXCHECK
555 # undef strsep
556 # if HAVE_RAW_DECL_STRSEP
557 _GL_WARN_ON_USE (strsep, "strsep is unportable - "
558                  "use gnulib module strsep for portability");
559 # endif
560 #endif
561 
562 #if @GNULIB_STRSTR@
563 # if @REPLACE_STRSTR@
564 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
565 #   define strstr rpl_strstr
566 #  endif
567 _GL_FUNCDECL_RPL (strstr, char *, (const char *haystack, const char *needle)
568                                   _GL_ATTRIBUTE_PURE
569                                   _GL_ARG_NONNULL ((1, 2)));
570 _GL_CXXALIAS_RPL (strstr, char *, (const char *haystack, const char *needle));
571 # else
572   /* On some systems, this function is defined as an overloaded function:
573        extern "C++" { const char * strstr (const char *, const char *); }
574        extern "C++" { char * strstr (char *, const char *); }  */
575 _GL_CXXALIAS_SYS_CAST2 (strstr,
576                         char *, (const char *haystack, const char *needle),
577                         const char *, (const char *haystack, const char *needle));
578 # endif
579 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
580      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
581 _GL_CXXALIASWARN1 (strstr, char *, (char *haystack, const char *needle));
582 _GL_CXXALIASWARN1 (strstr, const char *,
583                    (const char *haystack, const char *needle));
584 # else
585 _GL_CXXALIASWARN (strstr);
586 # endif
587 #elif defined GNULIB_POSIXCHECK
588 /* strstr() does not work with multibyte strings if the locale encoding is
589    different from UTF-8:
590    POSIX says that it operates on "strings", and "string" in POSIX is defined
591    as a sequence of bytes, not of characters.  */
592 # undef strstr
593 /* Assume strstr is always declared.  */
594 _GL_WARN_ON_USE (strstr, "strstr is quadratic on many systems, and cannot "
595                  "work correctly on character strings in most "
596                  "multibyte locales - "
597                  "use mbsstr if you care about internationalization, "
598                  "or use strstr if you care about speed");
599 #endif
600 
601 /* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive
602    comparison.  */
603 #if @GNULIB_STRCASESTR@
604 # if @REPLACE_STRCASESTR@
605 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
606 #   define strcasestr rpl_strcasestr
607 #  endif
608 _GL_FUNCDECL_RPL (strcasestr, char *,
609                   (const char *haystack, const char *needle)
610                   _GL_ATTRIBUTE_PURE
611                   _GL_ARG_NONNULL ((1, 2)));
612 _GL_CXXALIAS_RPL (strcasestr, char *,
613                   (const char *haystack, const char *needle));
614 # else
615 #  if ! @HAVE_STRCASESTR@
616 _GL_FUNCDECL_SYS (strcasestr, char *,
617                   (const char *haystack, const char *needle)
618                   _GL_ATTRIBUTE_PURE
619                   _GL_ARG_NONNULL ((1, 2)));
620 #  endif
621   /* On some systems, this function is defined as an overloaded function:
622        extern "C++" { const char * strcasestr (const char *, const char *); }
623        extern "C++" { char * strcasestr (char *, const char *); }  */
624 _GL_CXXALIAS_SYS_CAST2 (strcasestr,
625                         char *, (const char *haystack, const char *needle),
626                         const char *, (const char *haystack, const char *needle));
627 # endif
628 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
629      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
630 _GL_CXXALIASWARN1 (strcasestr, char *, (char *haystack, const char *needle));
631 _GL_CXXALIASWARN1 (strcasestr, const char *,
632                    (const char *haystack, const char *needle));
633 # else
634 _GL_CXXALIASWARN (strcasestr);
635 # endif
636 #elif defined GNULIB_POSIXCHECK
637 /* strcasestr() does not work with multibyte strings:
638    It is a glibc extension, and glibc implements it only for unibyte
639    locales.  */
640 # undef strcasestr
641 # if HAVE_RAW_DECL_STRCASESTR
642 _GL_WARN_ON_USE (strcasestr, "strcasestr does work correctly on character "
643                  "strings in multibyte locales - "
644                  "use mbscasestr if you care about "
645                  "internationalization, or use c-strcasestr if you want "
646                  "a locale independent function");
647 # endif
648 #endif
649 
650 /* Parse S into tokens separated by characters in DELIM.
651    If S is NULL, the saved pointer in SAVE_PTR is used as
652    the next starting point.  For example:
653         char s[] = "-abc-=-def";
654         char *sp;
655         x = strtok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
656         x = strtok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
657         x = strtok_r(NULL, "=", &sp);   // x = NULL
658                 // s = "abc\0-def\0"
659 
660    This is a variant of strtok() that is multithread-safe.
661 
662    For the POSIX documentation for this function, see:
663    http://www.opengroup.org/susv3xsh/strtok.html
664 
665    Caveat: It modifies the original string.
666    Caveat: These functions cannot be used on constant strings.
667    Caveat: The identity of the delimiting character is lost.
668    Caveat: It doesn't work with multibyte strings unless all of the delimiter
669            characters are ASCII characters < 0x30.
670 
671    See also strsep().  */
672 #if @GNULIB_STRTOK_R@
673 # if @REPLACE_STRTOK_R@
674 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
675 #   undef strtok_r
676 #   define strtok_r rpl_strtok_r
677 #  endif
678 _GL_FUNCDECL_RPL (strtok_r, char *,
679                   (char *restrict s, char const *restrict delim,
680                    char **restrict save_ptr)
681                   _GL_ARG_NONNULL ((2, 3)));
682 _GL_CXXALIAS_RPL (strtok_r, char *,
683                   (char *restrict s, char const *restrict delim,
684                    char **restrict save_ptr));
685 # else
686 #  if @UNDEFINE_STRTOK_R@ || defined GNULIB_POSIXCHECK
687 #   undef strtok_r
688 #  endif
689 #  if ! @HAVE_DECL_STRTOK_R@
690 _GL_FUNCDECL_SYS (strtok_r, char *,
691                   (char *restrict s, char const *restrict delim,
692                    char **restrict save_ptr)
693                   _GL_ARG_NONNULL ((2, 3)));
694 #  endif
695 _GL_CXXALIAS_SYS (strtok_r, char *,
696                   (char *restrict s, char const *restrict delim,
697                    char **restrict save_ptr));
698 # endif
699 _GL_CXXALIASWARN (strtok_r);
700 # if defined GNULIB_POSIXCHECK
701 _GL_WARN_ON_USE (strtok_r, "strtok_r cannot work correctly on character "
702                  "strings in multibyte locales - "
703                  "use mbstok_r if you care about internationalization");
704 # endif
705 #elif defined GNULIB_POSIXCHECK
706 # undef strtok_r
707 # if HAVE_RAW_DECL_STRTOK_R
708 _GL_WARN_ON_USE (strtok_r, "strtok_r is unportable - "
709                  "use gnulib module strtok_r for portability");
710 # endif
711 #endif
712 
713 
714 /* The following functions are not specified by POSIX.  They are gnulib
715    extensions.  */
716 
717 #if @GNULIB_MBSLEN@
718 /* Return the number of multibyte characters in the character string STRING.
719    This considers multibyte characters, unlike strlen, which counts bytes.  */
720 # ifdef __MirBSD__  /* MirBSD defines mbslen as a macro.  Override it.  */
721 #  undef mbslen
722 # endif
723 # if @HAVE_MBSLEN@  /* AIX, OSF/1, MirBSD define mbslen already in libc.  */
724 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
725 #   define mbslen rpl_mbslen
726 #  endif
727 _GL_FUNCDECL_RPL (mbslen, size_t, (const char *string)
728                                   _GL_ATTRIBUTE_PURE
729                                   _GL_ARG_NONNULL ((1)));
730 _GL_CXXALIAS_RPL (mbslen, size_t, (const char *string));
731 # else
732 _GL_FUNCDECL_SYS (mbslen, size_t, (const char *string)
733                                   _GL_ATTRIBUTE_PURE
734                                   _GL_ARG_NONNULL ((1)));
735 _GL_CXXALIAS_SYS (mbslen, size_t, (const char *string));
736 # endif
737 _GL_CXXALIASWARN (mbslen);
738 #endif
739 
740 #if @GNULIB_MBSNLEN@
741 /* Return the number of multibyte characters in the character string starting
742    at STRING and ending at STRING + LEN.  */
743 _GL_EXTERN_C size_t mbsnlen (const char *string, size_t len)
744      _GL_ATTRIBUTE_PURE
745      _GL_ARG_NONNULL ((1));
746 #endif
747 
748 #if @GNULIB_MBSCHR@
749 /* Locate the first single-byte character C in the character string STRING,
750    and return a pointer to it.  Return NULL if C is not found in STRING.
751    Unlike strchr(), this function works correctly in multibyte locales with
752    encodings such as GB18030.  */
753 # if defined __hpux
754 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
755 #   define mbschr rpl_mbschr /* avoid collision with HP-UX function */
756 #  endif
757 _GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c)
758                                   _GL_ATTRIBUTE_PURE
759                                   _GL_ARG_NONNULL ((1)));
760 _GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c));
761 # else
762 _GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c)
763                                   _GL_ATTRIBUTE_PURE
764                                   _GL_ARG_NONNULL ((1)));
765 _GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c));
766 # endif
767 _GL_CXXALIASWARN (mbschr);
768 #endif
769 
770 #if @GNULIB_MBSRCHR@
771 /* Locate the last single-byte character C in the character string STRING,
772    and return a pointer to it.  Return NULL if C is not found in STRING.
773    Unlike strrchr(), this function works correctly in multibyte locales with
774    encodings such as GB18030.  */
775 # if defined __hpux || defined __INTERIX
776 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
777 #   define mbsrchr rpl_mbsrchr /* avoid collision with system function */
778 #  endif
779 _GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c)
780                                    _GL_ATTRIBUTE_PURE
781                                    _GL_ARG_NONNULL ((1)));
782 _GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c));
783 # else
784 _GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c)
785                                    _GL_ATTRIBUTE_PURE
786                                    _GL_ARG_NONNULL ((1)));
787 _GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c));
788 # endif
789 _GL_CXXALIASWARN (mbsrchr);
790 #endif
791 
792 #if @GNULIB_MBSSTR@
793 /* Find the first occurrence of the character string NEEDLE in the character
794    string HAYSTACK.  Return NULL if NEEDLE is not found in HAYSTACK.
795    Unlike strstr(), this function works correctly in multibyte locales with
796    encodings different from UTF-8.  */
797 _GL_EXTERN_C char * mbsstr (const char *haystack, const char *needle)
798      _GL_ATTRIBUTE_PURE
799      _GL_ARG_NONNULL ((1, 2));
800 #endif
801 
802 #if @GNULIB_MBSCASECMP@
803 /* Compare the character strings S1 and S2, ignoring case, returning less than,
804    equal to or greater than zero if S1 is lexicographically less than, equal to
805    or greater than S2.
806    Note: This function may, in multibyte locales, return 0 for strings of
807    different lengths!
808    Unlike strcasecmp(), this function works correctly in multibyte locales.  */
809 _GL_EXTERN_C int mbscasecmp (const char *s1, const char *s2)
810      _GL_ATTRIBUTE_PURE
811      _GL_ARG_NONNULL ((1, 2));
812 #endif
813 
814 #if @GNULIB_MBSNCASECMP@
815 /* Compare the initial segment of the character string S1 consisting of at most
816    N characters with the initial segment of the character string S2 consisting
817    of at most N characters, ignoring case, returning less than, equal to or
818    greater than zero if the initial segment of S1 is lexicographically less
819    than, equal to or greater than the initial segment of S2.
820    Note: This function may, in multibyte locales, return 0 for initial segments
821    of different lengths!
822    Unlike strncasecmp(), this function works correctly in multibyte locales.
823    But beware that N is not a byte count but a character count!  */
824 _GL_EXTERN_C int mbsncasecmp (const char *s1, const char *s2, size_t n)
825      _GL_ATTRIBUTE_PURE
826      _GL_ARG_NONNULL ((1, 2));
827 #endif
828 
829 #if @GNULIB_MBSPCASECMP@
830 /* Compare the initial segment of the character string STRING consisting of
831    at most mbslen (PREFIX) characters with the character string PREFIX,
832    ignoring case.  If the two match, return a pointer to the first byte
833    after this prefix in STRING.  Otherwise, return NULL.
834    Note: This function may, in multibyte locales, return non-NULL if STRING
835    is of smaller length than PREFIX!
836    Unlike strncasecmp(), this function works correctly in multibyte
837    locales.  */
838 _GL_EXTERN_C char * mbspcasecmp (const char *string, const char *prefix)
839      _GL_ATTRIBUTE_PURE
840      _GL_ARG_NONNULL ((1, 2));
841 #endif
842 
843 #if @GNULIB_MBSCASESTR@
844 /* Find the first occurrence of the character string NEEDLE in the character
845    string HAYSTACK, using case-insensitive comparison.
846    Note: This function may, in multibyte locales, return success even if
847    strlen (haystack) < strlen (needle) !
848    Unlike strcasestr(), this function works correctly in multibyte locales.  */
849 _GL_EXTERN_C char * mbscasestr (const char *haystack, const char *needle)
850      _GL_ATTRIBUTE_PURE
851      _GL_ARG_NONNULL ((1, 2));
852 #endif
853 
854 #if @GNULIB_MBSCSPN@
855 /* Find the first occurrence in the character string STRING of any character
856    in the character string ACCEPT.  Return the number of bytes from the
857    beginning of the string to this occurrence, or to the end of the string
858    if none exists.
859    Unlike strcspn(), this function works correctly in multibyte locales.  */
860 _GL_EXTERN_C size_t mbscspn (const char *string, const char *accept)
861      _GL_ATTRIBUTE_PURE
862      _GL_ARG_NONNULL ((1, 2));
863 #endif
864 
865 #if @GNULIB_MBSPBRK@
866 /* Find the first occurrence in the character string STRING of any character
867    in the character string ACCEPT.  Return the pointer to it, or NULL if none
868    exists.
869    Unlike strpbrk(), this function works correctly in multibyte locales.  */
870 # if defined __hpux
871 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
872 #   define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */
873 #  endif
874 _GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept)
875                                    _GL_ATTRIBUTE_PURE
876                                    _GL_ARG_NONNULL ((1, 2)));
877 _GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept));
878 # else
879 _GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept)
880                                    _GL_ATTRIBUTE_PURE
881                                    _GL_ARG_NONNULL ((1, 2)));
882 _GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept));
883 # endif
884 _GL_CXXALIASWARN (mbspbrk);
885 #endif
886 
887 #if @GNULIB_MBSSPN@
888 /* Find the first occurrence in the character string STRING of any character
889    not in the character string REJECT.  Return the number of bytes from the
890    beginning of the string to this occurrence, or to the end of the string
891    if none exists.
892    Unlike strspn(), this function works correctly in multibyte locales.  */
893 _GL_EXTERN_C size_t mbsspn (const char *string, const char *reject)
894      _GL_ATTRIBUTE_PURE
895      _GL_ARG_NONNULL ((1, 2));
896 #endif
897 
898 #if @GNULIB_MBSSEP@
899 /* Search the next delimiter (multibyte character listed in the character
900    string DELIM) starting at the character string *STRINGP.
901    If one is found, overwrite it with a NUL, and advance *STRINGP to point
902    to the next multibyte character after it.  Otherwise, set *STRINGP to NULL.
903    If *STRINGP was already NULL, nothing happens.
904    Return the old value of *STRINGP.
905 
906    This is a variant of mbstok_r() that supports empty fields.
907 
908    Caveat: It modifies the original string.
909    Caveat: These functions cannot be used on constant strings.
910    Caveat: The identity of the delimiting character is lost.
911 
912    See also mbstok_r().  */
913 _GL_EXTERN_C char * mbssep (char **stringp, const char *delim)
914      _GL_ARG_NONNULL ((1, 2));
915 #endif
916 
917 #if @GNULIB_MBSTOK_R@
918 /* Parse the character string STRING into tokens separated by characters in
919    the character string DELIM.
920    If STRING is NULL, the saved pointer in SAVE_PTR is used as
921    the next starting point.  For example:
922         char s[] = "-abc-=-def";
923         char *sp;
924         x = mbstok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
925         x = mbstok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
926         x = mbstok_r(NULL, "=", &sp);   // x = NULL
927                 // s = "abc\0-def\0"
928 
929    Caveat: It modifies the original string.
930    Caveat: These functions cannot be used on constant strings.
931    Caveat: The identity of the delimiting character is lost.
932 
933    See also mbssep().  */
934 _GL_EXTERN_C char * mbstok_r (char *string, const char *delim, char **save_ptr)
935      _GL_ARG_NONNULL ((2, 3));
936 #endif
937 
938 /* Map any int, typically from errno, into an error message.  */
939 #if @GNULIB_STRERROR@
940 # if @REPLACE_STRERROR@
941 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
942 #   undef strerror
943 #   define strerror rpl_strerror
944 #  endif
945 _GL_FUNCDECL_RPL (strerror, char *, (int));
946 _GL_CXXALIAS_RPL (strerror, char *, (int));
947 # else
948 _GL_CXXALIAS_SYS (strerror, char *, (int));
949 # endif
950 _GL_CXXALIASWARN (strerror);
951 #elif defined GNULIB_POSIXCHECK
952 # undef strerror
953 /* Assume strerror is always declared.  */
954 _GL_WARN_ON_USE (strerror, "strerror is unportable - "
955                  "use gnulib module strerror to guarantee non-NULL result");
956 #endif
957 
958 /* Map any int, typically from errno, into an error message.  Multithread-safe.
959    Uses the POSIX declaration, not the glibc declaration.  */
960 #if @GNULIB_STRERROR_R@
961 # if @REPLACE_STRERROR_R@
962 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
963 #   undef strerror_r
964 #   define strerror_r rpl_strerror_r
965 #  endif
966 _GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen)
967                                    _GL_ARG_NONNULL ((2)));
968 _GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen));
969 # else
970 #  if !@HAVE_DECL_STRERROR_R@
971 _GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen)
972                                    _GL_ARG_NONNULL ((2)));
973 #  endif
974 _GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen));
975 # endif
976 # if @HAVE_DECL_STRERROR_R@
977 _GL_CXXALIASWARN (strerror_r);
978 # endif
979 #elif defined GNULIB_POSIXCHECK
980 # undef strerror_r
981 # if HAVE_RAW_DECL_STRERROR_R
982 _GL_WARN_ON_USE (strerror_r, "strerror_r is unportable - "
983                  "use gnulib module strerror_r-posix for portability");
984 # endif
985 #endif
986 
987 #if @GNULIB_STRSIGNAL@
988 # if @REPLACE_STRSIGNAL@
989 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
990 #   define strsignal rpl_strsignal
991 #  endif
992 _GL_FUNCDECL_RPL (strsignal, char *, (int __sig));
993 _GL_CXXALIAS_RPL (strsignal, char *, (int __sig));
994 # else
995 #  if ! @HAVE_DECL_STRSIGNAL@
996 _GL_FUNCDECL_SYS (strsignal, char *, (int __sig));
997 #  endif
998 /* Need to cast, because on Cygwin 1.5.x systems, the return type is
999    'const char *'.  */
1000 _GL_CXXALIAS_SYS_CAST (strsignal, char *, (int __sig));
1001 # endif
1002 _GL_CXXALIASWARN (strsignal);
1003 #elif defined GNULIB_POSIXCHECK
1004 # undef strsignal
1005 # if HAVE_RAW_DECL_STRSIGNAL
1006 _GL_WARN_ON_USE (strsignal, "strsignal is unportable - "
1007                  "use gnulib module strsignal for portability");
1008 # endif
1009 #endif
1010 
1011 #if @GNULIB_STRVERSCMP@
1012 # if !@HAVE_STRVERSCMP@
1013 _GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *)
1014                                    _GL_ATTRIBUTE_PURE
1015                                    _GL_ARG_NONNULL ((1, 2)));
1016 # endif
1017 _GL_CXXALIAS_SYS (strverscmp, int, (const char *, const char *));
1018 _GL_CXXALIASWARN (strverscmp);
1019 #elif defined GNULIB_POSIXCHECK
1020 # undef strverscmp
1021 # if HAVE_RAW_DECL_STRVERSCMP
1022 _GL_WARN_ON_USE (strverscmp, "strverscmp is unportable - "
1023                  "use gnulib module strverscmp for portability");
1024 # endif
1025 #endif
1026 
1027 
1028 #endif /* _@GUARD_PREFIX@_STRING_H */
1029 #endif /* _@GUARD_PREFIX@_STRING_H */
1030