gitweb.dragonflybsd.org Git - dragonfly.git/blob - gnu/usr.bin/diff/libdiffutils/string.h

1 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */

2 /* -*- buffer-read-only: t -*- vi: set ro: */

3 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */

4 /* A GNU-like <string.h>.

5

7

8 This program is free software; you can redistribute it and/or modify

9 it under the terms of the GNU General Public License as published by

10 the Free Software Foundation; either version 3, or (at your option)

11 any later version.

12

13 This program is distributed in the hope that it will be useful,

14 but WITHOUT ANY WARRANTY; without even the implied warranty of

15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

16 GNU General Public License for more details.

17

18 You should have received a copy of the GNU General Public License

19 along with this program; if not, write to the Free Software Foundation,

20 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */

21

22 #ifndef _GL_STRING_H

23

24 #if __GNUC__ >= 3

25 #pragma GCC system_header

26 #endif

27

28

29 /* The include_next requires a split double-inclusion guard. */

30 #include_next <string.h>

31

32 #ifndef _GL_STRING_H

33 #define _GL_STRING_H

34

35 /* NetBSD 5.0 mis-defines NULL. */

36 #include <stddef.h>

37

38 /* MirBSD defines mbslen as a macro. */

39 #if 1 && defined __MirBSD__

40 # include <wchar.h>

41 #endif

42

43 /* The __attribute__ feature is available in gcc versions 2.5 and later.

44 The attribute __pure__ was added in gcc 2.96. */

45 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)

46 # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))

47 #else

48 # define _GL_ATTRIBUTE_PURE /* empty */

49 #endif

50

51 /* NetBSD 5.0 declares strsignal in <unistd.h>, not in <string.h>. */

52 /* But in any case avoid namespace pollution on glibc systems. */

53 #if (0 || defined GNULIB_POSIXCHECK) && defined __NetBSD__ \

54 && ! defined __GLIBC__

55 # include <unistd.h>

56 #endif

57

58 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */

59 #ifndef _GL_CXXDEFS_H

60 #define _GL_CXXDEFS_H

61

62 /* The three most frequent use cases of these macros are:

63

64 * For providing a substitute for a function that is missing on some

65 platforms, but is declared and works fine on the platforms on which

66 it exists:

67

68 #if @GNULIB_FOO@

69 # if !@HAVE_FOO@

70 _GL_FUNCDECL_SYS (foo, ...);

71 # endif

72 _GL_CXXALIAS_SYS (foo, ...);

73 _GL_CXXALIASWARN (foo);

74 #elif defined GNULIB_POSIXCHECK

75 ...

76 #endif

77

78 * For providing a replacement for a function that exists on all platforms,

79 but is broken/insufficient and needs to be replaced on some platforms:

80

81 #if @GNULIB_FOO@

82 # if @REPLACE_FOO@

83 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

84 # undef foo

85 # define foo rpl_foo

86 # endif

87 _GL_FUNCDECL_RPL (foo, ...);

88 _GL_CXXALIAS_RPL (foo, ...);

89 # else

90 _GL_CXXALIAS_SYS (foo, ...);

91 # endif

92 _GL_CXXALIASWARN (foo);

93 #elif defined GNULIB_POSIXCHECK

94 ...

95 #endif

96

97 * For providing a replacement for a function that exists on some platforms

98 but is broken/insufficient and needs to be replaced on some of them and

99 is additionally either missing or undeclared on some other platforms:

100

101 #if @GNULIB_FOO@

102 # if @REPLACE_FOO@

103 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

104 # undef foo

105 # define foo rpl_foo

106 # endif

107 _GL_FUNCDECL_RPL (foo, ...);

108 _GL_CXXALIAS_RPL (foo, ...);

109 # else

110 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@

111 _GL_FUNCDECL_SYS (foo, ...);

112 # endif

113 _GL_CXXALIAS_SYS (foo, ...);

114 # endif

115 _GL_CXXALIASWARN (foo);

116 #elif defined GNULIB_POSIXCHECK

117 ...

118 #endif

119 */

120

121 /* _GL_EXTERN_C declaration;

122 performs the declaration with C linkage. */

123 #if defined __cplusplus

124 # define _GL_EXTERN_C extern "C"

125 #else

126 # define _GL_EXTERN_C extern

127 #endif

128

129 /* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);

130 declares a replacement function, named rpl_func, with the given prototype,

131 consisting of return type, parameters, and attributes.

132 Example:

133 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)

134 _GL_ARG_NONNULL ((1)));

135 */

136 #define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \

137 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)

138 #define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \

139 _GL_EXTERN_C rettype rpl_func parameters_and_attributes

140

141 /* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);

142 declares the system function, named func, with the given prototype,

143 consisting of return type, parameters, and attributes.

144 Example:

145 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)

146 _GL_ARG_NONNULL ((1)));

147 */

148 #define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \

149 _GL_EXTERN_C rettype func parameters_and_attributes

150

151 /* _GL_CXXALIAS_RPL (func, rettype, parameters);

152 declares a C++ alias called GNULIB_NAMESPACE::func

153 that redirects to rpl_func, if GNULIB_NAMESPACE is defined.

154 Example:

155 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));

156 */

157 #define _GL_CXXALIAS_RPL(func,rettype,parameters) \

158 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)

159 #if defined __cplusplus && defined GNULIB_NAMESPACE

160 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \

161 namespace GNULIB_NAMESPACE \

162 { \

163 rettype (*const func) parameters = ::rpl_func; \

164 } \

165 _GL_EXTERN_C int _gl_cxxalias_dummy

166 #else

167 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \

168 _GL_EXTERN_C int _gl_cxxalias_dummy

169 #endif

170

171 /* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);

172 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);

173 except that the C function rpl_func may have a slightly different

174 declaration. A cast is used to silence the "invalid conversion" error

175 that would otherwise occur. */

176 #if defined __cplusplus && defined GNULIB_NAMESPACE

177 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \

178 namespace GNULIB_NAMESPACE \

179 { \

180 rettype (*const func) parameters = \

181 reinterpret_cast<rettype(*)parameters>(::rpl_func); \

182 } \

183 _GL_EXTERN_C int _gl_cxxalias_dummy

184 #else

185 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \

186 _GL_EXTERN_C int _gl_cxxalias_dummy

187 #endif

188

189 /* _GL_CXXALIAS_SYS (func, rettype, parameters);

190 declares a C++ alias called GNULIB_NAMESPACE::func

191 that redirects to the system provided function func, if GNULIB_NAMESPACE

192 is defined.

193 Example:

194 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));

195 */

196 #if defined __cplusplus && defined GNULIB_NAMESPACE

197 /* If we were to write

198 rettype (*const func) parameters = ::func;

199 like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls

200 better (remove an indirection through a 'static' pointer variable),

201 but then the _GL_CXXALIASWARN macro below would cause a warning not only

202 for uses of ::func but also for uses of GNULIB_NAMESPACE::func. */

203 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \

204 namespace GNULIB_NAMESPACE \

205 { \

206 static rettype (*func) parameters = ::func; \

207 } \

208 _GL_EXTERN_C int _gl_cxxalias_dummy

209 #else

210 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \

211 _GL_EXTERN_C int _gl_cxxalias_dummy

212 #endif

213

214 /* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);

215 is like _GL_CXXALIAS_SYS (func, rettype, parameters);

216 except that the C function func may have a slightly different declaration.

217 A cast is used to silence the "invalid conversion" error that would

218 otherwise occur. */

219 #if defined __cplusplus && defined GNULIB_NAMESPACE

220 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \

221 namespace GNULIB_NAMESPACE \

222 { \

223 static rettype (*func) parameters = \

224 reinterpret_cast<rettype(*)parameters>(::func); \

225 } \

226 _GL_EXTERN_C int _gl_cxxalias_dummy

227 #else

228 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \

229 _GL_EXTERN_C int _gl_cxxalias_dummy

230 #endif

231

232 /* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);

233 is like _GL_CXXALIAS_SYS (func, rettype, parameters);

234 except that the C function is picked among a set of overloaded functions,

235 namely the one with rettype2 and parameters2. Two consecutive casts

236 are used to silence the "cannot find a match" and "invalid conversion"

237 errors that would otherwise occur. */

238 #if defined __cplusplus && defined GNULIB_NAMESPACE

239 /* The outer cast must be a reinterpret_cast.

240 The inner cast: When the function is defined as a set of overloaded

241 functions, it works as a static_cast<>, choosing the designated variant.

242 When the function is defined as a single variant, it works as a

243 reinterpret_cast<>. The parenthesized cast syntax works both ways. */

244 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \

245 namespace GNULIB_NAMESPACE \

246 { \

247 static rettype (*func) parameters = \

248 reinterpret_cast<rettype(*)parameters>( \

249 (rettype2(*)parameters2)(::func)); \

250 } \

251 _GL_EXTERN_C int _gl_cxxalias_dummy

252 #else

253 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \

254 _GL_EXTERN_C int _gl_cxxalias_dummy

255 #endif

256

257 /* _GL_CXXALIASWARN (func);

258 causes a warning to be emitted when ::func is used but not when

259 GNULIB_NAMESPACE::func is used. func must be defined without overloaded

260 variants. */

261 #if defined __cplusplus && defined GNULIB_NAMESPACE

262 # define _GL_CXXALIASWARN(func) \

263 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)

264 # define _GL_CXXALIASWARN_1(func,namespace) \

265 _GL_CXXALIASWARN_2 (func, namespace)

266 /* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,

267 we enable the warning only when not optimizing. */

268 # if !__OPTIMIZE__

269 # define _GL_CXXALIASWARN_2(func,namespace) \

270 _GL_WARN_ON_USE (func, \

271 "The symbol ::" #func " refers to the system function. " \

272 "Use " #namespace "::" #func " instead.")

273 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

274 # define _GL_CXXALIASWARN_2(func,namespace) \

275 extern __typeof__ (func) func

276 # else

277 # define _GL_CXXALIASWARN_2(func,namespace) \

278 _GL_EXTERN_C int _gl_cxxalias_dummy

279 # endif

280 #else

281 # define _GL_CXXALIASWARN(func) \

282 _GL_EXTERN_C int _gl_cxxalias_dummy

283 #endif

284

285 /* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);

286 causes a warning to be emitted when the given overloaded variant of ::func

287 is used but not when GNULIB_NAMESPACE::func is used. */

288 #if defined __cplusplus && defined GNULIB_NAMESPACE

289 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \

290 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \

291 GNULIB_NAMESPACE)

292 # define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \

293 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)

294 /* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,

295 we enable the warning only when not optimizing. */

296 # if !__OPTIMIZE__

297 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

298 _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \

299 "The symbol ::" #func " refers to the system function. " \

300 "Use " #namespace "::" #func " instead.")

301 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

302 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

303 extern __typeof__ (func) func

304 # else

305 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

306 _GL_EXTERN_C int _gl_cxxalias_dummy

307 # endif

308 #else

309 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \

310 _GL_EXTERN_C int _gl_cxxalias_dummy

311 #endif

312

313 #endif /* _GL_CXXDEFS_H */

314

315 /* The definition of _GL_ARG_NONNULL is copied here. */

316 /* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools

317 that the values passed as arguments n, ..., m must be non-NULL pointers.

318 n = 1 stands for the first argument, n = 2 for the second argument etc. */

319 #ifndef _GL_ARG_NONNULL

320 # if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3

321 # define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))

322 # else

323 # define _GL_ARG_NONNULL(params)

324 # endif

325 #endif

326

327 /* The definition of _GL_WARN_ON_USE is copied here. */

328 #ifndef _GL_WARN_ON_USE

329

330 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)

331 /* A compiler attribute is available in gcc versions 4.3.0 and later. */

332 # define _GL_WARN_ON_USE(function, message) \

333 extern __typeof__ (function) function __attribute__ ((__warning__ (message)))

334 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

335 /* Verify the existence of the function. */

336 # define _GL_WARN_ON_USE(function, message) \

337 extern __typeof__ (function) function

338 # else /* Unsupported. */

339 # define _GL_WARN_ON_USE(function, message) \

340 _GL_WARN_EXTERN_C int _gl_warn_on_use

341 # endif

342 #endif

343

344 /* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")

345 is like _GL_WARN_ON_USE (function, "string"), except that the function is

346 declared with the given prototype, consisting of return type, parameters,

347 and attributes.

348 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does

349 not work in this case. */

350 #ifndef _GL_WARN_ON_USE_CXX

351 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)

352 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

353 extern rettype function parameters_and_attributes \

354 __attribute__ ((__warning__ (msg)))

355 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

356 /* Verify the existence of the function. */

357 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

358 extern rettype function parameters_and_attributes

359 # else /* Unsupported. */

360 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

361 _GL_WARN_EXTERN_C int _gl_warn_on_use

362 # endif

363 #endif

364

365 /* _GL_WARN_EXTERN_C declaration;

366 performs the declaration with C linkage. */

367 #ifndef _GL_WARN_EXTERN_C

368 # if defined __cplusplus

369 # define _GL_WARN_EXTERN_C extern "C"

370 # else

371 # define _GL_WARN_EXTERN_C extern

372 # endif

373 #endif

374

375

376 /* Find the index of the least-significant set bit. */

377 #if 0

378 # if !1

379 _GL_FUNCDECL_SYS (ffsl, int, (long int i));

380 # endif

381 _GL_CXXALIAS_SYS (ffsl, int, (long int i));

382 _GL_CXXALIASWARN (ffsl);

383 #elif defined GNULIB_POSIXCHECK

384 # undef ffsl

385 # if HAVE_RAW_DECL_FFSL

386 _GL_WARN_ON_USE (ffsl, "ffsl is not portable - use the ffsl module");

387 # endif

388 #endif

389

390

391 /* Find the index of the least-significant set bit. */

392 #if 0

393 # if !1

394 _GL_FUNCDECL_SYS (ffsll, int, (long long int i));

395 # endif

396 _GL_CXXALIAS_SYS (ffsll, int, (long long int i));

397 _GL_CXXALIASWARN (ffsll);

398 #elif defined GNULIB_POSIXCHECK

399 # undef ffsll

400 # if HAVE_RAW_DECL_FFSLL

401 _GL_WARN_ON_USE (ffsll, "ffsll is not portable - use the ffsll module");

402 # endif

403 #endif

404

405

406 /* Return the first instance of C within N bytes of S, or NULL. */

407 #if 1

408 # if 0

409 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

410 # define memchr rpl_memchr

411 # endif

412 _GL_FUNCDECL_RPL (memchr, void *, (void const *__s, int __c, size_t __n)

413 _GL_ATTRIBUTE_PURE

414 _GL_ARG_NONNULL ((1)));

415 _GL_CXXALIAS_RPL (memchr, void *, (void const *__s, int __c, size_t __n));

416 # else

417 # if ! 1

418 _GL_FUNCDECL_SYS (memchr, void *, (void const *__s, int __c, size_t __n)

419 _GL_ATTRIBUTE_PURE

420 _GL_ARG_NONNULL ((1)));

421 # endif

422 /* On some systems, this function is defined as an overloaded function:

423 extern "C" { const void * std::memchr (const void *, int, size_t); }

424 extern "C++" { void * std::memchr (void *, int, size_t); } */

425 _GL_CXXALIAS_SYS_CAST2 (memchr,

426 void *, (void const *__s, int __c, size_t __n),

427 void const *, (void const *__s, int __c, size_t __n));

428 # endif

429 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \

430 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))

431 _GL_CXXALIASWARN1 (memchr, void *, (void *__s, int __c, size_t __n));

432 _GL_CXXALIASWARN1 (memchr, void const *,

433 (void const *__s, int __c, size_t __n));

434 # else

435 _GL_CXXALIASWARN (memchr);

436 # endif

437 #elif defined GNULIB_POSIXCHECK

438 # undef memchr

439 /* Assume memchr is always declared. */

440 _GL_WARN_ON_USE (memchr, "memchr has platform-specific bugs - "

441 "use gnulib module memchr for portability" );

442 #endif

443

444 /* Return the first occurrence of NEEDLE in HAYSTACK. */

445 #if 0

446 # if 0

447 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

448 # define memmem rpl_memmem

449 # endif

450 _GL_FUNCDECL_RPL (memmem, void *,

451 (void const *__haystack, size_t __haystack_len,

452 void const *__needle, size_t __needle_len)

453 _GL_ATTRIBUTE_PURE

454 _GL_ARG_NONNULL ((1, 3)));

455 _GL_CXXALIAS_RPL (memmem, void *,

456 (void const *__haystack, size_t __haystack_len,

457 void const *__needle, size_t __needle_len));

458 # else

459 # if ! 1

460 _GL_FUNCDECL_SYS (memmem, void *,

461 (void const *__haystack, size_t __haystack_len,

462 void const *__needle, size_t __needle_len)

463 _GL_ATTRIBUTE_PURE

464 _GL_ARG_NONNULL ((1, 3)));

465 # endif

466 _GL_CXXALIAS_SYS (memmem, void *,

467 (void const *__haystack, size_t __haystack_len,

468 void const *__needle, size_t __needle_len));

469 # endif

470 _GL_CXXALIASWARN (memmem);

471 #elif defined GNULIB_POSIXCHECK

472 # undef memmem

473 # if HAVE_RAW_DECL_MEMMEM

474 _GL_WARN_ON_USE (memmem, "memmem is unportable and often quadratic - "

475 "use gnulib module memmem-simple for portability, "

476 "and module memmem for speed" );

477 # endif

478 #endif

479

480 /* Copy N bytes of SRC to DEST, return pointer to bytes after the

481 last written byte. */

482 #if 0

483 # if ! 1

484 _GL_FUNCDECL_SYS (mempcpy, void *,

485 (void *restrict __dest, void const *restrict __src,

486 size_t __n)

487 _GL_ARG_NONNULL ((1, 2)));

488 # endif

489 _GL_CXXALIAS_SYS (mempcpy, void *,

490 (void *restrict __dest, void const *restrict __src,

491 size_t __n));

492 _GL_CXXALIASWARN (mempcpy);

493 #elif defined GNULIB_POSIXCHECK

494 # undef mempcpy

495 # if HAVE_RAW_DECL_MEMPCPY

496 _GL_WARN_ON_USE (mempcpy, "mempcpy is unportable - "

497 "use gnulib module mempcpy for portability");

498 # endif

499 #endif

500

501 /* Search backwards through a block for a byte (specified as an int). */

502 #if 0

503 # if ! 1

504 _GL_FUNCDECL_SYS (memrchr, void *, (void const *, int, size_t)

505 _GL_ATTRIBUTE_PURE

506 _GL_ARG_NONNULL ((1)));

507 # endif

508 /* On some systems, this function is defined as an overloaded function:

509 extern "C++" { const void * std::memrchr (const void *, int, size_t); }

510 extern "C++" { void * std::memrchr (void *, int, size_t); } */

511 _GL_CXXALIAS_SYS_CAST2 (memrchr,

512 void *, (void const *, int, size_t),

513 void const *, (void const *, int, size_t));

514 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \

515 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))

516 _GL_CXXALIASWARN1 (memrchr, void *, (void *, int, size_t));

517 _GL_CXXALIASWARN1 (memrchr, void const *, (void const *, int, size_t));

518 # else

519 _GL_CXXALIASWARN (memrchr);

520 # endif

521 #elif defined GNULIB_POSIXCHECK

522 # undef memrchr

523 # if HAVE_RAW_DECL_MEMRCHR

524 _GL_WARN_ON_USE (memrchr, "memrchr is unportable - "

525 "use gnulib module memrchr for portability");

526 # endif

527 #endif

528

529 /* Find the first occurrence of C in S. More efficient than

530 memchr(S,C,N), at the expense of undefined behavior if C does not

531 occur within N bytes. */

532 #if 0

533 # if ! 1

534 _GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in)

535 _GL_ATTRIBUTE_PURE

536 _GL_ARG_NONNULL ((1)));

537 # endif

538 /* On some systems, this function is defined as an overloaded function:

539 extern "C++" { const void * std::rawmemchr (const void *, int); }

540 extern "C++" { void * std::rawmemchr (void *, int); } */

541 _GL_CXXALIAS_SYS_CAST2 (rawmemchr,

542 void *, (void const *__s, int __c_in),

543 void const *, (void const *__s, int __c_in));

544 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \

545 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))

546 _GL_CXXALIASWARN1 (rawmemchr, void *, (void *__s, int __c_in));

547 _GL_CXXALIASWARN1 (rawmemchr, void const *, (void const *__s, int __c_in));

548 # else

549 _GL_CXXALIASWARN (rawmemchr);

550 # endif

551 #elif defined GNULIB_POSIXCHECK

552 # undef rawmemchr

553 # if HAVE_RAW_DECL_RAWMEMCHR

554 _GL_WARN_ON_USE (rawmemchr, "rawmemchr is unportable - "

555 "use gnulib module rawmemchr for portability");

556 # endif

557 #endif

558

559 /* Copy SRC to DST, returning the address of the terminating '\0' in DST. */

560 #if 0

561 # if ! 1

562 _GL_FUNCDECL_SYS (stpcpy, char *,

563 (char *restrict __dst, char const *restrict __src)

564 _GL_ARG_NONNULL ((1, 2)));

565 # endif

566 _GL_CXXALIAS_SYS (stpcpy, char *,

567 (char *restrict __dst, char const *restrict __src));

568 _GL_CXXALIASWARN (stpcpy);

569 #elif defined GNULIB_POSIXCHECK

570 # undef stpcpy

571 # if HAVE_RAW_DECL_STPCPY

572 _GL_WARN_ON_USE (stpcpy, "stpcpy is unportable - "

573 "use gnulib module stpcpy for portability");

574 # endif

575 #endif

576

577 /* Copy no more than N bytes of SRC to DST, returning a pointer past the

578 last non-NUL byte written into DST. */

579 #if 0

580 # if 0

581 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

582 # undef stpncpy

583 # define stpncpy rpl_stpncpy

584 # endif

585 _GL_FUNCDECL_RPL (stpncpy, char *,

586 (char *restrict __dst, char const *restrict __src,

587 size_t __n)

588 _GL_ARG_NONNULL ((1, 2)));

589 _GL_CXXALIAS_RPL (stpncpy, char *,

590 (char *restrict __dst, char const *restrict __src,

591 size_t __n));

592 # else

593 # if ! 1

594 _GL_FUNCDECL_SYS (stpncpy, char *,

595 (char *restrict __dst, char const *restrict __src,

596 size_t __n)

597 _GL_ARG_NONNULL ((1, 2)));

598 # endif

599 _GL_CXXALIAS_SYS (stpncpy, char *,

600 (char *restrict __dst, char const *restrict __src,

601 size_t __n));

602 # endif

603 _GL_CXXALIASWARN (stpncpy);

604 #elif defined GNULIB_POSIXCHECK

605 # undef stpncpy

606 # if HAVE_RAW_DECL_STPNCPY

607 _GL_WARN_ON_USE (stpncpy, "stpncpy is unportable - "

608 "use gnulib module stpncpy for portability");

609 # endif

610 #endif

611

612 #if defined GNULIB_POSIXCHECK

613 /* strchr() does not work with multibyte strings if the locale encoding is

614 GB18030 and the character to be searched is a digit. */

615 # undef strchr

616 /* Assume strchr is always declared. */

617 _GL_WARN_ON_USE (strchr, "strchr cannot work correctly on character strings "

618 "in some multibyte locales - "

619 "use mbschr if you care about internationalization");

620 #endif

621

622 /* Find the first occurrence of C in S or the final NUL byte. */

623 #if 0

624 # if 0

625 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

626 # define strchrnul rpl_strchrnul

627 # endif

628 _GL_FUNCDECL_RPL (strchrnul, char *, (const char *__s, int __c_in)

629 _GL_ATTRIBUTE_PURE

630 _GL_ARG_NONNULL ((1)));

631 _GL_CXXALIAS_RPL (strchrnul, char *,

632 (const char *str, int ch));

633 # else

634 # if ! 1

635 _GL_FUNCDECL_SYS (strchrnul, char *, (char const *__s, int __c_in)

636 _GL_ATTRIBUTE_PURE

637 _GL_ARG_NONNULL ((1)));

638 # endif

639 /* On some systems, this function is defined as an overloaded function:

640 extern "C++" { const char * std::strchrnul (const char *, int); }

641 extern "C++" { char * std::strchrnul (char *, int); } */

642 _GL_CXXALIAS_SYS_CAST2 (strchrnul,

643 char *, (char const *__s, int __c_in),

644 char const *, (char const *__s, int __c_in));

645 # endif

646 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \

647 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))

648 _GL_CXXALIASWARN1 (strchrnul, char *, (char *__s, int __c_in));

649 _GL_CXXALIASWARN1 (strchrnul, char const *, (char const *__s, int __c_in));

650 # else

651 _GL_CXXALIASWARN (strchrnul);

652 # endif

653 #elif defined GNULIB_POSIXCHECK

654 # undef strchrnul

655 # if HAVE_RAW_DECL_STRCHRNUL

656 _GL_WARN_ON_USE (strchrnul, "strchrnul is unportable - "

657 "use gnulib module strchrnul for portability");

658 # endif

659 #endif

660

661 /* Duplicate S, returning an identical malloc'd string. */

662 #if 0

663 # if 0

664 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

665 # undef strdup

666 # define strdup rpl_strdup

667 # endif

668 _GL_FUNCDECL_RPL (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));

669 _GL_CXXALIAS_RPL (strdup, char *, (char const *__s));

670 # else

671 # if defined __cplusplus && defined GNULIB_NAMESPACE && defined strdup

672 /* strdup exists as a function and as a macro. Get rid of the macro. */

673 # undef strdup

674 # endif

675 # if !(1 || defined strdup)

676 _GL_FUNCDECL_SYS (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));

677 # endif

678 _GL_CXXALIAS_SYS (strdup, char *, (char const *__s));

679 # endif

680 _GL_CXXALIASWARN (strdup);

681 #elif defined GNULIB_POSIXCHECK

682 # undef strdup

683 # if HAVE_RAW_DECL_STRDUP

684 _GL_WARN_ON_USE (strdup, "strdup is unportable - "

685 "use gnulib module strdup for portability");

686 # endif

687 #endif

688

689 /* Append no more than N characters from SRC onto DEST. */

690 #if 0

691 # if 0

692 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

693 # undef strncat

694 # define strncat rpl_strncat

695 # endif

696 _GL_FUNCDECL_RPL (strncat, char *, (char *dest, const char *src, size_t n)

697 _GL_ARG_NONNULL ((1, 2)));

698 _GL_CXXALIAS_RPL (strncat, char *, (char *dest, const char *src, size_t n));

