← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gettext/utopic

« back to all changes in this revision

Viewing changes to gettext-runtime/gnulib-lib/string.in.h

  • Committer: Colin Watson
  • Date: 2010-08-01 21:36:08 UTC
  • mfrom: (2.1.10 sid)
  • Revision ID: cjwatson@canonical.com-20100801213608-yy7vkm8lpatep3ci
merge from Debian 0.18.1.1-1

Show diffs side-by-side

added added

removed removed

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