1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 *******************************************************************************
5 * Copyright (C) 2010-2016, International Business Machines Corporation and
6 * others. All Rights Reserved.
7 *******************************************************************************
8 */
9
10 #include "unicode/utypes.h"
11
12 #if !UCONFIG_NO_FORMATTING
13
14 #include "unicode/locdspnm.h"
15 #include "unicode/simpleformatter.h"
16 #include "unicode/ures.h"
17 #include "unicode/udisplaycontext.h"
18 #include "unicode/brkiter.h"
19 #include "unicode/ucurr.h"
20 #include "cmemory.h"
21 #include "cstring.h"
22 #include "mutex.h"
23 #include "ulocimp.h"
24 #include "umutex.h"
25 #include "ureslocs.h"
26 #include "uresimp.h"
27
28 #include <stdarg.h>
29
30 /**
31 * Concatenate a number of null-terminated strings to buffer, leaving a
32 * null-terminated string. The last argument should be the null pointer.
33 * Return the length of the string in the buffer, not counting the trailing
34 * null. Return -1 if there is an error (buffer is null, or buflen < 1).
35 */
ncat(char * buffer,uint32_t buflen,...)36 static int32_t ncat(char *buffer, uint32_t buflen, ...) {
37 va_list args;
38 char *str;
39 char *p = buffer;
40 const char* e = buffer + buflen - 1;
41
42 if (buffer == NULL || buflen < 1) {
43 return -1;
44 }
45
46 va_start(args, buflen);
47 while ((str = va_arg(args, char *))) {
48 char c;
49 while (p != e && (c = *str++)) {
50 *p++ = c;
51 }
52 }
53 *p = 0;
54 va_end(args);
55
56 return p - buffer;
57 }
58
59 U_NAMESPACE_BEGIN
60
61 ////////////////////////////////////////////////////////////////////////////////////////////////////
62
63 // Access resource data for locale components.
64 // Wrap code in uloc.c for now.
65 class ICUDataTable {
66 const char* path;
67 Locale locale;
68
69 public:
70 ICUDataTable(const char* path, const Locale& locale);
71 ~ICUDataTable();
72
73 const Locale& getLocale();
74
75 UnicodeString& get(const char* tableKey, const char* itemKey,
76 UnicodeString& result) const;
77 UnicodeString& get(const char* tableKey, const char* subTableKey, const char* itemKey,
78 UnicodeString& result) const;
79
80 UnicodeString& getNoFallback(const char* tableKey, const char* itemKey,
81 UnicodeString &result) const;
82 UnicodeString& getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,
83 UnicodeString &result) const;
84 };
85
86 inline UnicodeString &
get(const char * tableKey,const char * itemKey,UnicodeString & result) const87 ICUDataTable::get(const char* tableKey, const char* itemKey, UnicodeString& result) const {
88 return get(tableKey, NULL, itemKey, result);
89 }
90
91 inline UnicodeString &
getNoFallback(const char * tableKey,const char * itemKey,UnicodeString & result) const92 ICUDataTable::getNoFallback(const char* tableKey, const char* itemKey, UnicodeString& result) const {
93 return getNoFallback(tableKey, NULL, itemKey, result);
94 }
95
ICUDataTable(const char * path,const Locale & locale)96 ICUDataTable::ICUDataTable(const char* path, const Locale& locale)
97 : path(NULL), locale(Locale::getRoot())
98 {
99 if (path) {
100 int32_t len = uprv_strlen(path);
101 this->path = (const char*) uprv_malloc(len + 1);
102 if (this->path) {
103 uprv_strcpy((char *)this->path, path);
104 this->locale = locale;
105 }
106 }
107 }
108
~ICUDataTable()109 ICUDataTable::~ICUDataTable() {
110 if (path) {
111 uprv_free((void*) path);
112 path = NULL;
113 }
114 }
115
116 const Locale&
getLocale()117 ICUDataTable::getLocale() {
118 return locale;
119 }
120
121 UnicodeString &
get(const char * tableKey,const char * subTableKey,const char * itemKey,UnicodeString & result) const122 ICUDataTable::get(const char* tableKey, const char* subTableKey, const char* itemKey,
123 UnicodeString &result) const {
124 UErrorCode status = U_ZERO_ERROR;
125 int32_t len = 0;
126
127 const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
128 tableKey, subTableKey, itemKey,
129 &len, &status);
130 if (U_SUCCESS(status) && len > 0) {
131 return result.setTo(s, len);
132 }
133 return result.setTo(UnicodeString(itemKey, -1, US_INV));
134 }
135
136 UnicodeString &
getNoFallback(const char * tableKey,const char * subTableKey,const char * itemKey,UnicodeString & result) const137 ICUDataTable::getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,
138 UnicodeString& result) const {
139 UErrorCode status = U_ZERO_ERROR;
140 int32_t len = 0;
141
142 const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
143 tableKey, subTableKey, itemKey,
144 &len, &status);
145 if (U_SUCCESS(status)) {
146 return result.setTo(s, len);
147 }
148
149 result.setToBogus();
150 return result;
151 }
152
153 ////////////////////////////////////////////////////////////////////////////////////////////////////
154
~LocaleDisplayNames()155 LocaleDisplayNames::~LocaleDisplayNames() {}
156
157 ////////////////////////////////////////////////////////////////////////////////////////////////////
158
159 #if 0 // currently unused
160
161 class DefaultLocaleDisplayNames : public LocaleDisplayNames {
162 UDialectHandling dialectHandling;
163
164 public:
165 // constructor
166 DefaultLocaleDisplayNames(UDialectHandling dialectHandling);
167
168 virtual ~DefaultLocaleDisplayNames();
169
170 virtual const Locale& getLocale() const;
171 virtual UDialectHandling getDialectHandling() const;
172
173 virtual UnicodeString& localeDisplayName(const Locale& locale,
174 UnicodeString& result) const;
175 virtual UnicodeString& localeDisplayName(const char* localeId,
176 UnicodeString& result) const;
177 virtual UnicodeString& languageDisplayName(const char* lang,
178 UnicodeString& result) const;
179 virtual UnicodeString& scriptDisplayName(const char* script,
180 UnicodeString& result) const;
181 virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
182 UnicodeString& result) const;
183 virtual UnicodeString& regionDisplayName(const char* region,
184 UnicodeString& result) const;
185 virtual UnicodeString& variantDisplayName(const char* variant,
186 UnicodeString& result) const;
187 virtual UnicodeString& keyDisplayName(const char* key,
188 UnicodeString& result) const;
189 virtual UnicodeString& keyValueDisplayName(const char* key,
190 const char* value,
191 UnicodeString& result) const;
192 };
193
194 DefaultLocaleDisplayNames::DefaultLocaleDisplayNames(UDialectHandling dialectHandling)
195 : dialectHandling(dialectHandling) {
196 }
197
198 DefaultLocaleDisplayNames::~DefaultLocaleDisplayNames() {
199 }
200
201 const Locale&
202 DefaultLocaleDisplayNames::getLocale() const {
203 return Locale::getRoot();
204 }
205
206 UDialectHandling
207 DefaultLocaleDisplayNames::getDialectHandling() const {
208 return dialectHandling;
209 }
210
211 UnicodeString&
212 DefaultLocaleDisplayNames::localeDisplayName(const Locale& locale,
213 UnicodeString& result) const {
214 return result = UnicodeString(locale.getName(), -1, US_INV);
215 }
216
217 UnicodeString&
218 DefaultLocaleDisplayNames::localeDisplayName(const char* localeId,
219 UnicodeString& result) const {
220 return result = UnicodeString(localeId, -1, US_INV);
221 }
222
223 UnicodeString&
224 DefaultLocaleDisplayNames::languageDisplayName(const char* lang,
225 UnicodeString& result) const {
226 return result = UnicodeString(lang, -1, US_INV);
227 }
228
229 UnicodeString&
230 DefaultLocaleDisplayNames::scriptDisplayName(const char* script,
231 UnicodeString& result) const {
232 return result = UnicodeString(script, -1, US_INV);
233 }
234
235 UnicodeString&
236 DefaultLocaleDisplayNames::scriptDisplayName(UScriptCode scriptCode,
237 UnicodeString& result) const {
238 const char* name = uscript_getName(scriptCode);
239 if (name) {
240 return result = UnicodeString(name, -1, US_INV);
241 }
242 return result.remove();
243 }
244
245 UnicodeString&
246 DefaultLocaleDisplayNames::regionDisplayName(const char* region,
247 UnicodeString& result) const {
248 return result = UnicodeString(region, -1, US_INV);
249 }
250
251 UnicodeString&
252 DefaultLocaleDisplayNames::variantDisplayName(const char* variant,
253 UnicodeString& result) const {
254 return result = UnicodeString(variant, -1, US_INV);
255 }
256
257 UnicodeString&
258 DefaultLocaleDisplayNames::keyDisplayName(const char* key,
259 UnicodeString& result) const {
260 return result = UnicodeString(key, -1, US_INV);
261 }
262
263 UnicodeString&
264 DefaultLocaleDisplayNames::keyValueDisplayName(const char* /* key */,
265 const char* value,
266 UnicodeString& result) const {
267 return result = UnicodeString(value, -1, US_INV);
268 }
269
270 #endif // currently unused class DefaultLocaleDisplayNames
271
272 ////////////////////////////////////////////////////////////////////////////////////////////////////
273
274 class LocaleDisplayNamesImpl : public LocaleDisplayNames {
275 Locale locale;
276 UDialectHandling dialectHandling;
277 ICUDataTable langData;
278 ICUDataTable regionData;
279 SimpleFormatter separatorFormat;
280 SimpleFormatter format;
281 SimpleFormatter keyTypeFormat;
282 UDisplayContext capitalizationContext;
283 #if !UCONFIG_NO_BREAK_ITERATION
284 BreakIterator* capitalizationBrkIter;
285 #else
286 UObject* capitalizationBrkIter;
287 #endif
288 static UMutex capitalizationBrkIterLock;
289 UnicodeString formatOpenParen;
290 UnicodeString formatReplaceOpenParen;
291 UnicodeString formatCloseParen;
292 UnicodeString formatReplaceCloseParen;
293 UDisplayContext nameLength;
294
295 // Constants for capitalization context usage types.
296 enum CapContextUsage {
297 kCapContextUsageLanguage,
298 kCapContextUsageScript,
299 kCapContextUsageTerritory,
300 kCapContextUsageVariant,
301 kCapContextUsageKey,
302 kCapContextUsageKeyValue,
303 kCapContextUsageCount
304 };
305 // Capitalization transforms. For each usage type, indicates whether to titlecase for
306 // the context specified in capitalizationContext (which we know at construction time)
307 UBool fCapitalization[kCapContextUsageCount];
308
309 public:
310 // constructor
311 LocaleDisplayNamesImpl(const Locale& locale, UDialectHandling dialectHandling);
312 LocaleDisplayNamesImpl(const Locale& locale, UDisplayContext *contexts, int32_t length);
313 virtual ~LocaleDisplayNamesImpl();
314
315 virtual const Locale& getLocale() const;
316 virtual UDialectHandling getDialectHandling() const;
317 virtual UDisplayContext getContext(UDisplayContextType type) const;
318
319 virtual UnicodeString& localeDisplayName(const Locale& locale,
320 UnicodeString& result) const;
321 virtual UnicodeString& localeDisplayName(const char* localeId,
322 UnicodeString& result) const;
323 virtual UnicodeString& languageDisplayName(const char* lang,
324 UnicodeString& result) const;
325 virtual UnicodeString& scriptDisplayName(const char* script,
326 UnicodeString& result) const;
327 virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
328 UnicodeString& result) const;
329 virtual UnicodeString& regionDisplayName(const char* region,
330 UnicodeString& result) const;
331 virtual UnicodeString& variantDisplayName(const char* variant,
332 UnicodeString& result) const;
333 virtual UnicodeString& keyDisplayName(const char* key,
334 UnicodeString& result) const;
335 virtual UnicodeString& keyValueDisplayName(const char* key,
336 const char* value,
337 UnicodeString& result) const;
338 private:
339 UnicodeString& localeIdName(const char* localeId,
340 UnicodeString& result) const;
341 UnicodeString& appendWithSep(UnicodeString& buffer, const UnicodeString& src) const;
342 UnicodeString& adjustForUsageAndContext(CapContextUsage usage, UnicodeString& result) const;
343 UnicodeString& scriptDisplayName(const char* script, UnicodeString& result, UBool skipAdjust) const;
344 UnicodeString& regionDisplayName(const char* region, UnicodeString& result, UBool skipAdjust) const;
345 UnicodeString& variantDisplayName(const char* variant, UnicodeString& result, UBool skipAdjust) const;
346 UnicodeString& keyDisplayName(const char* key, UnicodeString& result, UBool skipAdjust) const;
347 UnicodeString& keyValueDisplayName(const char* key, const char* value,
348 UnicodeString& result, UBool skipAdjust) const;
349 void initialize(void);
350
351 struct CapitalizationContextSink;
352 };
353
354 UMutex LocaleDisplayNamesImpl::capitalizationBrkIterLock = U_MUTEX_INITIALIZER;
355
LocaleDisplayNamesImpl(const Locale & locale,UDialectHandling dialectHandling)356 LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,
357 UDialectHandling dialectHandling)
358 : dialectHandling(dialectHandling)
359 , langData(U_ICUDATA_LANG, locale)
360 , regionData(U_ICUDATA_REGION, locale)
361 , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
362 , capitalizationBrkIter(NULL)
363 , nameLength(UDISPCTX_LENGTH_FULL)
364 {
365 initialize();
366 }
367
LocaleDisplayNamesImpl(const Locale & locale,UDisplayContext * contexts,int32_t length)368 LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,
369 UDisplayContext *contexts, int32_t length)
370 : dialectHandling(ULDN_STANDARD_NAMES)
371 , langData(U_ICUDATA_LANG, locale)
372 , regionData(U_ICUDATA_REGION, locale)
373 , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
374 , capitalizationBrkIter(NULL)
375 , nameLength(UDISPCTX_LENGTH_FULL)
376 {
377 while (length-- > 0) {
378 UDisplayContext value = *contexts++;
379 UDisplayContextType selector = (UDisplayContextType)((uint32_t)value >> 8);
380 switch (selector) {
381 case UDISPCTX_TYPE_DIALECT_HANDLING:
382 dialectHandling = (UDialectHandling)value;
383 break;
384 case UDISPCTX_TYPE_CAPITALIZATION:
385 capitalizationContext = value;
386 break;
387 case UDISPCTX_TYPE_DISPLAY_LENGTH:
388 nameLength = value;
389 break;
390 default:
391 break;
392 }
393 }
394 initialize();
395 }
396
397 struct LocaleDisplayNamesImpl::CapitalizationContextSink : public ResourceSink {
398 UBool hasCapitalizationUsage;
399 LocaleDisplayNamesImpl& parent;
400
CapitalizationContextSinkLocaleDisplayNamesImpl::CapitalizationContextSink401 CapitalizationContextSink(LocaleDisplayNamesImpl& _parent)
402 : hasCapitalizationUsage(FALSE), parent(_parent) {}
403 virtual ~CapitalizationContextSink();
404
putLocaleDisplayNamesImpl::CapitalizationContextSink405 virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
406 UErrorCode &errorCode) {
407 ResourceTable contexts = value.getTable(errorCode);
408 if (U_FAILURE(errorCode)) { return; }
409 for (int i = 0; contexts.getKeyAndValue(i, key, value); ++i) {
410
411 CapContextUsage usageEnum;
412 if (uprv_strcmp(key, "key") == 0) {
413 usageEnum = kCapContextUsageKey;
414 } else if (uprv_strcmp(key, "keyValue") == 0) {
415 usageEnum = kCapContextUsageKeyValue;
416 } else if (uprv_strcmp(key, "languages") == 0) {
417 usageEnum = kCapContextUsageLanguage;
418 } else if (uprv_strcmp(key, "script") == 0) {
419 usageEnum = kCapContextUsageScript;
420 } else if (uprv_strcmp(key, "territory") == 0) {
421 usageEnum = kCapContextUsageTerritory;
422 } else if (uprv_strcmp(key, "variant") == 0) {
423 usageEnum = kCapContextUsageVariant;
424 } else {
425 continue;
426 }
427
428 int32_t len = 0;
429 const int32_t* intVector = value.getIntVector(len, errorCode);
430 if (U_FAILURE(errorCode)) { return; }
431 if (len < 2) { continue; }
432
433 int32_t titlecaseInt = (parent.capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU) ? intVector[0] : intVector[1];
434 if (titlecaseInt == 0) { continue; }
435
436 parent.fCapitalization[usageEnum] = TRUE;
437 hasCapitalizationUsage = TRUE;
438 }
439 }
440 };
441
442 // Virtual destructors must be defined out of line.
~CapitalizationContextSink()443 LocaleDisplayNamesImpl::CapitalizationContextSink::~CapitalizationContextSink() {}
444
445 void
initialize(void)446 LocaleDisplayNamesImpl::initialize(void) {
447 LocaleDisplayNamesImpl *nonConstThis = (LocaleDisplayNamesImpl *)this;
448 nonConstThis->locale = langData.getLocale() == Locale::getRoot()
449 ? regionData.getLocale()
450 : langData.getLocale();
451
452 UnicodeString sep;
453 langData.getNoFallback("localeDisplayPattern", "separator", sep);
454 if (sep.isBogus()) {
455 sep = UnicodeString("{0}, {1}", -1, US_INV);
456 }
457 UErrorCode status = U_ZERO_ERROR;
458 separatorFormat.applyPatternMinMaxArguments(sep, 2, 2, status);
459
460 UnicodeString pattern;
461 langData.getNoFallback("localeDisplayPattern", "pattern", pattern);
462 if (pattern.isBogus()) {
463 pattern = UnicodeString("{0} ({1})", -1, US_INV);
464 }
465 format.applyPatternMinMaxArguments(pattern, 2, 2, status);
466 if (pattern.indexOf((UChar)0xFF08) >= 0) {
467 formatOpenParen.setTo((UChar)0xFF08); // fullwidth (
468 formatReplaceOpenParen.setTo((UChar)0xFF3B); // fullwidth [
469 formatCloseParen.setTo((UChar)0xFF09); // fullwidth )
470 formatReplaceCloseParen.setTo((UChar)0xFF3D); // fullwidth ]
471 } else {
472 formatOpenParen.setTo((UChar)0x0028); // (
473 formatReplaceOpenParen.setTo((UChar)0x005B); // [
474 formatCloseParen.setTo((UChar)0x0029); // )
475 formatReplaceCloseParen.setTo((UChar)0x005D); // ]
476 }
477
478 UnicodeString ktPattern;
479 langData.get("localeDisplayPattern", "keyTypePattern", ktPattern);
480 if (ktPattern.isBogus()) {
481 ktPattern = UnicodeString("{0}={1}", -1, US_INV);
482 }
483 keyTypeFormat.applyPatternMinMaxArguments(ktPattern, 2, 2, status);
484
485 uprv_memset(fCapitalization, 0, sizeof(fCapitalization));
486 #if !UCONFIG_NO_BREAK_ITERATION
487 // Only get the context data if we need it! This is a const object so we know now...
488 // Also check whether we will need a break iterator (depends on the data)
489 UBool needBrkIter = FALSE;
490 if (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU || capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_STANDALONE) {
491 LocalUResourceBundlePointer resource(ures_open(NULL, locale.getName(), &status));
492 if (U_FAILURE(status)) { return; }
493 CapitalizationContextSink sink(*this);
494 ures_getAllItemsWithFallback(resource.getAlias(), "contextTransforms", sink, status);
495 if (status == U_MISSING_RESOURCE_ERROR) {
496 // Silently ignore. Not every locale has contextTransforms.
497 status = U_ZERO_ERROR;
498 } else if (U_FAILURE(status)) {
499 return;
500 }
501 needBrkIter = sink.hasCapitalizationUsage;
502 }
503 // Get a sentence break iterator if we will need it
504 if (needBrkIter || capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE) {
505 status = U_ZERO_ERROR;
506 capitalizationBrkIter = BreakIterator::createSentenceInstance(locale, status);
507 if (U_FAILURE(status)) {
508 delete capitalizationBrkIter;
509 capitalizationBrkIter = NULL;
510 }
511 }
512 #endif
513 }
514
~LocaleDisplayNamesImpl()515 LocaleDisplayNamesImpl::~LocaleDisplayNamesImpl() {
516 #if !UCONFIG_NO_BREAK_ITERATION
517 delete capitalizationBrkIter;
518 #endif
519 }
520
521 const Locale&
getLocale() const522 LocaleDisplayNamesImpl::getLocale() const {
523 return locale;
524 }
525
526 UDialectHandling
getDialectHandling() const527 LocaleDisplayNamesImpl::getDialectHandling() const {
528 return dialectHandling;
529 }
530
531 UDisplayContext
getContext(UDisplayContextType type) const532 LocaleDisplayNamesImpl::getContext(UDisplayContextType type) const {
533 switch (type) {
534 case UDISPCTX_TYPE_DIALECT_HANDLING:
535 return (UDisplayContext)dialectHandling;
536 case UDISPCTX_TYPE_CAPITALIZATION:
537 return capitalizationContext;
538 case UDISPCTX_TYPE_DISPLAY_LENGTH:
539 return nameLength;
540 default:
541 break;
542 }
543 return (UDisplayContext)0;
544 }
545
546 UnicodeString&
adjustForUsageAndContext(CapContextUsage usage,UnicodeString & result) const547 LocaleDisplayNamesImpl::adjustForUsageAndContext(CapContextUsage usage,
548 UnicodeString& result) const {
549 #if !UCONFIG_NO_BREAK_ITERATION
550 // check to see whether we need to titlecase result
551 if ( result.length() > 0 && u_islower(result.char32At(0)) && capitalizationBrkIter!= NULL &&
552 ( capitalizationContext==UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE || fCapitalization[usage] ) ) {
553 // note fCapitalization[usage] won't be set unless capitalizationContext is UI_LIST_OR_MENU or STANDALONE
554 Mutex lock(&capitalizationBrkIterLock);
555 result.toTitle(capitalizationBrkIter, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
556 }
557 #endif
558 return result;
559 }
560
561 UnicodeString&
localeDisplayName(const Locale & locale,UnicodeString & result) const562 LocaleDisplayNamesImpl::localeDisplayName(const Locale& locale,
563 UnicodeString& result) const {
564 if (locale.isBogus()) {
565 result.setToBogus();
566 return result;
567 }
568 UnicodeString resultName;
569
570 const char* lang = locale.getLanguage();
571 if (uprv_strlen(lang) == 0) {
572 lang = "root";
573 }
574 const char* script = locale.getScript();
575 const char* country = locale.getCountry();
576 const char* variant = locale.getVariant();
577
578 UBool hasScript = uprv_strlen(script) > 0;
579 UBool hasCountry = uprv_strlen(country) > 0;
580 UBool hasVariant = uprv_strlen(variant) > 0;
581
582 if (dialectHandling == ULDN_DIALECT_NAMES) {
583 char buffer[ULOC_FULLNAME_CAPACITY];
584 do { // loop construct is so we can break early out of search
585 if (hasScript && hasCountry) {
586 ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, "_", country, (char *)0);
587 localeIdName(buffer, resultName);
588 if (!resultName.isBogus()) {
589 hasScript = FALSE;
590 hasCountry = FALSE;
591 break;
592 }
593 }
594 if (hasScript) {
595 ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, (char *)0);
596 localeIdName(buffer, resultName);
597 if (!resultName.isBogus()) {
598 hasScript = FALSE;
599 break;
600 }
601 }
602 if (hasCountry) {
603 ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", country, (char*)0);
604 localeIdName(buffer, resultName);
605 if (!resultName.isBogus()) {
606 hasCountry = FALSE;
607 break;
608 }
609 }
610 } while (FALSE);
611 }
612 if (resultName.isBogus() || resultName.isEmpty()) {
613 localeIdName(lang, resultName);
614 }
615
616 UnicodeString resultRemainder;
617 UnicodeString temp;
618 UErrorCode status = U_ZERO_ERROR;
619
620 if (hasScript) {
621 resultRemainder.append(scriptDisplayName(script, temp, TRUE));
622 }
623 if (hasCountry) {
624 appendWithSep(resultRemainder, regionDisplayName(country, temp, TRUE));
625 }
626 if (hasVariant) {
627 appendWithSep(resultRemainder, variantDisplayName(variant, temp, TRUE));
628 }
629 resultRemainder.findAndReplace(formatOpenParen, formatReplaceOpenParen);
630 resultRemainder.findAndReplace(formatCloseParen, formatReplaceCloseParen);
631
632 LocalPointer<StringEnumeration> e(locale.createKeywords(status));
633 if (e.isValid() && U_SUCCESS(status)) {
634 UnicodeString temp2;
635 char value[ULOC_KEYWORD_AND_VALUES_CAPACITY]; // sigh, no ULOC_VALUE_CAPACITY
636 const char* key;
637 while ((key = e->next((int32_t *)0, status)) != NULL) {
638 locale.getKeywordValue(key, value, ULOC_KEYWORD_AND_VALUES_CAPACITY, status);
639 if (U_FAILURE(status)) {
640 return result;
641 }
642 keyDisplayName(key, temp, TRUE);
643 temp.findAndReplace(formatOpenParen, formatReplaceOpenParen);
644 temp.findAndReplace(formatCloseParen, formatReplaceCloseParen);
645 keyValueDisplayName(key, value, temp2, TRUE);
646 temp2.findAndReplace(formatOpenParen, formatReplaceOpenParen);
647 temp2.findAndReplace(formatCloseParen, formatReplaceCloseParen);
648 if (temp2 != UnicodeString(value, -1, US_INV)) {
649 appendWithSep(resultRemainder, temp2);
650 } else if (temp != UnicodeString(key, -1, US_INV)) {
651 UnicodeString temp3;
652 keyTypeFormat.format(temp, temp2, temp3, status);
653 appendWithSep(resultRemainder, temp3);
654 } else {
655 appendWithSep(resultRemainder, temp)
656 .append((UChar)0x3d /* = */)
657 .append(temp2);
658 }
659 }
660 }
661
662 if (!resultRemainder.isEmpty()) {
663 format.format(resultName, resultRemainder, result.remove(), status);
664 return adjustForUsageAndContext(kCapContextUsageLanguage, result);
665 }
666
667 result = resultName;
668 return adjustForUsageAndContext(kCapContextUsageLanguage, result);
669 }
670
671 UnicodeString&
appendWithSep(UnicodeString & buffer,const UnicodeString & src) const672 LocaleDisplayNamesImpl::appendWithSep(UnicodeString& buffer, const UnicodeString& src) const {
673 if (buffer.isEmpty()) {
674 buffer.setTo(src);
675 } else {
676 const UnicodeString *values[2] = { &buffer, &src };
677 UErrorCode status = U_ZERO_ERROR;
678 separatorFormat.formatAndReplace(values, 2, buffer, NULL, 0, status);
679 }
680 return buffer;
681 }
682
683 UnicodeString&
localeDisplayName(const char * localeId,UnicodeString & result) const684 LocaleDisplayNamesImpl::localeDisplayName(const char* localeId,
685 UnicodeString& result) const {
686 return localeDisplayName(Locale(localeId), result);
687 }
688
689 // private
690 UnicodeString&
localeIdName(const char * localeId,UnicodeString & result) const691 LocaleDisplayNamesImpl::localeIdName(const char* localeId,
692 UnicodeString& result) const {
693 if (nameLength == UDISPCTX_LENGTH_SHORT) {
694 langData.getNoFallback("Languages%short", localeId, result);
695 if (!result.isBogus()) {
696 return result;
697 }
698 }
699 return langData.getNoFallback("Languages", localeId, result);
700 }
701
702 UnicodeString&
languageDisplayName(const char * lang,UnicodeString & result) const703 LocaleDisplayNamesImpl::languageDisplayName(const char* lang,
704 UnicodeString& result) const {
705 if (uprv_strcmp("root", lang) == 0 || uprv_strchr(lang, '_') != NULL) {
706 return result = UnicodeString(lang, -1, US_INV);
707 }
708 if (nameLength == UDISPCTX_LENGTH_SHORT) {
709 langData.get("Languages%short", lang, result);
710 if (!result.isBogus()) {
711 return adjustForUsageAndContext(kCapContextUsageLanguage, result);
712 }
713 }
714 langData.get("Languages", lang, result);
715 return adjustForUsageAndContext(kCapContextUsageLanguage, result);
716 }
717
718 UnicodeString&
scriptDisplayName(const char * script,UnicodeString & result,UBool skipAdjust) const719 LocaleDisplayNamesImpl::scriptDisplayName(const char* script,
720 UnicodeString& result,
721 UBool skipAdjust) const {
722 if (nameLength == UDISPCTX_LENGTH_SHORT) {
723 langData.get("Scripts%short", script, result);
724 if (!result.isBogus()) {
725 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageScript, result);
726 }
727 }
728 langData.get("Scripts", script, result);
729 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageScript, result);
730 }
731
732 UnicodeString&
scriptDisplayName(const char * script,UnicodeString & result) const733 LocaleDisplayNamesImpl::scriptDisplayName(const char* script,
734 UnicodeString& result) const {
735 return scriptDisplayName(script, result, FALSE);
736 }
737
738 UnicodeString&
scriptDisplayName(UScriptCode scriptCode,UnicodeString & result) const739 LocaleDisplayNamesImpl::scriptDisplayName(UScriptCode scriptCode,
740 UnicodeString& result) const {
741 return scriptDisplayName(uscript_getName(scriptCode), result, FALSE);
742 }
743
744 UnicodeString&
regionDisplayName(const char * region,UnicodeString & result,UBool skipAdjust) const745 LocaleDisplayNamesImpl::regionDisplayName(const char* region,
746 UnicodeString& result,
747 UBool skipAdjust) const {
748 if (nameLength == UDISPCTX_LENGTH_SHORT) {
749 regionData.get("Countries%short", region, result);
750 if (!result.isBogus()) {
751 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageTerritory, result);
752 }
753 }
754 regionData.get("Countries", region, result);
755 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageTerritory, result);
756 }
757
758 UnicodeString&
regionDisplayName(const char * region,UnicodeString & result) const759 LocaleDisplayNamesImpl::regionDisplayName(const char* region,
760 UnicodeString& result) const {
761 return regionDisplayName(region, result, FALSE);
762 }
763
764
765 UnicodeString&
variantDisplayName(const char * variant,UnicodeString & result,UBool skipAdjust) const766 LocaleDisplayNamesImpl::variantDisplayName(const char* variant,
767 UnicodeString& result,
768 UBool skipAdjust) const {
769 // don't have a resource for short variant names
770 langData.get("Variants", variant, result);
771 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageVariant, result);
772 }
773
774 UnicodeString&
variantDisplayName(const char * variant,UnicodeString & result) const775 LocaleDisplayNamesImpl::variantDisplayName(const char* variant,
776 UnicodeString& result) const {
777 return variantDisplayName(variant, result, FALSE);
778 }
779
780 UnicodeString&
keyDisplayName(const char * key,UnicodeString & result,UBool skipAdjust) const781 LocaleDisplayNamesImpl::keyDisplayName(const char* key,
782 UnicodeString& result,
783 UBool skipAdjust) const {
784 // don't have a resource for short key names
785 langData.get("Keys", key, result);
786 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKey, result);
787 }
788
789 UnicodeString&
keyDisplayName(const char * key,UnicodeString & result) const790 LocaleDisplayNamesImpl::keyDisplayName(const char* key,
791 UnicodeString& result) const {
792 return keyDisplayName(key, result, FALSE);
793 }
794
795 UnicodeString&
keyValueDisplayName(const char * key,const char * value,UnicodeString & result,UBool skipAdjust) const796 LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,
797 const char* value,
798 UnicodeString& result,
799 UBool skipAdjust) const {
800 if (uprv_strcmp(key, "currency") == 0) {
801 // ICU4C does not have ICU4J CurrencyDisplayInfo equivalent for now.
802 UErrorCode sts = U_ZERO_ERROR;
803 UnicodeString ustrValue(value, -1, US_INV);
804 int32_t len;
805 UBool isChoice = FALSE;
806 const UChar *currencyName = ucurr_getName(ustrValue.getTerminatedBuffer(),
807 locale.getBaseName(), UCURR_LONG_NAME, &isChoice, &len, &sts);
808 if (U_FAILURE(sts)) {
809 // Return the value as is on failure
810 result = ustrValue;
811 return result;
812 }
813 result.setTo(currencyName, len);
814 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);
815 }
816
817 if (nameLength == UDISPCTX_LENGTH_SHORT) {
818 langData.get("Types%short", key, value, result);
819 if (!result.isBogus()) {
820 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);
821 }
822 }
823 langData.get("Types", key, value, result);
824 return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);
825 }
826
827 UnicodeString&
keyValueDisplayName(const char * key,const char * value,UnicodeString & result) const828 LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,
829 const char* value,
830 UnicodeString& result) const {
831 return keyValueDisplayName(key, value, result, FALSE);
832 }
833
834 ////////////////////////////////////////////////////////////////////////////////////////////////////
835
836 LocaleDisplayNames*
createInstance(const Locale & locale,UDialectHandling dialectHandling)837 LocaleDisplayNames::createInstance(const Locale& locale,
838 UDialectHandling dialectHandling) {
839 return new LocaleDisplayNamesImpl(locale, dialectHandling);
840 }
841
842 LocaleDisplayNames*
createInstance(const Locale & locale,UDisplayContext * contexts,int32_t length)843 LocaleDisplayNames::createInstance(const Locale& locale,
844 UDisplayContext *contexts, int32_t length) {
845 if (contexts == NULL) {
846 length = 0;
847 }
848 return new LocaleDisplayNamesImpl(locale, contexts, length);
849 }
850
851 U_NAMESPACE_END
852
853 ////////////////////////////////////////////////////////////////////////////////////////////////////
854
855 U_NAMESPACE_USE
856
857 U_CAPI ULocaleDisplayNames * U_EXPORT2
uldn_open(const char * locale,UDialectHandling dialectHandling,UErrorCode * pErrorCode)858 uldn_open(const char * locale,
859 UDialectHandling dialectHandling,
860 UErrorCode *pErrorCode) {
861 if (U_FAILURE(*pErrorCode)) {
862 return 0;
863 }
864 if (locale == NULL) {
865 locale = uloc_getDefault();
866 }
867 return (ULocaleDisplayNames *)LocaleDisplayNames::createInstance(Locale(locale), dialectHandling);
868 }
869
870 U_CAPI ULocaleDisplayNames * U_EXPORT2
uldn_openForContext(const char * locale,UDisplayContext * contexts,int32_t length,UErrorCode * pErrorCode)871 uldn_openForContext(const char * locale,
872 UDisplayContext *contexts, int32_t length,
873 UErrorCode *pErrorCode) {
874 if (U_FAILURE(*pErrorCode)) {
875 return 0;
876 }
877 if (locale == NULL) {
878 locale = uloc_getDefault();
879 }
880 return (ULocaleDisplayNames *)LocaleDisplayNames::createInstance(Locale(locale), contexts, length);
881 }
882
883
884 U_CAPI void U_EXPORT2
uldn_close(ULocaleDisplayNames * ldn)885 uldn_close(ULocaleDisplayNames *ldn) {
886 delete (LocaleDisplayNames *)ldn;
887 }
888
889 U_CAPI const char * U_EXPORT2
uldn_getLocale(const ULocaleDisplayNames * ldn)890 uldn_getLocale(const ULocaleDisplayNames *ldn) {
891 if (ldn) {
892 return ((const LocaleDisplayNames *)ldn)->getLocale().getName();
893 }
894 return NULL;
895 }
896
897 U_CAPI UDialectHandling U_EXPORT2
uldn_getDialectHandling(const ULocaleDisplayNames * ldn)898 uldn_getDialectHandling(const ULocaleDisplayNames *ldn) {
899 if (ldn) {
900 return ((const LocaleDisplayNames *)ldn)->getDialectHandling();
901 }
902 return ULDN_STANDARD_NAMES;
903 }
904
905 U_CAPI UDisplayContext U_EXPORT2
uldn_getContext(const ULocaleDisplayNames * ldn,UDisplayContextType type,UErrorCode * pErrorCode)906 uldn_getContext(const ULocaleDisplayNames *ldn,
907 UDisplayContextType type,
908 UErrorCode *pErrorCode) {
909 if (U_FAILURE(*pErrorCode)) {
910 return (UDisplayContext)0;
911 }
912 return ((const LocaleDisplayNames *)ldn)->getContext(type);
913 }
914
915 U_CAPI int32_t U_EXPORT2
uldn_localeDisplayName(const ULocaleDisplayNames * ldn,const char * locale,UChar * result,int32_t maxResultSize,UErrorCode * pErrorCode)916 uldn_localeDisplayName(const ULocaleDisplayNames *ldn,
917 const char *locale,
918 UChar *result,
919 int32_t maxResultSize,
920 UErrorCode *pErrorCode) {
921 if (U_FAILURE(*pErrorCode)) {
922 return 0;
923 }
924 if (ldn == NULL || locale == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
925 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
926 return 0;
927 }
928 UnicodeString temp(result, 0, maxResultSize);
929 ((const LocaleDisplayNames *)ldn)->localeDisplayName(locale, temp);
930 if (temp.isBogus()) {
931 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
932 return 0;
933 }
934 return temp.extract(result, maxResultSize, *pErrorCode);
935 }
936
937 U_CAPI int32_t U_EXPORT2
uldn_languageDisplayName(const ULocaleDisplayNames * ldn,const char * lang,UChar * result,int32_t maxResultSize,UErrorCode * pErrorCode)938 uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
939 const char *lang,
940 UChar *result,
941 int32_t maxResultSize,
942 UErrorCode *pErrorCode) {
943 if (U_FAILURE(*pErrorCode)) {
944 return 0;
945 }
946 if (ldn == NULL || lang == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
947 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
948 return 0;
949 }
950 UnicodeString temp(result, 0, maxResultSize);
951 ((const LocaleDisplayNames *)ldn)->languageDisplayName(lang, temp);
952 return temp.extract(result, maxResultSize, *pErrorCode);
953 }
954
955 U_CAPI int32_t U_EXPORT2
uldn_scriptDisplayName(const ULocaleDisplayNames * ldn,const char * script,UChar * result,int32_t maxResultSize,UErrorCode * pErrorCode)956 uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
957 const char *script,
958 UChar *result,
959 int32_t maxResultSize,
960 UErrorCode *pErrorCode) {
961 if (U_FAILURE(*pErrorCode)) {
962 return 0;
963 }
964 if (ldn == NULL || script == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
965 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
966 return 0;
967 }
968 UnicodeString temp(result, 0, maxResultSize);
969 ((const LocaleDisplayNames *)ldn)->scriptDisplayName(script, temp);
970 return temp.extract(result, maxResultSize, *pErrorCode);
971 }
972
973 U_CAPI int32_t U_EXPORT2
uldn_scriptCodeDisplayName(const ULocaleDisplayNames * ldn,UScriptCode scriptCode,UChar * result,int32_t maxResultSize,UErrorCode * pErrorCode)974 uldn_scriptCodeDisplayName(const ULocaleDisplayNames *ldn,
975 UScriptCode scriptCode,
976 UChar *result,
977 int32_t maxResultSize,
978 UErrorCode *pErrorCode) {
979 return uldn_scriptDisplayName(ldn, uscript_getName(scriptCode), result, maxResultSize, pErrorCode);
980 }
981
982 U_CAPI int32_t U_EXPORT2
uldn_regionDisplayName(const ULocaleDisplayNames * ldn,const char * region,UChar * result,int32_t maxResultSize,UErrorCode * pErrorCode)983 uldn_regionDisplayName(const ULocaleDisplayNames *ldn,
984 const char *region,
985 UChar *result,
986 int32_t maxResultSize,
987 UErrorCode *pErrorCode) {
988 if (U_FAILURE(*pErrorCode)) {
989 return 0;
990 }
991 if (ldn == NULL || region == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
992 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
993 return 0;
994 }
995 UnicodeString temp(result, 0, maxResultSize);
996 ((const LocaleDisplayNames *)ldn)->regionDisplayName(region, temp);
997 return temp.extract(result, maxResultSize, *pErrorCode);
998 }
999
1000 U_CAPI int32_t U_EXPORT2
uldn_variantDisplayName(const ULocaleDisplayNames * ldn,const char * variant,UChar * result,int32_t maxResultSize,UErrorCode * pErrorCode)1001 uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
1002 const char *variant,
1003 UChar *result,
1004 int32_t maxResultSize,
1005 UErrorCode *pErrorCode) {
1006 if (U_FAILURE(*pErrorCode)) {
1007 return 0;
1008 }
1009 if (ldn == NULL || variant == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
1010 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
1011 return 0;
1012 }
1013 UnicodeString temp(result, 0, maxResultSize);
1014 ((const LocaleDisplayNames *)ldn)->variantDisplayName(variant, temp);
1015 return temp.extract(result, maxResultSize, *pErrorCode);
1016 }
1017
1018 U_CAPI int32_t U_EXPORT2
uldn_keyDisplayName(const ULocaleDisplayNames * ldn,const char * key,UChar * result,int32_t maxResultSize,UErrorCode * pErrorCode)1019 uldn_keyDisplayName(const ULocaleDisplayNames *ldn,
1020 const char *key,
1021 UChar *result,
1022 int32_t maxResultSize,
1023 UErrorCode *pErrorCode) {
1024 if (U_FAILURE(*pErrorCode)) {
1025 return 0;
1026 }
1027 if (ldn == NULL || key == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
1028 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
1029 return 0;
1030 }
1031 UnicodeString temp(result, 0, maxResultSize);
1032 ((const LocaleDisplayNames *)ldn)->keyDisplayName(key, temp);
1033 return temp.extract(result, maxResultSize, *pErrorCode);
1034 }
1035
1036 U_CAPI int32_t U_EXPORT2
uldn_keyValueDisplayName(const ULocaleDisplayNames * ldn,const char * key,const char * value,UChar * result,int32_t maxResultSize,UErrorCode * pErrorCode)1037 uldn_keyValueDisplayName(const ULocaleDisplayNames *ldn,
1038 const char *key,
1039 const char *value,
1040 UChar *result,
1041 int32_t maxResultSize,
1042 UErrorCode *pErrorCode) {
1043 if (U_FAILURE(*pErrorCode)) {
1044 return 0;
1045 }
1046 if (ldn == NULL || key == NULL || value == NULL || (result == NULL && maxResultSize > 0)
1047 || maxResultSize < 0) {
1048 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
1049 return 0;
1050 }
1051 UnicodeString temp(result, 0, maxResultSize);
1052 ((const LocaleDisplayNames *)ldn)->keyValueDisplayName(key, value, temp);
1053 return temp.extract(result, maxResultSize, *pErrorCode);
1054 }
1055
1056 #endif
1057