(fwscanf, wscanf, swscanf, vfwscanf, vwscanf, vswscanf): Redirect to
[kopensolaris-gnu/glibc.git] / wcsmbs / bits / wchar2.h
index 12f478e..e1b7c13 100644 (file)
@@ -1,5 +1,5 @@
 /* Checking macros for wchar functions.
-   Copyright (C) 2005 Free Software Foundation, Inc.
+   Copyright (C) 2005, 2006, 2007 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
@@ -18,7 +18,7 @@
    02111-1307 USA.  */
 
 #ifndef _WCHAR_H
-# error "Never include <bits/wchar.h> directly; use <wchar.h> instead."
+# error "Never include <bits/wchar2.h> directly; use <wchar.h> instead."
 #endif
 
 
@@ -30,9 +30,9 @@ extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias,
                                 __const wchar_t *__restrict __s2, size_t __n),
                                wmemcpy);
 
-extern __always_inline wchar_t *
-wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
-        size_t __n)
+__extern_always_inline wchar_t *
+__NTH (wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
+               size_t __n))
 {
   if (__bos0 (__s1) != (size_t) -1)
     return __wmemcpy_chk (__s1, __s2, __n, __bos0 (__s1) / sizeof (wchar_t));
@@ -46,9 +46,9 @@ extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1,
                                                   __const wchar_t *__s2,
                                                   size_t __n), wmemmove);
 
-extern __always_inline wchar_t *
-wmemmove (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
-         size_t __n)
+__extern_always_inline wchar_t *
+__NTH (wmemmove (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
+                size_t __n))
 {
   if (__bos0 (__s1) != (size_t) -1)
     return __wmemmove_chk (__s1, __s2, __n, __bos0 (__s1) / sizeof (wchar_t));
@@ -65,9 +65,9 @@ extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias,
                                 __const wchar_t *__restrict __s2,
                                 size_t __n), wmempcpy);
 
-extern __always_inline wchar_t *
-wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
-         size_t __n)
+__extern_always_inline wchar_t *
+__NTH (wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,
+                size_t __n))
 {
   if (__bos0 (__s1) != (size_t) -1)
     return __wmempcpy_chk (__s1, __s2, __n, __bos0 (__s1) / sizeof (wchar_t));
@@ -81,8 +81,8 @@ extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
 extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c,
                                                  size_t __n), wmemset);
 
-extern __always_inline wchar_t *
-wmemset (wchar_t *__restrict __s, wchar_t __c, size_t __n)
+__extern_always_inline wchar_t *
+__NTH (wmemset (wchar_t *__restrict __s, wchar_t __c, size_t __n))
 {
   if (__bos0 (__s) != (size_t) -1)
     return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t));
@@ -97,8 +97,8 @@ extern wchar_t *__REDIRECT_NTH (__wcscpy_alias,
                                (wchar_t *__restrict __dest,
                                 __const wchar_t *__restrict __src), wcscpy);
 
-extern __always_inline wchar_t *
-wcscpy (wchar_t *__dest, __const wchar_t *__src)
+__extern_always_inline wchar_t *
+__NTH (wcscpy (wchar_t *__dest, __const wchar_t *__src))
 {
   if (__bos (__dest) != (size_t) -1)
     return __wcscpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
@@ -112,8 +112,8 @@ extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias, (wchar_t *__dest,
                                                 __const wchar_t *__src),
                                wcpcpy);
 
-extern __always_inline wchar_t *
-wcpcpy (wchar_t *__dest, __const wchar_t *__src)
+__extern_always_inline wchar_t *
+__NTH (wcpcpy (wchar_t *__dest, __const wchar_t *__src))
 {
   if (__bos (__dest) != (size_t) -1)
     return __wcpcpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
@@ -129,8 +129,8 @@ extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias,
                                 __const wchar_t *__restrict __src,
                                 size_t __n), wcsncpy);
 
