unotools/source/i18n/localedatawrapper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <limits>
  21 #include <stdio.h>
  22 #include <string>
  23
  24 #include <sal/log.hxx>
  25 #include <unotools/localedatawrapper.hxx>
  26 #include <unotools/digitgroupingiterator.hxx>
  27 #include <comphelper/diagnose_ex.hxx>
  28 #include <tools/debug.hxx>
  29 #include <i18nlangtag/languagetag.hxx>
  30 #include <o3tl/safeint.hxx>
  31
  32 #include <com/sun/star/i18n/KNumberFormatUsage.hpp>
  33 #include <com/sun/star/i18n/KNumberFormatType.hpp>
  34 #include <com/sun/star/i18n/LocaleData2.hpp>
  35 #include <com/sun/star/i18n/NumberFormatIndex.hpp>
  36 #include <com/sun/star/i18n/NumberFormatMapper.hpp>
  37
  38 #include <comphelper/processfactory.hxx>
  39 #include <comphelper/sequence.hxx>
  40 #include <rtl/ustrbuf.hxx>
  41 #include <rtl/math.hxx>
  42 #include <tools/date.hxx>
  43 #include <tools/time.hxx>
  44 #include <o3tl/string_view.hxx>
  45 #include <utility>
  46
  47 const sal_uInt16 nCurrFormatDefault = 0;
  48
  49 using namespace ::com::sun::star;
  50 using namespace ::com::sun::star::i18n;
  51 using namespace ::com::sun::star::uno;
  52
  53 namespace
  54 {
  55     uno::Sequence< lang::Locale > gInstalledLocales;
  56     std::vector< LanguageType > gInstalledLanguageTypes;
  57 }
  58
  59 sal_uInt8 LocaleDataWrapper::nLocaleDataChecking = 0;
  60
  61 LocaleDataWrapper::LocaleDataWrapper(
  62             const Reference< uno::XComponentContext > & rxContext,
  63             LanguageTag aLanguageTag
  64             )
  65         :
  66         m_xContext( rxContext ),
  67         xLD( LocaleData2::create(rxContext) ),
  68         maLanguageTag(std::move( aLanguageTag ))
  69 {
  70     loadData();
  71     loadDateAcceptancePatterns({});
  72 }
  73
  74 LocaleDataWrapper::LocaleDataWrapper(
  75             LanguageTag aLanguageTag,
  76             const std::vector<OUString> & rOverrideDateAcceptancePatterns
  77             )
  78         :
  79         m_xContext( comphelper::getProcessComponentContext() ),
  80         xLD( LocaleData2::create(m_xContext) ),
  81         maLanguageTag(std::move( aLanguageTag ))
  82 {
  83     loadData();
  84     loadDateAcceptancePatterns(rOverrideDateAcceptancePatterns);
  85 }
  86
  87 LocaleDataWrapper::~LocaleDataWrapper()
  88 {
  89 }
  90
  91 const LanguageTag& LocaleDataWrapper::getLanguageTag() const
  92 {
  93     return maLanguageTag;
  94 }
  95
  96 const css::lang::Locale& LocaleDataWrapper::getMyLocale() const
  97 {
  98     return maLanguageTag.getLocale();
  99 }
 100
 101 void LocaleDataWrapper::loadData()
 102 {
 103     const css::lang::Locale& rMyLocale = maLanguageTag.getLocale();
 104
 105     {
 106         const Sequence< Currency2 > aCurrSeq = getAllCurrencies();
 107         if ( !aCurrSeq.hasElements() )
 108         {
 109             if (areChecksEnabled())
 110                 outputCheckMessage("LocaleDataWrapper::getCurrSymbolsImpl: no currency at all, using ShellsAndPebbles");
 111             aCurrSymbol = "ShellsAndPebbles";
 112             aCurrBankSymbol = aCurrSymbol;
 113             nCurrPositiveFormat = nCurrNegativeFormat = nCurrFormatDefault;
 114             nCurrDigits = 2;
 115         }
 116         else
 117         {
 118             auto pCurr = std::find_if(aCurrSeq.begin(), aCurrSeq.end(),
 119                 [](const Currency2& rCurr) { return rCurr.Default; });
 120             if ( pCurr == aCurrSeq.end() )
 121             {
 122                 if (areChecksEnabled())
 123                 {
 124                     outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::getCurrSymbolsImpl: no default currency" ) );
 125                 }
 126                 pCurr = aCurrSeq.begin();
 127             }
 128             aCurrSymbol = pCurr->Symbol;
 129             aCurrBankSymbol = pCurr->BankSymbol;
 130             nCurrDigits = pCurr->DecimalPlaces;
 131         }
 132     }
 133
 134     loadCurrencyFormats();
 135
 136     {
 137         xDefaultCalendar.reset();
 138         xSecondaryCalendar.reset();
 139         const Sequence< Calendar2 > xCals = getAllCalendars();
 140         if (xCals.getLength() > 1)
 141         {
 142             auto pCal = std::find_if(xCals.begin(), xCals.end(),
 143                 [](const Calendar2& rCal) { return !rCal.Default; });
 144             if (pCal != xCals.end())
 145                 xSecondaryCalendar = std::make_shared<Calendar2>( *pCal);
 146         }
 147         auto pCal = xCals.begin();
 148         if (xCals.getLength() > 1)
 149         {
 150             pCal = std::find_if(xCals.begin(), xCals.end(),
 151                 [](const Calendar2& rCal) { return rCal.Default; });
 152             if (pCal == xCals.end())
 153                 pCal = xCals.begin();
 154         }
 155         xDefaultCalendar = std::make_shared<Calendar2>( *pCal);
 156     }
 157
 158     loadDateOrders();
 159
 160     try
 161     {
 162         aDateAcceptancePatterns = xLD->getDateAcceptancePatterns( rMyLocale );
 163     }
 164     catch (const Exception&)
 165     {
 166         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getDateAcceptancePatterns" );
 167         aDateAcceptancePatterns = {};
 168     }
 169
 170
 171     loadDigitGrouping();
 172
 173     try
 174     {
 175         aReservedWords = comphelper::sequenceToContainer<std::vector<OUString>>(xLD->getReservedWord( rMyLocale ));
 176     }
 177     catch ( const Exception& )
 178     {
 179         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getReservedWord" );
 180     }
 181
 182     try
 183     {
 184         aLocaleDataItem = xLD->getLocaleItem2( rMyLocale );
 185     }
 186     catch (const Exception&)
 187     {
 188         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getLocaleItem" );
 189         static const css::i18n::LocaleDataItem2 aEmptyItem;
 190         aLocaleDataItem = aEmptyItem;
 191     }
 192
 193     aLocaleItem[LocaleItem::DATE_SEPARATOR] = aLocaleDataItem.dateSeparator;
 194     aLocaleItem[LocaleItem::THOUSAND_SEPARATOR] = aLocaleDataItem.thousandSeparator;
 195     aLocaleItem[LocaleItem::DECIMAL_SEPARATOR] = aLocaleDataItem.decimalSeparator;
 196     aLocaleItem[LocaleItem::TIME_SEPARATOR] = aLocaleDataItem.timeSeparator;
 197     aLocaleItem[LocaleItem::TIME_100SEC_SEPARATOR] = aLocaleDataItem.time100SecSeparator;
 198     aLocaleItem[LocaleItem::LIST_SEPARATOR] = aLocaleDataItem.listSeparator;
 199     aLocaleItem[LocaleItem::SINGLE_QUOTATION_START] = aLocaleDataItem.quotationStart;
 200     aLocaleItem[LocaleItem::SINGLE_QUOTATION_END] = aLocaleDataItem.quotationEnd;
 201     aLocaleItem[LocaleItem::DOUBLE_QUOTATION_START] = aLocaleDataItem.doubleQuotationStart;
 202     aLocaleItem[LocaleItem::DOUBLE_QUOTATION_END] = aLocaleDataItem.doubleQuotationEnd;
 203     aLocaleItem[LocaleItem::MEASUREMENT_SYSTEM] = aLocaleDataItem.measurementSystem;
 204     aLocaleItem[LocaleItem::TIME_AM] = aLocaleDataItem.timeAM;
 205     aLocaleItem[LocaleItem::TIME_PM] = aLocaleDataItem.timePM;
 206     aLocaleItem[LocaleItem::LONG_DATE_DAY_OF_WEEK_SEPARATOR] = aLocaleDataItem.LongDateDayOfWeekSeparator;
 207     aLocaleItem[LocaleItem::LONG_DATE_DAY_SEPARATOR] = aLocaleDataItem.LongDateDaySeparator;
 208     aLocaleItem[LocaleItem::LONG_DATE_MONTH_SEPARATOR] = aLocaleDataItem.LongDateMonthSeparator;
 209     aLocaleItem[LocaleItem::LONG_DATE_YEAR_SEPARATOR] = aLocaleDataItem.LongDateYearSeparator;
 210     aLocaleItem[LocaleItem::DECIMAL_SEPARATOR_ALTERNATIVE] = aLocaleDataItem.decimalSeparatorAlternative;
 211 }
 212
 213 /* FIXME-BCP47: locale data should provide a language tag instead that could be
 214  * passed on. */
 215 css::i18n::LanguageCountryInfo LocaleDataWrapper::getLanguageCountryInfo() const
 216 {
 217     try
 218     {
 219         return xLD->getLanguageCountryInfo( getMyLocale() );
 220     }
 221     catch (const Exception&)
 222     {
 223         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getLanguageCountryInfo" );
 224     }
 225     return css::i18n::LanguageCountryInfo();
 226 }
 227
 228 const css::i18n::LocaleDataItem2& LocaleDataWrapper::getLocaleItem() const
 229 {
 230     return aLocaleDataItem;
 231 }
 232
 233 css::uno::Sequence< css::i18n::Currency2 > LocaleDataWrapper::getAllCurrencies() const
 234 {
 235     try
 236     {
 237         return xLD->getAllCurrencies2( getMyLocale() );
 238     }
 239     catch (const Exception&)
 240     {
 241         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getAllCurrencies" );
 242     }
 243     return {};
 244 }
 245
 246 css::uno::Sequence< css::i18n::FormatElement > LocaleDataWrapper::getAllFormats() const
 247 {
 248     try
 249     {
 250         return xLD->getAllFormats( getMyLocale() );
 251     }
 252     catch (const Exception&)
 253     {
 254         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getAllFormats" );
 255     }
 256     return {};
 257 }
 258
 259 css::i18n::ForbiddenCharacters LocaleDataWrapper::getForbiddenCharacters() const
 260 {
 261     try
 262     {
 263         return xLD->getForbiddenCharacters( getMyLocale() );
 264     }
 265     catch (const Exception&)
 266     {
 267         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getForbiddenCharacters" );
 268     }
 269     return css::i18n::ForbiddenCharacters();
 270 }
 271
 272 const css::uno::Sequence< css::lang::Locale > & LocaleDataWrapper::getAllInstalledLocaleNames() const
 273 {
 274     uno::Sequence< lang::Locale > &rInstalledLocales = gInstalledLocales;
 275
 276     if ( rInstalledLocales.hasElements() )
 277         return rInstalledLocales;
 278
 279     try
 280     {
 281         rInstalledLocales = xLD->getAllInstalledLocaleNames();
 282     }
 283     catch ( const Exception& )
 284     {
 285         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getAllInstalledLocaleNames" );
 286     }
 287     return rInstalledLocales;
 288 }
 289
 290 // --- Impl and helpers ----------------------------------------------------
 291
 292 // static
 293 const css::uno::Sequence< css::lang::Locale >& LocaleDataWrapper::getInstalledLocaleNames()
 294 {
 295     const uno::Sequence< lang::Locale > &rInstalledLocales = gInstalledLocales;
 296
 297     if ( !rInstalledLocales.hasElements() )
 298     {
 299         LocaleDataWrapper aLDW( ::comphelper::getProcessComponentContext(), LanguageTag( LANGUAGE_SYSTEM) );
 300         aLDW.getAllInstalledLocaleNames();
 301     }
 302     return rInstalledLocales;
 303 }
 304
 305 // static
 306 const std::vector< LanguageType >& LocaleDataWrapper::getInstalledLanguageTypes()
 307 {
 308     std::vector< LanguageType > &rInstalledLanguageTypes = gInstalledLanguageTypes;
 309
 310     if ( !rInstalledLanguageTypes.empty() )
 311         return rInstalledLanguageTypes;
 312
 313     const css::uno::Sequence< css::lang::Locale > xLoc =  getInstalledLocaleNames();
 314     sal_Int32 nCount = xLoc.getLength();
 315     std::vector< LanguageType > xLang;
 316     xLang.reserve(nCount);
 317     for ( const auto& rLoc : xLoc )
 318     {
 319         LanguageTag aLanguageTag( rLoc );
 320         OUString aDebugLocale;
 321         if (areChecksEnabled())
 322         {
 323             aDebugLocale = aLanguageTag.getBcp47( false);
 324         }
 325
 326         LanguageType eLang = aLanguageTag.getLanguageType( false);
 327         if (areChecksEnabled() && eLang == LANGUAGE_DONTKNOW)
 328         {
 329             OUString aMsg = "ConvertIsoNamesToLanguage: unknown MS-LCID for locale\n" +
 330                 aDebugLocale;
 331             outputCheckMessage(aMsg);
 332         }
 333
 334         if ( eLang == LANGUAGE_NORWEGIAN)       // no_NO, not Bokmal (nb_NO), not Nynorsk (nn_NO)
 335             eLang = LANGUAGE_DONTKNOW;  // don't offer "Unknown" language
 336         if ( eLang != LANGUAGE_DONTKNOW )
 337         {
 338             LanguageTag aBackLanguageTag( eLang);
 339             if ( aLanguageTag != aBackLanguageTag )
 340             {
 341                 // In checks, exclude known problems because no MS-LCID defined
 342                 // and default for Language found.
 343                 if ( areChecksEnabled()
 344                         && aDebugLocale != "ar-SD"  // Sudan/ar
 345                         && aDebugLocale != "en-CB"  // Caribbean is not a country
 346 //                      && aDebugLocale != "en-BG"  // ?!? Bulgaria/en
 347 //                      && aDebugLocale != "es-BR"  // ?!? Brazil/es
 348                     )
 349                 {
 350                     outputCheckMessage(Concat2View(
 351                         "ConvertIsoNamesToLanguage/ConvertLanguageToIsoNames: ambiguous locale (MS-LCID?)\n"
 352                         + aDebugLocale
 353                         + "  ->  0x"
 354                         + OUString::number(static_cast<sal_Int32>(static_cast<sal_uInt16>(eLang)), 16)
 355                         + "  ->  "
 356                         + aBackLanguageTag.getBcp47() ));
 357                 }
 358                 eLang = LANGUAGE_DONTKNOW;
 359             }
 360         }
 361         if ( eLang != LANGUAGE_DONTKNOW )
 362             xLang.push_back(eLang);
 363     }
 364     rInstalledLanguageTypes = xLang;
 365
 366     return rInstalledLanguageTypes;
 367 }
 368
 369 const OUString& LocaleDataWrapper::getOneLocaleItem( sal_Int16 nItem ) const
 370 {
 371     if ( nItem >= LocaleItem::COUNT2 )
 372     {
 373         SAL_WARN( "unotools.i18n", "getOneLocaleItem: bounds" );
 374         return aLocaleItem[0];
 375     }
 376     return aLocaleItem[nItem];
 377 }
 378
 379 const OUString& LocaleDataWrapper::getOneReservedWord( sal_Int16 nWord ) const
 380 {
 381     if ( nWord < 0 || o3tl::make_unsigned(nWord) >= aReservedWords.size() )
 382     {
 383         SAL_WARN( "unotools.i18n", "getOneReservedWord: bounds" );
 384         static const OUString EMPTY;
 385         return EMPTY;
 386     }
 387     return aReservedWords[nWord];
 388 }
 389
 390 MeasurementSystem LocaleDataWrapper::mapMeasurementStringToEnum( std::u16string_view rMS ) const
 391 {
 392 //! TODO: could be cached too
 393     if ( o3tl::equalsIgnoreAsciiCase( rMS, u"metric" ) )
 394         return MeasurementSystem::Metric;
 395 //! TODO: other measurement systems? => extend enum MeasurementSystem
 396     return MeasurementSystem::US;
 397 }
 398
 399 bool LocaleDataWrapper::doesSecondaryCalendarUseEC( std::u16string_view rName ) const
 400 {
 401     if (rName.empty())
 402         return false;
 403
 404     // Check language tag first to avoid loading all calendars of this locale.
 405     LanguageTag aLoaded( getLoadedLanguageTag());
 406     const OUString& aBcp47( aLoaded.getBcp47());
 407     // So far determine only by locale, we know for a few.
 408     /* TODO: check date format codes? or add to locale data? */
 409     if (    aBcp47 != "ja-JP" &&
 410             aBcp47 != "lo-LA" &&
 411             aBcp47 != "zh-TW")
 412         return false;
 413
 414     if (!xSecondaryCalendar)
 415         return false;
 416     if (!xSecondaryCalendar->Name.equalsIgnoreAsciiCase( rName))
 417         return false;
 418
 419     return true;
 420 }
 421
 422 const std::shared_ptr< css::i18n::Calendar2 >& LocaleDataWrapper::getDefaultCalendar() const
 423 {
 424     return xDefaultCalendar;
 425 }
 426
 427 css::uno::Sequence< css::i18n::CalendarItem2 > const & LocaleDataWrapper::getDefaultCalendarDays() const
 428 {
 429     return getDefaultCalendar()->Days;
 430 }
 431
 432 css::uno::Sequence< css::i18n::CalendarItem2 > const & LocaleDataWrapper::getDefaultCalendarMonths() const
 433 {
 434     return getDefaultCalendar()->Months;
 435 }
 436
 437 // --- currencies -----------------------------------------------------
 438
 439 const OUString& LocaleDataWrapper::getCurrSymbol() const
 440 {
 441     return aCurrSymbol;
 442 }
 443
 444 const OUString& LocaleDataWrapper::getCurrBankSymbol() const
 445 {
 446     return aCurrBankSymbol;
 447 }
 448
 449 sal_uInt16 LocaleDataWrapper::getCurrPositiveFormat() const
 450 {
 451     return nCurrPositiveFormat;
 452 }
 453
 454 sal_uInt16 LocaleDataWrapper::getCurrNegativeFormat() const
 455 {
 456     return nCurrNegativeFormat;
 457 }
 458
 459 sal_uInt16 LocaleDataWrapper::getCurrDigits() const
 460 {
 461     return nCurrDigits;
 462 }
 463
 464 void LocaleDataWrapper::scanCurrFormatImpl( std::u16string_view rCode,
 465         sal_Int32 nStart, sal_Int32& nSign, sal_Int32& nPar,
 466         sal_Int32& nNum, sal_Int32& nBlank, sal_Int32& nSym ) const
 467 {
 468     nSign = nPar = nNum = nBlank = nSym = -1;
 469     const sal_Unicode* const pStr = rCode.data();
 470     const sal_Unicode* const pStop = pStr + rCode.size();
 471     const sal_Unicode* p = pStr + nStart;
 472     int nInSection = 0;
 473     bool bQuote = false;
 474     while ( p < pStop )
 475     {
 476         if ( bQuote )
 477         {
 478             if ( *p == '"' && *(p-1) != '\\' )
 479                 bQuote = false;
 480         }
 481         else
 482         {
 483             switch ( *p )
 484             {
 485                 case '"' :
 486                     if ( pStr == p || *(p-1) != '\\' )
 487                         bQuote = true;
 488                 break;
 489                 case '-' :
 490                     if (!nInSection && nSign == -1)
 491                         nSign = p - pStr;
 492                 break;
 493                 case '(' :
 494                     if (!nInSection && nPar == -1)
 495                         nPar = p - pStr;
 496                 break;
 497                 case '0' :
 498                 case '#' :
 499                     if (!nInSection && nNum == -1)
 500                         nNum = p - pStr;
 501                 break;
 502                 case '[' :
 503                     nInSection++;
 504                 break;
 505                 case ']' :
 506                     if ( nInSection )
 507                     {
 508                         nInSection--;
 509                         if (!nInSection && nBlank == -1
 510                           && nSym != -1 && p < pStop-1 && *(p+1) == ' ' )
 511                             nBlank = p - pStr + 1;
 512                     }
 513                 break;
 514                 case '$' :
 515                     if (nSym == -1 && nInSection && *(p-1) == '[')
 516                     {
 517                         nSym = p - pStr + 1;
 518                         if (nNum != -1 && *(p-2) == ' ')
 519                             nBlank = p - pStr - 2;
 520                     }
 521                 break;
 522                 case ';' :
 523                     if ( !nInSection )
 524                         p = pStop;
 525                 break;
 526                 default:
 527                     if (!nInSection && nSym == -1 && o3tl::starts_with(rCode.substr(static_cast<sal_Int32>(p - pStr)), aCurrSymbol))
 528                     {   // currency symbol not surrounded by [$...]
 529                         nSym = p - pStr;
 530                         if (nBlank == -1 && pStr < p && *(p-1) == ' ')
 531                             nBlank = p - pStr - 1;
 532                         p += aCurrSymbol.getLength() - 1;
 533                         if (nBlank == -1 && p < pStop-2 && *(p+2) == ' ')
 534                             nBlank = p - pStr + 2;
 535                     }
 536             }
 537         }
 538         p++;
 539     }
 540 }
 541
 542 void LocaleDataWrapper::loadCurrencyFormats()
 543 {
 544     css::uno::Reference< css::i18n::XNumberFormatCode > xNFC = i18n::NumberFormatMapper::create( m_xContext );
 545     uno::Sequence< NumberFormatCode > aFormatSeq = xNFC->getAllFormatCode( KNumberFormatUsage::CURRENCY, maLanguageTag.getLocale() );
 546     sal_Int32 nCnt = aFormatSeq.getLength();
 547     if ( !nCnt )
 548     {   // bad luck
 549         if (areChecksEnabled())
 550         {
 551             outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::getCurrFormatsImpl: no currency formats" ) );
 552         }
 553         nCurrPositiveFormat = nCurrNegativeFormat = nCurrFormatDefault;
 554         return;
 555     }
 556     // find a negative code (medium preferred) and a default (medium preferred) (not necessarily the same)
 557     NumberFormatCode const * const pFormatArr = aFormatSeq.getArray();
 558     sal_Int32 nElem, nDef, nNeg, nMedium;
 559     nDef = nNeg = nMedium = -1;
 560     for ( nElem = 0; nElem < nCnt; nElem++ )
 561     {
 562         if ( pFormatArr[nElem].Type == KNumberFormatType::MEDIUM )
 563         {
 564             if ( pFormatArr[nElem].Default )
 565             {
 566                 nDef = nElem;
 567                 nMedium = nElem;
 568                 if ( pFormatArr[nElem].Code.indexOf( ';' ) >= 0 )
 569                     nNeg = nElem;
 570             }
 571             else
 572             {
 573                 if ( (nNeg == -1 || nMedium == -1) && pFormatArr[nElem].Code.indexOf( ';' ) >= 0 )
 574                     nNeg = nElem;
 575                 if ( nMedium == -1 )
 576                     nMedium = nElem;
 577             }
 578         }
 579         else
 580         {
 581             if ( nDef == -1 && pFormatArr[nElem].Default )
 582                 nDef = nElem;
 583             if ( nNeg == -1 && pFormatArr[nElem].Code.indexOf( ';' ) >= 0 )
 584                 nNeg = nElem;
 585         }
 586     }
 587
 588     sal_Int32 nSign, nPar, nNum, nBlank, nSym;
 589
 590     // positive format
 591     nElem = (nDef >= 0 ? nDef : (nNeg >= 0 ? nNeg : 0));
 592     scanCurrFormatImpl( pFormatArr[nElem].Code, 0, nSign, nPar, nNum, nBlank, nSym );
 593     if (areChecksEnabled() && (nNum == -1 || nSym == -1))
 594     {
 595         outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::getCurrFormatsImpl: CurrPositiveFormat?" ) );
 596     }
 597     if (nBlank == -1)
 598     {
 599         if ( nSym < nNum )
 600             nCurrPositiveFormat = 0;    // $1
 601         else
 602             nCurrPositiveFormat = 1;    // 1$
 603     }
 604     else
 605     {
 606         if ( nSym < nNum )
 607             nCurrPositiveFormat = 2;    // $ 1
 608         else
 609             nCurrPositiveFormat = 3;    // 1 $
 610     }
 611
 612     // negative format
 613     if ( nNeg < 0 )
 614         nCurrNegativeFormat = nCurrFormatDefault;
 615     else
 616     {
 617         const OUString& rCode = pFormatArr[nNeg].Code;
 618         sal_Int32 nDelim = rCode.indexOf(';');
 619         scanCurrFormatImpl( rCode, nDelim+1, nSign, nPar, nNum, nBlank, nSym );
 620         if (areChecksEnabled() && (nNum == -1 || nSym == -1 || (nPar == -1 && nSign == -1)))
 621         {
 622             outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::getCurrFormatsImpl: CurrNegativeFormat?" ) );
 623         }
 624         // NOTE: one of nPar or nSign are allowed to be -1
 625         if (nBlank == -1)
 626         {
 627             if ( nSym < nNum )
 628             {
 629                 if ( -1 < nPar && nPar < nSym )
 630                     nCurrNegativeFormat = 0;    // ($1)
 631                 else if ( -1 < nSign && nSign < nSym )
 632                     nCurrNegativeFormat = 1;    // -$1
 633                 else if ( nNum < nSign )
 634                     nCurrNegativeFormat = 3;    // $1-
 635                 else
 636                     nCurrNegativeFormat = 2;    // $-1
 637             }
 638             else
 639             {
 640                 if ( -1 < nPar && nPar < nNum )
 641                     nCurrNegativeFormat = 4;    // (1$)
 642                 else if ( -1 < nSign && nSign < nNum )
 643                     nCurrNegativeFormat = 5;    // -1$
 644                 else if ( nSym < nSign )
 645                     nCurrNegativeFormat = 7;    // 1$-
 646                 else
 647                     nCurrNegativeFormat = 6;    // 1-$
 648             }
 649         }
 650         else
 651         {
 652             if ( nSym < nNum )
 653             {
 654                 if ( -1 < nPar && nPar < nSym )
 655                     nCurrNegativeFormat = 14;   // ($ 1)
 656                 else if ( -1 < nSign && nSign < nSym )
 657                     nCurrNegativeFormat = 9;    // -$ 1
 658                 else if ( nNum < nSign )
 659                     nCurrNegativeFormat = 12;   // $ 1-
 660                 else
 661                     nCurrNegativeFormat = 11;   // $ -1
 662             }
 663             else
 664             {
 665                 if ( -1 < nPar && nPar < nNum )
 666                     nCurrNegativeFormat = 15;   // (1 $)
 667                 else if ( -1 < nSign && nSign < nNum )
 668                     nCurrNegativeFormat = 8;    // -1 $
 669                 else if ( nSym < nSign )
 670                     nCurrNegativeFormat = 10;   // 1 $-
 671                 else
 672                     nCurrNegativeFormat = 13;   // 1- $
 673             }
 674         }
 675     }
 676 }
 677
 678 // --- date -----------------------------------------------------------
 679
 680 DateOrder LocaleDataWrapper::getDateOrder() const
 681 {
 682     return nDateOrder;
 683 }
 684
 685 LongDateOrder LocaleDataWrapper::getLongDateOrder() const
 686 {
 687     return nLongDateOrder;
 688 }
 689
 690 LongDateOrder LocaleDataWrapper::scanDateOrderImpl( std::u16string_view rCode ) const
 691 {
 692     // Only some european versions were translated, the ones with different
 693     // keyword combinations are:
 694     // English DMY, German TMJ, Spanish DMA, French JMA, Italian GMA,
 695     // Dutch DMJ, Finnish PKV
 696
 697     // default is English keywords for every other language
 698     size_t nDay = rCode.find('D');
 699     size_t nMonth = rCode.find('M');
 700     size_t nYear = rCode.find('Y');
 701     if (nDay == std::u16string_view::npos || nMonth == std::u16string_view::npos || nYear == std::u16string_view::npos)
 702     {   // This algorithm assumes that all three parts (DMY) are present
 703         if (nMonth == std::u16string_view::npos)
 704         {   // only Finnish has something else than 'M' for month
 705             nMonth = rCode.find('K');
 706             if (nMonth != std::u16string_view::npos)
 707             {
 708                 nDay = rCode.find('P');
 709                 nYear = rCode.find('V');
 710             }
 711         }
 712         else if (nDay == std::u16string_view::npos)
 713         {   // We have a month 'M' if we reach this branch.
 714             // Possible languages containing 'M' but no 'D':
 715             // German, French, Italian
 716             nDay = rCode.find('T');         // German
 717             if (nDay != std::u16string_view::npos)
 718                 nYear = rCode.find('J');
 719             else
 720             {
 721                 nYear = rCode.find('A');    // French, Italian
 722                 if (nYear != std::u16string_view::npos)
 723                 {
 724                     nDay = rCode.find('J'); // French
 725                     if (nDay == std::u16string_view::npos)
 726                         nDay = rCode.find('G'); // Italian
 727                 }
 728             }
 729         }
 730         else
 731         {   // We have a month 'M' and a day 'D'.
 732             // Possible languages containing 'D' and 'M' but not 'Y':
 733             // Spanish, Dutch
 734             nYear = rCode.find('A');        // Spanish
 735             if (nYear == std::u16string_view::npos)
 736                 nYear = rCode.find('J');    // Dutch
 737         }
 738         if (nDay == std::u16string_view::npos || nMonth == std::u16string_view::npos || nYear == std::u16string_view::npos)
 739         {
 740             if (areChecksEnabled())
 741             {
 742                 outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::scanDateOrder: not all DMY present" ) );
 743             }
 744             if (nDay == std::u16string_view::npos)
 745                 nDay = rCode.size();
 746             if (nMonth == std::u16string_view::npos)
 747                 nMonth = rCode.size();
 748             if (nYear == std::u16string_view::npos)
 749                 nYear = rCode.size();
 750         }
 751     }
 752     // compare with <= because each position may equal rCode.getLength()
 753     if ( nDay <= nMonth && nMonth <= nYear )
 754         return LongDateOrder::DMY;     // also if every position equals rCode.getLength()
 755     else if ( nMonth <= nDay && nDay <= nYear )
 756         return LongDateOrder::MDY;
 757     else if ( nYear <= nMonth && nMonth <= nDay )
 758         return LongDateOrder::YMD;
 759     else if ( nYear <= nDay && nDay <= nMonth )
 760         return LongDateOrder::YDM;
 761     else
 762     {
 763         if (areChecksEnabled())
 764         {
 765             outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::scanDateOrder: no magic applicable" ) );
 766         }
 767         return LongDateOrder::DMY;
 768     }
 769 }
 770
 771 static DateOrder getDateOrderFromLongDateOrder( LongDateOrder eLong )
 772 {
 773     switch (eLong)
 774     {
 775         case LongDateOrder::YMD:
 776             return DateOrder::YMD;
 777         break;
 778         case LongDateOrder::DMY:
 779             return DateOrder::DMY;
 780         break;
 781         case LongDateOrder::MDY:
 782             return DateOrder::MDY;
 783         break;
 784         case LongDateOrder::YDM:
 785         default:
 786             assert(!"unhandled LongDateOrder to DateOrder");
 787             return DateOrder::DMY;
 788     }
 789 }
 790
 791 void LocaleDataWrapper::loadDateOrders()
 792 {
 793     css::uno::Reference< css::i18n::XNumberFormatCode > xNFC = i18n::NumberFormatMapper::create( m_xContext );
 794     uno::Sequence< NumberFormatCode > aFormatSeq = xNFC->getAllFormatCode( KNumberFormatUsage::DATE, maLanguageTag.getLocale() );
 795     sal_Int32 nCnt = aFormatSeq.getLength();
 796     if ( !nCnt )
 797     {   // bad luck
 798         if (areChecksEnabled())
 799         {
 800             outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::getDateOrdersImpl: no date formats" ) );
 801         }
 802         nDateOrder = DateOrder::DMY;
 803         nLongDateOrder = LongDateOrder::DMY;
 804         return;
 805     }
 806     // find the edit (21), a default (medium preferred),
 807     // a medium (default preferred), and a long (default preferred)
 808     NumberFormatCode const * const pFormatArr = aFormatSeq.getArray();
 809     sal_Int32 nEdit, nDef, nMedium, nLong;
 810     nEdit = nDef = nMedium = nLong = -1;
 811     for ( sal_Int32 nElem = 0; nElem < nCnt; nElem++ )
 812     {
 813         if ( nEdit == -1 && pFormatArr[nElem].Index == NumberFormatIndex::DATE_SYS_DDMMYYYY )
 814             nEdit = nElem;
 815         if ( nDef == -1 && pFormatArr[nElem].Default )
 816             nDef = nElem;
 817         switch ( pFormatArr[nElem].Type )
 818         {
 819             case KNumberFormatType::MEDIUM :
 820             {
 821                 if ( pFormatArr[nElem].Default )
 822                 {
 823                     nDef = nElem;
 824                     nMedium = nElem;
 825                 }
 826                 else if ( nMedium == -1 )
 827                     nMedium = nElem;
 828             }
 829             break;
 830             case KNumberFormatType::LONG :
 831             {
 832                 if ( pFormatArr[nElem].Default )
 833                     nLong = nElem;
 834                 else if ( nLong == -1 )
 835                     nLong = nElem;
 836             }
 837             break;
 838         }
 839     }
 840     if ( nEdit == -1 )
 841     {
 842         if (areChecksEnabled())
 843         {
 844             outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::getDateOrdersImpl: no edit" ) );
 845         }
 846         if ( nDef == -1 )
 847         {
 848             if (areChecksEnabled())
 849             {
 850                 outputCheckMessage( appendLocaleInfo( u"LocaleDataWrapper::getDateOrdersImpl: no default" ) );
 851             }
 852             if ( nMedium != -1 )
 853                 nDef = nMedium;
 854             else if ( nLong != -1 )
 855                 nDef = nLong;
 856             else
 857                 nDef = 0;
 858         }
 859         nEdit = nDef;
 860     }
 861     LongDateOrder nDO = scanDateOrderImpl( pFormatArr[nEdit].Code );
 862     if ( pFormatArr[nEdit].Type == KNumberFormatType::LONG )
 863     {   // normally this is not the case
 864         nLongDateOrder = nDO;
 865         nDateOrder = getDateOrderFromLongDateOrder(nDO);
 866     }
 867     else
 868     {
 869         // YDM should not occur in a short/medium date (i.e. no locale has
 870         // that) and is nowhere handled.
 871         nDateOrder = getDateOrderFromLongDateOrder(nDO);
 872         if ( nLong == -1 )
 873             nLongDateOrder = nDO;
 874         else
 875             nLongDateOrder = scanDateOrderImpl( pFormatArr[nLong].Code );
 876     }
 877 }
 878
 879 // --- digit grouping -------------------------------------------------
 880
 881 void LocaleDataWrapper::loadDigitGrouping()
 882 {
 883     /* TODO: This is a very simplified grouping setup that only serves its
 884      * current purpose for Indian locales. A free-form flexible one would
 885      * obtain grouping from locale data where it could be specified using, for
 886      * example, codes like #,### and #,##,### that would generate the integer
 887      * sequence. Needed additional API and a locale data element.
 888      */
 889
 890     if (aGrouping.hasElements() && aGrouping[0])
 891         return;
 892
 893     i18n::LanguageCountryInfo aLCInfo( getLanguageCountryInfo());
 894     if (aLCInfo.Country.equalsIgnoreAsciiCase("IN") || // India
 895         aLCInfo.Country.equalsIgnoreAsciiCase("BT") )  // Bhutan
 896     {
 897         aGrouping = { 3, 2, 0 };
 898     }
 899     else
 900     {
 901         aGrouping = { 3, 0, 0 };
 902     }
 903 }
 904
 905 const css::uno::Sequence< sal_Int32 >& LocaleDataWrapper::getDigitGrouping() const
 906 {
 907     return aGrouping;
 908 }
 909
 910 // --- simple number formatting helpers -------------------------------
 911
 912 // The ImplAdd... methods are taken from class International and modified to
 913 // suit the needs.
 914
 915 static void ImplAddUNum( OUStringBuffer& rBuf, sal_uInt64 nNumber )
 916 {
 917     // fill temp buffer with digits
 918     sal_Unicode aTempBuf[64];
 919     sal_Unicode* pTempBuf = aTempBuf;
 920     do
 921     {
 922         *pTempBuf = static_cast<sal_Unicode>(nNumber % 10) + '0';
 923         pTempBuf++;
 924         nNumber /= 10;
 925     }
 926     while ( nNumber );
 927
 928     // copy temp buffer to buffer passed
 929     do
 930     {
 931         pTempBuf--;
 932         rBuf.append(*pTempBuf);
 933     }
 934     while ( pTempBuf != aTempBuf );
 935 }
 936
 937 static void ImplAddUNum( OUStringBuffer& rBuf, sal_uInt64 nNumber, int nMinLen )
 938 {
 939     // fill temp buffer with digits
 940     sal_Unicode aTempBuf[64];
 941     sal_Unicode* pTempBuf = aTempBuf;
 942     do
 943     {
 944         *pTempBuf = static_cast<sal_Unicode>(nNumber % 10) + '0';
 945         pTempBuf++;
 946         nNumber /= 10;
 947         nMinLen--;
 948     }
 949     while ( nNumber );
 950
 951     // fill with zeros up to the minimal length
 952     while ( nMinLen > 0 )
 953     {
 954         rBuf.append('0');
 955         nMinLen--;
 956     }
 957
 958     // copy temp buffer to real buffer
 959     do
 960     {
 961         pTempBuf--;
 962         rBuf.append(*pTempBuf);
 963     }
 964     while ( pTempBuf != aTempBuf );
 965 }
 966
 967 static void ImplAddNum( OUStringBuffer& rBuf, sal_Int64 nNumber, int nMinLen )
 968 {
 969     if (nNumber < 0)
 970     {
 971         rBuf.append('-');
 972         nNumber = -nNumber;
 973     }
 974     return ImplAddUNum( rBuf, nNumber, nMinLen);
 975 }
 976
 977 static void ImplAdd2UNum( OUStringBuffer& rBuf, sal_uInt16 nNumber )
 978 {
 979     DBG_ASSERT( nNumber < 100, "ImplAdd2UNum() - Number >= 100" );
 980
 981     if ( nNumber < 10 )
 982     {
 983         rBuf.append('0');
 984         rBuf.append(static_cast<char>(nNumber + '0'));
 985     }
 986     else
 987     {
 988         sal_uInt16 nTemp = nNumber % 10;
 989         nNumber /= 10;
 990         rBuf.append(static_cast<char>(nNumber + '0'));
 991         rBuf.append(static_cast<char>(nTemp + '0'));
 992     }
 993 }
 994
 995 static void ImplAdd9UNum( OUStringBuffer& rBuf, sal_uInt32 nNumber )
 996 {
 997     DBG_ASSERT( nNumber < 1000000000, "ImplAdd9UNum() - Number >= 1000000000" );
 998
 999     std::ostringstream ostr;
1000     ostr.fill('0');
1001     ostr.width(9);
1002     ostr << nNumber;
1003     std::string aStr = ostr.str();
1004     rBuf.appendAscii(aStr.c_str(), aStr.size());
1005 }
1006
1007 void LocaleDataWrapper::ImplAddFormatNum( OUStringBuffer& rBuf,
1008         sal_Int64 nNumber, sal_uInt16 nDecimals, bool bUseThousandSep,
1009         bool bTrailingZeros ) const
1010 {
1011     OUStringBuffer aNumBuf(64);
1012     sal_uInt16  nNumLen;
1013
1014     // negative number
1015     sal_uInt64 abs;
1016     if ( nNumber < 0 )
1017     {
1018         // Avoid overflow, map -2^63 -> 2^63 explicitly:
1019         abs = nNumber == std::numeric_limits<sal_Int64>::min()
1020             ? static_cast<sal_uInt64>(std::numeric_limits<sal_Int64>::min()) : nNumber * -1;
1021         rBuf.append('-');
1022     }
1023     else
1024     {
1025         abs = nNumber;
1026     }
1027
1028     // convert number
1029     ImplAddUNum( aNumBuf, abs );
1030     nNumLen = static_cast<sal_uInt16>(aNumBuf.getLength());
1031
1032     if ( nNumLen <= nDecimals )
1033     {
1034         // strip .0 in decimals?
1035         if ( !nNumber && !bTrailingZeros )
1036         {
1037             rBuf.append('0');
1038         }
1039         else
1040         {
1041             // LeadingZero, insert 0
1042             if ( isNumLeadingZero() )
1043             {
1044                 rBuf.append('0');
1045             }
1046
1047             // append decimal separator
1048             rBuf.append( aLocaleDataItem.decimalSeparator );
1049
1050             // fill with zeros
1051             sal_uInt16 i = 0;
1052             while ( i < (nDecimals-nNumLen) )
1053             {
1054                 rBuf.append('0');
1055                 i++;
1056             }
1057
1058             // append decimals
1059             rBuf.append(aNumBuf);
1060         }
1061     }
1062     else
1063     {
1064         const OUString& rThoSep = aLocaleDataItem.thousandSeparator;
1065
1066         // copy number to buffer (excluding decimals)
1067         sal_uInt16 nNumLen2 = nNumLen-nDecimals;
1068         uno::Sequence< sal_Bool > aGroupPos;
1069         if (bUseThousandSep)
1070             aGroupPos = utl::DigitGroupingIterator::createForwardSequence(
1071                     nNumLen2, getDigitGrouping());
1072         sal_uInt16 i = 0;
1073         for (; i < nNumLen2; ++i )
1074         {
1075             rBuf.append(aNumBuf[i]);
1076
1077             // add thousand separator?
1078             if ( bUseThousandSep && aGroupPos[i] )
1079                 rBuf.append( rThoSep );
1080         }
1081
1082         // append decimals
1083         if ( nDecimals )
1084         {
1085             rBuf.append( aLocaleDataItem.decimalSeparator );
1086
1087             bool bNullEnd = true;
1088             while ( i < nNumLen )
1089             {
1090                 if ( aNumBuf[i] != '0' )
1091                     bNullEnd = false;
1092
1093                 rBuf.append(aNumBuf[i]);
1094                 i++;
1095             }
1096
1097             // strip .0 in decimals?
1098             if ( bNullEnd && !bTrailingZeros )
1099                 rBuf.setLength( rBuf.getLength() - (nDecimals + 1) );
1100         }
1101     }
1102 }
1103
1104 // --- simple date and time formatting --------------------------------
1105
1106 OUString LocaleDataWrapper::getDate( const Date& rDate ) const
1107 {
1108 //!TODO: leading zeros et al
1109     OUStringBuffer aBuf(128);
1110     sal_uInt16  nDay    = rDate.GetDay();
1111     sal_uInt16  nMonth  = rDate.GetMonth();
1112     sal_Int16   nYear   = rDate.GetYear();
1113     sal_uInt16  nYearLen;
1114
1115     if ( (true) /* IsDateCentury() */ )
1116         nYearLen = 4;
1117     else
1118     {
1119         nYearLen = 2;
1120         nYear %= 100;
1121     }
1122
1123     switch ( getDateOrder() )
1124     {
1125         case DateOrder::DMY :
1126             ImplAdd2UNum( aBuf, nDay );
1127             aBuf.append( aLocaleDataItem.dateSeparator );
1128             ImplAdd2UNum( aBuf, nMonth );
1129             aBuf.append( aLocaleDataItem.dateSeparator );
1130             ImplAddNum( aBuf, nYear, nYearLen );
1131         break;
1132         case DateOrder::MDY :
1133             ImplAdd2UNum( aBuf, nMonth );
1134             aBuf.append( aLocaleDataItem.dateSeparator );
1135             ImplAdd2UNum( aBuf, nDay );
1136             aBuf.append( aLocaleDataItem.dateSeparator );
1137             ImplAddNum( aBuf, nYear, nYearLen );
1138         break;
1139         default:
1140             ImplAddNum( aBuf, nYear, nYearLen );
1141             aBuf.append( aLocaleDataItem.dateSeparator );
1142             ImplAdd2UNum( aBuf, nMonth );
1143             aBuf.append( aLocaleDataItem.dateSeparator );
1144             ImplAdd2UNum( aBuf, nDay );
1145     }
1146
1147     return aBuf.makeStringAndClear();
1148 }
1149
1150 OUString LocaleDataWrapper::getTime( const tools::Time& rTime, bool bSec, bool b100Sec ) const
1151 {
1152 //!TODO: leading zeros et al
1153     OUStringBuffer aBuf(128);
1154     sal_uInt16  nHour = rTime.GetHour();
1155
1156     nHour %= 24;
1157
1158     ImplAdd2UNum( aBuf, nHour );
1159     aBuf.append( aLocaleDataItem.timeSeparator );
1160     ImplAdd2UNum( aBuf, rTime.GetMin() );
1161     if ( bSec )
1162     {
1163         aBuf.append( aLocaleDataItem.timeSeparator );
1164         ImplAdd2UNum( aBuf, rTime.GetSec() );
1165
1166         if ( b100Sec )
1167         {
1168             aBuf.append( aLocaleDataItem.time100SecSeparator );
1169             ImplAdd9UNum( aBuf, rTime.GetNanoSec() );
1170         }
1171     }
1172
1173     return aBuf.makeStringAndClear();
1174 }
1175
1176 OUString LocaleDataWrapper::getDuration( const tools::Time& rTime, bool bSec, bool b100Sec ) const
1177 {
1178     OUStringBuffer aBuf(128);
1179
1180     if ( rTime < tools::Time( 0 ) )
1181         aBuf.append(' ' );
1182
1183     if ( (true) /* IsTimeLeadingZero() */ )
1184         ImplAddUNum( aBuf, rTime.GetHour(), 2 );
1185     else
1186         ImplAddUNum( aBuf, rTime.GetHour() );
1187     aBuf.append( aLocaleDataItem.timeSeparator );
1188     ImplAdd2UNum( aBuf, rTime.GetMin() );
1189     if ( bSec )
1190     {
1191         aBuf.append( aLocaleDataItem.timeSeparator );
1192         ImplAdd2UNum( aBuf, rTime.GetSec() );
1193
1194         if ( b100Sec )
1195         {
1196             aBuf.append( aLocaleDataItem.time100SecSeparator );
1197             ImplAdd9UNum( aBuf, rTime.GetNanoSec() );
1198         }
1199     }
1200
1201     return aBuf.makeStringAndClear();
1202 }
1203
1204 // --- simple number formatting ---------------------------------------
1205
1206 static size_t ImplGetNumberStringLengthGuess( const css::i18n::LocaleDataItem2& rLocaleDataItem, sal_uInt16 nDecimals )
1207 {
1208     // approximately 3.2 bits per digit
1209     const size_t nDig = ((sizeof(sal_Int64) * 8) / 3) + 1;
1210     // digits, separators (pessimized for insane "every digit may be grouped"), leading zero, sign
1211     size_t nGuess = ((nDecimals < nDig) ?
1212         (((nDig - nDecimals) * rLocaleDataItem.thousandSeparator.getLength()) + nDig) :
1213         nDecimals) + rLocaleDataItem.decimalSeparator.getLength() + 3;
1214     return nGuess;
1215 }
1216
1217 OUString LocaleDataWrapper::getNum( sal_Int64 nNumber, sal_uInt16 nDecimals,
1218         bool bUseThousandSep, bool bTrailingZeros ) const
1219 {
1220     // check if digits and separators will fit into fixed buffer or allocate
1221     size_t nGuess = ImplGetNumberStringLengthGuess( aLocaleDataItem, nDecimals );
1222     OUStringBuffer aBuf(int(nGuess + 16));
1223
1224     ImplAddFormatNum( aBuf, nNumber, nDecimals,
1225         bUseThousandSep, bTrailingZeros );
1226
1227     return aBuf.makeStringAndClear();
1228 }
1229
1230 OUString LocaleDataWrapper::getCurr( sal_Int64 nNumber, sal_uInt16 nDecimals,
1231         std::u16string_view rCurrencySymbol, bool bUseThousandSep ) const
1232 {
1233     sal_Unicode cZeroChar = getCurrZeroChar();
1234
1235     // check if digits and separators will fit into fixed buffer or allocate
1236     size_t nGuess = ImplGetNumberStringLengthGuess( aLocaleDataItem, nDecimals );
1237     OUStringBuffer aNumBuf(sal_Int32(nGuess + 16));
1238
1239     bool bNeg;
1240     if ( nNumber < 0 )
1241     {
1242         bNeg = true;
1243         nNumber *= -1;
1244     }
1245     else
1246         bNeg = false;
1247
1248     // convert number
1249     ImplAddFormatNum( aNumBuf, nNumber, nDecimals,
1250         bUseThousandSep, true );
1251     const sal_Int32 nNumLen = aNumBuf.getLength();
1252
1253     // replace zeros with zero character
1254     if ( (cZeroChar != '0') && nDecimals /* && IsNumTrailingZeros() */ )
1255     {
1256         sal_uInt16  i;
1257         bool    bZero = true;
1258
1259         sal_uInt16 nNumBufIndex = nNumLen-nDecimals;
1260         i = 0;
1261         do
1262         {
1263             if ( aNumBuf[nNumBufIndex] != '0' )
1264             {
1265                 bZero = false;
1266                 break;
1267             }
1268
1269             nNumBufIndex++;
1270             i++;
1271         }
1272         while ( i < nDecimals );
1273
1274         if ( bZero )
1275         {
1276             nNumBufIndex = nNumLen-nDecimals;
1277             i = 0;
1278             do
1279             {
1280                 aNumBuf[nNumBufIndex] = cZeroChar;
1281                 nNumBufIndex++;
1282                 i++;
1283             }
1284             while ( i < nDecimals );
1285         }
1286     }
1287
1288     OUString aCur;
1289     if ( !bNeg )
1290     {
1291         switch( getCurrPositiveFormat() )
1292         {
1293             case 0:
1294                 aCur = rCurrencySymbol + aNumBuf;
1295                 break;
1296             case 1:
1297                 aCur = aNumBuf + rCurrencySymbol;
1298                 break;
1299             case 2:
1300                 aCur = OUString::Concat(rCurrencySymbol) + " " + aNumBuf;
1301                 break;
1302             case 3:
1303                 aCur = aNumBuf + " " + rCurrencySymbol;
1304                 break;
1305         }
1306     }
1307     else
1308     {
1309         switch( getCurrNegativeFormat() )
1310         {
1311             case 0:
1312                  aCur = OUString::Concat("(") + rCurrencySymbol + aNumBuf + ")";
1313                 break;
1314             case 1:
1315                  aCur = OUString::Concat("-") + rCurrencySymbol + aNumBuf;
1316                 break;
1317             case 2:
1318                  aCur = OUString::Concat(rCurrencySymbol) + "-" + aNumBuf;
1319                 break;
1320             case 3:
1321                  aCur = rCurrencySymbol + aNumBuf + "-";
1322                 break;
1323             case 4:
1324                  aCur = "(" + aNumBuf + rCurrencySymbol + ")";
1325                 break;
1326             case 5:
1327                  aCur = "-" + aNumBuf + rCurrencySymbol;
1328                 break;
1329             case 6:
1330                  aCur = aNumBuf + "-" + rCurrencySymbol;
1331                 break;
1332             case 7:
1333                  aCur = aNumBuf + rCurrencySymbol + "-";
1334                 break;
1335             case 8:
1336                  aCur = "-" + aNumBuf + " " + rCurrencySymbol;
1337                 break;
1338             case 9:
1339                  aCur = OUString::Concat("-") + rCurrencySymbol + " " + aNumBuf;
1340                 break;
1341             case 10:
1342                  aCur = aNumBuf + " " + rCurrencySymbol + "-";
1343                 break;
1344             case 11:
1345                  aCur = OUString::Concat(rCurrencySymbol) + " -" + aNumBuf;
1346                 break;
1347             case 12:
1348                  aCur = OUString::Concat(rCurrencySymbol) + " " + aNumBuf + "-";
1349                 break;
1350             case 13:
1351                  aCur = aNumBuf + "- " + rCurrencySymbol;
1352                 break;
1353             case 14:
1354                  aCur = OUString::Concat("(") + rCurrencySymbol + " " + aNumBuf + ")";
1355                 break;
1356             case 15:
1357                  aCur = "(" + aNumBuf + " " + rCurrencySymbol + ")";
1358                 break;
1359         }
1360     }
1361
1362     return aCur;
1363 }
1364
1365 // --- number parsing -------------------------------------------------
1366
1367 double LocaleDataWrapper::stringToDouble( std::u16string_view aString, bool bUseGroupSep,
1368         rtl_math_ConversionStatus* pStatus, sal_Int32* pParseEnd ) const
1369 {
1370     const sal_Unicode* pParseEndChar;
1371     double fValue = stringToDouble(aString.data(), aString.data() + aString.size(), bUseGroupSep, pStatus, &pParseEndChar);
1372     if (pParseEnd)
1373         *pParseEnd = pParseEndChar - aString.data();
1374     return fValue;
1375 }
1376
1377 double LocaleDataWrapper::stringToDouble( const sal_Unicode* pBegin, const sal_Unicode* pEnd, bool bUseGroupSep,
1378         rtl_math_ConversionStatus* pStatus, const sal_Unicode** ppParseEnd ) const
1379 {
1380     const sal_Unicode cGroupSep = (bUseGroupSep ? aLocaleDataItem.thousandSeparator[0] : 0);
1381     rtl_math_ConversionStatus eStatus = rtl_math_ConversionStatus_Ok;
1382     const sal_Unicode* pParseEnd = nullptr;
1383     double fValue = rtl_math_uStringToDouble( pBegin, pEnd, aLocaleDataItem.decimalSeparator[0], cGroupSep, &eStatus, &pParseEnd);
1384     bool bTryAlt = (pParseEnd < pEnd && !aLocaleDataItem.decimalSeparatorAlternative.isEmpty() &&
1385             *pParseEnd == aLocaleDataItem.decimalSeparatorAlternative.toChar());
1386     // Try re-parsing with alternative if that was the reason to stop.
1387     if (bTryAlt)
1388         fValue = rtl_math_uStringToDouble( pBegin, pEnd, aLocaleDataItem.decimalSeparatorAlternative.toChar(), cGroupSep, &eStatus, &pParseEnd);
1389     if (pStatus)
1390         *pStatus = eStatus;
1391     if (ppParseEnd)
1392         *ppParseEnd = pParseEnd;
1393     return fValue;
1394 }
1395
1396 // --- mixed ----------------------------------------------------------
1397
1398 LanguageTag LocaleDataWrapper::getLoadedLanguageTag() const
1399 {
1400     LanguageCountryInfo aLCInfo = getLanguageCountryInfo();
1401     return LanguageTag( lang::Locale( aLCInfo.Language, aLCInfo.Country, aLCInfo.Variant ));
1402 }
1403
1404 OUString LocaleDataWrapper::appendLocaleInfo(std::u16string_view rDebugMsg) const
1405 {
1406     LanguageTag aLoaded = getLoadedLanguageTag();
1407     return OUString::Concat(rDebugMsg) + "\n" + maLanguageTag.getBcp47() + " requested\n"
1408         + aLoaded.getBcp47() + " loaded";
1409 }
1410
1411 // static
1412 void LocaleDataWrapper::outputCheckMessage( std::u16string_view rMsg )
1413 {
1414     outputCheckMessage(OUStringToOString(rMsg, RTL_TEXTENCODING_UTF8).getStr());
1415 }
1416
1417 // static
1418 void LocaleDataWrapper::outputCheckMessage( const char* pStr )
1419 {
1420     fprintf( stderr, "\n%s\n", pStr);
1421     fflush( stderr);
1422     SAL_WARN("unotools.i18n", pStr);
1423 }
1424
1425 // static
1426 void LocaleDataWrapper::evaluateLocaleDataChecking()
1427 {
1428     // Using the rtl_Instance template here wouldn't solve all threaded write
1429     // accesses, since we want to assign the result to the static member
1430     // variable and would need to dereference the pointer returned and assign
1431     // the value unguarded. This is the same pattern manually coded.
1432     sal_uInt8 nCheck = nLocaleDataChecking;
1433     if (!nCheck)
1434     {
1435         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex());
1436         nCheck = nLocaleDataChecking;
1437         if (!nCheck)
1438         {
1439 #ifdef DBG_UTIL
1440             nCheck = 1;
1441 #else
1442             const char* pEnv = getenv( "OOO_ENABLE_LOCALE_DATA_CHECKS");
1443             if (pEnv && (pEnv[0] == 'Y' || pEnv[0] == 'y' || pEnv[0] == '1'))
1444                 nCheck = 1;
1445             else
1446                 nCheck = 2;
1447 #endif
1448             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
1449             nLocaleDataChecking = nCheck;
1450         }
1451     }
1452     else {
1453         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
1454     }
1455 }
1456
1457 // --- XLocaleData3 ----------------------------------------------------------
1458
1459 css::uno::Sequence< css::i18n::Calendar2 > LocaleDataWrapper::getAllCalendars() const
1460 {
1461     try
1462     {
1463         return xLD->getAllCalendars2( getMyLocale() );
1464     }
1465     catch (const Exception&)
1466     {
1467         TOOLS_WARN_EXCEPTION( "unotools.i18n", "getAllCalendars" );
1468     }
1469     return {};
1470 }
1471
1472 // --- XLocaleData4 ----------------------------------------------------------
1473
1474 const css::uno::Sequence< OUString > & LocaleDataWrapper::getDateAcceptancePatterns() const
1475 {
1476     return aDateAcceptancePatterns;
1477 }
1478
1479 // --- Override layer --------------------------------------------------------
1480
1481 void LocaleDataWrapper::loadDateAcceptancePatterns(
1482         const std::vector<OUString> & rPatterns )
1483 {
1484     if (!aDateAcceptancePatterns.hasElements() || rPatterns.empty())
1485     {
1486         try
1487         {
1488             aDateAcceptancePatterns = xLD->getDateAcceptancePatterns( maLanguageTag.getLocale() );
1489         }
1490         catch (const Exception&)
1491         {
1492             TOOLS_WARN_EXCEPTION( "unotools.i18n", "setDateAcceptancePatterns" );
1493         }
1494         if (rPatterns.empty())
1495             return;     // just a reset
1496         if (!aDateAcceptancePatterns.hasElements())
1497         {
1498             aDateAcceptancePatterns = comphelper::containerToSequence(rPatterns);
1499             return;
1500         }
1501     }
1502
1503     // Earlier versions checked for presence of the full date pattern with
1504     // aDateAcceptancePatterns[0] == rPatterns[0] and prepended that if not.
1505     // This lead to confusion if the patterns were intentionally specified
1506     // without, giving entirely a different DMY order, see tdf#150288.
1507     // Not checking this and accepting the given patterns as is may result in
1508     // the user shooting themself in the foot, but we can't have both.
1509     aDateAcceptancePatterns = comphelper::containerToSequence(rPatterns);
1510 }
1511
1512 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */