* include/cytpe.h: Prefix identifiers used as args of inlines

	with '__', throughout.
	* include/inttypes.h: Likewise.
	* include/math.h: Likewise.
	* include/stdio.h: Likewise.
	* include/stdlib.h: Likewise.
	* include/wchar.h: Likewise.
	* include/wctype.h: Likewise.

8 files changed, 468 insertions, 176 deletions

diff --git a/winsup/mingw/ChangeLog b/winsup/mingw/ChangeLog
index b9dcb1d5e98..e82e87e6c6c 100644
--- a/winsup/mingw/ChangeLog
+++ b/winsup/mingw/ChangeLog
@@ -1,9 +1,20 @@
+2002-10-02  Danny Smith  <dannysmith@users.sourceforge.net>
+
+	* include/cytpe.h: Prefix identifiers used as args of inlines
+	with '__', throughout.
+	* include/inttypes.h: Likewise.
+	* include/math.h: Likewise.
+	* include/stdio.h: Likewise.
+	* include/stdlib.h: Likewise.
+	* include/wchar.h: Likewise.
+	* include/wctype.h: Likewise.
+
 2002-09-30  Danny Smith  <dannysmith@users.sourceforge.net>
 
 	* include/ctype.h (_tolower): Move inlined definition out of
 	std namespace.
 	(_tolower): Likewise.
-	(is_wctype): Move into non-ANSI, block. Qualify wctype_t with
+	(is_wctype): Move into non-ANSI block. Qualify wctype_t with
 	 __CSTD.
 
 2002-09-29  Danny Smith  <dannysmith@users.sourceforge.net>
diff --git a/winsup/mingw/include/ctype.h b/winsup/mingw/include/ctype.h
index 1b2110dbf59..50e7ed2414e 100644
--- a/winsup/mingw/include/ctype.h
+++ b/winsup/mingw/include/ctype.h
@@ -93,12 +93,13 @@ int	_toupper(int);
 
 #if !defined (__NO_CTYPE_INLINES)
 /* these reproduce behaviour of lib underscored versions  */
-extern __inline__ int _tolower(int c) {return ( c -'A'+'a');}
-extern __inline__ int _toupper(int c) {return ( c -'a'+'A');}
+extern __inline__ int _tolower(int __c) {return ( __c -'A'+'a');}
+extern __inline__ int _toupper(int __c) {return ( __c -'a'+'A');}
 #endif
 
 int	_isctype (int, int);
-#endif
+
+#endif /* __STRICT_ANSI__ */
 
 __END_CGLOBAL_NAMESPACE
 __BEGIN_CSTD_NAMESPACE
@@ -163,18 +164,19 @@ extern unsigned short** _imp___ctype;
 
 #if ! (defined (__NO_CTYPE_INLINES) || defined (__STRICT_ANSI__ ))
 /* use  simple lookup if SB locale, else  _isctype()  */
-#define __ISCTYPE(c, mask)  (MB_CUR_MAX == 1 ? (_pctype[c] & mask) : __CGLOBAL _isctype(c, mask))
-extern __inline__ int isalnum(int c) {return __ISCTYPE(c, (_ALPHA|_DIGIT));}
-extern __inline__ int isalpha(int c) {return __ISCTYPE(c, _ALPHA);}
-extern __inline__ int iscntrl(int c) {return __ISCTYPE(c, _CONTROL);}
-extern __inline__ int isdigit(int c) {return __ISCTYPE(c, _DIGIT);}
-extern __inline__ int isgraph(int c) {return __ISCTYPE(c, (_PUNCT|_ALPHA|_DIGIT));}
-extern __inline__ int islower(int c) {return __ISCTYPE(c, _LOWER);}
-extern __inline__ int isprint(int c) {return __ISCTYPE(c, (_BLANK|_PUNCT|_ALPHA|_DIGIT));}
-extern __inline__ int ispunct(int c) {return __ISCTYPE(c, _PUNCT);}
-extern __inline__ int isspace(int c) {return __ISCTYPE(c, _SPACE);}
-extern __inline__ int isupper(int c) {return __ISCTYPE(c, _UPPER);}
-extern __inline__ int isxdigit(int c) {return __ISCTYPE(c, _HEX);}
+#define __ISCTYPE(__c, __mask) \
+  (MB_CUR_MAX == 1 ? (_pctype[__c] & __mask) : __CGLOBAL _isctype(__c, __mask))
+extern __inline__ int isalnum(int __c) {return __ISCTYPE(__c, (_ALPHA|_DIGIT));}
+extern __inline__ int isalpha(int __c) {return __ISCTYPE(__c, _ALPHA);}
+extern __inline__ int iscntrl(int __c) {return __ISCTYPE(__c, _CONTROL);}
+extern __inline__ int isdigit(int __c) {return __ISCTYPE(__c, _DIGIT);}
+extern __inline__ int isgraph(int __c) {return __ISCTYPE(__c, (_PUNCT|_ALPHA|_DIGIT));}
+extern __inline__ int islower(int __c) {return __ISCTYPE(__c, _LOWER);}
+extern __inline__ int isprint(int __c) {return __ISCTYPE(__c, (_BLANK|_PUNCT|_ALPHA|_DIGIT));}
+extern __inline__ int ispunct(int __c) {return __ISCTYPE(__c, _PUNCT);}
+extern __inline__ int isspace(int __c) {return __ISCTYPE(__c, _SPACE);}
+extern __inline__ int isupper(int __c) {return __ISCTYPE(__c, _UPPER);}
+extern __inline__ int isxdigit(int __c) {return __ISCTYPE(__c, _HEX);}
 
 /* TODO? Is it worth inlining ANSI tolower, toupper? Probably only
    if we only want C-locale. */
@@ -214,19 +216,20 @@ int	isleadbyte (int);
 
 #if ! (defined(__NO_CTYPE_INLINES) || defined(__WCTYPE_INLINES_DEFINED))
 #define __WCTYPE_INLINES_DEFINED