-extern __always_inline wchar_t *
-wcsncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n)
+__extern_always_inline wchar_t *
+__NTH (wcsncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n))
 {
   if (__bos (__dest) != (size_t) -1
       && (!__builtin_constant_p (__n) || __bos (__dest) >= __n))
@@ -148,8 +148,8 @@ extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias,
                                 __const wchar_t *__restrict __src,
                                 size_t __n), wcpncpy);
 
-extern __always_inline wchar_t *
-wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n)
+__extern_always_inline wchar_t *
+__NTH (wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n))
 {
   if (__bos (__dest) != (size_t) -1
       && (!__builtin_constant_p (__n) || __bos (__dest) >= __n))
@@ -166,8 +166,8 @@ extern wchar_t *__REDIRECT_NTH (__wcscat_alias,
                                (wchar_t *__restrict __dest,
                                 __const wchar_t *__restrict __src), wcscat);
 
-extern __always_inline wchar_t *
-wcscat (wchar_t *__dest, __const wchar_t *__src)
+__extern_always_inline wchar_t *
+__NTH (wcscat (wchar_t *__dest, __const wchar_t *__src))
 {
   if (__bos (__dest) != (size_t) -1)
     return __wcscat_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));
@@ -183,8 +183,8 @@ extern wchar_t *__REDIRECT_NTH (__wcsncat_alias,
                                 __const wchar_t *__restrict __src,
                                 size_t __n), wcsncat);
 
-extern __always_inline wchar_t *
-wcsncat (wchar_t *__dest, __const wchar_t *__src, size_t __n)
+__extern_always_inline wchar_t *
+__NTH (wcsncat (wchar_t *__dest, __const wchar_t *__src, size_t __n))
 {
   if (__bos (__dest) != (size_t) -1)
     return __wcsncat_chk (__dest, __src, __n,
@@ -198,68 +198,106 @@ extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
                           __const wchar_t *__restrict __format, ...)
      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 6))) */;
 
+extern int __REDIRECT_NTH (__swprintf_alias,
+                          (wchar_t *__restrict __s, size_t __n,
+                           __const wchar_t *__restrict __fmt, ...),
+                           swprintf);
+
+#ifdef __va_arg_pack
+__extern_always_inline int
+__NTH (swprintf (wchar_t *__restrict __s, size_t __n,
+                __const wchar_t *__restrict __fmt, ...))
+{
+  if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
+    return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, __bos (__s),
+                          __fmt, __va_arg_pack ());
+  return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
+}
+#elif !defined __cplusplus
 /* XXX We might want to have support in gcc for swprintf.  */
-#define swprintf(s, n, format, ...) \
+# define swprintf(s, n, ...) \
   (__bos (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1                       \
-   ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1, __bos (s), format,       \
-                    __VA_ARGS__)                                             \
-   : swprintf (s, n, format, __VA_ARGS__))
-
+   ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1, __bos (s), __VA_ARGS__)   \
+   : swprintf (s, n, __VA_ARGS__))
+#endif
 
 extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
                            int __flag, size_t __s_len,
                            __const wchar_t *__restrict __format,
                            __gnuc_va_list __arg)
      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */;
+
 extern int __REDIRECT_NTH (__vswprintf_alias,
                           (wchar_t *__restrict __s, size_t __n,
-                           __const wchar_t *__restrict __format,
-                           __gnuc_va_list __arg), vswprintf)
-     /* __attribute__ ((__format__ (__wprintf__, 3, 0))) */;
+                           __const wchar_t *__restrict __fmt,
+                           __gnuc_va_list __ap), vswprintf);
 
-
-extern __always_inline int
-vswprintf (wchar_t *__s, size_t __n, __const wchar_t *__format,
-          __gnuc_va_list __arg)
+__extern_always_inline int
+__NTH (vswprintf (wchar_t *__restrict __s, size_t __n,
+                 __const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
 {
   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1)
-    return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, __bos (__s),
-                           __format, __arg);
-  return vswprintf (__s, __n, __format, __arg);
+    return __vswprintf_chk (__s, __n,  __USE_FORTIFY_LEVEL - 1, __bos (__s),
+                           __fmt, __ap);
+  return __vswprintf_alias (__s, __n, __fmt, __ap);
 }
 
 
 #if __USE_FORTIFY_LEVEL > 1
 
-extern int __fwprintf_chk (FILE *__restrict __stream, int __flag,
+extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
                           __const wchar_t *__restrict __format, ...);
 extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
                          ...);
-extern int __vfwprintf_chk (FILE *__restrict __stream, int __flag,
+extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
                            __const wchar_t *__restrict __format,
-                           _G_va_list __ap);
+                           __gnuc_va_list __ap);
 extern int __vwprintf_chk (int __flag, __const wchar_t *__restrict __format,
-                          _G_va_list __ap);
+                          __gnuc_va_list __ap);
+
+# ifdef __va_arg_pack
+__extern_always_inline int
+wprintf (__const wchar_t *__restrict __fmt, ...)
+{
+  return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ());
+}
 
-# define wprintf(...) \
+__extern_always_inline 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, ...) \
+#  define fwprintf(stream, ...) \
   __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
-# define vwprintf(format, ap) \
-  __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, format, ap)
-# define vfwprintf(stream, format, ap) \
-  __vfwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, format, ap)
+# endif
+
+__extern_always_inline int
+vwprintf (__const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap);
+}
+
+__extern_always_inline 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
 
 extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
-                             FILE *__restrict __stream) __wur;
+                             __FILE *__restrict __stream) __wur;
 extern wchar_t *__REDIRECT (__fgetws_alias,
                            (wchar_t *__restrict __s, int __n,
-                            FILE *__restrict __stream), fgetws) __wur;
+                            __FILE *__restrict __stream), fgetws) __wur;
 
-extern __always_inline __wur wchar_t *
-fgetws (wchar_t *__restrict __s, int __n, FILE *__restrict __stream)
+__extern_always_inline __wur wchar_t *
+fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
 {
   if (__bos (__s) != (size_t) -1
       && (!__builtin_constant_p (__n) || (size_t) __n > __bos (__s)))
@@ -269,15 +307,15 @@ fgetws (wchar_t *__restrict __s, int __n, FILE *__restrict __stream)
 
 #ifdef __USE_GNU
 extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
-                                      int __n, FILE *__restrict __stream)
+                                      int __n, __FILE *__restrict __stream)
   __wur;
 extern wchar_t *__REDIRECT (__fgetws_unlocked_alias,
                            (wchar_t *__restrict __s, int __n,
-                            FILE *__restrict __stream), fgetws_unlocked)
+                            __FILE *__restrict __stream), fgetws_unlocked)
   __wur;
 
-extern __always_inline __wur wchar_t *
-fgetws_unlocked (wchar_t *__restrict __s, int __n, FILE *__restrict __stream)
+__extern_always_inline __wur wchar_t *
+fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
 {
   if (__bos (__s) != (size_t) -1
       && (!__builtin_constant_p (__n) || (size_t) __n > __bos (__s)))
@@ -285,3 +323,116 @@ fgetws_unlocked (wchar_t *__restrict __s, int __n, FILE *__restrict __stream)
   return __fgetws_unlocked_alias (__s, __n, __stream);
 }
 #endif
+
+
+extern size_t __wcrtomb_chk (char *__s, wchar_t __wchar, mbstate_t *__p,
+                         size_t __buflen) __THROW __wur;
+extern size_t __REDIRECT_NTH (__wcrtomb_alias,
+                             (char *__restrict __s, wchar_t __wchar,
+                              mbstate_t *__restrict __ps), wcrtomb) __wur;
+
+__extern_always_inline __wur size_t
+__NTH (wcrtomb (char *__s, wchar_t __wchar, mbstate_t *__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 (__bos (__s) != (size_t) -1 && __WCHAR_MB_LEN_MAX > __bos (__s))
+    return __wcrtomb_chk (__s, __wchar, __ps, __bos (__s));
+  return __wcrtomb_alias (__s, __wchar, __ps);
+}
+
+
+extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
+                              __const char **__restrict __src,
+                              size_t __len, mbstate_t *__restrict __ps,
+                              size_t __dstlen) __THROW;
+extern size_t __REDIRECT_NTH (__mbsrtowcs_alias,
+                             (wchar_t *__restrict __dst,
+                              __const char **__restrict __src,
+                              size_t __len, mbstate_t *__restrict __ps),
+                             mbsrtowcs);
+
+__extern_always_inline size_t
+__NTH (mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,
+                 size_t __len, mbstate_t *__restrict __ps))
+{
+  if (__bos (__dst) != (size_t) -1
+      && (!__builtin_constant_p (__len)
+         || __len > __bos (__dst) / sizeof (wchar_t)))
+    return __mbsrtowcs_chk (__dst, __src, __len, __ps,
+                           __bos (__dst) / sizeof (wchar_t));
+  return __mbsrtowcs_alias (__dst, __src, __len, __ps);
+}
+
+
+extern size_t __wcsrtombs_chk (char *__restrict __dst,
+                              __const wchar_t **__restrict __src,
+                              size_t __len, mbstate_t *__restrict __ps,
+                              size_t __dstlen) __THROW;
+extern size_t __REDIRECT_NTH (__wcsrtombs_alias,
+                             (char *__restrict __dst,
+                              __const wchar_t **__restrict __src,
+                              size_t __len, mbstate_t *__restrict __ps),
+                             wcsrtombs);
+
+__extern_always_inline size_t
+__NTH (wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,
+                 size_t __len, mbstate_t *__restrict __ps))
+{
+  if (__bos (__dst) != (size_t) -1
+      && (!__builtin_constant_p (__len) || __len > __bos (__dst)))
+    return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst));
+  return __wcsrtombs_alias (__dst, __src, __len, __ps);
+}
+
+
+#ifdef __USE_GNU
+extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
+                               __const char **__restrict __src, size_t __nmc,
+                               size_t __len, mbstate_t *__restrict __ps,
+                               size_t __dstlen) __THROW;
+extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias,
+                             (wchar_t *__restrict __dst,
+                              __const char **__restrict __src, size_t __nmc,
+                              size_t __len, mbstate_t *__restrict __ps),
+                             mbsnrtowcs);
+
+__extern_always_inline size_t
+__NTH (mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,
+                  size_t __nmc, size_t __len, mbstate_t *__restrict __ps))
+{
+  if (__bos (__dst) != (size_t) -1
+      && (!__builtin_constant_p (__len)
+         || __len > __bos (__dst) / sizeof (wchar_t)))
+    return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
+                            __bos (__dst) / sizeof (wchar_t));
+  return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
+}
+
+
+extern size_t __wcsnrtombs_chk (char *__restrict __dst,
+                               __const wchar_t **__restrict __src,
+                               size_t __nwc, size_t __len,
+                               mbstate_t *__restrict __ps, size_t __dstlen)
+     __THROW;
+extern size_t __REDIRECT_NTH (__wcsnrtombs_alias,
+                             (char *__restrict __dst,
+                              __const wchar_t **__restrict __src,
+                              size_t __nwc, size_t __len,
+                              mbstate_t *__restrict __ps), wcsnrtombs);
+
+__extern_always_inline size_t
+__NTH (wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,
+                  size_t __nwc, size_t __len, mbstate_t *__restrict __ps))
+{
+  if (__bos (__dst) != (size_t) -1
+      && (!__builtin_constant_p (__len) || __len > __bos (__dst)))
+    return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps, __bos (__dst));
+  return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
+}
+#endif