src/third_party/libc++/trunk/src/support/solaris/xlocale.c

   1
   2 #ifdef __sun__
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <dlfcn.h>
   8 #include <locale.h>
   9 #include <limits.h>
  10 #include <assert.h>
  11 #include <sys/localedef.h>
  12 #include "xlocale.h"
  13
  14 static _LC_locale_t *__C_locale;
  15
  16 #define FIX_LOCALE(l) l = (l == 0) ? __C_locale : l
  17
  18 #include "mbsnrtowcs.inc"
  19 #include "wcsnrtombs.inc"
  20
  21 size_t __mb_cur_max(locale_t __l) {
  22   FIX_LOCALE(__l);
  23   return (__l->lc_ctype->cmapp->cm_mb_cur_max);
  24 }
  25
  26 wint_t btowc_l(int __c, locale_t __l) {
  27   FIX_LOCALE(__l);
  28   return __l->lc_ctype->cmapp->core.user_api->btowc(__l->lc_ctype->cmapp, __c);
  29 }
  30
  31 int wctob_l(wint_t __c, locale_t __l) {
  32   FIX_LOCALE(__l);
  33   return __l->lc_ctype->cmapp->core.user_api->wctob(__l->lc_ctype->cmapp, __c);
  34 }
  35
  36 size_t wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l) {
  37   FIX_LOCALE(__l);
  38   return __l->lc_ctype->cmapp->core.user_api->wcrtomb(__l->lc_ctype->cmapp,
  39       __s, __wc, __ps);
  40 }
  41
  42 size_t mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
  43                  mbstate_t *__ps, locale_t __l) {
  44   FIX_LOCALE(__l);
  45   return __l->lc_ctype->cmapp->core.user_api->mbrtowc(__l->lc_ctype->cmapp,
  46       __pwc, __s, __n, __ps);
  47 }
  48
  49 int mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l) {
  50   FIX_LOCALE(__l);
  51   return __l->lc_ctype->cmapp->core.user_api->mbtowc(__l->lc_ctype->cmapp,
  52       __pwc, __pmb, __max);
  53 }
  54
  55 size_t mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l) {
  56   FIX_LOCALE(__l);
  57   return __l->lc_ctype->cmapp->core.user_api->mbrlen(__l->lc_ctype->cmapp, __s,
  58     __n, __ps);
  59 }
  60
  61 struct lconv *localeconv_l(locale_t __l) {
  62   FIX_LOCALE(__l);
  63   return __l->core.user_api->localeconv(__l);
  64 }
  65
  66 size_t mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
  67                    mbstate_t *__ps, locale_t __l) {
  68   FIX_LOCALE(__l);
  69   return __l->lc_ctype->cmapp->core.user_api->mbsrtowcs(__l->lc_ctype->cmapp,
  70       __dest, __src, __len, __ps);
  71 }
  72
  73 int wcscoll_l(const wchar_t *__s1, const wchar_t *__s2, locale_t __l) {
  74   FIX_LOCALE(__l);
  75   return __l->lc_collate->core.user_api->wcscoll(__l->lc_collate,
  76       __s1, __s2);
  77 }
  78
  79 int strcoll_l(const char *__s1, const char *__s2, locale_t __l) {
  80   FIX_LOCALE(__l);
  81   return __l->lc_collate->core.user_api->strcoll(__l->lc_collate,
  82       __s1, __s2);
  83 }
  84
  85 size_t strxfrm_l(char *__s1, const char *__s2, size_t __n, locale_t __l) {
  86   FIX_LOCALE(__l);
  87   return __l->lc_collate->core.user_api->strxfrm(__l->lc_collate,
  88       __s1, __s2, __n);
  89 }
  90 size_t strftime_l(char *__s, size_t __size, const char *__fmt, const struct tm
  91     *__tm, locale_t __l) {
  92   FIX_LOCALE(__l);
  93   return __l->lc_time->core.user_api->strftime(__l->lc_time,
  94       __s, __size, __fmt, __tm);
  95 }
  96
  97 size_t wcsxfrm_l(wchar_t *__ws1, const wchar_t *__ws2, size_t __n,
  98     locale_t __l) {
  99   FIX_LOCALE(__l);
 100   return __l->lc_collate->core.user_api->wcsxfrm(__l->lc_collate,
 101       __ws1, __ws2, __n);
 102 }
 103
 104 #define LOCALE_ISCTYPE(ctype, m) \
 105   int is##ctype##_l(int __c, locale_t __l) { \
 106     if ((__c < 0) || (__c > 255)) return 0;\
 107     FIX_LOCALE(__l);\
 108     return __l->lc_ctype->mask[__c] & m;\
 109   }\
 110   int isw##ctype##_l(wchar_t __c, locale_t __l) { \
 111     FIX_LOCALE(__l);\
 112     return __l->lc_ctype->core.user_api->iswctype(__l->lc_ctype, __c, m);\
 113   }
 114
 115 LOCALE_ISCTYPE(alnum, _ISALNUM)
 116 LOCALE_ISCTYPE(alpha, _ISALPHA)
 117 LOCALE_ISCTYPE(blank, _ISALPHA)
 118 LOCALE_ISCTYPE(cntrl, _ISCNTRL)
 119 LOCALE_ISCTYPE(digit, _ISDIGIT)
 120 LOCALE_ISCTYPE(graph, _ISGRAPH)
 121 LOCALE_ISCTYPE(lower, _ISLOWER)
 122 LOCALE_ISCTYPE(print, _ISPRINT)
 123 LOCALE_ISCTYPE(punct, _ISPUNCT)
 124 LOCALE_ISCTYPE(space, _ISSPACE)
 125 LOCALE_ISCTYPE(upper, _ISUPPER)
 126 LOCALE_ISCTYPE(xdigit, _ISXDIGIT)
 127
 128 int iswctype_l(wint_t __c, wctype_t __m, locale_t __l) {
 129     FIX_LOCALE(__l);\
 130     return __l->lc_ctype->core.user_api->iswctype(__l->lc_ctype, __c, __m);\
 131 }
 132
 133 int toupper_l(int __c, locale_t __l) {
 134   FIX_LOCALE(__l);
 135     if ((__c < 0) || (__c > __l->lc_ctype->max_upper)) return __c;
 136   return __l->lc_ctype->upper[__c];
 137 }
 138 int tolower_l(int __c, locale_t __l) {
 139   FIX_LOCALE(__l);
 140   if ((__c < 0) || (__c > __l->lc_ctype->max_lower)) return __c;
 141   return __l->lc_ctype->lower[__c];
 142 }
 143 wint_t towupper_l(wint_t __c, locale_t __l) {
 144   FIX_LOCALE(__l);
 145   return __l->lc_ctype->core.user_api->towupper(__l->lc_ctype, __c);
 146 }
 147 wint_t towlower_l(wint_t __c, locale_t __l) {
 148   FIX_LOCALE(__l);
 149   return __l->lc_ctype->core.user_api->towlower(__l->lc_ctype, __c);
 150 }
 151
 152 // FIXME: This disregards the locale, which is Very Wrong
 153 #define vsnprintf_l(__s, __n, __l, __format, __va)  \
 154     vsnprintf(__s, __n, __format, __va)
 155
 156 int sprintf_l(char *__s, locale_t __l, const char *__format, ...) {
 157   va_list __va;
 158   va_start(__va, __format);
 159   int __res = vsnprintf_l(__s, SIZE_MAX, __l, __format, __va);
 160   va_end(__va);
 161   return __res;
 162 }
 163
 164 int snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...)
 165 {
 166   va_list __va;
 167   va_start(__va, __format);
 168   int __res = vsnprintf_l(__s, __n , __l, __format, __va);
 169   va_end(__va);
 170   return __res;
 171 }
 172
 173 int asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
 174   va_list __va;
 175   va_start(__va, __format);
 176   // FIXME:
 177   int __res = vasprintf(__s, __format, __va);
 178   va_end(__va);
 179   return __res;
 180 }
 181
 182 int sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
 183   va_list __va;
 184   va_start(__va, __format);
 185   // FIXME:
 186   int __res = vsscanf(__s, __format, __va);
 187   va_end(__va);
 188   return __res;
 189 }
 190
 191 locale_t newlocale(int mask, const char *locale, locale_t base) {
 192
 193   if ((locale == NULL) || (locale[0] == '\0') ||
 194       ((locale[0] == 'C') && (locale[1] == '\0')))
 195   {
 196     return __C_locale;
 197   }
 198
 199   // Solaris locales are shared libraries that contain
 200   char *path;
 201 #ifdef __LP64
 202   asprintf(&path, "/usr/lib/locale/%1$s/amd64/%1$s.so.3", locale);
 203 #else
 204   asprintf(&path, "/usr/lib/locale/%1$s/%1$s.so.3", locale);
 205 #endif
 206   void *handle = dlopen(path, RTLD_LOCAL | RTLD_NOW);
 207   free(path);
 208   if (!handle)
 209     return 0;
 210   _LC_locale_t *(*init)() = dlsym(handle, "instantiate");
 211   if (!init)
 212     return 0;
 213   _LC_locale_t  *p = init();
 214   if (!p)
 215     return 0;
 216
 217   if (!base)
 218     base = __C_locale;
 219
 220   locale_t ret = calloc(1, sizeof(struct _LC_locale_t));
 221   memcpy(ret, p, sizeof (_LC_locale_t));
 222   ret->lc_collate = (mask & LC_COLLATE_MASK) ? p->lc_collate : base->lc_collate;
 223   ret->lc_ctype = (mask & LC_CTYPE_MASK) ? p->lc_ctype : base->lc_ctype;
 224   ret->lc_messages = (mask & LC_MESSAGES_MASK) ? p->lc_messages : base->lc_messages;
 225   ret->lc_monetary = (mask & LC_MONETARY_MASK) ? p->lc_monetary : base->lc_monetary;
 226   ret->lc_time = (mask & LC_TIME_MASK) ? p->lc_time : base->lc_time;
 227   return ret;
 228 }
 229
 230 void freelocale(locale_t loc)
 231 {
 232   if (loc != __C_locale)
 233     free(loc);
 234 }
 235
 236 __attribute__((constructor))
 237 static void setupCLocale(void) {
 238   // The default initial locale is the C locale.  This is a statically
 239   // allocated locale inside libc.  At program start, __lc_locale will point to
 240   // this.  We need to grab a copy because it's not a public symbol.  If we had
 241   // access to the source code for libc, then we'd just use it directly...
 242   assert('C' == setlocale(LC_ALL, 0)[0]);
 243   __C_locale = __lc_locale;
 244 }
 245 #endif