699 # else

700 _GL_CXXALIAS_SYS (strncat, char *, (char *dest, const char *src, size_t n));

701 # endif

702 _GL_CXXALIASWARN (strncat);

703 #elif defined GNULIB_POSIXCHECK

704 # undef strncat

705 # if HAVE_RAW_DECL_STRNCAT

706 _GL_WARN_ON_USE (strncat, "strncat is unportable - "

707 "use gnulib module strncat for portability");

708 # endif

709 #endif

710

711 /* Return a newly allocated copy of at most N bytes of STRING. */

712 #if 1

713 # if 0

714 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

715 # undef strndup

716 # define strndup rpl_strndup

717 # endif

718 _GL_FUNCDECL_RPL (strndup, char *, (char const *__string, size_t __n)

719 _GL_ARG_NONNULL ((1)));

720 _GL_CXXALIAS_RPL (strndup, char *, (char const *__string, size_t __n));

721 # else

722 # if ! 1

723 _GL_FUNCDECL_SYS (strndup, char *, (char const *__string, size_t __n)

724 _GL_ARG_NONNULL ((1)));

725 # endif

726 _GL_CXXALIAS_SYS (strndup, char *, (char const *__string, size_t __n));

727 # endif

728 _GL_CXXALIASWARN (strndup);

729 #elif defined GNULIB_POSIXCHECK

730 # undef strndup

731 # if HAVE_RAW_DECL_STRNDUP

732 _GL_WARN_ON_USE (strndup, "strndup is unportable - "

733 "use gnulib module strndup for portability");

734 # endif

735 #endif

736

737 /* Find the length (number of bytes) of STRING, but scan at most

738 MAXLEN bytes. If no '\0' terminator is found in that many bytes,

739 return MAXLEN. */

740 #if 1

741 # if 0

742 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

743 # undef strnlen

744 # define strnlen rpl_strnlen

745 # endif

746 _GL_FUNCDECL_RPL (strnlen, size_t, (char const *__string, size_t __maxlen)

747 _GL_ATTRIBUTE_PURE

748 _GL_ARG_NONNULL ((1)));

749 _GL_CXXALIAS_RPL (strnlen, size_t, (char const *__string, size_t __maxlen));

750 # else

751 # if ! 1

752 _GL_FUNCDECL_SYS (strnlen, size_t, (char const *__string, size_t __maxlen)

753 _GL_ATTRIBUTE_PURE

754 _GL_ARG_NONNULL ((1)));

755 # endif

756 _GL_CXXALIAS_SYS (strnlen, size_t, (char const *__string, size_t __maxlen));

757 # endif

758 _GL_CXXALIASWARN (strnlen);

759 #elif defined GNULIB_POSIXCHECK

760 # undef strnlen

761 # if HAVE_RAW_DECL_STRNLEN

762 _GL_WARN_ON_USE (strnlen, "strnlen is unportable - "

763 "use gnulib module strnlen for portability");

764 # endif

765 #endif

766

767 #if defined GNULIB_POSIXCHECK

768 /* strcspn() assumes the second argument is a list of single-byte characters.

769 Even in this simple case, it does not work with multibyte strings if the

770 locale encoding is GB18030 and one of the characters to be searched is a

771 digit. */

772 # undef strcspn

773 /* Assume strcspn is always declared. */

774 _GL_WARN_ON_USE (strcspn, "strcspn cannot work correctly on character strings "

775 "in multibyte locales - "

776 "use mbscspn if you care about internationalization");

777 #endif

778

779 /* Find the first occurrence in S of any character in ACCEPT. */

780 #if 0

781 # if ! 1

782 _GL_FUNCDECL_SYS (strpbrk, char *, (char const *__s, char const *__accept)

783 _GL_ATTRIBUTE_PURE

784 _GL_ARG_NONNULL ((1, 2)));

785 # endif

786 /* On some systems, this function is defined as an overloaded function:

787 extern "C" { const char * strpbrk (const char *, const char *); }

788 extern "C++" { char * strpbrk (char *, const char *); } */

789 _GL_CXXALIAS_SYS_CAST2 (strpbrk,

790 char *, (char const *__s, char const *__accept),

791 const char *, (char const *__s, char const *__accept));

792 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \

793 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))

794 _GL_CXXALIASWARN1 (strpbrk, char *, (char *__s, char const *__accept));

795 _GL_CXXALIASWARN1 (strpbrk, char const *,

796 (char const *__s, char const *__accept));

797 # else

798 _GL_CXXALIASWARN (strpbrk);

799 # endif

800 # if defined GNULIB_POSIXCHECK

801 /* strpbrk() assumes the second argument is a list of single-byte characters.

802 Even in this simple case, it does not work with multibyte strings if the

803 locale encoding is GB18030 and one of the characters to be searched is a

804 digit. */

805 # undef strpbrk

806 _GL_WARN_ON_USE (strpbrk, "strpbrk cannot work correctly on character strings "

807 "in multibyte locales - "

808 "use mbspbrk if you care about internationalization");

809 # endif

810 #elif defined GNULIB_POSIXCHECK

811 # undef strpbrk

812 # if HAVE_RAW_DECL_STRPBRK

813 _GL_WARN_ON_USE (strpbrk, "strpbrk is unportable - "

814 "use gnulib module strpbrk for portability");

815 # endif

816 #endif

817

818 #if defined GNULIB_POSIXCHECK

819 /* strspn() assumes the second argument is a list of single-byte characters.

820 Even in this simple case, it cannot work with multibyte strings. */

821 # undef strspn

822 /* Assume strspn is always declared. */

823 _GL_WARN_ON_USE (strspn, "strspn cannot work correctly on character strings "

824 "in multibyte locales - "

825 "use mbsspn if you care about internationalization");

826 #endif

827

828 #if defined GNULIB_POSIXCHECK

829 /* strrchr() does not work with multibyte strings if the locale encoding is

830 GB18030 and the character to be searched is a digit. */

831 # undef strrchr

832 /* Assume strrchr is always declared. */

833 _GL_WARN_ON_USE (strrchr, "strrchr cannot work correctly on character strings "

834 "in some multibyte locales - "

835 "use mbsrchr if you care about internationalization");

836 #endif

837

838 /* Search the next delimiter (char listed in DELIM) starting at *STRINGP.

839 If one is found, overwrite it with a NUL, and advance *STRINGP

840 to point to the next char after it. Otherwise, set *STRINGP to NULL.

841 If *STRINGP was already NULL, nothing happens.

842 Return the old value of *STRINGP.

843

844 This is a variant of strtok() that is multithread-safe and supports

845 empty fields.

846

847 Caveat: It modifies the original string.

848 Caveat: These functions cannot be used on constant strings.

849 Caveat: The identity of the delimiting character is lost.

850 Caveat: It doesn't work with multibyte strings unless all of the delimiter

851 characters are ASCII characters < 0x30.

852

853 See also strtok_r(). */

