---

---

---

001: /* Checking macros for wchar functions.
002:    Copyright (C) 2005, 2006, 2007, 2010 Free Software Foundation, Inc.
003:    This file is part of the GNU C Library.
004: 
005:    The GNU C Library is free software; you can redistribute it and/or
006:    modify it under the terms of the GNU Lesser General Public
007:    License as published by the Free Software Foundation; either
008:    version 2.1 of the License, or (at your option) any later version.
009: 
010:    The GNU C Library is distributed in the hope that it will be useful,
011:    but WITHOUT ANY WARRANTY; without even the implied warranty of
012:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
013:    Lesser General Public License for more details.
014: 
015:    You should have received a copy of the GNU Lesser General Public
016:    License along with the GNU C Library; if not, write to the Free
017:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
018:    02111-1307 USA.  */
019: 
020: #ifndef _WCHAR_H
021: # error "Never include <bits/wchar2.h> directly; use <wchar.h> instead."
022: #endif
023: 
024: 
025: extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
026:                                __const wchar_t *__restrict __s2, size_t __n,
027:                                size_t __ns1) __THROW;
028: extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias,
029:                                 (wchar_t *__restrict __s1,
030:                                  __const wchar_t *__restrict __s2, size_t __n),
031:                                 wmemcpy);
032: extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn,
033:                                 (wchar_t *__restrict __s1,
034:                                  __const wchar_t *__restrict __s2, size_t __n,
035:                                  size_t __ns1), __wmemcpy_chk)
036:      __warnattr ("wmemcpy called with length bigger than size of destination "
037:                  "buffer");
038: 
039: __extern_always_inline wchar_t *
040: __NTH (wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
041:                 size_t __n))
042: {
043:   if (__bos0 (__s1) != (size_t) -1)
044:     {
045:       if (!__builtin_constant_p (__n))
046:         return __wmemcpy_chk (__s1, __s2, __n,
047:                               __bos0 (__s1) / sizeof (wchar_t));
048: 
049:       if (__n > __bos0 (__s1) / sizeof (wchar_t))
050:         return __wmemcpy_chk_warn (__s1, __s2, __n,
051:                                    __bos0 (__s1) / sizeof (wchar_t));
052:     }
053:   return __wmemcpy_alias (__s1, __s2, __n);
054: }
055: 
056: 
057: extern wchar_t *__wmemmove_chk (wchar_t *__s1, __const wchar_t *__s2,
058:                                 size_t __n, size_t __ns1) __THROW;
059: extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1,
060:                                                    __const wchar_t *__s2,
061:                                                    size_t __n), wmemmove);
062: extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn,
063:                                 (wchar_t *__s1, __const wchar_t *__s2,
064:                                  size_t __n, size_t __ns1), __wmemmove_chk)
065:      __warnattr ("wmemmove called with length bigger than size of destination "
066:                  "buffer");
067: 
068: __extern_always_inline wchar_t *
069: __NTH (wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n))
070: {
071:   if (__bos0 (__s1) != (size_t) -1)
072:     {
073:       if (!__builtin_constant_p (__n))
074:         return __wmemmove_chk (__s1, __s2, __n,
075:                                __bos0 (__s1) / sizeof (wchar_t));
076: 
077:       if (__n > __bos0 (__s1) / sizeof (wchar_t))
078:         return __wmemmove_chk_warn (__s1, __s2, __n,
079:                                     __bos0 (__s1) / sizeof (wchar_t));
080:     }
081:   return __wmemmove_alias (__s1, __s2, __n);
082: }
083: 
084: 
085: #ifdef __USE_GNU
086: extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
087:                                 __const wchar_t *__restrict __s2, size_t __n,
088:                                 size_t __ns1) __THROW;
089: extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias,
090:                                 (wchar_t *__restrict __s1,
091:                                  __const wchar_t *__restrict __s2,
092:                                  size_t __n), wmempcpy);
093: extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn,
094:                                 (wchar_t *__restrict __s1,
095:                                  __const wchar_t *__restrict __s2, size_t __n,
096:                                  size_t __ns1), __wmempcpy_chk)
097:      __warnattr ("wmempcpy called with length bigger than size of destination "
098:                  "buffer");
099: 
100: __extern_always_inline wchar_t *
101: __NTH (wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
102:                  size_t __n))
103: {
104:   if (__bos0 (__s1) != (size_t) -1)
105:     {
106:       if (!__builtin_constant_p (__n))
107:         return __wmempcpy_chk (__s1, __s2, __n,
108:                                __bos0 (__s1) / sizeof (wchar_t));
109: 
110:       if (__n > __bos0 (__s1) / sizeof (wchar_t))
111:         return __wmempcpy_chk_warn (__s1, __s2, __n,
112:                                     __bos0 (__s1) / sizeof (wchar_t));
113:     }
114:   return __wmempcpy_alias (__s1, __s2, __n);
115: }
116: #endif
117: 
118: 
119: extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
120:                                size_t __ns) __THROW;
121: extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c,
122:                                                   size_t __n), wmemset);
123: extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn,
124:                                 (wchar_t *__s, wchar_t __c, size_t __n,
125:                                  size_t __ns), __wmemset_chk)
126:      __warnattr ("wmemset called with length bigger than size of destination "
127:                  "buffer");
128: 
129: __extern_always_inline wchar_t *
130: __NTH (wmemset (wchar_t *__s, wchar_t __c, size_t __n))
131: {
132:   if (__bos0 (__s) != (size_t) -1)
133:     {
134:       if (!__builtin_constant_p (__n))
135:         return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t));
136: 
137:       if (__n > __bos0 (__s) / sizeof (wchar_t))
138:         return __wmemset_chk_warn (__s, __c, __n,
139:                                    __bos0 (__s) / sizeof (wchar_t));
140:     }
141:   return __wmemset_alias (__s, __c, __n);
142: }
143: 
144: 
145: extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
146:                               __const wchar_t *__restrict __src,
147:                               size_t __n) __THROW;
148: extern wchar_t *__REDIRECT_NTH (__wcscpy_alias,
149:                                 (wchar_t *__restrict __dest,
150:                                  __const wchar_t *__restrict __src), wcscpy);
151: 
152: __extern_always_inline wchar_t *
153: __NTH (wcscpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src))
154: {
155:   if (__bos (__dest) != (size_t) -1)
156:     return __wcscpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
157:   return __wcscpy_alias (__dest, __src);
158: }
159: 
160: 
161: extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest,
162:                               __const wchar_t *__restrict __src,
163:                               size_t __destlen) __THROW;
164: extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias,
165:                                 (wchar_t *__restrict __dest,
166:                                  __const wchar_t *__restrict __src), wcpcpy);
167: 
168: __extern_always_inline wchar_t *
169: __NTH (wcpcpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src))
170: {
171:   if (__bos (__dest) != (size_t) -1)
172:     return __wcpcpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
173:   return __wcpcpy_alias (__dest, __src);
174: }
175: 
176: 
177: extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
178:                                __const wchar_t *__restrict __src, size_t __n,
179:                                size_t __destlen) __THROW;
180: extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias,
181:                                 (wchar_t *__restrict __dest,
182:                                  __const wchar_t *__restrict __src,
183:                                  size_t __n), wcsncpy);
184: extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn,
185:                                 (wchar_t *__restrict __dest,
186:                                  __const wchar_t *__restrict __src,
187:                                  size_t __n, size_t __destlen), __wcsncpy_chk)
188:      __warnattr ("wcsncpy called with length bigger than size of destination "
189:                  "buffer");
190: 
191: __extern_always_inline wchar_t *
192: __NTH (wcsncpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src,
193:                 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 *__restrict __dest, __const wchar_t *__restrict __src,
224:                 size_t __n))
225: {
226:   if (__bos (__dest) != (size_t) -1)
227:     {
228:       if (!__builtin_constant_p (__n))
229:         return __wcpncpy_chk (__dest, __src, __n,
230:                               __bos (__dest) / sizeof (wchar_t));
231:       if (__n > __bos (__dest) / sizeof (wchar_t))
232:         return __wcpncpy_chk_warn (__dest, __src, __n,
233:                                    __bos (__dest) / sizeof (wchar_t));
234:     }
235:   return __wcpncpy_alias (__dest, __src, __n);
236: }
237: 
238: 
239: extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
240:                               __const wchar_t *__restrict __src,
241:                               size_t __destlen) __THROW;
242: extern wchar_t *__REDIRECT_NTH (__wcscat_alias,
243:                                 (wchar_t *__restrict __dest,
244:                                  __const wchar_t *__restrict __src), wcscat);
245: 
246: __extern_always_inline wchar_t *
247: __NTH (wcscat (wchar_t *__restrict __dest, __const wchar_t *__restrict __src))
248: {
249:   if (__bos (__dest) != (size_t) -1)
250:     return __wcscat_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
251:   return __wcscat_alias (__dest, __src);
252: }
253: 
254: 
255: extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
256:                                __const wchar_t *__restrict __src,
257:                                size_t __n, size_t __destlen) __THROW;
258: extern wchar_t *__REDIRECT_NTH (__wcsncat_alias,
259:                                 (wchar_t *__restrict __dest,
260:                                  __const wchar_t *__restrict __src,
261:                                  size_t __n), wcsncat);
262: 
263: __extern_always_inline wchar_t *
264: __NTH (wcsncat (wchar_t *__restrict __dest, __const wchar_t *__restrict __src,
265:                 size_t __n))
266: {
267:   if (__bos (__dest) != (size_t) -1)
268:     return __wcsncat_chk (__dest, __src, __n,
269:                           __bos (__dest) / sizeof (wchar_t));
270:   return __wcsncat_alias (__dest, __src, __n);
271: }
272: 
273: 
274: extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
275:                            int __flag, size_t __s_len,
276:                            __const wchar_t *__restrict __format, ...)
277:      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 6))) */;
278: 
279: extern int __REDIRECT_NTH_LDBL (__swprintf_alias,
280:                                 (wchar_t *__restrict __s, size_t __n,
281:                                  __const wchar_t *__restrict __fmt, ...),
282:                                 swprintf);
283: 
284: #ifdef __va_arg_pack
285: __extern_always_inline int
286: __NTH (swprintf (wchar_t *__restrict __s, size_t __n,
287:                  __const wchar_t *__restrict __fmt, ...))
288: {
289:   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
290:     return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
291:                            __bos (__s) / sizeof (wchar_t),
292:                            __fmt, __va_arg_pack ());
293:   return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
294: }
295: #elif !defined __cplusplus
296: /* XXX We might want to have support in gcc for swprintf.  */
297: # define swprintf(s, n, ...) \
298:   (__bos (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1                        \
299:    ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1,                           \
300:                      __bos (s) / sizeof (wchar_t), __VA_ARGS__)               \
301:    : swprintf (s, n, __VA_ARGS__))
302: #endif
303: 
304: extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
305:                             int __flag, size_t __s_len,
306:                             __const wchar_t *__restrict __format,
307:                             __gnuc_va_list __arg)
308:      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */;
309: 
310: extern int __REDIRECT_NTH_LDBL (__vswprintf_alias,
311:                                 (wchar_t *__restrict __s, size_t __n,
312:                                  __const wchar_t *__restrict __fmt,
313:                                  __gnuc_va_list __ap), vswprintf);
314: 
315: __extern_always_inline int
316: __NTH (vswprintf (wchar_t *__restrict __s, size_t __n,
317:                   __const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
318: {
319:   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
320:     return __vswprintf_chk (__s, __n,  __USE_FORTIFY_LEVEL - 1,
321:                             __bos (__s) / sizeof (wchar_t), __fmt, __ap);
322:   return __vswprintf_alias (__s, __n, __fmt, __ap);
323: }
324: 
325: 
326: #if __USE_FORTIFY_LEVEL > 1
327: 
328: extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
329:                            __const wchar_t *__restrict __format, ...);
330: extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
331:                           ...);
332: extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
333:                             __const wchar_t *__restrict __format,
334:                             __gnuc_va_list __ap);
335: extern int __vwprintf_chk (int __flag, __const wchar_t *__restrict __format,
336:                            __gnuc_va_list __ap);
337: 
338: # ifdef __va_arg_pack
339: __extern_always_inline int
340: wprintf (__const wchar_t *__restrict __fmt, ...)
341: {
342:   return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ());
343: }
344: 
345: __extern_always_inline int
346: fwprintf (__FILE *__restrict __stream, __const wchar_t *__restrict __fmt, ...)
347: {
348:   return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt,
349:                          __va_arg_pack ());
350: }
351: # elif !defined __cplusplus
352: #  define wprintf(...) \
353:   __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
354: #  define fwprintf(stream, ...) \
355:   __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
356: # endif
357: 
358: __extern_always_inline int
359: vwprintf (__const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
360: {
361:   return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap);
362: }
363: 
364: __extern_always_inline int
365: vfwprintf (__FILE *__restrict __stream,
366:            __const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
367: {
368:   return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap);
369: }
370: 
371: #endif
372: 
373: extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
374:                               __FILE *__restrict __stream) __wur;
375: extern wchar_t *__REDIRECT (__fgetws_alias,
376:                             (wchar_t *__restrict __s, int __n,
377:                              __FILE *__restrict __stream), fgetws) __wur;
378: extern wchar_t *__REDIRECT (__fgetws_chk_warn,
379:                             (wchar_t *__restrict __s, size_t __size, int __n,
380:                              __FILE *__restrict __stream), __fgetws_chk)
381:      __wur __warnattr ("fgetws called with bigger size than length "
382:                        "of destination buffer");
383: 
384: __extern_always_inline __wur wchar_t *
385: fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
386: {
387:   if (__bos (__s) != (size_t) -1)
388:     {
389:       if (!__builtin_constant_p (__n) || __n <= 0)
390:         return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t),
391:                              __n, __stream);
392: 
393:       if ((size_t) __n > __bos (__s) / sizeof (wchar_t))
394:         return __fgetws_chk_warn (__s, __bos (__s) / sizeof (wchar_t),
395:                                   __n, __stream);
396:     }
397:   return __fgetws_alias (__s, __n, __stream);
398: }
399: 
400: #ifdef __USE_GNU
401: extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
402:                                        int __n, __FILE *__restrict __stream)
403:   __wur;
404: extern wchar_t *__REDIRECT (__fgetws_unlocked_alias,
405:                             (wchar_t *__restrict __s, int __n,
406:                              __FILE *__restrict __stream), fgetws_unlocked)
407:   __wur;
408: extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn,
409:                             (wchar_t *__restrict __s, size_t __size, int __n,
410:                              __FILE *__restrict __stream),
411:                             __fgetws_unlocked_chk)
412:      __wur __warnattr ("fgetws_unlocked called with bigger size than length "
413:                        "of destination buffer");
414: 
415: __extern_always_inline __wur wchar_t *
416: fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
417: {
418:   if (__bos (__s) != (size_t) -1)
419:     {
420:       if (!__builtin_constant_p (__n) || __n <= 0)
421:         return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t),
422:                                       __n, __stream);
423: 
424:       if ((size_t) __n > __bos (__s) / sizeof (wchar_t))
425:         return __fgetws_unlocked_chk_warn (__s, __bos (__s) / sizeof (wchar_t),
426:                                            __n, __stream);
427:     }
428:   return __fgetws_unlocked_alias (__s, __n, __stream);
429: }
430: #endif
431: 
432: 
433: extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar,
434:                              mbstate_t *__restrict __p,
435:                              size_t __buflen) __THROW __wur;
436: extern size_t __REDIRECT_NTH (__wcrtomb_alias,
437:                               (char *__restrict __s, wchar_t __wchar,
438:                                mbstate_t *__restrict __ps), wcrtomb) __wur;
439: 
440: __extern_always_inline __wur size_t
441: __NTH (wcrtomb (char *__restrict __s, wchar_t __wchar,
442:                 mbstate_t *__restrict __ps))
443: {
444:   /* We would have to include <limits.h> to get a definition of MB_LEN_MAX.
445:      But this would only disturb the namespace.  So we define our own
446:      version here.  */
447: #define __WCHAR_MB_LEN_MAX      16
448: #if defined MB_LEN_MAX && MB_LEN_MAX != __WCHAR_MB_LEN_MAX
449: # error "Assumed value of MB_LEN_MAX wrong"
450: #endif
451:   if (__bos (__s) != (size_t) -1 && __WCHAR_MB_LEN_MAX > __bos (__s))
452:     return __wcrtomb_chk (__s, __wchar, __ps, __bos (__s));
453:   return __wcrtomb_alias (__s, __wchar, __ps);
454: }
455: 
456: 
457: extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
458:                                __const char **__restrict __src,
459:                                size_t __len, mbstate_t *__restrict __ps,
460:                                size_t __dstlen) __THROW;
461: extern size_t __REDIRECT_NTH (__mbsrtowcs_alias,
462:                               (wchar_t *__restrict __dst,
463:                                __const char **__restrict __src,
464:                                size_t __len, mbstate_t *__restrict __ps),
465:                               mbsrtowcs);
466: extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn,
467:                               (wchar_t *__restrict __dst,
468:                                __const char **__restrict __src,
469:                                size_t __len, mbstate_t *__restrict __ps,
470:                                size_t __dstlen), __mbsrtowcs_chk)
471:      __warnattr ("mbsrtowcs called with dst buffer smaller than len "
472:                  "* sizeof (wchar_t)");
473: 
474: __extern_always_inline size_t
475: __NTH (mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,
476:                   size_t __len, mbstate_t *__restrict __ps))
477: {
478:   if (__bos (__dst) != (size_t) -1)
479:     {
480:       if (!__builtin_constant_p (__len))
481:         return __mbsrtowcs_chk (__dst, __src, __len, __ps,
482:                                 __bos (__dst) / sizeof (wchar_t));
483: 
484:       if (__len > __bos (__dst) / sizeof (wchar_t))
485:         return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
486:                                      __bos (__dst) / sizeof (wchar_t));
487:     }
488:   return __mbsrtowcs_alias (__dst, __src, __len, __ps);
489: }
490: 
491: 
492: extern size_t __wcsrtombs_chk (char *__restrict __dst,
493:                                __const wchar_t **__restrict __src,
494:                                size_t __len, mbstate_t *__restrict __ps,
495:                                size_t __dstlen) __THROW;
496: extern size_t __REDIRECT_NTH (__wcsrtombs_alias,
497:                               (char *__restrict __dst,
498:                                __const wchar_t **__restrict __src,
499:                                size_t __len, mbstate_t *__restrict __ps),
500:                               wcsrtombs);
501: extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn,
502:                               (char *__restrict __dst,
503:                                __const wchar_t **__restrict __src,
504:                                size_t __len, mbstate_t *__restrict __ps,
505:                                size_t __dstlen), __wcsrtombs_chk)
506:     __warnattr ("wcsrtombs called with dst buffer smaller than len");
507: 
508: __extern_always_inline size_t
509: __NTH (wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,
510:                   size_t __len, mbstate_t *__restrict __ps))
511: {
512:   if (__bos (__dst) != (size_t) -1)
513:     {
514:       if (!__builtin_constant_p (__len))
515:         return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst));
516: 
517:       if (__len > __bos (__dst))
518:         return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __bos (__dst));
519:     }
520:   return __wcsrtombs_alias (__dst, __src, __len, __ps);
521: }
522: 
523: 
524: #ifdef __USE_GNU
525: extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
526:                                 __const char **__restrict __src, size_t __nmc,
527:                                 size_t __len, mbstate_t *__restrict __ps,
528:                                 size_t __dstlen) __THROW;
529: extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias,
530:                               (wchar_t *__restrict __dst,
531:                                __const char **__restrict __src, size_t __nmc,
532:                                size_t __len, mbstate_t *__restrict __ps),
533:                               mbsnrtowcs);
534: extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn,
535:                               (wchar_t *__restrict __dst,
536:                                __const char **__restrict __src, size_t __nmc,
537:                                size_t __len, mbstate_t *__restrict __ps,
538:                                size_t __dstlen), __mbsnrtowcs_chk)
539:      __warnattr ("mbsnrtowcs called with dst buffer smaller than len "
540:                  "* sizeof (wchar_t)");
541: 
542: __extern_always_inline size_t
543: __NTH (mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,
544:                    size_t __nmc, size_t __len, mbstate_t *__restrict __ps))
545: {
546:   if (__bos (__dst) != (size_t) -1)
547:     {
548:       if (!__builtin_constant_p (__len))
549:         return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
550:                                  __bos (__dst) / sizeof (wchar_t));
551: 
552:       if (__len > __bos (__dst) / sizeof (wchar_t))
553:         return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
554:                                       __bos (__dst) / sizeof (wchar_t));
555:     }
556:   return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
557: }
558: 
559: 
560: extern size_t __wcsnrtombs_chk (char *__restrict __dst,
561:                                 __const wchar_t **__restrict __src,
562:                                 size_t __nwc, size_t __len,
563:                                 mbstate_t *__restrict __ps, size_t __dstlen)
564:      __THROW;
565: extern size_t __REDIRECT_NTH (__wcsnrtombs_alias,
566:                               (char *__restrict __dst,
567:                                __const wchar_t **__restrict __src,
568:                                size_t __nwc, size_t __len,
569:                                mbstate_t *__restrict __ps), wcsnrtombs);
570: extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn,
571:                               (char *__restrict __dst,
572:                                __const wchar_t **__restrict __src,
573:                                size_t __nwc, size_t __len,
574:                                mbstate_t *__restrict __ps,
575:                                size_t __dstlen), __wcsnrtombs_chk)
576:      __warnattr ("wcsnrtombs called with dst buffer smaller than len");
577: 
578: __extern_always_inline size_t
579: __NTH (wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,
580:                    size_t __nwc, size_t __len, mbstate_t *__restrict __ps))
581: {
582:   if (__bos (__dst) != (size_t) -1)
583:     {
584:       if (!__builtin_constant_p (__len))
585:         return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
586:                                  __bos (__dst));
587: 
588:       if (__len > __bos (__dst))
589:         return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
590:                                       __bos (__dst));
591:     }
592:   return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
593: }
594: #endif
595: 

---

---

---