wcsmbs/bits/wchar2.h

   1 /* Checking macros for wchar functions.
   2    Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #ifndef _WCHAR_H
  21 # error "Never include <bits/wchar2.h> directly; use <wchar.h> instead."
  22 #endif
  23
  24
  25 extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
  26                                __const wchar_t *__restrict __s2, size_t __n,
  27                                size_t __ns1) __THROW;
  28 extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias,
  29                                 (wchar_t *__restrict __s1,
  30                                  __const wchar_t *__restrict __s2, size_t __n),
  31                                 wmemcpy);
  32 extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn,
  33                                 (wchar_t *__restrict __s1,
  34                                  __const wchar_t *__restrict __s2, size_t __n,
  35                                  size_t __ns1), __wmemcpy_chk)
  36      __warnattr ("wmemcpy called with length bigger than size of destination "
  37                  "buffer");
  38
  39 __extern_always_inline wchar_t *
  40 __NTH (wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
  41                 size_t __n))
  42 {
  43   if (__bos0 (__s1) != (size_t) -1)
  44     {
  45       if (!__builtin_constant_p (__n))
  46         return __wmemcpy_chk (__s1, __s2, __n,
  47                               __bos0 (__s1) / sizeof (wchar_t));
  48
  49       if (__n > __bos0 (__s1) / sizeof (wchar_t))
  50         return __wmemcpy_chk_warn (__s1, __s2, __n,
  51                                    __bos0 (__s1) / sizeof (wchar_t));
  52     }
  53   return __wmemcpy_alias (__s1, __s2, __n);
  54 }
  55
  56
  57 extern wchar_t *__wmemmove_chk (wchar_t *__s1, __const wchar_t *__s2,
  58                                 size_t __n, size_t __ns1) __THROW;
  59 extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1,
  60                                                    __const wchar_t *__s2,
  61                                                    size_t __n), wmemmove);
  62 extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn,
  63                                 (wchar_t *__restrict __s1,
  64                                  __const wchar_t *__restrict __s2, size_t __n,
  65                                  size_t __ns1), __wmemmove_chk)
  66      __warnattr ("wmemmove called with length bigger than size of destination "
  67                  "buffer");
  68
  69 __extern_always_inline wchar_t *
  70 __NTH (wmemmove (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
  71                  size_t __n))
  72 {
  73   if (__bos0 (__s1) != (size_t) -1)
  74     {
  75       if (!__builtin_constant_p (__n))
  76         return __wmemmove_chk (__s1, __s2, __n,
  77                                __bos0 (__s1) / sizeof (wchar_t));
  78
  79       if (__n > __bos0 (__s1) / sizeof (wchar_t))
  80         return __wmemmove_chk_warn (__s1, __s2, __n,
  81                                     __bos0 (__s1) / sizeof (wchar_t));
  82     }
  83   return __wmemmove_alias (__s1, __s2, __n);
  84 }
  85
  86
  87 #ifdef __USE_GNU
  88 extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
  89                                 __const wchar_t *__restrict __s2, size_t __n,
  90                                 size_t __ns1) __THROW;
  91 extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias,
  92                                 (wchar_t *__restrict __s1,
  93                                  __const wchar_t *__restrict __s2,
  94                                  size_t __n), wmempcpy);
  95 extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn,
  96                                 (wchar_t *__restrict __s1,
  97                                  __const wchar_t *__restrict __s2, size_t __n,
  98                                  size_t __ns1), __wmempcpy_chk)
  99      __warnattr ("wmempcpy called with length bigger than size of destination "
 100                  "buffer");
 101
 102 __extern_always_inline wchar_t *
 103 __NTH (wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
 104                  size_t __n))
 105 {
 106   if (__bos0 (__s1) != (size_t) -1)
 107     {
 108       if (!__builtin_constant_p (__n))
 109         return __wmempcpy_chk (__s1, __s2, __n,
 110                                __bos0 (__s1) / sizeof (wchar_t));
 111
 112       if (__n > __bos0 (__s1) / sizeof (wchar_t))
 113         return __wmempcpy_chk_warn (__s1, __s2, __n,
 114                                     __bos0 (__s1) / sizeof (wchar_t));
 115     }
 116   return __wmempcpy_alias (__s1, __s2, __n);
 117 }
 118 #endif
 119
 120
 121 extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
 122                                size_t __ns) __THROW;
 123 extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c,
 124                                                   size_t __n), wmemset);
 125 extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn,
 126                                 (wchar_t *__s, wchar_t __c, size_t __n,
 127                                  size_t __ns), __wmemset_chk)
 128      __warnattr ("wmemset called with length bigger than size of destination "
 129                  "buffer");
 130
 131 __extern_always_inline wchar_t *
 132 __NTH (wmemset (wchar_t *__restrict __s, wchar_t __c, size_t __n))
 133 {
 134   if (__bos0 (__s) != (size_t) -1)
 135     {
 136       if (!__builtin_constant_p (__n))
 137         return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t));
 138
 139       if (__n > __bos0 (__s) / sizeof (wchar_t))
 140         return __wmemset_chk_warn (__s, __c, __n,
 141                                    __bos0 (__s) / sizeof (wchar_t));
 142     }
 143   return __wmemset_alias (__s, __c, __n);
 144 }
 145
 146
 147 extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
 148                               __const wchar_t *__restrict __src,
 149                               size_t __n) __THROW;
 150 extern wchar_t *__REDIRECT_NTH (__wcscpy_alias,
 151                                 (wchar_t *__restrict __dest,
 152                                  __const wchar_t *__restrict __src), wcscpy);
 153
 154 __extern_always_inline wchar_t *
 155 __NTH (wcscpy (wchar_t *__dest, __const wchar_t *__src))
 156 {
 157   if (__bos (__dest) != (size_t) -1)
 158     return __wcscpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
 159   return __wcscpy_alias (__dest, __src);
 160 }
 161
 162
 163 extern wchar_t *__wcpcpy_chk (wchar_t *__dest, __const wchar_t *__src,
 164                               size_t __destlen) __THROW;
 165 extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias, (wchar_t *__dest,
 166                                                  __const wchar_t *__src),
 167                                 wcpcpy);
 168
 169 __extern_always_inline wchar_t *
 170 __NTH (wcpcpy (wchar_t *__dest, __const wchar_t *__src))
 171 {
 172   if (__bos (__dest) != (size_t) -1)
 173     return __wcpcpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
 174   return __wcpcpy_alias (__dest, __src);
 175 }
 176
 177
 178 extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
 179                                __const wchar_t *__restrict __src, size_t __n,
 180                                size_t __destlen) __THROW;
 181 extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias,
 182                                 (wchar_t *__restrict __dest,
 183                                  __const wchar_t *__restrict __src,
 184                                  size_t __n), wcsncpy);
 185 extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn,
 186                                 (wchar_t *__restrict __dest,
 187                                  __const wchar_t *__restrict __src,
 188                                  size_t __n, size_t __destlen), __wcsncpy_chk)
 189      __warnattr ("wcsncpy called with length bigger than size of destination "
 190                  "buffer");
 191
 192 __extern_always_inline wchar_t *
 193 __NTH (wcsncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n))
 194 {
 195   if (__bos (__dest) != (size_t) -1)
 196     {
 197       if (!__builtin_constant_p (__n))
 198         return __wcsncpy_chk (__dest, __src, __n,
 199                               __bos (__dest) / sizeof (wchar_t));
 200       if (__n > __bos (__dest) / sizeof (wchar_t))
 201         return __wcsncpy_chk_warn (__dest, __src, __n,
 202                                    __bos (__dest) / sizeof (wchar_t));
 203     }
 204   return __wcsncpy_alias (__dest, __src, __n);
 205 }
 206
 207
 208 extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
 209                                __const wchar_t *__restrict __src, size_t __n,
 210                                size_t __destlen) __THROW;
 211 extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias,
 212                                 (wchar_t *__restrict __dest,
 213                                  __const wchar_t *__restrict __src,
 214                                  size_t __n), wcpncpy);
 215 extern wchar_t *__REDIRECT_NTH (__wcpncpy_chk_warn,
 216                                 (wchar_t *__restrict __dest,
 217                                  __const wchar_t *__restrict __src,
 218                                  size_t __n, size_t __destlen), __wcpncpy_chk)
 219      __warnattr ("wcpncpy called with length bigger than size of destination "
 220                  "buffer");
 221
 222 __extern_always_inline wchar_t *
 223 __NTH (wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n))
 224 {
 225   if (__bos (__dest) != (size_t) -1)
 226     {
 227       if (!__builtin_constant_p (__n))
 228         return __wcpncpy_chk (__dest, __src, __n,
 229                               __bos (__dest) / sizeof (wchar_t));
 230       if (__n > __bos (__dest) / sizeof (wchar_t))
 231         return __wcpncpy_chk_warn (__dest, __src, __n,
 232                                    __bos (__dest) / sizeof (wchar_t));
 233     }
 234   return __wcpncpy_alias (__dest, __src, __n);
 235 }
 236
 237
 238 extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
 239                               __const wchar_t *__restrict __src,
 240                               size_t __destlen) __THROW;
 241 extern wchar_t *__REDIRECT_NTH (__wcscat_alias,
 242                                 (wchar_t *__restrict __dest,
 243                                  __const wchar_t *__restrict __src), wcscat);
 244
 245 __extern_always_inline wchar_t *
 246 __NTH (wcscat (wchar_t *__dest, __const wchar_t *__src))
 247 {
 248   if (__bos (__dest) != (size_t) -1)
 249     return __wcscat_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
 250   return __wcscat_alias (__dest, __src);
 251 }
 252
 253
 254 extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
 255                                __const wchar_t *__restrict __src,
 256                                size_t __n, size_t __destlen) __THROW;
 257 extern wchar_t *__REDIRECT_NTH (__wcsncat_alias,
 258                                 (wchar_t *__restrict __dest,
 259                                  __const wchar_t *__restrict __src,
 260                                  size_t __n), wcsncat);
 261
 262 __extern_always_inline wchar_t *
 263 __NTH (wcsncat (wchar_t *__dest, __const wchar_t *__src, size_t __n))
 264 {
 265   if (__bos (__dest) != (size_t) -1)
 266     return __wcsncat_chk (__dest, __src, __n,
 267                           __bos (__dest) / sizeof (wchar_t));
 268   return __wcsncat_alias (__dest, __src, __n);
 269 }
 270
 271
 272 extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
 273                            int __flag, size_t __s_len,
 274                            __const wchar_t *__restrict __format, ...)
 275      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 6))) */;
 276
 277 extern int __REDIRECT_NTH_LDBL (__swprintf_alias,
 278                                 (wchar_t *__restrict __s, size_t __n,
 279                                  __const wchar_t *__restrict __fmt, ...),
 280                                 swprintf);
 281
 282 #ifdef __va_arg_pack
 283 __extern_always_inline int
 284 __NTH (swprintf (wchar_t *__restrict __s, size_t __n,
 285                  __const wchar_t *__restrict __fmt, ...))
 286 {
 287   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
 288     return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
 289                            __bos (__s) / sizeof (wchar_t),
 290                            __fmt, __va_arg_pack ());
 291   return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
 292 }
 293 #elif !defined __cplusplus
 294 /* XXX We might want to have support in gcc for swprintf.  */
 295 # define swprintf(s, n, ...) \
 296   (__bos (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1                        \
 297    ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1,                           \
 298                      __bos (s) / sizeof (wchar_t), __VA_ARGS__)               \
 299    : swprintf (s, n, __VA_ARGS__))
 300 #endif
 301
 302 extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
 303                             int __flag, size_t __s_len,
 304                             __const wchar_t *__restrict __format,
 305                             __gnuc_va_list __arg)
 306      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */;
 307
 308 extern int __REDIRECT_NTH_LDBL (__vswprintf_alias,
 309                                 (wchar_t *__restrict __s, size_t __n,
 310                                  __const wchar_t *__restrict __fmt,
 311                                  __gnuc_va_list __ap), vswprintf);
 312
 313 __extern_always_inline int
 314 __NTH (vswprintf (wchar_t *__restrict __s, size_t __n,
 315                   __const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
 316 {
 317   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
 318     return __vswprintf_chk (__s, __n,  __USE_FORTIFY_LEVEL - 1,
 319                             __bos (__s) / sizeof (wchar_t), __fmt, __ap);
 320   return __vswprintf_alias (__s, __n, __fmt, __ap);
 321 }
 322
 323
 324 #if __USE_FORTIFY_LEVEL > 1
 325
 326 extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
 327                            __const wchar_t *__restrict __format, ...);
 328 extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
 329                           ...);
 330 extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
 331                             __const wchar_t *__restrict __format,
 332                             __gnuc_va_list __ap);
 333 extern int __vwprintf_chk (int __flag, __const wchar_t *__restrict __format,
 334                            __gnuc_va_list __ap);
 335
 336 # ifdef __va_arg_pack
 337 __extern_always_inline int
 338 wprintf (__const wchar_t *__restrict __fmt, ...)
 339 {
 340   return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ());
 341 }
 342
 343 __extern_always_inline int
 344 fwprintf (__FILE *__restrict __stream, __const wchar_t *__restrict __fmt, ...)
 345 {
 346   return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt,
 347                          __va_arg_pack ());
 348 }
 349 # elif !defined __cplusplus
 350 #  define wprintf(...) \
 351   __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
 352 #  define fwprintf(stream, ...) \
 353   __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
 354 # endif
 355
 356 __extern_always_inline int
 357 vwprintf (__const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
 358 {
 359   return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap);
 360 }
 361
 362 __extern_always_inline int
 363 vfwprintf (__FILE *__restrict __stream,
 364            __const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
 365 {
 366   return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap);
 367 }
 368
 369 #endif
 370
 371 extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
 372                               __FILE *__restrict __stream) __wur;
 373 extern wchar_t *__REDIRECT (__fgetws_alias,
 374                             (wchar_t *__restrict __s, int __n,
 375                              __FILE *__restrict __stream), fgetws) __wur;
 376 extern wchar_t *__REDIRECT (__fgetws_chk_warn,
 377                             (wchar_t *__restrict __s, size_t __size, int __n,
 378                              __FILE *__restrict __stream), __fgetws_chk)
 379      __wur __warnattr ("fgetws called with bigger size than length "
 380                        "of destination buffer");
 381
 382 __extern_always_inline __wur wchar_t *
 383 fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
 384 {
 385   if (__bos (__s) != (size_t) -1)
 386     {
 387       if (!__builtin_constant_p (__n) || __n <= 0)
 388         return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t),
 389                              __n, __stream);
 390
 391       if ((size_t) __n > __bos (__s) / sizeof (wchar_t))
 392         return __fgetws_chk_warn (__s, __bos (__s) / sizeof (wchar_t),
 393                                   __n, __stream);
 394     }
 395   return __fgetws_alias (__s, __n, __stream);
 396 }
 397
 398 #ifdef __USE_GNU
 399 extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
 400                                        int __n, __FILE *__restrict __stream)
 401   __wur;
 402 extern wchar_t *__REDIRECT (__fgetws_unlocked_alias,
 403                             (wchar_t *__restrict __s, int __n,
 404                              __FILE *__restrict __stream), fgetws_unlocked)
 405   __wur;
 406 extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn,
 407                             (wchar_t *__restrict __s, size_t __size, int __n,
 408                              __FILE *__restrict __stream),
 409                             __fgetws_unlocked_chk)
 410      __wur __warnattr ("fgetws_unlocked called with bigger size than length "
 411                        "of destination buffer");
 412
 413 __extern_always_inline __wur wchar_t *
 414 fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
 415 {
 416   if (__bos (__s) != (size_t) -1)
 417     {
 418       if (!__builtin_constant_p (__n) || __n <= 0)
 419         return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t),
 420                                       __n, __stream);
 421
 422       if ((size_t) __n > __bos (__s) / sizeof (wchar_t))
 423         return __fgetws_unlocked_chk_warn (__s, __bos (__s) / sizeof (wchar_t),
 424                                            __n, __stream);
 425     }
 426   return __fgetws_unlocked_alias (__s, __n, __stream);
 427 }
 428 #endif
 429
 430
 431 extern size_t __wcrtomb_chk (char *__s, wchar_t __wchar, mbstate_t *__p,
 432                           size_t __buflen) __THROW __wur;
 433 extern size_t __REDIRECT_NTH (__wcrtomb_alias,
 434                               (char *__restrict __s, wchar_t __wchar,
 435                                mbstate_t *__restrict __ps), wcrtomb) __wur;
 436
 437 __extern_always_inline __wur size_t
 438 __NTH (wcrtomb (char *__s, wchar_t __wchar, mbstate_t *__ps))
 439 {
 440   /* We would have to include <limits.h> to get a definition of MB_LEN_MAX.
 441      But this would only disturb the namespace.  So we define our own
 442      version here.  */
 443 #define __WCHAR_MB_LEN_MAX      16
 444 #if defined MB_LEN_MAX && MB_LEN_MAX != __WCHAR_MB_LEN_MAX
 445 # error "Assumed value of MB_LEN_MAX wrong"
 446 #endif
 447   if (__bos (__s) != (size_t) -1 && __WCHAR_MB_LEN_MAX > __bos (__s))
 448     return __wcrtomb_chk (__s, __wchar, __ps, __bos (__s));
 449   return __wcrtomb_alias (__s, __wchar, __ps);
 450 }
 451
 452
 453 extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
 454                                __const char **__restrict __src,
 455                                size_t __len, mbstate_t *__restrict __ps,
 456                                size_t __dstlen) __THROW;
 457 extern size_t __REDIRECT_NTH (__mbsrtowcs_alias,
 458                               (wchar_t *__restrict __dst,
 459                                __const char **__restrict __src,
 460                                size_t __len, mbstate_t *__restrict __ps),
 461                               mbsrtowcs);
 462 extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn,
 463                               (wchar_t *__restrict __dst,
 464                                __const char **__restrict __src,
 465                                size_t __len, mbstate_t *__restrict __ps,
 466                                size_t __dstlen), __mbsrtowcs_chk)
 467      __warnattr ("mbsrtowcs called with dst buffer smaller than len "
 468                  "* sizeof (wchar_t)");
 469
 470 __extern_always_inline size_t
 471 __NTH (mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,
 472                   size_t __len, mbstate_t *__restrict __ps))
 473 {
 474   if (__bos (__dst) != (size_t) -1)
 475     {
 476       if (!__builtin_constant_p (__len))
 477         return __mbsrtowcs_chk (__dst, __src, __len, __ps,
 478                                 __bos (__dst) / sizeof (wchar_t));
 479
 480       if (__len > __bos (__dst) / sizeof (wchar_t))
 481         return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
 482                                      __bos (__dst) / sizeof (wchar_t));
 483     }
 484   return __mbsrtowcs_alias (__dst, __src, __len, __ps);
 485 }
 486
 487
 488 extern size_t __wcsrtombs_chk (char *__restrict __dst,
 489                                __const wchar_t **__restrict __src,
 490                                size_t __len, mbstate_t *__restrict __ps,
 491                                size_t __dstlen) __THROW;
 492 extern size_t __REDIRECT_NTH (__wcsrtombs_alias,
 493                               (char *__restrict __dst,
 494                                __const wchar_t **__restrict __src,
 495                                size_t __len, mbstate_t *__restrict __ps),
 496                               wcsrtombs);
 497 extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn,
 498                               (char *__restrict __dst,
 499                                __const wchar_t **__restrict __src,
 500                                size_t __len, mbstate_t *__restrict __ps,
 501                                size_t __dstlen), __wcsrtombs_chk)
 502     __warnattr ("wcsrtombs called with dst buffer smaller than len");
 503
 504 __extern_always_inline size_t
 505 __NTH (wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,
 506                   size_t __len, mbstate_t *__restrict __ps))
 507 {
 508   if (__bos (__dst) != (size_t) -1)
 509     {
 510       if (!__builtin_constant_p (__len))
 511         return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst));
 512
 513       if (__len > __bos (__dst))
 514         return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __bos (__dst));
 515     }
 516   return __wcsrtombs_alias (__dst, __src, __len, __ps);
 517 }
 518
 519
 520 #ifdef __USE_GNU
 521 extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
 522                                 __const char **__restrict __src, size_t __nmc,
 523                                 size_t __len, mbstate_t *__restrict __ps,
 524                                 size_t __dstlen) __THROW;
 525 extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias,
 526                               (wchar_t *__restrict __dst,
 527                                __const char **__restrict __src, size_t __nmc,
 528                                size_t __len, mbstate_t *__restrict __ps),
 529                               mbsnrtowcs);
 530 extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn,
 531                               (wchar_t *__restrict __dst,
 532                                __const char **__restrict __src, size_t __nmc,
 533                                size_t __len, mbstate_t *__restrict __ps,
 534                                size_t __dstlen), __mbsnrtowcs_chk)
 535      __warnattr ("mbsnrtowcs called with dst buffer smaller than len "
 536                  "* sizeof (wchar_t)");
 537
 538 __extern_always_inline size_t
 539 __NTH (mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,
 540                    size_t __nmc, size_t __len, mbstate_t *__restrict __ps))
 541 {
 542   if (__bos (__dst) != (size_t) -1)
 543     {
 544       if (!__builtin_constant_p (__len))
 545         return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
 546                                  __bos (__dst) / sizeof (wchar_t));
 547
 548       if (__len > __bos (__dst) / sizeof (wchar_t))
 549         return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
 550                                       __bos (__dst) / sizeof (wchar_t));
 551     }
 552   return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
 553 }
 554
 555
 556 extern size_t __wcsnrtombs_chk (char *__restrict __dst,
 557                                 __const wchar_t **__restrict __src,
 558                                 size_t __nwc, size_t __len,
 559                                 mbstate_t *__restrict __ps, size_t __dstlen)
 560      __THROW;
 561 extern size_t __REDIRECT_NTH (__wcsnrtombs_alias,
 562                               (char *__restrict __dst,
 563                                __const wchar_t **__restrict __src,
 564                                size_t __nwc, size_t __len,
 565                                mbstate_t *__restrict __ps), wcsnrtombs);
 566 extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn,
 567                               (char *__restrict __dst,
 568                                __const wchar_t **__restrict __src,
 569                                size_t __nwc, size_t __len,
 570                                mbstate_t *__restrict __ps,
 571                                size_t __dstlen), __wcsnrtombs_chk)
 572      __warnattr ("wcsnrtombs called with dst buffer smaller than len");
 573
 574 __extern_always_inline size_t
 575 __NTH (wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,
 576                    size_t __nwc, size_t __len, mbstate_t *__restrict __ps))
 577 {
 578   if (__bos (__dst) != (size_t) -1)
 579     {
 580       if (!__builtin_constant_p (__len))
 581         return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
 582                                  __bos (__dst));
 583
 584       if (__len > __bos (__dst))
 585         return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
 586                                       __bos (__dst));
 587     }
 588   return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
 589 }
 590 #endif