854 #if 0

855 # if ! 1

856 _GL_FUNCDECL_SYS (strsep, char *,

857 (char **restrict __stringp, char const *restrict __delim)

858 _GL_ARG_NONNULL ((1, 2)));

859 # endif

860 _GL_CXXALIAS_SYS (strsep, char *,

861 (char **restrict __stringp, char const *restrict __delim));

862 _GL_CXXALIASWARN (strsep);

863 # if defined GNULIB_POSIXCHECK

864 # undef strsep

865 _GL_WARN_ON_USE (strsep, "strsep cannot work correctly on character strings "

866 "in multibyte locales - "

867 "use mbssep if you care about internationalization");

868 # endif

869 #elif defined GNULIB_POSIXCHECK

870 # undef strsep

871 # if HAVE_RAW_DECL_STRSEP

872 _GL_WARN_ON_USE (strsep, "strsep is unportable - "

873 "use gnulib module strsep for portability");

874 # endif

875 #endif

876

877 #if 0

878 # if 0

879 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

880 # define strstr rpl_strstr

881 # endif

882 _GL_FUNCDECL_RPL (strstr, char *, (const char *haystack, const char *needle)

883 _GL_ATTRIBUTE_PURE

884 _GL_ARG_NONNULL ((1, 2)));

885 _GL_CXXALIAS_RPL (strstr, char *, (const char *haystack, const char *needle));

886 # else

887 /* On some systems, this function is defined as an overloaded function:

888 extern "C++" { const char * strstr (const char *, const char *); }

889 extern "C++" { char * strstr (char *, const char *); } */

890 _GL_CXXALIAS_SYS_CAST2 (strstr,

891 char *, (const char *haystack, const char *needle),

892 const char *, (const char *haystack, const char *needle));

893 # endif

894 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \

895 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))

896 _GL_CXXALIASWARN1 (strstr, char *, (char *haystack, const char *needle));

897 _GL_CXXALIASWARN1 (strstr, const char *,

898 (const char *haystack, const char *needle));

899 # else

900 _GL_CXXALIASWARN (strstr);

901 # endif

902 #elif defined GNULIB_POSIXCHECK

903 /* strstr() does not work with multibyte strings if the locale encoding is

904 different from UTF-8:

905 POSIX says that it operates on "strings", and "string" in POSIX is defined

906 as a sequence of bytes, not of characters. */

907 # undef strstr

908 /* Assume strstr is always declared. */

909 _GL_WARN_ON_USE (strstr, "strstr is quadratic on many systems, and cannot "

910 "work correctly on character strings in most "

911 "multibyte locales - "

912 "use mbsstr if you care about internationalization, "

913 "or use strstr if you care about speed");

914 #endif

915

916 /* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive

917 comparison. */

918 #if 0

919 # if 0

920 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

921 # define strcasestr rpl_strcasestr

922 # endif

923 _GL_FUNCDECL_RPL (strcasestr, char *,

924 (const char *haystack, const char *needle)

925 _GL_ATTRIBUTE_PURE

926 _GL_ARG_NONNULL ((1, 2)));

927 _GL_CXXALIAS_RPL (strcasestr, char *,

928 (const char *haystack, const char *needle));

929 # else

930 # if ! 1

931 _GL_FUNCDECL_SYS (strcasestr, char *,

932 (const char *haystack, const char *needle)

933 _GL_ATTRIBUTE_PURE

934 _GL_ARG_NONNULL ((1, 2)));

935 # endif

936 /* On some systems, this function is defined as an overloaded function:

937 extern "C++" { const char * strcasestr (const char *, const char *); }

938 extern "C++" { char * strcasestr (char *, const char *); } */

939 _GL_CXXALIAS_SYS_CAST2 (strcasestr,

940 char *, (const char *haystack, const char *needle),

941 const char *, (const char *haystack, const char *needle));

942 # endif

943 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \

944 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))

945 _GL_CXXALIASWARN1 (strcasestr, char *, (char *haystack, const char *needle));

946 _GL_CXXALIASWARN1 (strcasestr, const char *,

947 (const char *haystack, const char *needle));

948 # else

949 _GL_CXXALIASWARN (strcasestr);

950 # endif

951 #elif defined GNULIB_POSIXCHECK

952 /* strcasestr() does not work with multibyte strings:

953 It is a glibc extension, and glibc implements it only for unibyte

954 locales. */

955 # undef strcasestr

956 # if HAVE_RAW_DECL_STRCASESTR

957 _GL_WARN_ON_USE (strcasestr, "strcasestr does work correctly on character "

958 "strings in multibyte locales - "

959 "use mbscasestr if you care about "

960 "internationalization, or use c-strcasestr if you want "

961 "a locale independent function");

962 # endif

963 #endif

964

965 /* Parse S into tokens separated by characters in DELIM.

966 If S is NULL, the saved pointer in SAVE_PTR is used as

967 the next starting point. For example:

968 char s[] = "-abc-=-def";

969 char *sp;

970 x = strtok_r(s, "-", &sp); // x = "abc", sp = "=-def"

971 x = strtok_r(NULL, "-=", &sp); // x = "def", sp = NULL

972 x = strtok_r(NULL, "=", &sp); // x = NULL

973 // s = "abc\0-def\0"

974

975 This is a variant of strtok() that is multithread-safe.

976

977 For the POSIX documentation for this function, see:

978 http://www.opengroup.org/susv3xsh/strtok.html

979

980 Caveat: It modifies the original string.

981 Caveat: These functions cannot be used on constant strings.

982 Caveat: The identity of the delimiting character is lost.

983 Caveat: It doesn't work with multibyte strings unless all of the delimiter

984 characters are ASCII characters < 0x30.

985

986 See also strsep(). */

987 #if 0

988 # if 0

989 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

990 # undef strtok_r

991 # define strtok_r rpl_strtok_r

992 # endif

993 _GL_FUNCDECL_RPL (strtok_r, char *,

994 (char *restrict s, char const *restrict delim,

995 char **restrict save_ptr)

996 _GL_ARG_NONNULL ((2, 3)));

997 _GL_CXXALIAS_RPL (strtok_r, char *,

998 (char *restrict s, char const *restrict delim,

999 char **restrict save_ptr));

1000 # else

1001 # if 0 || defined GNULIB_POSIXCHECK

1002 # undef strtok_r

1003 # endif

1004 # if ! 1

1005 _GL_FUNCDECL_SYS (strtok_r, char *,

1006 (char *restrict s, char const *restrict delim,

1007 char **restrict save_ptr)

1008 _GL_ARG_NONNULL ((2, 3)));

1009 # endif

1010 _GL_CXXALIAS_SYS (strtok_r, char *,

1011 (char *restrict s, char const *restrict delim,

1012 char **restrict save_ptr));

1013 # endif

1014 _GL_CXXALIASWARN (strtok_r);

1015 # if defined GNULIB_POSIXCHECK

1016 _GL_WARN_ON_USE (strtok_r, "strtok_r cannot work correctly on character "

1017 "strings in multibyte locales - "

1018 "use mbstok_r if you care about internationalization");

1019 # endif

1020 #elif defined GNULIB_POSIXCHECK

1021 # undef strtok_r

1022 # if HAVE_RAW_DECL_STRTOK_R

1023 _GL_WARN_ON_USE (strtok_r, "strtok_r is unportable - "

1024 "use gnulib module strtok_r for portability");

1025 # endif

1026 #endif

1027

1028

1029 /* The following functions are not specified by POSIX. They are gnulib

1030 extensions. */

1031

1032 #if 1

1033 /* Return the number of multibyte characters in the character string STRING.

1034 This considers multibyte characters, unlike strlen, which counts bytes. */

1035 # ifdef __MirBSD__ /* MirBSD defines mbslen as a macro. Override it. */

1036 # undef mbslen

1037 # endif

1038 # if 0 /* AIX, OSF/1, MirBSD define mbslen already in libc. */

1039 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

1040 # define mbslen rpl_mbslen

1041 # endif

1042 _GL_FUNCDECL_RPL (mbslen, size_t, (const char *string) _GL_ARG_NONNULL ((1)));

1043 _GL_CXXALIAS_RPL (mbslen, size_t, (const char *string));

1044 # else

1045 _GL_FUNCDECL_SYS (mbslen, size_t, (const char *string) _GL_ARG_NONNULL ((1)));

1046 _GL_CXXALIAS_SYS (mbslen, size_t, (const char *string));

1047 # endif

1048 _GL_CXXALIASWARN (mbslen);

1049 #endif

1050

1051 #if 0

1052 /* Return the number of multibyte characters in the character string starting

1053 at STRING and ending at STRING + LEN. */

1054 _GL_EXTERN_C size_t mbsnlen (const char *string, size_t len)

1055 _GL_ARG_NONNULL ((1));

1056 #endif

1057

1058 #if 0

1059 /* Locate the first single-byte character C in the character string STRING,

1060 and return a pointer to it. Return NULL if C is not found in STRING.

1061 Unlike strchr(), this function works correctly in multibyte locales with

1062 encodings such as GB18030. */

1063 # if defined __hpux

1064 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

1065 # define mbschr rpl_mbschr /* avoid collision with HP-UX function */

1066 # endif

1067 _GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c)

1068 _GL_ARG_NONNULL ((1)));

1069 _GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c));

1070 # else

1071 _GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c)

1072 _GL_ARG_NONNULL ((1)));

1073 _GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c));

1074 # endif

1075 _GL_CXXALIASWARN (mbschr);

1076 #endif

1077

1078 #if 0

1079 /* Locate the last single-byte character C in the character string STRING,

1080 and return a pointer to it. Return NULL if C is not found in STRING.

1081 Unlike strrchr(), this function works correctly in multibyte locales with

1082 encodings such as GB18030. */

1083 # if defined __hpux || defined __INTERIX

1084 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

1085 # define mbsrchr rpl_mbsrchr /* avoid collision with system function */

1086 # endif

1087 _GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c)

1088 _GL_ARG_NONNULL ((1)));

1089 _GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c));

1090 # else

1091 _GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c)

1092 _GL_ARG_NONNULL ((1)));

1093 _GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c));

1094 # endif

1095 _GL_CXXALIASWARN (mbsrchr);

1096 #endif

1097

1098 #if 1

1099 /* Find the first occurrence of the character string NEEDLE in the character

1100 string HAYSTACK. Return NULL if NEEDLE is not found in HAYSTACK.

1101 Unlike strstr(), this function works correctly in multibyte locales with

1102 encodings different from UTF-8. */

1103 _GL_EXTERN_C char * mbsstr (const char *haystack, const char *needle)

1104 _GL_ARG_NONNULL ((1, 2));

1105 #endif

1106

1107 #if 1

1108 /* Compare the character strings S1 and S2, ignoring case, returning less than,

1109 equal to or greater than zero if S1 is lexicographically less than, equal to

1110 or greater than S2.

1111 Note: This function may, in multibyte locales, return 0 for strings of

1112 different lengths!

1113 Unlike strcasecmp(), this function works correctly in multibyte locales. */

1114 _GL_EXTERN_C int mbscasecmp (const char *s1, const char *s2)

1115 _GL_ARG_NONNULL ((1, 2));

1116 #endif

1117

1118 #if 0

1119 /* Compare the initial segment of the character string S1 consisting of at most

1120 N characters with the initial segment of the character string S2 consisting

1121 of at most N characters, ignoring case, returning less than, equal to or

1122 greater than zero if the initial segment of S1 is lexicographically less

1123 than, equal to or greater than the initial segment of S2.

1124 Note: This function may, in multibyte locales, return 0 for initial segments

1125 of different lengths!

1126 Unlike strncasecmp(), this function works correctly in multibyte locales.

1127 But beware that N is not a byte count but a character count! */

1128 _GL_EXTERN_C int mbsncasecmp (const char *s1, const char *s2, size_t n)

1129 _GL_ARG_NONNULL ((1, 2));

1130 #endif

1131

1132 #if 0

1133 /* Compare the initial segment of the character string STRING consisting of

1134 at most mbslen (PREFIX) characters with the character string PREFIX,

1135 ignoring case. If the two match, return a pointer to the first byte

1136 after this prefix in STRING. Otherwise, return NULL.

1137 Note: This function may, in multibyte locales, return non-NULL if STRING

1138 is of smaller length than PREFIX!

1139 Unlike strncasecmp(), this function works correctly in multibyte

1140 locales. */

1141 _GL_EXTERN_C char * mbspcasecmp (const char *string, const char *prefix)

1142 _GL_ARG_NONNULL ((1, 2));

1143 #endif

1144

1145 #if 0

1146 /* Find the first occurrence of the character string NEEDLE in the character

1147 string HAYSTACK, using case-insensitive comparison.

1148 Note: This function may, in multibyte locales, return success even if

1149 strlen (haystack) < strlen (needle) !

1150 Unlike strcasestr(), this function works correctly in multibyte locales. */

1151 _GL_EXTERN_C char * mbscasestr (const char *haystack, const char *needle)

1152 _GL_ARG_NONNULL ((1, 2));

1153 #endif

1154

1155 #if 0

1156 /* Find the first occurrence in the character string STRING of any character

1157 in the character string ACCEPT. Return the number of bytes from the

1158 beginning of the string to this occurrence, or to the end of the string

1159 if none exists.

1160 Unlike strcspn(), this function works correctly in multibyte locales. */

1161 _GL_EXTERN_C size_t mbscspn (const char *string, const char *accept)

1162 _GL_ARG_NONNULL ((1, 2));

1163 #endif

1164

1165 #if 0

1166 /* Find the first occurrence in the character string STRING of any character

1167 in the character string ACCEPT. Return the pointer to it, or NULL if none

1168 exists.

1169 Unlike strpbrk(), this function works correctly in multibyte locales. */

1170 # if defined __hpux

1171 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

1172 # define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */

1173 # endif

1174 _GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept)

1175 _GL_ARG_NONNULL ((1, 2)));

1176 _GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept));

1177 # else

1178 _GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept)

1179 _GL_ARG_NONNULL ((1, 2)));

1180 _GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept));

1181 # endif

1182 _GL_CXXALIASWARN (mbspbrk);

1183 #endif

1184

1185 #if 0

1186 /* Find the first occurrence in the character string STRING of any character

1187 not in the character string REJECT. Return the number of bytes from the

1188 beginning of the string to this occurrence, or to the end of the string

1189 if none exists.

1190 Unlike strspn(), this function works correctly in multibyte locales. */

1191 _GL_EXTERN_C size_t mbsspn (const char *string, const char *reject)

1192 _GL_ARG_NONNULL ((1, 2));

1193 #endif

1194

1195 #if 0

1196 /* Search the next delimiter (multibyte character listed in the character

1197 string DELIM) starting at the character string *STRINGP.

1198 If one is found, overwrite it with a NUL, and advance *STRINGP to point

1199 to the next multibyte character after it. Otherwise, set *STRINGP to NULL.

1200 If *STRINGP was already NULL, nothing happens.

1201 Return the old value of *STRINGP.

1202

1203 This is a variant of mbstok_r() that supports empty fields.

1204

1205 Caveat: It modifies the original string.

1206 Caveat: These functions cannot be used on constant strings.

1207 Caveat: The identity of the delimiting character is lost.

1208

1209 See also mbstok_r(). */

1210 _GL_EXTERN_C char * mbssep (char **stringp, const char *delim)

1211 _GL_ARG_NONNULL ((1, 2));

1212 #endif

1213

1214 #if 0

1215 /* Parse the character string STRING into tokens separated by characters in

1216 the character string DELIM.

1217 If STRING is NULL, the saved pointer in SAVE_PTR is used as

1218 the next starting point. For example:

1219 char s[] = "-abc-=-def";

1220 char *sp;

1221 x = mbstok_r(s, "-", &sp); // x = "abc", sp = "=-def"

1222 x = mbstok_r(NULL, "-=", &sp); // x = "def", sp = NULL

1223 x = mbstok_r(NULL, "=", &sp); // x = NULL

1224 // s = "abc\0-def\0"

1225

1226 Caveat: It modifies the original string.

1227 Caveat: These functions cannot be used on constant strings.

1228 Caveat: The identity of the delimiting character is lost.

1229

1230 See also mbssep(). */

1231 _GL_EXTERN_C char * mbstok_r (char *string, const char *delim, char **save_ptr)

1232 _GL_ARG_NONNULL ((2, 3));

1233 #endif

1234

1235 /* Map any int, typically from errno, into an error message. */

1236 #if 1

1237 # if 1

1238 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

1239 # undef strerror

1240 # define strerror rpl_strerror

1241 # endif

1242 _GL_FUNCDECL_RPL (strerror, char *, (int));

1243 _GL_CXXALIAS_RPL (strerror, char *, (int));

1244 # else

1245 _GL_CXXALIAS_SYS (strerror, char *, (int));

1246 # endif

1247 _GL_CXXALIASWARN (strerror);

1248 #elif defined GNULIB_POSIXCHECK

1249 # undef strerror

1250 /* Assume strerror is always declared. */

1251 _GL_WARN_ON_USE (strerror, "strerror is unportable - "

1252 "use gnulib module strerror to guarantee non-NULL result");

1253 #endif

1254

1255 /* Map any int, typically from errno, into an error message. Multithread-safe.

1256 Uses the POSIX declaration, not the glibc declaration. */

1257 #if 0

1258 # if 0

1259 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

1260 # undef strerror_r

1261 # define strerror_r rpl_strerror_r

1262 # endif

1263 _GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen)

1264 _GL_ARG_NONNULL ((2)));

1265 _GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen));

1266 # else

1267 # if !1

1268 _GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen)

1269 _GL_ARG_NONNULL ((2)));

1270 # endif

1271 _GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen));

1272 # endif

1273 # if 1

1274 _GL_CXXALIASWARN (strerror_r);

1275 # endif

1276 #elif defined GNULIB_POSIXCHECK

1277 # undef strerror_r

1278 # if HAVE_RAW_DECL_STRERROR_R

1279 _GL_WARN_ON_USE (strerror_r, "strerror_r is unportable - "

1280 "use gnulib module strerror_r-posix for portability");

1281 # endif

1282 #endif

1283

1284 #if 0

1285 # if 0

1286 # if !(defined __cplusplus && defined GNULIB_NAMESPACE)

1287 # define strsignal rpl_strsignal

1288 # endif

1289 _GL_FUNCDECL_RPL (strsignal, char *, (int __sig));

1290 _GL_CXXALIAS_RPL (strsignal, char *, (int __sig));

1291 # else

1292 # if ! 1

1293 _GL_FUNCDECL_SYS (strsignal, char *, (int __sig));

1294 # endif

1295 /* Need to cast, because on Cygwin 1.5.x systems, the return type is

1296 'const char *'. */

1297 _GL_CXXALIAS_SYS_CAST (strsignal, char *, (int __sig));

1298 # endif

1299 _GL_CXXALIASWARN (strsignal);

1300 #elif defined GNULIB_POSIXCHECK

1301 # undef strsignal

1302 # if HAVE_RAW_DECL_STRSIGNAL

1303 _GL_WARN_ON_USE (strsignal, "strsignal is unportable - "

1304 "use gnulib module strsignal for portability");

1305 # endif

1306 #endif

1307

1308 #if 0

1309 # if !1

1310 _GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *)

1311 _GL_ARG_NONNULL ((1, 2)));

1312 # endif

1313 _GL_CXXALIAS_SYS (strverscmp, int, (const char *, const char *));

1314 _GL_CXXALIASWARN (strverscmp);

1315 #elif defined GNULIB_POSIXCHECK

1316 # undef strverscmp

1317 # if HAVE_RAW_DECL_STRVERSCMP

1318 _GL_WARN_ON_USE (strverscmp, "strverscmp is unportable - "

1319 "use gnulib module strverscmp for portability");

1320 # endif

1321 #endif

1322

1323

1324 #endif /* _GL_STRING_H */

1325 #endif /* _GL_STRING_H */