maint/gnulib/lib/unistr.in.h

/* */
This source file includes following definitions.
u8_check
u16_mbtouc_unsafe
u32_mbtouc_unsafe
u8_mbtouc
u16_mbtouc
u32_mbtouc
u8_uctomb
u16_uctomb
u32_uctomb
   1 /* Elementary Unicode string functions.
   2    Copyright (C) 2001-2002, 2005-2021 Free Software Foundation, Inc.
   3 
   4    This file is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as
   6    published by the Free Software Foundation; either version 2.1 of the
   7    License, or (at your option) any later version.
   8 
   9    This file is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU Lesser General Public License for more details.
  13 
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16 
  17 #ifndef _UNISTR_H
  18 #define _UNISTR_H
  19 
  20 #include "unitypes.h"
  21 
  22 /* Get bool.  */
  23 #include <stdbool.h>
  24 
  25 /* Get size_t, ptrdiff_t.  */
  26 #include <stddef.h>
  27 
  28 /* Get free().  */
  29 #include <stdlib.h>
  30 
  31 #ifdef __cplusplus
  32 extern "C" {
  33 #endif
  34 
  35 
  36 /* Conventions:
  37 
  38    All functions prefixed with u8_ operate on UTF-8 encoded strings.
  39    Their unit is an uint8_t (1 byte).
  40 
  41    All functions prefixed with u16_ operate on UTF-16 encoded strings.
  42    Their unit is an uint16_t (a 2-byte word).
  43 
  44    All functions prefixed with u32_ operate on UCS-4 encoded strings.
  45    Their unit is an uint32_t (a 4-byte word).
  46 
  47    All argument pairs (s, n) denote a Unicode string s[0..n-1] with exactly
  48    n units.
  49 
  50    All arguments starting with "str" and the arguments of functions starting
  51    with u8_str/u16_str/u32_str denote a NUL terminated string, i.e. a string
  52    which terminates at the first NUL unit.  This termination unit is
  53    considered part of the string for all memory allocation purposes, but
  54    is not considered part of the string for all other logical purposes.
  55 
  56    Functions returning a string result take a (resultbuf, lengthp) argument
  57    pair.  If resultbuf is not NULL and the result fits into *lengthp units,
  58    it is put in resultbuf, and resultbuf is returned.  Otherwise, a freshly
  59    allocated string is returned.  In both cases, *lengthp is set to the
  60    length (number of units) of the returned string.  In case of error,
  61    NULL is returned and errno is set.  */
  62 
  63 
  64 /* Elementary string checks.  */
  65 
  66 /* Check whether an UTF-8 string is well-formed.
  67    Return NULL if valid, or a pointer to the first invalid unit otherwise.  */
  68 extern const uint8_t *
  69        u8_check (const uint8_t *s, size_t n)
     /*  */
  70        _UC_ATTRIBUTE_PURE;
  71 
  72 /* Check whether an UTF-16 string is well-formed.
  73    Return NULL if valid, or a pointer to the first invalid unit otherwise.  */
  74 extern const uint16_t *
  75        u16_check (const uint16_t *s, size_t n)
  76        _UC_ATTRIBUTE_PURE;
  77 
  78 /* Check whether an UCS-4 string is well-formed.
  79    Return NULL if valid, or a pointer to the first invalid unit otherwise.  */
  80 extern const uint32_t *
  81        u32_check (const uint32_t *s, size_t n)
  82        _UC_ATTRIBUTE_PURE;
  83 
  84 
  85 /* Elementary string conversions.  */
  86 
  87 /* Convert an UTF-8 string to an UTF-16 string.  */
  88 extern uint16_t *
  89        u8_to_u16 (const uint8_t *s, size_t n, uint16_t *resultbuf,
  90                   size_t *lengthp);
  91 
  92 /* Convert an UTF-8 string to an UCS-4 string.  */
  93 extern uint32_t *
  94        u8_to_u32 (const uint8_t *s, size_t n, uint32_t *resultbuf,
  95                   size_t *lengthp);
  96 
  97 /* Convert an UTF-16 string to an UTF-8 string.  */
  98 extern uint8_t *
  99        u16_to_u8 (const uint16_t *s, size_t n, uint8_t *resultbuf,
 100                   size_t *lengthp);
 101 
 102 /* Convert an UTF-16 string to an UCS-4 string.  */
 103 extern uint32_t *
 104        u16_to_u32 (const uint16_t *s, size_t n, uint32_t *resultbuf,
 105                    size_t *lengthp);
 106 
 107 /* Convert an UCS-4 string to an UTF-8 string.  */
 108 extern uint8_t *
 109        u32_to_u8 (const uint32_t *s, size_t n, uint8_t *resultbuf,
 110                   size_t *lengthp);
 111 
 112 /* Convert an UCS-4 string to an UTF-16 string.  */
 113 extern uint16_t *
 114        u32_to_u16 (const uint32_t *s, size_t n, uint16_t *resultbuf,
 115                    size_t *lengthp);
 116 
 117 
 118 /* Elementary string functions.  */
 119 
 120 /* Return the length (number of units) of the first character in S, which is
 121    no longer than N.  Return 0 if it is the NUL character.  Return -1 upon
 122    failure.  */
 123 /* Similar to mblen(), except that s must not be NULL.  */
 124 extern int
 125        u8_mblen (const uint8_t *s, size_t n)
 126        _UC_ATTRIBUTE_PURE;
 127 extern int
 128        u16_mblen (const uint16_t *s, size_t n)
 129        _UC_ATTRIBUTE_PURE;
 130 extern int
 131        u32_mblen (const uint32_t *s, size_t n)
 132        _UC_ATTRIBUTE_PURE;
 133 
 134 /* Return the length (number of units) of the first character in S, putting
 135    its 'ucs4_t' representation in *PUC.  Upon failure, *PUC is set to 0xfffd,
 136    and an appropriate number of units is returned.
 137    The number of available units, N, must be > 0.  */
 138 /* Similar to mbtowc(), except that puc and s must not be NULL, n must be > 0,
 139    and the NUL character is not treated specially.  */
 140 /* The variants with _unsafe suffix are for backward compatibility with
 141    libunistring versions < 0.9.7.  */
 142 
 143 #if GNULIB_UNISTR_U8_MBTOUC_UNSAFE || HAVE_LIBUNISTRING
 144 # if !HAVE_INLINE
 145 extern int
 146        u8_mbtouc_unsafe (ucs4_t *puc, const uint8_t *s, size_t n);
 147 # else
 148 extern int
 149        u8_mbtouc_unsafe_aux (ucs4_t *puc, const uint8_t *s, size_t n);
 150 static inline int
 151 u8_mbtouc_unsafe (ucs4_t *puc, const uint8_t *s, size_t n)
 152 {
 153   uint8_t c = *s;
 154 
 155   if (c < 0x80)
 156     {
 157       *puc = c;
 158       return 1;
 159     }
 160   else
 161     return u8_mbtouc_unsafe_aux (puc, s, n);
 162 }
 163 # endif
 164 #endif
 165 
 166 #if GNULIB_UNISTR_U16_MBTOUC_UNSAFE || HAVE_LIBUNISTRING
 167 # if !HAVE_INLINE
 168 extern int
 169        u16_mbtouc_unsafe (ucs4_t *puc, const uint16_t *s, size_t n);
 170 # else
 171 extern int
 172        u16_mbtouc_unsafe_aux (ucs4_t *puc, const uint16_t *s, size_t n);
 173 static inline int
 174 u16_mbtouc_unsafe (ucs4_t *puc, const uint16_t *s, size_t n)
     /*  */
 175 {
 176   uint16_t c = *s;
 177 
 178   if (c < 0xd800 || c >= 0xe000)
 179     {
 180       *puc = c;
 181       return 1;
 182     }
 183   else
 184     return u16_mbtouc_unsafe_aux (puc, s, n);
 185 }
 186 # endif
 187 #endif
 188 
 189 #if GNULIB_UNISTR_U32_MBTOUC_UNSAFE || HAVE_LIBUNISTRING
 190 # if !HAVE_INLINE
 191 extern int
 192        u32_mbtouc_unsafe (ucs4_t *puc, const uint32_t *s, size_t n);
 193 # else
 194 static inline int
 195 u32_mbtouc_unsafe (ucs4_t *puc,
     /*  */
 196                    const uint32_t *s, _GL_ATTRIBUTE_MAYBE_UNUSED size_t n)
 197 {
 198   uint32_t c = *s;
 199 
 200   if (c < 0xd800 || (c >= 0xe000 && c < 0x110000))
 201     *puc = c;
 202   else
 203     /* invalid multibyte character */
 204     *puc = 0xfffd;
 205   return 1;
 206 }
 207 # endif
 208 #endif
 209 
 210 #if GNULIB_UNISTR_U8_MBTOUC || HAVE_LIBUNISTRING
 211 # if !HAVE_INLINE
 212 extern int
 213        u8_mbtouc (ucs4_t *puc, const uint8_t *s, size_t n);
 214 # else
 215 extern int
 216        u8_mbtouc_aux (ucs4_t *puc, const uint8_t *s, size_t n);
 217 static inline int
 218 u8_mbtouc (ucs4_t *puc, const uint8_t *s, size_t n)
     /*  */
 219 {
 220   uint8_t c = *s;
 221 
 222   if (c < 0x80)
 223     {
 224       *puc = c;
 225       return 1;
 226     }
 227   else
 228     return u8_mbtouc_aux (puc, s, n);
 229 }
 230 # endif
 231 #endif
 232 
 233 #if GNULIB_UNISTR_U16_MBTOUC || HAVE_LIBUNISTRING
 234 # if !HAVE_INLINE
 235 extern int
 236        u16_mbtouc (ucs4_t *puc, const uint16_t *s, size_t n);
 237 # else
 238 extern int
 239        u16_mbtouc_aux (ucs4_t *puc, const uint16_t *s, size_t n);
 240 static inline int
 241 u16_mbtouc (ucs4_t *puc, const uint16_t *s, size_t n)
     /*  */
 242 {
 243   uint16_t c = *s;
 244 
 245   if (c < 0xd800 || c >= 0xe000)
 246     {
 247       *puc = c;
 248       return 1;
 249     }
 250   else
 251     return u16_mbtouc_aux (puc, s, n);
 252 }
 253 # endif
 254 #endif
 255 
 256 #if GNULIB_UNISTR_U32_MBTOUC || HAVE_LIBUNISTRING
 257 # if !HAVE_INLINE
 258 extern int
 259        u32_mbtouc (ucs4_t *puc, const uint32_t *s, size_t n);
 260 # else
 261 static inline int
 262 u32_mbtouc (ucs4_t *puc, const uint32_t *s,
     /*  */
 263             _GL_ATTRIBUTE_MAYBE_UNUSED size_t n)
 264 {
 265   uint32_t c = *s;
 266 
 267   if (c < 0xd800 || (c >= 0xe000 && c < 0x110000))
 268     *puc = c;
 269   else
 270     /* invalid multibyte character */
 271     *puc = 0xfffd;
 272   return 1;
 273 }
 274 # endif
 275 #endif
 276 
 277 /* Return the length (number of units) of the first character in S, putting
 278    its 'ucs4_t' representation in *PUC.  Upon failure, *PUC is set to 0xfffd,
 279    and -1 is returned for an invalid sequence of units, -2 is returned for an
 280    incomplete sequence of units.
 281    The number of available units, N, must be > 0.  */
 282 /* Similar to u*_mbtouc(), except that the return value gives more details
 283    about the failure, similar to mbrtowc().  */
 284 
 285 #if GNULIB_UNISTR_U8_MBTOUCR || HAVE_LIBUNISTRING
 286 extern int
 287        u8_mbtoucr (ucs4_t *puc, const uint8_t *s, size_t n);
 288 #endif
 289 
 290 #if GNULIB_UNISTR_U16_MBTOUCR || HAVE_LIBUNISTRING
 291 extern int
 292        u16_mbtoucr (ucs4_t *puc, const uint16_t *s, size_t n);
 293 #endif
 294 
 295 #if GNULIB_UNISTR_U32_MBTOUCR || HAVE_LIBUNISTRING
 296 extern int
 297        u32_mbtoucr (ucs4_t *puc, const uint32_t *s, size_t n);
 298 #endif
 299 
 300 /* Put the multibyte character represented by UC in S, returning its
 301    length.  Return -1 upon failure, -2 if the number of available units, N,
 302    is too small.  The latter case cannot occur if N >= 6/2/1, respectively.  */
 303 /* Similar to wctomb(), except that s must not be NULL, and the argument n
 304    must be specified.  */
 305 
 306 #if GNULIB_UNISTR_U8_UCTOMB || HAVE_LIBUNISTRING
 307 /* Auxiliary function, also used by u8_chr, u8_strchr, u8_strrchr.  */
 308 extern int
 309        u8_uctomb_aux (uint8_t *s, ucs4_t uc, ptrdiff_t n);
 310 # if !HAVE_INLINE
 311 extern int
 312        u8_uctomb (uint8_t *s, ucs4_t uc, ptrdiff_t n);
 313 # else
 314 static inline int
 315 u8_uctomb (uint8_t *s, ucs4_t uc, ptrdiff_t n)
     /*  */
 316 {
 317   if (uc < 0x80 && n > 0)
 318     {
 319       s[0] = uc;
 320       return 1;
 321     }
 322   else
 323     return u8_uctomb_aux (s, uc, n);
 324 }
 325 # endif
 326 #endif
 327 
 328 #if GNULIB_UNISTR_U16_UCTOMB || HAVE_LIBUNISTRING
 329 /* Auxiliary function, also used by u16_chr, u16_strchr, u16_strrchr.  */
 330 extern int
 331        u16_uctomb_aux (uint16_t *s, ucs4_t uc, ptrdiff_t n);
 332 # if !HAVE_INLINE
 333 extern int
 334        u16_uctomb (uint16_t *s, ucs4_t uc, ptrdiff_t n);
 335 # else
 336 static inline int
 337 u16_uctomb (uint16_t *s, ucs4_t uc, ptrdiff_t n)
     /*  */
 338 {
 339   if (uc < 0xd800 && n > 0)
 340     {
 341       s[0] = uc;
 342       return 1;
 343     }
 344   else
 345     return u16_uctomb_aux (s, uc, n);
 346 }
 347 # endif
 348 #endif
 349 
 350 #if GNULIB_UNISTR_U32_UCTOMB || HAVE_LIBUNISTRING
 351 # if !HAVE_INLINE
 352 extern int
 353        u32_uctomb (uint32_t *s, ucs4_t uc, ptrdiff_t n);
 354 # else
 355 static inline int
 356 u32_uctomb (uint32_t *s, ucs4_t uc, ptrdiff_t n)
     /*  */
 357 {
 358   if (uc < 0xd800 || (uc >= 0xe000 && uc < 0x110000))
 359     {
 360       if (n > 0)
 361         {
 362           *s = uc;
 363           return 1;
 364         }
 365       else
 366         return -2;
 367     }
 368   else
 369     return -1;
 370 }
 371 # endif
 372 #endif
 373 
 374 /* Copy N units from SRC to DEST.  */
 375 /* Similar to memcpy().  */
 376 extern uint8_t *
 377        u8_cpy (uint8_t *_UC_RESTRICT dest, const uint8_t *src, size_t n);
 378 extern uint16_t *
 379        u16_cpy (uint16_t *_UC_RESTRICT dest, const uint16_t *src, size_t n);
 380 extern uint32_t *
 381        u32_cpy (uint32_t *_UC_RESTRICT dest, const uint32_t *src, size_t n);
 382 
 383 /* Copy N units from SRC to DEST, guaranteeing correct behavior for
 384    overlapping memory areas.  */
 385 /* Similar to memmove().  */
 386 extern uint8_t *
 387        u8_move (uint8_t *dest, const uint8_t *src, size_t n);
 388 extern uint16_t *
 389        u16_move (uint16_t *dest, const uint16_t *src, size_t n);
 390 extern uint32_t *
 391        u32_move (uint32_t *dest, const uint32_t *src, size_t n);
 392 
 393 /* Set the first N characters of S to UC.  UC should be a character that
 394    occupies only 1 unit.  */
 395 /* Similar to memset().  */
 396 extern uint8_t *
 397        u8_set (uint8_t *s, ucs4_t uc, size_t n);
 398 extern uint16_t *
 399        u16_set (uint16_t *s, ucs4_t uc, size_t n);
 400 extern uint32_t *
 401        u32_set (uint32_t *s, ucs4_t uc, size_t n);
 402 
 403 /* Compare S1 and S2, each of length N.  */
 404 /* Similar to memcmp().  */
 405 extern int
 406        u8_cmp (const uint8_t *s1, const uint8_t *s2, size_t n)
 407        _UC_ATTRIBUTE_PURE;
 408 extern int
 409        u16_cmp (const uint16_t *s1, const uint16_t *s2, size_t n)
 410        _UC_ATTRIBUTE_PURE;
 411 extern int
 412        u32_cmp (const uint32_t *s1, const uint32_t *s2, size_t n)
 413        _UC_ATTRIBUTE_PURE;
 414 
 415 /* Compare S1 and S2.  */
 416 /* Similar to the gnulib function memcmp2().  */
 417 extern int
 418        u8_cmp2 (const uint8_t *s1, size_t n1, const uint8_t *s2, size_t n2)
 419        _UC_ATTRIBUTE_PURE;
 420 extern int
 421        u16_cmp2 (const uint16_t *s1, size_t n1, const uint16_t *s2, size_t n2)
 422        _UC_ATTRIBUTE_PURE;
 423 extern int
 424        u32_cmp2 (const uint32_t *s1, size_t n1, const uint32_t *s2, size_t n2)
 425        _UC_ATTRIBUTE_PURE;
 426 
 427 /* Search the string at S for UC.  */
 428 /* Similar to memchr().  */
 429 extern uint8_t *
 430        u8_chr (const uint8_t *s, size_t n, ucs4_t uc)
 431        _UC_ATTRIBUTE_PURE;
 432 extern uint16_t *
 433        u16_chr (const uint16_t *s, size_t n, ucs4_t uc)
 434        _UC_ATTRIBUTE_PURE;
 435 extern uint32_t *
 436        u32_chr (const uint32_t *s, size_t n, ucs4_t uc)
 437        _UC_ATTRIBUTE_PURE;
 438 
 439 /* Count the number of Unicode characters in the N units from S.  */
 440 /* Similar to mbsnlen().  */
 441 extern size_t
 442        u8_mbsnlen (const uint8_t *s, size_t n)
 443        _UC_ATTRIBUTE_PURE;
 444 extern size_t
 445        u16_mbsnlen (const uint16_t *s, size_t n)
 446        _UC_ATTRIBUTE_PURE;
 447 extern size_t
 448        u32_mbsnlen (const uint32_t *s, size_t n)
 449        _UC_ATTRIBUTE_PURE;
 450 
 451 /* Elementary string functions with memory allocation.  */
 452 
 453 /* Make a freshly allocated copy of S, of length N.  */
 454 extern uint8_t *
 455        u8_cpy_alloc (const uint8_t *s, size_t n);
 456 extern uint16_t *
 457        u16_cpy_alloc (const uint16_t *s, size_t n);
 458 extern uint32_t *
 459        u32_cpy_alloc (const uint32_t *s, size_t n);
 460 
 461 /* Elementary string functions on NUL terminated strings.  */
 462 
 463 /* Return the length (number of units) of the first character in S.
 464    Return 0 if it is the NUL character.  Return -1 upon failure.  */
 465 extern int
 466        u8_strmblen (const uint8_t *s)
 467        _UC_ATTRIBUTE_PURE;
 468 extern int
 469        u16_strmblen (const uint16_t *s)
 470        _UC_ATTRIBUTE_PURE;
 471 extern int
 472        u32_strmblen (const uint32_t *s)
 473        _UC_ATTRIBUTE_PURE;
 474 
 475 /* Return the length (number of units) of the first character in S, putting
 476    its 'ucs4_t' representation in *PUC.  Return 0 if it is the NUL
 477    character.  Return -1 upon failure.  */
 478 extern int
 479        u8_strmbtouc (ucs4_t *puc, const uint8_t *s);
 480 extern int
 481        u16_strmbtouc (ucs4_t *puc, const uint16_t *s);
 482 extern int
 483        u32_strmbtouc (ucs4_t *puc, const uint32_t *s);
 484 
 485 /* Forward iteration step.  Advances the pointer past the next character,
 486    or returns NULL if the end of the string has been reached.  Puts the
 487    character's 'ucs4_t' representation in *PUC.  */
 488 extern const uint8_t *
 489        u8_next (ucs4_t *puc, const uint8_t *s);
 490 extern const uint16_t *
 491        u16_next (ucs4_t *puc, const uint16_t *s);
 492 extern const uint32_t *
 493        u32_next (ucs4_t *puc, const uint32_t *s);
 494 
 495 /* Backward iteration step.  Advances the pointer to point to the previous
 496    character, or returns NULL if the beginning of the string had been reached.
 497    Puts the character's 'ucs4_t' representation in *PUC.  */
 498 extern const uint8_t *
 499        u8_prev (ucs4_t *puc, const uint8_t *s, const uint8_t *start);
 500 extern const uint16_t *
 501        u16_prev (ucs4_t *puc, const uint16_t *s, const uint16_t *start);
 502 extern const uint32_t *
 503        u32_prev (ucs4_t *puc, const uint32_t *s, const uint32_t *start);
 504 
 505 /* Return the number of units in S.  */
 506 /* Similar to strlen(), wcslen().  */
 507 extern size_t
 508        u8_strlen (const uint8_t *s)
 509        _UC_ATTRIBUTE_PURE;
 510 extern size_t
 511        u16_strlen (const uint16_t *s)
 512        _UC_ATTRIBUTE_PURE;
 513 extern size_t
 514        u32_strlen (const uint32_t *s)
 515        _UC_ATTRIBUTE_PURE;
 516 
 517 /* Return the number of units in S, but at most MAXLEN.  */
 518 /* Similar to strnlen(), wcsnlen().  */
 519 extern size_t
 520        u8_strnlen (const uint8_t *s, size_t maxlen)
 521        _UC_ATTRIBUTE_PURE;
 522 extern size_t
 523        u16_strnlen (const uint16_t *s, size_t maxlen)
 524        _UC_ATTRIBUTE_PURE;
 525 extern size_t
 526        u32_strnlen (const uint32_t *s, size_t maxlen)
 527        _UC_ATTRIBUTE_PURE;
 528 
 529 /* Copy SRC to DEST.  */
 530 /* Similar to strcpy(), wcscpy().  */
 531 extern uint8_t *
 532        u8_strcpy (uint8_t *_UC_RESTRICT dest, const uint8_t *src);
 533 extern uint16_t *
 534        u16_strcpy (uint16_t *_UC_RESTRICT dest, const uint16_t *src);
 535 extern uint32_t *
 536        u32_strcpy (uint32_t *_UC_RESTRICT dest, const uint32_t *src);
 537 
 538 /* Copy SRC to DEST, returning the address of the terminating NUL in DEST.  */
 539 /* Similar to stpcpy().  */
 540 extern uint8_t *
 541        u8_stpcpy (uint8_t *_UC_RESTRICT dest, const uint8_t *src);
 542 extern uint16_t *
 543        u16_stpcpy (uint16_t *_UC_RESTRICT dest, const uint16_t *src);
 544 extern uint32_t *
 545        u32_stpcpy (uint32_t *_UC_RESTRICT dest, const uint32_t *src);
 546 
 547 /* Copy no more than N units of SRC to DEST.  */
 548 /* Similar to strncpy(), wcsncpy().  */
 549 extern uint8_t *
 550        u8_strncpy (uint8_t *_UC_RESTRICT dest, const uint8_t *src, size_t n);
 551 extern uint16_t *
 552        u16_strncpy (uint16_t *_UC_RESTRICT dest, const uint16_t *src, size_t n);
 553 extern uint32_t *
 554        u32_strncpy (uint32_t *_UC_RESTRICT dest, const uint32_t *src, size_t n);
 555 
 556 /* Copy no more than N units of SRC to DEST.  Return a pointer past the last
 557    non-NUL unit written into DEST.  */
 558 /* Similar to stpncpy().  */
 559 extern uint8_t *
 560        u8_stpncpy (uint8_t *_UC_RESTRICT dest, const uint8_t *src, size_t n);
 561 extern uint16_t *
 562        u16_stpncpy (uint16_t *_UC_RESTRICT dest, const uint16_t *src, size_t n);
 563 extern uint32_t *
 564        u32_stpncpy (uint32_t *_UC_RESTRICT dest, const uint32_t *src, size_t n);
 565 
 566 /* Append SRC onto DEST.  */
 567 /* Similar to strcat(), wcscat().  */
 568 extern uint8_t *
 569        u8_strcat (uint8_t *_UC_RESTRICT dest, const uint8_t *src);
 570 extern uint16_t *
 571        u16_strcat (uint16_t *_UC_RESTRICT dest, const uint16_t *src);
 572 extern uint32_t *
 573        u32_strcat (uint32_t *_UC_RESTRICT dest, const uint32_t *src);
 574 
 575 /* Append no more than N units of SRC onto DEST.  */
 576 /* Similar to strncat(), wcsncat().  */
 577 extern uint8_t *
 578        u8_strncat (uint8_t *_UC_RESTRICT dest, const uint8_t *src, size_t n);
 579 extern uint16_t *
 580        u16_strncat (uint16_t *_UC_RESTRICT dest, const uint16_t *src, size_t n);
 581 extern uint32_t *
 582        u32_strncat (uint32_t *_UC_RESTRICT dest, const uint32_t *src, size_t n);
 583 
 584 /* Compare S1 and S2.  */
 585 /* Similar to strcmp(), wcscmp().  */
 586 #ifdef __sun
 587 /* Avoid a collision with the u8_strcmp() function in Solaris 11 libc.  */
 588 extern int
 589        u8_strcmp_gnu (const uint8_t *s1, const uint8_t *s2)
 590        _UC_ATTRIBUTE_PURE;
 591 # define u8_strcmp u8_strcmp_gnu
 592 #else
 593 extern int
 594        u8_strcmp (const uint8_t *s1, const uint8_t *s2)
 595        _UC_ATTRIBUTE_PURE;
 596 #endif
 597 extern int
 598        u16_strcmp (const uint16_t *s1, const uint16_t *s2)
 599        _UC_ATTRIBUTE_PURE;
 600 extern int
 601        u32_strcmp (const uint32_t *s1, const uint32_t *s2)
 602        _UC_ATTRIBUTE_PURE;
 603 
 604 /* Compare S1 and S2 using the collation rules of the current locale.
 605    Return -1 if S1 < S2, 0 if S1 = S2, 1 if S1 > S2.
 606    Upon failure, set errno and return any value.  */
 607 /* Similar to strcoll(), wcscoll().  */
 608 extern int
 609        u8_strcoll (const uint8_t *s1, const uint8_t *s2);
 610 extern int
 611        u16_strcoll (const uint16_t *s1, const uint16_t *s2);
 612 extern int
 613        u32_strcoll (const uint32_t *s1, const uint32_t *s2);
 614 
 615 /* Compare no more than N units of S1 and S2.  */
 616 /* Similar to strncmp(), wcsncmp().  */
 617 extern int
 618        u8_strncmp (const uint8_t *s1, const uint8_t *s2, size_t n)
 619        _UC_ATTRIBUTE_PURE;
 620 extern int
 621        u16_strncmp (const uint16_t *s1, const uint16_t *s2, size_t n)
 622        _UC_ATTRIBUTE_PURE;
 623 extern int
 624        u32_strncmp (const uint32_t *s1, const uint32_t *s2, size_t n)
 625        _UC_ATTRIBUTE_PURE;
 626 
 627 /* Duplicate S, returning an identical malloc'd string.  */
 628 /* Similar to strdup(), wcsdup().  */
 629 extern uint8_t *
 630        u8_strdup (const uint8_t *s)
 631        _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE;
 632 extern uint16_t *
 633        u16_strdup (const uint16_t *s)
 634        _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE;
 635 extern uint32_t *
 636        u32_strdup (const uint32_t *s)
 637        _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE;
 638 
 639 /* Find the first occurrence of UC in STR.  */
 640 /* Similar to strchr(), wcschr().  */
 641 extern uint8_t *
 642        u8_strchr (const uint8_t *str, ucs4_t uc)
 643        _UC_ATTRIBUTE_PURE;
 644 extern uint16_t *
 645        u16_strchr (const uint16_t *str, ucs4_t uc)
 646        _UC_ATTRIBUTE_PURE;
 647 extern uint32_t *
 648        u32_strchr (const uint32_t *str, ucs4_t uc)
 649        _UC_ATTRIBUTE_PURE;
 650 
 651 /* Find the last occurrence of UC in STR.  */
 652 /* Similar to strrchr(), wcsrchr().  */
 653 extern uint8_t *
 654        u8_strrchr (const uint8_t *str, ucs4_t uc)
 655        _UC_ATTRIBUTE_PURE;
 656 extern uint16_t *
 657        u16_strrchr (const uint16_t *str, ucs4_t uc)
 658        _UC_ATTRIBUTE_PURE;
 659 extern uint32_t *
 660        u32_strrchr (const uint32_t *str, ucs4_t uc)
 661        _UC_ATTRIBUTE_PURE;
 662 
 663 /* Return the length of the initial segment of STR which consists entirely
 664    of Unicode characters not in REJECT.  */
 665 /* Similar to strcspn(), wcscspn().  */
 666 extern size_t
 667        u8_strcspn (const uint8_t *str, const uint8_t *reject)
 668        _UC_ATTRIBUTE_PURE;
 669 extern size_t
 670        u16_strcspn (const uint16_t *str, const uint16_t *reject)
 671        _UC_ATTRIBUTE_PURE;
 672 extern size_t
 673        u32_strcspn (const uint32_t *str, const uint32_t *reject)
 674        _UC_ATTRIBUTE_PURE;
 675 
 676 /* Return the length of the initial segment of STR which consists entirely
 677    of Unicode characters in ACCEPT.  */
 678 /* Similar to strspn(), wcsspn().  */
 679 extern size_t
 680        u8_strspn (const uint8_t *str, const uint8_t *accept)
 681        _UC_ATTRIBUTE_PURE;
 682 extern size_t
 683        u16_strspn (const uint16_t *str, const uint16_t *accept)
 684        _UC_ATTRIBUTE_PURE;
 685 extern size_t
 686        u32_strspn (const uint32_t *str, const uint32_t *accept)
 687        _UC_ATTRIBUTE_PURE;
 688 
 689 /* Find the first occurrence in STR of any character in ACCEPT.  */
 690 /* Similar to strpbrk(), wcspbrk().  */
 691 extern uint8_t *
 692        u8_strpbrk (const uint8_t *str, const uint8_t *accept)
 693        _UC_ATTRIBUTE_PURE;
 694 extern uint16_t *
 695        u16_strpbrk (const uint16_t *str, const uint16_t *accept)
 696        _UC_ATTRIBUTE_PURE;
 697 extern uint32_t *
 698        u32_strpbrk (const uint32_t *str, const uint32_t *accept)
 699        _UC_ATTRIBUTE_PURE;
 700 
 701 /* Find the first occurrence of NEEDLE in HAYSTACK.  */
 702 /* Similar to strstr(), wcsstr().  */
 703 extern uint8_t *
 704        u8_strstr (const uint8_t *haystack, const uint8_t *needle)
 705        _UC_ATTRIBUTE_PURE;
 706 extern uint16_t *
 707        u16_strstr (const uint16_t *haystack, const uint16_t *needle)
 708        _UC_ATTRIBUTE_PURE;
 709 extern uint32_t *
 710        u32_strstr (const uint32_t *haystack, const uint32_t *needle)
 711        _UC_ATTRIBUTE_PURE;
 712 
 713 /* Test whether STR starts with PREFIX.  */
 714 extern bool
 715        u8_startswith (const uint8_t *str, const uint8_t *prefix)
 716        _UC_ATTRIBUTE_PURE;
 717 extern bool
 718        u16_startswith (const uint16_t *str, const uint16_t *prefix)
 719        _UC_ATTRIBUTE_PURE;
 720 extern bool
 721        u32_startswith (const uint32_t *str, const uint32_t *prefix)
 722        _UC_ATTRIBUTE_PURE;
 723 
 724 /* Test whether STR ends with SUFFIX.  */
 725 extern bool
 726        u8_endswith (const uint8_t *str, const uint8_t *suffix)
 727        _UC_ATTRIBUTE_PURE;
 728 extern bool
 729        u16_endswith (const uint16_t *str, const uint16_t *suffix)
 730        _UC_ATTRIBUTE_PURE;
 731 extern bool
 732        u32_endswith (const uint32_t *str, const uint32_t *suffix)
 733        _UC_ATTRIBUTE_PURE;
 734 
 735 /* Divide STR into tokens separated by characters in DELIM.
 736    This interface is actually more similar to wcstok than to strtok.  */
 737 /* Similar to strtok_r(), wcstok().  */
 738 extern uint8_t *
 739        u8_strtok (uint8_t *_UC_RESTRICT str, const uint8_t *delim,
 740                   uint8_t **ptr);
 741 extern uint16_t *
 742        u16_strtok (uint16_t *_UC_RESTRICT str, const uint16_t *delim,
 743                    uint16_t **ptr);
 744 extern uint32_t *
 745        u32_strtok (uint32_t *_UC_RESTRICT str, const uint32_t *delim,
 746                    uint32_t **ptr);
 747 
 748 
 749 #ifdef __cplusplus
 750 }
 751 #endif
 752 
 753 #endif /* _UNISTR_H */
/* */
root/maint/gnulib/lib/unistr.in.h

DEFINITIONS