-extern __inline__ int iswalnum(wint_t wc) {return (iswctype(wc,_ALPHA|_DIGIT));}
-extern __inline__ int iswalpha(wint_t wc) {return (iswctype(wc,_ALPHA));}
-extern __inline__ int iswascii(wint_t wc) {return (((unsigned)wc & 0x7F) ==0);}
-extern __inline__ int iswcntrl(wint_t wc) {return (iswctype(wc,_CONTROL));}
-extern __inline__ int iswdigit(wint_t wc) {return (iswctype(wc,_DIGIT));}
-extern __inline__ int iswgraph(wint_t wc) {return (iswctype(wc,_PUNCT|_ALPHA|_DIGIT));}
-extern __inline__ int iswlower(wint_t wc) {return (iswctype(wc,_LOWER));}
-extern __inline__ int iswprint(wint_t wc) {return (iswctype(wc,_BLANK|_PUNCT|_ALPHA|_DIGIT));}
-extern __inline__ int iswpunct(wint_t wc) {return (iswctype(wc,_PUNCT));}
-extern __inline__ int iswspace(wint_t wc) {return (iswctype(wc,_SPACE));}
-extern __inline__ int iswupper(wint_t wc) {return (iswctype(wc,_UPPER));}
-extern __inline__ int iswxdigit(wint_t wc) {return (iswctype(wc,_HEX));}
-extern __inline__ int isleadbyte(int c) {return (_pctype[(unsigned char)(c)] & _LEADBYTE);}
+extern __inline__ int iswalnum(wint_t __wc) {return (iswctype(__wc,_ALPHA|_DIGIT));}
+extern __inline__ int iswalpha(wint_t __wc) {return (iswctype(__wc,_ALPHA));}
+extern __inline__ int iswascii(wint_t __wc) {return (((unsigned)__wc & 0x7F) ==0);}
+extern __inline__ int iswcntrl(wint_t __wc) {return (iswctype(__wc,_CONTROL));}
+extern __inline__ int iswdigit(wint_t __wc) {return (iswctype(__wc,_DIGIT));}
+extern __inline__ int iswgraph(wint_t __wc) {return (iswctype(__wc,_PUNCT|_ALPHA|_DIGIT));}
+extern __inline__ int iswlower(wint_t __wc) {return (iswctype(__wc,_LOWER));}
+extern __inline__ int iswprint(wint_t __wc) {return (iswctype(__wc,_BLANK|_PUNCT|_ALPHA|_DIGIT));}
+extern __inline__ int iswpunct(wint_t __wc) {return (iswctype(__wc,_PUNCT));}
+extern __inline__ int iswspace(wint_t __wc) {return (iswctype(__wc,_SPACE));}
+extern __inline__ int iswupper(wint_t __wc) {return (iswctype(__wc,_UPPER));}
+extern __inline__ int iswxdigit(wint_t __wc) {return (iswctype(__wc,_HEX));}
+extern __inline__ int isleadbyte(int __c)
+  {return (_pctype[(unsigned char)(__c)] & _LEADBYTE);}
 #endif /* !(defined(__NO_CTYPE_INLINES) || defined(__WCTYPE_INLINES_DEFINED)) */
 __END_CSTD_NAMESPACE
 
@@ -240,10 +243,11 @@ int	__iscsymf (int);	/* Valid first character in C symbol */
 int	__iscsym (int);		/* Valid character in C symbol (after first) */
 
 #ifndef __NO_CTYPE_INLINES
-extern __inline__ int __isascii(int c) {return (((unsigned)c & ~0x7F) == 0);} 
-extern __inline__ int __toascii(int c) {return (c & 0x7F);}
-extern __inline__ int __iscsymf(int c) {return (__CSTD isalpha(c) || (c == '_'));}
-extern __inline__ int __iscsym(int c)  {return  (__CSTD isalnum(c) || (c == '_'));}
+extern __inline__ int __isascii(int __c)
+  {return (((unsigned)__c & ~0x7F) == 0);} 
+extern __inline__ int __toascii(int __c) {return  (__c & 0x7F);}
+extern __inline__ int __iscsymf(int __c) {return (__CSTD isalpha(__c) || (__c == '_'));}
+extern __inline__ int __iscsym(int __c)  {return  (__CSTD isalnum(__c) || (__c == '_'));}
 #endif /* __NO_CTYPE_INLINES */
 
 #ifndef	_NO_OLDNAMES
diff --git a/winsup/mingw/include/inttypes.h b/winsup/mingw/include/inttypes.h
new file mode 100644
index 00000000000..f5b4d78133b
--- /dev/null
+++ b/winsup/mingw/include/inttypes.h
@@ -0,0 +1,275 @@
+/* 7.8 Format conversion of integer types <inttypes.h> */
+
+#ifndef _INTTYPES_H_
+#define _INTTYPES_H_
+
+#include <stdint.h>
+#define __need_wchar_t
+#include <stddef.h>
+
+#ifdef	__cplusplus
+extern	"C"	{
+#endif
+
+typedef struct {
+	intmax_t quot;
+	intmax_t rem;
+	} imaxdiv_t;
+
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS)
+
+/* 7.8.1 Macros for format specifiers
+ * 
+ * MS runtime does not yet understand C9x standard "ll"
+ * length specifier. It appears to treat "ll" as "l".
+ * The non-standard I64 length specifier causes warning in GCC,
+ * but understood by MS runtime functions.
+ */
+
+/* fprintf macros for signed types */
+#define PRId8 "d"
+#define PRId16 "d"
+#define PRId32 "d"
+#define PRId64 "I64d"
+
+#define PRIdLEAST8 "d"
+#define PRIdLEAST16 "d"
+#define PRIdLEAST32 "d"
+#define PRIdLEAST64 "I64d"
+
+#define PRIdFAST8 "d"
+#define PRIdFAST16 "d"
+#define PRIdFAST32 "d"
+#define PRIdFAST64 "I64d"
+
+#define PRIdMAX "I64d"
+#define PRIdPTR "d"
+
+#define PRIi8 "i"
+#define PRIi16 "i"
+#define PRIi32 "i"
+#define PRIi64 "I64i"
+
+#define PRIiLEAST8 "i"
+#define PRIiLEAST16 "i"
+#define PRIiLEAST32 "i"
+#define PRIiLEAST64 "I64i"
+
+#define PRIiFAST8 "i"
+#define PRIiFAST16 "i"
+#define PRIiFAST32 "i"
+#define PRIiFAST64 "I64i"
+
+#define PRIiMAX "I64i"
+#define PRIiPTR "i"
+
+#define PRIo8 "o"
+#define PRIo16 "o"
+#define PRIo32 "o"
+#define PRIo64 "I64o"
+
+#define PRIoLEAST8 "o"
+#define PRIoLEAST16 "o"
+#define PRIoLEAST32 "o"
+#define PRIoLEAST64 "I64o"
+
+#define PRIoFAST8 "o"
+#define PRIoFAST16 "o"
+#define PRIoFAST32 "o"
+#define PRIoFAST64 "I64o"
+
+#define PRIoMAX "I64o"
+
+#define PRIoPTR "o"
+
+/* fprintf macros for unsigned types */
+#define PRIu8 "u"
+#define PRIu16 "u"
+#define PRIu32 "u"
+#define PRIu64 "I64u"
+
+
+#define PRIuLEAST8 "u"
+#define PRIuLEAST16 "u"
+#define PRIuLEAST32 "u"
+#define PRIuLEAST64 "I64u"
+
+#define PRIuFAST8 "u"
+#define PRIuFAST16 "u"
+#define PRIuFAST32 "u"
+#define PRIuFAST64 "I64u"
+
+#define PRIuMAX "I64u"
+#define PRIuPTR "u"
+
+#define PRIx8 "x"
+#define PRIx16 "x"
+#define PRIx32 "x"
+#define PRIx64 "I64x"
+
+#define PRIxLEAST8 "x"
+#define PRIxLEAST16 "x"
+#define PRIxLEAST32 "x"
+#define PRIxLEAST64 "I64x"
+
+#define PRIxFAST8 "x"
+#define PRIxFAST16 "x"
+#define PRIxFAST32 "x"
+#define PRIxFAST64 "I64x"
+
+#define PRIxMAX "I64x"
+#define PRIxPTR "x"
+
+#define PRIX8 "X"
+#define PRIX16 "X"
+#define PRIX32 "X"
+#define PRIX64 "I64X"
+
+#define PRIXLEAST8 "X"
+#define PRIXLEAST16 "X"
+#define PRIXLEAST32 "X"
+#define PRIXLEAST64 "I64X"
+
+#define PRIXFAST8 "X"
+#define PRIXFAST16 "X"
+#define PRIXFAST32 "X"
+#define PRIXFAST64 "I64X"
+
+#define PRIXMAX "I64X"
+#define PRIXPTR "X"
+
+/*
+ *   fscanf macros for signed int types
+ *   NOTE: if 32-bit int is used for int_fast8_t and int_fast16_t
+ *   (see stdint.h, 7.18.1.3), FAST8 and FAST16 should have
+ *   no length identifiers
+ */
+
+#define SCNd16 "hd"
+#define SCNd32 "d"
+#define SCNd64 "I64d"
+
+#define SCNdLEAST16 "hd"
+#define SCNdLEAST32 "d"
+#define SCNdLEAST64 "I64d"
+
+#define SCNdFAST16 "hd"
+#define SCNdFAST32 "d"
+#define SCNdFAST64 "I64d"
+
+#define SCNdMAX "I64d"
+#define SCNdPTR "d"
+
+#define SCNi16 "hi"
+#define SCNi32 "i"
+#define SCNi64 "I64i"
+
+#define SCNiLEAST16 "hi"
+#define SCNiLEAST32 "i"
+#define SCNiLEAST64 "I64i"
+
+#define SCNiFAST16 "hi"
+#define SCNiFAST32 "i"
+#define SCNiFAST64 "I64i"
+
+#define SCNiMAX "I64i"
+#define SCNiPTR "i"
+
+#define SCNo16 "ho"
+#define SCNo32 "o"
+#define SCNo64 "I64o"
+
+#define SCNoLEAST16 "ho"
+#define SCNoLEAST32 "o"
+#define SCNoLEAST64 "I64o"
+
+#define SCNoFAST16 "ho"
+#define SCNoFAST32 "o"
+#define SCNoFAST64 "I64o"
+
+#define SCNoMAX "I64o"
+#define SCNoPTR "o"
+
+#define SCNx16 "hx"
+#define SCNx32 "x"
+#define SCNx64 "I64x"
+
+#define SCNxLEAST16 "hx"
+#define SCNxLEAST32 "x"
+#define SCNxLEAST64 "I64x"
+
+#define SCNxFAST16 "hx"
+#define SCNxFAST32 "x"
+#define SCNxFAST64 "I64x"
+
+#define SCNxMAX "I64x"
+#define SCNxPTR "x"
+
+
+/* fscanf macros for unsigned int types */
+
+#define SCNu16 "hu"
+#define SCNu32 "u"
+#define SCNu64 "I64u"
+
+#define SCNuLEAST16 "hu"
+#define SCNuLEAST32 "u"
+#define SCNuLEAST64 "I64u"
+
+#define SCNuFAST16 "hu"
+#define SCNuFAST32 "u"
+#define SCNuFAST64 "I64u"
+
+#define SCNuMAX "I64u"
+#define SCNuPTR "u"
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+/*
+ * no length modifier for char types prior to C9x
+ * MS runtime  scanf appears to treat "hh" as "h" 
+ */
+
+/* signed char */
+#define SCNd8 "hhd"
+#define SCNdLEAST8 "hhd"
+#define SCNdFAST8 "hhd"
+
+#define SCNi8 "hhi"
+#define SCNiLEAST8 "hhi"
+#define SCNiFAST8 "hhi"
+
+#define SCNo8 "hho"
+#define SCNoLEAST8 "hho"
+#define SCNoFAST8 "hho"
+
+#define SCNx8 "hhx"
+#define SCNxLEAST8 "hhx"
+#define SCNxFAST8 "hhx"
+
+/* unsigned char */
+#define SCNu8 "hhu"
+#define SCNuLEAST8 "hhu"
+#define SCNuFAST8 "hhu"
+#endif /* __STDC_VERSION__ >= 199901 */
+
+#endif	/* !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) */
+
+extern __inline__ intmax_t imaxabs (intmax_t __j)
+	{return	(__j >= 0 ? __j : -__j);}
+imaxdiv_t imaxdiv (intmax_t numer, intmax_t denom);
+
+/* 7.8.2 Conversion functions for greatest-width integer types */
+
+intmax_t   strtoimax (const char* __restrict__ nptr, char** __restrict__ endptr, int base);
+uintmax_t  strtoumax (const char* __restrict__ nptr, char** __restrict__ endptr, int base);
+
+intmax_t wcstoimax (const wchar_t* __restrict__ nptr, wchar_t** __restrict__ endptr,
+	   int base);
+uintmax_t wcstoumax (const wchar_t* __restrict__ nptr, wchar_t** __restrict__ endptr,
+	   int base);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* ndef _INTTYPES_H */
diff --git a/winsup/mingw/include/math.h b/winsup/mingw/include/math.h
index 593889e5733..3abb189f74f 100644
--- a/winsup/mingw/include/math.h
+++ b/winsup/mingw/include/math.h
@@ -143,19 +143,19 @@ double	log (double);
 double	log10 (double);
 double	pow (double, double);
 double	sqrt (double);
