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
25extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
26			       __const wchar_t *__restrict __s2, size_t __n,
27			       size_t __ns1) __THROW;
28extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias,
29				(wchar_t *__restrict __s1,
30				 __const wchar_t *__restrict __s2, size_t __n),
31				wmemcpy);
32extern 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
57extern wchar_t *__wmemmove_chk (wchar_t *__s1, __const wchar_t *__s2,
58				size_t __n, size_t __ns1) __THROW;
59extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1,
60						   __const wchar_t *__s2,
61						   size_t __n), wmemmove);
62extern 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
88extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
89				__const wchar_t *__restrict __s2, size_t __n,
90				size_t __ns1) __THROW;
91extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias,
92				(wchar_t *__restrict __s1,
93				 __const wchar_t *__restrict __s2,
94				 size_t __n), wmempcpy);
95extern 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
121extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
122			       size_t __ns) __THROW;
123extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c,
124						  size_t __n), wmemset);
125extern 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
147extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
148			      __const wchar_t *__restrict __src,
149			      size_t __n) __THROW;
150extern 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
163extern wchar_t *__wcpcpy_chk (wchar_t *__dest, __const wchar_t *__src,
164			      size_t __destlen) __THROW;
165extern 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
178extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
179			       __const wchar_t *__restrict __src, size_t __n,
180			       size_t __destlen) __THROW;
181extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias,
182				(wchar_t *__restrict __dest,
183				 __const wchar_t *__restrict __src,
184				 size_t __n), wcsncpy);
185extern 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
208extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
209			       __const wchar_t *__restrict __src, size_t __n,
210			       size_t __destlen) __THROW;
211extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias,
212				(wchar_t *__restrict __dest,
213				 __const wchar_t *__restrict __src,
214				 size_t __n), wcpncpy);
215extern 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
238extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
239			      __const wchar_t *__restrict __src,
240			      size_t __destlen) __THROW;
241extern 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
254extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
255			       __const wchar_t *__restrict __src,
256			       size_t __n, size_t __destlen) __THROW;
257extern 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
272extern 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
277extern 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
302extern 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
308extern 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
326extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
327			   __const wchar_t *__restrict __format, ...);
328extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
329			  ...);
330extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
331			    __const wchar_t *__restrict __format,
332			    __gnuc_va_list __ap);
333extern 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
338wprintf (__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
344fwprintf (__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
357vwprintf (__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
363vfwprintf (__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
371extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
372			      __FILE *__restrict __stream) __wur;
373extern wchar_t *__REDIRECT (__fgetws_alias,
374			    (wchar_t *__restrict __s, int __n,
375			     __FILE *__restrict __stream), fgetws) __wur;
376extern 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 *
383fgetws (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
399extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
400				       int __n, __FILE *__restrict __stream)
401  __wur;
402extern wchar_t *__REDIRECT (__fgetws_unlocked_alias,
403			    (wchar_t *__restrict __s, int __n,
404			     __FILE *__restrict __stream), fgetws_unlocked)
405  __wur;
406extern 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 *
414fgetws_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
431extern size_t __wcrtomb_chk (char *__s, wchar_t __wchar, mbstate_t *__p,
432			  size_t __buflen) __THROW __wur;
433extern 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
453extern 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;
457extern 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);
462extern 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
488extern 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;
492extern 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);
497extern 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
521extern 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;
525extern 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);
530extern 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
556extern 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;
561extern 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);
566extern 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
591