icuSources/i18n/ulocdata.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 ******************************************************************************
   5 *                                                                            *
   6 * Copyright (C) 2003-2016, International Business Machines                   *
   7 *                Corporation and others. All Rights Reserved.                *
   8 *                                                                            *
   9 ******************************************************************************
  10 *   file name:  ulocdata.c
  11 *   encoding:   UTF-8
  12 *   tab size:   8 (not used)
  13 *   indentation:4
  14 *
  15 *   created on: 2003Oct21
  16 *   created by: Ram Viswanadha,John Emmons
  17 */
  18
  19 #include "cmemory.h"
  20 #include "unicode/ustring.h"
  21 #include "unicode/ures.h"
  22 #include "unicode/uloc.h"
  23 #include "unicode/ulocdata.h"
  24 #include "uresimp.h"
  25 #include "ureslocs.h"
  26 #include "ulocimp.h"
  27
  28 #define MEASUREMENT_SYSTEM  "MeasurementSystem"
  29 #define PAPER_SIZE          "PaperSize"
  30
  31 /** A locale data object.
  32  *  For usage in C programs.
  33  *  @draft ICU 3.4
  34  */
  35 struct ULocaleData {
  36     /**
  37      * Controls the "No Substitute" behavior of this locale data object
  38      */
  39     UBool noSubstitute;
  40
  41     /**
  42      * Pointer to the resource bundle associated with this locale data object
  43      */
  44     UResourceBundle *bundle;
  45
  46     /**
  47      * Pointer to the lang resource bundle associated with this locale data object
  48      */
  49     UResourceBundle *langBundle;
  50 };
  51
  52 U_CAPI ULocaleData* U_EXPORT2
  53 ulocdata_open(const char *localeID, UErrorCode *status)
  54 {
  55    ULocaleData *uld;
  56
  57    if (U_FAILURE(*status)) {
  58        return NULL;
  59    }
  60
  61    uld = (ULocaleData *)uprv_malloc(sizeof(ULocaleData));
  62    if (uld == NULL) {
  63       *status = U_MEMORY_ALLOCATION_ERROR;
  64       return(NULL);
  65    }
  66
  67    uld->langBundle = NULL;
  68
  69    uld->noSubstitute = FALSE;
  70    uld->bundle = ures_open(NULL, localeID, status);
  71    uld->langBundle = ures_open(U_ICUDATA_LANG, localeID, status);
  72
  73    if (U_FAILURE(*status)) {
  74       uprv_free(uld);
  75       return NULL;
  76    }
  77
  78    return uld;
  79 }
  80
  81 U_CAPI void U_EXPORT2
  82 ulocdata_close(ULocaleData *uld)
  83 {
  84     if ( uld != NULL ) {
  85        ures_close(uld->langBundle);
  86        ures_close(uld->bundle);
  87        uprv_free(uld);
  88     }
  89 }
  90
  91 U_CAPI void U_EXPORT2
  92 ulocdata_setNoSubstitute(ULocaleData *uld, UBool setting)
  93 {
  94    uld->noSubstitute = setting;
  95 }
  96
  97 U_CAPI UBool U_EXPORT2
  98 ulocdata_getNoSubstitute(ULocaleData *uld)
  99 {
 100    return uld->noSubstitute;
 101 }
 102
 103 U_CAPI USet* U_EXPORT2
 104 ulocdata_getExemplarSet(ULocaleData *uld, USet *fillIn,
 105                         uint32_t options, ULocaleDataExemplarSetType extype, UErrorCode *status){
 106
 107     static const char* const exemplarSetTypes[] = { "ExemplarCharacters",
 108                                                     "AuxExemplarCharacters",
 109                                                     "ExemplarCharactersIndex",
 110                                                     "ExemplarCharactersPunctuation"};
 111     const UChar *exemplarChars = NULL;
 112     int32_t len = 0;
 113     UErrorCode localStatus = U_ZERO_ERROR;
 114
 115     if (U_FAILURE(*status))
 116         return NULL;
 117
 118     exemplarChars = ures_getStringByKey(uld->bundle, exemplarSetTypes[extype], &len, &localStatus);
 119     if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
 120         localStatus = U_MISSING_RESOURCE_ERROR;
 121     }
 122
 123     if (localStatus != U_ZERO_ERROR) {
 124         *status = localStatus;
 125     }
 126
 127     if (U_FAILURE(*status))
 128         return NULL;
 129
 130     if(fillIn != NULL)
 131         uset_applyPattern(fillIn, exemplarChars, len,
 132                           USET_IGNORE_SPACE | options, status);
 133     else
 134         fillIn = uset_openPatternOptions(exemplarChars, len,
 135                                          USET_IGNORE_SPACE | options, status);
 136
 137     return fillIn;
 138
 139 }
 140
 141 U_CAPI int32_t U_EXPORT2
 142 ulocdata_getDelimiter(ULocaleData *uld, ULocaleDataDelimiterType type,
 143                       UChar *result, int32_t resultLength, UErrorCode *status){
 144
 145     static const char* const delimiterKeys[] =  {
 146         "quotationStart",
 147         "quotationEnd",
 148         "alternateQuotationStart",
 149         "alternateQuotationEnd"
 150     };
 151
 152     UResourceBundle *delimiterBundle;
 153     int32_t len = 0;
 154     const UChar *delimiter = NULL;
 155     UErrorCode localStatus = U_ZERO_ERROR;
 156
 157     if (U_FAILURE(*status))
 158         return 0;
 159
 160     delimiterBundle = ures_getByKey(uld->bundle, "delimiters", NULL, &localStatus);
 161
 162     if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
 163         localStatus = U_MISSING_RESOURCE_ERROR;
 164     }
 165
 166     if (localStatus != U_ZERO_ERROR) {
 167         *status = localStatus;
 168     }
 169
 170     if (U_FAILURE(*status)){
 171         ures_close(delimiterBundle);
 172         return 0;
 173     }
 174
 175     delimiter = ures_getStringByKey(delimiterBundle, delimiterKeys[type], &len, &localStatus);
 176     ures_close(delimiterBundle);
 177
 178     if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
 179         localStatus = U_MISSING_RESOURCE_ERROR;
 180     }
 181
 182     if (localStatus != U_ZERO_ERROR) {
 183         *status = localStatus;
 184     }
 185
 186     if (U_FAILURE(*status)){
 187         return 0;
 188     }
 189
 190     u_strncpy(result,delimiter, resultLength);
 191     return len;
 192 }
 193
 194 static UResourceBundle * measurementTypeBundleForLocale(const char *localeID, const char *measurementType, UErrorCode *status){
 195     char region[ULOC_COUNTRY_CAPACITY];
 196     UResourceBundle *rb;
 197     UResourceBundle *measTypeBundle = NULL;
 198
 199     ulocimp_getRegionForSupplementalData(localeID, TRUE, region, ULOC_COUNTRY_CAPACITY, status);
 200
 201     rb = ures_openDirect(NULL, "supplementalData", status);
 202     ures_getByKey(rb, "measurementData", rb, status);
 203     if (rb != NULL) {
 204         UResourceBundle *measDataBundle = ures_getByKey(rb, region, NULL, status);
 205         if (U_SUCCESS(*status)) {
 206                 measTypeBundle = ures_getByKey(measDataBundle, measurementType, NULL, status);
 207         }
 208         if (*status == U_MISSING_RESOURCE_ERROR) {
 209             *status = U_ZERO_ERROR;
 210             if (measDataBundle != NULL) {
 211                 ures_close(measDataBundle);
 212             }
 213             measDataBundle = ures_getByKey(rb, "001", NULL, status);
 214             measTypeBundle = ures_getByKey(measDataBundle, measurementType, NULL, status);
 215         }
 216         ures_close(measDataBundle);
 217     }
 218     ures_close(rb);
 219     return measTypeBundle;
 220 }
 221
 222 U_CAPI UMeasurementSystem U_EXPORT2
 223 ulocdata_getMeasurementSystem(const char *localeID, UErrorCode *status){
 224
 225     UResourceBundle* measurement=NULL;
 226     UMeasurementSystem system = UMS_LIMIT;
 227
 228     if(status == NULL || U_FAILURE(*status)){
 229         return system;
 230     }
 231
 232     measurement = measurementTypeBundleForLocale(localeID, MEASUREMENT_SYSTEM, status);
 233     system = (UMeasurementSystem) ures_getInt(measurement, status);
 234
 235     ures_close(measurement);
 236
 237     return system;
 238
 239 }
 240
 241 U_CAPI void U_EXPORT2
 242 ulocdata_getPaperSize(const char* localeID, int32_t *height, int32_t *width, UErrorCode *status){
 243     UResourceBundle* paperSizeBundle = NULL;
 244     const int32_t* paperSize=NULL;
 245     int32_t len = 0;
 246
 247     if(status == NULL || U_FAILURE(*status)){
 248         return;
 249     }
 250
 251     paperSizeBundle = measurementTypeBundleForLocale(localeID, PAPER_SIZE, status);
 252     paperSize = ures_getIntVector(paperSizeBundle, &len,  status);
 253
 254     if(U_SUCCESS(*status)){
 255         if(len < 2){
 256             *status = U_INTERNAL_PROGRAM_ERROR;
 257         }else{
 258             *height = paperSize[0];
 259             *width  = paperSize[1];
 260         }
 261     }
 262
 263     ures_close(paperSizeBundle);
 264
 265 }
 266
 267 U_CAPI void U_EXPORT2
 268 ulocdata_getCLDRVersion(UVersionInfo versionArray, UErrorCode *status) {
 269     UResourceBundle *rb = NULL;
 270     rb = ures_openDirect(NULL, "supplementalData", status);
 271     ures_getVersionByKey(rb, "cldrVersion", versionArray, status);
 272     ures_close(rb);
 273 }
 274
 275 U_CAPI int32_t U_EXPORT2
 276 ulocdata_getLocaleDisplayPattern(ULocaleData *uld,
 277                                  UChar *result,
 278                                  int32_t resultCapacity,
 279                                  UErrorCode *status) {
 280     UResourceBundle *patternBundle;
 281     int32_t len = 0;
 282     const UChar *pattern = NULL;
 283     UErrorCode localStatus = U_ZERO_ERROR;
 284
 285     if (U_FAILURE(*status))
 286         return 0;
 287
 288     patternBundle = ures_getByKey(uld->langBundle, "localeDisplayPattern", NULL, &localStatus);
 289
 290     if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
 291         localStatus = U_MISSING_RESOURCE_ERROR;
 292     }
 293
 294     if (localStatus != U_ZERO_ERROR) {
 295         *status = localStatus;
 296     }
 297
 298     if (U_FAILURE(*status)){
 299         ures_close(patternBundle);
 300         return 0;
 301     }
 302
 303     pattern = ures_getStringByKey(patternBundle, "pattern", &len, &localStatus);
 304     ures_close(patternBundle);
 305
 306     if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
 307         localStatus = U_MISSING_RESOURCE_ERROR;
 308     }
 309
 310     if (localStatus != U_ZERO_ERROR) {
 311         *status = localStatus;
 312     }
 313
 314     if (U_FAILURE(*status)){
 315         return 0;
 316     }
 317
 318     u_strncpy(result, pattern, resultCapacity);
 319     return len;
 320 }
 321
 322
 323 U_CAPI int32_t U_EXPORT2
 324 ulocdata_getLocaleSeparator(ULocaleData *uld,
 325                             UChar *result,
 326                             int32_t resultCapacity,
 327                             UErrorCode *status)  {
 328     UResourceBundle *separatorBundle;
 329     int32_t len = 0;
 330     const UChar *separator = NULL;
 331     UErrorCode localStatus = U_ZERO_ERROR;
 332     UChar *p0, *p1;
 333     static const UChar sub0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 }; /* {0} */
 334     static const UChar sub1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 }; /* {1} */
 335     static const int32_t subLen = 3;
 336
 337     if (U_FAILURE(*status))
 338         return 0;
 339
 340     separatorBundle = ures_getByKey(uld->langBundle, "localeDisplayPattern", NULL, &localStatus);
 341
 342     if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
 343         localStatus = U_MISSING_RESOURCE_ERROR;
 344     }
 345
 346     if (localStatus != U_ZERO_ERROR) {
 347         *status = localStatus;
 348     }
 349
 350     if (U_FAILURE(*status)){
 351         ures_close(separatorBundle);
 352         return 0;
 353     }
 354
 355     separator = ures_getStringByKey(separatorBundle, "separator", &len, &localStatus);
 356     ures_close(separatorBundle);
 357
 358     if ( (localStatus == U_USING_DEFAULT_WARNING) && uld->noSubstitute ) {
 359         localStatus = U_MISSING_RESOURCE_ERROR;
 360     }
 361
 362     if (localStatus != U_ZERO_ERROR) {
 363         *status = localStatus;
 364     }
 365
 366     if (U_FAILURE(*status)){
 367         return 0;
 368     }
 369
 370     /* For backwards compatibility, if we have a pattern, return the portion between {0} and {1} */
 371     p0=u_strstr(separator, sub0);
 372     p1=u_strstr(separator, sub1);
 373     if (p0!=NULL && p1!=NULL && p0<=p1) {
 374         separator = (const UChar *)p0 + subLen;
 375         len = p1 - separator;
 376         /* Desired separator is no longer zero-terminated; handle that if necessary */
 377         if (len < resultCapacity) {
 378             u_strncpy(result, separator, len);
 379             result[len] = 0;
 380             return len;
 381         }
 382     }
 383
 384     u_strncpy(result, separator, resultCapacity);
 385     return len;
 386 }