-extern __inline__  double sqrt (double x)
+extern __inline__  double sqrt (double __x)
 {
   double res;
-  __asm__ ("fsqrt;" : "=t" (res) : "0" (x));
+  __asm__ ("fsqrt;" : "=t" (res) : "0" (__x));
   return res;
 }
 double	ceil (double);
 double	floor (double);
 double	fabs (double);
-extern __inline__  double fabs (double x)
+extern __inline__  double fabs (double __x)
 {
   double res;
-  __asm__ ("fabs;" : "=t" (res) : "0" (x));
+  __asm__ ("fabs;" : "=t" (res) : "0" (__x));
   return res;
 }
 double	ldexp (double, int);
@@ -166,7 +166,6 @@ double	fmod (double, double);
 __END_CSTD_NAMESPACE
 __BEGIN_CGLOBAL_NAMESPACE
 
-
 #ifndef	__STRICT_ANSI__
 
 /* Complex number (for cabs). This really belongs in complex.h */
@@ -242,7 +241,6 @@ int fpclass (double);
 #define HUGE_VALL (1.0L/0.0L)
 #define INFINITY (1.0F/0.0F)
 
-
 /* 7.12.3.1 */
 /*
    Return values for fpclassify.
@@ -257,7 +255,6 @@ int fpclass (double);
 #define FP_SUBNORMAL	(FP_NORMAL | FP_ZERO)
 /* 0x0200 is signbit mask */
 
-
 /*
   We can't inline float or double, because we want to ensure truncation
   to semantic type before classification. 
@@ -268,83 +265,83 @@ int fpclass (double);
 extern int __fpclassifyf (float);
 extern int __fpclassify (double);
 
-extern __inline__ int __fpclassifyl (long double x){
+extern __inline__ int __fpclassifyl (long double __x){
   unsigned short sw;
-  __asm__ ("fxam; fstsw %%ax;" : "=a" (sw): "t" (x));
+  __asm__ ("fxam; fstsw %%ax;" : "=a" (sw): "t" (__x));
   return sw & (FP_NAN | FP_NORMAL | FP_ZERO );
 }
 
-#define fpclassify(x) (sizeof (x) == sizeof (float) ? __fpclassifyf (x)	  \
-		       : sizeof (x) == sizeof (double) ? __fpclassify (x) \
-		       : __fpclassifyl (x))
+#define fpclassify(__x) (sizeof (__x) == sizeof (float) ? __fpclassifyf (__x)	  \
+		       : sizeof (__x) == sizeof (double) ? __fpclassify (__x) \
+		       : __fpclassifyl (__x))
 
 /* 7.12.3.2 */
-#define isfinite(x) ((fpclassify(x) & FP_NAN) == 0)
+#define isfinite(__x) ((fpclassify(__x) & FP_NAN) == 0)
 
 /* 7.12.3.3 */
-#define isinf(x) (fpclassify(x) == FP_INFINITE)
+#define isinf(__x) (fpclassify(__x) == FP_INFINITE)
 
 /* 7.12.3.4 */
 /* We don't need to worry about trucation here:
    A NaN stays a NaN. */
 
-extern __inline__ int __isnan (double _x)
+extern __inline__ int __isnan (double __x)
 {
   unsigned short sw;
   __asm__ ("fxam;"
-	   "fstsw %%ax": "=a" (sw) : "t" (_x));
+	   "fstsw %%ax": "=a" (sw) : "t" (__x));
   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
     == FP_NAN;
 }
 
-extern __inline__ int __isnanf (float _x)
+extern __inline__ int __isnanf (float __x)
 {
   unsigned short sw;
   __asm__ ("fxam;"
-	    "fstsw %%ax": "=a" (sw) : "t" (_x));
+	    "fstsw %%ax": "=a" (sw) : "t" (__x));
   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
     == FP_NAN;
 }
 
-extern __inline__ int __isnanl (long double _x)
+extern __inline__ int __isnanl (long double __x)
 {
   unsigned short sw;
   __asm__ ("fxam;"
-	    "fstsw %%ax": "=a" (sw) : "t" (_x));
+	    "fstsw %%ax": "=a" (sw) : "t" (__x));
   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
     == FP_NAN;
 }
 
 
-#define isnan(x) (sizeof (x) == sizeof (float) ? __isnanf (x)	\
-		  : sizeof (x) == sizeof (double) ? __isnan (x)	\
-		  : __isnanl (x))
+#define isnan(__x) (sizeof (__x) == sizeof (float) ? __isnanf (__x)	\
+		  : sizeof (__x) == sizeof (double) ? __isnan (__x)	\
+		  : __isnanl (__x))
 
 /* 7.12.3.5 */
-#define isnormal(x) (fpclassify(x) == FP_NORMAL)
+#define isnormal(__x) (fpclassify(__x) == FP_NORMAL)
 
 /* 7.12.3.6 The signbit macro */
-extern __inline__ int __signbit (double x) {
+extern __inline__ int __signbit (double __x) {
   unsigned short stw;
-  __asm__ ( "fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
+  __asm__ ( "fxam; fstsw %%a__x;": "=a" (stw) : "t" (__x));
   return stw & 0x0200;
 }
 
-extern  __inline__ int __signbitf (float x) {
+extern  __inline__ int __signbitf (float __x) {
   unsigned short stw;
-  __asm__ ("fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
+  __asm__ ("fxam; fstsw %%a__x;": "=a" (stw) : "t" (__x));
   return stw & 0x0200;
 }
-extern  __inline__ int __signbitl (long double x) {
+extern  __inline__ int __signbitl (long double __x) {
   unsigned short stw;
-  __asm__ ("fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
+  __asm__ ("fxam; fstsw %%a__x;": "=a" (stw) : "t" (__x));
   return stw & 0x0200;
 }
 
 
-#define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x)	\
-		    : sizeof (x) == sizeof (double) ? __signbit (x)	\
-		    : __signbitl (x))
+#define signbit(__x) (sizeof (__x) == sizeof (float) ? __signbitf (__x)	\
+		    : sizeof (__x) == sizeof (double) ? __signbit (__x)	\
+		    : __signbitl (__x))
 
 /* 7.12.4 Trigonometric functions: Double in C89 */
 extern float sinf (float);
@@ -369,16 +366,16 @@ extern float atan2f (float, float);
 extern long double atan2l (long double, long double);
 
 /* 7.12.5 Hyperbolic functions: Double in C89  */
-extern __inline__ float sinhf (float x)
-  {return (float) __CSTD sinh (x);}
+extern __inline__ float sinhf (float __x)
+  {return (float) __CSTD sinh (__x);}
 extern long double sinhl (long double);
 
-extern __inline__ float coshf (float x)
-  {return (float) __CSTD cosh (x);}
+extern __inline__ float coshf (float __x)
+  {return (float) __CSTD cosh (__x);}
 extern long double coshl (long double);
 
-extern __inline__ float tanhf (float x)
-  {return (float) __CSTD tanh (x);}
+extern __inline__ float tanhf (float __x)
+  {return (float) __CSTD tanh (__x);}
 extern long double tanhl (long double);
 
 /*
@@ -386,8 +383,8 @@ extern long double tanhl (long double);
  */ 
 
 /* 7.12.6.1 Double in C89 */
-extern __inline__ float expf (float x)
-  {return (float) __CSTD exp (x);}
+extern __inline__ float expf (float __x)
+  {return (float) __CSTD exp (__x);}
 extern long double expl (long double);
 
 /* 7.12.6.2 */
@@ -398,8 +395,8 @@ extern long double exp2l(long double);
 /* 7.12.6.3 The expm1 functions: TODO */
 
 /* 7.12.6.4 Double in C89 */
-extern __inline__ float frexpf (float x, int* expn)
-  {return (float) __CSTD frexp (x, expn);}
+extern __inline__ float frexpf (float __x, int* __expn)
+  {return (float) __CSTD frexp (__x, __expn);}
 extern long double frexpl (long double, int*);
 
 /* 7.12.6.5 */
@@ -410,8 +407,8 @@ extern int ilogbf (float);
 extern int ilogbl (long double);
 
 /* 7.12.6.6  Double in C89 */
-extern __inline__ float ldexpf (float x, int expn)
-  {return (float) __CSTD ldexp (x, expn);}
+extern __inline__ float ldexpf (float __x, int __expn)
+  {return (float) __CSTD ldexp (__x, __expn);}
 extern long double ldexpl (long double, int);
 
 /* 7.12.6.7 Double in C89 */
@@ -437,27 +434,27 @@ extern double logb (double);
 extern float logbf (float);
 extern long double logbl (long double);
 
-extern __inline__ double logb (double x)
+extern __inline__ double logb (double __x)
 {
   double res;
   __asm__ ("fxtract\n\t"
-       "fstp	%%st" : "=t" (res) : "0" (x));
+       "fstp	%%st" : "=t" (res) : "0" (__x));
   return res;
 }
 
-extern __inline__ float logbf (float x)
+extern __inline__ float logbf (float __x)
 {
   float res;
   __asm__ ("fxtract\n\t"
-       "fstp	%%st" : "=t" (res) : "0" (x));
+       "fstp	%%st" : "=t" (res) : "0" (__x));
   return res;
 }
 
-extern __inline__ long double logbl (long double x)
+extern __inline__ long double logbl (long double __x)
 {
   long double res;
   __asm__ ("fxtract\n\t"
-       "fstp	%%st" : "=t" (res) : "0" (x));
+       "fstp	%%st" : "=t" (res) : "0" (__x));
   return res;
 }
 
@@ -481,43 +478,43 @@ extern float cbrtf (float);
 extern long double cbrtl (long double);
 
 /* 7.12.7.2 The fabs functions: Double in C89 */
-extern __inline__ float fabsf (float x)
+extern __inline__ float fabsf (float __x)
 {
   float res;
-  __asm__ ("fabs;" : "=t" (res) : "0" (x));
+  __asm__ ("fabs;" : "=t" (res) : "0" (__x));
   return res;
 }
 
-extern __inline__ long double fabsl (long double x)
+extern __inline__ long double fabsl (long double __x)
 {
   long double res;
-  __asm__ ("fabs;" : "=t" (res) : "0" (x));
+  __asm__ ("fabs;" : "=t" (res) : "0" (__x));
   return res;
 }
 
 /* 7.12.7.3  */
 extern double hypot (double, double); /* in libmoldname.a */
-extern __inline__ float hypotf (float x, float y)
-  { return (float) hypot (x, y);}
+extern __inline__ float hypotf (float __x, float __y)
+  { return (float) hypot (__x, __y);}
 extern long double hypotl (long double, long double);
 
 /* 7.12.7.4 The pow functions. Double in C89 */
-extern __inline__ float powf (float x, float y)
-  {return (float) __CSTD pow (x, y);}
+extern __inline__ float powf (float __x, float __y)
+  {return (float) __CSTD pow (__x, __y);}
 extern long double powl (long double, long double);
 
 /* 7.12.7.5 The sqrt functions. Double in C89. */
-extern __inline__ float sqrtf (float x)
+extern __inline__ float sqrtf (float __x)
 {
   float res;
-  __asm__ ("fsqrt" : "=t" (res) : "0" (x));
+  __asm__ ("fsqrt" : "=t" (res) : "0" (__x));
   return res;
 }
 
-extern __inline__ long double sqrtl (long double x)
+extern __inline__ long double sqrtl (long double __x)
 {
   long double res;
-  __asm__ ("fsqrt" : "=t" (res) : "0" (x));
+  __asm__ ("fsqrt" : "=t" (res) : "0" (__x));
   return res;
 }
 
@@ -538,73 +535,73 @@ extern long double nearbyintl (long double);
 
 /* 7.12.9.4 */
 /* round, using fpu control word settings */
-extern __inline__ double rint (double x)
+extern __inline__ double rint (double __x)
 {
   double retval;
-  __asm__ ("frndint;": "=t" (retval) : "0" (x));
+  __asm__ ("frndint;": "=t" (retval) : "0" (__x));
   return retval;
 }
 
-extern __inline__ float rintf (float x)
+extern __inline__ float rintf (float __x)
 {
   float retval;
-  __asm__ ("frndint;" : "=t" (retval) : "0" (x) );
+  __asm__ ("frndint;" : "=t" (retval) : "0" (__x) );
   return retval;
 }
 
-extern __inline__ long double rintl (long double x)
+extern __inline__ long double rintl (long double __x)
 {
   long double retval;
-  __asm__ ("frndint;" : "=t" (retval) : "0" (x) );
+  __asm__ ("frndint;" : "=t" (retval) : "0" (__x) );
   return retval;
 }
 
 /* 7.12.9.5 */
-extern __inline__ long lrint (double x) 
+extern __inline__ long lrint (double __x) 
 {
   long retval;  
   __asm__ __volatile__							      \
-    ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");				      \
+    ("fistpl %0"  : "=m" (retval) : "t" (__x) : "st");				      \
   return retval;
 }
 
-extern __inline__ long lrintf (float x) 
+extern __inline__ long lrintf (float __x) 
 {
   long retval;
   __asm__ __volatile__							      \
-    ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");				      \
+    ("fistpl %0"  : "=m" (retval) : "t" (__x) : "st");				      \
   return retval;
 }
 
-extern __inline__ long lrintl (long double x) 
+extern __inline__ long lrintl (long double __x) 
 {
   long retval;
   __asm__ __volatile__							      \
-    ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");				      \
+    ("fistpl %0"  : "=m" (retval) : "t" (__x) : "st");				      \
   return retval;
 }
 
-extern __inline__ long long llrint (double x) 
+extern __inline__ long long llrint (double __x) 
 {
   long long retval;
   __asm__ __volatile__							      \
-    ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");				      \
+    ("fistpll %0"  : "=m" (retval) : "t" (__x) : "st");				      \
   return retval;
 }
 
-extern __inline__ long long llrintf (float x) 
+extern __inline__ long long llrintf (float __x) 
 {
   long long retval;
   __asm__ __volatile__							      \
-    ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");				      \
+    ("fistpll %0"  : "=m" (retval) : "t" (__x) : "st");				      \
   return retval;
 }
 
-extern __inline__ long long llrintl (long double x) 
+extern __inline__ long long llrintl (long double __x) 
 {
   long long retval;
   __asm__ __volatile__							      \
-    ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");				      \
+    ("fistpll %0"  : "=m" (retval) : "t" (__x) : "st");				      \
   return retval;
 }
 
@@ -669,9 +666,9 @@ extern float nextafterf (float, float);
 
 /* 7.12.12.1 */
 /*  x > y ? (x - y) : 0.0  */
-extern double fdim (double x, double y);
-extern float fdimf (float x, float y);
-extern long double fdiml (long double x, long double y);
+extern double fdim (double __x, double __y);
+extern float fdimf (float __x, float __y);
+extern long double fdiml (long double __x, long double __y);
 
 /* fmax and fmin.
    NaN arguments are treated as missing data: if one argument is a NaN
@@ -694,7 +691,6 @@ extern double fma (double, double, double);
 extern float fmaf (float, float, float);
 extern long double fmal (long double, long double, long double);
 
-
 /* 7.12.14 */
 /* 
  *  With these functions, comparisons involving quiet NaNs set the FP
@@ -706,34 +702,34 @@ extern long double fmal (long double, long double, long double);
 
 #if __GNUC__ >= 3
 
-#define isgreater(x, y) __builtin_isgreater(x, y)
-#define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
-#define isless(x, y) __builtin_isless(x, y)
-#define islessequal(x, y) __builtin_islessequal(x, y)
-#define islessgreater(x, y) __builtin_islessgreater(x, y)
-#define isunordered(x, y) __builtin_isunordered(x, y)
+#define isgreater(__x, __y) __builtin_isgreater(__x, __y)
+#define isgreaterequal(__x, __y) __builtin_isgreaterequal(__x, __y)
+#define isless(__x, __y) __builtin_isless(__x, __y)
+#define islessequal(__x, __y) __builtin_islessequal(__x, __y)
+#define islessgreater(__x, __y) __builtin_islessgreater(__x, __y)
+#define isunordered(__x, __y) __builtin_isunordered(__x, __y)
 
 #else
 /*  helper  */
 extern  __inline__ int
-__fp_unordered_compare (long double x, long double y){
+__fp_unordered_compare (long double __x, long double __y){
   unsigned short retval;
   __asm__ ("fucom %%st(1);"
-	   "fnstsw;": "=a" (retval) : "t" (x), "u" (y));
+	   "fnstsw;": "=a" (retval) : "t" (__x), "u" (__y));
   return retval;
 }
 
-#define isgreater(x, y) ((__fp_unordered_compare(x, y) \
+#define isgreater(__x, __y) ((__fp_unordered_compare(__x, __y) \
 			   & 0x4500) == 0)
-#define isless(x, y) ((__fp_unordered_compare (y, x) \
+#define isless(__x, __y) ((__fp_unordered_compare (__y, __x) \
                        & 0x4500) == 0)
-#define isgreaterequal(x, y) ((__fp_unordered_compare (x, y) \
+#define isgreaterequal(__x, __y) ((__fp_unordered_compare (__x, __y) \
                                & FP_INFINITE) == 0)
-#define islessequal(x, y) ((__fp_unordered_compare(y, x) \
+#define islessequal(__x, __y) ((__fp_unordered_compare(__y, __x) \
 			    & FP_INFINITE) == 0)
-#define islessgreater(x, y) ((__fp_unordered_compare(x, y) \
+#define islessgreater(__x, __y) ((__fp_unordered_compare(__x, __y) \
 			      & FP_SUBNORMAL) == 0)
-#define isunordered(x, y) ((__fp_unordered_compare(x, y) \
+#define isunordered(__x, __y) ((__fp_unordered_compare(__x, __y) \
 			    & 0x4500) == 0x4500)
 
 #endif
@@ -744,6 +740,7 @@ __fp_unordered_compare (long double x, long double y){
 
 __END_CGLOBAL_NAMESPACE
 
+
 #endif	/* Not RC_INVOKED */
 
 
diff --git a/winsup/mingw/include/stdio.h b/winsup/mingw/include/stdio.h
index ebe221539ce..0670e94d629 100644
--- a/winsup/mingw/include/stdio.h
+++ b/winsup/mingw/include/stdio.h
@@ -231,9 +231,9 @@ int	_vsnprintf (char*, size_t, const char*, __VALIST);
 
 #ifndef __NO_ISOCEXT  /* externs in libmingwex.a */
 int snprintf(char* s, size_t n, const char*  format, ...);
-extern __inline__ int vsnprintf (char* s, size_t n, const char* format,
-			   __VALIST arg)
-  { return _vsnprintf ( s, n, format, arg); }
+extern __inline__ int
+vsnprintf (char* __s, size_t __n, const char* __format, __VALIST __arg)
+  { return _vsnprintf ( __s, __n, __format, __arg); }
 #endif
 
 __END_CGLOBAL_NAMESPACE
@@ -382,8 +382,9 @@ int	_vsnwprintf (wchar_t*, size_t, const wchar_t*, __VALIST);
 #ifndef __NO_ISOCEXT  /* externs in libmingwex.a */
 int snwprintf(wchar_t* s, size_t n, const wchar_t*  format, ...);
 extern __inline__ int
-vsnwprintf (wchar_t* s, size_t n, const wchar_t* format, __VALIST arg)
-  { return _vsnwprintf ( s, n, format, arg);}
+vsnwprintf (wchar_t* __s, size_t __n, const wchar_t* __format,
+	    __VALIST __arg)
+  { return _vsnwprintf ( __s, __n, __format, __arg);}
 #endif
 
 __END_CGLOBAL_NAMESPACE
diff --git a/winsup/mingw/include/stdlib.h b/winsup/mingw/include/stdlib.h
index d9e05c9e1e8..eb06c7138cb 100644
--- a/winsup/mingw/include/stdlib.h
+++ b/winsup/mingw/include/stdlib.h
@@ -296,8 +296,8 @@ long	atol	(const char*);
 
 double	strtod	(const char*, char**);
 #if !defined __NO_ISOCEXT  /* extern stubs in static libmingwex.a */
-extern __inline__ float strtof (const char *nptr, char **endptr)
-  { return (strtod (nptr, endptr));}
+extern __inline__ float strtof (const char *__nptr, char **__endptr)
+  { return (strtod (__nptr, __endptr));}
 #endif /* __NO_ISOCEXT */
 
 long	strtol	(const char*, char**, int);
@@ -316,8 +316,8 @@ __BEGIN_CSTD_NAMESPACE
 /*  also declared in wchar.h */
 double	wcstod	(const wchar_t*, wchar_t**);
 #if !defined __NO_ISOCEXT /* extern stub in static libmingwex.a */
-extern __inline__ float wcstof( const wchar_t *nptr, wchar_t **endptr)
-{  return (wcstod(nptr, endptr)); }
+extern __inline__ float wcstof( const wchar_t *__nptr, wchar_t **__endptr)
+{  return (wcstod(__nptr, __endptr)); }
 #endif /* __NO_ISOCEXT */
 
 long	wcstol	(const wchar_t*, wchar_t**, int);
@@ -452,15 +452,15 @@ char*	gcvt (double, int, char*);
 
 void _Exit(int) _ATTRIB_NORETURN; /* Declare to get noreturn attribute.  */
 #ifndef __STRICT_ANSI__ /* inline using non-ANSI exit */
-extern __inline__ void _Exit(int status)
-	{ __CGLOBAL _exit(status); }
+extern __inline__ void _Exit(int __status)
+	{ __CGLOBAL _exit(__status); }
 #endif
 
 typedef struct { long long quot, rem; } lldiv_t;
 lldiv_t	lldiv (long long, long long);
 
-extern __inline__ long long llabs(long long _j)
-  {return (_j >= 0 ? _j : -_j);}
+extern __inline__ long long llabs(long long __j)
+  {return (__j >= 0 ? __j : -__j);}
 
 long long strtoll (const char* __restrict__, char** __restrict, int);
 unsigned long long strtoull (const char* __restrict__, char** __restrict__, int);
@@ -469,8 +469,8 @@ unsigned long long strtoull (const char* __restrict__, char** __restrict__, int)
 long long atoll (const char *);
 #if !defined (__STRICT_ANSI__)
   /* inline using non-ansi function */
-extern __inline__ long long  atoll (const char * _c)
-	{ return  __CGLOBAL _atoi64 (_c); }
+extern __inline__ long long  atoll (const char * __c)
+	{ return  __CGLOBAL _atoi64 (__c); }
 #endif
 #endif
 #endif /* __NO_ISOCEXT */
@@ -488,16 +488,16 @@ wchar_t* lltow(long long, wchar_t *, int);
 wchar_t* ulltow(unsigned long long, wchar_t *, int);
 
   /* inline using non-ansi functions */
-extern __inline__ char* lltoa(long long _n, char * _c, int _i)
-	{ return _i64toa (_n, _c, _i); }
-extern __inline__ char* ulltoa(unsigned long long _n, char * _c, int _i)
-	{ return _ui64toa (_n, _c, _i); }
-extern __inline__ long long wtoll(const wchar_t * _w)
- 	{ return _wtoi64 (_w); }
-extern __inline__ wchar_t* lltow(long long _n, wchar_t * _w, int _i)
-	{ return _i64tow (_n, _w, _i); } 
-extern __inline__ wchar_t* ulltow(unsigned long long _n, wchar_t * _w, int _i)
-	{ return _ui64tow (_n, _w, _i); } 
+extern __inline__ char* lltoa(long long __n, char * __c, int __i)
+	{ return _i64toa (__n, __c, __i); }
+extern __inline__ char* ulltoa(unsigned long long __n, char * __c, int __i)
+	{ return _ui64toa (__n, __c, __i); }
+extern __inline__ long long wtoll(const wchar_t * __w)
+ 	{ return _wtoi64 (__w); }
+extern __inline__ wchar_t* lltow(long long __n, wchar_t * __w, int __i)
+	{ return _i64tow (__n, __w, __i); } 
+extern __inline__ wchar_t* ulltow(unsigned long long __n, wchar_t * __w, int __i)
+	{ return _ui64tow (__n, __w, __i); } 
 
 #endif /* (__STRICT_ANSI__)  */
 #endif /* __MSVCRT__ */
diff --git a/winsup/mingw/include/wchar.h b/winsup/mingw/include/wchar.h
index 0238668c2dc..b09110c0000 100644
--- a/winsup/mingw/include/wchar.h
+++ b/winsup/mingw/include/wchar.h
@@ -150,8 +150,9 @@ int	_vsnwprintf (wchar_t*, size_t, const wchar_t*, __VALIST);
 #ifndef __NO_ISOCEXT  /* externs in libmingwex.a */
 int snwprintf(wchar_t* s, size_t n, const wchar_t*  format, ...);
 extern __inline__ int
-vsnwprintf (wchar_t* s, size_t n, const wchar_t* format, __VALIST arg)
-  { return _vsnwprintf ( s, n, format, arg);}
+vsnwprintf (wchar_t* __s, size_t __n, const wchar_t* __format,
+	    __VALIST __arg)
+  { return _vsnwprintf ( __s, __n, __format, __arg);}
 #endif
 __END_CGLOBAL_NAMESPACE
 
@@ -404,8 +405,8 @@ long	wcstol	(const wchar_t*, wchar_t**, int);
 unsigned long	wcstoul (const wchar_t*, wchar_t**, int);
 double	wcstod	(const wchar_t*, wchar_t**);
 #if !defined __NO_ISOCEXT /* extern stub in static libmingwex.a */
-extern __inline__ float wcstof( const wchar_t *nptr, wchar_t **endptr)
-{  return (wcstod(nptr, endptr)); }
+extern __inline__ float wcstof( const wchar_t *__nptr, wchar_t **__endptr)
+{  return (wcstod(__nptr, __endptr)); }
 #endif /* __NO_ISOCEXT */
 __END_CSTD_NAMESPACE
 #define  _WSTDLIB_DEFINED
@@ -433,8 +434,10 @@ size_t  wcsrtombs(char *, const wchar_t **, size_t, mbstate_t *);
 int  	wctob(wint_t);
 
 #ifndef __NO_ISOCEXT /* these need static lib libmingwex.a */
-extern __inline__ int fwide(FILE* stream, int mode) {return -1;} /* limited to byte orientation */ 
-extern __inline__ int mbsinit(const mbstate_t* ps) {return 1;}
+extern __inline__ int fwide(FILE* __stream, int __mode)
+  {return -1;} /* limited to byte orientation */ 
+extern __inline__ int mbsinit(const mbstate_t* __ps)
+  {return 1;}
 wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n);
 wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);
 int wmemcmp(const wchar_t* s1, const wchar_t * s2, size_t n);
diff --git a/winsup/mingw/include/wctype.h b/winsup/mingw/include/wctype.h
index 443a9f05fcd..aa9340c507b 100644
--- a/winsup/mingw/include/wctype.h
+++ b/winsup/mingw/include/wctype.h
@@ -108,19 +108,20 @@ extern unsigned short** _imp___ctype;
 
 #if !(defined(__NO_CTYPE_INLINES) || defined(__WCTYPE_INLINES_DEFINED))
 #define __WCTYPE_INLINES_DEFINED
-extern __inline__ int iswalnum(wint_t wc) {return (iswctype(wc,_ALPHA|_DIGIT));}
-extern __inline__ int iswalpha(wint_t wc) {return (iswctype(wc,_ALPHA));}
-extern __inline__ int iswascii(wint_t wc) {return (((unsigned)wc & 0x7F) ==0);}
-extern __inline__ int iswcntrl(wint_t wc) {return (iswctype(wc,_CONTROL));}
-extern __inline__ int iswdigit(wint_t wc) {return (iswctype(wc,_DIGIT));}
-extern __inline__ int iswgraph(wint_t wc) {return (iswctype(wc,_PUNCT|_ALPHA|_DIGIT));}
-extern __inline__ int iswlower(wint_t wc) {return (iswctype(wc,_LOWER));}
-extern __inline__ int iswprint(wint_t wc) {return (iswctype(wc,_BLANK|_PUNCT|_ALPHA|_DIGIT));}
-extern __inline__ int iswpunct(wint_t wc) {return (iswctype(wc,_PUNCT));}
-extern __inline__ int iswspace(wint_t wc) {return (iswctype(wc,_SPACE));}
-extern __inline__ int iswupper(wint_t wc) {return (iswctype(wc,_UPPER));}
-extern __inline__ int iswxdigit(wint_t wc) {return (iswctype(wc,_HEX));}
-extern __inline__ int isleadbyte(int c) {return (_pctype[(unsigned char)(c)] & _LEADBYTE);}
+extern __inline__ int iswalnum(wint_t__wc) {return (iswctype(__wc,_ALPHA|_DIGIT));}
+extern __inline__ int iswalpha(wint_t__wc) {return (iswctype(__wc,_ALPHA));}
+extern __inline__ int iswascii(wint_t__wc) {return (((unsigned)wc & 0x7F) ==0);}
+extern __inline__ int iswcntrl(wint_t__wc) {return (iswctype(__wc,_CONTROL));}
+extern __inline__ int iswdigit(wint_t__wc) {return (iswctype(__wc,_DIGIT));}
+extern __inline__ int iswgraph(wint_t__wc) {return (iswctype(__wc,_PUNCT|_ALPHA|_DIGIT));}
+extern __inline__ int iswlower(wint_t__wc) {return (iswctype(__wc,_LOWER));}
+extern __inline__ int iswprint(wint_t__wc) {return (iswctype(__wc,_BLANK|_PUNCT|_ALPHA|_DIGIT));}
+extern __inline__ int iswpunct(wint_t__wc) {return (iswctype(__wc,_PUNCT));}
+extern __inline__ int iswspace(wint_t__wc) {return (iswctype(__wc,_SPACE));}
+extern __inline__ int iswupper(wint_t__wc) {return (iswctype(__wc,_UPPER));}
+extern __inline__ int iswxdigit(wint_t__wc) {return (iswctype(__wc,_HEX));}
+extern __inline__ int isleadbyte(int __c)
+  {return (_pctype[(unsigned char)(__c)] & _LEADBYTE);}
 #endif /* !(defined(__NO_CTYPE_INLINES) || defined(__WCTYPE_INLINES_DEFINED)) */