|
1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Name : c_locale_libc.cpp |
|
15 // Part of : libstdcpp |
|
16 // Adaptation layer to get locale functionality. |
|
17 // Version : |
|
18 // This material, including documentation and any related |
|
19 // computer programs, is protected by copyright controlled by |
|
20 // Nokia Corporation. All rights are reserved. Copying, |
|
21 // including reproducing, storing, adapting or translating, any |
|
22 // or all of this material requires the prior written consent of |
|
23 // Nokia Corporation. This material also contains confidential |
|
24 // information which may not be disclosed to others without the |
|
25 // prior written consent of Nokia Corporation. |
|
26 // |
|
27 |
|
28 |
|
29 |
|
30 //#include "stlport_prefix.h" |
|
31 #include <limits.h> |
|
32 #include <locale.h> |
|
33 #include <langinfo.h> |
|
34 #include <string.h> |
|
35 #include <stdlib.h> |
|
36 #include <wctype.h> |
|
37 #include "c_locale.h" |
|
38 #include "e32cmn.h" |
|
39 #include "e32std.h" |
|
40 |
|
41 #ifdef _MESSAGE_CATALOG_ |
|
42 #include <libintl.h> |
|
43 #endif |
|
44 |
|
45 #define LOCALE_SYSTEM_DEFAULT "C" |
|
46 #define MAX_NAME_LEN 30 |
|
47 |
|
48 #if (defined (__GNUC__) || defined (_KCC) || defined(__ICC)) && (!defined (__SYMBIAN32__)) |
|
49 typedef unsigned short int _Locale_mask_t; |
|
50 #else |
|
51 typedef unsigned int _Locale_mask_t; |
|
52 #endif |
|
53 |
|
54 typedef struct _Locale_ctype { |
|
55 char name[MAX_NAME_LEN]; |
|
56 _Locale_mask_t ctable[257]; |
|
57 } L_ctype_t; |
|
58 |
|
59 |
|
60 typedef struct _Locale_numeric { |
|
61 char name[MAX_NAME_LEN]; |
|
62 char decimal_point[4]; |
|
63 char thousands_sep[4]; |
|
64 char *grouping; |
|
65 } L_numeric_t; |
|
66 |
|
67 typedef struct _Locale_time { |
|
68 char name[MAX_NAME_LEN]; |
|
69 char *month[12]; |
|
70 char *abbrev_month[12]; |
|
71 char *dayofweek[7]; |
|
72 char *abbrev_dayofweek[7]; |
|
73 } L_time_t; |
|
74 |
|
75 typedef struct _Locale_collate { |
|
76 char name[MAX_NAME_LEN]; |
|
77 } L_collate_t; |
|
78 |
|
79 typedef struct _Locale_monetary { |
|
80 char name[MAX_NAME_LEN]; |
|
81 char decimal_point[4]; |
|
82 char thousands_sep[4]; |
|
83 char *grouping; |
|
84 char int_curr_symbol[5]; // 3+1+1 |
|
85 char curr_symbol[6]; |
|
86 char negative_sign[5]; |
|
87 char positive_sign[5]; |
|
88 int frac_digits; |
|
89 int int_frac_digits; |
|
90 } L_monetary_t; |
|
91 |
|
92 typedef struct _Locale_messages { |
|
93 char name[MAX_NAME_LEN]; |
|
94 char* domain; |
|
95 } L_messages_t; |
|
96 |
|
97 char* __getString(char* str) |
|
98 { |
|
99 int len = strlen(str)+1; |
|
100 char* temp = (char*) new char[len]; |
|
101 strcpy(temp, str); |
|
102 |
|
103 return temp; |
|
104 |
|
105 } |
|
106 |
|
107 size_t _Locale_strxfrm(L_collate_t* lcol, char* pDestStr, size_t destLen, |
|
108 const char* pSrcStr, size_t srcLen); |
|
109 |
|
110 size_t _Locale_strwxfrm(L_collate_t* lcol, wchar_t* pDestStr, size_t destLen, |
|
111 const wchar_t* pSrcStr, size_t srcLen); |
|
112 |
|
113 void _Locale_init() |
|
114 {} |
|
115 |
|
116 void _Locale_final() |
|
117 {} |
|
118 |
|
119 /* Gets the system locale name */ |
|
120 static const char* Locale_common_default( char* name) |
|
121 { |
|
122 if(name != NULL) |
|
123 { |
|
124 strcpy(name,LOCALE_SYSTEM_DEFAULT); |
|
125 } |
|
126 return LOCALE_SYSTEM_DEFAULT; |
|
127 } |
|
128 |
|
129 |
|
130 static char * Locale_extract_name ( const char *cname, char *into, int category ) |
|
131 { |
|
132 int i = 0; |
|
133 const char * end; |
|
134 const char* strstar = "*", *strnull = ""; |
|
135 if ( cname[0] != '/' ) |
|
136 { |
|
137 if (strcmp(cname,strnull) == 0) |
|
138 return strcpy(into, strstar); |
|
139 else |
|
140 return strcpy(into, cname); /* simple locale name */ |
|
141 } |
|
142 |
|
143 for ( i = 0; i <= category; i ++ ) { |
|
144 while ( *cname != '\0' && *cname != '/' ) |
|
145 cname++; |
|
146 if ( *cname == '\0' ) |
|
147 return into; |
|
148 cname++; |
|
149 } |
|
150 |
|
151 if ( *cname == '\0' ) |
|
152 return into; |
|
153 |
|
154 end = cname; |
|
155 while ( *end != '\0' && *end != '/' ) |
|
156 end++; |
|
157 strncpy ( into, cname, end - cname ); |
|
158 into [ end - cname ] = '\0'; |
|
159 return into; |
|
160 } |
|
161 |
|
162 _Locale_mask_t Get_locale_wchar_ctype(wint_t wc, _Locale_mask_t /*mask*/) |
|
163 { |
|
164 _Locale_mask_t ret = 0; |
|
165 |
|
166 if (iswcntrl(wc)) ret |= _Locale_CNTRL; |
|
167 if (iswupper(wc)) ret |= _Locale_UPPER; |
|
168 if (iswlower(wc)) ret |= _Locale_LOWER; |
|
169 if (iswdigit(wc)) ret |= _Locale_DIGIT; |
|
170 if (iswxdigit(wc)) ret |= _Locale_XDIGIT; |
|
171 if (iswpunct(wc)) ret |= _Locale_PUNCT; |
|
172 if (iswspace(wc)) ret |= _Locale_SPACE; |
|
173 if (iswprint(wc)) ret |= _Locale_PRINT; |
|
174 if (iswalpha(wc)) ret |= _Locale_ALPHA; |
|
175 return ret; |
|
176 } |
|
177 |
|
178 _Locale_mask_t Get_locale_char_ctype(unsigned char c) |
|
179 { |
|
180 _Locale_mask_t ret = 0; |
|
181 |
|
182 if (iscntrl(c)) ret |= _Locale_CNTRL; |
|
183 if (isupper(c)) ret |= _Locale_UPPER; |
|
184 if (islower(c)) ret |= _Locale_LOWER; |
|
185 if (isdigit(c)) ret |= _Locale_DIGIT; |
|
186 if (isxdigit(c)) ret |= _Locale_XDIGIT; |
|
187 if (ispunct(c)) ret |= _Locale_PUNCT; |
|
188 if (isspace(c)) ret |= _Locale_SPACE; |
|
189 if (isprint(c)) ret |= _Locale_PRINT; |
|
190 if (isalpha(c)) ret |= _Locale_ALPHA; |
|
191 |
|
192 return ret; |
|
193 } |
|
194 |
|
195 |
|
196 void* _Locale_ctype_create(const char * name, struct _Locale_name_hint* /*hint*/) |
|
197 { |
|
198 unsigned char buffer[256]; |
|
199 int i; |
|
200 _Locale_mask_t* ctable; |
|
201 |
|
202 L_ctype_t *plocCType = new (L_ctype_t); |
|
203 if (!plocCType) |
|
204 return NULL; |
|
205 |
|
206 strcpy(plocCType->name, name); |
|
207 char* ptemp = setlocale(LC_CTYPE, name); |
|
208 if (!ptemp) |
|
209 return NULL; |
|
210 |
|
211 ctable = plocCType->ctable; |
|
212 |
|
213 /* Partial implementation for ANSI code page, need to implement for DBCS code pages*/ |
|
214 |
|
215 /* Make table with all characters. */ |
|
216 for(i = 0; i < 256; i++) |
|
217 { |
|
218 buffer[i] = i; |
|
219 } |
|
220 for (i=0;i<256;i++) |
|
221 { |
|
222 ctable[i+1] = Get_locale_char_ctype(buffer[i]); |
|
223 } |
|
224 ctable[0] = 0; //EOF |
|
225 return plocCType; |
|
226 } |
|
227 |
|
228 void* _Locale_numeric_create(const char *name, struct _Locale_name_hint* /*hint*/) |
|
229 { |
|
230 L_numeric_t *plocNumeric = new (L_numeric_t); |
|
231 struct lconv *plconv; |
|
232 |
|
233 if (!plocNumeric) |
|
234 return NULL; |
|
235 |
|
236 strcpy(plocNumeric->name, name); |
|
237 char* ptemp = setlocale(LC_NUMERIC, name); |
|
238 if (!ptemp) |
|
239 return NULL; |
|
240 |
|
241 plconv = localeconv(); |
|
242 |
|
243 //copy locale numeric data to local structure |
|
244 plocNumeric->grouping = __getString(plconv->grouping); |
|
245 strcpy(plocNumeric->decimal_point, plconv->decimal_point); |
|
246 strcpy(plocNumeric->thousands_sep, plconv->thousands_sep); |
|
247 |
|
248 return plocNumeric; |
|
249 } |
|
250 |
|
251 void*_Locale_time_create(const char * name, struct _Locale_name_hint* /*hint*/) |
|
252 { |
|
253 L_time_t *plocTime = new(L_time_t); |
|
254 |
|
255 if (!plocTime ) |
|
256 return NULL; |
|
257 |
|
258 strcpy(plocTime ->name, name); |
|
259 char* ptemp = setlocale(LC_TIME, name); |
|
260 if (!ptemp) |
|
261 return NULL; |
|
262 |
|
263 int i; |
|
264 |
|
265 //Get all month names |
|
266 int index = (MON_1); |
|
267 for (i = 0;i<12;i++,index++) |
|
268 plocTime->month[i] = __getString(nl_langinfo(index)); |
|
269 |
|
270 //Get all abbrevated month names |
|
271 index = (ABMON_1); |
|
272 for (i = 0;i<12;i++,index++) |
|
273 plocTime->abbrev_month[i] = __getString(nl_langinfo(index)); |
|
274 |
|
275 //Get all weekday names |
|
276 index = (DAY_1); |
|
277 for (i = 0;i<7;i++,index++) |
|
278 plocTime->dayofweek[i] = __getString(nl_langinfo(index)); |
|
279 |
|
280 //Get all weekday names |
|
281 index = (ABDAY_1); |
|
282 for (i = 0;i<7;i++,index++) |
|
283 plocTime->abbrev_dayofweek[i] = __getString(nl_langinfo(index)); |
|
284 |
|
285 return plocTime; |
|
286 } |
|
287 |
|
288 void* _Locale_collate_create(const char *name, struct _Locale_name_hint* /*hint*/) |
|
289 { |
|
290 L_collate_t *plocCollate = new(L_collate_t); |
|
291 |
|
292 if (!plocCollate) |
|
293 return NULL; |
|
294 |
|
295 char* ptemp = setlocale(LC_COLLATE, name); |
|
296 if (!ptemp) |
|
297 return NULL; |
|
298 |
|
299 strcpy(plocCollate->name, name); |
|
300 return plocCollate; |
|
301 } |
|
302 |
|
303 void* _Locale_monetary_create(const char * name, struct _Locale_name_hint* /*hint*/) |
|
304 { |
|
305 L_monetary_t *plocMonetary = new(L_monetary_t); |
|
306 struct lconv *plconv; |
|
307 |
|
308 if (!plocMonetary) |
|
309 return NULL; |
|
310 |
|
311 strcpy(plocMonetary->name, name); |
|
312 char* ptemp = setlocale(LC_MONETARY, name); |
|
313 if (!ptemp) |
|
314 return NULL; |
|
315 |
|
316 plconv = localeconv(); |
|
317 |
|
318 strcpy(plocMonetary->decimal_point,plconv->mon_decimal_point); |
|
319 strcpy(plocMonetary->thousands_sep, plconv->mon_thousands_sep); |
|
320 strcpy(plocMonetary->int_curr_symbol, plconv->int_curr_symbol); |
|
321 strcpy(plocMonetary->curr_symbol, plconv->currency_symbol); |
|
322 strcpy(plocMonetary->negative_sign, plconv->negative_sign); |
|
323 strcpy(plocMonetary->positive_sign, plconv->positive_sign); |
|
324 plocMonetary->grouping = __getString(plconv->mon_grouping); |
|
325 plocMonetary->frac_digits = plconv->frac_digits; |
|
326 plocMonetary->int_frac_digits = plconv->int_frac_digits; |
|
327 |
|
328 return plocMonetary; |
|
329 } |
|
330 |
|
331 void* _Locale_messages_create(const char *name, struct _Locale_name_hint* /*hint*/) |
|
332 { |
|
333 L_messages_t *plocMessages= new(L_messages_t); |
|
334 |
|
335 if (!plocMessages) |
|
336 return NULL; |
|
337 |
|
338 char* ptemp = setlocale(LC_MESSAGES, name); |
|
339 if (!ptemp) |
|
340 return NULL; |
|
341 |
|
342 strcpy(plocMessages->name, name); |
|
343 return plocMessages; |
|
344 } |
|
345 |
|
346 const char* _Locale_ctype_default(char* buff) |
|
347 { |
|
348 return Locale_common_default(buff); |
|
349 } |
|
350 |
|
351 const char* _Locale_numeric_default(char *buff) |
|
352 { |
|
353 return Locale_common_default(buff); |
|
354 } |
|
355 |
|
356 const char* _Locale_time_default(char* buff) |
|
357 { |
|
358 return Locale_common_default(buff); |
|
359 } |
|
360 |
|
361 const char* _Locale_collate_default(char* buff) |
|
362 { |
|
363 return Locale_common_default(buff); |
|
364 } |
|
365 |
|
366 const char* _Locale_monetary_default(char* buff) |
|
367 { |
|
368 return Locale_common_default(buff); |
|
369 } |
|
370 |
|
371 const char* _Locale_messages_default(char* buff) |
|
372 { |
|
373 return Locale_common_default(buff); |
|
374 } |
|
375 |
|
376 char const* _Locale_ctype_name(const void* cat, char* buff) |
|
377 { |
|
378 strcpy(buff, ((L_ctype_t*)cat)->name); |
|
379 return buff; |
|
380 } |
|
381 |
|
382 char const* _Locale_numeric_name(const void* cat, char* buff) |
|
383 { |
|
384 strcpy(buff, ((L_numeric_t*)cat)->name); |
|
385 return buff; |
|
386 } |
|
387 |
|
388 char const* _Locale_time_name(const void* cat, char* buff) |
|
389 { |
|
390 strcpy(buff, ((L_time_t*)cat)->name); |
|
391 return buff; |
|
392 } |
|
393 |
|
394 char const* _Locale_collate_name(const void* cat, char* buff) |
|
395 { |
|
396 strcpy(buff, ((L_collate_t*)cat)->name); |
|
397 return buff; |
|
398 } |
|
399 |
|
400 char const* _Locale_monetary_name(const void* cat, char* buff) |
|
401 { |
|
402 strcpy(buff, ((L_monetary_t*)cat)->name); |
|
403 return buff; |
|
404 } |
|
405 |
|
406 char const* _Locale_messages_name(const void* cat, char* buff) |
|
407 { |
|
408 strcpy(buff, ((L_messages_t*)cat)->name); |
|
409 return buff; |
|
410 } |
|
411 |
|
412 void _Locale_ctype_destroy(void* locale) |
|
413 { |
|
414 delete((L_ctype_t*)locale); |
|
415 } |
|
416 |
|
417 void _Locale_numeric_destroy(void* locale) |
|
418 { |
|
419 delete ((L_numeric_t*)locale)->grouping; |
|
420 delete (L_numeric_t*)locale; |
|
421 } |
|
422 |
|
423 void _Locale_time_destroy(void* locale) |
|
424 { |
|
425 int i; //count |
|
426 L_time_t* plocTime =(L_time_t*)locale; |
|
427 |
|
428 //delete months |
|
429 for (i = 0;i<12;i++) |
|
430 delete (plocTime->month[i]); |
|
431 |
|
432 //delete abbrevated months |
|
433 for (i = 0;i<12;i++) |
|
434 delete (plocTime->abbrev_month[i]); |
|
435 |
|
436 //delete week day |
|
437 for (i = 0;i<7;i++) |
|
438 delete (plocTime->dayofweek[i]); |
|
439 |
|
440 //delete abbrevated week day |
|
441 for (i = 0;i<7;i++) |
|
442 delete (plocTime->abbrev_dayofweek[i]); |
|
443 |
|
444 delete((L_time_t*)locale); |
|
445 } |
|
446 |
|
447 void _Locale_collate_destroy(void* locale) |
|
448 { |
|
449 delete((L_collate_t*)locale); |
|
450 } |
|
451 |
|
452 void _Locale_monetary_destroy(void* locale) |
|
453 { |
|
454 delete ((L_monetary_t*)locale)->grouping; |
|
455 delete((L_monetary_t*)locale); |
|
456 } |
|
457 |
|
458 void _Locale_messages_destroy(void* locale) |
|
459 { |
|
460 delete((L_messages_t*)locale); |
|
461 } |
|
462 |
|
463 char const* _Locale_extract_ctype_name(const char* cname, char* buf, struct _Locale_name_hint* /*__hint*/) |
|
464 { |
|
465 return Locale_extract_name(cname, buf, LC_CTYPE); |
|
466 } |
|
467 |
|
468 char const* _Locale_extract_numeric_name(const char* cname, char* buf, struct _Locale_name_hint* /*__hint*/) |
|
469 { |
|
470 return Locale_extract_name(cname, buf, LC_NUMERIC); |
|
471 } |
|
472 |
|
473 char const* _Locale_extract_time_name(const char* cname, char* buf, struct _Locale_name_hint* /*__hint*/) |
|
474 { |
|
475 return Locale_extract_name(cname, buf, LC_TIME); |
|
476 } |
|
477 |
|
478 char const* _Locale_extract_collate_name(const char* cname, char* buf, struct _Locale_name_hint* /*__hint*/) |
|
479 { |
|
480 return Locale_extract_name(cname, buf, LC_COLLATE); |
|
481 } |
|
482 |
|
483 char const* _Locale_extract_monetary_name(const char* cname, char* buf, struct _Locale_name_hint* /*__hint*/) |
|
484 { |
|
485 return Locale_extract_name(cname, buf, LC_MONETARY); |
|
486 } |
|
487 |
|
488 char const* _Locale_extract_messages_name(const char* cname, char* buf, struct _Locale_name_hint* /*__hint*/) |
|
489 { |
|
490 return Locale_extract_name(cname, buf, LC_MESSAGES); |
|
491 } |
|
492 |
|
493 const char* _Locale_compose_name(char* buf, |
|
494 const char* ctype, const char* numeric, |
|
495 const char* time, const char* collate, |
|
496 const char* monetary, const char* messages, |
|
497 const char* /*default_name*/) |
|
498 { |
|
499 |
|
500 if ( !strcmp ( ctype, numeric ) && |
|
501 !strcmp ( ctype, time ) && |
|
502 !strcmp ( ctype, collate ) && |
|
503 !strcmp ( ctype, monetary ) && |
|
504 !strcmp ( ctype, messages ) ) |
|
505 return strcpy ( buf, ctype ); |
|
506 |
|
507 strcpy ( buf, "/" ); |
|
508 strcat ( buf, ctype ); |
|
509 |
|
510 strcat ( buf, "/" ); |
|
511 strcat ( buf, numeric ); |
|
512 |
|
513 strcat ( buf, "/" ); |
|
514 strcat ( buf, time ); |
|
515 |
|
516 strcat ( buf, "/" ); |
|
517 strcat ( buf, collate ); |
|
518 |
|
519 strcat ( buf, "/" ); |
|
520 strcat ( buf, monetary ); |
|
521 |
|
522 strcat ( buf, "/" ); |
|
523 strcat ( buf, messages ); |
|
524 |
|
525 return buf; |
|
526 } |
|
527 |
|
528 struct _Locale_name_hint* _Locale_get_ctype_hint(struct _Locale_ctype* /*ctype*/) |
|
529 { return 0; } |
|
530 struct _Locale_name_hint* _Locale_get_numeric_hint(struct _Locale_numeric* /*numeric*/) |
|
531 { return 0; } |
|
532 struct _Locale_name_hint* _Locale_get_time_hint(struct _Locale_time* /*time*/) |
|
533 { return 0; } |
|
534 struct _Locale_name_hint* _Locale_get_collate_hint(struct _Locale_collate* /*collate*/) |
|
535 { return 0; } |
|
536 struct _Locale_name_hint* _Locale_get_monetary_hint(struct _Locale_monetary* /*monetary*/) |
|
537 { return 0; } |
|
538 struct _Locale_name_hint* _Locale_get_messages_hint(struct _Locale_messages* /*messages*/) |
|
539 { return 0; } |
|
540 |
|
541 /* ctype */ |
|
542 |
|
543 const _Locale_mask_t* _Locale_ctype_table(struct _Locale_ctype* lctype) |
|
544 { |
|
545 return lctype->ctable; |
|
546 } |
|
547 |
|
548 int _Locale_toupper(struct _Locale_ctype* /*lctype*/, int c) |
|
549 { |
|
550 return toupper(c); |
|
551 } |
|
552 |
|
553 int _Locale_tolower(L_ctype_t* /*lctype*/, int c) |
|
554 { |
|
555 return tolower(c); |
|
556 } |
|
557 |
|
558 _Locale_mask_t _Locale_wchar_ctype(L_ctype_t* /*lctype*/, wint_t c, _Locale_mask_t which_bits) |
|
559 { |
|
560 _Locale_mask_t mask = Get_locale_wchar_ctype(c,which_bits); |
|
561 return mask & which_bits; |
|
562 } |
|
563 |
|
564 wint_t _Locale_wchar_tolower(L_ctype_t* /*lctype*/, wint_t c) |
|
565 { |
|
566 return towlower(c); |
|
567 } |
|
568 |
|
569 wint_t _Locale_wchar_toupper(L_ctype_t* /*lctype*/, wint_t c) |
|
570 { |
|
571 return towupper(c); |
|
572 } |
|
573 |
|
574 int _Locale_mb_cur_max (L_ctype_t * /*lctype*/) |
|
575 { |
|
576 return MB_CUR_MAX; |
|
577 } |
|
578 |
|
579 int _Locale_mb_cur_min (L_ctype_t * /*lctype*/) |
|
580 { |
|
581 return 1; |
|
582 } |
|
583 |
|
584 int _Locale_is_stateless (L_ctype_t * /*lctype*/) |
|
585 { |
|
586 return (MB_CUR_MAX == 1)?1:0; |
|
587 } |
|
588 |
|
589 wint_t _Locale_btowc(L_ctype_t * lctype, int c) |
|
590 { |
|
591 setlocale(LC_CTYPE, lctype->name); |
|
592 return btowc(c); |
|
593 } |
|
594 |
|
595 int _Locale_wctob(L_ctype_t * lctype, wint_t wc) |
|
596 { |
|
597 setlocale(LC_CTYPE, lctype->name); |
|
598 return wctob(wc); |
|
599 } |
|
600 |
|
601 size_t _Locale_mbtowc(struct _Locale_ctype *lctype, |
|
602 wchar_t *to, /* size_t n1 - removed in 5.x? */ |
|
603 const char *from, size_t n, |
|
604 mbstate_t * /*shift_state*/) |
|
605 { |
|
606 setlocale(LC_CTYPE, lctype->name); |
|
607 return (size_t) mbtowc(to, from,n); |
|
608 } |
|
609 |
|
610 size_t _Locale_wctomb(L_ctype_t* lctype, |
|
611 char *to, size_t /*n*/, |
|
612 const wchar_t c, |
|
613 mbstate_t */*shift_state*/) |
|
614 { |
|
615 setlocale(LC_CTYPE, lctype->name); |
|
616 return (size_t) wctomb(to, c); |
|
617 } |
|
618 |
|
619 |
|
620 size_t _Locale_unshift(L_ctype_t * /*lctype*/, |
|
621 mbstate_t */*st*/, |
|
622 char *buff, size_t /*n*/, char ** next) |
|
623 { |
|
624 //Conversion is not required, because iconv will not do partial conversion. |
|
625 *next = buff; |
|
626 return 0; |
|
627 } |
|
628 |
|
629 /* Collate */ |
|
630 |
|
631 int _Locale_strcmp(L_collate_t* lcol, |
|
632 const char* pStr1, size_t len1, const char* pStr2, |
|
633 size_t len2) |
|
634 { |
|
635 |
|
636 char *ptempStr1 = NULL, *ptempStr2 = NULL; |
|
637 int tempLen1, tempLen2; |
|
638 |
|
639 tempLen1 = _Locale_strxfrm(lcol, NULL, 0, pStr1, len1); |
|
640 tempLen2 = _Locale_strxfrm(lcol, NULL, 0, pStr2, len2); |
|
641 ptempStr1 = (char*) new char[tempLen1+1]; |
|
642 ptempStr2 = (char*) new char[tempLen2+1]; |
|
643 int ret; |
|
644 int minN = tempLen1 < tempLen2 ? tempLen1 : tempLen2; |
|
645 setlocale(LC_COLLATE, lcol->name); |
|
646 _Locale_strxfrm(lcol, ptempStr1, tempLen1, pStr1, len1); |
|
647 _Locale_strxfrm(lcol, ptempStr2, tempLen2, pStr2, len2); |
|
648 ret = strncmp(ptempStr1, ptempStr2, minN); |
|
649 |
|
650 delete [] ptempStr1; |
|
651 delete [] ptempStr2; |
|
652 |
|
653 if (ret == 0) |
|
654 { |
|
655 if (len1 < len2) |
|
656 return -1; |
|
657 else if (len1 > len2) |
|
658 return 1; |
|
659 else |
|
660 return 0; |
|
661 } |
|
662 else |
|
663 return ret; |
|
664 |
|
665 } |
|
666 |
|
667 int _Locale_strwcmp(L_collate_t* lcol, |
|
668 const wchar_t* pStr1, size_t len1, |
|
669 const wchar_t* pStr2, size_t len2) |
|
670 { |
|
671 wchar_t *ptempStr1 = NULL, *ptempStr2 = NULL; |
|
672 int tempLen1,tempLen2; |
|
673 |
|
674 tempLen1 = _Locale_strwxfrm(lcol, NULL,0,pStr1,len1); |
|
675 tempLen2 = _Locale_strwxfrm(lcol, NULL,0,pStr2,len2); |
|
676 ptempStr1 = (wchar_t*) new wchar_t[tempLen1+1]; |
|
677 ptempStr2 = (wchar_t*) new wchar_t[tempLen2+1]; |
|
678 int ret; |
|
679 int minN = tempLen1 < tempLen2 ? tempLen1 : tempLen2; |
|
680 setlocale(LC_COLLATE, lcol->name); |
|
681 _Locale_strwxfrm(lcol, ptempStr1,tempLen1+1,pStr1,len1); |
|
682 _Locale_strwxfrm(lcol, ptempStr2,tempLen2+1,pStr2,len2); |
|
683 ret = wcsncmp(ptempStr1, ptempStr2, minN); |
|
684 |
|
685 delete [] ptempStr1; |
|
686 delete [] ptempStr2; |
|
687 |
|
688 if (ret == 0) |
|
689 { |
|
690 if (len1 < len2) |
|
691 return -1; |
|
692 else if (len1 > len2) |
|
693 return 1; |
|
694 else |
|
695 return 0; |
|
696 } |
|
697 else |
|
698 return ret; |
|
699 } |
|
700 |
|
701 size_t _Locale_strxfrm(L_collate_t* lcol, |
|
702 char* pDestStr, size_t destLen, |
|
703 const char* pSrcStr, size_t srcLen) |
|
704 { |
|
705 size_t n; |
|
706 setlocale(LC_COLLATE, lcol->name); |
|
707 |
|
708 char* ptemp = (char*) new char[srcLen+1]; |
|
709 if(ptemp == NULL) |
|
710 return 0; |
|
711 strncpy(ptemp, pSrcStr, srcLen); |
|
712 *(ptemp + srcLen) = 0; |
|
713 |
|
714 n = strxfrm(pDestStr, ptemp, destLen); |
|
715 |
|
716 delete []ptemp; |
|
717 |
|
718 if ((pDestStr == NULL) || (destLen ==0) ) |
|
719 return n; |
|
720 else if(n > destLen) |
|
721 return (size_t)-1; |
|
722 |
|
723 pDestStr[n] = 0; |
|
724 return n; |
|
725 } |
|
726 |
|
727 size_t _Locale_strwxfrm(L_collate_t* lcol, |
|
728 wchar_t* pDestStr, size_t destLen, |
|
729 const wchar_t* pSrcStr, size_t srcLen) |
|
730 { |
|
731 size_t n; |
|
732 setlocale(LC_COLLATE, lcol->name); |
|
733 wchar_t* ptemp = (wchar_t*) new wchar_t[srcLen+1]; |
|
734 if(ptemp == NULL) |
|
735 return 0; |
|
736 wcsncpy(ptemp, pSrcStr, srcLen); |
|
737 *(ptemp+srcLen) = 0; |
|
738 n = wcsxfrm(pDestStr, ptemp, destLen); |
|
739 delete []ptemp; |
|
740 if ((pDestStr == NULL) || (destLen ==0) ) |
|
741 return n; |
|
742 else if(n > destLen) |
|
743 return (size_t)-1; |
|
744 |
|
745 pDestStr[n] = 0; |
|
746 return n; |
|
747 } |
|
748 |
|
749 /* Numeric */ |
|
750 |
|
751 char _Locale_decimal_point(L_numeric_t* lnum) |
|
752 { |
|
753 return lnum->decimal_point[0]; |
|
754 } |
|
755 |
|
756 char _Locale_thousands_sep(L_numeric_t* lnum) |
|
757 { |
|
758 return lnum->thousands_sep[0]; |
|
759 } |
|
760 const char* _Locale_grouping(L_numeric_t*lnum) |
|
761 { |
|
762 return lnum->grouping; |
|
763 } |
|
764 |
|
765 const char * _Locale_true(L_numeric_t * /*lnum*/) |
|
766 { |
|
767 const char* __true_name="true"; //glib and NT doing the same |
|
768 return __true_name; |
|
769 } |
|
770 |
|
771 const char * _Locale_false(L_numeric_t * /*lnum*/) |
|
772 { |
|
773 const char* __false_name="false"; //glib and NT doing the same |
|
774 return __false_name; |
|
775 } |
|
776 |
|
777 |
|
778 /* Monetary */ |
|
779 |
|
780 const char* _Locale_int_curr_symbol(L_monetary_t * lmon) |
|
781 { |
|
782 return lmon->int_curr_symbol; |
|
783 } |
|
784 |
|
785 const char* _Locale_currency_symbol(L_monetary_t * lmon) |
|
786 { |
|
787 return lmon->curr_symbol; |
|
788 } |
|
789 |
|
790 char _Locale_mon_decimal_point(L_monetary_t * lmon) |
|
791 { |
|
792 return lmon->decimal_point[0]; |
|
793 } |
|
794 |
|
795 char _Locale_mon_thousands_sep(L_monetary_t * lmon) |
|
796 { |
|
797 return lmon->thousands_sep[0]; |
|
798 } |
|
799 |
|
800 const char* _Locale_mon_grouping(L_monetary_t * lmon) |
|
801 { |
|
802 return lmon->grouping; |
|
803 } |
|
804 |
|
805 const char* _Locale_positive_sign(L_monetary_t * lmon) |
|
806 { |
|
807 return lmon->positive_sign; |
|
808 } |
|
809 |
|
810 const char* _Locale_negative_sign(L_monetary_t * lmon) |
|
811 { |
|
812 return lmon->negative_sign; |
|
813 } |
|
814 |
|
815 char _Locale_int_frac_digits(L_monetary_t * lmon) |
|
816 { |
|
817 return lmon->int_frac_digits; |
|
818 } |
|
819 |
|
820 char _Locale_frac_digits(L_monetary_t * lmon) |
|
821 { |
|
822 return lmon->frac_digits; |
|
823 } |
|
824 |
|
825 int _Locale_p_cs_precedes(L_monetary_t * lmon) |
|
826 { |
|
827 struct lconv* plconv; |
|
828 setlocale(LC_MONETARY, lmon->name); |
|
829 plconv = localeconv(); |
|
830 return plconv->p_cs_precedes; |
|
831 } |
|
832 |
|
833 int _Locale_p_sep_by_space(L_monetary_t * lmon) |
|
834 { |
|
835 struct lconv* plconv; |
|
836 setlocale(LC_MONETARY, lmon->name); |
|
837 plconv = localeconv(); |
|
838 return plconv->p_sep_by_space; |
|
839 } |
|
840 |
|
841 int _Locale_p_sign_posn(L_monetary_t * lmon) |
|
842 { |
|
843 struct lconv* plconv; |
|
844 setlocale(LC_MONETARY, lmon->name); |
|
845 plconv = localeconv(); |
|
846 return plconv->p_sign_posn; |
|
847 } |
|
848 |
|
849 int _Locale_n_cs_precedes(L_monetary_t * lmon) |
|
850 { |
|
851 struct lconv* plconv; |
|
852 setlocale(LC_MONETARY, lmon->name); |
|
853 plconv = localeconv(); |
|
854 return plconv->n_cs_precedes; |
|
855 } |
|
856 |
|
857 int _Locale_n_sep_by_space(L_monetary_t * lmon) |
|
858 { |
|
859 struct lconv* plconv; |
|
860 setlocale(LC_MONETARY, lmon->name); |
|
861 plconv = localeconv(); |
|
862 return plconv->n_sep_by_space; |
|
863 } |
|
864 |
|
865 int _Locale_n_sign_posn(L_monetary_t * lmon) |
|
866 { |
|
867 struct lconv* plconv; |
|
868 setlocale(LC_MONETARY, lmon->name); |
|
869 plconv = localeconv(); |
|
870 return plconv->n_sign_posn; |
|
871 } |
|
872 |
|
873 /* Time */ |
|
874 const char * _Locale_full_monthname(L_time_t * ltime, int month) |
|
875 { |
|
876 return ltime->month[month]; |
|
877 } |
|
878 |
|
879 const char * _Locale_abbrev_monthname(L_time_t * ltime, int month) |
|
880 { |
|
881 return ltime->abbrev_month[month]; |
|
882 } |
|
883 |
|
884 const char * _Locale_full_dayofweek(L_time_t * ltime, int day) |
|
885 { |
|
886 return ltime->dayofweek[day]; |
|
887 } |
|
888 |
|
889 const char * _Locale_abbrev_dayofweek(L_time_t * ltime, int day) |
|
890 { |
|
891 return ltime->abbrev_dayofweek[day]; |
|
892 } |
|
893 |
|
894 const char* _Locale_d_t_fmt(L_time_t* ltime) |
|
895 { |
|
896 setlocale(LC_TIME, ltime->name); |
|
897 return nl_langinfo(D_T_FMT); |
|
898 } |
|
899 |
|
900 const char* _Locale_d_fmt(L_time_t* ltime) |
|
901 { |
|
902 setlocale(LC_TIME, ltime->name); |
|
903 return nl_langinfo(D_FMT); |
|
904 } |
|
905 |
|
906 const char* _Locale_t_fmt(L_time_t* ltime) |
|
907 { |
|
908 setlocale(LC_TIME, ltime->name); |
|
909 return nl_langinfo(T_FMT); |
|
910 } |
|
911 |
|
912 const char* _Locale_long_d_t_fmt(L_time_t* ltime) |
|
913 { |
|
914 setlocale(LC_TIME, ltime->name); |
|
915 return nl_langinfo(D_T_FMT); |
|
916 } |
|
917 |
|
918 const char* _Locale_long_d_fmt(L_time_t* ltime) |
|
919 { |
|
920 setlocale(LC_TIME, ltime->name); |
|
921 return nl_langinfo(D_FMT); |
|
922 } |
|
923 |
|
924 const char* _Locale_am_str(L_time_t* ltime) |
|
925 { |
|
926 setlocale(LC_TIME, ltime->name); |
|
927 return nl_langinfo(AM_STR); |
|
928 } |
|
929 |
|
930 const char* _Locale_pm_str(L_time_t* ltime) |
|
931 { |
|
932 setlocale(LC_TIME, ltime->name); |
|
933 return nl_langinfo(PM_STR); |
|
934 } |
|
935 |
|
936 const char* _Locale_t_fmt_ampm(L_time_t* ltime) |
|
937 { |
|
938 setlocale(LC_TIME, ltime->name); |
|
939 return nl_langinfo(T_FMT_AMPM); |
|
940 } |
|
941 |
|
942 /* Messages */ |
|
943 |
|
944 nl_catd_type _Locale_catopen(struct _Locale_messages* lmessage, const char* catalogName) |
|
945 { |
|
946 lmessage->domain = __getString((char*)catalogName); |
|
947 return 1; |
|
948 } |
|
949 |
|
950 void _Locale_catclose(struct _Locale_messages* lmessage, nl_catd_type /*catalog_desc*/) |
|
951 { |
|
952 delete(lmessage->domain); |
|
953 lmessage->domain = NULL; |
|
954 } |
|
955 |
|
956 const char* _Locale_catgets(struct _Locale_messages* lmessage, nl_catd_type /*catalog_desc*/, |
|
957 int /*set*/, int /*message*/, |
|
958 const char * /*dfault*/) |
|
959 { |
|
960 char* locale = setlocale(LC_ALL, lmessage->name); |
|
961 #ifdef _MESSAGE_CATALOG_ |
|
962 textdomain(lmessage->domain); |
|
963 |
|
964 return gettext(dfault); |
|
965 #else |
|
966 return NULL; |
|
967 #endif |
|
968 |
|
969 } |
|
970 |