1/*
2*******************************************************************************
3* Copyright (C) 2010-2012, International Business Machines Corporation and
4* others. All Rights Reserved.
5*******************************************************************************
6*/
7
8#include "unicode/utypes.h"
9
10#if !UCONFIG_NO_FORMATTING
11
12#include "unicode/locdspnm.h"
13#include "unicode/msgfmt.h"
14#include "unicode/ures.h"
15#include "unicode/brkiter.h"
16
17#include "cmemory.h"
18#include "cstring.h"
19#include "ulocimp.h"
20#include "ureslocs.h"
21#include "uresimp.h"
22
23#include <stdarg.h>
24
25/**
26 * Concatenate a number of null-terminated strings to buffer, leaving a
27 * null-terminated string.  The last argument should be the null pointer.
28 * Return the length of the string in the buffer, not counting the trailing
29 * null.  Return -1 if there is an error (buffer is null, or buflen < 1).
30 */
31static int32_t ncat(char *buffer, uint32_t buflen, ...) {
32  va_list args;
33  char *str;
34  char *p = buffer;
35  const char* e = buffer + buflen - 1;
36
37  if (buffer == NULL || buflen < 1) {
38    return -1;
39  }
40
41  va_start(args, buflen);
42  while ((str = va_arg(args, char *))) {
43    char c;
44    while (p != e && (c = *str++)) {
45      *p++ = c;
46    }
47  }
48  *p = 0;
49  va_end(args);
50
51  return p - buffer;
52}
53
54U_NAMESPACE_BEGIN
55
56////////////////////////////////////////////////////////////////////////////////////////////////////
57
58// Access resource data for locale components.
59// Wrap code in uloc.c for now.
60class ICUDataTable {
61    const char* path;
62    Locale locale;
63
64public:
65    ICUDataTable(const char* path, const Locale& locale);
66    ~ICUDataTable();
67
68    const Locale& getLocale();
69
70    UnicodeString& get(const char* tableKey, const char* itemKey,
71                        UnicodeString& result) const;
72    UnicodeString& get(const char* tableKey, const char* subTableKey, const char* itemKey,
73                        UnicodeString& result) const;
74
75    UnicodeString& getNoFallback(const char* tableKey, const char* itemKey,
76                                UnicodeString &result) const;
77    UnicodeString& getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,
78                                UnicodeString &result) const;
79};
80
81inline UnicodeString &
82ICUDataTable::get(const char* tableKey, const char* itemKey, UnicodeString& result) const {
83    return get(tableKey, NULL, itemKey, result);
84}
85
86inline UnicodeString &
87ICUDataTable::getNoFallback(const char* tableKey, const char* itemKey, UnicodeString& result) const {
88    return getNoFallback(tableKey, NULL, itemKey, result);
89}
90
91ICUDataTable::ICUDataTable(const char* path, const Locale& locale)
92    : path(NULL), locale(Locale::getRoot())
93{
94  if (path) {
95    int32_t len = uprv_strlen(path);
96    this->path = (const char*) uprv_malloc(len + 1);
97    if (this->path) {
98      uprv_strcpy((char *)this->path, path);
99      this->locale = locale;
100    }
101  }
102}
103
104ICUDataTable::~ICUDataTable() {
105  if (path) {
106    uprv_free((void*) path);
107    path = NULL;
108  }
109}
110
111const Locale&
112ICUDataTable::getLocale() {
113  return locale;
114}
115
116UnicodeString &
117ICUDataTable::get(const char* tableKey, const char* subTableKey, const char* itemKey,
118                  UnicodeString &result) const {
119  UErrorCode status = U_ZERO_ERROR;
120  int32_t len = 0;
121
122  const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
123                                                   tableKey, subTableKey, itemKey,
124                                                   &len, &status);
125  if (U_SUCCESS(status) && len > 0) {
126    return result.setTo(s, len);
127  }
128  return result.setTo(UnicodeString(itemKey, -1, US_INV));
129}
130
131UnicodeString &
132ICUDataTable::getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,
133                            UnicodeString& result) const {
134  UErrorCode status = U_ZERO_ERROR;
135  int32_t len = 0;
136
137  const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
138                                                   tableKey, subTableKey, itemKey,
139                                                   &len, &status);
140  if (U_SUCCESS(status)) {
141    return result.setTo(s, len);
142  }
143
144  result.setToBogus();
145  return result;
146}
147
148////////////////////////////////////////////////////////////////////////////////////////////////////
149
150LocaleDisplayNames::~LocaleDisplayNames() {}
151
152////////////////////////////////////////////////////////////////////////////////////////////////////
153
154#if 0  // currently unused
155
156class DefaultLocaleDisplayNames : public LocaleDisplayNames {
157  UDialectHandling dialectHandling;
158
159public:
160  // constructor
161  DefaultLocaleDisplayNames(UDialectHandling dialectHandling);
162
163  virtual ~DefaultLocaleDisplayNames();
164
165  virtual const Locale& getLocale() const;
166  virtual UDialectHandling getDialectHandling() const;
167
168  virtual UnicodeString& localeDisplayName(const Locale& locale,
169                                           UnicodeString& result) const;
170  virtual UnicodeString& localeDisplayName(const char* localeId,
171                                           UnicodeString& result) const;
172  virtual UnicodeString& languageDisplayName(const char* lang,
173                                             UnicodeString& result) const;
174  virtual UnicodeString& scriptDisplayName(const char* script,
175                                           UnicodeString& result) const;
176  virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
177                                           UnicodeString& result) const;
178  virtual UnicodeString& regionDisplayName(const char* region,
179                                           UnicodeString& result) const;
180  virtual UnicodeString& variantDisplayName(const char* variant,
181                                            UnicodeString& result) const;
182  virtual UnicodeString& keyDisplayName(const char* key,
183                                        UnicodeString& result) const;
184  virtual UnicodeString& keyValueDisplayName(const char* key,
185                                             const char* value,
186                                             UnicodeString& result) const;
187};
188
189DefaultLocaleDisplayNames::DefaultLocaleDisplayNames(UDialectHandling dialectHandling)
190    : dialectHandling(dialectHandling) {
191}
192
193DefaultLocaleDisplayNames::~DefaultLocaleDisplayNames() {
194}
195
196const Locale&
197DefaultLocaleDisplayNames::getLocale() const {
198  return Locale::getRoot();
199}
200
201UDialectHandling
202DefaultLocaleDisplayNames::getDialectHandling() const {
203  return dialectHandling;
204}
205
206UnicodeString&
207DefaultLocaleDisplayNames::localeDisplayName(const Locale& locale,
208                                             UnicodeString& result) const {
209  return result = UnicodeString(locale.getName(), -1, US_INV);
210}
211
212UnicodeString&
213DefaultLocaleDisplayNames::localeDisplayName(const char* localeId,
214                                             UnicodeString& result) const {
215  return result = UnicodeString(localeId, -1, US_INV);
216}
217
218UnicodeString&
219DefaultLocaleDisplayNames::languageDisplayName(const char* lang,
220                                               UnicodeString& result) const {
221  return result = UnicodeString(lang, -1, US_INV);
222}
223
224UnicodeString&
225DefaultLocaleDisplayNames::scriptDisplayName(const char* script,
226                                             UnicodeString& result) const {
227  return result = UnicodeString(script, -1, US_INV);
228}
229
230UnicodeString&
231DefaultLocaleDisplayNames::scriptDisplayName(UScriptCode scriptCode,
232                                             UnicodeString& result) const {
233  const char* name = uscript_getName(scriptCode);
234  if (name) {
235    return result = UnicodeString(name, -1, US_INV);
236  }
237  return result.remove();
238}
239
240UnicodeString&
241DefaultLocaleDisplayNames::regionDisplayName(const char* region,
242                                             UnicodeString& result) const {
243  return result = UnicodeString(region, -1, US_INV);
244}
245
246UnicodeString&
247DefaultLocaleDisplayNames::variantDisplayName(const char* variant,
248                                              UnicodeString& result) const {
249  return result = UnicodeString(variant, -1, US_INV);
250}
251
252UnicodeString&
253DefaultLocaleDisplayNames::keyDisplayName(const char* key,
254                                          UnicodeString& result) const {
255  return result = UnicodeString(key, -1, US_INV);
256}
257
258UnicodeString&
259DefaultLocaleDisplayNames::keyValueDisplayName(const char* /* key */,
260                                               const char* value,
261                                               UnicodeString& result) const {
262  return result = UnicodeString(value, -1, US_INV);
263}
264
265#endif  // currently unused class DefaultLocaleDisplayNames
266
267////////////////////////////////////////////////////////////////////////////////////////////////////
268
269class LocaleDisplayNamesImpl : public LocaleDisplayNames {
270    Locale locale;
271    UDialectHandling dialectHandling;
272    ICUDataTable langData;
273    ICUDataTable regionData;
274    UnicodeString sep;
275    MessageFormat *format;
276    MessageFormat *keyTypeFormat;
277    UDisplayContext capitalizationContext;
278
279    // Constants for capitalization context usage types.
280    enum CapContextUsage {
281        kCapContextUsageLanguage,
282        kCapContextUsageScript,
283        kCapContextUsageTerritory,
284        kCapContextUsageVariant,
285        kCapContextUsageKey,
286        kCapContextUsageType,
287        kCapContextUsageCount
288    };
289    // Capitalization transforms. For each usage type, the first array element indicates
290    // whether to titlecase for uiListOrMenu context, the second indicates whether to
291    // titlecase for stand-alone context.
292     UBool fCapitalization[kCapContextUsageCount][2];
293
294public:
295    // constructor
296    LocaleDisplayNamesImpl(const Locale& locale, UDialectHandling dialectHandling);
297    LocaleDisplayNamesImpl(const Locale& locale, UDisplayContext *contexts, int32_t length);
298    virtual ~LocaleDisplayNamesImpl();
299
300    virtual const Locale& getLocale() const;
301    virtual UDialectHandling getDialectHandling() const;
302    virtual UDisplayContext getContext(UDisplayContextType type) const;
303
304    virtual UnicodeString& localeDisplayName(const Locale& locale,
305                                                UnicodeString& result) const;
306    virtual UnicodeString& localeDisplayName(const char* localeId,
307                                                UnicodeString& result) const;
308    virtual UnicodeString& languageDisplayName(const char* lang,
309                                               UnicodeString& result) const;
310    virtual UnicodeString& scriptDisplayName(const char* script,
311                                                UnicodeString& result) const;
312    virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
313                                                UnicodeString& result) const;
314    virtual UnicodeString& regionDisplayName(const char* region,
315                                                UnicodeString& result) const;
316    virtual UnicodeString& variantDisplayName(const char* variant,
317                                                UnicodeString& result) const;
318    virtual UnicodeString& keyDisplayName(const char* key,
319                                                UnicodeString& result) const;
320    virtual UnicodeString& keyValueDisplayName(const char* key,
321                                                const char* value,
322                                                UnicodeString& result) const;
323private:
324    UnicodeString& localeIdName(const char* localeId,
325                                UnicodeString& result) const;
326    UnicodeString& appendWithSep(UnicodeString& buffer, const UnicodeString& src) const;
327    UnicodeString& adjustForUsageAndContext(CapContextUsage usage, UnicodeString& result) const;
328    void initialize(void);
329};
330
331LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,
332                                               UDialectHandling dialectHandling)
333    : dialectHandling(dialectHandling)
334    , langData(U_ICUDATA_LANG, locale)
335    , regionData(U_ICUDATA_REGION, locale)
336    , format(NULL)
337    , keyTypeFormat(NULL)
338    , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
339{
340    initialize();
341}
342
343LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,
344                                               UDisplayContext *contexts, int32_t length)
345    : dialectHandling(ULDN_STANDARD_NAMES)
346    , langData(U_ICUDATA_LANG, locale)
347    , regionData(U_ICUDATA_REGION, locale)
348    , format(NULL)
349    , keyTypeFormat(NULL)
350    , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
351{
352    while (length-- > 0) {
353        UDisplayContext value = *contexts++;
354        UDisplayContextType selector = (UDisplayContextType)((uint32_t)value >> 8);
355        switch (selector) {
356            case UDISPCTX_TYPE_DIALECT_HANDLING:
357                dialectHandling = (UDialectHandling)value;
358                break;
359            case UDISPCTX_TYPE_CAPITALIZATION:
360                capitalizationContext = value;
361                break;
362            default:
363                break;
364        }
365    }
366    initialize();
367}
368
369void
370LocaleDisplayNamesImpl::initialize(void) {
371    LocaleDisplayNamesImpl *nonConstThis = (LocaleDisplayNamesImpl *)this;
372    nonConstThis->locale = langData.getLocale() == Locale::getRoot()
373        ? regionData.getLocale()
374        : langData.getLocale();
375
376    langData.getNoFallback("localeDisplayPattern", "separator", sep);
377    if (sep.isBogus()) {
378        sep = UnicodeString(", ", -1, US_INV);
379    }
380
381    UnicodeString pattern;
382    langData.getNoFallback("localeDisplayPattern", "pattern", pattern);
383    if (pattern.isBogus()) {
384        pattern = UnicodeString("{0} ({1})", -1, US_INV);
385    }
386    UErrorCode status = U_ZERO_ERROR;
387    format = new MessageFormat(pattern, status);
388
389    UnicodeString ktPattern;
390    langData.get("localeDisplayPattern", "keyTypePattern", ktPattern);
391    if (ktPattern.isBogus()) {
392        ktPattern = UnicodeString("{0}={1}", -1, US_INV);
393    }
394    keyTypeFormat = new MessageFormat(ktPattern, status);
395
396    uprv_memset(fCapitalization, 0, sizeof(fCapitalization));
397#if !UCONFIG_NO_BREAK_ITERATION
398    // The following is basically copied from DateFormatSymbols::initializeData
399    typedef struct {
400        const char * usageName;
401        LocaleDisplayNamesImpl::CapContextUsage usageEnum;
402    } ContextUsageNameToEnum;
403    const ContextUsageNameToEnum contextUsageTypeMap[] = {
404       // Entries must be sorted by usageTypeName; entry with NULL name terminates list.
405        { "key",        kCapContextUsageKey },
406        { "languages",  kCapContextUsageLanguage },
407        { "script",     kCapContextUsageScript },
408        { "territory",  kCapContextUsageTerritory },
409        { "type",       kCapContextUsageType },
410        { "variant",    kCapContextUsageVariant },
411        { NULL,         (CapContextUsage)0 },
412    };
413    int32_t len = 0;
414    UResourceBundle *localeBundle = ures_open(NULL, locale.getName(), &status);
415    if (U_SUCCESS(status)) {
416        UResourceBundle *contextTransforms = ures_getByKeyWithFallback(localeBundle, "contextTransforms", NULL, &status);
417        if (U_SUCCESS(status)) {
418            UResourceBundle *contextTransformUsage;
419            while ( (contextTransformUsage = ures_getNextResource(contextTransforms, NULL, &status)) != NULL ) {
420                const int32_t * intVector = ures_getIntVector(contextTransformUsage, &len, &status);
421                if (U_SUCCESS(status) && intVector != NULL && len >= 2) {
422                    const char* usageKey = ures_getKey(contextTransformUsage);
423                    if (usageKey != NULL) {
424                        const ContextUsageNameToEnum * typeMapPtr = contextUsageTypeMap;
425                        int32_t compResult = 0;
426                        // linear search; list is short and we cannot be sure that bsearch is available
427                        while ( typeMapPtr->usageName != NULL && (compResult = uprv_strcmp(usageKey, typeMapPtr->usageName)) > 0 ) {
428                            ++typeMapPtr;
429                        }
430                        if (typeMapPtr->usageName != NULL && compResult == 0) {
431                            fCapitalization[typeMapPtr->usageEnum][0] = intVector[0];
432                            fCapitalization[typeMapPtr->usageEnum][1] = intVector[1];
433                        }
434                    }
435                }
436                status = U_ZERO_ERROR;
437                ures_close(contextTransformUsage);
438            }
439            ures_close(contextTransforms);
440        }
441        ures_close(localeBundle);
442    }
443#endif
444}
445
446LocaleDisplayNamesImpl::~LocaleDisplayNamesImpl() {
447    delete format;
448    delete keyTypeFormat;
449 }
450
451const Locale&
452LocaleDisplayNamesImpl::getLocale() const {
453    return locale;
454}
455
456UDialectHandling
457LocaleDisplayNamesImpl::getDialectHandling() const {
458    return dialectHandling;
459}
460
461UDisplayContext
462LocaleDisplayNamesImpl::getContext(UDisplayContextType type) const {
463    switch (type) {
464        case UDISPCTX_TYPE_DIALECT_HANDLING:
465            return (UDisplayContext)dialectHandling;
466        case UDISPCTX_TYPE_CAPITALIZATION:
467            return capitalizationContext;
468        default:
469            break;
470    }
471    return (UDisplayContext)0;
472}
473
474UnicodeString&
475LocaleDisplayNamesImpl::adjustForUsageAndContext(CapContextUsage usage,
476                                                UnicodeString& result) const {
477#if !UCONFIG_NO_BREAK_ITERATION
478    // check to see whether we need to titlecase result
479    UBool titlecase = FALSE;
480    switch (capitalizationContext) {
481        case UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE:
482            titlecase = TRUE;
483            break;
484        case UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU:
485            titlecase = fCapitalization[usage][0];
486            break;
487        case UDISPCTX_CAPITALIZATION_FOR_STANDALONE:
488            titlecase = fCapitalization[usage][1];
489            break;
490        default:
491            // titlecase = FALSE;
492            break;
493    }
494    if (titlecase) {
495        // TODO: Fix this titlecase hack when we figure out something better to do.
496        // We don't want to titlecase the whole text, only something like the first word,
497        // of the first segment long enough to have a complete cluster, whichever is
498        // shorter. We could have keep a word break iterator around, but I am not sure
499        // that will do the ight thing for the purposes here. For now we assume that in
500        // languages for which titlecasing makes a difference, we can stop at non-letter
501        // characters in 0x0000-0x00FF and only titlecase up to the first occurrence of
502        // any of those, or to a small number of chars, whichever comes first.
503        int32_t stopPos, stopPosLimit = 8, len = result.length();
504        if ( stopPosLimit > len ) {
505            stopPosLimit = len;
506        }
507        for ( stopPos = 0; stopPos < stopPosLimit; stopPos++ ) {
508            UChar32 ch = result.char32At(stopPos);
509            if ( (ch < 0x41) || (ch > 0x5A && ch < 0x61) || (ch > 0x7A && ch < 0xC0) ) {
510                break;
511            }
512            if (ch >= 0x10000) {
513                stopPos++;
514            }
515        }
516        if ( stopPos > 0 && stopPos < len ) {
517            UnicodeString firstWord(result, 0, stopPos);
518            firstWord.toTitle(NULL, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
519            result.replaceBetween(0, stopPos, firstWord);
520        } else {
521            // no stopPos, titlecase the whole text
522            result.toTitle(NULL, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
523        }
524    }
525#endif
526    return result;
527}
528
529UnicodeString&
530LocaleDisplayNamesImpl::localeDisplayName(const Locale& locale,
531                                          UnicodeString& result) const {
532  UnicodeString resultName;
533
534  const char* lang = locale.getLanguage();
535  if (uprv_strlen(lang) == 0) {
536    lang = "root";
537  }
538  const char* script = locale.getScript();
539  const char* country = locale.getCountry();
540  const char* variant = locale.getVariant();
541
542  UBool hasScript = uprv_strlen(script) > 0;
543  UBool hasCountry = uprv_strlen(country) > 0;
544  UBool hasVariant = uprv_strlen(variant) > 0;
545
546  if (dialectHandling == ULDN_DIALECT_NAMES) {
547    char buffer[ULOC_FULLNAME_CAPACITY];
548    do { // loop construct is so we can break early out of search
549      if (hasScript && hasCountry) {
550        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, "_", country, (char *)0);
551        localeIdName(buffer, resultName);
552        if (!resultName.isBogus()) {
553          hasScript = FALSE;
554          hasCountry = FALSE;
555          break;
556        }
557      }
558      if (hasScript) {
559        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, (char *)0);
560        localeIdName(buffer, resultName);
561        if (!resultName.isBogus()) {
562          hasScript = FALSE;
563          break;
564        }
565      }
566      if (hasCountry) {
567        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", country, (char*)0);
568        localeIdName(buffer, resultName);
569        if (!resultName.isBogus()) {
570          hasCountry = FALSE;
571          break;
572        }
573      }
574    } while (FALSE);
575  }
576  if (resultName.isBogus() || resultName.isEmpty()) {
577    localeIdName(lang, resultName);
578  }
579
580  UnicodeString resultRemainder;
581  UnicodeString temp;
582  StringEnumeration *e = NULL;
583  UErrorCode status = U_ZERO_ERROR;
584
585  if (hasScript) {
586    resultRemainder.append(scriptDisplayName(script, temp));
587  }
588  if (hasCountry) {
589    appendWithSep(resultRemainder, regionDisplayName(country, temp));
590  }
591  if (hasVariant) {
592    appendWithSep(resultRemainder, variantDisplayName(variant, temp));
593  }
594
595  e = locale.createKeywords(status);
596  if (e && U_SUCCESS(status)) {
597    UnicodeString temp2;
598    char value[ULOC_KEYWORD_AND_VALUES_CAPACITY]; // sigh, no ULOC_VALUE_CAPACITY
599    const char* key;
600    while ((key = e->next((int32_t *)0, status)) != NULL) {
601      locale.getKeywordValue(key, value, ULOC_KEYWORD_AND_VALUES_CAPACITY, status);
602      keyDisplayName(key, temp);
603      keyValueDisplayName(key, value, temp2);
604      if (temp2 != UnicodeString(value, -1, US_INV)) {
605        appendWithSep(resultRemainder, temp2);
606      } else if (temp != UnicodeString(key, -1, US_INV)) {
607        UnicodeString temp3;
608        Formattable data[] = {
609          temp,
610          temp2
611        };
612        FieldPosition fpos;
613        status = U_ZERO_ERROR;
614        keyTypeFormat->format(data, 2, temp3, fpos, status);
615        appendWithSep(resultRemainder, temp3);
616      } else {
617        appendWithSep(resultRemainder, temp)
618          .append((UChar)0x3d /* = */)
619          .append(temp2);
620      }
621    }
622    delete e;
623  }
624
625  if (!resultRemainder.isEmpty()) {
626    Formattable data[] = {
627      resultName,
628      resultRemainder
629    };
630    FieldPosition fpos;
631    status = U_ZERO_ERROR;
632    format->format(data, 2, result, fpos, status);
633    return adjustForUsageAndContext(kCapContextUsageLanguage, result);
634  }
635
636  result = resultName;
637  return adjustForUsageAndContext(kCapContextUsageLanguage, result);
638}
639
640UnicodeString&
641LocaleDisplayNamesImpl::appendWithSep(UnicodeString& buffer, const UnicodeString& src) const {
642    if (!buffer.isEmpty()) {
643        buffer.append(sep);
644    }
645    buffer.append(src);
646    return buffer;
647}
648
649UnicodeString&
650LocaleDisplayNamesImpl::localeDisplayName(const char* localeId,
651                                          UnicodeString& result) const {
652    return localeDisplayName(Locale(localeId), result);
653}
654
655// private
656UnicodeString&
657LocaleDisplayNamesImpl::localeIdName(const char* localeId,
658                                     UnicodeString& result) const {
659    return langData.getNoFallback("Languages", localeId, result);
660}
661
662UnicodeString&
663LocaleDisplayNamesImpl::languageDisplayName(const char* lang,
664                                            UnicodeString& result) const {
665    if (uprv_strcmp("root", lang) == 0 || uprv_strchr(lang, '_') != NULL) {
666        return result = UnicodeString(lang, -1, US_INV);
667    }
668    langData.get("Languages", lang, result);
669    return adjustForUsageAndContext(kCapContextUsageLanguage, result);
670}
671
672UnicodeString&
673LocaleDisplayNamesImpl::scriptDisplayName(const char* script,
674                                          UnicodeString& result) const {
675    langData.get("Scripts", script, result);
676    return adjustForUsageAndContext(kCapContextUsageScript, result);
677}
678
679UnicodeString&
680LocaleDisplayNamesImpl::scriptDisplayName(UScriptCode scriptCode,
681                                          UnicodeString& result) const {
682    const char* name = uscript_getName(scriptCode);
683    langData.get("Scripts", name, result);
684    return adjustForUsageAndContext(kCapContextUsageScript, result);
685}
686
687UnicodeString&
688LocaleDisplayNamesImpl::regionDisplayName(const char* region,
689                                          UnicodeString& result) const {
690    regionData.get("Countries", region, result);
691    return adjustForUsageAndContext(kCapContextUsageTerritory, result);
692}
693
694UnicodeString&
695LocaleDisplayNamesImpl::variantDisplayName(const char* variant,
696                                           UnicodeString& result) const {
697    langData.get("Variants", variant, result);
698    return adjustForUsageAndContext(kCapContextUsageVariant, result);
699}
700
701UnicodeString&
702LocaleDisplayNamesImpl::keyDisplayName(const char* key,
703                                       UnicodeString& result) const {
704    langData.get("Keys", key, result);
705    return adjustForUsageAndContext(kCapContextUsageKey, result);
706}
707
708UnicodeString&
709LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,
710                                            const char* value,
711                                            UnicodeString& result) const {
712    langData.get("Types", key, value, result);
713    return adjustForUsageAndContext(kCapContextUsageType, result);
714}
715
716////////////////////////////////////////////////////////////////////////////////////////////////////
717
718LocaleDisplayNames*
719LocaleDisplayNames::createInstance(const Locale& locale,
720                                   UDialectHandling dialectHandling) {
721    return new LocaleDisplayNamesImpl(locale, dialectHandling);
722}
723
724LocaleDisplayNames*
725LocaleDisplayNames::createInstance(const Locale& locale,
726                                   UDisplayContext *contexts, int32_t length) {
727    if (contexts == NULL) {
728        length = 0;
729    }
730    return new LocaleDisplayNamesImpl(locale, contexts, length);
731}
732
733U_NAMESPACE_END
734
735////////////////////////////////////////////////////////////////////////////////////////////////////
736
737U_NAMESPACE_USE
738
739U_CAPI ULocaleDisplayNames * U_EXPORT2
740uldn_open(const char * locale,
741          UDialectHandling dialectHandling,
742          UErrorCode *pErrorCode) {
743  if (U_FAILURE(*pErrorCode)) {
744    return 0;
745  }
746  if (locale == NULL) {
747    locale = uloc_getDefault();
748  }
749  return (ULocaleDisplayNames *)LocaleDisplayNames::createInstance(Locale(locale), dialectHandling);
750}
751
752U_CAPI ULocaleDisplayNames * U_EXPORT2
753uldn_openForContext(const char * locale,
754                    UDisplayContext *contexts, int32_t length,
755                    UErrorCode *pErrorCode) {
756  if (U_FAILURE(*pErrorCode)) {
757    return 0;
758  }
759  if (locale == NULL) {
760    locale = uloc_getDefault();
761  }
762  return (ULocaleDisplayNames *)LocaleDisplayNames::createInstance(Locale(locale), contexts, length);
763}
764
765
766U_CAPI void U_EXPORT2
767uldn_close(ULocaleDisplayNames *ldn) {
768  delete (LocaleDisplayNames *)ldn;
769}
770
771U_CAPI const char * U_EXPORT2
772uldn_getLocale(const ULocaleDisplayNames *ldn) {
773  if (ldn) {
774    return ((const LocaleDisplayNames *)ldn)->getLocale().getName();
775  }
776  return NULL;
777}
778
779U_CAPI UDialectHandling U_EXPORT2
780uldn_getDialectHandling(const ULocaleDisplayNames *ldn) {
781  if (ldn) {
782    return ((const LocaleDisplayNames *)ldn)->getDialectHandling();
783  }
784  return ULDN_STANDARD_NAMES;
785}
786
787U_CAPI UDisplayContext U_EXPORT2
788uldn_getContext(const ULocaleDisplayNames *ldn,
789              UDisplayContextType type,
790              UErrorCode *pErrorCode) {
791  if (U_FAILURE(*pErrorCode)) {
792    return (UDisplayContext)0;
793  }
794  return ((const LocaleDisplayNames *)ldn)->getContext(type);
795}
796
797U_CAPI int32_t U_EXPORT2
798uldn_localeDisplayName(const ULocaleDisplayNames *ldn,
799                       const char *locale,
800                       UChar *result,
801                       int32_t maxResultSize,
802                       UErrorCode *pErrorCode) {
803  if (U_FAILURE(*pErrorCode)) {
804    return 0;
805  }
806  if (ldn == NULL || locale == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
807    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
808    return 0;
809  }
810  UnicodeString temp(result, 0, maxResultSize);
811  ((const LocaleDisplayNames *)ldn)->localeDisplayName(locale, temp);
812  return temp.extract(result, maxResultSize, *pErrorCode);
813}
814
815U_CAPI int32_t U_EXPORT2
816uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
817                         const char *lang,
818                         UChar *result,
819                         int32_t maxResultSize,
820                         UErrorCode *pErrorCode) {
821  if (U_FAILURE(*pErrorCode)) {
822    return 0;
823  }
824  if (ldn == NULL || lang == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
825    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
826    return 0;
827  }
828  UnicodeString temp(result, 0, maxResultSize);
829  ((const LocaleDisplayNames *)ldn)->languageDisplayName(lang, temp);
830  return temp.extract(result, maxResultSize, *pErrorCode);
831}
832
833U_CAPI int32_t U_EXPORT2
834uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
835                       const char *script,
836                       UChar *result,
837                       int32_t maxResultSize,
838                       UErrorCode *pErrorCode) {
839  if (U_FAILURE(*pErrorCode)) {
840    return 0;
841  }
842  if (ldn == NULL || script == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
843    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
844    return 0;
845  }
846  UnicodeString temp(result, 0, maxResultSize);
847  ((const LocaleDisplayNames *)ldn)->scriptDisplayName(script, temp);
848  return temp.extract(result, maxResultSize, *pErrorCode);
849}
850
851U_CAPI int32_t U_EXPORT2
852uldn_scriptCodeDisplayName(const ULocaleDisplayNames *ldn,
853                           UScriptCode scriptCode,
854                           UChar *result,
855                           int32_t maxResultSize,
856                           UErrorCode *pErrorCode) {
857  return uldn_scriptDisplayName(ldn, uscript_getName(scriptCode), result, maxResultSize, pErrorCode);
858}
859
860U_CAPI int32_t U_EXPORT2
861uldn_regionDisplayName(const ULocaleDisplayNames *ldn,
862                       const char *region,
863                       UChar *result,
864                       int32_t maxResultSize,
865                       UErrorCode *pErrorCode) {
866  if (U_FAILURE(*pErrorCode)) {
867    return 0;
868  }
869  if (ldn == NULL || region == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
870    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
871    return 0;
872  }
873  UnicodeString temp(result, 0, maxResultSize);
874  ((const LocaleDisplayNames *)ldn)->regionDisplayName(region, temp);
875  return temp.extract(result, maxResultSize, *pErrorCode);
876}
877
878U_CAPI int32_t U_EXPORT2
879uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
880                        const char *variant,
881                        UChar *result,
882                        int32_t maxResultSize,
883                        UErrorCode *pErrorCode) {
884  if (U_FAILURE(*pErrorCode)) {
885    return 0;
886  }
887  if (ldn == NULL || variant == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
888    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
889    return 0;
890  }
891  UnicodeString temp(result, 0, maxResultSize);
892  ((const LocaleDisplayNames *)ldn)->variantDisplayName(variant, temp);
893  return temp.extract(result, maxResultSize, *pErrorCode);
894}
895
896U_CAPI int32_t U_EXPORT2
897uldn_keyDisplayName(const ULocaleDisplayNames *ldn,
898                    const char *key,
899                    UChar *result,
900                    int32_t maxResultSize,
901                    UErrorCode *pErrorCode) {
902  if (U_FAILURE(*pErrorCode)) {
903    return 0;
904  }
905  if (ldn == NULL || key == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
906    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
907    return 0;
908  }
909  UnicodeString temp(result, 0, maxResultSize);
910  ((const LocaleDisplayNames *)ldn)->keyDisplayName(key, temp);
911  return temp.extract(result, maxResultSize, *pErrorCode);
912}
913
914U_CAPI int32_t U_EXPORT2
915uldn_keyValueDisplayName(const ULocaleDisplayNames *ldn,
916                         const char *key,
917                         const char *value,
918                         UChar *result,
919                         int32_t maxResultSize,
920                         UErrorCode *pErrorCode) {
921  if (U_FAILURE(*pErrorCode)) {
922    return 0;
923  }
924  if (ldn == NULL || key == NULL || value == NULL || (result == NULL && maxResultSize > 0)
925      || maxResultSize < 0) {
926    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
927    return 0;
928  }
929  UnicodeString temp(result, 0, maxResultSize);
930  ((const LocaleDisplayNames *)ldn)->keyValueDisplayName(key, value, temp);
931  return temp.extract(result, maxResultSize, *pErrorCode);
932}
933
934#endif
935