* libc/ctype/iswalpha.c: Handle all wchar_t as unicode on

	_MB_CAPABLE systems.
	* libc/ctype/iswblank.c: Ditto.
	* libc/ctype/iswcntrl.c: Ditto.
	* libc/ctype/iswprint.c: Ditto.
	* libc/ctype/iswpunct.c: Ditto.
	* libc/ctype/iswspace.c: Ditto.
	* libc/ctype/jp2uc.c (__jp2uc): On Cygwin, just return c.
	Explain why.
	* libc/ctype/towlower.c: Ditto.
	* libc/ctype/towupper.c: Ditto.
	* libc/include/sys/config.h: Define _MB_EXTENDED_CHARSETS_ISO
	and _MB_EXTENDED_CHARSETS_WINDOWS if _MB_EXTENDED_CHARSETS_ALL is
	defined.  Define _MB_EXTENDED_CHARSETS_ALL on Cygwin only for now.
	* libc/include/sys/reent.h (struct _reent): Mark _current_category
	and _current_locale as unused.
	* libc/locale/locale.c: Add new charset support to documentation.
	Include ../stdio/local.h from here.
	(lc_ctype_charset): Set to "ASCII" by default.
	(lc_message_charset): Ditto.
	(_setlocale_r): Don't set _current_category and _current_locale.
	(loadlocale): Add Cygwin codepage support.  On _MB_CAPABLE
	systems, set __mbtowc and __wctomb function pointers to function
	corresponding with current charset.  Don't allow non-existant
	ISO-8859-12 charset.  Add support for Windows singlebyte codepages.
	On Cygwin, add support for GBK, CP949, and BIG5.  On Cygwin,
	call __set_ctype() in case the catorgy is LC_CTYPE.  Don't set
	_current_category and _current_locale.
	* libc/stdlib/Makefile.am (GENERAL_SOURCES): Add sb_charsets.c.
	* libc/stdlib/Makefile.in: Regenerate.
	* libc/stdlib/local.h: Add prototype for __locale_charset.
	Add prototypes for __mbtowc and __wctomb pointers.
	Add prototypes for charset-specific _wctomb_r and _mbtowc_r
	functions.
	Declare tables and functions from sb_charsets.c.
	* libc/stdlib/mbtowc_r.c (__mbtowc): Define.  Set to __ascii_mbtowc
	by default.
	(_mbtowc_r): Just call __mbtowc from here.
	(__ascii_mbtowc): New function.
	(__iso_mbtowc): New function.
	(__cp_mbtowc): New function.
	(__utf8_mbtowc): New function.
	(__sjis_mbtowc): New function.  Disable on Cygwin.
	(__eucjp_mbtowc): New function.  Disable on Cygwin.
	(__jis_mbtowc): New function.  Disable on Cygwin.
	* libc/stdlib/sb_charsets.c: New file, adding singlebyte to UTF
	conversion tables for all ISO and CP charsets.
	(__iso_8859_index): New function.
	(__cp_index): New function.
	* libc/stdlib/wctomb_r.c (__wctomb): Define.  Set to __ascii_wctomb
	by default.
	(_wctomb_r): Just call __wctomb from here.
	(__ascii_wctomb): New function.
	(__utf8_wctomb): New function.
	(__sjis_wctomb): New function.  Disable on Cygwin.
	(__eucjp_wctomb): New function.  Disable on Cygwin.
	(__jis_wctomb): New function.  Disable on Cygwin.
	(__iso_wctomb): New function.
	(__cp_wctomb): New function.

9 files changed, 1516 insertions, 1652 deletions

