[thirdparty/glibc.git] / wcsmbs / bits / wchar2.h

/* Checking macros for wchar functions.
   Copyright (C) 2005-2025 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

#ifndef _WCHAR_H
# error "Never include <bits/wchar2.h> directly; use <wchar.h> instead."
#endif

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wmemcpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __s1),
		const wchar_t *__restrict __s2, size_t __n))
     __fortify_clang_warning_only_if_bos0_lt2 (__n, __s1, sizeof (wchar_t),
					       "wmemcpy called with length bigger "
					       "than size of destination buffer")
{
  return __glibc_fortify_n (wmemcpy, __n, sizeof (wchar_t),
			    __glibc_objsize0 (__s1),
			    __s1, __s2, __n);
}

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wmemmove (__fortify_clang_overload_arg (wchar_t *, ,__s1),
		 const wchar_t *__s2, size_t __n))
     __fortify_clang_warning_only_if_bos0_lt2 (__n, __s1, sizeof (wchar_t),
					       "wmemmove called with length bigger "
					       "than size of destination buffer")
{
  return __glibc_fortify_n (wmemmove, __n, sizeof (wchar_t),
			    __glibc_objsize0 (__s1),
			    __s1, __s2, __n);
}

#ifdef __USE_GNU
__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wmempcpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __s1),
		 const wchar_t *__restrict __s2, size_t __n))
     __fortify_clang_warning_only_if_bos0_lt2 (__n, __s1, sizeof (wchar_t),
					       "wmempcpy called with length bigger "
					       "than size of destination buffer")
{
  return __glibc_fortify_n (wmempcpy, __n, sizeof (wchar_t),
			    __glibc_objsize0 (__s1),
			    __s1, __s2, __n);
}
#endif

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wmemset (__fortify_clang_overload_arg (wchar_t *, ,__s), wchar_t __c,
		size_t __n))
     __fortify_clang_warning_only_if_bos0_lt2 (__n, __s, sizeof (wchar_t),
					       "wmemset called with length bigger "
					       "than size of destination buffer")
{
  return __glibc_fortify_n (wmemset, __n, sizeof (wchar_t),
			    __glibc_objsize0 (__s),
			    __s, __c, __n);
}

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wcscpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	       const wchar_t *__restrict __src))
{
  size_t __sz = __glibc_objsize (__dest);
  if (__sz != (size_t) -1)
    return __wcscpy_chk (__dest, __src, __sz / sizeof (wchar_t));
  return __wcscpy_alias (__dest, __src);
}

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wcpcpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	       const wchar_t *__restrict __src))
{
  size_t __sz = __glibc_objsize (__dest);
  if (__sz != (size_t) -1)
    return __wcpcpy_chk (__dest, __src, __sz / sizeof (wchar_t));
  return __wcpcpy_alias (__dest, __src);
}

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wcsncpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
		const wchar_t *__restrict __src, size_t __n))
     __fortify_clang_warning_only_if_bos0_lt2 (__n, __dest, sizeof (wchar_t),
					       "wcsncpy called with length bigger "
					       "than size of destination buffer")
{
  return __glibc_fortify_n (wcsncpy, __n, sizeof (wchar_t),
			    __glibc_objsize (__dest),
			    __dest, __src, __n);
}

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wcpncpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
		const wchar_t *__restrict __src, size_t __n))
     __fortify_clang_warning_only_if_bos0_lt2 (__n, __dest, sizeof (wchar_t),
					       "wcpncpy called with length bigger "
					       "than size of destination buffer")
{
  return __glibc_fortify_n (wcpncpy, __n, sizeof (wchar_t),
			    __glibc_objsize (__dest),
			    __dest, __src, __n);
}

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wcscat (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	       const wchar_t *__restrict __src))
{
  size_t __sz = __glibc_objsize (__dest);
  if (__sz != (size_t) -1)
    return __wcscat_chk (__dest, __src, __sz / sizeof (wchar_t));
  return __wcscat_alias (__dest, __src);
}

__fortify_function __attribute_overloadable__ wchar_t *
__NTH (wcsncat (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	       const wchar_t *__restrict __src, size_t __n))
{
  size_t __sz = __glibc_objsize (__dest);
  if (__sz != (size_t) -1)
    return __wcsncat_chk (__dest, __src, __n, __sz / sizeof (wchar_t));
  return __wcsncat_alias (__dest, __src, __n);
}

#ifdef __USE_MISC
__fortify_function __attribute_overloadable__ size_t
__NTH (wcslcpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
		const wchar_t *__restrict __src, size_t __n))
     __fortify_clang_warning_only_if_bos0_lt2 (__n, __dest, sizeof (wchar_t),
					       "wcslcpy called with length bigger "
					       "than size of destination buffer")
{
  if (__glibc_objsize (__dest) != (size_t) -1
      && (!__builtin_constant_p (__n
				 > __glibc_objsize (__dest) / sizeof (wchar_t))
	  || __n > __glibc_objsize (__dest) / sizeof (wchar_t)))
    return __wcslcpy_chk (__dest, __src, __n,
			  __glibc_objsize (__dest) / sizeof (wchar_t));
  return __wcslcpy_alias (__dest, __src, __n);
}

__fortify_function __attribute_overloadable__ size_t
__NTH (wcslcat (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
		const wchar_t *__restrict __src, size_t __n))
{
  if (__glibc_objsize (__dest) != (size_t) -1
      && (!__builtin_constant_p (__n > __glibc_objsize (__dest)
				 / sizeof (wchar_t))
	  || __n > __glibc_objsize (__dest) / sizeof (wchar_t)))
    return __wcslcat_chk (__dest, __src, __n,
			  __glibc_objsize (__dest) / sizeof (wchar_t));
  return __wcslcat_alias (__dest, __src, __n);
}
#endif /* __USE_MISC */

