--- setrunelocale.c.bsdnew	2009-11-09 15:05:25.000000000 -0800
+++ setrunelocale.c	2009-11-09 17:20:45.000000000 -0800
@@ -33,6 +33,8 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD: src/lib/libc/locale/setrunelocale.c,v 1.51 2008/01/23 03:05:35 ache Exp $");
 
+#include "xlocale_private.h"
+
 #include <runetype.h>
 #include <errno.h>
 #include <limits.h>
@@ -45,67 +47,60 @@ __FBSDID("$FreeBSD: src/lib/libc/locale/
 #include "mblocal.h"
 #include "setlocale.h"
 
-extern int __mb_sb_limit;
-
-extern _RuneLocale	*_Read_RuneMagi(FILE *);
+extern struct __xlocale_st_runelocale	*_Read_RuneMagi(FILE *);
 
-static int		__setrunelocale(const char *);
+#ifdef UNIFDEF_LEGACY_RUNE_APIS
+/* depreciated interfaces */
+rune_t	sgetrune(const char *, size_t, char const **);
+int	sputrune(rune_t, char *, size_t, char **);
+#endif /* UNIFDEF_LEGACY_RUNE_APIS */
 
-static int
-__setrunelocale(const char *encoding)
+__private_extern__ int
+__setrunelocale(const char *encoding, locale_t loc)
 {
 	FILE *fp;
 	char name[PATH_MAX];
+	struct __xlocale_st_runelocale *xrl;
 	_RuneLocale *rl;
 	int saverr, ret;
-	size_t (*old__mbrtowc)(wchar_t * __restrict,
-	    const char * __restrict, size_t, mbstate_t * __restrict);
-	size_t (*old__wcrtomb)(char * __restrict, wchar_t,
-	    mbstate_t * __restrict);
-	int (*old__mbsinit)(const mbstate_t *);
-	size_t (*old__mbsnrtowcs)(wchar_t * __restrict,
-	    const char ** __restrict, size_t, size_t, mbstate_t * __restrict);
-	size_t (*old__wcsnrtombs)(char * __restrict,
-	    const wchar_t ** __restrict, size_t, size_t,
-	    mbstate_t * __restrict);
-	static char ctype_encoding[ENCODING_LEN + 1];
-	static _RuneLocale *CachedRuneLocale;
-	static int Cached__mb_cur_max;
-	static int Cached__mb_sb_limit;
-	static size_t (*Cached__mbrtowc)(wchar_t * __restrict,
-	    const char * __restrict, size_t, mbstate_t * __restrict);
-	static size_t (*Cached__wcrtomb)(char * __restrict, wchar_t,
-	    mbstate_t * __restrict);
-	static int (*Cached__mbsinit)(const mbstate_t *);
-	static size_t (*Cached__mbsnrtowcs)(wchar_t * __restrict,
-	    const char ** __restrict, size_t, size_t, mbstate_t * __restrict);
-	static size_t (*Cached__wcsnrtombs)(char * __restrict,
-	    const wchar_t ** __restrict, size_t, size_t,
-	    mbstate_t * __restrict);
+	static struct __xlocale_st_runelocale *CachedRuneLocale;
+	extern int __mb_cur_max;
+	extern int __mb_sb_limit;
+	static pthread_lock_t cache_lock = LOCK_INITIALIZER;
 
 	/*
 	 * The "C" and "POSIX" locale are always here.
 	 */
 	if (strcmp(encoding, "C") == 0 || strcmp(encoding, "POSIX") == 0) {
-		(void) _none_init(&_DefaultRuneLocale);
+		XL_RELEASE(loc->__lc_ctype);
+		loc->__lc_ctype = &_DefaultRuneXLocale;
+		/* no need to retain _DefaultRuneXLocale */
+		if (loc == &__global_locale) {
+			_CurrentRuneLocale = &loc->__lc_ctype->_CurrentRuneLocale;
+			__mb_cur_max = loc->__lc_ctype->__mb_cur_max;
+			__mb_sb_limit = loc->__lc_ctype->__mb_sb_limit;
+		}
 		return (0);
 	}
 
 	/*
 	 * If the locale name is the same as our cache, use the cache.
 	 */
+	LOCK(cache_lock);
 	if (CachedRuneLocale != NULL &&
-	    strcmp(encoding, ctype_encoding) == 0) {
-		_CurrentRuneLocale = CachedRuneLocale;
-		__mb_cur_max = Cached__mb_cur_max;
-		__mb_sb_limit = Cached__mb_sb_limit;
-		__mbrtowc = Cached__mbrtowc;
-		__mbsinit = Cached__mbsinit;
-		__mbsnrtowcs = Cached__mbsnrtowcs;
-		__wcrtomb = Cached__wcrtomb;
-		__wcsnrtombs = Cached__wcsnrtombs;
+	    strcmp(encoding, CachedRuneLocale->__ctype_encoding) == 0) {
+		XL_RELEASE(loc->__lc_ctype);
+		loc->__lc_ctype = CachedRuneLocale;
+		XL_RETAIN(loc->__lc_ctype);
+		if (loc == &__global_locale) {
+			_CurrentRuneLocale = &loc->__lc_ctype->_CurrentRuneLocale;
+			__mb_cur_max = loc->__lc_ctype->__mb_cur_max;
+			__mb_sb_limit = loc->__lc_ctype->__mb_sb_limit;
+		}
+		UNLOCK(cache_lock);
 		return (0);
 	}
+	UNLOCK(cache_lock);
 
 	/*
 	 * Slurp the locale file into the cache.
@@ -120,80 +115,90 @@ __setrunelocale(const char *encoding)
 	if ((fp = fopen(name, "r")) == NULL)
 		return (errno == 0 ? ENOENT : errno);
 
-	if ((rl = _Read_RuneMagi(fp)) == NULL) {
+	if ((xrl = _Read_RuneMagi(fp)) == NULL) {
 		saverr = (errno == 0 ? EFTYPE : errno);
 		(void)fclose(fp);
 		return (saverr);
 	}
 	(void)fclose(fp);
 
-	old__mbrtowc = __mbrtowc;
-	old__mbsinit = __mbsinit;
-	old__mbsnrtowcs = __mbsnrtowcs;
-	old__wcrtomb = __wcrtomb;
-	old__wcsnrtombs = __wcsnrtombs;
-
-	__mbrtowc = NULL;
-	__mbsinit = NULL;
-	__mbsnrtowcs = __mbsnrtowcs_std;
-	__wcrtomb = NULL;
-	__wcsnrtombs = __wcsnrtombs_std;
-
+	xrl->__mbrtowc = NULL;
+	xrl->__mbsinit = NULL;
+	xrl->__mbsnrtowcs = __mbsnrtowcs_std;
+	xrl->__wcrtomb = NULL;
+	xrl->__wcsnrtombs = __wcsnrtombs_std;
+
+	rl = &xrl->_CurrentRuneLocale;
+
+#ifdef UNIFDEF_LEGACY_RUNE_APIS
+	/* provide backwards compatibility (depreciated interface) */
+	rl->__sputrune = sputrune;
+	rl->__sgetrune = sgetrune;
+#else /* UNIFDEF_LEGACY_RUNE_APIS */
 	rl->__sputrune = NULL;
 	rl->__sgetrune = NULL;
+#endif /* UNIFDEF_LEGACY_RUNE_APIS */
+
 	if (strcmp(rl->__encoding, "NONE") == 0)
-		ret = _none_init(rl);
+		ret = _none_init(xrl);
 	else if (strcmp(rl->__encoding, "ASCII") == 0)
-		ret = _ascii_init(rl);
+		ret = _ascii_init(xrl);
 	else if (strcmp(rl->__encoding, "UTF-8") == 0)
-		ret = _UTF8_init(rl);
+		ret = _UTF8_init(xrl);
 	else if (strcmp(rl->__encoding, "EUC") == 0)
-		ret = _EUC_init(rl);
+		ret = _EUC_init(xrl);
 	else if (strcmp(rl->__encoding, "GB18030") == 0)
- 		ret = _GB18030_init(rl);
+ 		ret = _GB18030_init(xrl);
 	else if (strcmp(rl->__encoding, "GB2312") == 0)
-		ret = _GB2312_init(rl);
+		ret = _GB2312_init(xrl);
 	else if (strcmp(rl->__encoding, "GBK") == 0)
-		ret = _GBK_init(rl);
+		ret = _GBK_init(xrl);
 	else if (strcmp(rl->__encoding, "BIG5") == 0)
-		ret = _BIG5_init(rl);
+		ret = _BIG5_init(xrl);
 	else if (strcmp(rl->__encoding, "MSKanji") == 0)
-		ret = _MSKanji_init(rl);
+		ret = _MSKanji_init(xrl);
+	else if (strcmp(rl->__encoding, "UTF2") == 0)
+		ret = _UTF2_init(xrl);
 	else
 		ret = EFTYPE;
 
 	if (ret == 0) {
-		if (CachedRuneLocale != NULL) {
-			/* See euc.c */
-			if (strcmp(CachedRuneLocale->__encoding, "EUC") == 0)
-				free(CachedRuneLocale->__variable);
-			free(CachedRuneLocale);
+		(void)strcpy(xrl->__ctype_encoding, encoding);
+		XL_RELEASE(loc->__lc_ctype);
+		loc->__lc_ctype = xrl;
+		if (loc == &__global_locale) {
+			_CurrentRuneLocale = &loc->__lc_ctype->_CurrentRuneLocale;
+			__mb_cur_max = loc->__lc_ctype->__mb_cur_max;
+			__mb_sb_limit = loc->__lc_ctype->__mb_sb_limit;
 		}
-		CachedRuneLocale = _CurrentRuneLocale;
-		Cached__mb_cur_max = __mb_cur_max;
-		Cached__mb_sb_limit = __mb_sb_limit;
-		Cached__mbrtowc = __mbrtowc;
-		Cached__mbsinit = __mbsinit;
-		Cached__mbsnrtowcs = __mbsnrtowcs;
-		Cached__wcrtomb = __wcrtomb;
-		Cached__wcsnrtombs = __wcsnrtombs;
-		(void)strcpy(ctype_encoding, encoding);
-	} else {
-		__mbrtowc = old__mbrtowc;
-		__mbsinit = old__mbsinit;
-		__mbsnrtowcs = old__mbsnrtowcs;
-		__wcrtomb = old__wcrtomb;
-		__wcsnrtombs = old__wcsnrtombs;
-		free(rl);
-	}
+		LOCK(cache_lock);
+		XL_RELEASE(CachedRuneLocale);
+		CachedRuneLocale = xrl;
+		XL_RETAIN(CachedRuneLocale);
+		UNLOCK(cache_lock);
+	} else
+		XL_RELEASE(xrl);
 
 	return (ret);
 }
 
+#ifdef UNIFDEF_LEGACY_RUNE_APIS
 int
-__wrap_setrunelocale(const char *locale)
+setrunelocale(const char *encoding)
+{
+	int ret;
+
+	XL_LOCK(&__global_locale);
+	ret = __setrunelocale(encoding, &__global_locale);
+	XL_UNLOCK(&__global_locale);
+	return ret;
+}
+#endif /* UNIFDEF_LEGACY_RUNE_APIS */
+
+__private_extern__ int
+__wrap_setrunelocale(const char *locale, locale_t loc)
 {
-	int ret = __setrunelocale(locale);
+	int ret = __setrunelocale(locale, loc);
 
 	if (ret != 0) {
 		errno = ret;