tor-browser

locresdata.cpp (7809B)

---

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright (C) 1997-2012, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  loclikely.cpp
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2010feb25
*   created by: Markus W. Scherer
*
*   Code for miscellaneous locale-related resource bundle data access,
*   separated out from other .cpp files
*   that then do not depend on resource bundle code and this data.
*/

#include "unicode/utypes.h"
#include "unicode/putil.h"
#include "unicode/uloc.h"
#include "unicode/ures.h"
#include "charstr.h"
#include "cstring.h"
#include "ulocimp.h"
#include "uresimp.h"

/*
* Lookup a resource bundle table item with fallback on the table level.
* Regular resource bundle lookups perform fallback to parent locale bundles
* and eventually the root bundle, but only for top-level items.
* This function takes the name of a top-level table and of an item in that table
* and performs a lookup of both, falling back until a bundle contains a table
* with this item.
*
* Note: Only the opening of entire bundles falls back through the default locale
* before root. Once a bundle is open, item lookups do not go through the
* default locale because that would result in a mix of languages that is
* unpredictable to the programmer and most likely useless.
*/
U_CAPI const char16_t * U_EXPORT2
uloc_getTableStringWithFallback(const char *path, const char *locale,
                             const char *tableKey, const char *subTableKey,
                             const char *itemKey,
                             int32_t *pLength,
                             UErrorCode *pErrorCode)
{
   if (U_FAILURE(*pErrorCode)) { return nullptr; }
/*    char localeBuffer[ULOC_FULLNAME_CAPACITY*4];*/
   const char16_t *item=nullptr;
   UErrorCode errorCode;

   /*
    * open the bundle for the current locale
    * this falls back through the locale's chain to root
    */
   errorCode=U_ZERO_ERROR;
   icu::LocalUResourceBundlePointer rb(ures_open(path, locale, &errorCode));

   if(U_FAILURE(errorCode)) {
       /* total failure, not even root could be opened */
       *pErrorCode=errorCode;
       return nullptr;
   } else if(errorCode==U_USING_DEFAULT_WARNING ||
               (errorCode==U_USING_FALLBACK_WARNING && *pErrorCode!=U_USING_DEFAULT_WARNING)
   ) {
       /* set the "strongest" error code (success->fallback->default->failure) */
       *pErrorCode=errorCode;
   }

   for(;;){
       icu::StackUResourceBundle table;
       icu::StackUResourceBundle subTable;
       ures_getByKeyWithFallback(rb.getAlias(), tableKey, table.getAlias(), &errorCode);

       if (subTableKey != nullptr) {
           /*
           ures_getByKeyWithFallback(table.getAlias(), subTableKey, subTable.getAlias(), &errorCode);
           item = ures_getStringByKeyWithFallback(subTable.getAlias(), itemKey, pLength, &errorCode);
           if(U_FAILURE(errorCode)){
               *pErrorCode = errorCode;
           }
           
           break;*/
           
           ures_getByKeyWithFallback(table.getAlias(), subTableKey, table.getAlias(), &errorCode);
       }
       if(U_SUCCESS(errorCode)){
           item = ures_getStringByKeyWithFallback(table.getAlias(), itemKey, pLength, &errorCode);
           if(U_FAILURE(errorCode)){
               const char* replacement = nullptr;
               *pErrorCode = errorCode; /*save the errorCode*/
               errorCode = U_ZERO_ERROR;
               /* may be a deprecated code */
               if(uprv_strcmp(tableKey, "Countries")==0){
                   replacement =  uloc_getCurrentCountryID(itemKey);
               }else if(uprv_strcmp(tableKey, "Languages")==0){
                   replacement =  uloc_getCurrentLanguageID(itemKey);
               }
               /*pointer comparison is ok since uloc_getCurrentCountryID & uloc_getCurrentLanguageID return the key itself is replacement is not found*/
               if(replacement!=nullptr && itemKey != replacement){
                   item = ures_getStringByKeyWithFallback(table.getAlias(), replacement, pLength, &errorCode);
                   if(U_SUCCESS(errorCode)){
                       *pErrorCode = errorCode;
                       break;
                   }
               }
           }else{
               break;
           }
       }
       
       if(U_FAILURE(errorCode)){    

           /* still can't figure out ?.. try the fallback mechanism */
           int32_t len = 0;
           const char16_t* fallbackLocale =  nullptr;
           *pErrorCode = errorCode;
           errorCode = U_ZERO_ERROR;

           fallbackLocale = ures_getStringByKeyWithFallback(table.getAlias(), "Fallback", &len, &errorCode);
           if(U_FAILURE(errorCode)){
              *pErrorCode = errorCode;
               break;
           }

           icu::CharString explicitFallbackName;
           explicitFallbackName.appendInvariantChars(fallbackLocale, len, errorCode);

           /* guard against recursive fallback */
           if (explicitFallbackName == locale) {
               *pErrorCode = U_INTERNAL_PROGRAM_ERROR;
               break;
           }
           rb.adoptInstead(ures_open(path, explicitFallbackName.data(), &errorCode));
           if(U_FAILURE(errorCode)){
               *pErrorCode = errorCode;
               break;
           }
           /* succeeded in opening the fallback bundle .. continue and try to fetch the item */
       }else{
           break;
       }
   }

   return item;
}

namespace {

ULayoutType
_uloc_getOrientationHelper(const char* localeId,
                          const char* key,
                          UErrorCode& status)
{
   ULayoutType result = ULOC_LAYOUT_UNKNOWN;

   if (U_FAILURE(status)) { return result; }

   if (localeId == nullptr) {
       localeId = uloc_getDefault();
   }
   icu::CharString localeBuffer = ulocimp_canonicalize(localeId, status);

   if (U_FAILURE(status)) { return result; }

   int32_t length = 0;
   const char16_t* const value =
       uloc_getTableStringWithFallback(
           nullptr,
           localeBuffer.data(),
           "layout",
           nullptr,
           key,
           &length,
           &status);

   if (U_FAILURE(status)) { return result; }

   if (length != 0) {
       switch(value[0])
       {
       case 0x0062: /* 'b' */
           result = ULOC_LAYOUT_BTT;
           break;
       case 0x006C: /* 'l' */
           result = ULOC_LAYOUT_LTR;
           break;
       case 0x0072: /* 'r' */
           result = ULOC_LAYOUT_RTL;
           break;
       case 0x0074: /* 't' */
           result = ULOC_LAYOUT_TTB;
           break;
       default:
           status = U_INTERNAL_PROGRAM_ERROR;
           break;
       }
   }

   return result;
}

}  // namespace

U_CAPI ULayoutType U_EXPORT2
uloc_getCharacterOrientation(const char* localeId,
                            UErrorCode *status)
{
   return _uloc_getOrientationHelper(localeId, "characters", *status);
}

/**
* Get the layout line orientation for the specified locale.
* 
* @param localeID locale name
* @param status Error status
* @return an enum indicating the layout orientation for lines.
*/
U_CAPI ULayoutType U_EXPORT2
uloc_getLineOrientation(const char* localeId,
                       UErrorCode *status)
{
   return _uloc_getOrientationHelper(localeId, "lines", *status);
}