#ifdef __va_arg_pack
__fortify_function int
__NTH (swprintf (wchar_t *__restrict __s, size_t __n,
		 const wchar_t *__restrict __fmt, ...))
{
  size_t __sz = __glibc_objsize (__s);
  if (__sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
    return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
			   __sz / sizeof (wchar_t), __fmt, __va_arg_pack ());
  return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
}
#elif __fortify_use_clang
__fortify_function_error_function __attribute_overloadable__ int
__NTH (swprintf (__fortify_clang_overload_arg (wchar_t *, __restrict, __s),
		 size_t __n, const wchar_t *__restrict __fmt, ...))
{
  __gnuc_va_list __fortify_ap;
  __builtin_va_start (__fortify_ap, __fmt);
  int __r;
  if (__glibc_objsize (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
    __r = __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
			   __glibc_objsize (__s) / sizeof (wchar_t),
			   __fmt, __fortify_ap);
  else
    __r = __vswprintf_alias (__s, __n, __fmt, __fortify_ap);
  __builtin_va_end (__fortify_ap);
  return __r;
}
#elif !defined __cplusplus
/* XXX We might want to have support in gcc for swprintf.  */
# define swprintf(s, n, ...) \
  (__glibc_objsize (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1		      \
   ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1,			      \
		     __glibc_objsize (s) / sizeof (wchar_t), __VA_ARGS__)	      \
   : swprintf (s, n, __VA_ARGS__))
#endif

__fortify_function int
__NTH (vswprintf (wchar_t *__restrict __s, size_t __n,
		  const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
{
  size_t __sz = __glibc_objsize (__s);
  if (__sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
    return __vswprintf_chk (__s, __n,  __USE_FORTIFY_LEVEL - 1,
			    __sz / sizeof (wchar_t), __fmt, __ap);
  return __vswprintf_alias (__s, __n, __fmt, __ap);
}


#if __USE_FORTIFY_LEVEL > 1

# ifdef __va_arg_pack
__fortify_function int
wprintf (const wchar_t *__restrict __fmt, ...)
{
  return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ());
}

__fortify_function int
fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...)
{
  return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt,
			 __va_arg_pack ());
}
# elif !defined __cplusplus
#  define wprintf(...) \
  __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
#  define fwprintf(stream, ...) \
  __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
# endif

__fortify_function int
vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap);
}

__fortify_function int
vfwprintf (__FILE *__restrict __stream,
	   const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap);
}

#endif
__fortify_function __attribute_overloadable__ __wur wchar_t *
fgetws (__fortify_clang_overload_arg (wchar_t *, __restrict, __s), int __n,
	__FILE *__restrict __stream)
     __fortify_clang_warning_only_if_bos_lt2 (__n, __s, sizeof (wchar_t),
					      "fgetws called with length bigger "
					      "than size of destination buffer")
{
  size_t __sz = __glibc_objsize (__s);
  if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), __sz))
    return __fgetws_alias (__s, __n, __stream);
