The Tor Browser / file comparison

comparison: intl/icu/source/common/locid.cpp

intl/icu/source/common/locid.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:5b4f4ff2b433
1 /*
2 **********************************************************************
3 * Copyright (C) 1997-2012, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 **********************************************************************
6 *
7 * File locid.cpp
8 *
9 * Created by: Richard Gillam
10 *
11 * Modification History:
12 *
13 * Date Name Description
14 * 02/11/97 aliu Changed gLocPath to fgDataDirectory and added
15 * methods to get and set it.
16 * 04/02/97 aliu Made operator!= inline; fixed return value
17 * of getName().
18 * 04/15/97 aliu Cleanup for AIX/Win32.
19 * 04/24/97 aliu Numerous changes per code review.
20 * 08/18/98 stephen Changed getDisplayName()
21 * Added SIMPLIFIED_CHINESE, TRADITIONAL_CHINESE
22 * Added getISOCountries(), getISOLanguages(),
23 * getLanguagesForCountry()
24 * 03/16/99 bertrand rehaul.
25 * 07/21/99 stephen Added U_CFUNC setDefault
26 * 11/09/99 weiv Added const char * getName() const;
27 * 04/12/00 srl removing unicodestring api's and cached hash code
28 * 08/10/01 grhoten Change the static Locales to accessor functions
29 ******************************************************************************
30 */
31
32
33 #include "unicode/locid.h"
34 #include "unicode/uloc.h"
35 #include "putilimp.h"
36 #include "mutex.h"
37 #include "umutex.h"
38 #include "uassert.h"
39 #include "cmemory.h"
40 #include "cstring.h"
41 #include "uhash.h"
42 #include "ucln_cmn.h"
43 #include "ustr_imp.h"
44
45 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
46
47 U_CDECL_BEGIN
48 static UBool U_CALLCONV locale_cleanup(void);
49 U_CDECL_END
50
51 U_NAMESPACE_BEGIN
52
53 static Locale *gLocaleCache = NULL;
54
55 // gDefaultLocaleMutex protects all access to gDefaultLocalesHashT and gDefaultLocale.
56 static UMutex gDefaultLocaleMutex = U_MUTEX_INITIALIZER;
57 static UHashtable *gDefaultLocalesHashT = NULL;
58 static Locale *gDefaultLocale = NULL;
59
60 U_NAMESPACE_END
61
62 typedef enum ELocalePos {
63 eENGLISH,
64 eFRENCH,
65 eGERMAN,
66 eITALIAN,
67 eJAPANESE,
68 eKOREAN,
69 eCHINESE,
70
71 eFRANCE,
72 eGERMANY,
73 eITALY,
74 eJAPAN,
75 eKOREA,
76 eCHINA, /* Alias for PRC */
77 eTAIWAN,
78 eUK,
79 eUS,
80 eCANADA,
81 eCANADA_FRENCH,
82 eROOT,
83
84
85 //eDEFAULT,
86 eMAX_LOCALES
87 } ELocalePos;
88
89 U_CFUNC int32_t locale_getKeywords(const char *localeID,
90 char prev,
91 char *keywords, int32_t keywordCapacity,
92 char *values, int32_t valuesCapacity, int32_t *valLen,
93 UBool valuesToo,
94 UErrorCode *status);
95
96 U_CDECL_BEGIN
97 //
98 // Deleter function for Locales owned by the default Locale hash table/
99 //
100 static void U_CALLCONV
101 deleteLocale(void *obj) {
102 delete (icu::Locale *) obj;
103 }
104
105 static UBool U_CALLCONV locale_cleanup(void)
106 {
107 U_NAMESPACE_USE
108
109 if (gLocaleCache) {
110 delete [] gLocaleCache;
111 gLocaleCache = NULL;
112 }
113
114 if (gDefaultLocalesHashT) {
115 uhash_close(gDefaultLocalesHashT); // Automatically deletes all elements, using deleter func.
116 gDefaultLocalesHashT = NULL;
117 gDefaultLocale = NULL;
118 }
119
120 return TRUE;
121 }
122 U_CDECL_END
123
124 U_NAMESPACE_BEGIN
125
126 Locale *locale_set_default_internal(const char *id, UErrorCode& status) {
127 // Synchronize this entire function.
128 Mutex lock(&gDefaultLocaleMutex);
129
130 UBool canonicalize = FALSE;
131
132 // If given a NULL string for the locale id, grab the default
133 // name from the system.
134 // (Different from most other locale APIs, where a null name means use
135 // the current ICU default locale.)
136 if (id == NULL) {
137 id = uprv_getDefaultLocaleID(); // This function not thread safe? TODO: verify.
138 canonicalize = TRUE; // always canonicalize host ID
139 }
140
141 char localeNameBuf[512];
142
143 if (canonicalize) {
144 uloc_canonicalize(id, localeNameBuf, sizeof(localeNameBuf)-1, &status);
145 } else {
146 uloc_getName(id, localeNameBuf, sizeof(localeNameBuf)-1, &status);
147 }
148 localeNameBuf[sizeof(localeNameBuf)-1] = 0; // Force null termination in event of
149 // a long name filling the buffer.
150 // (long names are truncated.)
151 //
152 if (U_FAILURE(status)) {
153 return gDefaultLocale;
154 }
155
156 if (gDefaultLocalesHashT == NULL) {
157 gDefaultLocalesHashT = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);
158 if (U_FAILURE(status)) {
159 return gDefaultLocale;
160 }
161 uhash_setValueDeleter(gDefaultLocalesHashT, deleteLocale);
162 ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup);
163 }
164
165 Locale *newDefault = (Locale *)uhash_get(gDefaultLocalesHashT, localeNameBuf);
166 if (newDefault == NULL) {
167 newDefault = new Locale(Locale::eBOGUS);
168 if (newDefault == NULL) {
169 status = U_MEMORY_ALLOCATION_ERROR;
170 return gDefaultLocale;
171 }
172 newDefault->init(localeNameBuf, FALSE);
173 uhash_put(gDefaultLocalesHashT, (char*) newDefault->getName(), newDefault, &status);
174 if (U_FAILURE(status)) {
175 return gDefaultLocale;
176 }
177 }
178 gDefaultLocale = newDefault;
179 return gDefaultLocale;
180 }
181
182 U_NAMESPACE_END
183
184 /* sfb 07/21/99 */
185 U_CFUNC void
186 locale_set_default(const char *id)
187 {
188 U_NAMESPACE_USE
189 UErrorCode status = U_ZERO_ERROR;
190 locale_set_default_internal(id, status);
191 }
192 /* end */
193
194 U_CFUNC const char *
195 locale_get_default(void)
196 {
197 U_NAMESPACE_USE
198 return Locale::getDefault().getName();
199 }
200
201
202 U_NAMESPACE_BEGIN
203
204 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale)
205
206 /*Character separating the posix id fields*/
207 // '_'
208 // In the platform codepage.
209 #define SEP_CHAR '_'
210
211 Locale::~Locale()
212 {
213 /*if fullName is on the heap, we free it*/
214 if (fullName != fullNameBuffer)
215 {
216 uprv_free(fullName);
217 fullName = NULL;
218 }
219 if (baseName && baseName != baseNameBuffer) {
220 uprv_free(baseName);
221 baseName = NULL;
222 }
223 }
224
225 Locale::Locale()
226 : UObject(), fullName(fullNameBuffer), baseName(NULL)
227 {
228 init(NULL, FALSE);
229 }
230
231 /*
232 * Internal constructor to allow construction of a locale object with
233 * NO side effects. (Default constructor tries to get
234 * the default locale.)
235 */
236 Locale::Locale(Locale::ELocaleType)
237 : UObject(), fullName(fullNameBuffer), baseName(NULL)
238 {
239 setToBogus();
240 }
241
242
243 Locale::Locale( const char * newLanguage,
244 const char * newCountry,
245 const char * newVariant,
246 const char * newKeywords)
247 : UObject(), fullName(fullNameBuffer), baseName(NULL)
248 {
249 if( (newLanguage==NULL) && (newCountry == NULL) && (newVariant == NULL) )
250 {
251 init(NULL, FALSE); /* shortcut */
252 }
253 else
254 {
255 MaybeStackArray<char, ULOC_FULLNAME_CAPACITY> togo;
256 int32_t size = 0;
257 int32_t lsize = 0;
258 int32_t csize = 0;
259 int32_t vsize = 0;
260 int32_t ksize = 0;
261 char *p;
262
263 // Calculate the size of the resulting string.
264
265 // Language
266 if ( newLanguage != NULL )
267 {
268 lsize = (int32_t)uprv_strlen(newLanguage);
269 size = lsize;
270 }
271
272 // _Country
273 if ( newCountry != NULL )
274 {
275 csize = (int32_t)uprv_strlen(newCountry);
276 size += csize;
277 }
278
279 // _Variant
280 if ( newVariant != NULL )
281 {
282 // remove leading _'s
283 while(newVariant[0] == SEP_CHAR)
284 {
285 newVariant++;
286 }
287
288 // remove trailing _'s
289 vsize = (int32_t)uprv_strlen(newVariant);
290 while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR) )
291 {
292 vsize--;
293 }
294 }
295
296 if( vsize > 0 )
297 {
298 size += vsize;
299 }
300
301 // Separator rules:
302 if ( vsize > 0 )
303 {
304 size += 2; // at least: __v
305 }
306 else if ( csize > 0 )
307 {
308 size += 1; // at least: _v
309 }
310
311 if ( newKeywords != NULL)
312 {
313 ksize = (int32_t)uprv_strlen(newKeywords);
314 size += ksize + 1;
315 }
316
317
318 // NOW we have the full locale string..
319
320 /*if the whole string is longer than our internal limit, we need
321 to go to the heap for temporary buffers*/
322 if (size >= togo.getCapacity())
323 {
324 // If togo_heap could not be created, initialize with default settings.
325 if (togo.resize(size+1) == NULL) {
326 init(NULL, FALSE);
327 }
328 }
329
330 togo[0] = 0;
331
332 // Now, copy it back.
333 p = togo.getAlias();
334 if ( lsize != 0 )
335 {
336 uprv_strcpy(p, newLanguage);
337 p += lsize;
338 }
339
340 if ( ( vsize != 0 ) || (csize != 0) ) // at least: __v
341 { // ^
342 *p++ = SEP_CHAR;
343 }
344
345 if ( csize != 0 )
346 {
347 uprv_strcpy(p, newCountry);
348 p += csize;
349 }
350
351 if ( vsize != 0)
352 {
353 *p++ = SEP_CHAR; // at least: __v
354
355 uprv_strncpy(p, newVariant, vsize); // Must use strncpy because
356 p += vsize; // of trimming (above).
357 *p = 0; // terminate
358 }
359
360 if ( ksize != 0)
361 {
362 if (uprv_strchr(newKeywords, '=')) {
363 *p++ = '@'; /* keyword parsing */
364 }
365 else {
366 *p++ = '_'; /* Variant parsing with a script */
367 if ( vsize == 0) {
368 *p++ = '_'; /* No country found */
369 }
370 }
371 uprv_strcpy(p, newKeywords);
372 p += ksize;
373 }
374
375 // Parse it, because for example 'language' might really be a complete
376 // string.
377 init(togo.getAlias(), FALSE);
378 }
379 }
380
381 Locale::Locale(const Locale &other)
382 : UObject(other), fullName(fullNameBuffer), baseName(NULL)
383 {
384 *this = other;
385 }
386
387 Locale &Locale::operator=(const Locale &other)
388 {
389 if (this == &other) {
390 return *this;
391 }
392
393 if (&other == NULL) {
394 this->setToBogus();
395 return *this;
396 }
397
398 /* Free our current storage */
399 if(fullName != fullNameBuffer) {
400 uprv_free(fullName);
401 fullName = fullNameBuffer;
402 }
403
404 /* Allocate the full name if necessary */
405 if(other.fullName != other.fullNameBuffer) {
406 fullName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(other.fullName)+1));
407 if (fullName == NULL) {
408 return *this;
409 }
410 }
411 /* Copy the full name */
412 uprv_strcpy(fullName, other.fullName);
413
414 /* baseName is the cached result of getBaseName. if 'other' has a
415 baseName and it fits in baseNameBuffer, then copy it. otherwise set
416 it to NULL, and let the user lazy-create it (in getBaseName) if they
417 want it. */
418 if(baseName && baseName != baseNameBuffer) {
419 uprv_free(baseName);
420 }
421 baseName = NULL;
422
423 if(other.baseName == other.baseNameBuffer) {
424 uprv_strcpy(baseNameBuffer, other.baseNameBuffer);
425 baseName = baseNameBuffer;
426 }
427
428 /* Copy the language and country fields */
429 uprv_strcpy(language, other.language);
430 uprv_strcpy(script, other.script);
431 uprv_strcpy(country, other.country);
432
433 /* The variantBegin is an offset, just copy it */
434 variantBegin = other.variantBegin;
435 fIsBogus = other.fIsBogus;
436 return *this;
437 }
438
439 Locale *
440 Locale::clone() const {
441 return new Locale(*this);
442 }
443
444 UBool
445 Locale::operator==( const Locale& other) const
446 {
447 return (uprv_strcmp(other.fullName, fullName) == 0);
448 }
449
450 #define ISASCIIALPHA(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
451
452 /*This function initializes a Locale from a C locale ID*/
453 Locale& Locale::init(const char* localeID, UBool canonicalize)
454 {
455 fIsBogus = FALSE;
456 /* Free our current storage */
457 if(fullName != fullNameBuffer) {
458 uprv_free(fullName);
459 fullName = fullNameBuffer;
460 }
461
462 if(baseName && baseName != baseNameBuffer) {
463 uprv_free(baseName);
464 baseName = NULL;
465 }
466
467 // not a loop:
468 // just an easy way to have a common error-exit
469 // without goto and without another function
470 do {
471 char *separator;
472 char *field[5] = {0};
473 int32_t fieldLen[5] = {0};
474 int32_t fieldIdx;
475 int32_t variantField;
476 int32_t length;
477 UErrorCode err;
478
479 if(localeID == NULL) {
480 // not an error, just set the default locale
481 return *this = getDefault();
482 }
483
484 /* preset all fields to empty */
485 language[0] = script[0] = country[0] = 0;
486
487 // "canonicalize" the locale ID to ICU/Java format
488 err = U_ZERO_ERROR;
489 length = canonicalize ?
490 uloc_canonicalize(localeID, fullName, sizeof(fullNameBuffer), &err) :
491 uloc_getName(localeID, fullName, sizeof(fullNameBuffer), &err);
492
493 if(err == U_BUFFER_OVERFLOW_ERROR || length >= (int32_t)sizeof(fullNameBuffer)) {
494 /*Go to heap for the fullName if necessary*/
495 fullName = (char *)uprv_malloc(sizeof(char)*(length + 1));
496 if(fullName == 0) {
497 fullName = fullNameBuffer;
498 break; // error: out of memory
499 }
500 err = U_ZERO_ERROR;
501 length = canonicalize ?
502 uloc_canonicalize(localeID, fullName, length+1, &err) :
503 uloc_getName(localeID, fullName, length+1, &err);
504 }
505 if(U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) {
506 /* should never occur */
507 break;
508 }
509
510 variantBegin = length;
511
512 /* after uloc_getName/canonicalize() we know that only '_' are separators */
513 separator = field[0] = fullName;
514 fieldIdx = 1;
515 while ((separator = uprv_strchr(field[fieldIdx-1], SEP_CHAR)) && fieldIdx < (int32_t)(sizeof(field)/sizeof(field[0]))-1) {
516 field[fieldIdx] = separator + 1;
517 fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]);
518 fieldIdx++;
519 }
520 // variant may contain @foo or .foo POSIX cruft; remove it
521 separator = uprv_strchr(field[fieldIdx-1], '@');
522 char* sep2 = uprv_strchr(field[fieldIdx-1], '.');
523 if (separator!=NULL || sep2!=NULL) {
524 if (separator==NULL || (sep2!=NULL && separator > sep2)) {
525 separator = sep2;
526 }
527 fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]);
528 } else {
529 fieldLen[fieldIdx-1] = length - (int32_t)(field[fieldIdx-1] - fullName);
530 }
531
532 if (fieldLen[0] >= (int32_t)(sizeof(language)))
533 {
534 break; // error: the language field is too long
535 }
536
537 variantField = 1; /* Usually the 2nd one, except when a script or country is also used. */
538 if (fieldLen[0] > 0) {
539 /* We have a language */
540 uprv_memcpy(language, fullName, fieldLen[0]);
541 language[fieldLen[0]] = 0;
542 }
543 if (fieldLen[1] == 4 && ISASCIIALPHA(field[1][0]) &&
544 ISASCIIALPHA(field[1][1]) && ISASCIIALPHA(field[1][2]) &&
545 ISASCIIALPHA(field[1][3])) {
546 /* We have at least a script */
547 uprv_memcpy(script, field[1], fieldLen[1]);
548 script[fieldLen[1]] = 0;
549 variantField++;
550 }
551
552 if (fieldLen[variantField] == 2 || fieldLen[variantField] == 3) {
553 /* We have a country */
554 uprv_memcpy(country, field[variantField], fieldLen[variantField]);
555 country[fieldLen[variantField]] = 0;
556 variantField++;
557 } else if (fieldLen[variantField] == 0) {
558 variantField++; /* script or country empty but variant in next field (i.e. en__POSIX) */
559 }
560
561 if (fieldLen[variantField] > 0) {
562 /* We have a variant */
563 variantBegin = (int32_t)(field[variantField] - fullName);
564 }
565
566 // successful end of init()
567 return *this;
568 } while(0); /*loop doesn't iterate*/
569
570 // when an error occurs, then set this object to "bogus" (there is no UErrorCode here)
571 setToBogus();
572
573 return *this;
574 }
575
576 int32_t
577 Locale::hashCode() const
578 {
579 return ustr_hashCharsN(fullName, uprv_strlen(fullName));
580 }
581
582 void
583 Locale::setToBogus() {
584 /* Free our current storage */
585 if(fullName != fullNameBuffer) {
586 uprv_free(fullName);
587 fullName = fullNameBuffer;
588 }
589 if(baseName && baseName != baseNameBuffer) {
590 uprv_free(baseName);
591 baseName = NULL;
592 }
593 *fullNameBuffer = 0;
594 *language = 0;
595 *script = 0;
596 *country = 0;
597 fIsBogus = TRUE;
598 }
599
600 const Locale& U_EXPORT2
601 Locale::getDefault()
602 {
603 {
604 Mutex lock(&gDefaultLocaleMutex);
605 if (gDefaultLocale != NULL) {
606 return *gDefaultLocale;
607 }
608 }
609 UErrorCode status = U_ZERO_ERROR;
610 return *locale_set_default_internal(NULL, status);
611 }
612
613
614
615 void U_EXPORT2
616 Locale::setDefault( const Locale& newLocale,
617 UErrorCode& status)
618 {
619 if (U_FAILURE(status)) {
620 return;
621 }
622
623 /* Set the default from the full name string of the supplied locale.
624 * This is a convenient way to access the default locale caching mechanisms.
625 */
626 const char *localeID = newLocale.getName();
627 locale_set_default_internal(localeID, status);
628 }
629
630 Locale U_EXPORT2
631 Locale::createFromName (const char *name)
632 {
633 if (name) {
634 Locale l("");
635 l.init(name, FALSE);
636 return l;
637 }
638 else {
639 return getDefault();
640 }
641 }
642
643 Locale U_EXPORT2
644 Locale::createCanonical(const char* name) {
645 Locale loc("");
646 loc.init(name, TRUE);
647 return loc;
648 }
649
650 const char *
651 Locale::getISO3Language() const
652 {
653 return uloc_getISO3Language(fullName);
654 }
655
656
657 const char *
658 Locale::getISO3Country() const
659 {
660 return uloc_getISO3Country(fullName);
661 }
662
663 /**
664 * Return the LCID value as specified in the "LocaleID" resource for this
665 * locale. The LocaleID must be expressed as a hexadecimal number, from
666 * one to four digits. If the LocaleID resource is not present, or is
667 * in an incorrect format, 0 is returned. The LocaleID is for use in
668 * Windows (it is an LCID), but is available on all platforms.
669 */
670 uint32_t
671 Locale::getLCID() const
672 {
673 return uloc_getLCID(fullName);
674 }
675
676 const char* const* U_EXPORT2 Locale::getISOCountries()
677 {
678 return uloc_getISOCountries();
679 }
680
681 const char* const* U_EXPORT2 Locale::getISOLanguages()
682 {
683 return uloc_getISOLanguages();
684 }
685
686 // Set the locale's data based on a posix id.
687 void Locale::setFromPOSIXID(const char *posixID)
688 {
689 init(posixID, TRUE);
690 }
691
692 const Locale & U_EXPORT2
693 Locale::getRoot(void)
694 {
695 return getLocale(eROOT);
696 }
697
698 const Locale & U_EXPORT2
699 Locale::getEnglish(void)
700 {
701 return getLocale(eENGLISH);
702 }
703
704 const Locale & U_EXPORT2
705 Locale::getFrench(void)
706 {
707 return getLocale(eFRENCH);
708 }
709
710 const Locale & U_EXPORT2
711 Locale::getGerman(void)
712 {
713 return getLocale(eGERMAN);
714 }
715
716 const Locale & U_EXPORT2
717 Locale::getItalian(void)
718 {
719 return getLocale(eITALIAN);
720 }
721
722 const Locale & U_EXPORT2
723 Locale::getJapanese(void)
724 {
725 return getLocale(eJAPANESE);
726 }
727
728 const Locale & U_EXPORT2
729 Locale::getKorean(void)
730 {
731 return getLocale(eKOREAN);
732 }
733
734 const Locale & U_EXPORT2
735 Locale::getChinese(void)
736 {
737 return getLocale(eCHINESE);
738 }
739
740 const Locale & U_EXPORT2
741 Locale::getSimplifiedChinese(void)
742 {
743 return getLocale(eCHINA);
744 }
745
746 const Locale & U_EXPORT2
747 Locale::getTraditionalChinese(void)
748 {
749 return getLocale(eTAIWAN);
750 }
751
752
753 const Locale & U_EXPORT2
754 Locale::getFrance(void)
755 {
756 return getLocale(eFRANCE);
757 }
758
759 const Locale & U_EXPORT2
760 Locale::getGermany(void)
761 {
762 return getLocale(eGERMANY);
763 }
764
765 const Locale & U_EXPORT2
766 Locale::getItaly(void)
767 {
768 return getLocale(eITALY);
769 }
770
771 const Locale & U_EXPORT2
772 Locale::getJapan(void)
773 {
774 return getLocale(eJAPAN);
775 }
776
777 const Locale & U_EXPORT2
778 Locale::getKorea(void)
779 {
780 return getLocale(eKOREA);
781 }
782
783 const Locale & U_EXPORT2
784 Locale::getChina(void)
785 {
786 return getLocale(eCHINA);
787 }
788
789 const Locale & U_EXPORT2
790 Locale::getPRC(void)
791 {
792 return getLocale(eCHINA);
793 }
794
795 const Locale & U_EXPORT2
796 Locale::getTaiwan(void)
797 {
798 return getLocale(eTAIWAN);
799 }
800
801 const Locale & U_EXPORT2
802 Locale::getUK(void)
803 {
804 return getLocale(eUK);
805 }
806
807 const Locale & U_EXPORT2
808 Locale::getUS(void)
809 {
810 return getLocale(eUS);
811 }
812
813 const Locale & U_EXPORT2
814 Locale::getCanada(void)
815 {
816 return getLocale(eCANADA);
817 }
818
819 const Locale & U_EXPORT2
820 Locale::getCanadaFrench(void)
821 {
822 return getLocale(eCANADA_FRENCH);
823 }
824
825 const Locale &
826 Locale::getLocale(int locid)
827 {
828 Locale *localeCache = getLocaleCache();
829 U_ASSERT((locid < eMAX_LOCALES)&&(locid>=0));
830 if (localeCache == NULL) {
831 // Failure allocating the locale cache.
832 // The best we can do is return a NULL reference.
833 locid = 0;
834 }
835 return localeCache[locid]; /*operating on NULL*/
836 }
837
838 /*
839 This function is defined this way in order to get around static
840 initialization and static destruction.
841 */
842 Locale *
843 Locale::getLocaleCache(void)
844 {
845 umtx_lock(NULL);
846 UBool needInit = (gLocaleCache == NULL);
847 umtx_unlock(NULL);
848
849 if (needInit) {
850 Locale *tLocaleCache = new Locale[(int)eMAX_LOCALES];
851 if (tLocaleCache == NULL) {
852 return NULL;
853 }
854 tLocaleCache[eROOT] = Locale("");
855 tLocaleCache[eENGLISH] = Locale("en");
856 tLocaleCache[eFRENCH] = Locale("fr");
857 tLocaleCache[eGERMAN] = Locale("de");
858 tLocaleCache[eITALIAN] = Locale("it");
859 tLocaleCache[eJAPANESE] = Locale("ja");
860 tLocaleCache[eKOREAN] = Locale("ko");
861 tLocaleCache[eCHINESE] = Locale("zh");
862 tLocaleCache[eFRANCE] = Locale("fr", "FR");
863 tLocaleCache[eGERMANY] = Locale("de", "DE");
864 tLocaleCache[eITALY] = Locale("it", "IT");
865 tLocaleCache[eJAPAN] = Locale("ja", "JP");
866 tLocaleCache[eKOREA] = Locale("ko", "KR");
867 tLocaleCache[eCHINA] = Locale("zh", "CN");
868 tLocaleCache[eTAIWAN] = Locale("zh", "TW");
869 tLocaleCache[eUK] = Locale("en", "GB");
870 tLocaleCache[eUS] = Locale("en", "US");
871 tLocaleCache[eCANADA] = Locale("en", "CA");
872 tLocaleCache[eCANADA_FRENCH] = Locale("fr", "CA");
873
874 umtx_lock(NULL);
875 if (gLocaleCache == NULL) {
876 gLocaleCache = tLocaleCache;
877 tLocaleCache = NULL;
878 ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup);
879 }
880 umtx_unlock(NULL);
881 if (tLocaleCache) {
882 delete [] tLocaleCache; // Fancy array delete will destruct each member.
883 }
884 }
885 return gLocaleCache;
886 }
887
888 class KeywordEnumeration : public StringEnumeration {
889 private:
890 char *keywords;
891 char *current;
892 int32_t length;
893 UnicodeString currUSKey;
894 static const char fgClassID;/* Warning this is used beyond the typical RTTI usage. */
895
896 public:
897 static UClassID U_EXPORT2 getStaticClassID(void) { return (UClassID)&fgClassID; }
898 virtual UClassID getDynamicClassID(void) const { return getStaticClassID(); }
899 public:
900 KeywordEnumeration(const char *keys, int32_t keywordLen, int32_t currentIndex, UErrorCode &status)
901 : keywords((char *)&fgClassID), current((char *)&fgClassID), length(0) {
902 if(U_SUCCESS(status) && keywordLen != 0) {
903 if(keys == NULL || keywordLen < 0) {
904 status = U_ILLEGAL_ARGUMENT_ERROR;
905 } else {
906 keywords = (char *)uprv_malloc(keywordLen+1);
907 if (keywords == NULL) {
908 status = U_MEMORY_ALLOCATION_ERROR;
909 }
910 else {
911 uprv_memcpy(keywords, keys, keywordLen);
912 keywords[keywordLen] = 0;
913 current = keywords + currentIndex;
914 length = keywordLen;
915 }
916 }
917 }
918 }
919
920 virtual ~KeywordEnumeration();
921
922 virtual StringEnumeration * clone() const
923 {
924 UErrorCode status = U_ZERO_ERROR;
925 return new KeywordEnumeration(keywords, length, (int32_t)(current - keywords), status);
926 }
927
928 virtual int32_t count(UErrorCode &/*status*/) const {
929 char *kw = keywords;
930 int32_t result = 0;
931 while(*kw) {
932 result++;
933 kw += uprv_strlen(kw)+1;
934 }
935 return result;
936 }
937
938 virtual const char* next(int32_t* resultLength, UErrorCode& status) {
939 const char* result;
940 int32_t len;
941 if(U_SUCCESS(status) && *current != 0) {
942 result = current;
943 len = (int32_t)uprv_strlen(current);
944 current += len+1;
945 if(resultLength != NULL) {
946 *resultLength = len;
947 }
948 } else {
949 if(resultLength != NULL) {
950 *resultLength = 0;
951 }
952 result = NULL;
953 }
954 return result;
955 }
956
957 virtual const UnicodeString* snext(UErrorCode& status) {
958 int32_t resultLength = 0;
959 const char *s = next(&resultLength, status);
960 return setChars(s, resultLength, status);
961 }
962
963 virtual void reset(UErrorCode& /*status*/) {
964 current = keywords;
965 }
966 };
967
968 const char KeywordEnumeration::fgClassID = '\0';
969
970 KeywordEnumeration::~KeywordEnumeration() {
971 uprv_free(keywords);
972 }
973
974 StringEnumeration *
975 Locale::createKeywords(UErrorCode &status) const
976 {
977 char keywords[256];
978 int32_t keywordCapacity = 256;
979 StringEnumeration *result = NULL;
980
981 const char* variantStart = uprv_strchr(fullName, '@');
982 const char* assignment = uprv_strchr(fullName, '=');
983 if(variantStart) {
984 if(assignment > variantStart) {
985 int32_t keyLen = locale_getKeywords(variantStart+1, '@', keywords, keywordCapacity, NULL, 0, NULL, FALSE, &status);
986 if(keyLen) {
987 result = new KeywordEnumeration(keywords, keyLen, 0, status);
988 }
989 } else {
990 status = U_INVALID_FORMAT_ERROR;
991 }
992 }
993 return result;
994 }
995
996 int32_t
997 Locale::getKeywordValue(const char* keywordName, char *buffer, int32_t bufLen, UErrorCode &status) const
998 {
999 return uloc_getKeywordValue(fullName, keywordName, buffer, bufLen, &status);
1000 }
1001
1002 void
1003 Locale::setKeywordValue(const char* keywordName, const char* keywordValue, UErrorCode &status)
1004 {
1005 uloc_setKeywordValue(keywordName, keywordValue, fullName, ULOC_FULLNAME_CAPACITY, &status);
1006 }
1007
1008 const char *
1009 Locale::getBaseName() const
1010 {
1011 // lazy init
1012 UErrorCode status = U_ZERO_ERROR;
1013 // semantically const
1014 if(baseName == 0) {
1015 ((Locale *)this)->baseName = ((Locale *)this)->baseNameBuffer;
1016 int32_t baseNameSize = uloc_getBaseName(fullName, baseName, ULOC_FULLNAME_CAPACITY, &status);
1017 if(baseNameSize >= ULOC_FULLNAME_CAPACITY) {
1018 ((Locale *)this)->baseName = (char *)uprv_malloc(sizeof(char) * baseNameSize + 1);
1019 if (baseName == NULL) {
1020 return baseName;
1021 }
1022 uloc_getBaseName(fullName, baseName, baseNameSize+1, &status);
1023 }
1024 baseName[baseNameSize] = 0;
1025
1026 // the computation of variantBegin leaves it equal to the length
1027 // of fullName if there is no variant. It should instead be
1028 // the length of the baseName. Patch around this for now.
1029 if (variantBegin == (int32_t)uprv_strlen(fullName)) {
1030 ((Locale*)this)->variantBegin = baseNameSize;
1031 }
1032 }
1033 return baseName;
1034 }
1035
1036 //eof
1037 U_NAMESPACE_END

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial