Libc-1082.50.1.tar.gz

[apple/libc.git] / locale / FreeBSD / setrunelocale.c

diff --git a/locale/FreeBSD/setrunelocale.c b/locale/FreeBSD/setrunelocale.c
index bf2b6d95b3139866791a421f92b4696dab64a2ff..fbb2275349c51696a8fe816746f5cc18bed80731 100644 (file)
--- a/locale/FreeBSD/setrunelocale.c
+++ b/locale/FreeBSD/setrunelocale.c
@@ -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 <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>
 #include <runetype.h>
 #include <errno.h>
 #include <limits.h>


@@ -45,67 +47,60 @@ __FBSDID("$FreeBSD: src/lib/libc/locale/setrunelocale.c,v 1.51 2008/01/23 03:05:
 #include "mblocal.h"
 #include "setlocale.h"
 
 #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];
 {
        FILE *fp;
        char name[PATH_MAX];

+       struct __xlocale_st_runelocale *xrl;

        _RuneLocale *rl;
        int saverr, ret;
        _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) {
 
        /*
         * 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.
         */
                return (0);
        }
 
        /*
         * If the locale name is the same as our cache, use the cache.
         */

+       LOCK(cache_lock);

        if (CachedRuneLocale != NULL &&
        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);
        }
                return (0);
        }

+       UNLOCK(cache_lock);

 
        /*
         * Slurp the locale file into the cache.
 
        /*
         * 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 ((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);
 
                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;
+       xrl->__mbrtowc = NULL;
+       xrl->__mbsinit = NULL;
+       xrl->__mbsnrtowcs = __mbsnrtowcs_std;
+       xrl->__wcrtomb = NULL;
+       xrl->__wcsnrtombs = __wcsnrtombs_std;

 
 

-       __mbrtowc = NULL;
-       __mbsinit = NULL;
-       __mbsnrtowcs = __mbsnrtowcs_std;
-       __wcrtomb = NULL;
-       __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;
        rl->__sputrune = NULL;
        rl->__sgetrune = NULL;

+#endif /* UNIFDEF_LEGACY_RUNE_APIS */
+

        if (strcmp(rl->__encoding, "NONE") == 0)
        if (strcmp(rl->__encoding, "NONE") == 0)

-               ret = _none_init(rl);
+               ret = _none_init(xrl);

        else if (strcmp(rl->__encoding, "ASCII") == 0)
        else if (strcmp(rl->__encoding, "ASCII") == 0)

-               ret = _ascii_init(rl);
+               ret = _ascii_init(xrl);

        else if (strcmp(rl->__encoding, "UTF-8") == 0)
        else if (strcmp(rl->__encoding, "UTF-8") == 0)

-               ret = _UTF8_init(rl);
+               ret = _UTF8_init(xrl);

        else if (strcmp(rl->__encoding, "EUC") == 0)
        else if (strcmp(rl->__encoding, "EUC") == 0)

-               ret = _EUC_init(rl);
+               ret = _EUC_init(xrl);

        else if (strcmp(rl->__encoding, "GB18030") == 0)
        else if (strcmp(rl->__encoding, "GB18030") == 0)

-               ret = _GB18030_init(rl);
+               ret = _GB18030_init(xrl);

        else if (strcmp(rl->__encoding, "GB2312") == 0)
        else if (strcmp(rl->__encoding, "GB2312") == 0)

-               ret = _GB2312_init(rl);
+               ret = _GB2312_init(xrl);

        else if (strcmp(rl->__encoding, "GBK") == 0)
        else if (strcmp(rl->__encoding, "GBK") == 0)

-               ret = _GBK_init(rl);
+               ret = _GBK_init(xrl);

        else if (strcmp(rl->__encoding, "BIG5") == 0)
        else if (strcmp(rl->__encoding, "BIG5") == 0)

-               ret = _BIG5_init(rl);
+               ret = _BIG5_init(xrl);

        else if (strcmp(rl->__encoding, "MSKanji") == 0)
        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) {
        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);
 }
 
 
        return (ret);
 }
 

+#ifdef UNIFDEF_LEGACY_RUNE_APIS

 int
 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;
 
        if (ret != 0) {
                errno = ret;