#if !__fortify_use_clang
  if (__glibc_unsafe_len (__n, sizeof (wchar_t), __sz))
    return __fgetws_chk_warn (__s, __sz / sizeof (wchar_t), __n, __stream);
#endif
  return __fgetws_chk (__s, __sz / sizeof (wchar_t), __n, __stream);
}

#ifdef __USE_GNU
__fortify_function __attribute_overloadable__ __wur wchar_t *
fgetws_unlocked (__fortify_clang_overload_arg (wchar_t *, __restrict, __s),
		 int __n, __FILE *__restrict __stream)
     __fortify_clang_warning_only_if_bos_lt2 (__n, __s, sizeof (wchar_t),
					      "fgetws_unlocked called with length bigger "
					      "than size of destination buffer")
{
  size_t __sz = __glibc_objsize (__s);
  if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), __sz))
    return __fgetws_unlocked_alias (__s, __n, __stream);
# if !__fortify_use_clang
  if (__glibc_unsafe_len (__n, sizeof (wchar_t), __sz))
    return __fgetws_unlocked_chk_warn (__s, __sz / sizeof (wchar_t), __n,
				       __stream);
# endif
  return __fgetws_unlocked_chk (__s, __sz / sizeof (wchar_t), __n, __stream);
}
#endif

__fortify_function __attribute_overloadable__ __wur size_t
__NTH (wcrtomb (__fortify_clang_overload_arg (char *, __restrict, __s),
		wchar_t __wchar, mbstate_t *__restrict __ps))
{
  /* We would have to include <limits.h> to get a definition of MB_LEN_MAX.
     But this would only disturb the namespace.  So we define our own
     version here.  */
#define __WCHAR_MB_LEN_MAX	16
#if defined MB_LEN_MAX && MB_LEN_MAX != __WCHAR_MB_LEN_MAX
# error "Assumed value of MB_LEN_MAX wrong"
#endif
  if (__glibc_objsize (__s) != (size_t) -1
      && __WCHAR_MB_LEN_MAX > __glibc_objsize (__s))
    return __wcrtomb_chk (__s, __wchar, __ps, __glibc_objsize (__s));
  return __wcrtomb_alias (__s, __wchar, __ps);
}

__fortify_function __attribute_overloadable__ size_t
__NTH (mbsrtowcs (__fortify_clang_overload_arg (wchar_t *, __restrict, __dst),
		  const char **__restrict __src,
		  size_t __len, mbstate_t *__restrict __ps))
     __fortify_clang_warning_only_if_bos_lt2 (__len, __dst, sizeof (wchar_t),
					      "mbsrtowcs called with dst buffer "
					      "smaller than len * sizeof (wchar_t)")
{
  return __glibc_fortify_n (mbsrtowcs, __len, sizeof (wchar_t),
			    __glibc_objsize (__dst),
			    __dst, __src, __len, __ps);
}

__fortify_function __attribute_overloadable__ size_t
__NTH (wcsrtombs (__fortify_clang_overload_arg (char *, __restrict, __dst),
		  const wchar_t **__restrict __src,
		  size_t __len, mbstate_t *__restrict __ps))
     __fortify_clang_warning_only_if_bos_lt (__len, __dst,
					     "wcsrtombs called with dst buffer "
					     "smaller than len")
{
  return __glibc_fortify (wcsrtombs, __len, sizeof (char),
			  __glibc_objsize (__dst),
			  __dst, __src, __len, __ps);
}


#ifdef	__USE_XOPEN2K8
__fortify_function __attribute_overloadable__ size_t
__NTH (mbsnrtowcs (__fortify_clang_overload_arg (wchar_t *, __restrict, __dst),
		   const char **__restrict __src, size_t __nmc, size_t __len,
		   mbstate_t *__restrict __ps))
     __fortify_clang_warning_only_if_bos_lt (sizeof (wchar_t) * __len, __dst,
					     "mbsnrtowcs called with dst buffer "
					     "smaller than len * sizeof (wchar_t)")
{
  return __glibc_fortify_n (mbsnrtowcs, __len, sizeof (wchar_t),
			    __glibc_objsize (__dst),
			    __dst, __src, __nmc, __len, __ps);
}

