← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/lib/libcxx/support/solaris/xlocale.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/lib/libcxx/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