diff --git a/newlib/libc/ctype/iswalpha.c b/newlib/libc/ctype/iswalpha.c
index a2c9cf9b9..4e2ad6b0d 100644
--- a/newlib/libc/ctype/iswalpha.c
+++ b/newlib/libc/ctype/iswalpha.c
@@ -70,270 +70,253 @@ int
 _DEFUN(iswalpha,(c), wint_t c)
 {
 #ifdef _MB_CAPABLE
-  int unicode = 0;
+  unsigned const char *table;
+  unsigned char *ptr;
+  unsigned char ctmp;
+  int size;
+  wint_t x;
 
   if (!strcmp (__locale_charset (), "JIS"))
-    {
-      c = __jp2uc (c, JP_JIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_JIS);
   else if (!strcmp (__locale_charset (), "SJIS"))
-    {
-      c = __jp2uc (c, JP_SJIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_SJIS);
   else if (!strcmp (__locale_charset (), "EUCJP"))
+    c = __jp2uc (c, JP_EUCJP);
+
+  x = (c >> 8);
+  /* for some large sections, all characters are alphabetic so handle them here */
+  if ((x >= 0x34 && x <= 0x4c) ||
+      (x >= 0x4e && x <= 0x9e) ||
+      (x >= 0xac && x <= 0xd6) ||
+      (x >= 0x200 && x <= 0x2a5))
+    return 1;
+  
+  switch (x)
     {
-      c = __jp2uc (c, JP_EUCJP);
-      unicode = 1;
-    }
-  else if (!strcmp (__locale_charset (), "UTF-8"))
-    {
-      unicode = 1;
+    case 0x00:
+      table = u0;
+      size = sizeof(u0);
+      break;
+    case 0x01:
+    case 0x15:
+    case 0xa0:
+    case 0xa1:
+    case 0xa2:
+    case 0xa3:
+    case 0xf9:
+    case 0xfc:
+    case 0x2f8:
+    case 0x2f9:
+      return 1;
+    case 0x02:
+      table = u2;
+      size = sizeof(u2);
+      break;
+    case 0x03:
+      table = u3;
+      size = sizeof(u3);
+      break;
+    case 0x04:
+      table = u4;
+      size = sizeof(u4);
+      break;
+    case 0x05:
+      table = u5;
+      size = sizeof(u5);
+      break;
+    case 0x06:
+      table = u6;
+      size = sizeof(u6);
+      break;
+    case 0x07:
+      table = u7;
+      size = sizeof(u7);
+      break;
+    case 0x09:
+      table = u9;
+      size = sizeof(u9);
+      break;
+    case 0x0a:
+      table = ua;
+      size = sizeof(ua);
+      break;
+    case 0x0b:
+      table = ub;
+      size = sizeof(ub);
+      break;
+    case 0x0c:
+      table = uc;
+      size = sizeof(uc);
+      break;
+    case 0x0d:
+      table = ud;
+      size = sizeof(ud);
+      break;
+    case 0x0e:
+      table = ue;
+      size = sizeof(ue);
+      break;
+    case 0x0f:
+      table = uf;
+      size = sizeof(uf);
+      break;
+    case 0x10:
+      table = u10;
+      size = sizeof(u10);
+      break;
+    case 0x11:
+      table = u11;
+      size = sizeof(u11);
+      break;
+    case 0x12:
+      table = u12;
+      size = sizeof(u12);
+      break;
+    case 0x13:
+      table = u13;
+      size = sizeof(u13);
+      break;
+    case 0x14:
+      table = u14;
+      size = sizeof(u14);
+      break;
+    case 0x16:
+      table = u16;
+      size = sizeof(u16);
+      break;
+    case 0x17:
+      table = u17;
+      size = sizeof(u17);
+      break;
+    case 0x18:
+      table = u18;
+      size = sizeof(u18);
+      break;
+    case 0x1e:
+      table = u1e;
+      size = sizeof(u1e);
+      break;
+    case 0x1f:
+      table = u1f;
+      size = sizeof(u1f);
+      break;
+    case 0x20:
+      table = u20;
+      size = sizeof(u20);
+      break;
+    case 0x21:
+      table = u21;
+      size = sizeof(u21);
+      break;
+    case 0x24:
+      table = u24;
+      size = sizeof(u24);
+      break;
+    case 0x30:
+      table = u30;
+      size = sizeof(u30);
+      break;
+    case 0x31:
+      table = u31;
+      size = sizeof(u31);
+      break;
+    case 0x4d:
+      table = u4d;
+      size = sizeof(u4d);
+      break;
+    case 0x9f:
+      table = u9f;
+      size = sizeof(u9f);
+      break;
+    case 0xa4:
+      table = ua4;
+      size = sizeof(ua4);
+      break;
+    case 0xd7:
+      table = ud7;
+      size = sizeof(ud7);
+      break;
+    case 0xfa:
+      table = ufa;
+      size = sizeof(ufa);
+      break;
+    case 0xfb:
+      table = ufb;
+      size = sizeof(ufb);
+      break;
+    case 0xfd:
+      table = ufd;
+      size = sizeof(ufd);
+      break;
+    case 0xfe:
+      table = ufe;
+      size = sizeof(ufe);
+      break;
+    case 0xff:
+      table = uff;
+      size = sizeof(uff);
+      break;
+    case 0x103:
+      table = u103;
+      size = sizeof(u103);
+      break;
+    case 0x104:
+      table = u104;
+      size = sizeof(u104);
+      break;
+    case 0x1d4:
+      table = u1d4;
+      size = sizeof(u1d4);
+      break;
+    case 0x1d5:
+      table = u1d5;
+      size = sizeof(u1d5);
+      break;
+    case 0x1d6:
+      table = u1d6;
+      size = sizeof(u1d6);
+      break;
+    case 0x1d7:
+      table = u1d7;
+      size = sizeof(u1d7);
+      break;
+    case 0x2a6:
+      table = u2a6;
+      size = sizeof(u2a6);
+      break;
+    case 0x2fa:
+      table = u2fa;
+      size = sizeof(u2fa);
+      break;
+    default:
+      return 0;
     }
-
-  if (unicode)
+  /* we have narrowed down to a section of 256 characters to check */
+  /* now check if c matches the alphabetic wide-chars within that section */
+  ptr = (unsigned char *)table;
+  ctmp = (unsigned char)c;
+  while (ptr < table + size)
     {
-      unsigned const char *table;
-      unsigned char *ptr;
-      unsigned char ctmp;
-      int size;
-      wint_t x = (c >> 8);
-      
-      /* for some large sections, all characters are alphabetic so handle them here */
-      if ((x >= 0x34 && x <= 0x4c) ||
-	  (x >= 0x4e && x <= 0x9e) ||
-	  (x >= 0xac && x <= 0xd6) ||
-	  (x >= 0x200 && x <= 0x2a5))
+      if (ctmp == *ptr)
 	return 1;
-      
-      switch (x)
-	{
-	case 0x00:
-	  table = u0;
-	  size = sizeof(u0);
-	  break;
-	case 0x01:
-	case 0x15:
-	case 0xa0:
-	case 0xa1:
-	case 0xa2:
-	case 0xa3:
-	case 0xf9:
-	case 0xfc:
-	case 0x2f8:
-	case 0x2f9:
-	  return 1;
-	case 0x02:
-	  table = u2;
-	  size = sizeof(u2);
-	  break;
-	case 0x03:
-	  table = u3;
-	  size = sizeof(u3);
-	  break;
-	case 0x04:
-	  table = u4;
-	  size = sizeof(u4);
-	  break;
-	case 0x05:
-	  table = u5;
-	  size = sizeof(u5);
-	  break;
-	case 0x06:
-	  table = u6;
-	  size = sizeof(u6);
-	  break;
-	case 0x07:
-	  table = u7;
-	  size = sizeof(u7);
-	  break;
-	case 0x09:
-	  table = u9;
-	  size = sizeof(u9);
-	  break;
-	case 0x0a:
-	  table = ua;
-	  size = sizeof(ua);
-	  break;
-	case 0x0b:
-	  table = ub;
-	  size = sizeof(ub);
-	  break;
-	case 0x0c:
-	  table = uc;
-	  size = sizeof(uc);
-	  break;
-	case 0x0d:
-	  table = ud;
-	  size = sizeof(ud);
-	  break;
-	case 0x0e:
-	  table = ue;
-	  size = sizeof(ue);
-	  break;
-	case 0x0f:
-	  table = uf;
-	  size = sizeof(uf);
-	  break;
-	case 0x10:
-	  table = u10;
-	  size = sizeof(u10);
-	  break;
-	case 0x11:
-	  table = u11;
-	  size = sizeof(u11);
-	  break;
-	case 0x12:
-	  table = u12;
-	  size = sizeof(u12);
-	  break;
-	case 0x13:
-	  table = u13;
-	  size = sizeof(u13);
-	  break;
-	case 0x14:
-	  table = u14;
-	  size = sizeof(u14);
-	  break;
-	case 0x16:
-	  table = u16;
-	  size = sizeof(u16);
-	  break;
-	case 0x17:
-	  table = u17;
-	  size = sizeof(u17);
-	  break;
-	case 0x18:
-	  table = u18;
-	  size = sizeof(u18);
-	  break;
-	case 0x1e:
-	  table = u1e;
-	  size = sizeof(u1e);
-	  break;
-	case 0x1f:
-	  table = u1f;
-	  size = sizeof(u1f);
-	  break;
-	case 0x20:
-	  table = u20;
-	  size = sizeof(u20);
-	  break;
-	case 0x21:
-	  table = u21;
-	  size = sizeof(u21);
-	  break;
-	case 0x24:
-	  table = u24;
-	  size = sizeof(u24);
-	  break;
-	case 0x30:
-	  table = u30;
-	  size = sizeof(u30);
-	  break;
-	case 0x31:
-	  table = u31;
-	  size = sizeof(u31);
-	  break;
-	case 0x4d:
-	  table = u4d;
-	  size = sizeof(u4d);
-	  break;
-	case 0x9f:
-	  table = u9f;
-	  size = sizeof(u9f);
-	  break;
-	case 0xa4:
-	  table = ua4;
-	  size = sizeof(ua4);
-	  break;
-	case 0xd7:
-	  table = ud7;
-	  size = sizeof(ud7);
-	  break;
-	case 0xfa:
-	  table = ufa;
-	  size = sizeof(ufa);
-	  break;
-	case 0xfb:
-	  table = ufb;
-	  size = sizeof(ufb);
-	  break;
-	case 0xfd:
-	  table = ufd;
-	  size = sizeof(ufd);
-	  break;
-	case 0xfe:
-	  table = ufe;
-	  size = sizeof(ufe);
-	  break;
-	case 0xff:
-	  table = uff;
-	  size = sizeof(uff);
-	  break;
-	case 0x103:
-	  table = u103;
-	  size = sizeof(u103);
-	  break;
-	case 0x104:
-	  table = u104;
-	  size = sizeof(u104);
-	  break;
-	case 0x1d4:
-	  table = u1d4;
-	  size = sizeof(u1d4);
-	  break;
-	case 0x1d5:
-	  table = u1d5;
-	  size = sizeof(u1d5);
-	  break;
-	case 0x1d6:
-	  table = u1d6;
-	  size = sizeof(u1d6);
-	  break;
-	case 0x1d7:
-	  table = u1d7;
-	  size = sizeof(u1d7);
-	  break;
-	case 0x2a6:
-	  table = u2a6;
-	  size = sizeof(u2a6);
-	  break;
-	case 0x2fa:
-	  table = u2fa;
-	  size = sizeof(u2fa);
-	  break;
-	default:
-	  return 0;
-	}
-      /* we have narrowed down to a section of 256 characters to check */
-      /* now check if c matches the alphabetic wide-chars within that section */
-      ptr = (unsigned char *)table;
-      ctmp = (unsigned char)c;
-      while (ptr < table + size)
+      if (ctmp < *ptr)
+	return 0;
+      /* otherwise c > *ptr */
+      /* look for 0x0 as next element which indicates a range */
+      ++ptr;
+      if (*ptr == 0x0)
 	{
-	  if (ctmp == *ptr)
+	  /* we have a range..see if c falls within range */
+	  ++ptr;
+	  if (ctmp <= *ptr)
 	    return 1;
-	  if (ctmp < *ptr)
-	    return 0;
-	  /* otherwise c > *ptr */
-	  /* look for 0x0 as next element which indicates a range */
 	  ++ptr;
-	  if (*ptr == 0x0)
-	    {
-	      /* we have a range..see if c falls within range */
-	      ++ptr;
-	      if (ctmp <= *ptr)
-		return 1;
-	      ++ptr;
-	    }
 	}
-      /* not in table */
-      return 0;
     }
-#endif /* _MB_CAPABLE */
-
+  /* not in table */
+  return 0;
+#else
   return (c < (wint_t)0x100 ? isalpha (c) : 0);
+#endif /* _MB_CAPABLE */
 }
 
diff --git a/newlib/libc/ctype/iswblank.c b/newlib/libc/ctype/iswblank.c
index 4db8ae013..e0601e945 100644
--- a/newlib/libc/ctype/iswblank.c
+++ b/newlib/libc/ctype/iswblank.c
@@ -66,37 +66,18 @@ int
 _DEFUN(iswblank,(c), wint_t c)
 {
 #ifdef _MB_CAPABLE
-  int unicode = 0;
-
   if (!strcmp (__locale_charset (), "JIS"))
-    {
-      c = __jp2uc (c, JP_JIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_JIS);
   else if (!strcmp (__locale_charset (), "SJIS"))
-    {
-      c = __jp2uc (c, JP_SJIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_SJIS);
   else if (!strcmp (__locale_charset (), "EUCJP"))
-    {
-      c = __jp2uc (c, JP_EUCJP);
-      unicode = 1;
-    }
-  else if (!strcmp (__locale_charset (), "UTF-8"))
-    {
-      unicode = 1;
-    }
-
-  if (unicode)
-    {
-      return (c == 0x0009 || c == 0x0020 || c == 0x1680 ||
-              (c >= 0x2000 && c <= 0x2006) ||
-              (c >= 0x2008 && c <= 0x200b) ||
-              c == 0x205f || c == 0x3000);
-    }
-#endif /* _MB_CAPABLE */
-
+    c = __jp2uc (c, JP_EUCJP);
+  return (c == 0x0009 || c == 0x0020 || c == 0x1680 ||
+	  (c >= 0x2000 && c <= 0x2006) ||
+	  (c >= 0x2008 && c <= 0x200b) ||
+	  c == 0x205f || c == 0x3000);
+#else
   return (c < 0x100 ? isblank (c) : 0);
+#endif /* _MB_CAPABLE */
 }
 
diff --git a/newlib/libc/ctype/iswcntrl.c b/newlib/libc/ctype/iswcntrl.c
index b9f946072..2d8a1ddd6 100644
--- a/newlib/libc/ctype/iswcntrl.c
+++ b/newlib/libc/ctype/iswcntrl.c
@@ -66,36 +66,17 @@ int
 _DEFUN(iswcntrl,(c), wint_t c)
 {
 #ifdef _MB_CAPABLE
-  int unicode = 0;
-
   if (!strcmp (__locale_charset (), "JIS"))
-    {
-      c = __jp2uc (c, JP_JIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_JIS);
   else if (!strcmp (__locale_charset (), "SJIS"))
-    {
-      c = __jp2uc (c, JP_SJIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_SJIS);
   else if (!strcmp (__locale_charset (), "EUCJP"))
-    {
-      c = __jp2uc (c, JP_EUCJP);
-      unicode = 1;
-    }
-  else if (!strcmp (__locale_charset (), "UTF-8"))
-    {
-      unicode = 1;
-    }
-
-  if (unicode)
-    {
-      return ((c >= 0x0000 && c <= 0x001f) || 
-              (c >= 0x007f && c <= 0x009f) ||
-              c == 0x2028 || c == 0x2029);
-    }
-#endif /* _MB_CAPABLE */
-
+    c = __jp2uc (c, JP_EUCJP);
+  return ((c >= 0x0000 && c <= 0x001f) || 
+	  (c >= 0x007f && c <= 0x009f) ||
+	  c == 0x2028 || c == 0x2029);
+#else
   return (c < 0x100 ? iscntrl (c) : 0);
+#endif /* _MB_CAPABLE */
 }
 
diff --git a/newlib/libc/ctype/iswprint.c b/newlib/libc/ctype/iswprint.c
index 814a26bfd..a632aa405 100644
--- a/newlib/libc/ctype/iswprint.c
+++ b/newlib/libc/ctype/iswprint.c
@@ -70,325 +70,308 @@ int
 _DEFUN(iswprint,(c), wint_t c)
 {
 #ifdef _MB_CAPABLE
-  int unicode = 0;
-
+  unsigned const char *table;
+  unsigned char *ptr;
+  unsigned char ctmp;
+  int size;
+  wint_t x;
+  
   if (!strcmp (__locale_charset (), "JIS"))
-    {
-      c = __jp2uc (c, JP_JIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_JIS);
   else if (!strcmp (__locale_charset (), "SJIS"))
-    {
-      c = __jp2uc (c, JP_SJIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_SJIS);
   else if (!strcmp (__locale_charset (), "EUCJP"))
+    c = __jp2uc (c, JP_EUCJP);
+
+  x = (c >> 8);
+  /* for some large sections, all characters are printuation so handle them here */
+  if ((x >= 0x34 && x <= 0x4c) ||
+      (x >= 0x4e && x <= 0x9e) ||
+      (x >= 0xac && x <= 0xd6) ||
+      (x >= 0xe0 && x <= 0xf9) ||
+      (x >= 0x200 && x <= 0x2a5) ||
+      (x >= 0xf00 && x <= 0xffe) ||
+      (x >= 0x1000 && x <= 0x10fe))
+    return 1;
+  
+  switch (x)
     {
-      c = __jp2uc (c, JP_EUCJP);
-      unicode = 1;
+    case 0x01:
+    case 0x15:
+    case 0x22:
+    case 0x25:
+    case 0x28:
+    case 0x29:
+    case 0x2a:
+    case 0xa0:
+    case 0xa1:
+    case 0xa2:
+    case 0xa3:
+    case 0xfc:
+    case 0x2f8:
+    case 0x2f9:
+      return 1;
+    case 0x00:
+      table = u0;
+      size = sizeof(u0);
+      break;
+    case 0x02:
+      table = u2;
+      size = sizeof(u2);
+      break;
+    case 0x03:
+      table = u3;
+      size = sizeof(u3);
+      break;
+    case 0x04:
+      table = u4;
+      size = sizeof(u4);
+      break;
+    case 0x05:
+      table = u5;
+      size = sizeof(u5);
+      break;
+    case 0x06:
+      table = u6;
+      size = sizeof(u6);
+      break;
+    case 0x07:
+      table = u7;
+      size = sizeof(u7);
+      break;
+    case 0x09:
+      table = u9;
+      size = sizeof(u9);
+      break;
+    case 0x0a:
+      table = ua;
+      size = sizeof(ua);
+      break;
+    case 0x0b:
+      table = ub;
+      size = sizeof(ub);
+      break;
+    case 0x0c:
+      table = uc;
+      size = sizeof(uc);
+      break;
+    case 0x0d:
+      table = ud;
+      size = sizeof(ud);
+      break;
+    case 0x0e:
+      table = ue;
+      size = sizeof(ue);
+      break;
+    case 0x0f:
+      table = uf;
+      size = sizeof(uf);
+      break;
+    case 0x10:
+      table = u10;
+      size = sizeof(u10);
+      break;
+    case 0x11:
+      table = u11;
+      size = sizeof(u11);
+      break;
+    case 0x12:
+      table = u12;
+      size = sizeof(u12);
+      break;
+    case 0x13:
+      table = u13;
+      size = sizeof(u13);
+      break;
+    case 0x14:
+      table = u14;
+      size = sizeof(u14);
+      break;
+    case 0x16:
+      table = u16;
+      size = sizeof(u16);
+      break;
+    case 0x17:
+      table = u17;
+      size = sizeof(u17);
+      break;
+    case 0x18:
+      table = u18;
+      size = sizeof(u18);
+      break;
+    case 0x1e:
+      table = u1e;
+      size = sizeof(u1e);
+      break;
+    case 0x1f:
+      table = u1f;
+      size = sizeof(u1f);
+      break;
+    case 0x20:
+      table = u20;
+      size = sizeof(u20);
+      break;
+    case 0x21:
+      table = u21;
+      size = sizeof(u21);
+      break;
+    case 0x23:
+      table = u23;
+      size = sizeof(u23);
+      break;
+    case 0x24:
+      table = u24;
+      size = sizeof(u24);
+      break;
+    case 0x26:
+      table = u26;
+      size = sizeof(u26);
+      break;
+    case 0x27:
+      table = u27;
+      size = sizeof(u27);
+      break;
+    case 0x2e:
+      table = u2e;
+      size = sizeof(u2e);
+      break;
+    case 0x2f:
+      table = u2f;
+      size = sizeof(u2f);
+      break;
+    case 0x30:
+      table = u30;
+      size = sizeof(u30);
+      break;
+    case 0x31:
+      table = u31;
+      size = sizeof(u31);
+      break;
+    case 0x32:
+      table = u32;
+      size = sizeof(u32);
+      break;
+    case 0x33:
+      table = u33;
+      size = sizeof(u33);
+      break;
+    case 0x4d:
+      table = u4d;
+      size = sizeof(u4d);
+      break;
+    case 0x9f:
+      table = u9f;
+      size = sizeof(u9f);
+      break;
+    case 0xa4:
+      table = ua4;
+      size = sizeof(ua4);
+      break;
+    case 0xd7:
+      table = ud7;
+      size = sizeof(ud7);
+      break;
+    case 0xfa:
+      table = ufa;
+      size = sizeof(ufa);
+      break;
+    case 0xfb:
+      table = ufb;
+      size = sizeof(ufb);
+      break;
+    case 0xfd:
+      table = ufd;
+      size = sizeof(ufd);
+      break;
+    case 0xfe:
+      table = ufe;
+      size = sizeof(ufe);
+      break;
+    case 0xff:
+      table = uff;
+      size = sizeof(uff);
+      break;
+    case 0x103:
+      table = u103;
+      size = sizeof(u103);
+      break;
+    case 0x104:
+      table = u104;
+      size = sizeof(u104);
+      break;
+    case 0x1d0:
+      table = u1d0;
+      size = sizeof(u1d0);
+      break;
+    case 0x1d1:
+      table = u1d1;
+      size = sizeof(u1d1);
+      break;
+    case 0x1d4:
+      table = u1d4;
+      size = sizeof(u1d4);
+      break;
+    case 0x1d5:
+      table = u1d5;
+      size = sizeof(u1d5);
+      break;
+    case 0x1d6:
+      table = u1d6;
+      size = sizeof(u1d6);
+      break;
+    case 0x1d7:
+      table = u1d7;
+      size = sizeof(u1d7);
+      break;
+    case 0x2a6:
+      table = u2a6;
+      size = sizeof(u2a6);
+      break;
+    case 0x2fa:
+      table = u2fa;
+      size = sizeof(u2fa);
+      break;
+    case 0xe00:
+      table = ue00;
+      size = sizeof(ue00);
+      break;
+    case 0xfff:
+      table = ufff;
+      size = sizeof(ufff);
+      break;
+    case 0x10ff:
+      table = u10ff;
+      size = sizeof(u10ff);
+      break;
+    default:
+      return 0;
     }
-  else if (!strcmp (__locale_charset (), "UTF-8"))
+  /* we have narrowed down to a section of 256 characters to check */
+  /* now check if c matches the printuation wide-chars within that section */
+  ptr = (unsigned char *)table;
+  ctmp = (unsigned char)c;
+  while (ptr < table + size)
     {
-      unicode = 1;
-    }
-
-  if (unicode)
-    {
-      unsigned const char *table;
-      unsigned char *ptr;
-      unsigned char ctmp;
-      int size;
-      wint_t x = (c >> 8);
-      
-      /* for some large sections, all characters are printuation so handle them here */
-      if ((x >= 0x34 && x <= 0x4c) ||
-	  (x >= 0x4e && x <= 0x9e) ||
-	  (x >= 0xac && x <= 0xd6) ||
-	  (x >= 0xe0 && x <= 0xf9) ||
-	  (x >= 0x200 && x <= 0x2a5) ||
-	  (x >= 0xf00 && x <= 0xffe) ||
-	  (x >= 0x1000 && x <= 0x10fe))
+      if (ctmp == *ptr)
 	return 1;
-      
-      switch (x)
-	{
-	case 0x01:
-	case 0x15:
-	case 0x22:
-	case 0x25:
-	case 0x28:
-	case 0x29:
-	case 0x2a:
-	case 0xa0:
-	case 0xa1:
-	case 0xa2:
-	case 0xa3:
-	case 0xfc:
-	case 0x2f8:
-	case 0x2f9:
-	  return 1;
-	case 0x00:
-	  table = u0;
-	  size = sizeof(u0);
-	  break;
-	case 0x02:
-	  table = u2;
-	  size = sizeof(u2);
-	  break;
-	case 0x03:
-	  table = u3;
-	  size = sizeof(u3);
-	  break;
-	case 0x04:
-	  table = u4;
-	  size = sizeof(u4);
-	  break;
-	case 0x05:
-	  table = u5;
-	  size = sizeof(u5);
-	  break;
-	case 0x06:
-	  table = u6;
-	  size = sizeof(u6);
-	  break;
-	case 0x07:
-	  table = u7;
-	  size = sizeof(u7);
-	  break;
-	case 0x09:
-	  table = u9;
-	  size = sizeof(u9);
-	  break;
-	case 0x0a:
-	  table = ua;
-	  size = sizeof(ua);
-	  break;
-	case 0x0b:
-	  table = ub;
-	  size = sizeof(ub);
-	  break;
-	case 0x0c:
-	  table = uc;
-	  size = sizeof(uc);
-	  break;
-	case 0x0d:
-	  table = ud;
-	  size = sizeof(ud);
-	  break;
-	case 0x0e:
-	  table = ue;
-	  size = sizeof(ue);
-	  break;
-	case 0x0f:
-	  table = uf;
-	  size = sizeof(uf);
-	  break;
-	case 0x10:
-	  table = u10;
-	  size = sizeof(u10);
-	  break;
-	case 0x11:
-	  table = u11;
-	  size = sizeof(u11);
-	  break;
-	case 0x12:
-	  table = u12;
-	  size = sizeof(u12);
-	  break;
-	case 0x13:
-	  table = u13;
-	  size = sizeof(u13);
-	  break;
-	case 0x14:
-	  table = u14;
-	  size = sizeof(u14);
-	  break;
-	case 0x16:
-	  table = u16;
-	  size = sizeof(u16);
-	  break;
-	case 0x17:
-	  table = u17;
-	  size = sizeof(u17);
-	  break;
-	case 0x18:
-	  table = u18;
-	  size = sizeof(u18);
-	  break;
-	case 0x1e:
-	  table = u1e;
-	  size = sizeof(u1e);
-	  break;
-	case 0x1f:
-	  table = u1f;
-	  size = sizeof(u1f);
-	  break;
-	case 0x20:
-	  table = u20;
-	  size = sizeof(u20);
-	  break;
-	case 0x21:
-	  table = u21;
-	  size = sizeof(u21);
-	  break;
-	case 0x23:
-	  table = u23;
-	  size = sizeof(u23);
-	  break;
-	case 0x24:
-	  table = u24;
-	  size = sizeof(u24);
-	  break;
-	case 0x26:
-	  table = u26;
-	  size = sizeof(u26);
-	  break;
-	case 0x27:
-	  table = u27;
-	  size = sizeof(u27);
-	  break;
-	case 0x2e:
-	  table = u2e;
-	  size = sizeof(u2e);
-	  break;
-	case 0x2f:
-	  table = u2f;
-	  size = sizeof(u2f);
-	  break;
-	case 0x30:
-	  table = u30;
-	  size = sizeof(u30);
-	  break;
-	case 0x31:
-	  table = u31;
-	  size = sizeof(u31);
-	  break;
-	case 0x32:
-	  table = u32;
-	  size = sizeof(u32);
-	  break;
-	case 0x33:
-	  table = u33;
-	  size = sizeof(u33);
-	  break;
-	case 0x4d:
-	  table = u4d;
-	  size = sizeof(u4d);
-	  break;
-	case 0x9f:
-	  table = u9f;
-	  size = sizeof(u9f);
-	  break;
-	case 0xa4:
-	  table = ua4;
-	  size = sizeof(ua4);
-	  break;
-	case 0xd7:
-	  table = ud7;
-	  size = sizeof(ud7);
-	  break;
-	case 0xfa:
-	  table = ufa;
-	  size = sizeof(ufa);
-	  break;
-	case 0xfb:
-	  table = ufb;
-	  size = sizeof(ufb);
-	  break;
-	case 0xfd:
-	  table = ufd;
-	  size = sizeof(ufd);
-	  break;
-	case 0xfe:
-	  table = ufe;
-	  size = sizeof(ufe);
-	  break;
-	case 0xff:
-	  table = uff;
-	  size = sizeof(uff);
-	  break;
-	case 0x103:
-	  table = u103;
-	  size = sizeof(u103);
-	  break;
-	case 0x104:
-	  table = u104;
-	  size = sizeof(u104);
-	  break;
-	case 0x1d0:
-	  table = u1d0;
-	  size = sizeof(u1d0);
-	  break;
-	case 0x1d1:
-	  table = u1d1;
-	  size = sizeof(u1d1);
-	  break;
-	case 0x1d4:
-	  table = u1d4;
-	  size = sizeof(u1d4);
-	  break;
-	case 0x1d5:
-	  table = u1d5;
-	  size = sizeof(u1d5);
-	  break;
-	case 0x1d6:
-	  table = u1d6;
-	  size = sizeof(u1d6);
-	  break;
-	case 0x1d7:
-	  table = u1d7;
-	  size = sizeof(u1d7);
-	  break;
-	case 0x2a6:
-	  table = u2a6;
-	  size = sizeof(u2a6);
-	  break;
-	case 0x2fa:
-	  table = u2fa;
-	  size = sizeof(u2fa);
-	  break;
-	case 0xe00:
-	  table = ue00;
-	  size = sizeof(ue00);
-	  break;
-	case 0xfff:
-	  table = ufff;
-	  size = sizeof(ufff);
-	  break;
-	case 0x10ff:
-	  table = u10ff;
-	  size = sizeof(u10ff);
-	  break;
-	default:
-	  return 0;
-	}
-      /* we have narrowed down to a section of 256 characters to check */
-      /* now check if c matches the printuation wide-chars within that section */
-      ptr = (unsigned char *)table;
-      ctmp = (unsigned char)c;
-      while (ptr < table + size)
+      if (ctmp < *ptr)
+	return 0;
+      /* otherwise c > *ptr */
+      /* look for 0x0 as next element which indicates a range */
+      ++ptr;
+      if (*ptr == 0x0)
 	{
-	  if (ctmp == *ptr)
+	  /* we have a range..see if c falls within range */
+	  ++ptr;
+	  if (ctmp <= *ptr)
 	    return 1;
-	  if (ctmp < *ptr)
-	    return 0;
-	  /* otherwise c > *ptr */
-	  /* look for 0x0 as next element which indicates a range */
 	  ++ptr;
-	  if (*ptr == 0x0)
-	    {
-	      /* we have a range..see if c falls within range */
-	      ++ptr;
-	      if (ctmp <= *ptr)
-		return 1;
-	      ++ptr;
-	    }
 	}
-      /* not in table */
-      return 0;
     }
-#endif /* _MB_CAPABLE */
-
+  /* not in table */
+  return 0;
+#else
   return (c < (wint_t)0x100 ? isprint (c) : 0);
+#endif /* _MB_CAPABLE */
 }
 
diff --git a/newlib/libc/ctype/iswpunct.c b/newlib/libc/ctype/iswpunct.c
index 1f19b66b8..fc0bd630f 100644
--- a/newlib/libc/ctype/iswpunct.c
+++ b/newlib/libc/ctype/iswpunct.c
@@ -70,260 +70,243 @@ int
 _DEFUN(iswpunct,(c), wint_t c)
 {
 #ifdef _MB_CAPABLE
-  int unicode = 0;
+  unsigned const char *table;
+  unsigned char *ptr;
+  unsigned char ctmp;
+  int size;
+  wint_t x;
 
   if (!strcmp (__locale_charset (), "JIS"))
-    {
-      c = __jp2uc (c, JP_JIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_JIS);
   else if (!strcmp (__locale_charset (), "SJIS"))
-    {
-      c = __jp2uc (c, JP_SJIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_SJIS);
   else if (!strcmp (__locale_charset (), "EUCJP"))
+    c = __jp2uc (c, JP_EUCJP);
+
+  x = (c >> 8);
+  /* for some large sections, all characters are punctuation so handle them here */
+  if ((x >= 0xe0 && x <= 0xf8) ||
+      (x >= 0xf00 && x <= 0xffe) ||
+      (x >= 0x1000 && x <= 0x10fe))
+    return 1;
+  
+  switch (x)
     {
-      c = __jp2uc (c, JP_EUCJP);
-      unicode = 1;
-    }
-  else if (!strcmp (__locale_charset (), "UTF-8"))
-    {
-      unicode = 1;
+    case 0x22:
+    case 0x25:
+    case 0x28:
+    case 0x29:
+    case 0x2a:
+      return 1;
+    case 0x00:
+      table = u0;
+      size = sizeof(u0);
+      break;
+    case 0x02:
+      table = u2;
+      size = sizeof(u2);
+      break;
+    case 0x03:
+      table = u3;
+      size = sizeof(u3);
+      break;
+    case 0x04:
+      table = u4;
+      size = sizeof(u4);
+      break;
+    case 0x05:
+      table = u5;
+      size = sizeof(u5);
+      break;
+    case 0x06:
+      table = u6;
+      size = sizeof(u6);
+      break;
+    case 0x07:
+      table = u7;
+      size = sizeof(u7);
+      break;
+    case 0x09:
+      table = u9;
+      size = sizeof(u9);
+      break;
+    case 0x0a:
+      table = ua;
+      size = sizeof(ua);
+      break;
+    case 0x0b:
+      table = ub;
+      size = sizeof(ub);
+      break;
+    case 0x0c:
+      table = uc;
+      size = sizeof(uc);
+      break;
+    case 0x0d:
+      table = ud;
+      size = sizeof(ud);
+      break;
+    case 0x0e:
+      table = ue;
+      size = sizeof(ue);
+      break;
+    case 0x0f:
+      table = uf;
+      size = sizeof(uf);
+      break;
+    case 0x10:
+      table = u10;
+      size = sizeof(u10);
+      break;
+    case 0x13:
+      table = u13;
+      size = sizeof(u13);
+      break;
+    case 0x16:
+      table = u16;
+      size = sizeof(u16);
+      break;
+    case 0x17:
+      table = u17;
+      size = sizeof(u17);
+      break;
+    case 0x18:
+      table = u18;
+      size = sizeof(u18);
+      break;
+    case 0x1f:
+      table = u1f;
+      size = sizeof(u1f);
+      break;
+    case 0x20:
+      table = u20;
+      size = sizeof(u20);
+      break;
+    case 0x21:
+      table = u21;
+      size = sizeof(u21);
+      break;
+    case 0x23:
+      table = u23;
+      size = sizeof(u23);
+      break;
+    case 0x24:
+      table = u24;
+      size = sizeof(u24);
+      break;
+    case 0x26:
+      table = u26;
+      size = sizeof(u26);
+      break;
+    case 0x27:
+      table = u27;
+      size = sizeof(u27);
+      break;
+    case 0x2e:
+      table = u2e;
+      size = sizeof(u2e);
+      break;
+    case 0x2f:
+      table = u2f;
+      size = sizeof(u2f);
+      break;
+    case 0x30:
+      table = u30;
+      size = sizeof(u30);
+      break;
+    case 0x31:
+      table = u31;
+      size = sizeof(u31);
+      break;
+    case 0x32:
+      table = u32;
+      size = sizeof(u32);
+      break;
+    case 0x33:
+      table = u33;
+      size = sizeof(u33);
+      break;
+    case 0xa4:
+      table = ua4;
+      size = sizeof(ua4);
+      break;
+    case 0xfb:
+      table = ufb;
+      size = sizeof(ufb);
+      break;
+    case 0xfd:
+      table = ufd;
+      size = sizeof(ufd);
+      break;
+    case 0xfe:
+      table = ufe;
+      size = sizeof(ufe);
+      break;
+    case 0xff:
+      table = uff;
+      size = sizeof(uff);
+      break;
+    case 0x103:
+      table = u103;
+      size = sizeof(u103);
+      break;
+    case 0x1d0:
+      table = u1d0;
+      size = sizeof(u1d0);
+      break;
+    case 0x1d1:
+      table = u1d1;
+      size = sizeof(u1d1);
+      break;
+    case 0x1d6:
+      table = u1d6;
+      size = sizeof(u1d6);
+      break;
+    case 0x1d7:
+      table = u1d7;
+      size = sizeof(u1d7);
+      break;
+    case 0xe00:
+      table = ue00;
+      size = sizeof(ue00);
+      break;
+    case 0xfff:
+      table = ufff;
+      size = sizeof(ufff);
+      break;
+    case 0x10ff:
+      table = u10ff;
+      size = sizeof(u10ff);
+      break;
+    default:
+      return 0;
     }
-
-  if (unicode)
+  /* we have narrowed down to a section of 256 characters to check */
+  /* now check if c matches the punctuation wide-chars within that section */
+  ptr = (unsigned char *)table;
+  ctmp = (unsigned char)c;
+  while (ptr < table + size)
     {
-      unsigned const char *table;
-      unsigned char *ptr;
-      unsigned char ctmp;
-      int size;
-      wint_t x = (c >> 8);
-      
-      /* for some large sections, all characters are punctuation so handle them here */
-      if ((x >= 0xe0 && x <= 0xf8) ||
-	  (x >= 0xf00 && x <= 0xffe) ||
-	  (x >= 0x1000 && x <= 0x10fe))
+      if (ctmp == *ptr)
 	return 1;
-      
-      switch (x)
-	{
-	case 0x22:
-	case 0x25:
-	case 0x28:
-	case 0x29:
-	case 0x2a:
-	  return 1;
-	case 0x00:
-	  table = u0;
-	  size = sizeof(u0);
-	  break;
-	case 0x02:
-	  table = u2;
-	  size = sizeof(u2);
-	  break;
-	case 0x03:
-	  table = u3;
-	  size = sizeof(u3);
-	  break;
-	case 0x04:
-	  table = u4;
-	  size = sizeof(u4);
-	  break;
-	case 0x05:
-	  table = u5;
-	  size = sizeof(u5);
-	  break;
-	case 0x06:
-	  table = u6;
-	  size = sizeof(u6);
-	  break;
-	case 0x07:
-	  table = u7;
-	  size = sizeof(u7);
-	  break;
-	case 0x09:
-	  table = u9;
-	  size = sizeof(u9);
-	  break;
-	case 0x0a:
-	  table = ua;
-	  size = sizeof(ua);
-	  break;
-	case 0x0b:
-	  table = ub;
-	  size = sizeof(ub);
-	  break;
-	case 0x0c:
-	  table = uc;
-	  size = sizeof(uc);
-	  break;
-	case 0x0d:
-	  table = ud;
-	  size = sizeof(ud);
-	  break;
-	case 0x0e:
-	  table = ue;
-	  size = sizeof(ue);
-	  break;
-	case 0x0f:
-	  table = uf;
-	  size = sizeof(uf);
-	  break;
-	case 0x10:
-	  table = u10;
-	  size = sizeof(u10);
-	  break;
-	case 0x13:
-	  table = u13;
-	  size = sizeof(u13);
-	  break;
-	case 0x16:
-	  table = u16;
-	  size = sizeof(u16);
-	  break;
-	case 0x17:
-	  table = u17;
-	  size = sizeof(u17);
-	  break;
-	case 0x18:
-	  table = u18;
-	  size = sizeof(u18);
-	  break;
-	case 0x1f:
-	  table = u1f;
-	  size = sizeof(u1f);
-	  break;
-	case 0x20:
-	  table = u20;
-	  size = sizeof(u20);
-	  break;
-	case 0x21:
-	  table = u21;
-	  size = sizeof(u21);
-	  break;
-	case 0x23:
-	  table = u23;
-	  size = sizeof(u23);
-	  break;
-	case 0x24:
-	  table = u24;
-	  size = sizeof(u24);
-	  break;
-	case 0x26:
-	  table = u26;
-	  size = sizeof(u26);
-	  break;
-	case 0x27:
-	  table = u27;
-	  size = sizeof(u27);
-	  break;
-	case 0x2e:
-	  table = u2e;
-	  size = sizeof(u2e);
-	  break;
-	case 0x2f:
-	  table = u2f;
-	  size = sizeof(u2f);
-	  break;
-	case 0x30:
-	  table = u30;
-	  size = sizeof(u30);
-	  break;
-	case 0x31:
-	  table = u31;
-	  size = sizeof(u31);
-	  break;
-	case 0x32:
-	  table = u32;
-	  size = sizeof(u32);
-	  break;
-	case 0x33:
-	  table = u33;
-	  size = sizeof(u33);
-	  break;
-	case 0xa4:
-	  table = ua4;
-	  size = sizeof(ua4);
-	  break;
-	case 0xfb:
-	  table = ufb;
-	  size = sizeof(ufb);
-	  break;
-	case 0xfd:
-	  table = ufd;
-	  size = sizeof(ufd);
-	  break;
-	case 0xfe:
-	  table = ufe;
-	  size = sizeof(ufe);
-	  break;
-	case 0xff:
-	  table = uff;
-	  size = sizeof(uff);
-	  break;
-	case 0x103:
-	  table = u103;
-	  size = sizeof(u103);
-	  break;
-	case 0x1d0:
-	  table = u1d0;
-	  size = sizeof(u1d0);
-	  break;
-	case 0x1d1:
-	  table = u1d1;
-	  size = sizeof(u1d1);
-	  break;
-	case 0x1d6:
-	  table = u1d6;
-	  size = sizeof(u1d6);
-	  break;
-	case 0x1d7:
-	  table = u1d7;
-	  size = sizeof(u1d7);
-	  break;
-	case 0xe00:
-	  table = ue00;
-	  size = sizeof(ue00);
-	  break;
-	case 0xfff:
-	  table = ufff;
-	  size = sizeof(ufff);
-	  break;
-	case 0x10ff:
-	  table = u10ff;
-	  size = sizeof(u10ff);
-	  break;
-	default:
-	  return 0;
-	}
-      /* we have narrowed down to a section of 256 characters to check */
-      /* now check if c matches the punctuation wide-chars within that section */
-      ptr = (unsigned char *)table;
-      ctmp = (unsigned char)c;
-      while (ptr < table + size)
+      if (ctmp < *ptr)
+	return 0;
+      /* otherwise c > *ptr */
+      /* look for 0x0 as next element which indicates a range */
+      ++ptr;
+      if (*ptr == 0x0)
 	{
-	  if (ctmp == *ptr)
+	  /* we have a range..see if c falls within range */
+	  ++ptr;
+	  if (ctmp <= *ptr)
 	    return 1;
-	  if (ctmp < *ptr)
-	    return 0;
-	  /* otherwise c > *ptr */
-	  /* look for 0x0 as next element which indicates a range */
 	  ++ptr;
-	  if (*ptr == 0x0)
-	    {
-	      /* we have a range..see if c falls within range */
-	      ++ptr;
-	      if (ctmp <= *ptr)
-		return 1;
-	      ++ptr;
-	    }
 	}
-      /* not in table */
-      return 0;
     }
-#endif /* _MB_CAPABLE */
-
+  /* not in table */
+  return 0;
+#else
   return (c < (wint_t)0x100 ? ispunct (c) : 0);
+#endif /* _MB_CAPABLE */
 }
 
diff --git a/newlib/libc/ctype/iswspace.c b/newlib/libc/ctype/iswspace.c
index b9c74395a..100e7822a 100644
--- a/newlib/libc/ctype/iswspace.c
+++ b/newlib/libc/ctype/iswspace.c
@@ -66,38 +66,19 @@ int
 _DEFUN(iswspace,(c), wint_t c)
 {
 #ifdef _MB_CAPABLE
-  int unicode = 0;
-
   if (!strcmp (__locale_charset (), "JIS"))
-    {
-      c = __jp2uc (c, JP_JIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_JIS);
   else if (!strcmp (__locale_charset (), "SJIS"))
-    {
-      c = __jp2uc (c, JP_SJIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_SJIS);
   else if (!strcmp (__locale_charset (), "EUCJP"))
-    {
-      c = __jp2uc (c, JP_EUCJP);
-      unicode = 1;
-    }
-  else if (!strcmp (__locale_charset (), "UTF-8"))
-    {
-      unicode = 1;
-    }
-
-  if (unicode)
-    {
-      return ((c >= 0x0009 && c <= 0x000d) || c == 0x0020 || c == 0x1680 ||
-              (c >= 0x2000 && c <= 0x2006) ||
-              (c >= 0x2008 && c <= 0x200b) ||
-              c == 0x2028 || c == 0x2029 ||
-              c == 0x205f || c == 0x3000);
-    }
-#endif /* _MB_CAPABLE */
-
+    c = __jp2uc (c, JP_EUCJP);
+  return ((c >= 0x0009 && c <= 0x000d) || c == 0x0020 || c == 0x1680 ||
+	  (c >= 0x2000 && c <= 0x2006) ||
+	  (c >= 0x2008 && c <= 0x200b) ||
+	  c == 0x2028 || c == 0x2029 ||
+	  c == 0x205f || c == 0x3000);
+#else
   return (c < 0x100 ? isspace (c) : 0);
+#endif /* _MB_CAPABLE */
 }
 
diff --git a/newlib/libc/ctype/jp2uc.c b/newlib/libc/ctype/jp2uc.c
index 9d26a7a68..d1096442e 100644
--- a/newlib/libc/ctype/jp2uc.c
+++ b/newlib/libc/ctype/jp2uc.c
@@ -41,6 +41,11 @@
 wint_t
 _DEFUN (__jp2uc, (c, type), wint_t c _AND int type)
 {
+/* Under Cygwin, the incoming wide character is already given in UTF due
+   to the requirements of the underlying OS. */
+#ifdef  __CYGWIN__
+  return c;
+#else
   int index, adj;
   unsigned char byte1, byte2;
   wint_t ret;
@@ -140,6 +145,7 @@ _DEFUN (__jp2uc, (c, type), wint_t c _AND int type)
     }
 
   return WEOF; 
+#endif
 }
 
 #endif /* _MB_CAPABLE */
diff --git a/newlib/libc/ctype/towlower.c b/newlib/libc/ctype/towlower.c
index c3fcb77ba..edda8ca34 100644
--- a/newlib/libc/ctype/towlower.c
+++ b/newlib/libc/ctype/towlower.c
@@ -70,405 +70,388 @@ wint_t
 _DEFUN(towlower,(c), wint_t c)
 {
 #ifdef _MB_CAPABLE
-  int unicode = 0;
-
   if (!strcmp (__locale_charset (), "JIS"))
-    {
-      c = __jp2uc (c, JP_JIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_JIS);
   else if (!strcmp (__locale_charset (), "SJIS"))
-    {
-      c = __jp2uc (c, JP_SJIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_SJIS);
   else if (!strcmp (__locale_charset (), "EUCJP"))
+    c = __jp2uc (c, JP_EUCJP);
+
+  if (c < 0x100)
     {
-      c = __jp2uc (c, JP_EUCJP);
-      unicode = 1;
-    }
-  else if (!strcmp (__locale_charset (), "UTF-8"))
-    {
-      unicode = 1;
-    }
+      if ((c >= 0x0041 && c <= 0x005a) ||
+	  (c >= 0x00c0 && c <= 0x00de))
+	return (c + 0x20);
 
-  if (unicode)
+      if (c == 0x00b5)
+	return 0x03bc;
+      
+      return c;
+    }
+  else if (c < 0x300)
     {
-      if (c < 0x100)
+      if ((c >= 0x0100 && c <= 0x012e) ||
+	  (c >= 0x0132 && c <= 0x0136) ||
+	  (c >= 0x014a && c <= 0x0176) ||
+	  (c >= 0x01de && c <= 0x01ee) ||
+	  (c >= 0x01f8 && c <= 0x021e) ||
+	  (c >= 0x0222 && c <= 0x0232))
 	{
-	  if ((c >= 0x0041 && c <= 0x005a) ||
-	      (c >= 0x00c0 && c <= 0x00de))
-	    return (c + 0x20);
+	  if (!(c & 0x01))
+	    return (c + 1);
+	  return c;
+	}
 
-	  if (c == 0x00b5)
-	    return 0x03bc;
-	  
+      if ((c >= 0x0139 && c <= 0x0147) ||
+	  (c >= 0x01cd && c <= 0x91db))
+	{
+	  if (c & 0x01)
+	    return (c + 1);
 	  return c;
 	}
-      else if (c < 0x300)
+      
+      if (c >= 0x178 && c <= 0x01f7)
 	{
-	  if ((c >= 0x0100 && c <= 0x012e) ||
-	      (c >= 0x0132 && c <= 0x0136) ||
-	      (c >= 0x014a && c <= 0x0176) ||
-	      (c >= 0x01de && c <= 0x01ee) ||
-	      (c >= 0x01f8 && c <= 0x021e) ||
-	      (c >= 0x0222 && c <= 0x0232))
+	  wint_t k;
+	  switch (c)
 	    {
-	      if (!(c & 0x01))
-		return (c + 1);
-	      return c;
+	    case 0x0178:
+	      k = 0x00ff;
+	      break;
+	    case 0x0179:
+	    case 0x017b:
+	    case 0x017d:
+	    case 0x0182:
+	    case 0x0184:
+	    case 0x0187:
+	    case 0x018b:
+	    case 0x0191:
+	    case 0x0198:
+	    case 0x01a0:
+	    case 0x01a2:
+	    case 0x01a4:
+	    case 0x01a7:
+	    case 0x01ac:
+	    case 0x01af:
+	    case 0x01b3:
+	    case 0x01b5:
+	    case 0x01b8:
+	    case 0x01bc:
+	    case 0x01c5:
+	    case 0x01c8:
+	    case 0x01cb:
+	    case 0x01cd:
+	    case 0x01cf:
+	    case 0x01d1:
+	    case 0x01d3:
+	    case 0x01d5:
+	    case 0x01d7:
+	    case 0x01d9:
+	    case 0x01db:
+	    case 0x01f2:
+	    case 0x01f4:
+	      k = c + 1;
+	      break;
+	    case 0x017f:
+	      k = 0x0073;
+	      break;
+	    case 0x0181:
+	      k = 0x0253;
+	      break;
+	    case 0x0186:
+	      k = 0x0254;
+	      break;
+	    case 0x0189:
+	      k = 0x0256;
+	      break;
+	    case 0x018a:
+	      k = 0x0257;
+	      break;
+	    case 0x018e:
+	      k = 0x01dd;
+	      break;
+	    case 0x018f:
+	      k = 0x0259;
+	      break;
+	    case 0x0190:
+	      k = 0x025b;
+	      break;
+	    case 0x0193:
+	      k = 0x0260;
+	      break;
+	    case 0x0194:
+	      k = 0x0263;
+	      break;
+	    case 0x0196:
+	      k = 0x0269;
+	      break;
+	    case 0x0197:
+	      k = 0x0268;
+	      break;
+	    case 0x019c:
+	      k = 0x026f;
+	      break;
+	    case 0x019d:
+	      k = 0x0272;
+	      break;
+	    case 0x019f:
+	      k = 0x0275;
+	      break;
+	    case 0x01a6:
+	      k = 0x0280;
+	      break;
+	    case 0x01a9:
+	      k = 0x0283;
+	      break;
+	    case 0x01ae:
+	      k = 0x0288;
+	      break;
+	    case 0x01b1:
+	      k = 0x028a;
+	      break;
+	    case 0x01b2:
+	      k = 0x028b;
+	      break;
+	    case 0x01b7:
+	      k = 0x0292;
+	      break;
+	    case 0x01c4:
+	    case 0x01c7:
+	    case 0x01ca:
+	    case 0x01f1:
+	      k = c + 2;
+	      break;
+	    case 0x01f6:
+	      k = 0x0195;
+	      break;
+	    case 0x01f7:
+	      k = 0x01bf;
+	      break;
+	    default:
+	      k = 0;
 	    }
+	  if (k != 0)
+	    return k;
+	}
 
-	  if ((c >= 0x0139 && c <= 0x0147) ||
-	      (c >= 0x01cd && c <= 0x91db))
-	    {
-	      if (c & 0x01)
-		return (c + 1);
-	      return c;
-	    }
-	  
-	  if (c >= 0x178 && c <= 0x01f7)
+      if (c == 0x0220)
+	return 0x019e;
+    }
+  else if (c < 0x0400)
+    {
+      if (c >= 0x0391 && c <= 0x03ab && c != 0x03a2)
+	return (c + 0x20);
+      if (c >= 0x03d8 && c <= 0x03ee && !(c & 0x01))
+	return (c + 1);
+      if (c >= 0x0386 && c <= 0x03f5)
+	{
+	  wint_t k;
+	  switch (c)
 	    {
-	      wint_t k;
-	      switch (c)
-		{
-		case 0x0178:
-		  k = 0x00ff;
-		  break;
-		case 0x0179:
-		case 0x017b:
-		case 0x017d:
-		case 0x0182:
-		case 0x0184:
-		case 0x0187:
-		case 0x018b:
-		case 0x0191:
-		case 0x0198:
-		case 0x01a0:
-		case 0x01a2:
-		case 0x01a4:
-		case 0x01a7:
-		case 0x01ac:
-		case 0x01af:
-		case 0x01b3:
-		case 0x01b5:
-		case 0x01b8:
-		case 0x01bc:
-		case 0x01c5:
-		case 0x01c8:
-		case 0x01cb:
-		case 0x01cd:
-		case 0x01cf:
-		case 0x01d1:
-		case 0x01d3:
-		case 0x01d5:
-		case 0x01d7:
-		case 0x01d9:
-		case 0x01db:
-		case 0x01f2:
-		case 0x01f4:
-		  k = c + 1;
-		  break;
-		case 0x017f:
-		  k = 0x0073;
-		  break;
-		case 0x0181:
-		  k = 0x0253;
-		  break;
-		case 0x0186:
-		  k = 0x0254;
-		  break;
-		case 0x0189:
-		  k = 0x0256;
-		  break;
-		case 0x018a:
-		  k = 0x0257;
-		  break;
-		case 0x018e:
-		  k = 0x01dd;
-		  break;
-		case 0x018f:
-		  k = 0x0259;
-		  break;
-		case 0x0190:
-		  k = 0x025b;
-		  break;
-		case 0x0193:
-		  k = 0x0260;
-		  break;
-		case 0x0194:
-		  k = 0x0263;
-		  break;
-		case 0x0196:
-		  k = 0x0269;
-		  break;
-		case 0x0197:
-		  k = 0x0268;
-		  break;
-		case 0x019c:
-		  k = 0x026f;
-		  break;
-		case 0x019d:
-		  k = 0x0272;
-		  break;
-		case 0x019f:
-		  k = 0x0275;
-		  break;
-		case 0x01a6:
-		  k = 0x0280;
-		  break;
-		case 0x01a9:
-		  k = 0x0283;
-		  break;
-		case 0x01ae:
-		  k = 0x0288;
-		  break;
-		case 0x01b1:
-		  k = 0x028a;
-		  break;
-		case 0x01b2:
-		  k = 0x028b;
-		  break;
-		case 0x01b7:
-		  k = 0x0292;
-		  break;
-		case 0x01c4:
-		case 0x01c7:
-		case 0x01ca:
-		case 0x01f1:
-		  k = c + 2;
-		  break;
-		case 0x01f6:
-		  k = 0x0195;
-		  break;
-		case 0x01f7:
-		  k = 0x01bf;
-		  break;
-		default:
-		  k = 0;
-		}
-	      if (k != 0)
-		return k;
+	    case 0x0386:
+	      k = 0x03ac;
+	      break;
+	    case 0x0388:
+	      k = 0x03ad;
+	      break;
+	    case 0x0389:
+	      k = 0x03ae;
+	      break;
+	    case 0x038a:
+	      k = 0x03af;
+	      break;
+	    case 0x038c:
+	      k = 0x03cc;
+	      break;
+	    case 0x038e:
+	      k = 0x03cd;
+	      break;
+	    case 0x038f:
+	      k = 0x038f;
+	      break;
+	    case 0x03c2:
+	      k = 0x03c3;
+	      break;
+	    case 0x03d0:
+	      k = 0x03b2;
+	      break;
+	    case 0x03d1:
+	      k = 0x03b8;
+	      break;
+	    case 0x03d5:
+	      k = 0x03c6;
+	      break;
+	    case 0x03d6:
+	      k = 0x03c0;
+	      break;
+	    case 0x03f0:
+	      k = 0x03ba;
+	      break;
+	    case 0x03f1:
+	      k = 0x03c1;
+	      break;
+	    case 0x03f2:
+	      k = 0x03c3;
+	      break;
+	    case 0x03f4:
+	      k = 0x03b8;
+	      break;
+	    case 0x03f5:
+	      k = 0x03b5;
+	      break;
+	    default:
+	      k = 0;
 	    }
-
-	  if (c == 0x0220)
-	    return 0x019e;
+	  if (k != 0)
+	    return k;
 	}
-      else if (c < 0x0400)
+
+      if (c == 0x0345)
+	return 0x03b9;
+    }
+  else if (c < 0x500)
+    {
+      if (c >= 0x0400 && c <= 0x040f)
+	return (c + 0x50);
+      
+      if (c >= 0x0410 && c <= 0x042f)
+	return (c + 0x20);
+      
+      if ((c >= 0x0460 && c <= 0x0480) ||
+	  (c >= 0x048a && c <= 0x04be) ||
+	  (c >= 0x04d0 && c <= 0x04f4) ||
+	  (c == 0x04f8))
 	{
-	  if (c >= 0x0391 && c <= 0x03ab && c != 0x03a2)
-	    return (c + 0x20);
-	  if (c >= 0x03d8 && c <= 0x03ee && !(c & 0x01))
+	  if (!(c & 0x01))
 	    return (c + 1);
-	  if (c >= 0x0386 && c <= 0x03f5)
-	    {
-	      wint_t k;
-	      switch (c)
-		{
-		case 0x0386:
-		  k = 0x03ac;
-		  break;
-		case 0x0388:
-		  k = 0x03ad;
-		  break;
-		case 0x0389:
-		  k = 0x03ae;
-		  break;
-		case 0x038a:
-		  k = 0x03af;
-		  break;
-		case 0x038c:
-		  k = 0x03cc;
-		  break;
-		case 0x038e:
-		  k = 0x03cd;
-		  break;
-		case 0x038f:
-		  k = 0x038f;
-		  break;
-		case 0x03c2:
-		  k = 0x03c3;
-		  break;
-		case 0x03d0:
-		  k = 0x03b2;
-		  break;
-		case 0x03d1:
-		  k = 0x03b8;
-		  break;
-		case 0x03d5:
-		  k = 0x03c6;
-		  break;
-		case 0x03d6:
-		  k = 0x03c0;
-		  break;
-		case 0x03f0:
-		  k = 0x03ba;
-		  break;
-		case 0x03f1:
-		  k = 0x03c1;
-		  break;
-		case 0x03f2:
-		  k = 0x03c3;
-		  break;
-		case 0x03f4:
-		  k = 0x03b8;
-		  break;
-		case 0x03f5:
-		  k = 0x03b5;
-		  break;
-		default:
-		  k = 0;
-		}
-	      if (k != 0)
-		return k;
-	    }
-
-	  if (c == 0x0345)
-	    return 0x03b9;
+	  return c;
 	}
-      else if (c < 0x500)
+      
+      if (c >= 0x04c1 && c <= 0x04cd)
 	{
-	  if (c >= 0x0400 && c <= 0x040f)
-	    return (c + 0x50);
-	  
-	  if (c >= 0x0410 && c <= 0x042f)
-	    return (c + 0x20);
-	  
-	  if ((c >= 0x0460 && c <= 0x0480) ||
-	      (c >= 0x048a && c <= 0x04be) ||
-	      (c >= 0x04d0 && c <= 0x04f4) ||
-	      (c == 0x04f8))
-	    {
-	      if (!(c & 0x01))
-		return (c + 1);
-	      return c;
-	    }
-	  
-	  if (c >= 0x04c1 && c <= 0x04cd)
-	    {
-	      if (c & 0x01)
-		return (c + 1);
-	      return c;
-	    }
+	  if (c & 0x01)
+	    return (c + 1);
+	  return c;
 	}
-      else if (c < 0x1f00)
+    }
+  else if (c < 0x1f00)
+    {
+      if ((c >= 0x0500 && c <= 0x050e) ||
+	  (c >= 0x1e00 && c <= 0x1e94) ||
+	  (c >= 0x1ea0 && c <= 0x1ef8))
 	{
-	  if ((c >= 0x0500 && c <= 0x050e) ||
-	      (c >= 0x1e00 && c <= 0x1e94) ||
-	      (c >= 0x1ea0 && c <= 0x1ef8))
-	    {
-	      if (!(c & 0x01))
-		return (c + 1);
-	      return c;
-	    }
-	  
-	  if (c >= 0x0531 && c <= 0x0556)
-	    return (c + 0x30);
-
-	  if (c == 0x1e9b)
-	    return 0x1e61;
+	  if (!(c & 0x01))
+	    return (c + 1);
+	  return c;
 	}
-      else if (c < 0x2000)
+      
+      if (c >= 0x0531 && c <= 0x0556)
+	return (c + 0x30);
+
+      if (c == 0x1e9b)
+	return 0x1e61;
+    }
+  else if (c < 0x2000)
+    {
+      if ((c >= 0x1f08 && c <= 0x1f0f) ||
+	  (c >= 0x1f18 && c <= 0x1f1d) ||
+	  (c >= 0x1f28 && c <= 0x1f2f) ||
+	  (c >= 0x1f38 && c <= 0x1f3f) ||
+	  (c >= 0x1f48 && c <= 0x1f4d) ||
+	  (c >= 0x1f68 && c <= 0x1f6f) ||
+	  (c >= 0x1f88 && c <= 0x1f8f) ||
+	  (c >= 0x1f98 && c <= 0x1f9f) ||
+	  (c >= 0x1fa8 && c <= 0x1faf))
+	return (c - 0x08);
+
+      if (c >= 0x1f59 && c <= 0x1f5f)
 	{
-	  if ((c >= 0x1f08 && c <= 0x1f0f) ||
-	      (c >= 0x1f18 && c <= 0x1f1d) ||
-	      (c >= 0x1f28 && c <= 0x1f2f) ||
-	      (c >= 0x1f38 && c <= 0x1f3f) ||
-	      (c >= 0x1f48 && c <= 0x1f4d) ||
-	      (c >= 0x1f68 && c <= 0x1f6f) ||
-	      (c >= 0x1f88 && c <= 0x1f8f) ||
-	      (c >= 0x1f98 && c <= 0x1f9f) ||
-	      (c >= 0x1fa8 && c <= 0x1faf))
+	  if (c & 0x01)
 	    return (c - 0x08);
-
-	  if (c >= 0x1f59 && c <= 0x1f5f)
-	    {
-	      if (c & 0x01)
-		return (c - 0x08);
-	      return c;
-	    }
-	
-	  if (c >= 0x1fb8 && c <= 0x1ffc)
+	  return c;
+	}
+    
+      if (c >= 0x1fb8 && c <= 0x1ffc)
+	{
+	  wint_t k;
+	  switch (c)
 	    {
-	      wint_t k;
-	      switch (c)
-		{
-		case 0x1fb8:
-		case 0x1fb9:
-		case 0x1fd8:
-		case 0x1fd9:
-		case 0x1fe8:
-		case 0x1fe9:
-		  k = c - 0x08;
-		  break;
-		case 0x1fba:
-		case 0x1fbb:
-		  k = c - 0x4a;
-		  break;
-		case 0x1fbc:
-		  k = 0x1fb3;
-		  break;
-		case 0x1fbe:
-		  k = 0x03b9;
-		  break;
-		case 0x1fc8:
-		case 0x1fc9:
-		case 0x1fca:
-		case 0x1fcb:
-		  k = c - 0x56;
-		  break;
-		case 0x1fcc:
-		  k = 0x1fc3;
-		  break;
-		case 0x1fda:
-		case 0x1fdb:
-		  k = c - 0x64;
-		  break;
-		case 0x1fea:
-		case 0x1feb:
-		  k = c - 0x70;
-		  break;
-		case 0x1fec:
-		  k = 0x1fe5;
-		  break;
-		case 0x1ffa:
-		case 0x1ffb:
-		  k = c - 0x7e;
-		  break;
-		case 0x1ffc:
-		  k = 0x1ff3;
-		  break;
-		default:
-		  k = 0;
-		}
-	      if (k != 0)
-		return k;
+	    case 0x1fb8:
+	    case 0x1fb9:
+	    case 0x1fd8:
+	    case 0x1fd9:
+	    case 0x1fe8:
+	    case 0x1fe9:
+	      k = c - 0x08;
+	      break;
+	    case 0x1fba:
+	    case 0x1fbb:
+	      k = c - 0x4a;
+	      break;
+	    case 0x1fbc:
+	      k = 0x1fb3;
+	      break;
+	    case 0x1fbe:
+	      k = 0x03b9;
+	      break;
+	    case 0x1fc8:
+	    case 0x1fc9:
+	    case 0x1fca:
+	    case 0x1fcb:
+	      k = c - 0x56;
+	      break;
+	    case 0x1fcc:
+	      k = 0x1fc3;
+	      break;
+	    case 0x1fda:
+	    case 0x1fdb:
+	      k = c - 0x64;
+	      break;
+	    case 0x1fea:
+	    case 0x1feb:
+	      k = c - 0x70;
+	      break;
+	    case 0x1fec:
+	      k = 0x1fe5;
+	      break;
+	    case 0x1ffa:
+	    case 0x1ffb:
+	      k = c - 0x7e;
+	      break;
+	    case 0x1ffc:
+	      k = 0x1ff3;
+	      break;
+	    default:
+	      k = 0;
 	    }
+	  if (k != 0)
+	    return k;
 	}
-      else 
-	{
-	  if (c >= 0x2160 && c <= 0x216f)
-	    return (c + 0x10);
-	  
-	  if (c >= 0x24b6 && c <= 0x24cf)
-	    return (c + 0x1a);
-	  
-	  if (c >= 0xff21 && c <= 0xff3a)
-	    return (c + 0x20);
-	  
-	  if (c >= 0x10400 && c <= 0x10425)
-	    return (c + 0x28);
+    }
+  else 
+    {
+      if (c >= 0x2160 && c <= 0x216f)
+	return (c + 0x10);
+      
+      if (c >= 0x24b6 && c <= 0x24cf)
+	return (c + 0x1a);
+      
+      if (c >= 0xff21 && c <= 0xff3a)
+	return (c + 0x20);
+      
+      if (c >= 0x10400 && c <= 0x10425)
+	return (c + 0x28);
 
-	  if (c == 0x2126)
-	    return 0x03c9;
-	  if (c == 0x212a)
-	    return 0x006b;
-	  if (c == 0x212b)
-	    return 0x00e5;
-	}
-    }     
-#endif /* _MB_CAPABLE */
-  
+      if (c == 0x2126)
+	return 0x03c9;
+      if (c == 0x212a)
+	return 0x006b;
+      if (c == 0x212b)
+	return 0x00e5;
+    }
+  return c;
+#else
   return (c < 0x00ff ? (wint_t)(tolower ((int)c)) : c);
+#endif /* _MB_CAPABLE */
 }
 
diff --git a/newlib/libc/ctype/towupper.c b/newlib/libc/ctype/towupper.c
index 385dc9ba6..dee9468bd 100644
--- a/newlib/libc/ctype/towupper.c
+++ b/newlib/libc/ctype/towupper.c
@@ -70,432 +70,415 @@ wint_t
 _DEFUN(towupper,(c), wint_t c)
 {
 #ifdef _MB_CAPABLE
-  int unicode = 0;
-
   if (!strcmp (__locale_charset (), "JIS"))
-    {
-      c = __jp2uc (c, JP_JIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_JIS);
   else if (!strcmp (__locale_charset (), "SJIS"))
-    {
-      c = __jp2uc (c, JP_SJIS);
-      unicode = 1;
-    }
+    c = __jp2uc (c, JP_SJIS);
   else if (!strcmp (__locale_charset (), "EUCJP"))
+    c = __jp2uc (c, JP_EUCJP);
+
+  if (c < 0x100)
     {
-      c = __jp2uc (c, JP_EUCJP);
-      unicode = 1;
-    }
-  else if (!strcmp (__locale_charset (), "UTF-8"))
-    {
-      unicode = 1;
+      if (c == 0x00b5)
+	return 0x039c;
+      
+      if ((c >= 0x00e0 && c <= 0x00fe) ||
+	  (c >= 0x0061 && c <= 0x007a))
+	return (c - 0x20);
+      
+      if (c == 0xff)
+	return 0x0178;
+      
+      return c;
     }
-
-  if (unicode)
+  else if (c < 0x300)
     {
-      if (c < 0x100)
+      if ((c >= 0x0101 && c <= 0x012f) ||
+	  (c >= 0x0133 && c <= 0x0137) ||
+	  (c >= 0x014b && c <= 0x0177) ||
+	  (c >= 0x01df && c <= 0x01ef) ||
+	  (c >= 0x01f9 && c <= 0x021f) ||
+	  (c >= 0x0223 && c <= 0x0233))
 	{
-	  if (c == 0x00b5)
-	    return 0x039c;
-	  
-	  if ((c >= 0x00e0 && c <= 0x00fe) ||
-	      (c >= 0x0061 && c <= 0x007a))
-	    return (c - 0x20);
-	  
-	  if (c == 0xff)
-	    return 0x0178;
-	  
+	  if (c & 0x01)
+	    return (c - 1);
 	  return c;
 	}
-      else if (c < 0x300)
-	{
-	  if ((c >= 0x0101 && c <= 0x012f) ||
-	      (c >= 0x0133 && c <= 0x0137) ||
-	      (c >= 0x014b && c <= 0x0177) ||
-	      (c >= 0x01df && c <= 0x01ef) ||
-	      (c >= 0x01f9 && c <= 0x021f) ||
-	      (c >= 0x0223 && c <= 0x0233))
-	    {
-	      if (c & 0x01)
-		return (c - 1);
-	      return c;
-	    }
 
-	  if ((c >= 0x013a && c <= 0x0148) ||
-	      (c >= 0x01ce && c <= 0x1dc))
-	    {
-	      if (!(c & 0x01))
-		return (c - 1);
-	      return c;
-	    }
-	  
-	  if (c == 0x0131)
-	    return 0x0049;
-	  
-	  if (c == 0x017a || c == 0x017c || c == 0x017e)
+      if ((c >= 0x013a && c <= 0x0148) ||
+	  (c >= 0x01ce && c <= 0x1dc))
+	{
+	  if (!(c & 0x01))
 	    return (c - 1);
-	  
-	  if (c >= 0x017f && c <= 0x0292)
-	    {
-	      wint_t k;
-	      switch (c)
-		{
-		case 0x017f:
-		  k = 0x0053;
-		  break;
-		case 0x0183:
-		  k = 0x0182;
-		  break;
-		case 0x0185:
-		  k = 0x0184;
-		  break;
-		case 0x0188:
-		  k = 0x0187;
-		  break;
-		case 0x018c:
-		  k = 0x018b;
-		  break;
-		case 0x0192:
-		  k = 0x0191;
-		  break;
-		case 0x0195:
-		  k = 0x01f6;
-		  break;
-		case 0x0199:
-		  k = 0x0198;
-		  break;
-		case 0x019e:
-		  k = 0x0220;
-		  break;
-		case 0x01a1:
-		case 0x01a3:
-		case 0x01a5:
-		case 0x01a8:
-		case 0x01ad:
-		case 0x01b0:
-		case 0x01b4:
-		case 0x01b6:
-		case 0x01b9:
-		case 0x01bd:
-		case 0x01c5:
-		case 0x01c8:
-		case 0x01cb:
-		case 0x01f2:
-		case 0x01f5:
-		  k = c - 1;
-		  break;
-		case 0x01bf:
-		  k = 0x01f7;
-		  break;
-		case 0x01c6:
-		case 0x01c9:
-		case 0x01cc:
-		  k = c - 2;
-		  break;
-		case 0x01dd:
-		  k = 0x018e;
-		  break;
-		case 0x01f3:
-		  k = 0x01f1;
-		  break;
-		case 0x0253:
-		  k = 0x0181;
-		  break;
-		case 0x0254:
-		  k = 0x0186;
-		  break;
-		case 0x0256:
-		  k = 0x0189;
-		  break;
-		case 0x0257:
-		  k = 0x018a;
-		  break;
-		case 0x0259:
-		  k = 0x018f;
-		  break;
-		case 0x025b:
-		  k = 0x0190;
-		  break;
-		case 0x0260:
-		  k = 0x0193;
-		  break;
-		case 0x0263:
-		  k = 0x0194;
-		  break;
-		case 0x0268:
-		  k = 0x0197;
-		  break;
-		case 0x0269:
-		  k = 0x0196;
-		  break;
-		case 0x026f:
-		  k = 0x019c;
-		  break;
-		case 0x0272:
-		  k = 0x019d;
-		  break;
-		case 0x0275:
-		  k = 0x019f;
-		  break;
-		case 0x0280:
-		  k = 0x01a6;
-		  break;
-		case 0x0283:
-		  k = 0x01a9;
-		  break;
-		case 0x0288:
-		  k = 0x01ae;
-		  break;
-		case 0x028a:
-		  k = 0x01b1;
-		  break;
-		case 0x028b:
-		  k = 0x01b2;
-		  break;
-		case 0x0292:
-		  k = 0x01b7;
-		  break;
-		default:
-		  k = 0;
-		}
-	      if (k != 0)
-		return k;
-	    }
+	  return c;
 	}
-      else if (c < 0x0400)
+      
+      if (c == 0x0131)
+	return 0x0049;
+      
+      if (c == 0x017a || c == 0x017c || c == 0x017e)
+	return (c - 1);
+      
+      if (c >= 0x017f && c <= 0x0292)
 	{
-	  if (c == 0x03ac)
-	    return 0x0386;
-	  
-	  if ((c & 0xfff0) == 0x03a0 && c >= 0x03ad)
-	    return (c - 0x15);
-	  
-	  if (c >= 0x03b1 && c <= 0x03cb && c != 0x03c2)
-	    return (c - 0x20);
-	  
-	  if (c == 0x03c2)
-	    return 0x03a3;
-	  
-	  if (c >= 0x03cc && c <= 0x03f5)
+	  wint_t k;
+	  switch (c)
 	    {
-	      wint_t k;
-	      switch (c)
-		{
-		case 0x03cc:
-		  k = 0x038c;
-		  break;
-		case 0x03cd:
-		case 0x03ce:
-		  k = c - 0x3f;
-		  break;
-		case 0x03d0:
-		  k = 0x0392;
-		  break;
-		case 0x03d1:
-		  k = 0x0398;
-		  break;
-		case 0x03d5:
-		  k = 0x03a6;
-		  break;
-		case 0x03d6:
-		  k = 0x03a0;
-		  break;
-		case 0x03d9:
-		case 0x03db:
-		case 0x03dd:
-		case 0x03df:
-		case 0x03e1:
-		case 0x03e3:
-		case 0x03e5:
-		case 0x03e7:
-		case 0x03e9:
-		case 0x03eb:
-		case 0x03ed:
-		case 0x03ef:
-		  k = c - 1;
-		  break;
-		case 0x03f0:
-		  k = 0x039a;
-		  break;
-		case 0x03f1:
-		  k = 0x03a1;
-		  break;
-		case 0x03f2:
-		  k = 0x03a3;
-		  break;
-		case 0x03f5:
-		  k = 0x0395;
-		  break;
-		default:
-		  k = 0;
-		}
-	      if (k != 0)
-		return k;
+	    case 0x017f:
+	      k = 0x0053;
+	      break;
+	    case 0x0183:
+	      k = 0x0182;
+	      break;
+	    case 0x0185:
+	      k = 0x0184;
+	      break;
+	    case 0x0188:
+	      k = 0x0187;
+	      break;
+	    case 0x018c:
+	      k = 0x018b;
+	      break;
+	    case 0x0192:
+	      k = 0x0191;
+	      break;
+	    case 0x0195:
+	      k = 0x01f6;
+	      break;
+	    case 0x0199:
+	      k = 0x0198;
+	      break;
+	    case 0x019e:
+	      k = 0x0220;
+	      break;
+	    case 0x01a1:
+	    case 0x01a3:
+	    case 0x01a5:
+	    case 0x01a8:
+	    case 0x01ad:
+	    case 0x01b0:
+	    case 0x01b4:
+	    case 0x01b6:
+	    case 0x01b9:
+	    case 0x01bd:
+	    case 0x01c5:
+	    case 0x01c8:
+	    case 0x01cb:
+	    case 0x01f2:
+	    case 0x01f5:
+	      k = c - 1;
+	      break;
+	    case 0x01bf:
+	      k = 0x01f7;
+	      break;
+	    case 0x01c6:
+	    case 0x01c9:
+	    case 0x01cc:
+	      k = c - 2;
+	      break;
+	    case 0x01dd:
+	      k = 0x018e;
+	      break;
+	    case 0x01f3:
+	      k = 0x01f1;
+	      break;
+	    case 0x0253:
+	      k = 0x0181;
+	      break;
+	    case 0x0254:
+	      k = 0x0186;
+	      break;
+	    case 0x0256:
+	      k = 0x0189;
+	      break;
+	    case 0x0257:
+	      k = 0x018a;
+	      break;
+	    case 0x0259:
+	      k = 0x018f;
+	      break;
+	    case 0x025b:
+	      k = 0x0190;
+	      break;
+	    case 0x0260:
+	      k = 0x0193;
+	      break;
+	    case 0x0263:
+	      k = 0x0194;
+	      break;
+	    case 0x0268:
+	      k = 0x0197;
+	      break;
+	    case 0x0269:
+	      k = 0x0196;
+	      break;
+	    case 0x026f:
+	      k = 0x019c;
+	      break;
+	    case 0x0272:
+	      k = 0x019d;
+	      break;
+	    case 0x0275:
+	      k = 0x019f;
+	      break;
+	    case 0x0280:
+	      k = 0x01a6;
+	      break;
+	    case 0x0283:
+	      k = 0x01a9;
+	      break;
+	    case 0x0288:
+	      k = 0x01ae;
+	      break;
+	    case 0x028a:
+	      k = 0x01b1;
+	      break;
+	    case 0x028b:
+	      k = 0x01b2;
+	      break;
+	    case 0x0292:
+	      k = 0x01b7;
+	      break;
+	    default:
+	      k = 0;
 	    }
+	  if (k != 0)
+	    return k;
 	}
-      else if (c < 0x500)
+    }
+  else if (c < 0x0400)
+    {
+      if (c == 0x03ac)
+	return 0x0386;
+      
+      if ((c & 0xfff0) == 0x03a0 && c >= 0x03ad)
+	return (c - 0x15);
+      
+      if (c >= 0x03b1 && c <= 0x03cb && c != 0x03c2)
+	return (c - 0x20);
+      
+      if (c == 0x03c2)
+	return 0x03a3;
+      
+      if (c >= 0x03cc && c <= 0x03f5)
 	{
-	  if (c >= 0x0450 && c <= 0x045f)
-	    return (c - 0x50);
-	  
-	  if (c >= 0x0430 && c <= 0x044f)
-	    return (c - 0x20);
-	  
-	  if ((c >= 0x0461 && c <= 0x0481) ||
-	      (c >= 0x048b && c <= 0x04bf) ||
-	      (c >= 0x04d1 && c <= 0x04f5))
-	    {
-	      if (c & 0x01)
-		return (c - 1);
-	      return c;
-	    }
-	  
-	  if (c >= 0x04c2 && c <= 0x04ce)
+	  wint_t k;
+	  switch (c)
 	    {
-	      if (!(c & 0x01))
-		return (c - 1);
-	      return c;
+	    case 0x03cc:
+	      k = 0x038c;
+	      break;
+	    case 0x03cd:
+	    case 0x03ce:
+	      k = c - 0x3f;
+	      break;
+	    case 0x03d0:
+	      k = 0x0392;
+	      break;
+	    case 0x03d1:
+	      k = 0x0398;
+	      break;
+	    case 0x03d5:
+	      k = 0x03a6;
+	      break;
+	    case 0x03d6:
+	      k = 0x03a0;
+	      break;
+	    case 0x03d9:
+	    case 0x03db:
+	    case 0x03dd:
+	    case 0x03df:
+	    case 0x03e1:
+	    case 0x03e3:
+	    case 0x03e5:
+	    case 0x03e7:
+	    case 0x03e9:
+	    case 0x03eb:
+	    case 0x03ed:
+	    case 0x03ef:
+	      k = c - 1;
+	      break;
+	    case 0x03f0:
+	      k = 0x039a;
+	      break;
+	    case 0x03f1:
+	      k = 0x03a1;
+	      break;
+	    case 0x03f2:
+	      k = 0x03a3;
+	      break;
+	    case 0x03f5:
+	      k = 0x0395;
+	      break;
+	    default:
+	      k = 0;
 	    }
-	  
-	  if (c == 0x04f9)
-	    return 0x04f8;
+	  if (k != 0)
+	    return k;
 	}
-      else if (c < 0x1f00)
+    }
+  else if (c < 0x500)
+    {
+      if (c >= 0x0450 && c <= 0x045f)
+	return (c - 0x50);
+      
+      if (c >= 0x0430 && c <= 0x044f)
+	return (c - 0x20);
+      
+      if ((c >= 0x0461 && c <= 0x0481) ||
+	  (c >= 0x048b && c <= 0x04bf) ||
+	  (c >= 0x04d1 && c <= 0x04f5))
 	{
-	  if ((c >= 0x0501 && c <= 0x050f) ||
-	      (c >= 0x1e01 && c <= 0x1e95) ||
-	      (c >= 0x1ea1 && c <= 0x1ef9))
-	    {
-	      if (c & 0x01)
-		return (c - 1);
-	      return c;
-	    }
-	  
-	  if (c >= 0x0561 && c <= 0x0586)
-	    return (c - 0x30);
-
-	  if (c == 0x1e9b)
-	    return 0x1e60;
+	  if (c & 0x01)
+	    return (c - 1);
+	  return c;
 	}
-      else if (c < 0x2000)
+      
+      if (c >= 0x04c2 && c <= 0x04ce)
 	{
-	  
-	  if ((c >= 0x1f00 && c <= 0x1f07) ||
-	      (c >= 0x1f10 && c <= 0x1f15) ||
-	      (c >= 0x1f20 && c <= 0x1f27) ||
-	      (c >= 0x1f30 && c <= 0x1f37) ||
-	      (c >= 0x1f40 && c <= 0x1f45) ||
-	      (c >= 0x1f60 && c <= 0x1f67) ||
-	      (c >= 0x1f80 && c <= 0x1f87) ||
-	      (c >= 0x1f90 && c <= 0x1f97) ||
-	      (c >= 0x1fa0 && c <= 0x1fa7))
-	    return (c + 0x08);
- 
-	  if (c >= 0x1f51 && c <= 0x1f57 && (c & 0x01))
-	    return (c + 0x08);
-	  
-	  if (c >= 0x1f70 && c <= 0x1ff3)
-	    {
-	      wint_t k;
-	      switch (c)
-		{
-		case 0x1fb0:
-		  k = 0x1fb8;
-		  break;
-		case 0x1fb1:
-		  k = 0x1fb9;
-		  break;
-		case 0x1f70:
-		  k = 0x1fba;
-		  break;
-		case 0x1f71:
-		  k = 0x1fbb;
-		  break;
-		case 0x1fb3:
-		  k = 0x1fbc;
-		  break;
-		case 0x1fbe:
-		  k = 0x0399;
-		  break;
-		case 0x1f72:
-		  k = 0x1fc8;
-		  break;
-		case 0x1f73:
-		  k = 0x1fc9;
-		  break;
-		case 0x1f74:
-		  k = 0x1fca;
-		  break;
-		case 0x1f75:
-		  k = 0x1fcb;
-		  break;
-		case 0x1fd0:
-		  k = 0x1fd8;
-		  break;
-		case 0x1fd1:
-		  k = 0x1fd9;
-		  break;
-		case 0x1f76:
-		  k = 0x1fda;
-		  break;
-		case 0x1f77:
-		  k = 0x1fdb;
-		  break;
-		case 0x1fe0:
-		  k = 0x1fe8;
-		  break;
-		case 0x1fe1:
-		  k = 0x1fe9;
-		  break;
-		case 0x1f7a:
-		  k = 0x1fea;
-		  break;
-		case 0x1f7b:
-		  k = 0x1feb;
-		  break;
-		case 0x1fe5:
-		  k = 0x1fec;
-		  break;
-		case 0x1f78:
-		  k = 0x1ff8;
-		  break;
-		case 0x1f79:
-		  k = 0x1ff9;
-		  break;
-		case 0x1f7c:
-		  k = 0x1ffa;
-		  break;
-		case 0x1f7d:
-		  k = 0x1ffb;
-		  break;
-		case 0x1ff3:
-		  k = 0x1ffc;
-		  break;
-		default:
-		  k = 0;
-		}
-	      if (k != 0)
-		return k;
-	    }
+	  if (!(c & 0x01))
+	    return (c - 1);
+	  return c;
 	}
-      else 
+      
+      if (c == 0x04f9)
+	return 0x04f8;
+    }
+  else if (c < 0x1f00)
+    {
+      if ((c >= 0x0501 && c <= 0x050f) ||
+	  (c >= 0x1e01 && c <= 0x1e95) ||
+	  (c >= 0x1ea1 && c <= 0x1ef9))
 	{
-	  if (c >= 0x2170 && c <= 0x217f)
-	    return (c - 0x10);
-	  
-	  if (c >= 0x24d0 && c <= 0x24e9)
-	    return (c - 0x1a);
-	  
-	  if (c >= 0xff41 && c <= 0xff5a)
-	    return (c - 0x20);
-	  
-	  if (c >= 0x10428 && c <= 0x1044d)
-	    return (c - 0x28);
+	  if (c & 0x01)
+	    return (c - 1);
+	  return c;
 	}
-    }     
-#endif /* _MB_CAPABLE */
-  
+      
+      if (c >= 0x0561 && c <= 0x0586)
+	return (c - 0x30);
+
+      if (c == 0x1e9b)
+	return 0x1e60;
+    }
+  else if (c < 0x2000)
+    {
+      
+      if ((c >= 0x1f00 && c <= 0x1f07) ||
+	  (c >= 0x1f10 && c <= 0x1f15) ||
+	  (c >= 0x1f20 && c <= 0x1f27) ||
+	  (c >= 0x1f30 && c <= 0x1f37) ||
+	  (c >= 0x1f40 && c <= 0x1f45) ||
+	  (c >= 0x1f60 && c <= 0x1f67) ||
+	  (c >= 0x1f80 && c <= 0x1f87) ||
+	  (c >= 0x1f90 && c <= 0x1f97) ||
+	  (c >= 0x1fa0 && c <= 0x1fa7))
+	return (c + 0x08);
+
+      if (c >= 0x1f51 && c <= 0x1f57 && (c & 0x01))
+	return (c + 0x08);
+      
+      if (c >= 0x1f70 && c <= 0x1ff3)
+	{
+	  wint_t k;
+	  switch (c)
+	    {
+	    case 0x1fb0:
+	      k = 0x1fb8;
+	      break;
+	    case 0x1fb1:
+	      k = 0x1fb9;
+	      break;
+	    case 0x1f70:
+	      k = 0x1fba;
+	      break;
+	    case 0x1f71:
+	      k = 0x1fbb;
+	      break;
+	    case 0x1fb3:
+	      k = 0x1fbc;
+	      break;
+	    case 0x1fbe:
+	      k = 0x0399;
+	      break;
+	    case 0x1f72:
+	      k = 0x1fc8;
+	      break;
+	    case 0x1f73:
+	      k = 0x1fc9;
+	      break;
+	    case 0x1f74:
+	      k = 0x1fca;
+	      break;
+	    case 0x1f75:
+	      k = 0x1fcb;
+	      break;
+	    case 0x1fd0:
+	      k = 0x1fd8;
+	      break;
+	    case 0x1fd1:
+	      k = 0x1fd9;
+	      break;
+	    case 0x1f76:
+	      k = 0x1fda;
+	      break;
+	    case 0x1f77:
+	      k = 0x1fdb;
+	      break;
+	    case 0x1fe0:
+	      k = 0x1fe8;
+	      break;
+	    case 0x1fe1:
+	      k = 0x1fe9;
+	      break;
+	    case 0x1f7a:
+	      k = 0x1fea;
+	      break;
+	    case 0x1f7b:
+	      k = 0x1feb;
+	      break;
+	    case 0x1fe5:
+	      k = 0x1fec;
+	      break;
+	    case 0x1f78:
+	      k = 0x1ff8;
+	      break;
+	    case 0x1f79:
+	      k = 0x1ff9;
+	      break;
+	    case 0x1f7c:
+	      k = 0x1ffa;
+	      break;
+	    case 0x1f7d:
+	      k = 0x1ffb;
+	      break;
+	    case 0x1ff3:
+	      k = 0x1ffc;
+	      break;
+	    default:
+	      k = 0;
+	    }
+	  if (k != 0)
+	    return k;
+	}
+    }
+  else 
+    {
+      if (c >= 0x2170 && c <= 0x217f)
+	return (c - 0x10);
+      
+      if (c >= 0x24d0 && c <= 0x24e9)
+	return (c - 0x1a);
+      
+      if (c >= 0xff41 && c <= 0xff5a)
+	return (c - 0x20);
+      
+      if (c >= 0x10428 && c <= 0x1044d)
+	return (c - 0x28);
+    }
+  return c;
+#else
   return (c < 0x00ff ? (wint_t)(toupper ((int)c)) : c);
+#endif /* _MB_CAPABLE */
 }