__fortify_function __attribute_overloadable__ size_t
__NTH (wcsnrtombs (__fortify_clang_overload_arg (char *, __restrict, __dst),
		   const wchar_t **__restrict __src, size_t __nwc,
		   size_t __len, mbstate_t *__restrict __ps))
     __fortify_clang_warning_only_if_bos_lt (__len, __dst,
					     "wcsnrtombs called with dst buffer "
					     "smaller than len")
{
  return __glibc_fortify (wcsnrtombs, __len, sizeof (char),
			  __glibc_objsize (__dst),
			  __dst, __src, __nwc, __len, __ps);
}
#endif
Commit	Line	Data
	1	/* Checking macros for wchar functions.
	2	Copyright (C) 2005-2025 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, see
	17	<https://www.gnu.org/licenses/>. */
	18
	19	#ifndef _WCHAR_H
	20	# error "Never include <bits/wchar2.h> directly; use <wchar.h> instead."
	21	#endif
	22
	23	__fortify_function __attribute_overloadable__ wchar_t *
	24	__NTH (wmemcpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __s1),
	25	const wchar_t *__restrict __s2, size_t __n))
	26	__fortify_clang_warning_only_if_bos0_lt2 (__n, __s1, sizeof (wchar_t),
	27	"wmemcpy called with length bigger "
	28	"than size of destination buffer")
	29	{
	30	return __glibc_fortify_n (wmemcpy, __n, sizeof (wchar_t),
	31	__glibc_objsize0 (__s1),
	32	__s1, __s2, __n);
	33	}
	34
	35	__fortify_function __attribute_overloadable__ wchar_t *
	36	__NTH (wmemmove (__fortify_clang_overload_arg (wchar_t *, ,__s1),
	37	const wchar_t *__s2, size_t __n))
	38	__fortify_clang_warning_only_if_bos0_lt2 (__n, __s1, sizeof (wchar_t),
	39	"wmemmove called with length bigger "
	40	"than size of destination buffer")
	41	{
	42	return __glibc_fortify_n (wmemmove, __n, sizeof (wchar_t),
	43	__glibc_objsize0 (__s1),
	44	__s1, __s2, __n);
	45	}
	46
	47	#ifdef __USE_GNU
	48	__fortify_function __attribute_overloadable__ wchar_t *
	49	__NTH (wmempcpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __s1),
	50	const wchar_t *__restrict __s2, size_t __n))
	51	__fortify_clang_warning_only_if_bos0_lt2 (__n, __s1, sizeof (wchar_t),
	52	"wmempcpy called with length bigger "
	53	"than size of destination buffer")
	54	{
	55	return __glibc_fortify_n (wmempcpy, __n, sizeof (wchar_t),
	56	__glibc_objsize0 (__s1),
	57	__s1, __s2, __n);
	58	}
	59	#endif
	60
	61	__fortify_function __attribute_overloadable__ wchar_t *
	62	__NTH (wmemset (__fortify_clang_overload_arg (wchar_t *, ,__s), wchar_t __c,
	63	size_t __n))
	64	__fortify_clang_warning_only_if_bos0_lt2 (__n, __s, sizeof (wchar_t),
	65	"wmemset called with length bigger "
	66	"than size of destination buffer")
	67	{
	68	return __glibc_fortify_n (wmemset, __n, sizeof (wchar_t),
	69	__glibc_objsize0 (__s),
	70	__s, __c, __n);
	71	}
	72
	73	__fortify_function __attribute_overloadable__ wchar_t *
	74	__NTH (wcscpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	75	const wchar_t *__restrict __src))
	76	{
	77	size_t __sz = __glibc_objsize (__dest);
	78	if (__sz != (size_t) -1)
	79	return __wcscpy_chk (__dest, __src, __sz / sizeof (wchar_t));
	80	return __wcscpy_alias (__dest, __src);
	81	}
	82
	83	__fortify_function __attribute_overloadable__ wchar_t *
	84	__NTH (wcpcpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	85	const wchar_t *__restrict __src))
	86	{
	87	size_t __sz = __glibc_objsize (__dest);
	88	if (__sz != (size_t) -1)
	89	return __wcpcpy_chk (__dest, __src, __sz / sizeof (wchar_t));
	90	return __wcpcpy_alias (__dest, __src);
	91	}
	92
	93	__fortify_function __attribute_overloadable__ wchar_t *
	94	__NTH (wcsncpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	95	const wchar_t *__restrict __src, size_t __n))
	96	__fortify_clang_warning_only_if_bos0_lt2 (__n, __dest, sizeof (wchar_t),
	97	"wcsncpy called with length bigger "
	98	"than size of destination buffer")
	99	{
	100	return __glibc_fortify_n (wcsncpy, __n, sizeof (wchar_t),
	101	__glibc_objsize (__dest),
	102	__dest, __src, __n);
	103	}
	104
	105	__fortify_function __attribute_overloadable__ wchar_t *
	106	__NTH (wcpncpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	107	const wchar_t *__restrict __src, size_t __n))
	108	__fortify_clang_warning_only_if_bos0_lt2 (__n, __dest, sizeof (wchar_t),
	109	"wcpncpy called with length bigger "
	110	"than size of destination buffer")
	111	{
	112	return __glibc_fortify_n (wcpncpy, __n, sizeof (wchar_t),
	113	__glibc_objsize (__dest),
	114	__dest, __src, __n);
	115	}
	116
	117	__fortify_function __attribute_overloadable__ wchar_t *
	118	__NTH (wcscat (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	119	const wchar_t *__restrict __src))
	120	{
	121	size_t __sz = __glibc_objsize (__dest);
	122	if (__sz != (size_t) -1)
	123	return __wcscat_chk (__dest, __src, __sz / sizeof (wchar_t));
	124	return __wcscat_alias (__dest, __src);
	125	}
	126
	127	__fortify_function __attribute_overloadable__ wchar_t *
	128	__NTH (wcsncat (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	129	const wchar_t *__restrict __src, size_t __n))
	130	{
	131	size_t __sz = __glibc_objsize (__dest);
	132	if (__sz != (size_t) -1)
	133	return __wcsncat_chk (__dest, __src, __n, __sz / sizeof (wchar_t));
	134	return __wcsncat_alias (__dest, __src, __n);
	135	}
	136
	137	#ifdef __USE_MISC
	138	__fortify_function __attribute_overloadable__ size_t
	139	__NTH (wcslcpy (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	140	const wchar_t *__restrict __src, size_t __n))
	141	__fortify_clang_warning_only_if_bos0_lt2 (__n, __dest, sizeof (wchar_t),
	142	"wcslcpy called with length bigger "
	143	"than size of destination buffer")
	144	{
	145	if (__glibc_objsize (__dest) != (size_t) -1
	146	&& (!__builtin_constant_p (__n
	147	> __glibc_objsize (__dest) / sizeof (wchar_t))
	148	\|\| __n > __glibc_objsize (__dest) / sizeof (wchar_t)))
	149	return __wcslcpy_chk (__dest, __src, __n,
	150	__glibc_objsize (__dest) / sizeof (wchar_t));
	151	return __wcslcpy_alias (__dest, __src, __n);
	152	}
	153
	154	__fortify_function __attribute_overloadable__ size_t
	155	__NTH (wcslcat (__fortify_clang_overload_arg (wchar_t *, __restrict, __dest),
	156	const wchar_t *__restrict __src, size_t __n))
	157	{
	158	if (__glibc_objsize (__dest) != (size_t) -1
	159	&& (!__builtin_constant_p (__n > __glibc_objsize (__dest)
	160	/ sizeof (wchar_t))
	161	\|\| __n > __glibc_objsize (__dest) / sizeof (wchar_t)))
	162	return __wcslcat_chk (__dest, __src, __n,
	163	__glibc_objsize (__dest) / sizeof (wchar_t));
	164	return __wcslcat_alias (__dest, __src, __n);
	165	}
	166	#endif /* __USE_MISC */
	167
	168	#ifdef __va_arg_pack
	169	__fortify_function int
	170	__NTH (swprintf (wchar_t *__restrict __s, size_t __n,
	171	const wchar_t *__restrict __fmt, ...))
	172	{
	173	size_t __sz = __glibc_objsize (__s);
	174	if (__sz != (size_t) -1 \|\| __USE_FORTIFY_LEVEL > 1)
	175	return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
	176	__sz / sizeof (wchar_t), __fmt, __va_arg_pack ());
	177	return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
	178	}
	179	#elif __fortify_use_clang
	180	__fortify_function_error_function __attribute_overloadable__ int
	181	__NTH (swprintf (__fortify_clang_overload_arg (wchar_t *, __restrict, __s),
	182	size_t __n, const wchar_t *__restrict __fmt, ...))
	183	{
	184	__gnuc_va_list __fortify_ap;
	185	__builtin_va_start (__fortify_ap, __fmt);
	186	int __r;
	187	if (__glibc_objsize (__s) != (size_t) -1 \|\| __USE_FORTIFY_LEVEL > 1)
	188	__r = __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
	189	__glibc_objsize (__s) / sizeof (wchar_t),
	190	__fmt, __fortify_ap);
	191	else
	192	__r = __vswprintf_alias (__s, __n, __fmt, __fortify_ap);
	193	__builtin_va_end (__fortify_ap);
	194	return __r;
	195	}
	196	#elif !defined __cplusplus
	197	/* XXX We might want to have support in gcc for swprintf. */
	198	# define swprintf(s, n, ...) \
	199	(__glibc_objsize (s) != (size_t) -1 \|\| __USE_FORTIFY_LEVEL > 1 \
	200	? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1, \
	201	__glibc_objsize (s) / sizeof (wchar_t), __VA_ARGS__) \
	202	: swprintf (s, n, __VA_ARGS__))
	203	#endif
	204
	205	__fortify_function int
	206	__NTH (vswprintf (wchar_t *__restrict __s, size_t __n,
	207	const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
	208	{
	209	size_t __sz = __glibc_objsize (__s);
	210	if (__sz != (size_t) -1 \|\| __USE_FORTIFY_LEVEL > 1)
	211	return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
	212	__sz / sizeof (wchar_t), __fmt, __ap);
	213	return __vswprintf_alias (__s, __n, __fmt, __ap);
	214	}
	215
	216
	217	#if __USE_FORTIFY_LEVEL > 1
	218
	219	# ifdef __va_arg_pack
	220	__fortify_function int
	221	wprintf (const wchar_t *__restrict __fmt, ...)
	222	{
	223	return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ());
	224	}
	225
	226	__fortify_function int
	227	fwprintf (__FILE __restrict __stream, const wchar_t __restrict __fmt, ...)
	228	{
	229	return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt,
	230	__va_arg_pack ());
	231	}
	232	# elif !defined __cplusplus
	233	# define wprintf(...) \
	234	__wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
	235	# define fwprintf(stream, ...) \
	236	__fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
	237	# endif
	238
	239	__fortify_function int
	240	vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
	241	{
	242	return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap);
	243	}
	244
	245	__fortify_function int
	246	vfwprintf (__FILE *__restrict __stream,
	247	const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
	248	{
	249	return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap);
	250	}
	251
	252	#endif
	253	__fortify_function __attribute_overloadable__ __wur wchar_t *
	254	fgetws (__fortify_clang_overload_arg (wchar_t *, __restrict, __s), int __n,
	255	__FILE *__restrict __stream)
	256	__fortify_clang_warning_only_if_bos_lt2 (__n, __s, sizeof (wchar_t),
	257	"fgetws called with length bigger "
	258	"than size of destination buffer")
	259	{
	260	size_t __sz = __glibc_objsize (__s);
	261	if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), __sz))
	262	return __fgetws_alias (__s, __n, __stream);
	263	#if !__fortify_use_clang
	264	if (__glibc_unsafe_len (__n, sizeof (wchar_t), __sz))
	265	return __fgetws_chk_warn (__s, __sz / sizeof (wchar_t), __n, __stream);
	266	#endif
	267	return __fgetws_chk (__s, __sz / sizeof (wchar_t), __n, __stream);
	268	}
	269
	270	#ifdef __USE_GNU
	271	__fortify_function __attribute_overloadable__ __wur wchar_t *
	272	fgetws_unlocked (__fortify_clang_overload_arg (wchar_t *, __restrict, __s),
	273	int __n, __FILE *__restrict __stream)
	274	__fortify_clang_warning_only_if_bos_lt2 (__n, __s, sizeof (wchar_t),
	275	"fgetws_unlocked called with length bigger "
	276	"than size of destination buffer")
	277	{
	278	size_t __sz = __glibc_objsize (__s);
	279	if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), __sz))
	280	return __fgetws_unlocked_alias (__s, __n, __stream);
	281	# if !__fortify_use_clang
	282	if (__glibc_unsafe_len (__n, sizeof (wchar_t), __sz))
	283	return __fgetws_unlocked_chk_warn (__s, __sz / sizeof (wchar_t), __n,
	284	__stream);
	285	# endif
	286	return __fgetws_unlocked_chk (__s, __sz / sizeof (wchar_t), __n, __stream);
	287	}
	288	#endif
	289
	290	__fortify_function __attribute_overloadable__ __wur size_t
	291	__NTH (wcrtomb (__fortify_clang_overload_arg (char *, __restrict, __s),
	292	wchar_t __wchar, mbstate_t *__restrict __ps))
	293	{
	294	/* We would have to include <limits.h> to get a definition of MB_LEN_MAX.
	295	But this would only disturb the namespace. So we define our own
	296	version here. */
	297	#define __WCHAR_MB_LEN_MAX 16
	298	#if defined MB_LEN_MAX && MB_LEN_MAX != __WCHAR_MB_LEN_MAX
	299	# error "Assumed value of MB_LEN_MAX wrong"
	300	#endif
	301	if (__glibc_objsize (__s) != (size_t) -1
	302	&& __WCHAR_MB_LEN_MAX > __glibc_objsize (__s))
	303	return __wcrtomb_chk (__s, __wchar, __ps, __glibc_objsize (__s));
	304	return __wcrtomb_alias (__s, __wchar, __ps);
	305	}
	306
	307	__fortify_function __attribute_overloadable__ size_t
	308	__NTH (mbsrtowcs (__fortify_clang_overload_arg (wchar_t *, __restrict, __dst),
	309	const char **__restrict __src,
	310	size_t __len, mbstate_t *__restrict __ps))
	311	__fortify_clang_warning_only_if_bos_lt2 (__len, __dst, sizeof (wchar_t),
	312	"mbsrtowcs called with dst buffer "
	313	"smaller than len * sizeof (wchar_t)")
	314	{
	315	return __glibc_fortify_n (mbsrtowcs, __len, sizeof (wchar_t),
	316	__glibc_objsize (__dst),
	317	__dst, __src, __len, __ps);
	318	}
	319
	320	__fortify_function __attribute_overloadable__ size_t
	321	__NTH (wcsrtombs (__fortify_clang_overload_arg (char *, __restrict, __dst),
	322	const wchar_t **__restrict __src,
	323	size_t __len, mbstate_t *__restrict __ps))
	324	__fortify_clang_warning_only_if_bos_lt (__len, __dst,
	325	"wcsrtombs called with dst buffer "
	326	"smaller than len")
	327	{
	328	return __glibc_fortify (wcsrtombs, __len, sizeof (char),
	329	__glibc_objsize (__dst),
	330	__dst, __src, __len, __ps);
	331	}
	332
	333
	334	#ifdef __USE_XOPEN2K8
	335	__fortify_function __attribute_overloadable__ size_t
	336	__NTH (mbsnrtowcs (__fortify_clang_overload_arg (wchar_t *, __restrict, __dst),
	337	const char **__restrict __src, size_t __nmc, size_t __len,
	338	mbstate_t *__restrict __ps))
	339	__fortify_clang_warning_only_if_bos_lt (sizeof (wchar_t) * __len, __dst,
	340	"mbsnrtowcs called with dst buffer "
	341	"smaller than len * sizeof (wchar_t)")
	342	{
	343	return __glibc_fortify_n (mbsnrtowcs, __len, sizeof (wchar_t),
	344	__glibc_objsize (__dst),
	345	__dst, __src, __nmc, __len, __ps);
	346	}
	347
	348	__fortify_function __attribute_overloadable__ size_t
	349	__NTH (wcsnrtombs (__fortify_clang_overload_arg (char *, __restrict, __dst),
	350	const wchar_t **__restrict __src, size_t __nwc,
	351	size_t __len, mbstate_t *__restrict __ps))
	352	__fortify_clang_warning_only_if_bos_lt (__len, __dst,
	353	"wcsnrtombs called with dst buffer "
	354	"smaller than len")
	355	{
	356	return __glibc_fortify (wcsnrtombs, __len, sizeof (char),
	357	__glibc_objsize (__dst),
	358	__dst, __src, __nwc, __len, __ps);
	359	}
	360	#endif